dll/win32/ws2_32/misc/sndrcv.c

   1 /*
   2  * COPYRIGHT:   See COPYING in the top level directory
   3  * PROJECT:     ReactOS WinSock 2 DLL
   4  * FILE:        misc/sndrcv.c
   5  * PURPOSE:     Send/receive functions
   6  * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
   7  * REVISIONS:
   8  *   CSH 01/09-2000 Created
   9  */
  10
  11 #include "ws2_32.h"
  12
  13 /*
  14  * @implemented
  15  */
  16 INT
  17 EXPORT
  18 recv(IN  SOCKET s,
  19      OUT CHAR FAR* buf,
  20      IN  INT len,
  21      IN  INT flags)
  22 {
  23     DWORD Error;
  24     DWORD BytesReceived;
  25     WSABUF WSABuf;
  26
  27     WS_DbgPrint(MAX_TRACE, ("s (0x%X)  buf (0x%X)  len (0x%X) flags (0x%X).\n",
  28                 s,
  29                 buf,
  30                 len,
  31                 flags));
  32
  33     WSABuf.len = len;
  34     WSABuf.buf = (CHAR FAR*)buf;
  35
  36     Error = WSARecv(s,
  37                     &WSABuf,
  38                     1,
  39                     &BytesReceived,
  40                     (LPDWORD)&flags,
  41                     NULL,
  42                     NULL);
  43
  44     if( Error )
  45         return -1;
  46     else
  47         return BytesReceived;
  48 }
  49
  50
  51 /*
  52  * @implemented
  53  */
  54 INT
  55 EXPORT
  56 recvfrom(IN      SOCKET s,
  57          OUT     CHAR FAR* buf,
  58          IN      INT len,
  59          IN      INT flags,
  60          OUT     LPSOCKADDR from,
  61          IN OUT  INT FAR* fromlen)
  62 {
  63     DWORD Error;
  64     DWORD BytesReceived;
  65     WSABUF WSABuf;
  66
  67     WS_DbgPrint(MAX_TRACE, ("s (0x%X)  buf (0x%X)  len (0x%X) flags (0x%X).\n",
  68                 s,
  69                 buf,
  70                 len,
  71                 flags));
  72
  73     WSABuf.len = len;
  74     WSABuf.buf = (CHAR FAR*)buf;
  75
  76     Error = WSARecvFrom(s,
  77                         &WSABuf,
  78                         1,
  79                         &BytesReceived,
  80                         (LPDWORD)&flags,
  81                         from,
  82                         fromlen,
  83                         NULL,
  84                         NULL);
  85
  86     if( Error )
  87         return -1;
  88     else
  89         return BytesReceived;
  90 }
  91
  92
  93 /*
  94  * @implemented
  95  */
  96 INT
  97 EXPORT
  98 send(IN  SOCKET s,
  99      IN  CONST CHAR FAR* buf,
 100      IN  INT len,
 101      IN  INT flags)
 102 {
 103     DWORD BytesSent;
 104     DWORD Error;
 105     WSABUF WSABuf;
 106
 107     WS_DbgPrint(MAX_TRACE, ("s (0x%X)  buf (0x%X)  len (0x%X) flags (0x%X).\n",
 108                 s,
 109                 buf,
 110                 len,
 111                 flags));
 112
 113     WSABuf.len = len;
 114     WSABuf.buf = (CHAR FAR*)buf;
 115
 116     Error = WSASend(s,
 117                     &WSABuf,
 118                     1,
 119                     &BytesSent,
 120                     flags,
 121                     NULL,
 122                     NULL);
 123
 124     if( Error )
 125     {
 126         WS_DbgPrint(MAX_TRACE,("Reporting error %d\n", Error));
 127         return -1;
 128     }
 129     else
 130     {
 131         WS_DbgPrint(MAX_TRACE,("Read %d bytes\n", BytesSent));
 132         return BytesSent;
 133     }
 134 }
 135
 136
 137 /*
 138  * @implemented
 139  */
 140 INT
 141 EXPORT
 142 sendto(IN  SOCKET s,
 143        IN  CONST CHAR FAR* buf,
 144        IN  INT len,
 145        IN  INT flags,
 146        IN  CONST struct sockaddr *to,
 147        IN  INT tolen)
 148 {
 149     DWORD Error;
 150     DWORD BytesSent;
 151     WSABUF WSABuf;
 152
 153     WS_DbgPrint(MAX_TRACE, ("s (0x%X)  buf (0x%X)  len (0x%X) flags (0x%X).\n",
 154                 s,
 155                 buf,
 156                 len,
 157                 flags));
 158
 159     WSABuf.len = len;
 160     WSABuf.buf = (CHAR FAR*)buf;
 161
 162     Error = WSASendTo(s,
 163                       &WSABuf,
 164                       1,
 165                       &BytesSent,
 166                       flags,
 167                       to,
 168                       tolen,
 169                       NULL,
 170                       NULL);
 171
 172     if( Error )
 173         return -1;
 174     else
 175         return BytesSent;
 176 }
 177
 178
 179 /*
 180  * @implemented
 181  */
 182 INT
 183 EXPORT
 184 WSARecv(IN      SOCKET s,
 185         IN OUT  LPWSABUF lpBuffers,
 186         IN      DWORD dwBufferCount,
 187         OUT     LPDWORD lpNumberOfBytesRecvd,
 188         IN OUT  LPDWORD lpFlags,
 189         IN      LPWSAOVERLAPPED lpOverlapped,
 190         IN      LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
 191 {
 192     PCATALOG_ENTRY Provider;
 193     INT Errno;
 194     INT Code;
 195
 196     WS_DbgPrint(MAX_TRACE, ("Called.\n"));
 197
 198     if (!ReferenceProviderByHandle((HANDLE)s,
 199                                    &Provider))
 200     {
 201         WSASetLastError(WSAENOTSOCK);
 202         return SOCKET_ERROR;
 203     }
 204
 205     assert(Provider->ProcTable.lpWSPRecv);
 206
 207     Code = Provider->ProcTable.lpWSPRecv(s,
 208                                          lpBuffers,
 209                                          dwBufferCount,
 210                                          lpNumberOfBytesRecvd,
 211                                          lpFlags,
 212                                          lpOverlapped,
 213                                          lpCompletionRoutine,
 214                                          NULL /* lpThreadId */,
 215                                          &Errno);
 216
 217     DereferenceProviderByPointer(Provider);
 218
 219     if (Code == SOCKET_ERROR)
 220         WSASetLastError(Errno);
 221
 222     return Code;
 223 }
 224
 225
 226 /*
 227  * @unimplemented
 228  */
 229 INT
 230 EXPORT
 231 WSARecvDisconnect(IN  SOCKET s,
 232                   OUT LPWSABUF lpInboundDisconnectData)
 233 {
 234     UNIMPLEMENTED
 235
 236     return 0;
 237 }
 238
 239
 240 /*
 241  * @implemented
 242  */
 243 INT
 244 EXPORT
 245 WSARecvFrom(IN      SOCKET s,
 246             IN OUT  LPWSABUF lpBuffers,
 247             IN      DWORD dwBufferCount,
 248             OUT     LPDWORD lpNumberOfBytesRecvd,
 249             IN OUT  LPDWORD lpFlags,
 250             OUT     LPSOCKADDR lpFrom,
 251             IN OUT  LPINT lpFromlen,
 252             IN      LPWSAOVERLAPPED lpOverlapped,
 253             IN      LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
 254 {
 255     PCATALOG_ENTRY Provider;
 256     INT Errno;
 257     INT Code;
 258
 259     WS_DbgPrint(MAX_TRACE, ("Called.\n"));
 260
 261     if (!ReferenceProviderByHandle((HANDLE)s, &Provider))
 262     {
 263         WSASetLastError(WSAENOTSOCK);
 264         return SOCKET_ERROR;
 265     }
 266
 267     assert(Provider->ProcTable.lpWSPRecvFrom);
 268
 269     Code = Provider->ProcTable.lpWSPRecvFrom(s,
 270                                              lpBuffers,
 271                                              dwBufferCount,
 272                                              lpNumberOfBytesRecvd,
 273                                              lpFlags,
 274                                              lpFrom,
 275                                              lpFromlen,
 276                                              lpOverlapped,
 277                                              lpCompletionRoutine,
 278                                              NULL /* lpThreadId */,
 279                                              &Errno);
 280
 281     DereferenceProviderByPointer(Provider);
 282
 283     if (Code == SOCKET_ERROR)
 284         WSASetLastError(Errno);
 285
 286     return Code;
 287 }
 288
 289
 290 /*
 291  * @implemented
 292  */
 293 INT
 294 EXPORT
 295 WSASend(IN  SOCKET s,
 296         IN  LPWSABUF lpBuffers,
 297         IN  DWORD dwBufferCount,
 298         OUT LPDWORD lpNumberOfBytesSent,
 299         IN  DWORD dwFlags,
 300         IN  LPWSAOVERLAPPED lpOverlapped,
 301         IN  LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
 302 {
 303     PCATALOG_ENTRY Provider;
 304     INT Errno;
 305     INT Code;
 306
 307     WS_DbgPrint(MAX_TRACE, ("Called.\n"));
 308
 309     if (!ReferenceProviderByHandle((HANDLE)s, &Provider))
 310     {
 311         WSASetLastError(WSAENOTSOCK);
 312         return SOCKET_ERROR;
 313     }
 314
 315     assert(Provider->ProcTable.lpWSPSend);
 316
 317     Code = Provider->ProcTable.lpWSPSend(s,
 318                                          lpBuffers,
 319                                          dwBufferCount,
 320                                          lpNumberOfBytesSent,
 321                                          dwFlags,
 322                                          lpOverlapped,
 323                                          lpCompletionRoutine,
 324                                          NULL /* lpThreadId */,
 325                                          &Errno);
 326
 327     DereferenceProviderByPointer(Provider);
 328
 329     if (Code == SOCKET_ERROR)
 330         WSASetLastError(Errno);
 331
 332     return Code;
 333 }
 334
 335
 336 /*
 337  * @unimplemented
 338  */
 339 INT
 340 EXPORT
 341 WSASendDisconnect(IN  SOCKET s,
 342                   IN  LPWSABUF lpOutboundDisconnectData)
 343 {
 344     UNIMPLEMENTED
 345
 346     return 0;
 347 }
 348
 349
 350 /*
 351  * @implemented
 352  */
 353 INT
 354 EXPORT
 355 WSASendTo(IN  SOCKET s,
 356           IN  LPWSABUF lpBuffers,
 357           IN  DWORD dwBufferCount,
 358           OUT LPDWORD lpNumberOfBytesSent,
 359           IN  DWORD dwFlags,
 360           IN  CONST struct sockaddr *lpTo,
 361           IN  INT iToLen,
 362           IN  LPWSAOVERLAPPED lpOverlapped,
 363           IN  LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
 364 {
 365     PCATALOG_ENTRY Provider;
 366     INT Errno;
 367     INT Code;
 368
 369     WS_DbgPrint(MAX_TRACE, ("Called.\n"));
 370
 371     if (!ReferenceProviderByHandle((HANDLE)s, &Provider))
 372     {
 373         WSASetLastError(WSAENOTSOCK);
 374         return SOCKET_ERROR;
 375     }
 376
 377     assert(Provider->ProcTable.lpWSPSendTo);
 378
 379 #if (__W32API_MAJOR_VERSION < 2 || __W32API_MINOR_VERSION < 5)
 380     Code = Provider->ProcTable.lpWSPSendTo(s,
 381                                            lpBuffers,
 382                                            dwBufferCount,
 383                                            lpNumberOfBytesSent,
 384                                            dwFlags,
 385                                            (CONST LPSOCKADDR)lpTo,
 386                                            iToLen,
 387                                            lpOverlapped,
 388                                            lpCompletionRoutine,
 389                                            NULL /* lpThreadId */,
 390                                            &Errno);
 391 #else
 392     Code = Provider->ProcTable.lpWSPSendTo(s,
 393                                            lpBuffers,
 394                                            dwBufferCount,
 395                                            lpNumberOfBytesSent,
 396                                            dwFlags,
 397                                            lpTo,
 398                                            iToLen,
 399                                            lpOverlapped,
 400                                            lpCompletionRoutine,
 401                                            NULL /* lpThreadId */,
 402                                            &Errno);
 403 #endif /* __W32API_MAJOR_VERSION < 2 || __W32API_MINOR_VERSION < 5 */
 404
 405     DereferenceProviderByPointer(Provider);
 406
 407     if (Code == SOCKET_ERROR)
 408         WSASetLastError(Errno);
 409     else
 410         WSASetLastError(0);
 411
 412     return Code;
 413 }
 414
 415 /* EOF */