rostests/apitests/ws2_32/getaddrinfo.c

   1 /*
   2  * PROJECT:         ReactOS api tests
   3  * LICENSE:         GPLv2+ - See COPYING in the top level directory
   4  * PURPOSE:         Test for getaddrinfo
   5  * PROGRAMMER:      Thomas Faber <thfabba@gmx.de>
   6  */
   7
   8 #define WIN32_NO_STATUS
   9 #include <winsock2.h>
  10 #include <ws2tcpip.h>
  11 #include <wine/test.h>
  12 #include <pseh/pseh2.h>
  13 #include <ndk/umtypes.h>
  14
  15 #define StartSeh()              ExceptionStatus = STATUS_SUCCESS; _SEH2_TRY {
  16 #define EndSeh(ExpectedStatus)  } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { ExceptionStatus = _SEH2_GetExceptionCode(); } _SEH2_END; ok(ExceptionStatus == ExpectedStatus, "Exception %lx, expected %lx\n", ExceptionStatus, ExpectedStatus)
  17
  18 #define ok_addrinfo(ai, flags, family, socktype, protocol, addrlen) do  \
  19 {                                                                       \
  20     ok_hex((ai)->ai_flags, flags);                                      \
  21     ok_dec((ai)->ai_family, family);                                    \
  22     ok_dec((ai)->ai_socktype, socktype);                                \
  23     ok_dec((ai)->ai_protocol, protocol);                                \
  24     ok_dec((ai)->ai_addrlen, addrlen);                                  \
  25 } while (0)
  26
  27 #define ok_sockaddr_in(sockaddr, family, port, addr) do                 \
  28 {                                                                       \
  29     int _i;                                                             \
  30     ok_dec(((SOCKADDR_IN *)(sockaddr))->sin_family, family);            \
  31     ok_dec(ntohs(((SOCKADDR_IN *)(sockaddr))->sin_port), port);         \
  32     ok_hex(((SOCKADDR_IN *)(sockaddr))->sin_addr.S_un.S_addr,           \
  33            inet_addr(addr));                                            \
  34     for (_i = 0; _i < 7; _i++)                                          \
  35         ok_dec(((SOCKADDR_IN *)(sockaddr))->sin_zero[_i], 0);           \
  36 } while (0)
  37
  38 #define InvalidPointer ((PVOID)0x5555555555555555ULL)
  39
  40 CHAR LocalAddress[sizeof("255.255.255.255")];
  41
  42 static
  43 VOID
  44 TestNodeName(VOID)
  45 {
  46     int Error;
  47     PADDRINFOA AddrInfo;
  48     ADDRINFOA Hints;
  49     NTSTATUS ExceptionStatus;
  50     struct
  51     {
  52         PCSTR NodeName;
  53         PCSTR ExpectedAddress;
  54         INT Flags;
  55     } Tests[] =
  56     {
  57         { "",                               LocalAddress },
  58         { " ",                              NULL },
  59         { "doesntexist.reactos.org",        NULL },
  60         { "localhost",                      "127.0.0.1" },
  61         { "localhost:80",                   NULL },
  62         { "7.8.9.10",                       "7.8.9.10",         AI_NUMERICHOST },
  63         { "0.0.0.0",                        "0.0.0.0",          AI_NUMERICHOST },
  64         { "255.255.255.255",                "255.255.255.255",  AI_NUMERICHOST },
  65         { "0.0.0.0 ",                       "0.0.0.0",    /* no AI_NUMERICHOST */ },
  66         { "0.0.0.0:80",                     NULL },
  67         { "0.0.0.0.0",                      NULL },
  68         { "1.1.1.256",                      NULL },
  69         /* let's just assume this one doesn't change any time soon ;) */
  70         { "google-public-dns-a.google.com", "8.8.8.8" },
  71     };
  72     const INT TestCount = sizeof(Tests) / sizeof(Tests[0]);
  73     INT i;
  74
  75     /* make sure we don't get IPv6 responses */
  76     ZeroMemory(&Hints, sizeof(Hints));
  77     Hints.ai_family = AF_INET;
  78
  79     trace("Nodes\n");
  80     for (i = 0; i < TestCount; i++)
  81     {
  82         trace("%d: '%s'\n", i, Tests[i].NodeName);
  83         StartSeh();
  84             AddrInfo = InvalidPointer;
  85             Error = getaddrinfo(Tests[i].NodeName, NULL, &Hints, &AddrInfo);
  86             if (Tests[i].ExpectedAddress)
  87             {
  88                 ok_dec(Error, 0);
  89                 ok_dec(WSAGetLastError(), 0);
  90                 ok(AddrInfo != NULL && AddrInfo != InvalidPointer,
  91                    "AddrInfo = %p\n", AddrInfo);
  92             }
  93             else
  94             {
  95                 ok_dec(Error, WSAHOST_NOT_FOUND);
  96                 ok_dec(WSAGetLastError(), WSAHOST_NOT_FOUND);
  97                 ok_ptr(AddrInfo, NULL);
  98             }
  99             if (!Error && AddrInfo && AddrInfo != InvalidPointer)
 100             {
 101                 ok_addrinfo(AddrInfo, Tests[i].Flags, AF_INET,
 102                             0, 0, sizeof(SOCKADDR_IN));
 103                 ok_ptr(AddrInfo->ai_canonname, NULL);
 104                 ok_sockaddr_in(AddrInfo->ai_addr, AF_INET,
 105                                0, Tests[i].ExpectedAddress);
 106                 ok_ptr(AddrInfo->ai_next, NULL);
 107                 freeaddrinfo(AddrInfo);
 108             }
 109         EndSeh(STATUS_SUCCESS);
 110     }
 111 }
 112
 113 static
 114 VOID
 115 TestServiceName(VOID)
 116 {
 117     int Error;
 118     PADDRINFOA AddrInfo;
 119     ADDRINFOA Hints;
 120     NTSTATUS ExceptionStatus;
 121     struct
 122     {
 123         PCSTR ServiceName;
 124         INT ExpectedPort;
 125         INT SockType;
 126     } Tests[] =
 127     {
 128         { "", 0 },
 129         { "0", 0 },
 130         { "1", 1 },
 131         { "a", -1 },
 132         { "010", 10 },
 133         { "0x1a", -1 },
 134         { "http", 80, SOCK_STREAM },
 135         { "smtp", 25, SOCK_STREAM },
 136         { "mail", 25, SOCK_STREAM }, /* alias for smtp */
 137         { "router", 520, SOCK_DGRAM },
 138         { "domain", 53, 0 /* DNS supports both UDP and TCP */ },
 139         { ":0", -1 },
 140         { "123", 123 },
 141         { " 123", 123 },
 142         { "    123", 123 },
 143         { "32767", 32767 },
 144         { "32768", 32768 },
 145         { "65535", 65535 },
 146         { "65536", 0 },
 147         { "65537", 1 },
 148         { "65540", 4 },
 149         { "65536", 0 },
 150         { "4294967295", 65535 },
 151         { "4294967296", 65535 },
 152         { "9999999999", 65535 },
 153         { "999999999999999999999999999999999999", 65535 },
 154         { "+5", 5 },
 155         { "-1", 65535 },
 156         { "-4", 65532 },
 157         { "-65534", 2 },
 158         { "-65535", 1 },
 159         { "-65536", 0 },
 160         { "-65537", 65535 },
 161         { "28a", -1 },
 162         { "28 ", -1 },
 163         { "a28", -1 },
 164     };
 165     const INT TestCount = sizeof(Tests) / sizeof(Tests[0]);
 166     INT i;
 167
 168     /* make sure we don't get IPv6 responses */
 169     ZeroMemory(&Hints, sizeof(Hints));
 170     Hints.ai_family = AF_INET;
 171
 172     trace("Services\n");
 173     for (i = 0; i < TestCount; i++)
 174     {
 175         trace("%d: '%s'\n", i, Tests[i].ServiceName);
 176         StartSeh()
 177             AddrInfo = InvalidPointer;
 178             Error = getaddrinfo(NULL, Tests[i].ServiceName, &Hints, &AddrInfo);
 179             if (Tests[i].ExpectedPort != -1)
 180             {
 181                 ok_dec(Error, 0);
 182                 ok_dec(WSAGetLastError(), 0);
 183                 ok(AddrInfo != NULL && AddrInfo != InvalidPointer,
 184                    "AddrInfo = %p\n", AddrInfo);
 185             }
 186             else
 187             {
 188                 ok_dec(Error, WSATYPE_NOT_FOUND);
 189                 ok_dec(WSAGetLastError(), WSATYPE_NOT_FOUND);
 190                 ok_ptr(AddrInfo, NULL);
 191             }
 192             if (!Error && AddrInfo && AddrInfo != InvalidPointer)
 193             {
 194                 ok_addrinfo(AddrInfo, 0, AF_INET,
 195                             Tests[i].SockType, 0, sizeof(SOCKADDR_IN));
 196                 ok_ptr(AddrInfo->ai_canonname, NULL);
 197                 ok_sockaddr_in(AddrInfo->ai_addr, AF_INET,
 198                                Tests[i].ExpectedPort, "127.0.0.1");
 199                 ok_ptr(AddrInfo->ai_next, NULL);
 200                 freeaddrinfo(AddrInfo);
 201             }
 202         EndSeh(STATUS_SUCCESS);
 203     }
 204 }
 205
 206 START_TEST(getaddrinfo)
 207 {
 208     WSADATA WsaData;
 209     int Error;
 210     PADDRINFOA AddrInfo;
 211     ADDRINFOA Hints;
 212     NTSTATUS ExceptionStatus;
 213     CHAR LocalHostName[128];
 214     struct hostent *Hostent;
 215
 216     /* not yet initialized */
 217     Error = getaddrinfo("127.0.0.1", "80", NULL, &AddrInfo);
 218     ok_dec(Error, WSANOTINITIALISED);
 219
 220     Error = WSAStartup(MAKEWORD(2, 2), &WsaData);
 221     ok_dec(Error, 0);
 222
 223     /* initialize LocalAddress for tests */
 224     Error = gethostname(LocalHostName, sizeof(LocalHostName));
 225     ok_dec(Error, 0);
 226     ok_dec(WSAGetLastError(), 0);
 227     trace("Local host name is '%s'\n", LocalHostName);
 228     Hostent = gethostbyname(LocalHostName);
 229     ok(Hostent != NULL, "gethostbyname failed with %d\n", WSAGetLastError());
 230     if (Hostent && Hostent->h_addr_list[0] && Hostent->h_length == sizeof(IN_ADDR))
 231     {
 232         IN_ADDR Address;
 233         memcpy(&Address, Hostent->h_addr_list[0], sizeof(Address));
 234         strcpy(LocalAddress, inet_ntoa(Address));
 235     }
 236     trace("Local address is '%s'\n", LocalAddress);
 237     ok(LocalAddress[0] != '\0',
 238        "Could not determine local address. Following test results may be wrong.\n");
 239
 240     ZeroMemory(&Hints, sizeof(Hints));
 241     /* parameter tests */
 242     StartSeh(); getaddrinfo(NULL, NULL, NULL, NULL); EndSeh(STATUS_ACCESS_VIOLATION);
 243     StartSeh(); getaddrinfo("", "", &Hints, NULL);   EndSeh(STATUS_ACCESS_VIOLATION);
 244     StartSeh();
 245         AddrInfo = InvalidPointer;
 246         Error = getaddrinfo(NULL, NULL, NULL, &AddrInfo);
 247         ok_dec(Error, WSAHOST_NOT_FOUND);
 248         ok_dec(WSAGetLastError(), WSAHOST_NOT_FOUND);
 249         ok_ptr(AddrInfo, NULL);
 250     EndSeh(STATUS_SUCCESS);
 251
 252     TestNodeName();
 253     TestServiceName();
 254     /* TODO: test passing both node name and service name */
 255     /* TODO: test hints */
 256     /* TODO: test IPv6 */
 257
 258     Error = WSACleanup();
 259     ok_dec(Error, 0);
 260
 261     /* not initialized anymore */
 262     Error = getaddrinfo("127.0.0.1", "80", NULL, &AddrInfo);
 263     ok_dec(Error, WSANOTINITIALISED);
 264 }