reactos/dll/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 <roscfg.h>
  12 #include <w32api.h>
  13 #include <ws2_32.h>
  14 #include <catalog.h>
  15 #include <handle.h>
  16
  17
  18 /*
  19  * @implemented
  20  */
  21 INT
  22 EXPORT
  23 recv(
  24   IN  SOCKET s,
  25   OUT CHAR FAR* buf,
  26   IN  INT len,
  27   IN  INT flags)
  28 {
  29   DWORD Error;
  30   DWORD BytesReceived;
  31   WSABUF WSABuf;
  32
  33   WS_DbgPrint(MAX_TRACE, ("s (0x%X)  buf (0x%X)  len (0x%X) flags (0x%X).\n",
  34       s, buf, len, flags));
  35
  36   WSABuf.len = len;
  37   WSABuf.buf = (CHAR FAR*)buf;
  38
  39   Error = WSARecv(s, &WSABuf, 1, &BytesReceived, (LPDWORD)&flags, NULL, NULL);
  40
  41   if( Error ) return -1; else return BytesReceived;
  42 }
  43
  44
  45 /*
  46  * @implemented
  47  */
  48 INT
  49 EXPORT
  50 recvfrom(
  51   IN      SOCKET s,
  52   OUT     CHAR FAR* buf,
  53   IN      INT len,
  54   IN      INT flags,
  55   OUT     LPSOCKADDR from,
  56   IN OUT  INT FAR* fromlen)
  57 {
  58   DWORD Error;
  59   DWORD BytesReceived;
  60   WSABUF WSABuf;
  61
  62   WS_DbgPrint(MAX_TRACE, ("s (0x%X)  buf (0x%X)  len (0x%X) flags (0x%X).\n",
  63       s, buf, len, flags));
  64
  65   WSABuf.len = len;
  66   WSABuf.buf = (CHAR FAR*)buf;
  67
  68   Error = WSARecvFrom(s, &WSABuf, 1, &BytesReceived, (LPDWORD)&flags, from, fromlen, NULL, NULL);
  69
  70   if( Error ) return -1; else return BytesReceived;
  71 }
  72
  73
  74 /*
  75  * @implemented
  76  */
  77 INT
  78 EXPORT
  79 send(
  80   IN  SOCKET s,
  81   IN  CONST CHAR FAR* buf,
  82   IN  INT len,
  83   IN  INT flags)
  84 {
  85   DWORD BytesSent;
  86   DWORD Error;
  87   WSABUF WSABuf;
  88
  89   WS_DbgPrint(MAX_TRACE, ("s (0x%X)  buf (0x%X)  len (0x%X) flags (0x%X).\n",
  90       s, buf, len, flags));
  91
  92   WSABuf.len = len;
  93   WSABuf.buf = (CHAR FAR*)buf;
  94
  95   Error = WSASend(s, &WSABuf, 1, &BytesSent, flags, NULL, NULL);
  96
  97   if( Error ) {
  98       WS_DbgPrint(MAX_TRACE,("Reporting error %d\n", Error));
  99       return -1;
 100   } else {
 101       WS_DbgPrint(MAX_TRACE,("Read %d bytes\n", BytesSent));
 102       return BytesSent;
 103   }
 104 }
 105
 106
 107 /*
 108  * @implemented
 109  */
 110 INT
 111 EXPORT
 112 sendto(
 113   IN  SOCKET s,
 114   IN  CONST CHAR FAR* buf,
 115   IN  INT len,
 116   IN  INT flags,
 117   IN  CONST struct sockaddr *to,
 118   IN  INT tolen)
 119 {
 120   DWORD Error;
 121   DWORD BytesSent;
 122   WSABUF WSABuf;
 123
 124   WS_DbgPrint(MAX_TRACE, ("s (0x%X)  buf (0x%X)  len (0x%X) flags (0x%X).\n",
 125       s, buf, len, flags));
 126
 127   WSABuf.len = len;
 128   WSABuf.buf = (CHAR FAR*)buf;
 129
 130   Error = WSASendTo(s, &WSABuf, 1, &BytesSent, flags, to, tolen, NULL, NULL);
 131
 132   if( Error ) return -1; else return BytesSent;
 133 }
 134
 135
 136 /*
 137  * @implemented
 138  */
 139 INT
 140 EXPORT
 141 WSARecv(
 142   IN      SOCKET s,
 143   IN OUT  LPWSABUF lpBuffers,
 144   IN      DWORD dwBufferCount,
 145   OUT     LPDWORD lpNumberOfBytesRecvd,
 146   IN OUT  LPDWORD lpFlags,
 147   IN      LPWSAOVERLAPPED lpOverlapped,
 148   IN      LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
 149 {
 150   PCATALOG_ENTRY Provider;
 151   INT Errno;
 152   INT Code;
 153
 154   WS_DbgPrint(MAX_TRACE, ("Called.\n"));
 155
 156   if (!ReferenceProviderByHandle((HANDLE)s, &Provider)) {
 157     WSASetLastError(WSAENOTSOCK);
 158     return SOCKET_ERROR;
 159   }
 160
 161   assert(Provider->ProcTable.lpWSPRecv);
 162
 163   Code = Provider->ProcTable.lpWSPRecv(s, lpBuffers, dwBufferCount,
 164     lpNumberOfBytesRecvd, lpFlags, lpOverlapped,
 165     lpCompletionRoutine, NULL /* lpThreadId */, &Errno);
 166
 167   DereferenceProviderByPointer(Provider);
 168
 169   if (Code == SOCKET_ERROR)
 170     WSASetLastError(Errno);
 171
 172   return Code;
 173 }
 174
 175
 176 /*
 177  * @unimplemented
 178  */
 179 INT
 180 EXPORT
 181 WSARecvDisconnect(
 182   IN  SOCKET s,
 183   OUT LPWSABUF lpInboundDisconnectData)
 184 {
 185   UNIMPLEMENTED
 186
 187   return 0;
 188 }
 189
 190
 191 /*
 192  * @implemented
 193  */
 194 INT
 195 EXPORT
 196 WSARecvFrom(
 197   IN      SOCKET s,
 198   IN OUT  LPWSABUF lpBuffers,
 199   IN      DWORD dwBufferCount,
 200   OUT     LPDWORD lpNumberOfBytesRecvd,
 201   IN OUT  LPDWORD lpFlags,
 202   OUT       LPSOCKADDR lpFrom,
 203   IN OUT  LPINT lpFromlen,
 204   IN      LPWSAOVERLAPPED lpOverlapped,
 205   IN      LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
 206 {
 207   PCATALOG_ENTRY Provider;
 208   INT Errno;
 209   INT Code;
 210
 211   WS_DbgPrint(MAX_TRACE, ("Called.\n"));
 212
 213   if (!ReferenceProviderByHandle((HANDLE)s, &Provider)) {
 214     WSASetLastError(WSAENOTSOCK);
 215     return SOCKET_ERROR;
 216   }
 217
 218   assert(Provider->ProcTable.lpWSPRecvFrom);
 219
 220   Code = Provider->ProcTable.lpWSPRecvFrom(s, lpBuffers, dwBufferCount,
 221     lpNumberOfBytesRecvd, lpFlags, lpFrom, lpFromlen, lpOverlapped,
 222     lpCompletionRoutine, NULL /* lpThreadId */, &Errno);
 223
 224   DereferenceProviderByPointer(Provider);
 225
 226   if (Code == SOCKET_ERROR)
 227     WSASetLastError(Errno);
 228
 229   return Code;
 230 }
 231
 232
 233 /*
 234  * @implemented
 235  */
 236 INT
 237 EXPORT
 238 WSASend(
 239   IN  SOCKET s,
 240   IN  LPWSABUF lpBuffers,
 241   IN  DWORD dwBufferCount,
 242   OUT LPDWORD lpNumberOfBytesSent,
 243   IN  DWORD dwFlags,
 244   IN  LPWSAOVERLAPPED lpOverlapped,
 245   IN  LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
 246 {
 247   PCATALOG_ENTRY Provider;
 248   INT Errno;
 249   INT Code;
 250
 251   WS_DbgPrint(MAX_TRACE, ("Called.\n"));
 252
 253   if (!ReferenceProviderByHandle((HANDLE)s, &Provider)) {
 254     WSASetLastError(WSAENOTSOCK);
 255     return SOCKET_ERROR;
 256   }
 257
 258   assert(Provider->ProcTable.lpWSPSend);
 259
 260   Code = Provider->ProcTable.lpWSPSend(s, lpBuffers, dwBufferCount,
 261     lpNumberOfBytesSent, dwFlags, lpOverlapped,
 262     lpCompletionRoutine, NULL /* lpThreadId */, &Errno);
 263
 264   DereferenceProviderByPointer(Provider);
 265
 266   if (Code == SOCKET_ERROR)
 267     WSASetLastError(Errno);
 268
 269   return Code;
 270 }
 271
 272
 273 /*
 274  * @unimplemented
 275  */
 276 INT
 277 EXPORT
 278 WSASendDisconnect(
 279   IN  SOCKET s,
 280   IN  LPWSABUF lpOutboundDisconnectData)
 281 {
 282   UNIMPLEMENTED
 283
 284   return 0;
 285 }
 286
 287
 288 /*
 289  * @implemented
 290  */
 291 INT
 292 EXPORT
 293 WSASendTo(
 294   IN  SOCKET s,
 295   IN  LPWSABUF lpBuffers,
 296   IN  DWORD dwBufferCount,
 297   OUT LPDWORD lpNumberOfBytesSent,
 298   IN  DWORD dwFlags,
 299   IN  CONST struct sockaddr *lpTo,
 300   IN  INT iToLen,
 301   IN  LPWSAOVERLAPPED lpOverlapped,
 302   IN  LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
 303 {
 304   PCATALOG_ENTRY Provider;
 305   INT Errno;
 306   INT Code;
 307
 308   WS_DbgPrint(MAX_TRACE, ("Called.\n"));
 309
 310   if (!ReferenceProviderByHandle((HANDLE)s, &Provider)) {
 311     WSASetLastError(WSAENOTSOCK);
 312     return SOCKET_ERROR;
 313   }
 314
 315   assert(Provider->ProcTable.lpWSPSendTo);
 316
 317 #if (__W32API_MAJOR_VERSION < 2 || __W32API_MINOR_VERSION < 5)
 318   Code = Provider->ProcTable.lpWSPSendTo(s, lpBuffers, dwBufferCount,
 319     lpNumberOfBytesSent, dwFlags, (CONST LPSOCKADDR) lpTo, iToLen, lpOverlapped,
 320     lpCompletionRoutine, NULL /* lpThreadId */, &Errno);
 321 #else
 322   Code = Provider->ProcTable.lpWSPSendTo(s, lpBuffers, dwBufferCount,
 323     lpNumberOfBytesSent, dwFlags, lpTo, iToLen, lpOverlapped,
 324     lpCompletionRoutine, NULL /* lpThreadId */, &Errno);
 325 #endif /* __W32API_MAJOR_VERSION < 2 || __W32API_MINOR_VERSION < 5 */
 326
 327   DereferenceProviderByPointer(Provider);
 328
 329   if (Code == SOCKET_ERROR)
 330     WSASetLastError(Errno);
 331
 332   return Code;
 333 }
 334
 335 /* EOF */