reactos/lib/msafd/misc/sndrcv.c

   1 /*
   2  * COPYRIGHT:   See COPYING in the top level directory
   3  * PROJECT:     ReactOS Ancillary Function Driver DLL
   4  * FILE:        misc/sndrcv.c
   5  * PURPOSE:     Send/receive routines
   6  * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
   7  * REVISIONS:
   8  *   CSH 01/09-2000 Created
   9  */
  10 #include <msafd.h>
  11
  12 INT
  13 WSPAPI
  14 WSPAsyncSelect(
  15     IN  SOCKET s,
  16     IN  HWND hWnd,
  17     IN  UINT wMsg,
  18     IN  LONG lEvent,
  19     OUT LPINT lpErrno)
  20 {
  21   UNIMPLEMENTED
  22
  23   return 0;
  24 }
  25
  26
  27 INT
  28 WSPAPI
  29 WSPRecv(
  30     IN      SOCKET s,
  31     IN OUT  LPWSABUF lpBuffers,
  32     IN      DWORD dwBufferCount,
  33     OUT     LPDWORD lpNumberOfBytesRecvd,
  34     IN OUT  LPDWORD lpFlags,
  35     IN      LPWSAOVERLAPPED lpOverlapped,
  36     IN      LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine,
  37     IN      LPWSATHREADID lpThreadId,
  38     OUT     LPINT lpErrno)
  39 {
  40   UNIMPLEMENTED
  41
  42   return 0;
  43 }
  44
  45
  46 INT
  47 WSPAPI
  48 WSPRecvDisconnect(
  49     IN  SOCKET s,
  50     OUT LPWSABUF lpInboundDisconnectData,
  51     OUT LPINT lpErrno)
  52 {
  53   UNIMPLEMENTED
  54
  55   return 0;
  56 }
  57
  58 INT
  59 WSPAPI
  60 WSPRecvFrom(
  61     IN      SOCKET s,
  62     IN OUT  LPWSABUF lpBuffers,
  63     IN      DWORD dwBufferCount,
  64     OUT     LPDWORD lpNumberOfBytesRecvd,
  65     IN OUT  LPDWORD lpFlags,
  66     OUT     LPSOCKADDR lpFrom,
  67     IN OUT  LPINT lpFromLen,
  68     IN      LPWSAOVERLAPPED lpOverlapped,
  69     IN      LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine,
  70     IN      LPWSATHREADID lpThreadId,
  71     OUT     LPINT lpErrno)
  72 {
  73   PFILE_REQUEST_RECVFROM Request;
  74   FILE_REPLY_RECVFROM Reply;
  75   IO_STATUS_BLOCK Iosb;
  76   NTSTATUS Status;
  77   DWORD Size;
  78
  79   AFD_DbgPrint(MAX_TRACE, ("Called.\n"));
  80
  81   Size = dwBufferCount * sizeof(WSABUF);
  82
  83   Request = (PFILE_REQUEST_RECVFROM)HeapAlloc(
  84     GlobalHeap, 0, sizeof(FILE_REQUEST_RECVFROM) + Size);
  85   if (!Request) {
  86     AFD_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
  87     *lpErrno = WSAENOBUFS;
  88     return SOCKET_ERROR;
  89   }
  90
  91   /* Put buffer pointers after request structure */
  92   Request->Buffers     = (LPWSABUF)(Request + sizeof(FILE_REQUEST_RECVFROM));
  93   Request->BufferCount = dwBufferCount;
  94   Request->Flags       = lpFlags;
  95   Request->From        = lpFrom;
  96   Request->FromLen     = lpFromLen;
  97
  98   RtlCopyMemory(Request->Buffers, lpBuffers, Size);
  99
 100   Status = NtDeviceIoControlFile((HANDLE)s,
 101     NULL,
 102                 NULL,
 103                 NULL,
 104                 &Iosb,
 105                 IOCTL_AFD_RECVFROM,
 106                 Request,
 107                 sizeof(FILE_REQUEST_RECVFROM) + Size,
 108                 &Reply,
 109                 sizeof(FILE_REPLY_RECVFROM));
 110
 111   HeapFree(GlobalHeap, 0, Request);
 112
 113         if (Status == STATUS_PENDING) {
 114     AFD_DbgPrint(MAX_TRACE, ("Waiting on transport.\n"));
 115     /* FIXME: Wait only for blocking sockets */
 116                 if (!NT_SUCCESS(NtWaitForSingleObject((HANDLE)s, FALSE, NULL))) {
 117       AFD_DbgPrint(MIN_TRACE, ("Wait failed.\n"));
 118       /* FIXME: What error code should be returned? */
 119                         *lpErrno = WSAENOBUFS;
 120                         return SOCKET_ERROR;
 121                 }
 122   }
 123
 124   if (!NT_SUCCESS(Status)) {
 125     AFD_DbgPrint(MAX_TRACE, ("Status (0x%X).\n", Status));
 126                 *lpErrno = WSAENOBUFS;
 127     return SOCKET_ERROR;
 128         }
 129
 130   AFD_DbgPrint(MAX_TRACE, ("Receive successful.\n"));
 131
 132   return 0;
 133 }
 134
 135
 136 INT
 137 WSPAPI
 138 WSPSend(
 139     IN  SOCKET s,
 140     IN  LPWSABUF lpBuffers,
 141     IN  DWORD dwBufferCount,
 142     OUT LPDWORD lpNumberOfBytesSent,
 143     IN  DWORD dwFlags,
 144     IN  LPWSAOVERLAPPED lpOverlapped,
 145     IN  LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine,
 146     IN  LPWSATHREADID lpThreadId,
 147     OUT LPINT lpErrno)
 148 {
 149   UNIMPLEMENTED
 150
 151   return 0;
 152 }
 153
 154
 155 INT
 156 WSPAPI
 157 WSPSendDisconnect(
 158     IN  SOCKET s,
 159     IN  LPWSABUF lpOutboundDisconnectData,
 160     OUT LPINT lpErrno)
 161 {
 162   UNIMPLEMENTED
 163
 164   return 0;
 165 }
 166
 167
 168 INT
 169 WSPAPI
 170 WSPSendTo(
 171     IN  SOCKET s,
 172     IN  LPWSABUF lpBuffers,
 173     IN  DWORD dwBufferCount,
 174     OUT LPDWORD lpNumberOfBytesSent,
 175     IN  DWORD dwFlags,
 176     IN  CONST LPSOCKADDR lpTo,
 177     IN  INT iToLen,
 178     IN  LPWSAOVERLAPPED lpOverlapped,
 179     IN  LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine,
 180     IN  LPWSATHREADID lpThreadId,
 181     OUT LPINT lpErrno)
 182 {
 183   PFILE_REQUEST_SENDTO Request;
 184   FILE_REPLY_SENDTO Reply;
 185   IO_STATUS_BLOCK Iosb;
 186   NTSTATUS Status;
 187   DWORD Size;
 188
 189   AFD_DbgPrint(MAX_TRACE, ("Called.\n"));
 190
 191   Size = dwBufferCount * sizeof(WSABUF);
 192
 193   Request = (PFILE_REQUEST_SENDTO)HeapAlloc(
 194     GlobalHeap, 0, sizeof(FILE_REQUEST_SENDTO) + Size);
 195   if (!Request) {
 196     AFD_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
 197     *lpErrno = WSAENOBUFS;
 198     return SOCKET_ERROR;
 199   }
 200
 201   /* Put buffer pointers after request structure */
 202   Request->Buffers     = (LPWSABUF)(Request + sizeof(FILE_REQUEST_SENDTO));
 203   Request->BufferCount = dwBufferCount;
 204   Request->Flags       = dwFlags;
 205   Request->ToLen       = iToLen;
 206
 207   RtlCopyMemory(&Request->To, lpTo, sizeof(SOCKADDR));
 208
 209   RtlCopyMemory(Request->Buffers, lpBuffers, Size);
 210
 211   Status = NtDeviceIoControlFile((HANDLE)s,
 212     NULL,
 213                 NULL,
 214                 NULL,
 215                 &Iosb,
 216                 IOCTL_AFD_SENDTO,
 217                 Request,
 218                 sizeof(FILE_REQUEST_SENDTO) + Size,
 219                 &Reply,
 220                 sizeof(FILE_REPLY_SENDTO));
 221
 222   HeapFree(GlobalHeap, 0, Request);
 223
 224         if (Status == STATUS_PENDING) {
 225     AFD_DbgPrint(MAX_TRACE, ("Waiting on transport.\n"));
 226     /* FIXME: Wait only for blocking sockets */
 227                 if (!NT_SUCCESS(NtWaitForSingleObject((HANDLE)s, FALSE, NULL))) {
 228       AFD_DbgPrint(MAX_TRACE, ("Wait failed.\n"));
 229       /* FIXME: What error code should be returned? */
 230       *lpErrno = WSAENOBUFS;
 231       return SOCKET_ERROR;
 232                 }
 233   }
 234
 235   if (!NT_SUCCESS(Status)) {
 236     AFD_DbgPrint(MAX_TRACE, ("Status (0x%X).\n", Status));
 237     *lpErrno = WSAENOBUFS;
 238     return SOCKET_ERROR;
 239   }
 240
 241   AFD_DbgPrint(MAX_TRACE, ("Send successful.\n"));
 242
 243   return 0;
 244 }
 245
 246 /* EOF */