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