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