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 "config.h"
38 #include "wine/port.h"
39
40 #include <stdarg.h>
41 #include "windef.h"
42 #include "winbase.h"
43 #include "wingdi.h"
44 #include "winuser.h"
45 #include "winsock2.h"
46 #include "ws2spi.h"
47
48 #include "wine/debug.h"
49
50 WINE_DEFAULT_DEBUG_CHANNEL(winsock);
51
52
53 struct async_query_header
54 {
55 HWND hWnd;
56 UINT uMsg;
57 void *sbuf;
58 INT sbuflen;
59 HANDLE handle;
60 };
61
62 struct async_query_gethostbyname
63 {
64 struct async_query_header query;
65 char *host_name;
66 };
67
68 struct async_query_gethostbyaddr
69 {
70 struct async_query_header query;
71 char *host_addr;
72 int host_len;
73 int host_type;
74 };
75
76 struct async_query_getprotobyname
77 {
78 struct async_query_header query;
79 char *proto_name;
80 };
81
82 struct async_query_getprotobynumber
83 {
84 struct async_query_header query;
85 int proto_number;
86 };
87
88 struct async_query_getservbyname
89 {
90 struct async_query_header query;
91 char *serv_name;
92 char *serv_proto;
93 };
94
95 struct async_query_getservbyport
96 {
97 struct async_query_header query;
98 char *serv_proto;
99 int serv_port;
100 };
101
102
103 /* ----------------------------------- helper functions - */
104
105 static int list_size(char** l, int item_size)
106 {
107 int i,j = 0;
108 if(l)
109 { for(i=0;l[i];i++)
110 j += (item_size) ? item_size : strlen(l[i]) + 1;
111 j += (i + 1) * sizeof(char*); }
112 return j;
113 }
114
115 static int list_dup(char** l_src, char* ref, int item_size)
116 {
117 char* p = ref;
118 char** l_to = (char**)ref;
119 int i,j,k;
120
121 for(j=0;l_src[j];j++) ;
122 p += (j + 1) * sizeof(char*);
123 for(i=0;i<j;i++)
124 { l_to[i] = p;
125 k = ( item_size ) ? item_size : strlen(l_src[i]) + 1;
126 memcpy(p, l_src[i], k); p += k; }
127 l_to[i] = NULL;
128 return (p - ref);
129 }
130
131 static DWORD finish_query( struct async_query_header *query, LPARAM lparam )
132 {
133 PostMessageW( query->hWnd, query->uMsg, (WPARAM)query->handle, lparam );
134 HeapFree( GetProcessHeap(), 0, query );
135 return 0;
136 }
137
138 /* ----- hostent */
139
140 static LPARAM copy_he(void *base, int size, const struct WS_hostent *he)
141 {
142 char *p;
143 int needed;
144 struct WS_hostent *to = base;
145
146 if (!he) return MAKELPARAM( 0, GetLastError() );
147
148 needed = sizeof(struct WS_hostent) + strlen(he->h_name) + 1 +
149 list_size(he->h_aliases, 0) +
150 list_size(he->h_addr_list, he->h_length );
151 if (size < needed) return MAKELPARAM( needed, WSAENOBUFS );
152
153 to->h_addrtype = he->h_addrtype;
154 to->h_length = he->h_length;
155 p = (char *)(to + 1);
156 to->h_name = p;
157 strcpy(p, he->h_name); p += strlen(p) + 1;
158 to->h_aliases = (char **)p;
159 p += list_dup(he->h_aliases, p, 0);
160 to->h_addr_list = (char **)p;
161 list_dup(he->h_addr_list, p, he->h_length);
162 return MAKELPARAM( needed, 0 );
163 }
164
165 static DWORD WINAPI async_gethostbyname(LPVOID arg)
166 {
167 struct async_query_gethostbyname *aq = arg;
168 struct WS_hostent *he = WS_gethostbyname( aq->host_name );
169
170 return finish_query( &aq->query, copy_he( aq->query.sbuf, aq->query.sbuflen, he ));
171 }
172
173 static DWORD WINAPI async_gethostbyaddr(LPVOID arg)
174 {
175 struct async_query_gethostbyaddr *aq = arg;
176 struct WS_hostent *he = WS_gethostbyaddr( aq->host_addr, aq->host_len, aq->host_type );
177
178 return finish_query( &aq->query, copy_he( aq->query.sbuf, aq->query.sbuflen, he ));
179 }
180
181 /* ----- protoent */
182
183 static LPARAM copy_pe(void *base, int size, const struct WS_protoent* pe)
184 {
185 char *p;
186 int needed;
187 struct WS_protoent *to = base;
188
189 if (!pe) return MAKELPARAM( 0, GetLastError() );
190
191 needed = sizeof(struct WS_protoent) + strlen(pe->p_name) + 1 + list_size(pe->p_aliases, 0);
192 if (size < needed) return MAKELPARAM( needed, WSAENOBUFS );
193
194 to->p_proto = pe->p_proto;
195 p = (char *)(to + 1);
196 to->p_name = p;
197 strcpy(p, pe->p_name); p += strlen(p) + 1;
198 to->p_aliases = (char **)p;
199 list_dup(pe->p_aliases, p, 0);
200 return MAKELPARAM( needed, 0 );
201 }
202
203 static DWORD WINAPI async_getprotobyname(LPVOID arg)
204 {
205 struct async_query_getprotobyname *aq = arg;
206 struct WS_protoent *pe = WS_getprotobyname( aq->proto_name );
207
208 return finish_query( &aq->query, copy_pe( aq->query.sbuf, aq->query.sbuflen, pe ));
209 }
210
211 static DWORD WINAPI async_getprotobynumber(LPVOID arg)
212 {
213 struct async_query_getprotobynumber *aq = arg;
214 struct WS_protoent *pe = WS_getprotobynumber( aq->proto_number );
215
216 return finish_query( &aq->query, copy_pe( aq->query.sbuf, aq->query.sbuflen, pe ));
217 }
218
219 /* ----- servent */
220
221 static LPARAM copy_se(void *base, int size, const struct WS_servent* se)
222 {
223 char *p;
224 int needed;
225 struct WS_servent *to = base;
226
227 if (!se) return MAKELPARAM( 0, GetLastError() );
228
229 needed = sizeof(struct WS_servent) + strlen(se->s_proto) + strlen(se->s_name) + 2 + list_size(se->s_aliases, 0);
230 if (size < needed) return MAKELPARAM( needed, WSAENOBUFS );
231
232 to->s_port = se->s_port;
233 p = (char *)(to + 1);
234 to->s_name = p;
235 strcpy(p, se->s_name); p += strlen(p) + 1;
236 to->s_proto = p;
237 strcpy(p, se->s_proto); p += strlen(p) + 1;
238 to->s_aliases = (char **)p;
239 list_dup(se->s_aliases, p, 0);
240 return MAKELPARAM( needed, 0 );
241 }
242
243 static DWORD WINAPI async_getservbyname(LPVOID arg)
244 {
245 struct async_query_getservbyname *aq = arg;
246 struct WS_servent *se = WS_getservbyname( aq->serv_name, aq->serv_proto );
247
248 return finish_query( &aq->query, copy_se( aq->query.sbuf, aq->query.sbuflen, se ));
249 }
250
251 static DWORD WINAPI async_getservbyport(LPVOID arg)
252 {
253 struct async_query_getservbyport *aq = arg;
254 struct WS_servent *se = WS_getservbyport( aq->serv_port, aq->serv_proto );
255
256 return finish_query( &aq->query, copy_se( aq->query.sbuf, aq->query.sbuflen, se ));
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, LPTHREAD_START_ROUTINE func,
268 struct async_query_header *query, void *sbuf, INT sbuflen )
269 {
270 static LONG next_handle = 0xdead;
271 HANDLE thread;
272 ULONG handle = LOWORD( InterlockedIncrement( &next_handle ));
273
274 /* avoid handle 0 */
275 while (!handle) handle = LOWORD( InterlockedIncrement( &next_handle ));
276
277 query->hWnd = hWnd;
278 query->uMsg = uMsg;
279 query->handle = UlongToHandle( handle );
280 query->sbuf = sbuf;
281 query->sbuflen = sbuflen;
282
283 thread = CreateThread( NULL, 0, func, query, 0, NULL );
284 if (!thread)
285 {
286 SetLastError( WSAEWOULDBLOCK );
287 return 0;
288 }
289 CloseHandle( thread );
290 return UlongToHandle( handle );
291 }
292
293
294 /***********************************************************************
295 * WSAAsyncGetHostByAddr (WS2_32.102)
296 */
297 HANDLE WINAPI WSAAsyncGetHostByAddr(HWND hWnd, UINT uMsg, LPCSTR addr,
298 INT len, INT type, LPSTR sbuf, INT buflen)
299 {
300 struct async_query_gethostbyaddr *aq;
301
302 TRACE("hwnd %p, msg %04x, addr %p[%i]\n", hWnd, uMsg, addr, len );
303
304 if (!(aq = HeapAlloc( GetProcessHeap(), 0, sizeof(*aq) + len )))
305 {
306 SetLastError( WSAEWOULDBLOCK );
307 return 0;
308 }
309 aq->host_addr = (char *)(aq + 1);
310 aq->host_len = len;
311 aq->host_type = type;
312 memcpy( aq->host_addr, addr, len );
313 return run_query( hWnd, uMsg, async_gethostbyaddr, &aq->query, sbuf, buflen );
314 }
315
316 /***********************************************************************
317 * WSAAsyncGetHostByName (WS2_32.103)
318 */
319 HANDLE WINAPI WSAAsyncGetHostByName(HWND hWnd, UINT uMsg, LPCSTR name,
320 LPSTR sbuf, INT buflen)
321 {
322 struct async_query_gethostbyname *aq;
323 unsigned int len = strlen(name) + 1;
324
325 TRACE("hwnd %p, msg %04x, host %s, buffer %i\n", hWnd, uMsg, debugstr_a(name), buflen );
326
327 if (!(aq = HeapAlloc( GetProcessHeap(), 0, sizeof(*aq) + len )))
328 {
329 SetLastError( WSAEWOULDBLOCK );
330 return 0;
331 }
332 aq->host_name = (char *)(aq + 1);
333 strcpy( aq->host_name, name );
334 return run_query( hWnd, uMsg, async_gethostbyname, &aq->query, sbuf, buflen );
335 }
336
337 /***********************************************************************
338 * WSAAsyncGetProtoByName (WS2_32.105)
339 */
340 HANDLE WINAPI WSAAsyncGetProtoByName(HWND hWnd, UINT uMsg, LPCSTR name,
341 LPSTR sbuf, INT buflen)
342 {
343 struct async_query_getprotobyname *aq;
344 unsigned int len = strlen(name) + 1;
345
346 TRACE("hwnd %p, msg %04x, proto %s, buffer %i\n", hWnd, uMsg, debugstr_a(name), buflen );
347
348 if (!(aq = HeapAlloc( GetProcessHeap(), 0, sizeof(*aq) + len )))
349 {
350 SetLastError( WSAEWOULDBLOCK );
351 return 0;
352 }
353 aq->proto_name = (char *)(aq + 1);
354 strcpy( aq->proto_name, name );
355 return run_query( hWnd, uMsg, async_getprotobyname, &aq->query, sbuf, buflen );
356 }
357
358
359 /***********************************************************************
360 * WSAAsyncGetProtoByNumber (WS2_32.104)
361 */
362 HANDLE WINAPI WSAAsyncGetProtoByNumber(HWND hWnd, UINT uMsg, INT number,
363 LPSTR sbuf, INT buflen)
364 {
365 struct async_query_getprotobynumber *aq;
366
367 TRACE("hwnd %p, msg %04x, num %i\n", hWnd, uMsg, number );
368
369 if (!(aq = HeapAlloc( GetProcessHeap(), 0, sizeof(*aq) )))
370 {
371 SetLastError( WSAEWOULDBLOCK );
372 return 0;
373 }
374 aq->proto_number = number;
375 return run_query( hWnd, uMsg, async_getprotobynumber, &aq->query, sbuf, buflen );
376 }
377
378 /***********************************************************************
379 * WSAAsyncGetServByName (WS2_32.107)
380 */
381 HANDLE WINAPI WSAAsyncGetServByName(HWND hWnd, UINT uMsg, LPCSTR name,
382 LPCSTR proto, LPSTR sbuf, INT buflen)
383 {
384 struct async_query_getservbyname *aq;
385 unsigned int len1 = strlen(name) + 1;
386 unsigned int len2 = strlen(proto) + 1;
387
388 TRACE("hwnd %p, msg %04x, name %s, proto %s\n", hWnd, uMsg, debugstr_a(name), debugstr_a(proto));
389
390 if (!(aq = HeapAlloc( GetProcessHeap(), 0, sizeof(*aq) + len1 + len2 )))
391 {
392 SetLastError( WSAEWOULDBLOCK );
393 return 0;
394 }
395 aq->serv_name = (char *)(aq + 1);
396 aq->serv_proto = aq->serv_name + len1;
397 strcpy( aq->serv_name, name );
398 strcpy( aq->serv_proto, proto );
399 return run_query( hWnd, uMsg, async_getservbyname, &aq->query, sbuf, buflen );
400 }
401
402 /***********************************************************************
403 * WSAAsyncGetServByPort (WS2_32.106)
404 */
405 HANDLE WINAPI WSAAsyncGetServByPort(HWND hWnd, UINT uMsg, INT port,
406 LPCSTR proto, LPSTR sbuf, INT buflen)
407 {
408 struct async_query_getservbyport *aq;
409 unsigned int len = strlen(proto) + 1;
410
411 TRACE("hwnd %p, msg %04x, port %i, proto %s\n", hWnd, uMsg, port, debugstr_a(proto));
412
413 if (!(aq = HeapAlloc( GetProcessHeap(), 0, sizeof(*aq) + len )))
414 {
415 SetLastError( WSAEWOULDBLOCK );
416 return 0;
417 }
418 aq->serv_proto = (char *)(aq + 1);
419 aq->serv_port = port;
420 strcpy( aq->serv_proto, proto );
421 return run_query( hWnd, uMsg, async_getservbyport, &aq->query, sbuf, buflen );
422 }
423
424 /***********************************************************************
425 * WSACancelAsyncRequest (WS2_32.108)
426 */
427 INT WINAPI WSACancelAsyncRequest(HANDLE hAsyncTaskHandle)
428 {
429 FIXME("(%p),stub\n", hAsyncTaskHandle);
430 return 0;
431 }
432
433 /***********************************************************************
434 * WSApSetPostRoutine (WS2_32.24)
435 */
436 INT WINAPI WSApSetPostRoutine(LPWPUPOSTMESSAGE lpPostRoutine)
437 {
438 FIXME("(%p), stub !\n", lpPostRoutine);
439 return 0;
440 }
441
442 /***********************************************************************
443 * WPUCompleteOverlappedRequest (WS2_32.25)
444 */
445 WSAEVENT WINAPI WPUCompleteOverlappedRequest(SOCKET s, LPWSAOVERLAPPED overlapped,
446 DWORD error, DWORD transferred, LPINT errcode)
447 {
448 FIXME("(0x%08lx,%p,0x%08x,0x%08x,%p), stub !\n", s, overlapped, error, transferred, errcode);
449
450 if (errcode)
451 *errcode = WSAEINVAL;
452
453 return NULL;
454 }
455
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.