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 }