VirtualBox

Changeset 43171 in vbox


Ignore:
Timestamp:
Sep 4, 2012 5:07:27 PM (13 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
80557
Message:

Runtime: add IPv6 parsing/resolving functions (contributed by Oliver Loch)
ExtPacks/VNC: add IPv6 support (contributed by Oliver Loch)

Location:
trunk
Files:
1 added
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/iprt/mangling.h

    r42712 r43171  
    1111
    1212/*
    13  * Copyright (C) 2011 Oracle Corporation
     13 * Copyright (C) 2011-2012 Oracle Corporation
    1414 *
    1515 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    11971197# define RTSocketClose                                  RT_MANGLER(RTSocketClose)
    11981198# define RTSocketFromNative                             RT_MANGLER(RTSocketFromNative)
     1199# define RTSocketGetAddrInfo                            RT_MANGLER(RTSocketGetAddrInfo)
    11991200# define RTSocketGetLocalAddress                        RT_MANGLER(RTSocketGetLocalAddress)
    12001201# define RTSocketGetPeerAddress                         RT_MANGLER(RTSocketGetPeerAddress)
    … …  
    12841285# define RTStrICmp                                      RT_MANGLER(RTStrICmp)
    12851286# define RTStrIStr                                      RT_MANGLER(RTStrIStr)
     1287# define RTStrIsIpAddr4                                 RT_MANGLER(RTStrIsIpAddr4)
     1288# define RTStrIsIpAddr6                                 RT_MANGLER(RTStrIsIpAddr6)
    12861289# define RTStrIsValidEncoding                           RT_MANGLER(RTStrIsValidEncoding)
    12871290# define RTStrmClearError                               RT_MANGLER(RTStrmClearError)

  • trunk/include/iprt/socket.h

    r39804 r43171  
    44
    55/*
    6  * Copyright (C) 2006-2011 Oracle Corporation
     6 * Copyright (C) 2006-2012 Oracle Corporation
    77 *
    88 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    126126 */
    127127RTDECL(int) RTSocketParseInetAddress(const char *pszAddress, unsigned uPort, PRTNETADDR pAddr);
     128
     129/**
     130 * Gets the ip addresses of a hostname via getaddrinfo()
     131 * Returns only the first result for the moment
     132 * This will change with the upcoming IPv6 struct.
     133 *
     134 * @returns IPRT status code.
     135 * @param   psz szString we want to lookup
     136 * @param   pszResult - memory used to write the result to
     137 * @param   resultSize - size of pszResult in bytes.
     138 *                       Holds size of string of the returned
     139 *                       address on out
     140 * @param   pAddrType   Which address to lookup, valid values are:
     141 *                      RTNETADDRTYPE_IPV4 -> lookup AF_INET
     142 *                      RTNETADDRTYPE_IPV6 -> lookup AF_INET6
     143 *                      RTNETADDRTYPE_INVALID,NULL,... -> lookup anything
     144 */
     145RTDECL(int) RTSocketGetAddrInfo(const char *psz, char *pszResult, size_t *resultSize, PRTNETADDRTYPE pAddrType);
    128146
    129147/**

  • trunk/include/iprt/string.h

    r40938 r43171  
    44
    55/*
    6  * Copyright (C) 2006-2010 Oracle Corporation
     6 * Copyright (C) 2006-2012 Oracle Corporation
    77 *
    88 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    38603860/** @} */
    38613861
     3862/** @defgroup rt_str_net    Network Address related String operations
     3863 * @ingroup grp_rt_str
     3864 * @{ */
     3865
     3866/** @page IPv6 Address Format
     3867 *
     3868 * IPv6 Addresses, their representation in text and other problems.
     3869 *
     3870 * The following is based on:
     3871 *
     3872 * - http://tools.ietf.org/html/rfc4291
     3873 * - http://tools.ietf.org/html/rfc5952
     3874 * - http://tools.ietf.org/html/rfc6052
     3875 *
     3876 *
     3877 * Before you start using those functions, you should have an idea of
     3878 * what you're dealing with, before you come and blame the functions...
     3879 *
     3880 * First of all, the address itself:
     3881 *
     3882 * An address is written like this: (READ THIS FINE MANUAL!)
     3883 *
     3884 * - 2001:db8:abc:def::1
     3885 *
     3886 * The characters between two colons are called a "hextet".
     3887 * Each hextet consists of four characters and each IPv6 address
     3888 * consists of a maximum of eight hextets. So a full blown address
     3889 * would look like this:
     3890 *
     3891 * - 1111:2222:3333:4444:5555:6666:7777:8888
     3892 *
     3893 * The allowed characters are "0123456789abcdef". They have to be
     3894 * lower case. Upper case is not allowed.
     3895 *
     3896 * *** Gaps and adress shortening
     3897 *
     3898 * If an address contains hextets that contain only "0"s, they
     3899 * can be shortened, like this:
     3900 *
     3901 * - 1111:2222:0000:0000:0000:0000:7777:8888 -> 1111:2222::7777:8888
     3902 *
     3903 * The double colon represents the hextets that have been shortened "::".
     3904 * The "::" will be called "gap" from now on.
     3905 *
     3906 * When shortening an address, there are some special rules that need to be applied:
     3907 *
     3908 * - Shorten always the longest group of hextets.
     3909 *
     3910 *   Let's say, you have this address: 2001:db8:0:0:0:1:0:0 then it has to be
     3911 *   shortened to "2001:db8::1:0:0". Shortening to "2001:db8:0:0:0:1::" would
     3912 *   return an error.
     3913 *
     3914 * - Two or more gaps the same size.
     3915 *
     3916 *   Let's say you have this address: 2001:db8:0:0:1:0:0:1. As you can see, there
     3917 *   are two gaps, both the size of two hextets. If you shorten the last two hextets,
     3918 *   you end up in pain, as the RFC forbids this, so the correct address is:
     3919 *   "2001:db8::1:0:0:1"
     3920 *
     3921 * It's important to note that an address can only be shortened ONE TIME!
     3922 * This is invalid: "2001:db8::1::1"
     3923 *
     3924 * *** The scope.
     3925 *
     3926 * Each address has a so called "scope" it is added to the end of the address,
     3927 * separated by a percent sign "%". If there is no scope at the end, it defaults
     3928 * to "0".
     3929 *
     3930 * So "2001:db8::1" is the same as "2001:db8::1%0".
     3931 *
     3932 * As in IPv6 all network interfaces can/should have the same address, the scope
     3933 * gives you the ability to choose on which interface the system should listen.
     3934 *
     3935 * AFAIK, the scope can be used with unicast as well as link local addresses, but
     3936 * it is mandatory with link local addresses (starting with fe80::).
     3937 *
     3938 * On Linux the default scope is the interface's name. On Windows it's just the index
     3939 * of the interface. Run "route print -6" in the shell, to see the interface's index
     3940 * on Winodows.
     3941 *
     3942 * All functions can deal with the scope, and DO NOT warn if you put garbage there.
     3943 *
     3944 * *** Port added to the IPv6 address
     3945 *
     3946 * There is only one way to add a port to an IPv6 address is to embed it in brackets:
     3947 *
     3948 * [2001:db8::1]:12345
     3949 *
     3950 * This gives you the address "2001:db8::1" and the port "12345".
     3951 *
     3952 * What also works, but is not recommended by rfc is to separate the port
     3953 * by a dot:
     3954 *
     3955 * 2001:db8::1.12345
     3956 *
     3957 * It even works with embedded IPv4 addresses.
     3958 *
     3959 * *** Special addresses and how they are written
     3960 *
     3961 * The following are notations to represent "special addresses".
     3962 *
     3963 * "::" IN6ADDR_ANY
     3964 * ":::123" IN6ADDR_ANY with port "123"
     3965 * "[::]:123" IN6ADDR_ANY with port "123"
     3966 * "[:::123]" -> NO. Not allowed and makes no sense
     3967 * "::1" -> address of the loopback device (127.0.0.1 in v4)
     3968 *
     3969 * On systems with dual sockets, one can use so called embedded IPv4 addresses:
     3970 *
     3971 * "::ffff:192.168.1.1" results in the IPv6 address "::ffff:c0a8:0101" as two octets
     3972 * of the IPv4 address will be converted to one hextet in the IPv6 address.
     3973 *
     3974 * The prefix of such addresses MUST BE "::ffff:", 10 bytes as zero and two bytes as 255.
     3975 *
     3976 * The so called IPv4-compatible IPv6 addresses are deprecated and no longer in use.
     3977 *
     3978 * *** Valid addresses and string
     3979 *
     3980 * If you use any of the IPv6 address functions, keep in mind, that those addresses
     3981 * are all returning "valid" even if the underlying system (e.g. VNC) doesn't like
     3982 * such strings.
     3983 *
     3984 * [2001:db8::1]
     3985 * [2001:db8::1]:12345
     3986 *
     3987 * and so on. So to make sure you only pass the underlying software a pure IPv6 address
     3988 * without any garbage, you should use the "outAddress" parameters to get a RFC compliant
     3989 * address returned.
     3990 *
     3991 * So after reading the above, you'll start using the functions and see a bool called
     3992 * "followRfc" which is true by default. This is what this bool does:
     3993 *
     3994 * The following addresses all represent the exact same address:
     3995 *
     3996 * 1 - 2001:db8::1
     3997 * 2 - 2001:db8:0::1
     3998 * 3 - 2001:0db8:0000:0000:0000:0000:0000:0001
     3999 * 4 - 2001:DB8::1
     4000 * 5 - [2001:db8::1]
     4001 * 6 - [2001:db8:0::1]
     4002 *
     4003 * According to RFC 5952, number two, three, four and six are invalid.
     4004 *
     4005 * #2 - because there is a single hextet that hasn't been shortened
     4006 *
     4007 * #3 - because there has nothing been shortened (hextets 3 to 7) and
     4008 *      there are leading zeros in at least one hextet ("0db8")
     4009 *
     4010 * #4 - all characters in an IPv6 address have to be lower case
     4011 *
     4012 * #6 - same as two but included in brackets
     4013 *
     4014 * If you follow RFC, the above addresses are not converted and an
     4015 * error is returned. If you turn RFC off, you will get the expected
     4016 * representation of the address.
     4017 *
     4018 * It's a nice way to convert "weird" addresses to rfc compliant addresses
     4019 *
     4020 */
     4021
     4022/**
     4023 * Takes a string and tests if it is a valid IPv6 representation
     4024 *
     4025 * @returns iprt status code.
     4026 * @param psz                  The string to test
     4027 * @param pszResultAddress     plain address, optional read "valid addresses
     4028 *                             and strings" above.
     4029 * @param resultAddressSize    size of pszResultAddress
     4030 * @param addressOnly          return only the plain address (no scope)
     4031 *                             Ignored, and will always return the if id
     4032 *
     4033 */
     4034RTDECL(int) RTStrIsIpAddr6(const char *psz, char *pszResultAddress, size_t resultAddressSize, bool addressOnly, bool followRfc);
     4035
     4036/**
     4037 * Takes a string and returns 0 if it is an IPv4 address
     4038 *
     4039 * @returns iprt status code
     4040 * @param pst              The string to test
     4041 */
     4042RTDECL(int) RTStrIsIpAddr4(const char *psz);
     4043
     4044/** @} */
     4045
    38624046
    38634047RT_C_DECLS_END

  • trunk/src/VBox/ExtPacks/VNC/VBoxVNC.cpp

    r40383 r43171  
    2828#include <iprt/path.h>
    2929#include <iprt/mem.h>
     30#include <iprt/socket.h>
    3031#include <iprt/stream.h>
    3132#include <iprt/string.h>
    … …  
    4344#define VNC_ADDRESSSIZE 60
    4445#define VNC_PORTSSIZE 20
     46#define VNC_ADDRESS_OPTION_MAX 500
    4547
    4648class VNCServerImpl
    … …  
    210212    vncServer->desktopName = "VBoxVNC";
    211213
     214#ifndef LIBVNCSERVER_IPv6
     215
    212216    // get listen address
    213217    char szAddress[VNC_ADDRESSSIZE + 1] = {0};
    … …  
    269273                                               &port, sizeof(port), NULL);
    270274    LogRel(("VNC: port = %u\n", port));
    271 
     275#else
     276    // with IPv6 from here
     277    /*
     278
     279       This is the deal:
     280
     281       Four new options are available:
     282       - VNCAddress4 -> IPv4 address to use
     283       - VNCPort4 -> IPv4 Port to use
     284       - VNCAddress6 -> IPv6 address to use
     285       - VNCPort6 -> IPv6 port to use
     286
     287       By default we prefer IPv6 over IPv4.
     288
     289       The address length can be unlimited as the interface identifier is not
     290       limited by any specs - if this is wrong, and someone knows the line
     291       and the RFC number, i'd appreciate a message :)
     292
     293       THE MAXIMUM LENGTH OF THE RETURNED VALUES MUST NOT BE GREATER THAN:
     294
     295                        --> VBOX_ADDRESS_OPTION_MAX <--
     296
     297       which is defined at the top of this file.
     298
     299       The way to determine which address to use is as follows:
     300
     301        1st - get address information from VRDEProperties
     302            "TCP/Address"
     303            "TCP/Ports"
     304
     305        2nd - if the address information is IPv4 get VNCAddress6 and VNCPort6
     306        2nd - if the address information is IPv6 get VNCAddress4 and VNCPort4
     307        2nd - if the address information is EMPTY and TCP/Ports returns 3389,
     308                check both, VNCAddress4 and VNCAddress6 as well as the ports.
     309                3389 is not a valid VNC port, therefore we assume it's not
     310                been set
     311
     312                If one of the addresses is empty we assume to listen on any
     313                interface/address for that protocol. In other words:
     314                IPv4: 0.0.0.0
     315                IPv6: ::
     316
     317        2nd - if everything is empty -> listen on all interfaces
     318
     319        3rd - check if the addresses are valid hand them to libvncserver
     320                to open the initial sockets.
     321
     322        4th - after the sockets have been opened, the used port of the
     323                address/protocol in TCP/Address is returned.
     324                if TCP/Address is empty, prefer IPv6
     325
     326     */
     327
     328    /* ok, now first get the address from VRDE/TCP/Address.
     329
     330    */
     331    // this should be put somewhere else
     332    char szIPv6ListenAll[] = "::";
     333    char szIPv4ListenAll[] = "0.0.0.0";
     334
     335    uint32_t ulServerPort4 = 0;
     336    uint32_t ulServerPort6 = 0;
     337    uint32_t cbOut = 0;
     338    size_t resSize = 0;
     339    RTNETADDRTYPE iAddrType = RTNETADDRTYPE_INVALID;
     340    char *pszTCPAddress = NULL;
     341    char *pszTCPPort = NULL;
     342    char *pszVNCAddress4 = NULL;
     343    char *pszVNCPort4 = NULL;
     344    char *pszVNCAddress6 = NULL;
     345    char *pszVNCPort6 = NULL;
     346    char *pszServerAddress4 = NULL;
     347    char *pszServerAddress6 = NULL;
     348    char *pszGetAddrInfo4 = NULL; // used to store the result of RTSocketGetAddrInfo()
     349    char *pszGetAddrInfo6 = NULL; // used to store the result of RTSocketGetAddrInfo()
     350
     351    // get address
     352    rc = -1;
     353    pszTCPAddress = (char *) RTMemTmpAlloc(VNC_ADDRESS_OPTION_MAX);
     354    memset(pszTCPAddress, '\0', VNC_ADDRESS_OPTION_MAX);
     355
     356    rc = instance->mCallbacks->VRDECallbackProperty(instance->mCallback,
     357                                                    VRDE_QP_NETWORK_ADDRESS,
     358                                                    pszTCPAddress,
     359                                                    VNC_ADDRESS_OPTION_MAX,
     360                                                    &cbOut);
     361
     362    // get port (range)
     363    rc = -1;
     364    pszTCPPort = (char *) RTMemTmpAlloc(VNC_ADDRESS_OPTION_MAX);
     365    memset(pszTCPPort,'\0',VNC_ADDRESS_OPTION_MAX);
     366
     367    rc = instance->mCallbacks->VRDECallbackProperty(instance->mCallback,
     368                                                    VRDE_QP_NETWORK_PORT_RANGE,
     369                                                    pszTCPPort,
     370                                                    VNC_ADDRESS_OPTION_MAX,
     371                                                    &cbOut);
     372
     373    Assert(cbOut < VNC_ADDRESS_OPTION_MAX);
     374
     375    // get tcp ports option from vrde
     376
     377    rc = -1;
     378
     379    pszTCPPort = (char *) RTMemTmpAlloc(6);
     380    memset(pszTCPPort,'\0',6);
     381
     382    VRDEFEATURE *pVRDEFeature = (VRDEFEATURE *) RTMemTmpAlloc(VNC_ADDRESS_OPTION_MAX);
     383    pVRDEFeature->u32ClientId = 0;
     384
     385    RTStrCopy(pVRDEFeature->achInfo, 19, "Property/TCP/Ports");
     386
     387    cbOut = 1;
     388
     389    rc = instance->mCallbacks->VRDECallbackProperty(instance->mCallback,
     390                                                    VRDE_QP_FEATURE,
     391                                                    pVRDEFeature,
     392                                                    VNC_ADDRESS_OPTION_MAX,
     393                                                    &cbOut);
     394
     395    Assert(cbOut < VNC_ADDRESS_OPTION_MAX);
     396
     397    if (RT_SUCCESS(rc))
     398    {
     399        RTStrCopy(pszTCPPort, cbOut, pVRDEFeature->achInfo);
     400    }
     401
     402    // get VNCAddress4
     403    rc = -1;
     404    const uint32_t lVNCAddress4FeatureSize = sizeof(VRDEFEATURE) + 24;
     405
     406    pszVNCAddress4 = (char *) RTMemTmpAlloc(24);
     407    memset(pszVNCAddress4,'\0',24);
     408
     409    pVRDEFeature->u32ClientId = 0;
     410
     411    RTStrCopy(pVRDEFeature->achInfo, 21, "Property/VNCAddress4");
     412
     413    cbOut = 1;
     414
     415    rc = instance->mCallbacks->VRDECallbackProperty(instance->mCallback,
     416                                                    VRDE_QP_FEATURE,
     417                                                    pVRDEFeature,
     418                                                    VNC_ADDRESS_OPTION_MAX,
     419                                                    &cbOut);
     420
     421    Assert(cbOut <= 24);
     422
     423    if (RT_SUCCESS(rc))
     424    {
     425       RTStrCopy(pszVNCAddress4,cbOut,pVRDEFeature->achInfo);
     426    }
     427
     428    // VNCPort4
     429    rc = -1;
     430    pszVNCPort4 = (char *) RTMemTmpAlloc(6);
     431
     432    pVRDEFeature->u32ClientId = 0;
     433    RTStrCopy(pVRDEFeature->achInfo, VNC_ADDRESS_OPTION_MAX, "Property/VNCPort4");
     434
     435    cbOut = VNC_ADDRESS_OPTION_MAX;
     436    rc = instance->mCallbacks->VRDECallbackProperty(instance->mCallback,
     437                                                    VRDE_QP_FEATURE,
     438                                                    pVRDEFeature,
     439                                                    VNC_ADDRESS_OPTION_MAX,
     440                                                    &cbOut);
     441
     442
     443    Assert(cbOut <= VNC_ADDRESS_OPTION_MAX);
     444    if (RT_SUCCESS(rc))
     445    {
     446        if (cbOut < 6)
     447        {
     448            RTStrCopy(pszVNCPort4, cbOut, pVRDEFeature->achInfo);
     449        }
     450
     451    }
     452
     453    // VNCAddress6
     454    rc = -1;
     455
     456    pszVNCAddress6 = (char *) RTMemTmpAlloc(VNC_ADDRESS_OPTION_MAX);
     457    memset(pszVNCAddress6,'\0',VNC_ADDRESS_OPTION_MAX);
     458
     459    pVRDEFeature->u32ClientId = 0;
     460    RTStrCopy(pVRDEFeature->achInfo, 21,"Property/VNCAddress6");
     461
     462    cbOut = VNC_ADDRESS_OPTION_MAX;
     463
     464    rc = instance->mCallbacks->VRDECallbackProperty(instance->mCallback,
     465                                                    VRDE_QP_FEATURE,
     466                                                    pVRDEFeature,
     467                                                    VNC_ADDRESS_OPTION_MAX,
     468                                                    &cbOut);
     469
     470    Assert(cbOut <= VNC_ADDRESS_OPTION_MAX);
     471
     472    if (RT_SUCCESS(rc))
     473    {
     474        RTStrCopy(pszVNCAddress6, cbOut, pVRDEFeature->achInfo);
     475    }
     476
     477    // VNCPort6
     478    pszVNCPort6 = (char *) RTMemTmpAlloc(6);
     479    memset(pszVNCPort6,'\0', 6);
     480
     481    pVRDEFeature->u32ClientId = 0;
     482    RTStrCopy(pVRDEFeature->achInfo, 18 , "Property/VNCPort6");
     483
     484    cbOut = 5;
     485
     486    rc = instance->mCallbacks->VRDECallbackProperty(instance->mCallback,
     487                                                    VRDE_QP_FEATURE,
     488                                                    pVRDEFeature,
     489                                                    VNC_ADDRESS_OPTION_MAX,
     490                                                    &cbOut);
     491
     492    Assert(cbOut <= 6);
     493
     494    if (RT_SUCCESS(rc))
     495    {
     496        RTStrCopy(pszVNCPort6, cbOut, pVRDEFeature->achInfo);
     497    }
     498
     499    rc = RTStrIsIpAddr4(pszTCPAddress);
     500
     501    if (RT_SUCCESS(rc))
     502    {
     503        pszServerAddress4 = pszTCPAddress;
     504
     505        if (strlen(pszTCPPort) > 0)
     506        {
     507            rc = RTStrToUInt32Ex(pszTCPPort, NULL, 10, &ulServerPort4);
     508
     509            if (!RT_SUCCESS(rc) || ulServerPort4 > 65535)
     510                ulServerPort4 = 0;
     511        }
     512
     513        rc = RTStrIsIpAddr6(pszVNCAddress6, NULL, 0, true, true);
     514
     515        if (RT_SUCCESS(rc))
     516        {
     517            pszServerAddress6 = pszVNCAddress6;
     518
     519        }
     520        else
     521        {
     522            pszServerAddress6 = szIPv6ListenAll;
     523        }
     524
     525        if (strlen(pszVNCPort6) > 0)
     526        {
     527            rc = RTStrToUInt32Ex(pszVNCPort6, NULL, 10, &ulServerPort6);
     528
     529            if (!RT_SUCCESS(rc) || ulServerPort6 > 65535)
     530                ulServerPort6 = 0;
     531
     532        }
     533
     534    }
     535
     536    rc = RTStrIsIpAddr6(pszTCPAddress, NULL, 0, true, true);
     537
     538    if (RT_SUCCESS(rc))
     539    {
     540        pszServerAddress6 = pszTCPAddress;
     541
     542        if (strlen(pszTCPPort) > 0)
     543        {
     544            rc = RTStrToUInt32Ex(pszTCPPort, NULL, 10, &ulServerPort6);
     545
     546            if (!RT_SUCCESS(rc) || ulServerPort6 > 65535)
     547                ulServerPort6 = 0;
     548        }
     549
     550        rc = RTStrIsIpAddr4(pszVNCAddress4);
     551
     552        if (RT_SUCCESS(rc))
     553        {
     554            pszServerAddress4 = pszVNCAddress4;
     555
     556        }
     557        else
     558        {
     559            pszServerAddress4 = szIPv4ListenAll;
     560        }
     561
     562        if (strlen(pszVNCPort4) > 0)
     563        {
     564            rc = RTStrToUInt32Ex(pszVNCPort4, NULL, 10, &ulServerPort4);
     565
     566            if (!RT_SUCCESS(rc) || ulServerPort4 > 65535)
     567                ulServerPort4 = 0;
     568
     569        }
     570    }
     571
     572    if ((pszServerAddress4 != pszTCPAddress) && (pszServerAddress6 != pszTCPAddress) && (strlen(pszTCPAddress) > 0))
     573    {
     574        // here we go, we prefer IPv6 over IPv4;
     575        pszGetAddrInfo6 = (char *) RTMemTmpAlloc(42);
     576        memset(pszGetAddrInfo6, '\0', 42);
     577        resSize = 42;
     578        iAddrType = RTNETADDRTYPE_IPV6;
     579
     580        rc = RTSocketGetAddrInfo(pszTCPAddress, pszGetAddrInfo6, &resSize, &iAddrType);
     581
     582        if (RT_SUCCESS(rc))
     583        {
     584            pszServerAddress6 = pszGetAddrInfo6;
     585
     586        }
     587        else
     588        {
     589            RTMemTmpFree(pszGetAddrInfo6);
     590            pszGetAddrInfo6 = NULL;
     591        }
     592
     593        if (!pszServerAddress6)
     594        {
     595            pszGetAddrInfo4 = (char *) RTMemTmpAlloc(16);
     596            memset(pszGetAddrInfo4,'\0',16);
     597            resSize = 16;
     598            iAddrType = RTNETADDRTYPE_IPV4;
     599
     600            rc = RTSocketGetAddrInfo(pszTCPAddress, pszGetAddrInfo4, &resSize, &iAddrType);
     601
     602            if (RT_SUCCESS(rc))
     603            {
     604                pszServerAddress4 = pszGetAddrInfo4;
     605            }
     606            else
     607            {
     608                RTMemTmpFree(pszGetAddrInfo4);
     609                pszGetAddrInfo4 = NULL;
     610            }
     611        }
     612    }
     613
     614    if (!pszServerAddress4 && strlen(pszVNCAddress4) > 0)
     615    {
     616        pszGetAddrInfo4 = (char *) RTMemTmpAlloc(16);
     617        memset(pszGetAddrInfo4,'\0',16);
     618        resSize = 16;
     619        iAddrType = RTNETADDRTYPE_IPV4;
     620
     621        rc = RTSocketGetAddrInfo(pszVNCAddress4, pszGetAddrInfo4, &resSize, &iAddrType);
     622
     623        if (RT_SUCCESS(rc))
     624            pszServerAddress4 = pszGetAddrInfo4;
     625
     626    }
     627
     628    if (!pszServerAddress6 && strlen(pszVNCAddress6) > 0)
     629    {
     630        pszGetAddrInfo6 = (char *) RTMemTmpAlloc(42);
     631        memset(pszGetAddrInfo6, '\0', 42);
     632        resSize = 42;
     633        iAddrType = RTNETADDRTYPE_IPV6;
     634
     635        rc = RTSocketGetAddrInfo(pszVNCAddress6, pszGetAddrInfo6, &resSize, &iAddrType);
     636
     637        if (RT_SUCCESS(rc))
     638            pszServerAddress6 = pszGetAddrInfo6;
     639
     640    }
     641    if (!pszServerAddress4)
     642    {
     643        rc = RTStrIsIpAddr4(pszVNCAddress4);
     644
     645        if (RT_SUCCESS(rc))
     646            pszServerAddress4 = pszVNCAddress4;
     647        else
     648            pszServerAddress4 = szIPv4ListenAll;
     649    }
     650    if (!pszServerAddress6)
     651    {
     652        rc = RTStrIsIpAddr6(pszVNCAddress6, NULL, 0, true, true);
     653
     654        if (RT_SUCCESS(rc))
     655            pszServerAddress6 = pszVNCAddress6;
     656        else
     657            pszServerAddress6 = szIPv6ListenAll;
     658    }
     659
     660    if (pszVNCPort4 && ulServerPort4 == 0)
     661    {
     662        rc = RTStrToUInt32Ex(pszVNCPort4, NULL, 10, &ulServerPort4);
     663
     664        if (!RT_SUCCESS(rc) || ulServerPort4 > 65535)
     665            ulServerPort4 = 0;
     666    }
     667    if (pszVNCPort6 && ulServerPort6 == 0)
     668    {
     669        rc = RTStrToUInt32Ex(pszVNCPort6, NULL, 10, &ulServerPort6);
     670
     671        if (!RT_SUCCESS(rc) || ulServerPort6 > 65535)
     672            ulServerPort6 = 0;
     673    }
     674    if (ulServerPort4 == 0 || ulServerPort6 == 0)
     675    {
     676        vncServer->autoPort = 1;
     677    }
     678    else
     679    {
     680        vncServer->port = ulServerPort4;
     681        vncServer->ipv6port = ulServerPort6;
     682    }
     683
     684    if (!rfbStringToAddr(pszServerAddress4,&vncServer->listenInterface))
     685        LogRel(("VNC: could not parse VNC server listen address IPv4 '%s'\n", pszServerAddress4));
     686
     687    vncServer->listen6Interface = pszServerAddress6;
     688
     689    rfbInitServer(vncServer);
     690
     691    vncServer->newClientHook = rfbNewClientEvent;
     692    vncServer->kbdAddEvent = vncKeyboardEvent;
     693    vncServer->ptrAddEvent = vncMouseEvent;
     694
     695    // notify about the actually used port
     696    int port = 0;
     697    port = vncServer->ipv6port;
     698
     699    if (vncServer->listen6Sock < 0)
     700    {
     701        LogRel(("VNC: not able to bind to IPv6 socket with address '%s'\n",pszServerAddress6));
     702        port = 0;
     703
     704    }
     705
     706    instance->mCallbacks->VRDECallbackProperty(instance->mCallback,
     707                                               VRDE_SP_NETWORK_BIND_PORT,
     708                                               &port, sizeof(port), NULL);
     709    LogRel(("VNC: port6 = %u\n", port));
     710
     711    if (pVRDEFeature)
     712        RTMemTmpFree(pVRDEFeature);
     713
     714    if (pszTCPAddress)
     715    {
     716        if (pszTCPAddress == pszServerAddress4)
     717            pszServerAddress4 = NULL;
     718
     719        if (pszTCPAddress == pszServerAddress6)
     720            pszServerAddress6 = NULL;
     721
     722        RTMemTmpFree(pszTCPAddress);
     723    }
     724
     725    if (pszTCPPort)
     726        RTMemTmpFree(pszTCPPort);
     727
     728    if (pszVNCAddress4)
     729        RTMemTmpFree(pszVNCAddress4);
     730
     731    if (pszVNCPort4)
     732        RTMemTmpFree(pszVNCPort4);
     733
     734    if (pszGetAddrInfo4)
     735        RTMemTmpFree(pszGetAddrInfo4);
     736
     737    if (pszVNCAddress6)
     738        RTMemTmpFree(pszVNCAddress6);
     739
     740    if (pszGetAddrInfo6)
     741        RTMemTmpFree(pszGetAddrInfo6);
     742
     743    // with ipv6 to here
     744#endif
    272745    // let's get the password
    273746    instance->szVNCPassword[0] = '\0';

  • trunk/src/VBox/Runtime/Makefile.kmk

    r42692 r43171  
    377377        common/string/RTStrCopyP.cpp \
    378378        common/string/RTStrCopyPEx.cpp \
     379        common/string/RTStrIPv6.cpp \
    379380        common/string/RTStrNCmp.cpp \
    380381        common/string/RTStrNLen.cpp \
    … …  
    900901        r3/posix/RTPathUserHome-posix.cpp \
    901902        r3/posix/RTSystemQueryOSInfo-posix.cpp \
    902         r3/posix/RTSystemQueryTotalRam-posix.cpp \
     903        r3/posix/RTSystemQueryTotalRam-posix.cpp \
    903904        r3/posix/RTTimeNow-posix.cpp \
    904905        r3/posix/RTTimeSet-posix.cpp \
    … …  
    12951296ifdef IPRT_WITH_KSTUFF
    12961297 VBoxRT_LIBS                  += \
    1297         $(PATH_STAGE_LIB)/VBox-kStuff$(VBOX_SUFF_LIB)
     1298        $(PATH_STAGE_LIB)/VBox-kStuff$(VBOX_SUFF_LIB)
    12981299endif
    12991300ifndef SDK_VBOX_LIBXML2_LIBS
    … …  
    13201321VBoxRT_LIBS.solaris            = \
    13211322        kstat \
    1322         contract
     1323        contract
    13231324ifn1of ($(KBUILD_TARGET_ARCH), sparc32 sparc64)
    13241325 # SMBIOS not available on Solaris SPARC.
    … …  
    17221723        common/string/memcmp.asm \
    17231724        common/string/memchr.asm \
    1724         common/string/memcpy.asm \
    1725         common/string/memset.asm \
    1726         common/string/memmove.asm \
    1727         common/string/strlen.asm \
     1725        common/string/memcpy.asm \
     1726        common/string/memset.asm \
     1727        common/string/memmove.asm \
     1728        common/string/strlen.asm \
    17281729        common/string/strncmp.cpp \
    17291730        common/string/strpbrk.cpp \
    … …  
    19211922
    19221923RuntimeR0Drv_ORDERDEPS.freebsd = \
    1923         $(PATH_STAGE)/gen-sys-hdrs/bus_if.h \
    1924         $(PATH_STAGE)/gen-sys-hdrs/device_if.h
     1924        $(PATH_STAGE)/gen-sys-hdrs/bus_if.h \
     1925        $(PATH_STAGE)/gen-sys-hdrs/device_if.h
    19251926
    19261927

  • trunk/src/VBox/Runtime/include/internal/string.h

    r36555 r43171  
    55
    66/*
    7  * Copyright (C) 2006-2007 Oracle Corporation
     7 * Copyright (C) 2006-2012 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    8181DECLHIDDEN(int) rtUtf8Length(const char *psz, size_t cch, size_t *pcuc, size_t *pcchActual);
    8282
     83DECLHIDDEN(int) rtStrToIpAddr6Str(const char *psz, char *pszAddrOut, size_t addrOutSize, char *pszPortOut, size_t portOutSize, bool followRfc);
     84
    8385RT_C_DECLS_END
    8486

  • trunk/src/VBox/Runtime/r3/socket.cpp

    r39807 r43171  
    55
    66/*
    7  * Copyright (C) 2006-2011 Oracle Corporation
     7 * Copyright (C) 2006-2012 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    6868#include "internal/magics.h"
    6969#include "internal/socket.h"
     70#include "internal/string.h"
    7071
    7172
    … …  
    587588}
    588589
     590
    589591static bool rtSocketIsIPv4Numerical(const char *pszAddress, PRTNETADDRIPV4 pAddr)
    590592{
    … …  
    681683
    682684
     685/*
     686 * new function to allow ipv4 and ipv6 addresses to be resolved.
     687 * breaks compatibility with windows before 2000
     688 * will change when the new ipv6 struct will be added
     689 * temporary solution
     690 */
     691RTDECL(int) RTSocketGetAddrInfo(const char *psz, char *pszResult, size_t *resultSize, PRTNETADDRTYPE pAddrType)
     692{
     693    int rc = 0;
     694    size_t resSize = 0;
     695    uint8_t *pubDummy = NULL;
     696
     697    struct sockaddr_in *pgrSa = NULL;
     698    struct sockaddr_in6 *pgrSa6 = NULL;
     699
     700    struct addrinfo grHints;
     701    struct addrinfo *pgrResults = NULL, *pgrResult = NULL;
     702
     703    char szIpV4Address[16];
     704    char szIpV6Address[40];
     705    char szDummy[10];
     706
     707    char *pszIpV4Address = NULL, *pszIpV6Address = NULL;
     708
     709    memset(szIpV4Address, '\0', 16);
     710    memset(szIpV6Address, '\0', 40);
     711    memset(szDummy, '\0', 10);
     712
     713    memset(&grHints, 0, sizeof(struct addrinfo));
     714
     715    if (*resultSize < 16)
     716        return VERR_NET_ADDRESS_NOT_AVAILABLE;
     717
     718    resSize = *resultSize;
     719
     720    grHints.ai_family = AF_UNSPEC;
     721
     722    if (*pAddrType == RTNETADDRTYPE_IPV6)
     723        grHints.ai_family = AF_INET6;
     724
     725    if (*pAddrType == RTNETADDRTYPE_IPV4)
     726        grHints.ai_family = AF_INET;
     727
     728    if (*pAddrType == RTNETADDRTYPE_INVALID || !pAddrType) // yes, it's been set before...
     729        grHints.ai_family = AF_UNSPEC;
     730
     731    grHints.ai_socktype = 0;
     732    grHints.ai_flags = 0;
     733    grHints.ai_protocol = 0;
     734
     735#ifdef RT_OS_WINDOWS
     736    /*
     737     * Winsock2 init
     738     */
     739    // *FIXME* someone should check if we really need 2, 2 here
     740    WORD    wVersionRequested = MAKEWORD(2, 2);
     741    WSADATA wsaData;
     742
     743    rc = WSAStartup(wVersionRequest, &wsaData);
     744
     745    if (wsaData.wVersion != wVersionRequested)
     746    {
     747        AssertMsgFailed(("Wrong winsock version\n"));
     748        return VERR_NOT_SUPPORTED;
     749    }
     750#endif
     751
     752    rc = getaddrinfo(psz, "", &grHints, &pgrResults);
     753
     754    if (rc != 0)
     755        return VERR_NET_ADDRESS_NOT_AVAILABLE;
     756
     757    // return data
     758    // on multiple matches return only the first one
     759
     760    if (!pgrResults)
     761        return VERR_NET_ADDRESS_NOT_AVAILABLE;
     762
     763    pgrResult = pgrResults->ai_next;
     764
     765    if (!pgrResult)
     766        return VERR_NET_ADDRESS_NOT_AVAILABLE;
     767
     768    if (pgrResult->ai_family == AF_INET)
     769    {
     770        pgrSa = (sockaddr_in *)pgrResult->ai_addr;
     771
     772        pszIpV4Address = &szIpV4Address[0];
     773
     774        pubDummy = (uint8_t *)&pgrSa->sin_addr;
     775
     776        for (int i = 0; i < 4; i++)
     777        {
     778            memset(szDummy, '\0', 10);
     779
     780            rc = RTStrPrintf(szDummy, 10, "%u", *pubDummy);
     781
     782            if (!rc || rc > 3 || rc < 1)
     783                return VERR_NET_ADDRESS_NOT_AVAILABLE;
     784
     785            memcpy(pszIpV4Address, szDummy, rc);
     786
     787            pszIpV4Address = (pszIpV4Address + rc);
     788
     789            if (i < 3)
     790            {
     791                *pszIpV4Address = '.';
     792                pszIpV4Address++;
     793            }
     794            pubDummy++;
     795        }
     796
     797        pgrResult = NULL;
     798        pgrSa = NULL;
     799        pubDummy = NULL;
     800        freeaddrinfo(pgrResults);
     801
     802        if (strlen(szIpV4Address) >= resSize)
     803        {
     804            memset(pszResult, 0, resSize);
     805            *resultSize = strlen(szIpV4Address) + 1;
     806            return VERR_BUFFER_OVERFLOW;
     807        }
     808        else
     809        {
     810            memcpy(pszResult, szIpV4Address, strlen(szIpV4Address));
     811            *resultSize = strlen(szIpV4Address);
     812            return VINF_SUCCESS;
     813        }
     814    }
     815
     816    if (pgrResult->ai_family == AF_INET6)
     817    {
     818        pgrSa6 = (sockaddr_in6 *) pgrResult->ai_addr;
     819
     820        pszIpV6Address = &szIpV6Address[0];
     821
     822        pubDummy = (uint8_t *) &pgrSa6->sin6_addr;
     823
     824        for (int i = 0; i < 16; i++)
     825        {
     826            memset(szDummy, '\0', 10);
     827
     828            rc = RTStrPrintf(szDummy, 10, "%02x", *pubDummy);
     829
     830            if (rc != 2)
     831                return VERR_NET_ADDRESS_NOT_AVAILABLE;
     832
     833            memcpy(pszIpV6Address, szDummy, rc);
     834
     835            pszIpV6Address = pszIpV6Address + rc;
     836            pubDummy++;
     837        }
     838
     839        pubDummy = NULL;
     840        pgrSa6 = NULL;
     841        pgrResult = NULL;
     842        freeaddrinfo(pgrResults);
     843
     844        if (strlen(szIpV6Address) == 32)
     845        {
     846            if (strlen(szIpV6Address) + 8 >= resSize)
     847            {
     848                *resultSize = 41;
     849                memset(pszResult, 0, resSize);
     850                return VERR_BUFFER_OVERFLOW;
     851            }
     852            else
     853            {
     854                memset(pszResult, '\0', resSize);
     855                rc = rtStrToIpAddr6Str(szIpV6Address, pszResult, resSize, NULL, 0, true);
     856
     857                if (rc != 0)
     858                    return VERR_NET_ADDRESS_NOT_AVAILABLE;
     859
     860                *resultSize = strlen(pszResult);
     861
     862                return VINF_SUCCESS;
     863            }
     864        }
     865        else
     866        {
     867            return VERR_NET_ADDRESS_NOT_AVAILABLE;
     868        }
     869
     870    } // AF_INET6
     871    return VERR_NET_ADDRESS_NOT_AVAILABLE;
     872}
     873
     874
    683875RTDECL(int) RTSocketRead(RTSOCKET hSocket, void *pvBuffer, size_t cbBuffer, size_t *pcbRead)
    684876{
    … …  
    692884    AssertPtr(pvBuffer);
    693885    AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
    694 
    695886
    696887    int rc = rtSocketSwitchBlockingMode(pThis, true /* fBlocking */);
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette