[WS2_32] Revert r74669
[reactos.git] / reactos / dll / win32 / ws2_32 / src / socklife.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS WinSock 2 API
4 * FILE: dll/win32/ws2_32_new/src/socklife.c
5 * PURPOSE: Socket Lifetime Support
6 * PROGRAMMER: Alex Ionescu (alex@relsoft.net)
7 */
8
9 /* INCLUDES ******************************************************************/
10
11 #include <ws2_32.h>
12
13 #define NDEBUG
14 #include <debug.h>
15
16 /* FUNCTIONS *****************************************************************/
17
18 /*
19 * @implemented
20 */
21 SOCKET
22 WSAAPI
23 accept(IN SOCKET s,
24 OUT LPSOCKADDR addr,
25 OUT INT FAR* addrlen)
26 {
27 /* Let WSA do it */
28 return WSAAccept(s, addr, addrlen, NULL, 0);
29 }
30
31 /*
32 * @implemented
33 */
34 INT
35 WSAAPI
36 bind(IN SOCKET s,
37 IN CONST struct sockaddr *name,
38 IN INT namelen)
39 {
40 PWSSOCKET Socket;
41 INT Status;
42 INT ErrorCode;
43 DPRINT("bind: %lx, %p, %lx\n", s, name, namelen);
44
45 /* Check for WSAStartup */
46 if ((ErrorCode = WsQuickProlog()) == ERROR_SUCCESS)
47 {
48 /* Get the Socket Context */
49 if ((Socket = WsSockGetSocket(s)))
50 {
51 if (name && (namelen >= sizeof(*name)))
52 {
53 /* Make the call */
54 Status = Socket->Provider->Service.lpWSPBind(s,
55 name,
56 namelen,
57 &ErrorCode);
58 /* Deference the Socket Context */
59 WsSockDereference(Socket);
60
61 /* Return Provider Value */
62 if (Status == ERROR_SUCCESS) return Status;
63
64 /* If everything seemed fine, then the WSP call failed itself */
65 if (ErrorCode == NO_ERROR) ErrorCode = WSASYSCALLFAILURE;
66 }
67 else
68 {
69 /* Deference the Socket Context */
70 WsSockDereference(Socket);
71
72 /* name or namelen not valid */
73 ErrorCode = WSAEFAULT;
74 }
75 }
76 else
77 {
78 /* No Socket Context Found */
79 ErrorCode = WSAENOTSOCK;
80 }
81 }
82
83 /* Return with an Error */
84 SetLastError(ErrorCode);
85 return SOCKET_ERROR;
86 }
87
88 /*
89 * @implemented
90 */
91 INT
92 WSAAPI
93 closesocket(IN SOCKET s)
94 {
95 PWSSOCKET Socket;
96 INT Status;
97 INT ErrorCode;
98 DPRINT("closesocket: %lx\n", s);
99
100 /* Check for WSAStartup */
101 if ((ErrorCode = WsQuickProlog()) == ERROR_SUCCESS)
102 {
103 /* Get the Socket Context */
104 if ((Socket = WsSockGetSocket(s)))
105 {
106 /* Make the call */
107 Status = Socket->Provider->Service.lpWSPCloseSocket(s, &ErrorCode);
108
109 /* Check if this is a provider socket */
110 if ((Status == ERROR_SUCCESS) && (Socket->IsProvider))
111 {
112 /* Disassociate the handle */
113 if (WsSockDisassociateHandle(Socket) == ERROR_SUCCESS)
114 {
115 /* Deference the Socket Context */
116 WsSockDereference(Socket);
117 }
118
119 /* Remove the last reference */
120 WsSockDereference(Socket);
121
122 /* Return success if everything is OK */
123 if (ErrorCode == ERROR_SUCCESS) return ErrorCode;
124 }
125 }
126 else
127 {
128 /* No Socket Context Found */
129 ErrorCode = WSAENOTSOCK;
130 }
131 }
132
133 /* Return with an Error */
134 SetLastError(ErrorCode);
135 return SOCKET_ERROR;
136 }
137
138 /*
139 * @implemented
140 */
141 SOCKET
142 WSAAPI
143 socket(IN INT af,
144 IN INT type,
145 IN INT protocol)
146 {
147 PWSPROCESS Process;
148 PWSTHREAD Thread;
149 DWORD Flags = 0;
150 INT ErrorCode;
151 DPRINT("socket: %lx, %lx, %lx\n", af, type, protocol);
152
153 /* Enter prolog */
154 if ((ErrorCode = WsApiProlog(&Process, &Thread)) != ERROR_SUCCESS)
155 {
156 /* Fail here */
157 SetLastError(ErrorCode);
158 return INVALID_SOCKET;
159 }
160
161 /* Check the current open type and use overlapped if it's default */
162 if (!Thread->OpenType) Flags = WSA_FLAG_OVERLAPPED;
163
164 /* Make the protocol negative if this is NETBIOS */
165 if ((af == AF_NETBIOS) && (protocol > 0)) protocol *= -1;
166
167 /* Now let WSA handle it */
168 return WSASocketW(af, type, protocol, NULL, 0, Flags);
169 }
170
171 /*
172 * @unimplemented
173 */
174 INT
175 WSPAPI
176 WPUCloseSocketHandle(IN SOCKET s,
177 OUT LPINT lpErrno)
178 {
179 UNIMPLEMENTED;
180 return 0;
181 }
182
183 /*
184 * @unimplemented
185 */
186 SOCKET
187 WSPAPI
188 WPUCreateSocketHandle(IN DWORD dwCatalogEntryId,
189 IN DWORD_PTR dwContext,
190 OUT LPINT lpErrno)
191 {
192 UNIMPLEMENTED;
193 return (SOCKET)0;
194 }
195
196 /*
197 * @implemented
198 */
199 SOCKET
200 WSPAPI
201 WPUModifyIFSHandle(IN DWORD dwCatalogEntryId,
202 IN SOCKET ProposedHandle,
203 OUT LPINT lpErrno)
204 {
205 SOCKET Handle = INVALID_SOCKET;
206 DWORD ErrorCode = ERROR_SUCCESS;
207 PWSPROCESS Process;
208 PTCATALOG Catalog;
209 PTCATALOG_ENTRY Entry;
210 PWSSOCKET Socket;
211 DPRINT("WPUModifyIFSHandle: %lx, %lx\n", dwCatalogEntryId, ProposedHandle);
212
213 /* Get the current process */
214 if ((Process = WsGetProcess()))
215 {
216 /* Get the Transport Catalog */
217 if ((Catalog = WsProcGetTCatalog(Process)))
218 {
219 /* Get the entry for this ID */
220 ErrorCode = WsTcGetEntryFromCatalogEntryId(Catalog,
221 dwCatalogEntryId,
222 &Entry);
223 /* Check for success */
224 if (ErrorCode == ERROR_SUCCESS)
225 {
226 /* Create a socket object */
227 if ((Socket = WsSockAllocate()))
228 {
229 /* Initialize it */
230 WsSockInitialize(Socket, Entry);
231
232 /* Associate it */
233 ErrorCode = WsSockAssociateHandle(Socket,
234 ProposedHandle,
235 TRUE);
236 /* Check for success */
237 if (ErrorCode == ERROR_SUCCESS)
238 {
239 /* Return */
240 Handle = ProposedHandle;
241 *lpErrno = ERROR_SUCCESS;
242 }
243 else
244 {
245 /* Fail */
246 WsSockDereference(Socket);
247 *lpErrno = ErrorCode;
248 }
249
250 /* Dereference the extra count */
251 WsSockDereference(Socket);
252 }
253 else
254 {
255 /* No memory to allocate a socket */
256 *lpErrno = WSAENOBUFS;
257 }
258
259 /* Dereference the catalog entry */
260 WsTcEntryDereference(Entry);
261 }
262 else
263 {
264 /* Entry not found */
265 *lpErrno = ErrorCode;
266 }
267 }
268 else
269 {
270 /* Catalog not found */
271 *lpErrno = WSANOTINITIALISED;
272 }
273 }
274 else
275 {
276 /* Process not ready */
277 *lpErrno = WSANOTINITIALISED;
278 }
279
280 /* Return */
281 return Handle;
282 }
283
284 /*
285 * @unimplemented
286 */
287 INT
288 WSPAPI
289 WPUQuerySocketHandleContext(IN SOCKET s,
290 OUT PDWORD_PTR lpContext,
291 OUT LPINT lpErrno)
292 {
293 UNIMPLEMENTED;
294 return 0;
295 }
296
297 /*
298 * @implemented
299 */
300 SOCKET
301 WSAAPI
302 WSAAccept(IN SOCKET s,
303 OUT LPSOCKADDR addr,
304 IN OUT LPINT addrlen,
305 IN LPCONDITIONPROC lpfnCondition,
306 IN DWORD_PTR dwCallbackData)
307 {
308 PWSPROCESS Process;
309 PWSTHREAD Thread;
310 PWSSOCKET Socket;
311 DWORD OpenType;
312 INT ErrorCode;
313 SOCKET Status;
314 DPRINT("WSAAccept: %lx, %lx, %lx, %p\n", s, addr, addrlen, lpfnCondition);
315
316 /* Enter prolog */
317 if ((ErrorCode = WsApiProlog(&Process, &Thread)) == ERROR_SUCCESS)
318 {
319 /* Get the Socket Context */
320 if ((Socket = WsSockGetSocket(s)))
321 {
322 /* Get the old open type and set new one */
323 OpenType = Thread->OpenType;
324 Thread->OpenType = Socket->Overlapped ? 0 : SO_SYNCHRONOUS_NONALERT;
325
326 /* Make the call */
327 Status = Socket->Provider->Service.lpWSPAccept(s,
328 addr,
329 addrlen,
330 lpfnCondition,
331 dwCallbackData,
332 &ErrorCode);
333 /* Restore open type */
334 Thread->OpenType = OpenType;
335
336 /* Deference the Socket Context */
337 WsSockDereference(Socket);
338
339 /* Check if we got a valid socket */
340 if (Status != INVALID_SOCKET)
341 {
342 /* Check if we got a new socket */
343 if (Status != s)
344 {
345 /* Add a new reference */
346 WsSockAddApiReference(Status);
347 }
348
349 /* Return */
350 return Status;
351 }
352 }
353 else
354 {
355 /* No Socket Context Found */
356 ErrorCode = WSAENOTSOCK;
357 }
358 }
359
360 /* Return with an Error */
361 SetLastError(ErrorCode);
362 return INVALID_SOCKET;
363 }
364
365 /*
366 * @implemented
367 */
368 SOCKET
369 WSAAPI
370 WSAJoinLeaf(IN SOCKET s,
371 IN CONST struct sockaddr *name,
372 IN INT namelen,
373 IN LPWSABUF lpCallerData,
374 OUT LPWSABUF lpCalleeData,
375 IN LPQOS lpSQOS,
376 IN LPQOS lpGQOS,
377 IN DWORD dwFlags)
378 {
379 PWSPROCESS Process;
380 PWSTHREAD Thread;
381 PWSSOCKET Socket;
382 DWORD OpenType;
383 INT ErrorCode;
384 SOCKET Status;
385 DPRINT("WSAJoinLeaf: %lx, %lx, %lx\n", s, name, namelen);
386
387 /* Enter prolog */
388 if ((ErrorCode = WsApiProlog(&Process, &Thread)) == ERROR_SUCCESS)
389 {
390 /* Get the Socket Context */
391 if ((Socket = WsSockGetSocket(s)))
392 {
393 /* Get the old open type and set new one */
394 OpenType = Thread->OpenType;
395 Thread->OpenType = Socket->Overlapped ? 0 : SO_SYNCHRONOUS_NONALERT;
396
397 /* Make the call */
398 Status = Socket->Provider->Service.lpWSPJoinLeaf(s,
399 name,
400 namelen,
401 lpCallerData,
402 lpCalleeData,
403 lpSQOS,
404 lpGQOS,
405 dwFlags,
406 &ErrorCode);
407 /* Restore open type */
408 Thread->OpenType = OpenType;
409
410 /* Deference the Socket Context */
411 WsSockDereference(Socket);
412
413 /* Check if we got a valid socket */
414 if (Status != INVALID_SOCKET)
415 {
416 /* Check if we got a new socket */
417 if (Status != s)
418 {
419 /* Add a new reference */
420 WsSockAddApiReference(Status);
421 }
422
423 /* Return */
424 return Status;
425 }
426 }
427 else
428 {
429 /* No Socket Context Found */
430 ErrorCode = WSAENOTSOCK;
431 }
432 }
433
434 /* Return with an Error */
435 SetLastError(ErrorCode);
436 return INVALID_SOCKET;
437 }
438
439 /*
440 * @implemented
441 */
442 SOCKET
443 WSAAPI
444 WSASocketA(IN INT af,
445 IN INT type,
446 IN INT protocol,
447 IN LPWSAPROTOCOL_INFOA lpProtocolInfo,
448 IN GROUP g,
449 IN DWORD dwFlags)
450 {
451 WSAPROTOCOL_INFOW ProtocolInfoW;
452 LPWSAPROTOCOL_INFOW p = &ProtocolInfoW;
453
454 /* Convert Protocol Info to Wide */
455 if (lpProtocolInfo)
456 {
457 /* Copy the Data */
458 memcpy(&ProtocolInfoW,
459 lpProtocolInfo,
460 sizeof(WSAPROTOCOL_INFOA) - sizeof(CHAR) * (WSAPROTOCOL_LEN + 1));
461
462 /* Convert the String */
463 MultiByteToWideChar(CP_ACP,
464 0,
465 lpProtocolInfo->szProtocol,
466 -1,
467 ProtocolInfoW.szProtocol,
468 sizeof(ProtocolInfoW.szProtocol) / sizeof(WCHAR));
469 }
470 else
471 {
472 /* No Protocol Info Specified */
473 p = NULL;
474 }
475
476 /* Call the Unicode Function */
477 return WSASocketW(af,
478 type,
479 protocol,
480 p,
481 g,
482 dwFlags);
483 }
484
485 /*
486 * @implemented
487 */
488 SOCKET
489 WSAAPI
490 WSASocketW(IN INT af,
491 IN INT type,
492 IN INT protocol,
493 IN LPWSAPROTOCOL_INFOW lpProtocolInfo,
494 IN GROUP g,
495 IN DWORD dwFlags)
496 {
497 PWSPROCESS Process;
498 PWSTHREAD Thread;
499 INT ErrorCode;
500 PTCATALOG Catalog;
501 DWORD CatalogId;
502 PTCATALOG_ENTRY CatalogEntry;
503 LPWSAPROTOCOL_INFOW ProtocolInfo;
504 DWORD OpenType;
505 SOCKET Status = INVALID_SOCKET;
506 DPRINT("WSASocketW: %lx, %lx, %lx, %p\n", af, type, protocol, lpProtocolInfo);
507
508 /* Enter prolog */
509 if ((ErrorCode = WsApiProlog(&Process, &Thread)) != ERROR_SUCCESS)
510 {
511 /* Fail now */
512 SetLastError(ErrorCode);
513 return INVALID_SOCKET;
514 }
515
516 /* Get the catalog */
517 Catalog = WsProcGetTCatalog(Process);
518
519 /* Find a Provider for the Catalog ID */
520 if (lpProtocolInfo)
521 {
522 /* Get the catalog ID */
523 CatalogId = lpProtocolInfo->dwCatalogEntryId;
524
525 /* Get the Catalog Entry */
526 ErrorCode = WsTcGetEntryFromCatalogEntryId(Catalog,
527 CatalogId,
528 &CatalogEntry);
529 }
530 else
531 {
532 /* No ID */
533 CatalogId = 0;
534
535 DoLookup:
536 /* Get the Catalog Data from the Socket Info */
537 ErrorCode = WsTcGetEntryFromTriplet(Catalog,
538 af,
539 type,
540 protocol,
541 CatalogId,
542 &CatalogEntry);
543 }
544
545 /* Check for Success */
546 if (ErrorCode == ERROR_SUCCESS)
547 {
548 /* Use the default Protocol Info if none given */
549 ProtocolInfo = lpProtocolInfo ? lpProtocolInfo : &CatalogEntry->ProtocolInfo;
550
551 /* Save the open type and set new one */
552 OpenType = Thread->OpenType;
553 Thread->OpenType = (dwFlags & WSA_FLAG_OVERLAPPED) ?
554 0 : SO_SYNCHRONOUS_NONALERT;
555
556 /* Call the Provider to create the Socket */
557 Status = CatalogEntry->Provider->Service.lpWSPSocket(af,
558 type,
559 protocol,
560 ProtocolInfo,
561 g,
562 dwFlags,
563 &ErrorCode);
564 /* Restore open type */
565 Thread->OpenType = OpenType;
566
567 /* Get the catalog ID now, and dereference */
568 CatalogId = ProtocolInfo->dwCatalogEntryId;
569 WsTcEntryDereference(CatalogEntry);
570
571 /* Did we fail with WSAEINPROGRESS and had no specific provider? */
572 if ((Status == INVALID_SOCKET) &&
573 (ErrorCode == WSAEINPROGRESS) &&
574 !(lpProtocolInfo))
575 {
576 /* In that case, restart the lookup from this ID */
577 goto DoLookup;
578 }
579
580 /* Check if we got a valid socket */
581 if (Status != INVALID_SOCKET)
582 {
583 /* Add an API reference and return */
584 WsSockAddApiReference(Status);
585 return Status;
586 }
587 }
588
589 /* Return with an Error */
590 SetLastError(ErrorCode);
591 return INVALID_SOCKET;
592 }