dlls/ws2_32/async.c

   1 /* Async WINSOCK DNS services
   2  *
   3  * Copyright (C) 1993,1994,1996,1997 John Brezak, Erik Bos, Alex Korobka.
   4  * Copyright (C) 1999 Marcus Meissner
   5  * Copyright (C) 2009 Alexandre Julliard
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  *
  21  * NOTE: If you make any changes to fix a particular app, make sure
  22  * they don't break something else like Netscape or telnet and ftp
  23  * clients and servers (www.winsite.com got a lot of those).
  24  *
  25  * FIXME:
  26  *      - Add WSACancel* and correct handle management. (works rather well for
  27  *        now without it.)
  28  *      - Verify & Check all calls for correctness
  29  *        (currently only WSAGetHostByName*, WSAGetServByPort* calls)
  30  *      - Check error returns.
  31  *      - mirc/mirc32 Finger @linux.kernel.org sometimes fails in threaded mode.
  32  *        (not sure why)
  33  *      - This implementation did ignore the "NOTE:" section above (since the
  34  *        whole stuff did not work anyway to other changes).
  35  */
  36
  37 #include <stdarg.h>
  38 #include "windef.h"
  39 #include "winbase.h"
  40 #include "wingdi.h"
  41 #include "winuser.h"
  42 #include "winsock2.h"
  43 #include "ws2spi.h"
  44
  45 #include "wine/debug.h"
  46
  47 WINE_DEFAULT_DEBUG_CHANNEL(winsock);
  48
  49
  50 struct async_query_header
  51 {
  52     LPARAM (*func)( struct async_query_header *query );
  53     HWND   hWnd;
  54     UINT   uMsg;
  55     void  *sbuf;
  56     INT    sbuflen;
  57     HANDLE handle;
  58 };
  59
  60 struct async_query_gethostbyname
  61 {
  62     struct async_query_header query;
  63     char *host_name;
  64 };
  65
  66 struct async_query_gethostbyaddr
  67 {
  68     struct async_query_header query;
  69     char *host_addr;
  70     int   host_len;
  71     int   host_type;
  72 };
  73
  74 struct async_query_getprotobyname
  75 {
  76     struct async_query_header query;
  77     char *proto_name;
  78 };
  79
  80 struct async_query_getprotobynumber
  81 {
  82     struct async_query_header query;
  83     int   proto_number;
  84 };
  85
  86 struct async_query_getservbyname
  87 {
  88     struct async_query_header query;
  89     char *serv_name;
  90     char *serv_proto;
  91 };
  92
  93 struct async_query_getservbyport
  94 {
  95     struct async_query_header query;
  96     char *serv_proto;
  97     int   serv_port;
  98 };
  99
 100
 101 /* ----------------------------------- helper functions - */
 102
 103 static int list_size(char** l, int item_size)
 104 {
 105   int i,j = 0;
 106   if(l)
 107   { for(i=0;l[i];i++)
 108         j += (item_size) ? item_size : strlen(l[i]) + 1;
 109     j += (i + 1) * sizeof(char*); }
 110   return j;
 111 }
 112
 113 static int list_dup(char** l_src, char* ref, int item_size)
 114 {
 115    char*                p = ref;
 116    char**               l_to = (char**)ref;
 117    int                  i,j,k;
 118
 119    for(j=0;l_src[j];j++) ;
 120    p += (j + 1) * sizeof(char*);
 121    for(i=0;i<j;i++)
 122    { l_to[i] = p;
 123      k = ( item_size ) ? item_size : strlen(l_src[i]) + 1;
 124      memcpy(p, l_src[i], k); p += k; }
 125    l_to[i] = NULL;
 126    return (p - ref);
 127 }
 128
 129 /* ----- hostent */
 130
 131 static LPARAM copy_he(void *base, int size, const struct hostent *he)
 132 {
 133     char *p;
 134     int needed;
 135     struct hostent *to = base;
 136
 137     if (!he) return MAKELPARAM( 0, GetLastError() );
 138
 139     needed = sizeof(struct hostent) + strlen(he->h_name) + 1 +
 140                  list_size(he->h_aliases, 0) +
 141                  list_size(he->h_addr_list, he->h_length );
 142     if (size < needed) return MAKELPARAM( needed, WSAENOBUFS );
 143
 144     to->h_addrtype = he->h_addrtype;
 145     to->h_length = he->h_length;
 146     p = (char *)(to + 1);
 147     to->h_name = p;
 148     strcpy(p, he->h_name); p += strlen(p) + 1;
 149     to->h_aliases = (char **)p;
 150     p += list_dup(he->h_aliases, p, 0);
 151     to->h_addr_list = (char **)p;
 152     list_dup(he->h_addr_list, p, he->h_length);
 153     return MAKELPARAM( needed, 0 );
 154 }
 155
 156 static LPARAM async_gethostbyname( struct async_query_header *query )
 157 {
 158     struct async_query_gethostbyname *aq = CONTAINING_RECORD( query, struct async_query_gethostbyname, query );
 159     struct hostent *he = gethostbyname( aq->host_name );
 160
 161     return copy_he( query->sbuf, query->sbuflen, he );
 162 }
 163
 164 static LPARAM async_gethostbyaddr( struct async_query_header *query )
 165 {
 166     struct async_query_gethostbyaddr *aq = CONTAINING_RECORD( query, struct async_query_gethostbyaddr, query );
 167     struct hostent *he = gethostbyaddr( aq->host_addr, aq->host_len, aq->host_type );
 168
 169     return copy_he( query->sbuf, query->sbuflen, he );
 170 }
 171
 172 /* ----- protoent */
 173
 174 static LPARAM copy_pe( void *base, int size, const struct protoent *pe )
 175 {
 176     char *p;
 177     int needed;
 178     struct protoent *to = base;
 179
 180     if (!pe) return MAKELPARAM( 0, GetLastError() );
 181
 182     needed = sizeof(struct protoent) + strlen( pe->p_name ) + 1 + list_size( pe->p_aliases, 0 );
 183     if (size < needed) return MAKELPARAM( needed, WSAENOBUFS );
 184
 185     to->p_proto = pe->p_proto;
 186     p = (char *)(to + 1);
 187     to->p_name = p;
 188     strcpy(p, pe->p_name); p += strlen(p) + 1;
 189     to->p_aliases = (char **)p;
 190     list_dup(pe->p_aliases, p, 0);
 191     return MAKELPARAM( needed, 0 );
 192 }
 193
 194 static LPARAM async_getprotobyname( struct async_query_header *query )
 195 {
 196     struct async_query_getprotobyname *aq = CONTAINING_RECORD( query, struct async_query_getprotobyname, query );
 197     struct protoent *pe = getprotobyname( aq->proto_name );
 198
 199     return copy_pe( query->sbuf, query->sbuflen, pe );
 200 }
 201
 202 static LPARAM async_getprotobynumber( struct async_query_header *query )
 203 {
 204     struct async_query_getprotobynumber *aq = CONTAINING_RECORD( query, struct async_query_getprotobynumber, query );
 205     struct protoent *pe = getprotobynumber( aq->proto_number );
 206
 207     return copy_pe( query->sbuf, query->sbuflen, pe );
 208 }
 209
 210 /* ----- servent */
 211
 212 static LPARAM copy_se( void *base, int size, const struct servent *se )
 213 {
 214     char *p;
 215     int needed;
 216     struct servent *to = base;
 217
 218     if (!se) return MAKELPARAM( 0, GetLastError() );
 219
 220     needed = sizeof(struct servent) + strlen( se->s_proto ) + strlen( se->s_name ) + 2 + list_size( se->s_aliases, 0 );
 221     if (size < needed) return MAKELPARAM( needed, WSAENOBUFS );
 222
 223     to->s_port = se->s_port;
 224     p = (char *)(to + 1);
 225     to->s_name = p;
 226     strcpy(p, se->s_name); p += strlen(p) + 1;
 227     to->s_proto = p;
 228     strcpy(p, se->s_proto); p += strlen(p) + 1;
 229     to->s_aliases = (char **)p;
 230     list_dup(se->s_aliases, p, 0);
 231     return MAKELPARAM( needed, 0 );
 232 }
 233
 234 static LPARAM async_getservbyname( struct async_query_header *query )
 235 {
 236     struct async_query_getservbyname *aq = CONTAINING_RECORD( query, struct async_query_getservbyname, query );
 237     struct servent *se = getservbyname( aq->serv_name, aq->serv_proto );
 238
 239     return copy_se( query->sbuf, query->sbuflen, se );
 240 }
 241
 242 static LPARAM async_getservbyport( struct async_query_header *query )
 243 {
 244     struct async_query_getservbyport *aq = CONTAINING_RECORD( query, struct async_query_getservbyport, query );
 245     struct servent *se = getservbyport( aq->serv_port, aq->serv_proto );
 246
 247     return copy_se( query->sbuf, query->sbuflen, se );
 248 }
 249
 250
 251 static void WINAPI async_worker( TP_CALLBACK_INSTANCE *instance, void *context )
 252 {
 253     struct async_query_header *query = context;
 254     LPARAM lparam = query->func( query );
 255     PostMessageW( query->hWnd, query->uMsg, (WPARAM)query->handle, lparam );
 256     HeapFree( GetProcessHeap(), 0, query );
 257 }
 258
 259
 260 /****************************************************************************
 261  * The main async help function.
 262  *
 263  * It either starts a thread or just calls the function directly for platforms
 264  * with no thread support. This relies on the fact that PostMessage() does
 265  * not actually call the windowproc before the function returns.
 266  */
 267 static HANDLE run_query( HWND hWnd, UINT uMsg, LPARAM (*func)(struct async_query_header *),
 268                          struct async_query_header *query, void *sbuf, INT sbuflen )
 269 {
 270     static LONG next_handle = 0xdead;
 271     ULONG handle;
 272     do
 273         handle = LOWORD( InterlockedIncrement( &next_handle ));
 274     while (!handle); /* avoid handle 0 */
 275
 276     query->func    = func;
 277     query->hWnd    = hWnd;
 278     query->uMsg    = uMsg;
 279     query->handle  = UlongToHandle( handle );
 280     query->sbuf    = sbuf;
 281     query->sbuflen = sbuflen;
 282
 283     if (!TrySubmitThreadpoolCallback( async_worker, query, NULL ))
 284     {
 285         SetLastError( WSAEWOULDBLOCK );
 286         HeapFree( GetProcessHeap(), 0, query );
 287         return 0;
 288     }
 289     return UlongToHandle( handle );
 290 }
 291
 292
 293 /***********************************************************************
 294  *       WSAAsyncGetHostByAddr        (WS2_32.102)
 295  */
 296 HANDLE WINAPI WSAAsyncGetHostByAddr(HWND hWnd, UINT uMsg, LPCSTR addr,
 297                                INT len, INT type, LPSTR sbuf, INT buflen)
 298 {
 299     struct async_query_gethostbyaddr *aq;
 300
 301     TRACE("hwnd %p, msg %04x, addr %p[%i]\n", hWnd, uMsg, addr, len );
 302
 303     if (!(aq = HeapAlloc( GetProcessHeap(), 0, sizeof(*aq) + len )))
 304     {
 305         SetLastError( WSAEWOULDBLOCK );
 306         return 0;
 307     }
 308     aq->host_addr = (char *)(aq + 1);
 309     aq->host_len  = len;
 310     aq->host_type = type;
 311     memcpy( aq->host_addr, addr, len );
 312     return run_query( hWnd, uMsg, async_gethostbyaddr, &aq->query, sbuf, buflen );
 313 }
 314
 315 /***********************************************************************
 316  *       WSAAsyncGetHostByName  (WS2_32.103)
 317  */
 318 HANDLE WINAPI WSAAsyncGetHostByName(HWND hWnd, UINT uMsg, LPCSTR name,
 319                                         LPSTR sbuf, INT buflen)
 320 {
 321     struct async_query_gethostbyname *aq;
 322     unsigned int len = strlen(name) + 1;
 323
 324     TRACE("hwnd %p, msg %04x, host %s, buffer %i\n", hWnd, uMsg, debugstr_a(name), buflen );
 325
 326     if (!(aq = HeapAlloc( GetProcessHeap(), 0, sizeof(*aq) + len )))
 327     {
 328         SetLastError( WSAEWOULDBLOCK );
 329         return 0;
 330     }
 331     aq->host_name = (char *)(aq + 1);
 332     strcpy( aq->host_name, name );
 333     return run_query( hWnd, uMsg, async_gethostbyname, &aq->query, sbuf, buflen );
 334 }
 335
 336 /***********************************************************************
 337  *       WSAAsyncGetProtoByName       (WS2_32.105)
 338  */
 339 HANDLE WINAPI WSAAsyncGetProtoByName(HWND hWnd, UINT uMsg, LPCSTR name,
 340                                          LPSTR sbuf, INT buflen)
 341 {
 342     struct async_query_getprotobyname *aq;
 343     unsigned int len = strlen(name) + 1;
 344
 345     TRACE("hwnd %p, msg %04x, proto %s, buffer %i\n", hWnd, uMsg, debugstr_a(name), buflen );
 346
 347     if (!(aq = HeapAlloc( GetProcessHeap(), 0, sizeof(*aq) + len )))
 348     {
 349         SetLastError( WSAEWOULDBLOCK );
 350         return 0;
 351     }
 352     aq->proto_name = (char *)(aq + 1);
 353     strcpy( aq->proto_name, name );
 354     return run_query( hWnd, uMsg, async_getprotobyname, &aq->query, sbuf, buflen );
 355 }
 356
 357
 358 /***********************************************************************
 359  *       WSAAsyncGetProtoByNumber     (WS2_32.104)
 360  */
 361 HANDLE WINAPI WSAAsyncGetProtoByNumber(HWND hWnd, UINT uMsg, INT number,
 362                                            LPSTR sbuf, INT buflen)
 363 {
 364     struct async_query_getprotobynumber *aq;
 365
 366     TRACE("hwnd %p, msg %04x, num %i\n", hWnd, uMsg, number );
 367
 368     if (!(aq = HeapAlloc( GetProcessHeap(), 0, sizeof(*aq) )))
 369     {
 370         SetLastError( WSAEWOULDBLOCK );
 371         return 0;
 372     }
 373     aq->proto_number = number;
 374     return run_query( hWnd, uMsg, async_getprotobynumber, &aq->query, sbuf, buflen );
 375 }
 376
 377 /***********************************************************************
 378  *       WSAAsyncGetServByName        (WS2_32.107)
 379  */
 380 HANDLE WINAPI WSAAsyncGetServByName(HWND hWnd, UINT uMsg, LPCSTR name,
 381                                         LPCSTR proto, LPSTR sbuf, INT buflen)
 382 {
 383     struct async_query_getservbyname *aq;
 384     unsigned int len1 = strlen(name) + 1;
 385     unsigned int len2 = proto ? strlen(proto) + 1 : 0;
 386
 387     TRACE("hwnd %p, msg %04x, name %s, proto %s\n", hWnd, uMsg, debugstr_a(name), debugstr_a(proto));
 388
 389     if (!(aq = HeapAlloc( GetProcessHeap(), 0, sizeof(*aq) + len1 + len2 )))
 390     {
 391         SetLastError( WSAEWOULDBLOCK );
 392         return 0;
 393     }
 394
 395     aq->serv_name  = (char *)(aq + 1);
 396     strcpy( aq->serv_name, name );
 397
 398     if (proto)
 399     {
 400         aq->serv_proto = aq->serv_name + len1;
 401         strcpy( aq->serv_proto, proto );
 402     }
 403     else
 404         aq->serv_proto = NULL;
 405
 406     return run_query( hWnd, uMsg, async_getservbyname, &aq->query, sbuf, buflen );
 407 }
 408
 409 /***********************************************************************
 410  *       WSAAsyncGetServByPort        (WS2_32.106)
 411  */
 412 HANDLE WINAPI WSAAsyncGetServByPort(HWND hWnd, UINT uMsg, INT port,
 413                                         LPCSTR proto, LPSTR sbuf, INT buflen)
 414 {
 415     struct async_query_getservbyport *aq;
 416     unsigned int len = proto ? strlen(proto) + 1 : 0;
 417
 418     TRACE("hwnd %p, msg %04x, port %i, proto %s\n", hWnd, uMsg, port, debugstr_a(proto));
 419
 420     if (!(aq = HeapAlloc( GetProcessHeap(), 0, sizeof(*aq) + len )))
 421     {
 422         SetLastError( WSAEWOULDBLOCK );
 423         return 0;
 424     }
 425
 426     if (proto)
 427     {
 428         aq->serv_proto = (char *)(aq + 1);
 429         strcpy( aq->serv_proto, proto );
 430     }
 431     else
 432         aq->serv_proto = NULL;
 433
 434     aq->serv_port = port;
 435
 436     return run_query( hWnd, uMsg, async_getservbyport, &aq->query, sbuf, buflen );
 437 }
 438
 439 /***********************************************************************
 440  *       WSACancelAsyncRequest  (WS2_32.108)
 441  */
 442 INT WINAPI WSACancelAsyncRequest(HANDLE hAsyncTaskHandle)
 443 {
 444     FIXME("(%p),stub\n", hAsyncTaskHandle);
 445     return 0;
 446 }
 447
 448 /***********************************************************************
 449  *       WSApSetPostRoutine     (WS2_32.24)
 450  */
 451 INT WINAPI WSApSetPostRoutine(LPWPUPOSTMESSAGE lpPostRoutine)
 452 {
 453     FIXME("(%p), stub !\n", lpPostRoutine);
 454     return 0;
 455 }
 456
 457 /***********************************************************************
 458  *        WPUCompleteOverlappedRequest   (WS2_32.25)
 459  */
 460 WSAEVENT WINAPI WPUCompleteOverlappedRequest(SOCKET s, LPWSAOVERLAPPED overlapped,
 461                                              DWORD error, DWORD transferred, LPINT errcode)
 462 {
 463     FIXME("(0x%08lx,%p,0x%08x,0x%08x,%p), stub !\n", s, overlapped, error, transferred, errcode);
 464
 465     if (errcode)
 466         *errcode = WSAEINVAL;
 467
 468     return NULL;
 469 }