ReactOS Fundraising Campaign 2012
 
€ 4,410 / € 30,000

Information | Donate

Home | Info | Community | Development | myReactOS | Contact Us

  1. Home
  2. Community
  3. Development
  4. myReactOS
  5. Fundraiser 2012

  1. Main Page
  2. Alphabetical List
  3. Data Structures
  4. Directories
  5. File List
  6. Data Fields
  7. Globals
  8. Related Pages

ReactOS Development > Doxygen

sndrcv.c
Go to the documentation of this file.
00001 /*
00002  * COPYRIGHT:   See COPYING in the top level directory
00003  * PROJECT:     ReactOS WinSock 2 DLL
00004  * FILE:        misc/sndrcv.c
00005  * PURPOSE:     Send/receive functions
00006  * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
00007  * REVISIONS:
00008  *   CSH 01/09-2000 Created
00009  */
00010 
00011 #include "ws2_32.h"
00012 
00013 /*
00014  * @implemented
00015  */
00016 INT
00017 EXPORT
00018 recv(IN  SOCKET s,
00019      OUT CHAR FAR* buf,
00020      IN  INT len,
00021      IN  INT flags)
00022 {
00023     DWORD Error;
00024     DWORD BytesReceived;
00025     WSABUF WSABuf;
00026 
00027     WS_DbgPrint(MAX_TRACE, ("s (0x%X)  buf (0x%X)  len (0x%X) flags (0x%X).\n",
00028                 s,
00029                 buf,
00030                 len,
00031                 flags));
00032 
00033     WSABuf.len = len;
00034     WSABuf.buf = (CHAR FAR*)buf;
00035 
00036     Error = WSARecv(s,
00037                     &WSABuf,
00038                     1,
00039                     &BytesReceived,
00040                     (LPDWORD)&flags,
00041                     NULL,
00042                     NULL);
00043 
00044     if( Error )
00045         return -1;
00046     else
00047         return BytesReceived;
00048 }
00049 
00050 
00051 /*
00052  * @implemented
00053  */
00054 INT
00055 EXPORT
00056 recvfrom(IN      SOCKET s,
00057          OUT     CHAR FAR* buf,
00058          IN      INT len,
00059          IN      INT flags,
00060          OUT     LPSOCKADDR from,
00061          IN OUT  INT FAR* fromlen)
00062 {
00063     DWORD Error;
00064     DWORD BytesReceived;
00065     WSABUF WSABuf;
00066 
00067     WS_DbgPrint(MAX_TRACE, ("s (0x%X)  buf (0x%X)  len (0x%X) flags (0x%X).\n",
00068                 s,
00069                 buf,
00070                 len,
00071                 flags));
00072 
00073     WSABuf.len = len;
00074     WSABuf.buf = (CHAR FAR*)buf;
00075 
00076     Error = WSARecvFrom(s,
00077                         &WSABuf,
00078                         1,
00079                         &BytesReceived,
00080                         (LPDWORD)&flags,
00081                         from,
00082                         fromlen,
00083                         NULL,
00084                         NULL);
00085 
00086     if( Error )
00087         return -1;
00088     else
00089         return BytesReceived;
00090 }
00091 
00092 
00093 /*
00094  * @implemented
00095  */
00096 INT
00097 EXPORT
00098 send(IN  SOCKET s,
00099      IN  CONST CHAR FAR* buf,
00100      IN  INT len,
00101      IN  INT flags)
00102 {
00103     DWORD BytesSent;
00104     DWORD Error;
00105     WSABUF WSABuf;
00106 
00107     WS_DbgPrint(MAX_TRACE, ("s (0x%X)  buf (0x%X)  len (0x%X) flags (0x%X).\n",
00108                 s,
00109                 buf,
00110                 len,
00111                 flags));
00112 
00113     WSABuf.len = len;
00114     WSABuf.buf = (CHAR FAR*)buf;
00115 
00116     Error = WSASend(s,
00117                     &WSABuf,
00118                     1,
00119                     &BytesSent,
00120                     flags,
00121                     NULL,
00122                     NULL);
00123 
00124     if( Error )
00125     {
00126         WS_DbgPrint(MAX_TRACE,("Reporting error %d\n", Error));
00127         return -1;
00128     }
00129     else
00130     {
00131         WS_DbgPrint(MAX_TRACE,("Read %d bytes\n", BytesSent));
00132         return BytesSent;
00133     }
00134 }
00135 
00136 
00137 /*
00138  * @implemented
00139  */
00140 INT
00141 EXPORT
00142 sendto(IN  SOCKET s,
00143        IN  CONST CHAR FAR* buf,
00144        IN  INT len,
00145        IN  INT flags,
00146        IN  CONST struct sockaddr *to,
00147        IN  INT tolen)
00148 {
00149     DWORD Error;
00150     DWORD BytesSent;
00151     WSABUF WSABuf;
00152 
00153     WS_DbgPrint(MAX_TRACE, ("s (0x%X)  buf (0x%X)  len (0x%X) flags (0x%X).\n",
00154                 s,
00155                 buf,
00156                 len,
00157                 flags));
00158 
00159     WSABuf.len = len;
00160     WSABuf.buf = (CHAR FAR*)buf;
00161 
00162     Error = WSASendTo(s,
00163                       &WSABuf,
00164                       1,
00165                       &BytesSent,
00166                       flags,
00167                       to,
00168                       tolen,
00169                       NULL,
00170                       NULL);
00171 
00172     if( Error )
00173         return -1;
00174     else
00175         return BytesSent;
00176 }
00177 
00178 
00179 /*
00180  * @implemented
00181  */
00182 INT
00183 EXPORT
00184 WSARecv(IN      SOCKET s,
00185         IN OUT  LPWSABUF lpBuffers,
00186         IN      DWORD dwBufferCount,
00187         OUT     LPDWORD lpNumberOfBytesRecvd,
00188         IN OUT  LPDWORD lpFlags,
00189         IN      LPWSAOVERLAPPED lpOverlapped,
00190         IN      LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
00191 {
00192     PCATALOG_ENTRY Provider;
00193     INT Errno;
00194     INT Code;
00195 
00196     WS_DbgPrint(MAX_TRACE, ("Called.\n"));
00197 
00198     if (!ReferenceProviderByHandle((HANDLE)s,
00199                                    &Provider))
00200     {
00201         WSASetLastError(WSAENOTSOCK);
00202         return SOCKET_ERROR;
00203     }
00204 
00205     assert(Provider->ProcTable.lpWSPRecv);
00206 
00207     Code = Provider->ProcTable.lpWSPRecv(s,
00208                                          lpBuffers,
00209                                          dwBufferCount,
00210                                          lpNumberOfBytesRecvd,
00211                                          lpFlags,
00212                                          lpOverlapped,
00213                                          lpCompletionRoutine,
00214                                          NULL /* lpThreadId */,
00215                                          &Errno);
00216 
00217     DereferenceProviderByPointer(Provider);
00218 
00219     if (Code == SOCKET_ERROR)
00220         WSASetLastError(Errno);
00221 
00222     return Code;
00223 }
00224 
00225 
00226 /*
00227  * @unimplemented
00228  */
00229 INT
00230 EXPORT
00231 WSARecvDisconnect(IN  SOCKET s,
00232                   OUT LPWSABUF lpInboundDisconnectData)
00233 {
00234     UNIMPLEMENTED
00235 
00236     return 0;
00237 }
00238 
00239 
00240 /*
00241  * @implemented
00242  */
00243 INT
00244 EXPORT
00245 WSARecvFrom(IN      SOCKET s,
00246             IN OUT  LPWSABUF lpBuffers,
00247             IN      DWORD dwBufferCount,
00248             OUT     LPDWORD lpNumberOfBytesRecvd,
00249             IN OUT  LPDWORD lpFlags,
00250             OUT     LPSOCKADDR lpFrom,
00251             IN OUT  LPINT lpFromlen,
00252             IN      LPWSAOVERLAPPED lpOverlapped,
00253             IN      LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
00254 {
00255     PCATALOG_ENTRY Provider;
00256     INT Errno;
00257     INT Code;
00258 
00259     WS_DbgPrint(MAX_TRACE, ("Called.\n"));
00260 
00261     if (!ReferenceProviderByHandle((HANDLE)s, &Provider))
00262     {
00263         WSASetLastError(WSAENOTSOCK);
00264         return SOCKET_ERROR;
00265     }
00266 
00267     assert(Provider->ProcTable.lpWSPRecvFrom);
00268 
00269     Code = Provider->ProcTable.lpWSPRecvFrom(s,
00270                                              lpBuffers,
00271                                              dwBufferCount,
00272                                              lpNumberOfBytesRecvd,
00273                                              lpFlags,
00274                                              lpFrom,
00275                                              lpFromlen,
00276                                              lpOverlapped,
00277                                              lpCompletionRoutine,
00278                                              NULL /* lpThreadId */,
00279                                              &Errno);
00280 
00281     DereferenceProviderByPointer(Provider);
00282 
00283     if (Code == SOCKET_ERROR)
00284         WSASetLastError(Errno);
00285 
00286     return Code;
00287 }
00288 
00289 
00290 /*
00291  * @implemented
00292  */
00293 INT
00294 EXPORT
00295 WSASend(IN  SOCKET s,
00296         IN  LPWSABUF lpBuffers,
00297         IN  DWORD dwBufferCount,
00298         OUT LPDWORD lpNumberOfBytesSent,
00299         IN  DWORD dwFlags,
00300         IN  LPWSAOVERLAPPED lpOverlapped,
00301         IN  LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
00302 {
00303     PCATALOG_ENTRY Provider;
00304     INT Errno;
00305     INT Code;
00306 
00307     WS_DbgPrint(MAX_TRACE, ("Called.\n"));
00308 
00309     if (!ReferenceProviderByHandle((HANDLE)s, &Provider))
00310     {
00311         WSASetLastError(WSAENOTSOCK);
00312         return SOCKET_ERROR;
00313     }
00314 
00315     assert(Provider->ProcTable.lpWSPSend);
00316 
00317     Code = Provider->ProcTable.lpWSPSend(s,
00318                                          lpBuffers,
00319                                          dwBufferCount,
00320                                          lpNumberOfBytesSent,
00321                                          dwFlags,
00322                                          lpOverlapped,
00323                                          lpCompletionRoutine,
00324                                          NULL /* lpThreadId */,
00325                                          &Errno);
00326 
00327     DereferenceProviderByPointer(Provider);
00328 
00329     if (Code == SOCKET_ERROR)
00330         WSASetLastError(Errno);
00331 
00332     return Code;
00333 }
00334 
00335 
00336 /*
00337  * @unimplemented
00338  */
00339 INT
00340 EXPORT
00341 WSASendDisconnect(IN  SOCKET s,
00342                   IN  LPWSABUF lpOutboundDisconnectData)
00343 {
00344     UNIMPLEMENTED
00345 
00346     return 0;
00347 }
00348 
00349 
00350 /*
00351  * @implemented
00352  */
00353 INT
00354 EXPORT
00355 WSASendTo(IN  SOCKET s,
00356           IN  LPWSABUF lpBuffers,
00357           IN  DWORD dwBufferCount,
00358           OUT LPDWORD lpNumberOfBytesSent,
00359           IN  DWORD dwFlags,
00360           IN  CONST struct sockaddr *lpTo,
00361           IN  INT iToLen,
00362           IN  LPWSAOVERLAPPED lpOverlapped,
00363           IN  LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
00364 {
00365     PCATALOG_ENTRY Provider;
00366     INT Errno;
00367     INT Code;
00368 
00369     WS_DbgPrint(MAX_TRACE, ("Called.\n"));
00370 
00371     if (!ReferenceProviderByHandle((HANDLE)s, &Provider))
00372     {
00373         WSASetLastError(WSAENOTSOCK);
00374         return SOCKET_ERROR;
00375     }
00376 
00377     assert(Provider->ProcTable.lpWSPSendTo);
00378 
00379 #if (__W32API_MAJOR_VERSION < 2 || __W32API_MINOR_VERSION < 5)
00380     Code = Provider->ProcTable.lpWSPSendTo(s,
00381                                            lpBuffers,
00382                                            dwBufferCount,
00383                                            lpNumberOfBytesSent,
00384                                            dwFlags,
00385                                            (CONST LPSOCKADDR)lpTo,
00386                                            iToLen,
00387                                            lpOverlapped,
00388                                            lpCompletionRoutine,
00389                                            NULL /* lpThreadId */,
00390                                            &Errno);
00391 #else
00392     Code = Provider->ProcTable.lpWSPSendTo(s,
00393                                            lpBuffers,
00394                                            dwBufferCount,
00395                                            lpNumberOfBytesSent,
00396                                            dwFlags,
00397                                            lpTo,
00398                                            iToLen,
00399                                            lpOverlapped,
00400                                            lpCompletionRoutine,
00401                                            NULL /* lpThreadId */,
00402                                            &Errno);
00403 #endif /* __W32API_MAJOR_VERSION < 2 || __W32API_MINOR_VERSION < 5 */
00404 
00405     DereferenceProviderByPointer(Provider);
00406 
00407     if (Code == SOCKET_ERROR)
00408         WSASetLastError(Errno);
00409     else
00410         WSASetLastError(0);
00411 
00412     return Code;
00413 }
00414 
00415 /* EOF */

Generated on Sat May 26 2012 04:23:20 for ReactOS by doxygen 1.7.6.1

ReactOS is a registered trademark or a trademark of ReactOS Foundation in the United States and other countries.