VirtualBox

source: vbox/trunk/src/VBox/Runtime/r3/socket.cpp@ 58389

Last change on this file since 58389 was 58389, checked in by vboxsync, 9 years ago

IPRT: Added RTSocketWriteToNB for non-blocking writes to UDP sockets without
locking the socket for exclusive use by the calling thread.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 65.5 KB
Line 
1/* $Id: socket.cpp 58389 2015-10-23 12:03:22Z vboxsync $ */
2/** @file
3 * IPRT - Network Sockets.
4 */
5
6/*
7 * Copyright (C) 2006-2015 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * The contents of this file may alternatively be used under the terms
18 * of the Common Development and Distribution License Version 1.0
19 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20 * VirtualBox OSE distribution, in which case the provisions of the
21 * CDDL are applicable instead of those of the GPL.
22 *
23 * You may elect to license modified versions of this file under the
24 * terms and conditions of either the GPL or the CDDL or both.
25 */
26
27
28/*********************************************************************************************************************************
29* Header Files *
30*********************************************************************************************************************************/
31#ifdef RT_OS_WINDOWS
32# include <winsock2.h>
33# include <ws2tcpip.h>
34#else /* !RT_OS_WINDOWS */
35# include <errno.h>
36# include <sys/select.h>
37# include <sys/stat.h>
38# include <sys/socket.h>
39# include <netinet/in.h>
40# include <netinet/tcp.h>
41# include <arpa/inet.h>
42# ifdef IPRT_WITH_TCPIP_V6
43# include <netinet6/in6.h>
44# endif
45# include <sys/un.h>
46# include <netdb.h>
47# include <unistd.h>
48# include <fcntl.h>
49# include <sys/uio.h>
50#endif /* !RT_OS_WINDOWS */
51#include <limits.h>
52
53#include "internal/iprt.h"
54#include <iprt/socket.h>
55
56#include <iprt/alloca.h>
57#include <iprt/asm.h>
58#include <iprt/assert.h>
59#include <iprt/ctype.h>
60#include <iprt/err.h>
61#include <iprt/mempool.h>
62#include <iprt/poll.h>
63#include <iprt/string.h>
64#include <iprt/thread.h>
65#include <iprt/time.h>
66#include <iprt/mem.h>
67#include <iprt/sg.h>
68#include <iprt/log.h>
69
70#include "internal/magics.h"
71#include "internal/socket.h"
72#include "internal/string.h"
73
74
75/*********************************************************************************************************************************
76* Defined Constants And Macros *
77*********************************************************************************************************************************/
78/* non-standard linux stuff (it seems). */
79#ifndef MSG_NOSIGNAL
80# define MSG_NOSIGNAL 0
81#endif
82
83/* Windows has different names for SHUT_XXX. */
84#ifndef SHUT_RDWR
85# ifdef SD_BOTH
86# define SHUT_RDWR SD_BOTH
87# else
88# define SHUT_RDWR 2
89# endif
90#endif
91#ifndef SHUT_WR
92# ifdef SD_SEND
93# define SHUT_WR SD_SEND
94# else
95# define SHUT_WR 1
96# endif
97#endif
98#ifndef SHUT_RD
99# ifdef SD_RECEIVE
100# define SHUT_RD SD_RECEIVE
101# else
102# define SHUT_RD 0
103# endif
104#endif
105
106/* fixup backlevel OSes. */
107#if defined(RT_OS_OS2) || defined(RT_OS_WINDOWS)
108# define socklen_t int
109#endif
110
111/** How many pending connection. */
112#define RTTCP_SERVER_BACKLOG 10
113
114/* Limit read and write sizes on Windows and OS/2. */
115#ifdef RT_OS_WINDOWS
116# define RTSOCKET_MAX_WRITE (INT_MAX / 2)
117# define RTSOCKET_MAX_READ (INT_MAX / 2)
118#elif defined(RT_OS_OS2)
119# define RTSOCKET_MAX_WRITE 0x10000
120# define RTSOCKET_MAX_READ 0x10000
121#endif
122
123
124/*********************************************************************************************************************************
125* Structures and Typedefs *
126*********************************************************************************************************************************/
127/**
128 * Socket handle data.
129 *
130 * This is mainly required for implementing RTPollSet on Windows.
131 */
132typedef struct RTSOCKETINT
133{
134 /** Magic number (RTSOCKET_MAGIC). */
135 uint32_t u32Magic;
136 /** Exclusive user count.
137 * This is used to prevent two threads from accessing the handle concurrently.
138 * It can be higher than 1 if this handle is reference multiple times in a
139 * polling set (Windows). */
140 uint32_t volatile cUsers;
141 /** The native socket handle. */
142 RTSOCKETNATIVE hNative;
143 /** Indicates whether the handle has been closed or not. */
144 bool volatile fClosed;
145 /** Indicates whether the socket is operating in blocking or non-blocking mode
146 * currently. */
147 bool fBlocking;
148#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
149 /** The pollset currently polling this socket. This is NIL if no one is
150 * polling. */
151 RTPOLLSET hPollSet;
152#endif
153#ifdef RT_OS_WINDOWS
154 /** The event semaphore we've associated with the socket handle.
155 * This is WSA_INVALID_EVENT if not done. */
156 WSAEVENT hEvent;
157 /** The events we're polling for. */
158 uint32_t fPollEvts;
159 /** The events we're currently subscribing to with WSAEventSelect.
160 * This is ZERO if we're currently not subscribing to anything. */
161 uint32_t fSubscribedEvts;
162 /** Saved events which are only posted once. */
163 uint32_t fEventsSaved;
164#endif /* RT_OS_WINDOWS */
165} RTSOCKETINT;
166
167
168/**
169 * Address union used internally for things like getpeername and getsockname.
170 */
171typedef union RTSOCKADDRUNION
172{
173 struct sockaddr Addr;
174 struct sockaddr_in IPv4;
175#ifdef IPRT_WITH_TCPIP_V6
176 struct sockaddr_in6 IPv6;
177#endif
178} RTSOCKADDRUNION;
179
180
181/**
182 * Get the last error as an iprt status code.
183 *
184 * @returns IPRT status code.
185 */
186DECLINLINE(int) rtSocketError(void)
187{
188#ifdef RT_OS_WINDOWS
189 return RTErrConvertFromWin32(WSAGetLastError());
190#else
191 return RTErrConvertFromErrno(errno);
192#endif
193}
194
195
196/**
197 * Resets the last error.
198 */
199DECLINLINE(void) rtSocketErrorReset(void)
200{
201#ifdef RT_OS_WINDOWS
202 WSASetLastError(0);
203#else
204 errno = 0;
205#endif
206}
207
208
209/**
210 * Get the last resolver error as an iprt status code.
211 *
212 * @returns iprt status code.
213 */
214DECLHIDDEN(int) rtSocketResolverError(void)
215{
216#ifdef RT_OS_WINDOWS
217 return RTErrConvertFromWin32(WSAGetLastError());
218#else
219 switch (h_errno)
220 {
221 case HOST_NOT_FOUND:
222 return VERR_NET_HOST_NOT_FOUND;
223 case NO_DATA:
224 return VERR_NET_ADDRESS_NOT_AVAILABLE;
225 case NO_RECOVERY:
226 return VERR_IO_GEN_FAILURE;
227 case TRY_AGAIN:
228 return VERR_TRY_AGAIN;
229
230 default:
231 return VERR_UNRESOLVED_ERROR;
232 }
233#endif
234}
235
236
237/**
238 * Converts from a native socket address to a generic IPRT network address.
239 *
240 * @returns IPRT status code.
241 * @param pSrc The source address.
242 * @param cbSrc The size of the source address.
243 * @param pAddr Where to return the generic IPRT network
244 * address.
245 */
246static int rtSocketNetAddrFromAddr(RTSOCKADDRUNION const *pSrc, size_t cbSrc, PRTNETADDR pAddr)
247{
248 /*
249 * Convert the address.
250 */
251 if ( cbSrc == sizeof(struct sockaddr_in)
252 && pSrc->Addr.sa_family == AF_INET)
253 {
254 RT_ZERO(*pAddr);
255 pAddr->enmType = RTNETADDRTYPE_IPV4;
256 pAddr->uPort = RT_N2H_U16(pSrc->IPv4.sin_port);
257 pAddr->uAddr.IPv4.u = pSrc->IPv4.sin_addr.s_addr;
258 }
259#ifdef IPRT_WITH_TCPIP_V6
260 else if ( cbSrc == sizeof(struct sockaddr_in6)
261 && pSrc->Addr.sa_family == AF_INET6)
262 {
263 RT_ZERO(*pAddr);
264 pAddr->enmType = RTNETADDRTYPE_IPV6;
265 pAddr->uPort = RT_N2H_U16(pSrc->IPv6.sin6_port);
266 pAddr->uAddr.IPv6.au32[0] = pSrc->IPv6.sin6_addr.s6_addr32[0];
267 pAddr->uAddr.IPv6.au32[1] = pSrc->IPv6.sin6_addr.s6_addr32[1];
268 pAddr->uAddr.IPv6.au32[2] = pSrc->IPv6.sin6_addr.s6_addr32[2];
269 pAddr->uAddr.IPv6.au32[3] = pSrc->IPv6.sin6_addr.s6_addr32[3];
270 }
271#endif
272 else
273 return VERR_NET_ADDRESS_FAMILY_NOT_SUPPORTED;
274 return VINF_SUCCESS;
275}
276
277
278/**
279 * Converts from a generic IPRT network address to a native socket address.
280 *
281 * @returns IPRT status code.
282 * @param pAddr Pointer to the generic IPRT network address.
283 * @param pDst The source address.
284 * @param cbDst The size of the source address.
285 * @param pcbAddr Where to store the size of the returned address.
286 * Optional
287 */
288static int rtSocketAddrFromNetAddr(PCRTNETADDR pAddr, RTSOCKADDRUNION *pDst, size_t cbDst, int *pcbAddr)
289{
290 RT_BZERO(pDst, cbDst);
291 if ( pAddr->enmType == RTNETADDRTYPE_IPV4
292 && cbDst >= sizeof(struct sockaddr_in))
293 {
294 pDst->Addr.sa_family = AF_INET;
295 pDst->IPv4.sin_port = RT_H2N_U16(pAddr->uPort);
296 pDst->IPv4.sin_addr.s_addr = pAddr->uAddr.IPv4.u;
297 if (pcbAddr)
298 *pcbAddr = sizeof(pDst->IPv4);
299 }
300#ifdef IPRT_WITH_TCPIP_V6
301 else if ( pAddr->enmType == RTNETADDRTYPE_IPV6
302 && cbDst >= sizeof(struct sockaddr_in6))
303 {
304 pDst->Addr.sa_family = AF_INET6;
305 pDst->IPv6.sin6_port = RT_H2N_U16(pAddr->uPort);
306 pSrc->IPv6.sin6_addr.s6_addr32[0] = pAddr->uAddr.IPv6.au32[0];
307 pSrc->IPv6.sin6_addr.s6_addr32[1] = pAddr->uAddr.IPv6.au32[1];
308 pSrc->IPv6.sin6_addr.s6_addr32[2] = pAddr->uAddr.IPv6.au32[2];
309 pSrc->IPv6.sin6_addr.s6_addr32[3] = pAddr->uAddr.IPv6.au32[3];
310 if (pcbAddr)
311 *pcbAddr = sizeof(pDst->IPv6);
312 }
313#endif
314 else
315 return VERR_NET_ADDRESS_FAMILY_NOT_SUPPORTED;
316 return VINF_SUCCESS;
317}
318
319
320/**
321 * Tries to lock the socket for exclusive usage by the calling thread.
322 *
323 * Call rtSocketUnlock() to unlock.
324 *
325 * @returns @c true if locked, @c false if not.
326 * @param pThis The socket structure.
327 */
328DECLINLINE(bool) rtSocketTryLock(RTSOCKETINT *pThis)
329{
330 return ASMAtomicCmpXchgU32(&pThis->cUsers, 1, 0);
331}
332
333
334/**
335 * Unlocks the socket.
336 *
337 * @param pThis The socket structure.
338 */
339DECLINLINE(void) rtSocketUnlock(RTSOCKETINT *pThis)
340{
341 ASMAtomicCmpXchgU32(&pThis->cUsers, 0, 1);
342}
343
344
345/**
346 * The slow path of rtSocketSwitchBlockingMode that does the actual switching.
347 *
348 * @returns IPRT status code.
349 * @param pThis The socket structure.
350 * @param fBlocking The desired mode of operation.
351 * @remarks Do not call directly.
352 */
353static int rtSocketSwitchBlockingModeSlow(RTSOCKETINT *pThis, bool fBlocking)
354{
355#ifdef RT_OS_WINDOWS
356 u_long uBlocking = fBlocking ? 0 : 1;
357 if (ioctlsocket(pThis->hNative, FIONBIO, &uBlocking))
358 return rtSocketError();
359
360#else
361 int fFlags = fcntl(pThis->hNative, F_GETFL, 0);
362 if (fFlags == -1)
363 return rtSocketError();
364
365 if (fBlocking)
366 fFlags &= ~O_NONBLOCK;
367 else
368 fFlags |= O_NONBLOCK;
369 if (fcntl(pThis->hNative, F_SETFL, fFlags) == -1)
370 return rtSocketError();
371#endif
372
373 pThis->fBlocking = fBlocking;
374 return VINF_SUCCESS;
375}
376
377
378/**
379 * Switches the socket to the desired blocking mode if necessary.
380 *
381 * The socket must be locked.
382 *
383 * @returns IPRT status code.
384 * @param pThis The socket structure.
385 * @param fBlocking The desired mode of operation.
386 */
387DECLINLINE(int) rtSocketSwitchBlockingMode(RTSOCKETINT *pThis, bool fBlocking)
388{
389 if (pThis->fBlocking != fBlocking)
390 return rtSocketSwitchBlockingModeSlow(pThis, fBlocking);
391 return VINF_SUCCESS;
392}
393
394
395/**
396 * Creates an IPRT socket handle for a native one.
397 *
398 * @returns IPRT status code.
399 * @param ppSocket Where to return the IPRT socket handle.
400 * @param hNative The native handle.
401 */
402DECLHIDDEN(int) rtSocketCreateForNative(RTSOCKETINT **ppSocket, RTSOCKETNATIVE hNative)
403{
404 RTSOCKETINT *pThis = (RTSOCKETINT *)RTMemPoolAlloc(RTMEMPOOL_DEFAULT, sizeof(*pThis));
405 if (!pThis)
406 return VERR_NO_MEMORY;
407 pThis->u32Magic = RTSOCKET_MAGIC;
408 pThis->cUsers = 0;
409 pThis->hNative = hNative;
410 pThis->fClosed = false;
411 pThis->fBlocking = true;
412#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
413 pThis->hPollSet = NIL_RTPOLLSET;
414#endif
415#ifdef RT_OS_WINDOWS
416 pThis->hEvent = WSA_INVALID_EVENT;
417 pThis->fPollEvts = 0;
418 pThis->fSubscribedEvts = 0;
419#endif
420 *ppSocket = pThis;
421 return VINF_SUCCESS;
422}
423
424
425RTDECL(int) RTSocketFromNative(PRTSOCKET phSocket, RTHCINTPTR uNative)
426{
427 AssertReturn(uNative != NIL_RTSOCKETNATIVE, VERR_INVALID_PARAMETER);
428#ifndef RT_OS_WINDOWS
429 AssertReturn(uNative >= 0, VERR_INVALID_PARAMETER);
430#endif
431 AssertPtrReturn(phSocket, VERR_INVALID_POINTER);
432 return rtSocketCreateForNative(phSocket, uNative);
433}
434
435
436/**
437 * Wrapper around socket().
438 *
439 * @returns IPRT status code.
440 * @param phSocket Where to store the handle to the socket on
441 * success.
442 * @param iDomain The protocol family (PF_XXX).
443 * @param iType The socket type (SOCK_XXX).
444 * @param iProtocol Socket parameter, usually 0.
445 */
446DECLHIDDEN(int) rtSocketCreate(PRTSOCKET phSocket, int iDomain, int iType, int iProtocol)
447{
448 /*
449 * Create the socket.
450 */
451 RTSOCKETNATIVE hNative = socket(iDomain, iType, iProtocol);
452 if (hNative == NIL_RTSOCKETNATIVE)
453 return rtSocketError();
454
455 /*
456 * Wrap it.
457 */
458 int rc = rtSocketCreateForNative(phSocket, hNative);
459 if (RT_FAILURE(rc))
460 {
461#ifdef RT_OS_WINDOWS
462 closesocket(hNative);
463#else
464 close(hNative);
465#endif
466 }
467 return rc;
468}
469
470
471RTDECL(uint32_t) RTSocketRetain(RTSOCKET hSocket)
472{
473 RTSOCKETINT *pThis = hSocket;
474 AssertPtrReturn(pThis, UINT32_MAX);
475 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, UINT32_MAX);
476 return RTMemPoolRetain(pThis);
477}
478
479
480/**
481 * Worker for RTSocketRelease and RTSocketClose.
482 *
483 * @returns IPRT status code.
484 * @param pThis The socket handle instance data.
485 * @param fDestroy Whether we're reaching ref count zero.
486 */
487static int rtSocketCloseIt(RTSOCKETINT *pThis, bool fDestroy)
488{
489 /*
490 * Invalidate the handle structure on destroy.
491 */
492 if (fDestroy)
493 {
494 Assert(ASMAtomicReadU32(&pThis->u32Magic) == RTSOCKET_MAGIC);
495 ASMAtomicWriteU32(&pThis->u32Magic, RTSOCKET_MAGIC_DEAD);
496 }
497
498 int rc = VINF_SUCCESS;
499 if (ASMAtomicCmpXchgBool(&pThis->fClosed, true, false))
500 {
501 /*
502 * Close the native handle.
503 */
504 RTSOCKETNATIVE hNative = pThis->hNative;
505 if (hNative != NIL_RTSOCKETNATIVE)
506 {
507 pThis->hNative = NIL_RTSOCKETNATIVE;
508
509#ifdef RT_OS_WINDOWS
510 if (closesocket(hNative))
511#else
512 if (close(hNative))
513#endif
514 {
515 rc = rtSocketError();
516#ifdef RT_OS_WINDOWS
517 AssertMsgFailed(("closesocket(%p) -> %Rrc\n", (uintptr_t)hNative, rc));
518#else
519 AssertMsgFailed(("close(%d) -> %Rrc\n", hNative, rc));
520#endif
521 }
522 }
523
524#ifdef RT_OS_WINDOWS
525 /*
526 * Close the event.
527 */
528 WSAEVENT hEvent = pThis->hEvent;
529 if (hEvent == WSA_INVALID_EVENT)
530 {
531 pThis->hEvent = WSA_INVALID_EVENT;
532 WSACloseEvent(hEvent);
533 }
534#endif
535 }
536
537 return rc;
538}
539
540
541RTDECL(uint32_t) RTSocketRelease(RTSOCKET hSocket)
542{
543 RTSOCKETINT *pThis = hSocket;
544 if (pThis == NIL_RTSOCKET)
545 return 0;
546 AssertPtrReturn(pThis, UINT32_MAX);
547 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, UINT32_MAX);
548
549 /* get the refcount without killing it... */
550 uint32_t cRefs = RTMemPoolRefCount(pThis);
551 AssertReturn(cRefs != UINT32_MAX, UINT32_MAX);
552 if (cRefs == 1)
553 rtSocketCloseIt(pThis, true);
554
555 return RTMemPoolRelease(RTMEMPOOL_DEFAULT, pThis);
556}
557
558
559RTDECL(int) RTSocketClose(RTSOCKET hSocket)
560{
561 RTSOCKETINT *pThis = hSocket;
562 if (pThis == NIL_RTSOCKET)
563 return VINF_SUCCESS;
564 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
565 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
566
567 uint32_t cRefs = RTMemPoolRefCount(pThis);
568 AssertReturn(cRefs != UINT32_MAX, UINT32_MAX);
569
570 int rc = rtSocketCloseIt(pThis, cRefs == 1);
571
572 RTMemPoolRelease(RTMEMPOOL_DEFAULT, pThis);
573 return rc;
574}
575
576
577RTDECL(RTHCUINTPTR) RTSocketToNative(RTSOCKET hSocket)
578{
579 RTSOCKETINT *pThis = hSocket;
580 AssertPtrReturn(pThis, RTHCUINTPTR_MAX);
581 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, RTHCUINTPTR_MAX);
582 return (RTHCUINTPTR)pThis->hNative;
583}
584
585
586RTDECL(int) RTSocketSetInheritance(RTSOCKET hSocket, bool fInheritable)
587{
588 RTSOCKETINT *pThis = hSocket;
589 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
590 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
591 AssertReturn(RTMemPoolRefCount(pThis) >= (pThis->cUsers ? 2U : 1U), VERR_CALLER_NO_REFERENCE);
592
593 int rc = VINF_SUCCESS;
594#ifdef RT_OS_WINDOWS
595 if (!SetHandleInformation((HANDLE)pThis->hNative, HANDLE_FLAG_INHERIT, fInheritable ? HANDLE_FLAG_INHERIT : 0))
596 rc = RTErrConvertFromWin32(GetLastError());
597#else
598 if (fcntl(pThis->hNative, F_SETFD, fInheritable ? 0 : FD_CLOEXEC) < 0)
599 rc = RTErrConvertFromErrno(errno);
600#endif
601
602 return rc;
603}
604
605
606static bool rtSocketIsIPv4Numerical(const char *pszAddress, PRTNETADDRIPV4 pAddr)
607{
608
609 /* Empty address resolves to the INADDR_ANY address (good for bind). */
610 if (!pszAddress || !*pszAddress)
611 {
612 pAddr->u = INADDR_ANY;
613 return true;
614 }
615
616 /* Four quads? */
617 char *psz = (char *)pszAddress;
618 for (int i = 0; i < 4; i++)
619 {
620 uint8_t u8;
621 int rc = RTStrToUInt8Ex(psz, &psz, 0, &u8);
622 if (rc != VINF_SUCCESS && rc != VWRN_TRAILING_CHARS)
623 return false;
624 if (*psz != (i < 3 ? '.' : '\0'))
625 return false;
626 psz++;
627
628 pAddr->au8[i] = u8; /* big endian */
629 }
630
631 return true;
632}
633
634RTDECL(int) RTSocketParseInetAddress(const char *pszAddress, unsigned uPort, PRTNETADDR pAddr)
635{
636 int rc;
637
638 /*
639 * Validate input.
640 */
641 AssertReturn(uPort > 0, VERR_INVALID_PARAMETER);
642 AssertPtrNullReturn(pszAddress, VERR_INVALID_POINTER);
643
644#ifdef RT_OS_WINDOWS
645 /*
646 * Initialize WinSock and check version.
647 */
648 WORD wVersionRequested = MAKEWORD(1, 1);
649 WSADATA wsaData;
650 rc = WSAStartup(wVersionRequested, &wsaData);
651 if (wsaData.wVersion != wVersionRequested)
652 {
653 AssertMsgFailed(("Wrong winsock version\n"));
654 return VERR_NOT_SUPPORTED;
655 }
656#endif
657
658 /*
659 * Resolve the address. Pretty crude at the moment, but we have to make
660 * sure to not ask the NT 4 gethostbyname about an IPv4 address as it may
661 * give a wrong answer.
662 */
663 /** @todo this only supports IPv4, and IPv6 support needs to be added.
664 * It probably needs to be converted to getaddrinfo(). */
665 RTNETADDRIPV4 IPv4Quad;
666 if (rtSocketIsIPv4Numerical(pszAddress, &IPv4Quad))
667 {
668 Log3(("rtSocketIsIPv4Numerical: %s -> %#x (%RTnaipv4)\n", pszAddress, IPv4Quad.u, IPv4Quad));
669 RT_ZERO(*pAddr);
670 pAddr->enmType = RTNETADDRTYPE_IPV4;
671 pAddr->uPort = uPort;
672 pAddr->uAddr.IPv4 = IPv4Quad;
673 return VINF_SUCCESS;
674 }
675
676 struct hostent *pHostEnt;
677 pHostEnt = gethostbyname(pszAddress);
678 if (!pHostEnt)
679 {
680 rc = rtSocketResolverError();
681 AssertMsgFailed(("Could not resolve '%s', rc=%Rrc\n", pszAddress, rc));
682 return rc;
683 }
684
685 if (pHostEnt->h_addrtype == AF_INET)
686 {
687 RT_ZERO(*pAddr);
688 pAddr->enmType = RTNETADDRTYPE_IPV4;
689 pAddr->uPort = uPort;
690 pAddr->uAddr.IPv4.u = ((struct in_addr *)pHostEnt->h_addr)->s_addr;
691 Log3(("gethostbyname: %s -> %#x (%RTnaipv4)\n", pszAddress, pAddr->uAddr.IPv4.u, pAddr->uAddr.IPv4));
692 }
693 else
694 return VERR_NET_ADDRESS_FAMILY_NOT_SUPPORTED;
695
696 return VINF_SUCCESS;
697}
698
699
700/*
701 * New function to allow both ipv4 and ipv6 addresses to be resolved.
702 * Breaks compatibility with windows before 2000.
703 */
704RTDECL(int) RTSocketQueryAddressStr(const char *pszHost, char *pszResult, size_t *pcbResult, PRTNETADDRTYPE penmAddrType)
705{
706 AssertPtrReturn(pszHost, VERR_INVALID_POINTER);
707 AssertPtrReturn(pcbResult, VERR_INVALID_POINTER);
708 AssertPtrNullReturn(penmAddrType, VERR_INVALID_POINTER);
709 AssertPtrNullReturn(pszResult, VERR_INVALID_POINTER);
710
711#if defined(RT_OS_OS2) || defined(RT_OS_WINDOWS) /** @todo dynamically resolve the APIs not present in NT4! */
712 return VERR_NOT_SUPPORTED;
713
714#else
715 int rc;
716 if (*pcbResult < 16)
717 return VERR_NET_ADDRESS_NOT_AVAILABLE;
718
719 /* Setup the hint. */
720 struct addrinfo grHints;
721 RT_ZERO(grHints);
722 grHints.ai_socktype = 0;
723 grHints.ai_flags = 0;
724 grHints.ai_protocol = 0;
725 grHints.ai_family = AF_UNSPEC;
726 if (penmAddrType)
727 {
728 switch (*penmAddrType)
729 {
730 case RTNETADDRTYPE_INVALID:
731 /*grHints.ai_family = AF_UNSPEC;*/
732 break;
733 case RTNETADDRTYPE_IPV4:
734 grHints.ai_family = AF_INET;
735 break;
736 case RTNETADDRTYPE_IPV6:
737 grHints.ai_family = AF_INET6;
738 break;
739 default:
740 AssertFailedReturn(VERR_INVALID_PARAMETER);
741 }
742 }
743
744# ifdef RT_OS_WINDOWS
745 /*
746 * Winsock2 init
747 */
748 /** @todo someone should check if we really need 2, 2 here */
749 WORD wVersionRequested = MAKEWORD(2, 2);
750 WSADATA wsaData;
751 rc = WSAStartup(wVersionRequested, &wsaData);
752 if (wsaData.wVersion != wVersionRequested)
753 {
754 AssertMsgFailed(("Wrong winsock version\n"));
755 return VERR_NOT_SUPPORTED;
756 }
757# endif
758
759 /** @todo r=bird: getaddrinfo and freeaddrinfo breaks the additions on NT4. */
760 struct addrinfo *pgrResults = NULL;
761 rc = getaddrinfo(pszHost, "", &grHints, &pgrResults);
762 if (rc != 0)
763 return VERR_NET_ADDRESS_NOT_AVAILABLE;
764
765 // return data
766 // on multiple matches return only the first one
767
768 if (!pgrResults)
769 return VERR_NET_ADDRESS_NOT_AVAILABLE;
770
771 struct addrinfo const *pgrResult = pgrResults->ai_next;
772 if (!pgrResult)
773 {
774 freeaddrinfo(pgrResults);
775 return VERR_NET_ADDRESS_NOT_AVAILABLE;
776 }
777
778 uint8_t const *pbDummy;
779 RTNETADDRTYPE enmAddrType = RTNETADDRTYPE_INVALID;
780 size_t cchIpAddress;
781 char szIpAddress[48];
782 if (pgrResult->ai_family == AF_INET)
783 {
784 struct sockaddr_in const *pgrSa = (struct sockaddr_in const *)pgrResult->ai_addr;
785 cchIpAddress = RTStrPrintf(szIpAddress, sizeof(szIpAddress),
786 "%RTnaipv4", pgrSa->sin_addr.s_addr);
787 Assert(cchIpAddress >= 7 && cchIpAddress < sizeof(szIpAddress) - 1);
788 enmAddrType = RTNETADDRTYPE_IPV4;
789 rc = VINF_SUCCESS;
790 }
791 else if (pgrResult->ai_family == AF_INET6)
792 {
793 struct sockaddr_in6 const *pgrSa6 = (struct sockaddr_in6 const *)pgrResult->ai_addr;
794 cchIpAddress = RTStrPrintf(szIpAddress, sizeof(szIpAddress),
795 "%RTnaipv6", (PRTNETADDRIPV6)&pgrSa6->sin6_addr);
796 enmAddrType = RTNETADDRTYPE_IPV6;
797 rc = VINF_SUCCESS;
798 }
799 else
800 {
801 rc = VERR_NET_ADDRESS_NOT_AVAILABLE;
802 szIpAddress[0] = '\0';
803 cchIpAddress = 0;
804 }
805 freeaddrinfo(pgrResults);
806
807 /*
808 * Copy out the result.
809 */
810 size_t const cbResult = *pcbResult;
811 *pcbResult = cchIpAddress + 1;
812 if (cchIpAddress < cbResult)
813 memcpy(pszResult, szIpAddress, cchIpAddress + 1);
814 else
815 {
816 RT_BZERO(pszResult, cbResult);
817 if (RT_SUCCESS(rc))
818 rc = VERR_BUFFER_OVERFLOW;
819 }
820 if (penmAddrType && RT_SUCCESS(rc))
821 *penmAddrType = enmAddrType;
822 return rc;
823#endif /* !RT_OS_OS2 */
824}
825
826
827RTDECL(int) RTSocketRead(RTSOCKET hSocket, void *pvBuffer, size_t cbBuffer, size_t *pcbRead)
828{
829 /*
830 * Validate input.
831 */
832 RTSOCKETINT *pThis = hSocket;
833 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
834 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
835 AssertReturn(cbBuffer > 0, VERR_INVALID_PARAMETER);
836 AssertPtr(pvBuffer);
837 AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
838
839 int rc = rtSocketSwitchBlockingMode(pThis, true /* fBlocking */);
840 if (RT_FAILURE(rc))
841 return rc;
842
843 /*
844 * Read loop.
845 * If pcbRead is NULL we have to fill the entire buffer!
846 */
847 size_t cbRead = 0;
848 size_t cbToRead = cbBuffer;
849 for (;;)
850 {
851 rtSocketErrorReset();
852#ifdef RTSOCKET_MAX_READ
853 int cbNow = cbToRead >= RTSOCKET_MAX_READ ? RTSOCKET_MAX_READ : (int)cbToRead;
854#else
855 size_t cbNow = cbToRead;
856#endif
857 ssize_t cbBytesRead = recv(pThis->hNative, (char *)pvBuffer + cbRead, cbNow, MSG_NOSIGNAL);
858 if (cbBytesRead <= 0)
859 {
860 rc = rtSocketError();
861 Assert(RT_FAILURE_NP(rc) || cbBytesRead == 0);
862 if (RT_SUCCESS_NP(rc))
863 {
864 if (!pcbRead)
865 rc = VERR_NET_SHUTDOWN;
866 else
867 {
868 *pcbRead = 0;
869 rc = VINF_SUCCESS;
870 }
871 }
872 break;
873 }
874 if (pcbRead)
875 {
876 /* return partial data */
877 *pcbRead = cbBytesRead;
878 break;
879 }
880
881 /* read more? */
882 cbRead += cbBytesRead;
883 if (cbRead == cbBuffer)
884 break;
885
886 /* next */
887 cbToRead = cbBuffer - cbRead;
888 }
889
890 rtSocketUnlock(pThis);
891 return rc;
892}
893
894
895RTDECL(int) RTSocketReadFrom(RTSOCKET hSocket, void *pvBuffer, size_t cbBuffer, size_t *pcbRead, PRTNETADDR pSrcAddr)
896{
897 /*
898 * Validate input.
899 */
900 RTSOCKETINT *pThis = hSocket;
901 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
902 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
903 AssertReturn(cbBuffer > 0, VERR_INVALID_PARAMETER);
904 AssertPtr(pvBuffer);
905 AssertPtr(pcbRead);
906 AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
907
908 int rc = rtSocketSwitchBlockingMode(pThis, true /* fBlocking */);
909 if (RT_FAILURE(rc))
910 return rc;
911
912 /*
913 * Read data.
914 */
915 size_t cbRead = 0;
916 size_t cbToRead = cbBuffer;
917 rtSocketErrorReset();
918 RTSOCKADDRUNION u;
919#ifdef RTSOCKET_MAX_READ
920 int cbNow = cbToRead >= RTSOCKET_MAX_READ ? RTSOCKET_MAX_READ : (int)cbToRead;
921 int cbAddr = sizeof(u);
922#else
923 size_t cbNow = cbToRead;
924 socklen_t cbAddr = sizeof(u);
925#endif
926 ssize_t cbBytesRead = recvfrom(pThis->hNative, (char *)pvBuffer + cbRead, cbNow, MSG_NOSIGNAL, &u.Addr, &cbAddr);
927 if (cbBytesRead <= 0)
928 {
929 rc = rtSocketError();
930 Assert(RT_FAILURE_NP(rc) || cbBytesRead == 0);
931 if (RT_SUCCESS_NP(rc))
932 {
933 *pcbRead = 0;
934 rc = VINF_SUCCESS;
935 }
936 }
937 else
938 {
939 if (pSrcAddr)
940 rc = rtSocketNetAddrFromAddr(&u, cbAddr, pSrcAddr);
941 *pcbRead = cbBytesRead;
942 }
943
944 rtSocketUnlock(pThis);
945 return rc;
946}
947
948
949RTDECL(int) RTSocketWrite(RTSOCKET hSocket, const void *pvBuffer, size_t cbBuffer)
950{
951 /*
952 * Validate input.
953 */
954 RTSOCKETINT *pThis = hSocket;
955 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
956 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
957 AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
958
959 int rc = rtSocketSwitchBlockingMode(pThis, true /* fBlocking */);
960 if (RT_FAILURE(rc))
961 return rc;
962
963 /*
964 * Try write all at once.
965 */
966#ifdef RTSOCKET_MAX_WRITE
967 int cbNow = cbBuffer >= RTSOCKET_MAX_WRITE ? RTSOCKET_MAX_WRITE : (int)cbBuffer;
968#else
969 size_t cbNow = cbBuffer >= SSIZE_MAX ? SSIZE_MAX : cbBuffer;
970#endif
971 ssize_t cbWritten = send(pThis->hNative, (const char *)pvBuffer, cbNow, MSG_NOSIGNAL);
972 if (RT_LIKELY((size_t)cbWritten == cbBuffer && cbWritten >= 0))
973 rc = VINF_SUCCESS;
974 else if (cbWritten < 0)
975 rc = rtSocketError();
976 else
977 {
978 /*
979 * Unfinished business, write the remainder of the request. Must ignore
980 * VERR_INTERRUPTED here if we've managed to send something.
981 */
982 size_t cbSentSoFar = 0;
983 for (;;)
984 {
985 /* advance */
986 cbBuffer -= (size_t)cbWritten;
987 if (!cbBuffer)
988 break;
989 cbSentSoFar += (size_t)cbWritten;
990 pvBuffer = (char const *)pvBuffer + cbWritten;
991
992 /* send */
993#ifdef RTSOCKET_MAX_WRITE
994 cbNow = cbBuffer >= RTSOCKET_MAX_WRITE ? RTSOCKET_MAX_WRITE : (int)cbBuffer;
995#else
996 cbNow = cbBuffer >= SSIZE_MAX ? SSIZE_MAX : cbBuffer;
997#endif
998 cbWritten = send(pThis->hNative, (const char *)pvBuffer, cbNow, MSG_NOSIGNAL);
999 if (cbWritten >= 0)
1000 AssertMsg(cbBuffer >= (size_t)cbWritten, ("Wrote more than we requested!!! cbWritten=%zu cbBuffer=%zu rtSocketError()=%d\n",
1001 cbWritten, cbBuffer, rtSocketError()));
1002 else
1003 {
1004 rc = rtSocketError();
1005 if (rc != VERR_INTERNAL_ERROR || cbSentSoFar == 0)
1006 break;
1007 cbWritten = 0;
1008 rc = VINF_SUCCESS;
1009 }
1010 }
1011 }
1012
1013 rtSocketUnlock(pThis);
1014 return rc;
1015}
1016
1017
1018RTDECL(int) RTSocketWriteTo(RTSOCKET hSocket, const void *pvBuffer, size_t cbBuffer, PCRTNETADDR pAddr)
1019{
1020 /*
1021 * Validate input.
1022 */
1023 RTSOCKETINT *pThis = hSocket;
1024 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1025 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
1026
1027 /* no locking since UDP reads may be done concurrently to writes, and
1028 * this is the normal use case of this code. */
1029
1030 int rc = rtSocketSwitchBlockingMode(pThis, true /* fBlocking */);
1031 if (RT_FAILURE(rc))
1032 return rc;
1033
1034 /* Figure out destination address. */
1035 struct sockaddr *pSA = NULL;
1036#ifdef RT_OS_WINDOWS
1037 int cbSA = 0;
1038#else
1039 socklen_t cbSA = 0;
1040#endif
1041 RTSOCKADDRUNION u;
1042 if (pAddr)
1043 {
1044 rc = rtSocketAddrFromNetAddr(pAddr, &u, sizeof(u), NULL);
1045 if (RT_FAILURE(rc))
1046 return rc;
1047 pSA = &u.Addr;
1048 cbSA = sizeof(u);
1049 }
1050
1051 /*
1052 * Must write all at once, otherwise it is a failure.
1053 */
1054#ifdef RT_OS_WINDOWS
1055 int cbNow = cbBuffer >= RTSOCKET_MAX_WRITE ? RTSOCKET_MAX_WRITE : (int)cbBuffer;
1056#else
1057 size_t cbNow = cbBuffer >= SSIZE_MAX ? SSIZE_MAX : cbBuffer;
1058#endif
1059 ssize_t cbWritten = sendto(pThis->hNative, (const char *)pvBuffer, cbNow, MSG_NOSIGNAL, pSA, cbSA);
1060 if (RT_LIKELY((size_t)cbWritten == cbBuffer && cbWritten >= 0))
1061 rc = VINF_SUCCESS;
1062 else if (cbWritten < 0)
1063 rc = rtSocketError();
1064 else
1065 rc = VERR_TOO_MUCH_DATA;
1066
1067 rtSocketUnlock(pThis);
1068 return rc;
1069}
1070
1071
1072RTDECL(int) RTSocketWriteToNB(RTSOCKET hSocket, const void *pvBuffer, size_t cbBuffer, PCRTNETADDR pAddr)
1073{
1074 /*
1075 * Validate input.
1076 */
1077 RTSOCKETINT *pThis = hSocket;
1078 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1079 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
1080
1081 /* no locking since UDP reads may be done concurrently to writes, and
1082 * this is the normal use case of this code. */
1083
1084 int rc = rtSocketSwitchBlockingMode(pThis, false /* fBlocking */);
1085 if (RT_FAILURE(rc))
1086 return rc;
1087
1088 /* Figure out destination address. */
1089 struct sockaddr *pSA = NULL;
1090#ifdef RT_OS_WINDOWS
1091 int cbSA = 0;
1092#else
1093 socklen_t cbSA = 0;
1094#endif
1095 RTSOCKADDRUNION u;
1096 if (pAddr)
1097 {
1098 rc = rtSocketAddrFromNetAddr(pAddr, &u, sizeof(u), NULL);
1099 if (RT_FAILURE(rc))
1100 return rc;
1101 pSA = &u.Addr;
1102 cbSA = sizeof(u);
1103 }
1104
1105 /*
1106 * Must write all at once, otherwise it is a failure.
1107 */
1108#ifdef RT_OS_WINDOWS
1109 int cbNow = cbBuffer >= RTSOCKET_MAX_WRITE ? RTSOCKET_MAX_WRITE : (int)cbBuffer;
1110#else
1111 size_t cbNow = cbBuffer >= SSIZE_MAX ? SSIZE_MAX : cbBuffer;
1112#endif
1113 ssize_t cbWritten = sendto(pThis->hNative, (const char *)pvBuffer, cbNow, MSG_NOSIGNAL, pSA, cbSA);
1114 if (RT_LIKELY((size_t)cbWritten == cbBuffer && cbWritten >= 0))
1115 rc = VINF_SUCCESS;
1116 else if (cbWritten < 0)
1117 rc = rtSocketError();
1118 else
1119 rc = VERR_TOO_MUCH_DATA;
1120
1121 rtSocketUnlock(pThis);
1122 return rc;
1123}
1124
1125
1126RTDECL(int) RTSocketSgWrite(RTSOCKET hSocket, PCRTSGBUF pSgBuf)
1127{
1128 /*
1129 * Validate input.
1130 */
1131 RTSOCKETINT *pThis = hSocket;
1132 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1133 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
1134 AssertPtrReturn(pSgBuf, VERR_INVALID_PARAMETER);
1135 AssertReturn(pSgBuf->cSegs > 0, VERR_INVALID_PARAMETER);
1136 AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
1137
1138 int rc = rtSocketSwitchBlockingMode(pThis, true /* fBlocking */);
1139 if (RT_FAILURE(rc))
1140 return rc;
1141
1142 /*
1143 * Construct message descriptor (translate pSgBuf) and send it.
1144 */
1145 rc = VERR_NO_TMP_MEMORY;
1146#ifdef RT_OS_WINDOWS
1147 AssertCompileSize(WSABUF, sizeof(RTSGSEG));
1148 AssertCompileMemberSize(WSABUF, buf, RT_SIZEOFMEMB(RTSGSEG, pvSeg));
1149
1150 LPWSABUF paMsg = (LPWSABUF)RTMemTmpAllocZ(pSgBuf->cSegs * sizeof(WSABUF));
1151 if (paMsg)
1152 {
1153 for (unsigned i = 0; i < pSgBuf->cSegs; i++)
1154 {
1155 paMsg[i].buf = (char *)pSgBuf->paSegs[i].pvSeg;
1156 paMsg[i].len = (u_long)pSgBuf->paSegs[i].cbSeg;
1157 }
1158
1159 DWORD dwSent;
1160 int hrc = WSASend(pThis->hNative, paMsg, pSgBuf->cSegs, &dwSent,
1161 MSG_NOSIGNAL, NULL, NULL);
1162 if (!hrc)
1163 rc = VINF_SUCCESS;
1164/** @todo check for incomplete writes */
1165 else
1166 rc = rtSocketError();
1167
1168 RTMemTmpFree(paMsg);
1169 }
1170
1171#else /* !RT_OS_WINDOWS */
1172 AssertCompileSize(struct iovec, sizeof(RTSGSEG));
1173 AssertCompileMemberSize(struct iovec, iov_base, RT_SIZEOFMEMB(RTSGSEG, pvSeg));
1174 AssertCompileMemberSize(struct iovec, iov_len, RT_SIZEOFMEMB(RTSGSEG, cbSeg));
1175
1176 struct iovec *paMsg = (struct iovec *)RTMemTmpAllocZ(pSgBuf->cSegs * sizeof(struct iovec));
1177 if (paMsg)
1178 {
1179 for (unsigned i = 0; i < pSgBuf->cSegs; i++)
1180 {
1181 paMsg[i].iov_base = pSgBuf->paSegs[i].pvSeg;
1182 paMsg[i].iov_len = pSgBuf->paSegs[i].cbSeg;
1183 }
1184
1185 struct msghdr msgHdr;
1186 RT_ZERO(msgHdr);
1187 msgHdr.msg_iov = paMsg;
1188 msgHdr.msg_iovlen = pSgBuf->cSegs;
1189 ssize_t cbWritten = sendmsg(pThis->hNative, &msgHdr, MSG_NOSIGNAL);
1190 if (RT_LIKELY(cbWritten >= 0))
1191 rc = VINF_SUCCESS;
1192/** @todo check for incomplete writes */
1193 else
1194 rc = rtSocketError();
1195
1196 RTMemTmpFree(paMsg);
1197 }
1198#endif /* !RT_OS_WINDOWS */
1199
1200 rtSocketUnlock(pThis);
1201 return rc;
1202}
1203
1204
1205RTDECL(int) RTSocketSgWriteL(RTSOCKET hSocket, size_t cSegs, ...)
1206{
1207 va_list va;
1208 va_start(va, cSegs);
1209 int rc = RTSocketSgWriteLV(hSocket, cSegs, va);
1210 va_end(va);
1211 return rc;
1212}
1213
1214
1215RTDECL(int) RTSocketSgWriteLV(RTSOCKET hSocket, size_t cSegs, va_list va)
1216{
1217 /*
1218 * Set up a S/G segment array + buffer on the stack and pass it
1219 * on to RTSocketSgWrite.
1220 */
1221 Assert(cSegs <= 16);
1222 PRTSGSEG paSegs = (PRTSGSEG)alloca(cSegs * sizeof(RTSGSEG));
1223 AssertReturn(paSegs, VERR_NO_TMP_MEMORY);
1224 for (size_t i = 0; i < cSegs; i++)
1225 {
1226 paSegs[i].pvSeg = va_arg(va, void *);
1227 paSegs[i].cbSeg = va_arg(va, size_t);
1228 }
1229
1230 RTSGBUF SgBuf;
1231 RTSgBufInit(&SgBuf, paSegs, cSegs);
1232 return RTSocketSgWrite(hSocket, &SgBuf);
1233}
1234
1235
1236RTDECL(int) RTSocketReadNB(RTSOCKET hSocket, void *pvBuffer, size_t cbBuffer, size_t *pcbRead)
1237{
1238 /*
1239 * Validate input.
1240 */
1241 RTSOCKETINT *pThis = hSocket;
1242 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1243 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
1244 AssertReturn(cbBuffer > 0, VERR_INVALID_PARAMETER);
1245 AssertPtr(pvBuffer);
1246 AssertPtrReturn(pcbRead, VERR_INVALID_PARAMETER);
1247 AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
1248
1249 int rc = rtSocketSwitchBlockingMode(pThis, false /* fBlocking */);
1250 if (RT_FAILURE(rc))
1251 return rc;
1252
1253 rtSocketErrorReset();
1254#ifdef RTSOCKET_MAX_READ
1255 int cbNow = cbBuffer >= RTSOCKET_MAX_WRITE ? RTSOCKET_MAX_WRITE : (int)cbBuffer;
1256#else
1257 size_t cbNow = cbBuffer;
1258#endif
1259
1260#ifdef RT_OS_WINDOWS
1261 int cbRead = recv(pThis->hNative, (char *)pvBuffer, cbNow, MSG_NOSIGNAL);
1262 if (cbRead >= 0)
1263 {
1264 *pcbRead = cbRead;
1265 rc = VINF_SUCCESS;
1266 }
1267 else
1268 rc = rtSocketError();
1269
1270 if (rc == VERR_TRY_AGAIN)
1271 rc = VINF_TRY_AGAIN;
1272#else
1273 ssize_t cbRead = recv(pThis->hNative, pvBuffer, cbNow, MSG_NOSIGNAL);
1274 if (cbRead >= 0)
1275 *pcbRead = cbRead;
1276 else if ( errno == EAGAIN
1277# ifdef EWOULDBLOCK
1278 || errno == EWOULDBLOCK
1279# endif
1280 )
1281 {
1282 *pcbRead = 0;
1283 rc = VINF_TRY_AGAIN;
1284 }
1285 else
1286 rc = rtSocketError();
1287#endif
1288
1289 rtSocketUnlock(pThis);
1290 return rc;
1291}
1292
1293
1294RTDECL(int) RTSocketWriteNB(RTSOCKET hSocket, const void *pvBuffer, size_t cbBuffer, size_t *pcbWritten)
1295{
1296 /*
1297 * Validate input.
1298 */
1299 RTSOCKETINT *pThis = hSocket;
1300 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1301 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
1302 AssertPtrReturn(pcbWritten, VERR_INVALID_PARAMETER);
1303 AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
1304
1305 int rc = rtSocketSwitchBlockingMode(pThis, false /* fBlocking */);
1306 if (RT_FAILURE(rc))
1307 return rc;
1308
1309 rtSocketErrorReset();
1310#ifdef RTSOCKET_MAX_WRITE
1311 int cbNow = cbBuffer >= RTSOCKET_MAX_WRITE ? RTSOCKET_MAX_WRITE : (int)cbBuffer;
1312#else
1313 size_t cbNow = cbBuffer;
1314#endif
1315
1316#ifdef RT_OS_WINDOWS
1317 int cbWritten = send(pThis->hNative, (const char *)pvBuffer, cbNow, MSG_NOSIGNAL);
1318 if (cbWritten >= 0)
1319 {
1320 *pcbWritten = cbWritten;
1321 rc = VINF_SUCCESS;
1322 }
1323 else
1324 rc = rtSocketError();
1325
1326 if (rc == VERR_TRY_AGAIN)
1327 rc = VINF_TRY_AGAIN;
1328#else
1329 ssize_t cbWritten = send(pThis->hNative, pvBuffer, cbBuffer, MSG_NOSIGNAL);
1330 if (cbWritten >= 0)
1331 *pcbWritten = cbWritten;
1332 else if ( errno == EAGAIN
1333# ifdef EWOULDBLOCK
1334 || errno == EWOULDBLOCK
1335# endif
1336 )
1337 {
1338 *pcbWritten = 0;
1339 rc = VINF_TRY_AGAIN;
1340 }
1341 else
1342 rc = rtSocketError();
1343#endif
1344
1345 rtSocketUnlock(pThis);
1346 return rc;
1347}
1348
1349
1350RTDECL(int) RTSocketSgWriteNB(RTSOCKET hSocket, PCRTSGBUF pSgBuf, size_t *pcbWritten)
1351{
1352 /*
1353 * Validate input.
1354 */
1355 RTSOCKETINT *pThis = hSocket;
1356 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1357 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
1358 AssertPtrReturn(pSgBuf, VERR_INVALID_PARAMETER);
1359 AssertPtrReturn(pcbWritten, VERR_INVALID_PARAMETER);
1360 AssertReturn(pSgBuf->cSegs > 0, VERR_INVALID_PARAMETER);
1361 AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
1362
1363 int rc = rtSocketSwitchBlockingMode(pThis, false /* fBlocking */);
1364 if (RT_FAILURE(rc))
1365 return rc;
1366
1367 unsigned cSegsToSend = 0;
1368 rc = VERR_NO_TMP_MEMORY;
1369#ifdef RT_OS_WINDOWS
1370 LPWSABUF paMsg = NULL;
1371
1372 RTSgBufMapToNative(paMsg, pSgBuf, WSABUF, buf, char *, len, u_long, cSegsToSend);
1373 if (paMsg)
1374 {
1375 DWORD dwSent = 0;
1376 int hrc = WSASend(pThis->hNative, paMsg, cSegsToSend, &dwSent,
1377 MSG_NOSIGNAL, NULL, NULL);
1378 if (!hrc)
1379 rc = VINF_SUCCESS;
1380 else
1381 rc = rtSocketError();
1382
1383 *pcbWritten = dwSent;
1384
1385 RTMemTmpFree(paMsg);
1386 }
1387
1388#else /* !RT_OS_WINDOWS */
1389 struct iovec *paMsg = NULL;
1390
1391 RTSgBufMapToNative(paMsg, pSgBuf, struct iovec, iov_base, void *, iov_len, size_t, cSegsToSend);
1392 if (paMsg)
1393 {
1394 struct msghdr msgHdr;
1395 RT_ZERO(msgHdr);
1396 msgHdr.msg_iov = paMsg;
1397 msgHdr.msg_iovlen = cSegsToSend;
1398 ssize_t cbWritten = sendmsg(pThis->hNative, &msgHdr, MSG_NOSIGNAL);
1399 if (RT_LIKELY(cbWritten >= 0))
1400 {
1401 rc = VINF_SUCCESS;
1402 *pcbWritten = cbWritten;
1403 }
1404 else
1405 rc = rtSocketError();
1406
1407 RTMemTmpFree(paMsg);
1408 }
1409#endif /* !RT_OS_WINDOWS */
1410
1411 rtSocketUnlock(pThis);
1412 return rc;
1413}
1414
1415
1416RTDECL(int) RTSocketSgWriteLNB(RTSOCKET hSocket, size_t cSegs, size_t *pcbWritten, ...)
1417{
1418 va_list va;
1419 va_start(va, pcbWritten);
1420 int rc = RTSocketSgWriteLVNB(hSocket, cSegs, pcbWritten, va);
1421 va_end(va);
1422 return rc;
1423}
1424
1425
1426RTDECL(int) RTSocketSgWriteLVNB(RTSOCKET hSocket, size_t cSegs, size_t *pcbWritten, va_list va)
1427{
1428 /*
1429 * Set up a S/G segment array + buffer on the stack and pass it
1430 * on to RTSocketSgWrite.
1431 */
1432 Assert(cSegs <= 16);
1433 PRTSGSEG paSegs = (PRTSGSEG)alloca(cSegs * sizeof(RTSGSEG));
1434 AssertReturn(paSegs, VERR_NO_TMP_MEMORY);
1435 for (size_t i = 0; i < cSegs; i++)
1436 {
1437 paSegs[i].pvSeg = va_arg(va, void *);
1438 paSegs[i].cbSeg = va_arg(va, size_t);
1439 }
1440
1441 RTSGBUF SgBuf;
1442 RTSgBufInit(&SgBuf, paSegs, cSegs);
1443 return RTSocketSgWriteNB(hSocket, &SgBuf, pcbWritten);
1444}
1445
1446
1447RTDECL(int) RTSocketSelectOne(RTSOCKET hSocket, RTMSINTERVAL cMillies)
1448{
1449 /*
1450 * Validate input.
1451 */
1452 RTSOCKETINT *pThis = hSocket;
1453 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1454 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
1455 AssertReturn(RTMemPoolRefCount(pThis) >= (pThis->cUsers ? 2U : 1U), VERR_CALLER_NO_REFERENCE);
1456 int const fdMax = (int)pThis->hNative + 1;
1457 AssertReturn(fdMax - 1 == pThis->hNative, VERR_INTERNAL_ERROR_5);
1458
1459 /*
1460 * Set up the file descriptor sets and do the select.
1461 */
1462 fd_set fdsetR;
1463 FD_ZERO(&fdsetR);
1464 FD_SET(pThis->hNative, &fdsetR);
1465
1466 fd_set fdsetE = fdsetR;
1467
1468 int rc;
1469 if (cMillies == RT_INDEFINITE_WAIT)
1470 rc = select(fdMax, &fdsetR, NULL, &fdsetE, NULL);
1471 else
1472 {
1473 struct timeval timeout;
1474 timeout.tv_sec = cMillies / 1000;
1475 timeout.tv_usec = (cMillies % 1000) * 1000;
1476 rc = select(fdMax, &fdsetR, NULL, &fdsetE, &timeout);
1477 }
1478 if (rc > 0)
1479 rc = VINF_SUCCESS;
1480 else if (rc == 0)
1481 rc = VERR_TIMEOUT;
1482 else
1483 rc = rtSocketError();
1484
1485 return rc;
1486}
1487
1488
1489RTDECL(int) RTSocketSelectOneEx(RTSOCKET hSocket, uint32_t fEvents, uint32_t *pfEvents, RTMSINTERVAL cMillies)
1490{
1491 /*
1492 * Validate input.
1493 */
1494 RTSOCKETINT *pThis = hSocket;
1495 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1496 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
1497 AssertPtrReturn(pfEvents, VERR_INVALID_PARAMETER);
1498 AssertReturn(!(fEvents & ~RTSOCKET_EVT_VALID_MASK), VERR_INVALID_PARAMETER);
1499 AssertReturn(RTMemPoolRefCount(pThis) >= (pThis->cUsers ? 2U : 1U), VERR_CALLER_NO_REFERENCE);
1500 int const fdMax = (int)pThis->hNative + 1;
1501 AssertReturn(fdMax - 1 == pThis->hNative, VERR_INTERNAL_ERROR_5);
1502
1503 *pfEvents = 0;
1504
1505 /*
1506 * Set up the file descriptor sets and do the select.
1507 */
1508 fd_set fdsetR;
1509 fd_set fdsetW;
1510 fd_set fdsetE;
1511 FD_ZERO(&fdsetR);
1512 FD_ZERO(&fdsetW);
1513 FD_ZERO(&fdsetE);
1514
1515 if (fEvents & RTSOCKET_EVT_READ)
1516 FD_SET(pThis->hNative, &fdsetR);
1517 if (fEvents & RTSOCKET_EVT_WRITE)
1518 FD_SET(pThis->hNative, &fdsetW);
1519 if (fEvents & RTSOCKET_EVT_ERROR)
1520 FD_SET(pThis->hNative, &fdsetE);
1521
1522 int rc;
1523 if (cMillies == RT_INDEFINITE_WAIT)
1524 rc = select(fdMax, &fdsetR, &fdsetW, &fdsetE, NULL);
1525 else
1526 {
1527 struct timeval timeout;
1528 timeout.tv_sec = cMillies / 1000;
1529 timeout.tv_usec = (cMillies % 1000) * 1000;
1530 rc = select(fdMax, &fdsetR, &fdsetW, &fdsetE, &timeout);
1531 }
1532 if (rc > 0)
1533 {
1534 if (FD_ISSET(pThis->hNative, &fdsetR))
1535 *pfEvents |= RTSOCKET_EVT_READ;
1536 if (FD_ISSET(pThis->hNative, &fdsetW))
1537 *pfEvents |= RTSOCKET_EVT_WRITE;
1538 if (FD_ISSET(pThis->hNative, &fdsetE))
1539 *pfEvents |= RTSOCKET_EVT_ERROR;
1540
1541 rc = VINF_SUCCESS;
1542 }
1543 else if (rc == 0)
1544 rc = VERR_TIMEOUT;
1545 else
1546 rc = rtSocketError();
1547
1548 return rc;
1549}
1550
1551
1552RTDECL(int) RTSocketShutdown(RTSOCKET hSocket, bool fRead, bool fWrite)
1553{
1554 /*
1555 * Validate input, don't lock it because we might want to interrupt a call
1556 * active on a different thread.
1557 */
1558 RTSOCKETINT *pThis = hSocket;
1559 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1560 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
1561 AssertReturn(RTMemPoolRefCount(pThis) >= (pThis->cUsers ? 2U : 1U), VERR_CALLER_NO_REFERENCE);
1562 AssertReturn(fRead || fWrite, VERR_INVALID_PARAMETER);
1563
1564 /*
1565 * Do the job.
1566 */
1567 int rc = VINF_SUCCESS;
1568 int fHow;
1569 if (fRead && fWrite)
1570 fHow = SHUT_RDWR;
1571 else if (fRead)
1572 fHow = SHUT_RD;
1573 else
1574 fHow = SHUT_WR;
1575 if (shutdown(pThis->hNative, fHow) == -1)
1576 rc = rtSocketError();
1577
1578 return rc;
1579}
1580
1581
1582RTDECL(int) RTSocketGetLocalAddress(RTSOCKET hSocket, PRTNETADDR pAddr)
1583{
1584 /*
1585 * Validate input.
1586 */
1587 RTSOCKETINT *pThis = hSocket;
1588 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1589 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
1590 AssertReturn(RTMemPoolRefCount(pThis) >= (pThis->cUsers ? 2U : 1U), VERR_CALLER_NO_REFERENCE);
1591
1592 /*
1593 * Get the address and convert it.
1594 */
1595 int rc;
1596 RTSOCKADDRUNION u;
1597#ifdef RT_OS_WINDOWS
1598 int cbAddr = sizeof(u);
1599#else
1600 socklen_t cbAddr = sizeof(u);
1601#endif
1602 RT_ZERO(u);
1603 if (getsockname(pThis->hNative, &u.Addr, &cbAddr) == 0)
1604 rc = rtSocketNetAddrFromAddr(&u, cbAddr, pAddr);
1605 else
1606 rc = rtSocketError();
1607
1608 return rc;
1609}
1610
1611
1612RTDECL(int) RTSocketGetPeerAddress(RTSOCKET hSocket, PRTNETADDR pAddr)
1613{
1614 /*
1615 * Validate input.
1616 */
1617 RTSOCKETINT *pThis = hSocket;
1618 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1619 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
1620 AssertReturn(RTMemPoolRefCount(pThis) >= (pThis->cUsers ? 2U : 1U), VERR_CALLER_NO_REFERENCE);
1621
1622 /*
1623 * Get the address and convert it.
1624 */
1625 int rc;
1626 RTSOCKADDRUNION u;
1627#ifdef RT_OS_WINDOWS
1628 int cbAddr = sizeof(u);
1629#else
1630 socklen_t cbAddr = sizeof(u);
1631#endif
1632 RT_ZERO(u);
1633 if (getpeername(pThis->hNative, &u.Addr, &cbAddr) == 0)
1634 rc = rtSocketNetAddrFromAddr(&u, cbAddr, pAddr);
1635 else
1636 rc = rtSocketError();
1637
1638 return rc;
1639}
1640
1641
1642
1643/**
1644 * Wrapper around bind.
1645 *
1646 * @returns IPRT status code.
1647 * @param hSocket The socket handle.
1648 * @param pAddr The address to bind to.
1649 */
1650DECLHIDDEN(int) rtSocketBind(RTSOCKET hSocket, PCRTNETADDR pAddr)
1651{
1652 RTSOCKADDRUNION u;
1653 int cbAddr;
1654 int rc = rtSocketAddrFromNetAddr(pAddr, &u, sizeof(u), &cbAddr);
1655 if (RT_SUCCESS(rc))
1656 rc = rtSocketBindRawAddr(hSocket, &u.Addr, cbAddr);
1657 return rc;
1658}
1659
1660
1661/**
1662 * Very thin wrapper around bind.
1663 *
1664 * @returns IPRT status code.
1665 * @param hSocket The socket handle.
1666 * @param pvAddr The address to bind to (struct sockaddr and
1667 * friends).
1668 * @param cbAddr The size of the address.
1669 */
1670DECLHIDDEN(int) rtSocketBindRawAddr(RTSOCKET hSocket, void const *pvAddr, size_t cbAddr)
1671{
1672 /*
1673 * Validate input.
1674 */
1675 RTSOCKETINT *pThis = hSocket;
1676 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1677 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
1678 AssertPtrReturn(pvAddr, VERR_INVALID_POINTER);
1679 AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
1680
1681 int rc;
1682 if (bind(pThis->hNative, (struct sockaddr const *)pvAddr, (int)cbAddr) == 0)
1683 rc = VINF_SUCCESS;
1684 else
1685 rc = rtSocketError();
1686
1687 rtSocketUnlock(pThis);
1688 return rc;
1689}
1690
1691
1692
1693/**
1694 * Wrapper around listen.
1695 *
1696 * @returns IPRT status code.
1697 * @param hSocket The socket handle.
1698 * @param cMaxPending The max number of pending connections.
1699 */
1700DECLHIDDEN(int) rtSocketListen(RTSOCKET hSocket, int cMaxPending)
1701{
1702 /*
1703 * Validate input.
1704 */
1705 RTSOCKETINT *pThis = hSocket;
1706 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1707 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
1708 AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
1709
1710 int rc = VINF_SUCCESS;
1711 if (listen(pThis->hNative, cMaxPending) != 0)
1712 rc = rtSocketError();
1713
1714 rtSocketUnlock(pThis);
1715 return rc;
1716}
1717
1718
1719/**
1720 * Wrapper around accept.
1721 *
1722 * @returns IPRT status code.
1723 * @param hSocket The socket handle.
1724 * @param phClient Where to return the client socket handle on
1725 * success.
1726 * @param pAddr Where to return the client address.
1727 * @param pcbAddr On input this gives the size buffer size of what
1728 * @a pAddr point to. On return this contains the
1729 * size of what's stored at @a pAddr.
1730 */
1731DECLHIDDEN(int) rtSocketAccept(RTSOCKET hSocket, PRTSOCKET phClient, struct sockaddr *pAddr, size_t *pcbAddr)
1732{
1733 /*
1734 * Validate input.
1735 * Only lock the socket temporarily while we get the native handle, so that
1736 * we can safely shutdown and destroy the socket from a different thread.
1737 */
1738 RTSOCKETINT *pThis = hSocket;
1739 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1740 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
1741 AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
1742
1743 /*
1744 * Call accept().
1745 */
1746 rtSocketErrorReset();
1747 int rc = VINF_SUCCESS;
1748#ifdef RT_OS_WINDOWS
1749 int cbAddr = (int)*pcbAddr;
1750#else
1751 socklen_t cbAddr = *pcbAddr;
1752#endif
1753 RTSOCKETNATIVE hNativeClient = accept(pThis->hNative, pAddr, &cbAddr);
1754 if (hNativeClient != NIL_RTSOCKETNATIVE)
1755 {
1756 *pcbAddr = cbAddr;
1757
1758 /*
1759 * Wrap the client socket.
1760 */
1761 rc = rtSocketCreateForNative(phClient, hNativeClient);
1762 if (RT_FAILURE(rc))
1763 {
1764#ifdef RT_OS_WINDOWS
1765 closesocket(hNativeClient);
1766#else
1767 close(hNativeClient);
1768#endif
1769 }
1770 }
1771 else
1772 rc = rtSocketError();
1773
1774 rtSocketUnlock(pThis);
1775 return rc;
1776}
1777
1778
1779/**
1780 * Wrapper around connect.
1781 *
1782 * @returns IPRT status code.
1783 * @param hSocket The socket handle.
1784 * @param pAddr The socket address to connect to.
1785 * @param cMillies Number of milliseconds to wait for the connect attempt to complete.
1786 * Use RT_INDEFINITE_WAIT to wait for ever.
1787 * Use RT_TCPCLIENTCONNECT_DEFAULT_WAIT to wait for the default time
1788 * configured on the running system.
1789 */
1790DECLHIDDEN(int) rtSocketConnect(RTSOCKET hSocket, PCRTNETADDR pAddr, RTMSINTERVAL cMillies)
1791{
1792 /*
1793 * Validate input.
1794 */
1795 RTSOCKETINT *pThis = hSocket;
1796 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1797 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
1798 AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
1799
1800 RTSOCKADDRUNION u;
1801 int cbAddr;
1802 int rc = rtSocketAddrFromNetAddr(pAddr, &u, sizeof(u), &cbAddr);
1803 if (RT_SUCCESS(rc))
1804 {
1805 if (cMillies == RT_SOCKETCONNECT_DEFAULT_WAIT)
1806 {
1807 if (connect(pThis->hNative, &u.Addr, cbAddr) != 0)
1808 rc = rtSocketError();
1809 }
1810 else
1811 {
1812 /*
1813 * Switch the socket to nonblocking mode, initiate the connect
1814 * and wait for the socket to become writable or until the timeout
1815 * expires.
1816 */
1817 rc = rtSocketSwitchBlockingMode(pThis, false /* fBlocking */);
1818 if (RT_SUCCESS(rc))
1819 {
1820 if (connect(pThis->hNative, &u.Addr, cbAddr) != 0)
1821 {
1822 rc = rtSocketError();
1823 if (rc == VERR_TRY_AGAIN || rc == VERR_NET_IN_PROGRESS)
1824 {
1825 int rcSock = 0;
1826 fd_set FdSetWriteable;
1827 struct timeval TvTimeout;
1828
1829 TvTimeout.tv_sec = cMillies / RT_MS_1SEC;
1830 TvTimeout.tv_usec = (cMillies % RT_MS_1SEC) * RT_US_1MS;
1831
1832 FD_ZERO(&FdSetWriteable);
1833 FD_SET(pThis->hNative, &FdSetWriteable);
1834 do
1835 {
1836 rcSock = select(pThis->hNative + 1, NULL, &FdSetWriteable, NULL,
1837 cMillies == RT_INDEFINITE_WAIT || cMillies >= INT_MAX
1838 ? NULL
1839 : &TvTimeout);
1840 if (rcSock > 0)
1841 {
1842 int iSockError = 0;
1843 socklen_t cbSockOpt = sizeof(iSockError);
1844 rcSock = getsockopt(pThis->hNative, SOL_SOCKET, SO_ERROR, (char *)&iSockError, &cbSockOpt);
1845 if (rcSock == 0)
1846 {
1847 if (iSockError == 0)
1848 rc = VINF_SUCCESS;
1849 else
1850 {
1851#ifdef RT_OS_WINDOWS
1852 rc = RTErrConvertFromWin32(iSockError);
1853#else
1854 rc = RTErrConvertFromErrno(iSockError);
1855#endif
1856 }
1857 }
1858 else
1859 rc = rtSocketError();
1860 }
1861 else if (rcSock == 0)
1862 rc = VERR_TIMEOUT;
1863 else
1864 rc = rtSocketError();
1865 } while (rc == VERR_INTERRUPTED);
1866 }
1867 }
1868
1869 rtSocketSwitchBlockingMode(pThis, true /* fBlocking */);
1870 }
1871 }
1872 }
1873
1874 rtSocketUnlock(pThis);
1875 return rc;
1876}
1877
1878
1879/**
1880 * Wrapper around connect, raw address, no timeout.
1881 *
1882 * @returns IPRT status code.
1883 * @param hSocket The socket handle.
1884 * @param pvAddr The raw socket address to connect to.
1885 * @param cbAddr The size of the raw address.
1886 */
1887DECLHIDDEN(int) rtSocketConnectRaw(RTSOCKET hSocket, void const *pvAddr, size_t cbAddr)
1888{
1889 /*
1890 * Validate input.
1891 */
1892 RTSOCKETINT *pThis = hSocket;
1893 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1894 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
1895 AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
1896
1897 int rc;
1898 if (connect(pThis->hNative, (const struct sockaddr *)pvAddr, (int)cbAddr) == 0)
1899 rc = VINF_SUCCESS;
1900 else
1901 rc = rtSocketError();
1902
1903 rtSocketUnlock(pThis);
1904 return rc;
1905}
1906
1907
1908/**
1909 * Wrapper around setsockopt.
1910 *
1911 * @returns IPRT status code.
1912 * @param hSocket The socket handle.
1913 * @param iLevel The protocol level, e.g. IPPORTO_TCP.
1914 * @param iOption The option, e.g. TCP_NODELAY.
1915 * @param pvValue The value buffer.
1916 * @param cbValue The size of the value pointed to by pvValue.
1917 */
1918DECLHIDDEN(int) rtSocketSetOpt(RTSOCKET hSocket, int iLevel, int iOption, void const *pvValue, int cbValue)
1919{
1920 /*
1921 * Validate input.
1922 */
1923 RTSOCKETINT *pThis = hSocket;
1924 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1925 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
1926 AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
1927
1928 int rc = VINF_SUCCESS;
1929 if (setsockopt(pThis->hNative, iLevel, iOption, (const char *)pvValue, cbValue) != 0)
1930 rc = rtSocketError();
1931
1932 rtSocketUnlock(pThis);
1933 return rc;
1934}
1935
1936
1937/**
1938 * Internal RTPollSetAdd helper that returns the handle that should be added to
1939 * the pollset.
1940 *
1941 * @returns Valid handle on success, INVALID_HANDLE_VALUE on failure.
1942 * @param hSocket The socket handle.
1943 * @param fEvents The events we're polling for.
1944 * @param phNative Where to put the primary handle.
1945 */
1946DECLHIDDEN(int) rtSocketPollGetHandle(RTSOCKET hSocket, uint32_t fEvents, PRTHCINTPTR phNative)
1947{
1948 RTSOCKETINT *pThis = hSocket;
1949 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1950 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
1951#ifdef RT_OS_WINDOWS
1952 AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
1953
1954 int rc = VINF_SUCCESS;
1955 if (pThis->hEvent != WSA_INVALID_EVENT)
1956 *phNative = (RTHCINTPTR)pThis->hEvent;
1957 else
1958 {
1959 pThis->hEvent = WSACreateEvent();
1960 *phNative = (RTHCINTPTR)pThis->hEvent;
1961 if (pThis->hEvent == WSA_INVALID_EVENT)
1962 rc = rtSocketError();
1963 }
1964
1965 rtSocketUnlock(pThis);
1966 return rc;
1967
1968#else /* !RT_OS_WINDOWS */
1969 *phNative = (RTHCUINTPTR)pThis->hNative;
1970 return VINF_SUCCESS;
1971#endif /* !RT_OS_WINDOWS */
1972}
1973
1974#ifdef RT_OS_WINDOWS
1975
1976/**
1977 * Undos the harm done by WSAEventSelect.
1978 *
1979 * @returns IPRT status code.
1980 * @param pThis The socket handle.
1981 */
1982static int rtSocketPollClearEventAndRestoreBlocking(RTSOCKETINT *pThis)
1983{
1984 int rc = VINF_SUCCESS;
1985 if (pThis->fSubscribedEvts)
1986 {
1987 if (WSAEventSelect(pThis->hNative, WSA_INVALID_EVENT, 0) == 0)
1988 {
1989 pThis->fSubscribedEvts = 0;
1990
1991 /*
1992 * Switch back to blocking mode if that was the state before the
1993 * operation.
1994 */
1995 if (pThis->fBlocking)
1996 {
1997 u_long fNonBlocking = 0;
1998 int rc2 = ioctlsocket(pThis->hNative, FIONBIO, &fNonBlocking);
1999 if (rc2 != 0)
2000 {
2001 rc = rtSocketError();
2002 AssertMsgFailed(("%Rrc; rc2=%d\n", rc, rc2));
2003 }
2004 }
2005 }
2006 else
2007 {
2008 rc = rtSocketError();
2009 AssertMsgFailed(("%Rrc\n", rc));
2010 }
2011 }
2012 return rc;
2013}
2014
2015
2016/**
2017 * Updates the mask of events we're subscribing to.
2018 *
2019 * @returns IPRT status code.
2020 * @param pThis The socket handle.
2021 * @param fEvents The events we want to subscribe to.
2022 */
2023static int rtSocketPollUpdateEvents(RTSOCKETINT *pThis, uint32_t fEvents)
2024{
2025 LONG fNetworkEvents = 0;
2026 if (fEvents & RTPOLL_EVT_READ)
2027 fNetworkEvents |= FD_READ;
2028 if (fEvents & RTPOLL_EVT_WRITE)
2029 fNetworkEvents |= FD_WRITE;
2030 if (fEvents & RTPOLL_EVT_ERROR)
2031 fNetworkEvents |= FD_CLOSE;
2032 LogFlowFunc(("fNetworkEvents=%#x\n", fNetworkEvents));
2033 if (WSAEventSelect(pThis->hNative, pThis->hEvent, fNetworkEvents) == 0)
2034 {
2035 pThis->fSubscribedEvts = fEvents;
2036 return VINF_SUCCESS;
2037 }
2038
2039 int rc = rtSocketError();
2040 AssertMsgFailed(("fNetworkEvents=%#x rc=%Rrc\n", fNetworkEvents, rtSocketError()));
2041 return rc;
2042}
2043
2044#endif /* RT_OS_WINDOWS */
2045
2046
2047#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
2048
2049/**
2050 * Checks for pending events.
2051 *
2052 * @returns Event mask or 0.
2053 * @param pThis The socket handle.
2054 * @param fEvents The desired events.
2055 */
2056static uint32_t rtSocketPollCheck(RTSOCKETINT *pThis, uint32_t fEvents)
2057{
2058 uint32_t fRetEvents = 0;
2059
2060 LogFlowFunc(("pThis=%#p fEvents=%#x\n", pThis, fEvents));
2061
2062# ifdef RT_OS_WINDOWS
2063 /* Make sure WSAEnumNetworkEvents returns what we want. */
2064 int rc = VINF_SUCCESS;
2065 if ((pThis->fSubscribedEvts & fEvents) != fEvents)
2066 rc = rtSocketPollUpdateEvents(pThis, pThis->fSubscribedEvts | fEvents);
2067
2068 /* Get the event mask, ASSUMES that WSAEnumNetworkEvents doesn't clear stuff. */
2069 WSANETWORKEVENTS NetEvts;
2070 RT_ZERO(NetEvts);
2071 if (WSAEnumNetworkEvents(pThis->hNative, pThis->hEvent, &NetEvts) == 0)
2072 {
2073 if ( (NetEvts.lNetworkEvents & FD_READ)
2074 && (fEvents & RTPOLL_EVT_READ)
2075 && NetEvts.iErrorCode[FD_READ_BIT] == 0)
2076 fRetEvents |= RTPOLL_EVT_READ;
2077
2078 if ( (NetEvts.lNetworkEvents & FD_WRITE)
2079 && (fEvents & RTPOLL_EVT_WRITE)
2080 && NetEvts.iErrorCode[FD_WRITE_BIT] == 0)
2081 fRetEvents |= RTPOLL_EVT_WRITE;
2082
2083 if (fEvents & RTPOLL_EVT_ERROR)
2084 {
2085 if (NetEvts.lNetworkEvents & FD_CLOSE)
2086 fRetEvents |= RTPOLL_EVT_ERROR;
2087 else
2088 for (uint32_t i = 0; i < FD_MAX_EVENTS; i++)
2089 if ( (NetEvts.lNetworkEvents & (1L << i))
2090 && NetEvts.iErrorCode[i] != 0)
2091 fRetEvents |= RTPOLL_EVT_ERROR;
2092 }
2093 }
2094 else
2095 rc = rtSocketError();
2096
2097 /* Fall back on select if we hit an error above. */
2098 if (RT_FAILURE(rc))
2099 {
2100
2101 }
2102
2103#else /* RT_OS_OS2 */
2104 int aFds[4] = { pThis->hNative, pThis->hNative, pThis->hNative, -1 };
2105 int rc = os2_select(aFds, 1, 1, 1, 0);
2106 if (rc > 0)
2107 {
2108 if (aFds[0] == pThis->hNative)
2109 fRetEvents |= RTPOLL_EVT_READ;
2110 if (aFds[1] == pThis->hNative)
2111 fRetEvents |= RTPOLL_EVT_WRITE;
2112 if (aFds[2] == pThis->hNative)
2113 fRetEvents |= RTPOLL_EVT_ERROR;
2114 fRetEvents &= fEvents;
2115 }
2116#endif /* RT_OS_OS2 */
2117
2118 LogFlowFunc(("fRetEvents=%#x\n", fRetEvents));
2119 return fRetEvents;
2120}
2121
2122
2123/**
2124 * Internal RTPoll helper that polls the socket handle and, if @a fNoWait is
2125 * clear, starts whatever actions we've got running during the poll call.
2126 *
2127 * @returns 0 if no pending events, actions initiated if @a fNoWait is clear.
2128 * Event mask (in @a fEvents) and no actions if the handle is ready
2129 * already.
2130 * UINT32_MAX (asserted) if the socket handle is busy in I/O or a
2131 * different poll set.
2132 *
2133 * @param hSocket The socket handle.
2134 * @param hPollSet The poll set handle (for access checks).
2135 * @param fEvents The events we're polling for.
2136 * @param fFinalEntry Set if this is the final entry for this handle
2137 * in this poll set. This can be used for dealing
2138 * with duplicate entries.
2139 * @param fNoWait Set if it's a zero-wait poll call. Clear if
2140 * we'll wait for an event to occur.
2141 *
2142 * @remarks There is a potential race wrt duplicate handles when @a fNoWait is
2143 * @c true, we don't currently care about that oddity...
2144 */
2145DECLHIDDEN(uint32_t) rtSocketPollStart(RTSOCKET hSocket, RTPOLLSET hPollSet, uint32_t fEvents, bool fFinalEntry, bool fNoWait)
2146{
2147 RTSOCKETINT *pThis = hSocket;
2148 AssertPtrReturn(pThis, UINT32_MAX);
2149 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, UINT32_MAX);
2150 /** @todo This isn't quite sane. Replace by critsect and open up concurrent
2151 * reads and writes! */
2152 if (rtSocketTryLock(pThis))
2153 pThis->hPollSet = hPollSet;
2154 else
2155 {
2156 AssertReturn(pThis->hPollSet == hPollSet, UINT32_MAX);
2157 ASMAtomicIncU32(&pThis->cUsers);
2158 }
2159
2160 /* (rtSocketPollCheck will reset the event object). */
2161# ifdef RT_OS_WINDOWS
2162 uint32_t fRetEvents = pThis->fEventsSaved;
2163 pThis->fEventsSaved = 0; /* Reset */
2164 fRetEvents |= rtSocketPollCheck(pThis, fEvents);
2165
2166 if ( !fRetEvents
2167 && !fNoWait)
2168 {
2169 pThis->fPollEvts |= fEvents;
2170 if ( fFinalEntry
2171 && pThis->fSubscribedEvts != pThis->fPollEvts)
2172 {
2173 int rc = rtSocketPollUpdateEvents(pThis, pThis->fPollEvts);
2174 if (RT_FAILURE(rc))
2175 {
2176 pThis->fPollEvts = 0;
2177 fRetEvents = UINT32_MAX;
2178 }
2179 }
2180 }
2181# else
2182 uint32_t fRetEvents = rtSocketPollCheck(pThis, fEvents);
2183# endif
2184
2185 if (fRetEvents || fNoWait)
2186 {
2187 if (pThis->cUsers == 1)
2188 {
2189# ifdef RT_OS_WINDOWS
2190 rtSocketPollClearEventAndRestoreBlocking(pThis);
2191# endif
2192 pThis->hPollSet = NIL_RTPOLLSET;
2193 }
2194 ASMAtomicDecU32(&pThis->cUsers);
2195 }
2196
2197 return fRetEvents;
2198}
2199
2200
2201/**
2202 * Called after a WaitForMultipleObjects returned in order to check for pending
2203 * events and stop whatever actions that rtSocketPollStart() initiated.
2204 *
2205 * @returns Event mask or 0.
2206 *
2207 * @param hSocket The socket handle.
2208 * @param fEvents The events we're polling for.
2209 * @param fFinalEntry Set if this is the final entry for this handle
2210 * in this poll set. This can be used for dealing
2211 * with duplicate entries. Only keep in mind that
2212 * this method is called in reverse order, so the
2213 * first call will have this set (when the entire
2214 * set was processed).
2215 * @param fHarvestEvents Set if we should check for pending events.
2216 */
2217DECLHIDDEN(uint32_t) rtSocketPollDone(RTSOCKET hSocket, uint32_t fEvents, bool fFinalEntry, bool fHarvestEvents)
2218{
2219 RTSOCKETINT *pThis = hSocket;
2220 AssertPtrReturn(pThis, 0);
2221 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, 0);
2222 Assert(pThis->cUsers > 0);
2223 Assert(pThis->hPollSet != NIL_RTPOLLSET);
2224
2225 /* Harvest events and clear the event mask for the next round of polling. */
2226 uint32_t fRetEvents = rtSocketPollCheck(pThis, fEvents);
2227# ifdef RT_OS_WINDOWS
2228 pThis->fPollEvts = 0;
2229
2230 /*
2231 * Save the write event if required.
2232 * It is only posted once and might get lost if the another source in the
2233 * pollset with a higher priority has pending events.
2234 */
2235 if ( !fHarvestEvents
2236 && fRetEvents)
2237 {
2238 pThis->fEventsSaved = fRetEvents;
2239 fRetEvents = 0;
2240 }
2241# endif
2242
2243 /* Make the socket blocking again and unlock the handle. */
2244 if (pThis->cUsers == 1)
2245 {
2246# ifdef RT_OS_WINDOWS
2247 rtSocketPollClearEventAndRestoreBlocking(pThis);
2248# endif
2249 pThis->hPollSet = NIL_RTPOLLSET;
2250 }
2251 ASMAtomicDecU32(&pThis->cUsers);
2252 return fRetEvents;
2253}
2254
2255#endif /* RT_OS_WINDOWS || RT_OS_OS2 */
2256
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette