VirtualBox

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

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

Runtime: Formatting fixes, time.cpp being the most significant.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 62.5 KB
Line 
1/* $Id: socket.cpp 56978 2015-07-18 18:55:25Z 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 */
214int 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 cbSrc 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 */
402int 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 */
446int 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) RTSocketSgWrite(RTSOCKET hSocket, PCRTSGBUF pSgBuf)
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 AssertPtrReturn(pSgBuf, VERR_INVALID_PARAMETER);
1081 AssertReturn(pSgBuf->cSegs > 0, VERR_INVALID_PARAMETER);
1082 AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
1083
1084 int rc = rtSocketSwitchBlockingMode(pThis, true /* fBlocking */);
1085 if (RT_FAILURE(rc))
1086 return rc;
1087
1088 /*
1089 * Construct message descriptor (translate pSgBuf) and send it.
1090 */
1091 rc = VERR_NO_TMP_MEMORY;
1092#ifdef RT_OS_WINDOWS
1093 AssertCompileSize(WSABUF, sizeof(RTSGSEG));
1094 AssertCompileMemberSize(WSABUF, buf, RT_SIZEOFMEMB(RTSGSEG, pvSeg));
1095
1096 LPWSABUF paMsg = (LPWSABUF)RTMemTmpAllocZ(pSgBuf->cSegs * sizeof(WSABUF));
1097 if (paMsg)
1098 {
1099 for (unsigned i = 0; i < pSgBuf->cSegs; i++)
1100 {
1101 paMsg[i].buf = (char *)pSgBuf->paSegs[i].pvSeg;
1102 paMsg[i].len = (u_long)pSgBuf->paSegs[i].cbSeg;
1103 }
1104
1105 DWORD dwSent;
1106 int hrc = WSASend(pThis->hNative, paMsg, pSgBuf->cSegs, &dwSent,
1107 MSG_NOSIGNAL, NULL, NULL);
1108 if (!hrc)
1109 rc = VINF_SUCCESS;
1110/** @todo check for incomplete writes */
1111 else
1112 rc = rtSocketError();
1113
1114 RTMemTmpFree(paMsg);
1115 }
1116
1117#else /* !RT_OS_WINDOWS */
1118 AssertCompileSize(struct iovec, sizeof(RTSGSEG));
1119 AssertCompileMemberSize(struct iovec, iov_base, RT_SIZEOFMEMB(RTSGSEG, pvSeg));
1120 AssertCompileMemberSize(struct iovec, iov_len, RT_SIZEOFMEMB(RTSGSEG, cbSeg));
1121
1122 struct iovec *paMsg = (struct iovec *)RTMemTmpAllocZ(pSgBuf->cSegs * sizeof(struct iovec));
1123 if (paMsg)
1124 {
1125 for (unsigned i = 0; i < pSgBuf->cSegs; i++)
1126 {
1127 paMsg[i].iov_base = pSgBuf->paSegs[i].pvSeg;
1128 paMsg[i].iov_len = pSgBuf->paSegs[i].cbSeg;
1129 }
1130
1131 struct msghdr msgHdr;
1132 RT_ZERO(msgHdr);
1133 msgHdr.msg_iov = paMsg;
1134 msgHdr.msg_iovlen = pSgBuf->cSegs;
1135 ssize_t cbWritten = sendmsg(pThis->hNative, &msgHdr, MSG_NOSIGNAL);
1136 if (RT_LIKELY(cbWritten >= 0))
1137 rc = VINF_SUCCESS;
1138/** @todo check for incomplete writes */
1139 else
1140 rc = rtSocketError();
1141
1142 RTMemTmpFree(paMsg);
1143 }
1144#endif /* !RT_OS_WINDOWS */
1145
1146 rtSocketUnlock(pThis);
1147 return rc;
1148}
1149
1150
1151RTDECL(int) RTSocketSgWriteL(RTSOCKET hSocket, size_t cSegs, ...)
1152{
1153 va_list va;
1154 va_start(va, cSegs);
1155 int rc = RTSocketSgWriteLV(hSocket, cSegs, va);
1156 va_end(va);
1157 return rc;
1158}
1159
1160
1161RTDECL(int) RTSocketSgWriteLV(RTSOCKET hSocket, size_t cSegs, va_list va)
1162{
1163 /*
1164 * Set up a S/G segment array + buffer on the stack and pass it
1165 * on to RTSocketSgWrite.
1166 */
1167 Assert(cSegs <= 16);
1168 PRTSGSEG paSegs = (PRTSGSEG)alloca(cSegs * sizeof(RTSGSEG));
1169 AssertReturn(paSegs, VERR_NO_TMP_MEMORY);
1170 for (size_t i = 0; i < cSegs; i++)
1171 {
1172 paSegs[i].pvSeg = va_arg(va, void *);
1173 paSegs[i].cbSeg = va_arg(va, size_t);
1174 }
1175
1176 RTSGBUF SgBuf;
1177 RTSgBufInit(&SgBuf, paSegs, cSegs);
1178 return RTSocketSgWrite(hSocket, &SgBuf);
1179}
1180
1181
1182RTDECL(int) RTSocketReadNB(RTSOCKET hSocket, void *pvBuffer, size_t cbBuffer, size_t *pcbRead)
1183{
1184 /*
1185 * Validate input.
1186 */
1187 RTSOCKETINT *pThis = hSocket;
1188 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1189 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
1190 AssertReturn(cbBuffer > 0, VERR_INVALID_PARAMETER);
1191 AssertPtr(pvBuffer);
1192 AssertPtrReturn(pcbRead, VERR_INVALID_PARAMETER);
1193 AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
1194
1195 int rc = rtSocketSwitchBlockingMode(pThis, false /* fBlocking */);
1196 if (RT_FAILURE(rc))
1197 return rc;
1198
1199 rtSocketErrorReset();
1200#ifdef RTSOCKET_MAX_READ
1201 int cbNow = cbBuffer >= RTSOCKET_MAX_WRITE ? RTSOCKET_MAX_WRITE : (int)cbBuffer;
1202#else
1203 size_t cbNow = cbBuffer;
1204#endif
1205
1206#ifdef RT_OS_WINDOWS
1207 int cbRead = recv(pThis->hNative, (char *)pvBuffer, cbNow, MSG_NOSIGNAL);
1208 if (cbRead >= 0)
1209 {
1210 *pcbRead = cbRead;
1211 rc = VINF_SUCCESS;
1212 }
1213 else
1214 rc = rtSocketError();
1215
1216 if (rc == VERR_TRY_AGAIN)
1217 rc = VINF_TRY_AGAIN;
1218#else
1219 ssize_t cbRead = recv(pThis->hNative, pvBuffer, cbNow, MSG_NOSIGNAL);
1220 if (cbRead >= 0)
1221 *pcbRead = cbRead;
1222 else if (errno == EAGAIN)
1223 {
1224 *pcbRead = 0;
1225 rc = VINF_TRY_AGAIN;
1226 }
1227 else
1228 rc = rtSocketError();
1229#endif
1230
1231 rtSocketUnlock(pThis);
1232 return rc;
1233}
1234
1235
1236RTDECL(int) RTSocketWriteNB(RTSOCKET hSocket, const void *pvBuffer, size_t cbBuffer, size_t *pcbWritten)
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 AssertPtrReturn(pcbWritten, VERR_INVALID_PARAMETER);
1245 AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
1246
1247 int rc = rtSocketSwitchBlockingMode(pThis, false /* fBlocking */);
1248 if (RT_FAILURE(rc))
1249 return rc;
1250
1251 rtSocketErrorReset();
1252#ifdef RTSOCKET_MAX_WRITE
1253 int cbNow = cbBuffer >= RTSOCKET_MAX_WRITE ? RTSOCKET_MAX_WRITE : (int)cbBuffer;
1254#else
1255 size_t cbNow = cbBuffer;
1256#endif
1257
1258#ifdef RT_OS_WINDOWS
1259 int cbWritten = send(pThis->hNative, (const char *)pvBuffer, cbNow, MSG_NOSIGNAL);
1260 if (cbWritten >= 0)
1261 {
1262 *pcbWritten = cbWritten;
1263 rc = VINF_SUCCESS;
1264 }
1265 else
1266 rc = rtSocketError();
1267
1268 if (rc == VERR_TRY_AGAIN)
1269 rc = VINF_TRY_AGAIN;
1270#else
1271 ssize_t cbWritten = send(pThis->hNative, pvBuffer, cbBuffer, MSG_NOSIGNAL);
1272 if (cbWritten >= 0)
1273 *pcbWritten = cbWritten;
1274 else if (errno == EAGAIN)
1275 {
1276 *pcbWritten = 0;
1277 rc = VINF_TRY_AGAIN;
1278 }
1279 else
1280 rc = rtSocketError();
1281#endif
1282
1283 rtSocketUnlock(pThis);
1284 return rc;
1285}
1286
1287
1288RTDECL(int) RTSocketSgWriteNB(RTSOCKET hSocket, PCRTSGBUF pSgBuf, size_t *pcbWritten)
1289{
1290 /*
1291 * Validate input.
1292 */
1293 RTSOCKETINT *pThis = hSocket;
1294 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1295 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
1296 AssertPtrReturn(pSgBuf, VERR_INVALID_PARAMETER);
1297 AssertPtrReturn(pcbWritten, VERR_INVALID_PARAMETER);
1298 AssertReturn(pSgBuf->cSegs > 0, VERR_INVALID_PARAMETER);
1299 AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
1300
1301 int rc = rtSocketSwitchBlockingMode(pThis, false /* fBlocking */);
1302 if (RT_FAILURE(rc))
1303 return rc;
1304
1305 unsigned cSegsToSend = 0;
1306 rc = VERR_NO_TMP_MEMORY;
1307#ifdef RT_OS_WINDOWS
1308 LPWSABUF paMsg = NULL;
1309
1310 RTSgBufMapToNative(paMsg, pSgBuf, WSABUF, buf, char *, len, u_long, cSegsToSend);
1311 if (paMsg)
1312 {
1313 DWORD dwSent = 0;
1314 int hrc = WSASend(pThis->hNative, paMsg, cSegsToSend, &dwSent,
1315 MSG_NOSIGNAL, NULL, NULL);
1316 if (!hrc)
1317 rc = VINF_SUCCESS;
1318 else
1319 rc = rtSocketError();
1320
1321 *pcbWritten = dwSent;
1322
1323 RTMemTmpFree(paMsg);
1324 }
1325
1326#else /* !RT_OS_WINDOWS */
1327 struct iovec *paMsg = NULL;
1328
1329 RTSgBufMapToNative(paMsg, pSgBuf, struct iovec, iov_base, void *, iov_len, size_t, cSegsToSend);
1330 if (paMsg)
1331 {
1332 struct msghdr msgHdr;
1333 RT_ZERO(msgHdr);
1334 msgHdr.msg_iov = paMsg;
1335 msgHdr.msg_iovlen = cSegsToSend;
1336 ssize_t cbWritten = sendmsg(pThis->hNative, &msgHdr, MSG_NOSIGNAL);
1337 if (RT_LIKELY(cbWritten >= 0))
1338 {
1339 rc = VINF_SUCCESS;
1340 *pcbWritten = cbWritten;
1341 }
1342 else
1343 rc = rtSocketError();
1344
1345 RTMemTmpFree(paMsg);
1346 }
1347#endif /* !RT_OS_WINDOWS */
1348
1349 rtSocketUnlock(pThis);
1350 return rc;
1351}
1352
1353
1354RTDECL(int) RTSocketSgWriteLNB(RTSOCKET hSocket, size_t cSegs, size_t *pcbWritten, ...)
1355{
1356 va_list va;
1357 va_start(va, pcbWritten);
1358 int rc = RTSocketSgWriteLVNB(hSocket, cSegs, pcbWritten, va);
1359 va_end(va);
1360 return rc;
1361}
1362
1363
1364RTDECL(int) RTSocketSgWriteLVNB(RTSOCKET hSocket, size_t cSegs, size_t *pcbWritten, va_list va)
1365{
1366 /*
1367 * Set up a S/G segment array + buffer on the stack and pass it
1368 * on to RTSocketSgWrite.
1369 */
1370 Assert(cSegs <= 16);
1371 PRTSGSEG paSegs = (PRTSGSEG)alloca(cSegs * sizeof(RTSGSEG));
1372 AssertReturn(paSegs, VERR_NO_TMP_MEMORY);
1373 for (size_t i = 0; i < cSegs; i++)
1374 {
1375 paSegs[i].pvSeg = va_arg(va, void *);
1376 paSegs[i].cbSeg = va_arg(va, size_t);
1377 }
1378
1379 RTSGBUF SgBuf;
1380 RTSgBufInit(&SgBuf, paSegs, cSegs);
1381 return RTSocketSgWriteNB(hSocket, &SgBuf, pcbWritten);
1382}
1383
1384
1385RTDECL(int) RTSocketSelectOne(RTSOCKET hSocket, RTMSINTERVAL cMillies)
1386{
1387 /*
1388 * Validate input.
1389 */
1390 RTSOCKETINT *pThis = hSocket;
1391 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1392 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
1393 AssertReturn(RTMemPoolRefCount(pThis) >= (pThis->cUsers ? 2U : 1U), VERR_CALLER_NO_REFERENCE);
1394 int const fdMax = (int)pThis->hNative + 1;
1395 AssertReturn(fdMax - 1 == pThis->hNative, VERR_INTERNAL_ERROR_5);
1396
1397 /*
1398 * Set up the file descriptor sets and do the select.
1399 */
1400 fd_set fdsetR;
1401 FD_ZERO(&fdsetR);
1402 FD_SET(pThis->hNative, &fdsetR);
1403
1404 fd_set fdsetE = fdsetR;
1405
1406 int rc;
1407 if (cMillies == RT_INDEFINITE_WAIT)
1408 rc = select(fdMax, &fdsetR, NULL, &fdsetE, NULL);
1409 else
1410 {
1411 struct timeval timeout;
1412 timeout.tv_sec = cMillies / 1000;
1413 timeout.tv_usec = (cMillies % 1000) * 1000;
1414 rc = select(fdMax, &fdsetR, NULL, &fdsetE, &timeout);
1415 }
1416 if (rc > 0)
1417 rc = VINF_SUCCESS;
1418 else if (rc == 0)
1419 rc = VERR_TIMEOUT;
1420 else
1421 rc = rtSocketError();
1422
1423 return rc;
1424}
1425
1426
1427RTDECL(int) RTSocketSelectOneEx(RTSOCKET hSocket, uint32_t fEvents, uint32_t *pfEvents,
1428 RTMSINTERVAL cMillies)
1429{
1430 /*
1431 * Validate input.
1432 */
1433 RTSOCKETINT *pThis = hSocket;
1434 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1435 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
1436 AssertPtrReturn(pfEvents, VERR_INVALID_PARAMETER);
1437 AssertReturn(!(fEvents & ~RTSOCKET_EVT_VALID_MASK), VERR_INVALID_PARAMETER);
1438 AssertReturn(RTMemPoolRefCount(pThis) >= (pThis->cUsers ? 2U : 1U), VERR_CALLER_NO_REFERENCE);
1439 int const fdMax = (int)pThis->hNative + 1;
1440 AssertReturn(fdMax - 1 == pThis->hNative, VERR_INTERNAL_ERROR_5);
1441
1442 *pfEvents = 0;
1443
1444 /*
1445 * Set up the file descriptor sets and do the select.
1446 */
1447 fd_set fdsetR;
1448 fd_set fdsetW;
1449 fd_set fdsetE;
1450 FD_ZERO(&fdsetR);
1451 FD_ZERO(&fdsetW);
1452 FD_ZERO(&fdsetE);
1453
1454 if (fEvents & RTSOCKET_EVT_READ)
1455 FD_SET(pThis->hNative, &fdsetR);
1456 if (fEvents & RTSOCKET_EVT_WRITE)
1457 FD_SET(pThis->hNative, &fdsetW);
1458 if (fEvents & RTSOCKET_EVT_ERROR)
1459 FD_SET(pThis->hNative, &fdsetE);
1460
1461 int rc;
1462 if (cMillies == RT_INDEFINITE_WAIT)
1463 rc = select(fdMax, &fdsetR, &fdsetW, &fdsetE, NULL);
1464 else
1465 {
1466 struct timeval timeout;
1467 timeout.tv_sec = cMillies / 1000;
1468 timeout.tv_usec = (cMillies % 1000) * 1000;
1469 rc = select(fdMax, &fdsetR, &fdsetW, &fdsetE, &timeout);
1470 }
1471 if (rc > 0)
1472 {
1473 if (FD_ISSET(pThis->hNative, &fdsetR))
1474 *pfEvents |= RTSOCKET_EVT_READ;
1475 if (FD_ISSET(pThis->hNative, &fdsetW))
1476 *pfEvents |= RTSOCKET_EVT_WRITE;
1477 if (FD_ISSET(pThis->hNative, &fdsetE))
1478 *pfEvents |= RTSOCKET_EVT_ERROR;
1479
1480 rc = VINF_SUCCESS;
1481 }
1482 else if (rc == 0)
1483 rc = VERR_TIMEOUT;
1484 else
1485 rc = rtSocketError();
1486
1487 return rc;
1488}
1489
1490
1491RTDECL(int) RTSocketShutdown(RTSOCKET hSocket, bool fRead, bool fWrite)
1492{
1493 /*
1494 * Validate input, don't lock it because we might want to interrupt a call
1495 * active on a different thread.
1496 */
1497 RTSOCKETINT *pThis = hSocket;
1498 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1499 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
1500 AssertReturn(RTMemPoolRefCount(pThis) >= (pThis->cUsers ? 2U : 1U), VERR_CALLER_NO_REFERENCE);
1501 AssertReturn(fRead || fWrite, VERR_INVALID_PARAMETER);
1502
1503 /*
1504 * Do the job.
1505 */
1506 int rc = VINF_SUCCESS;
1507 int fHow;
1508 if (fRead && fWrite)
1509 fHow = SHUT_RDWR;
1510 else if (fRead)
1511 fHow = SHUT_RD;
1512 else
1513 fHow = SHUT_WR;
1514 if (shutdown(pThis->hNative, fHow) == -1)
1515 rc = rtSocketError();
1516
1517 return rc;
1518}
1519
1520
1521RTDECL(int) RTSocketGetLocalAddress(RTSOCKET hSocket, PRTNETADDR pAddr)
1522{
1523 /*
1524 * Validate input.
1525 */
1526 RTSOCKETINT *pThis = hSocket;
1527 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1528 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
1529 AssertReturn(RTMemPoolRefCount(pThis) >= (pThis->cUsers ? 2U : 1U), VERR_CALLER_NO_REFERENCE);
1530
1531 /*
1532 * Get the address and convert it.
1533 */
1534 int rc;
1535 RTSOCKADDRUNION u;
1536#ifdef RT_OS_WINDOWS
1537 int cbAddr = sizeof(u);
1538#else
1539 socklen_t cbAddr = sizeof(u);
1540#endif
1541 RT_ZERO(u);
1542 if (getsockname(pThis->hNative, &u.Addr, &cbAddr) == 0)
1543 rc = rtSocketNetAddrFromAddr(&u, cbAddr, pAddr);
1544 else
1545 rc = rtSocketError();
1546
1547 return rc;
1548}
1549
1550
1551RTDECL(int) RTSocketGetPeerAddress(RTSOCKET hSocket, PRTNETADDR pAddr)
1552{
1553 /*
1554 * Validate input.
1555 */
1556 RTSOCKETINT *pThis = hSocket;
1557 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1558 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
1559 AssertReturn(RTMemPoolRefCount(pThis) >= (pThis->cUsers ? 2U : 1U), VERR_CALLER_NO_REFERENCE);
1560
1561 /*
1562 * Get the address and convert it.
1563 */
1564 int rc;
1565 RTSOCKADDRUNION u;
1566#ifdef RT_OS_WINDOWS
1567 int cbAddr = sizeof(u);
1568#else
1569 socklen_t cbAddr = sizeof(u);
1570#endif
1571 RT_ZERO(u);
1572 if (getpeername(pThis->hNative, &u.Addr, &cbAddr) == 0)
1573 rc = rtSocketNetAddrFromAddr(&u, cbAddr, pAddr);
1574 else
1575 rc = rtSocketError();
1576
1577 return rc;
1578}
1579
1580
1581
1582/**
1583 * Wrapper around bind.
1584 *
1585 * @returns IPRT status code.
1586 * @param hSocket The socket handle.
1587 * @param pAddr The address to bind to.
1588 */
1589int rtSocketBind(RTSOCKET hSocket, PCRTNETADDR pAddr)
1590{
1591 RTSOCKADDRUNION u;
1592 int cbAddr;
1593 int rc = rtSocketAddrFromNetAddr(pAddr, &u, sizeof(u), &cbAddr);
1594 if (RT_SUCCESS(rc))
1595 rc = rtSocketBindRawAddr(hSocket, &u.Addr, cbAddr);
1596 return rc;
1597}
1598
1599
1600/**
1601 * Very thin wrapper around bind.
1602 *
1603 * @returns IPRT status code.
1604 * @param hSocket The socket handle.
1605 * @param pvAddr The address to bind to (struct sockaddr and
1606 * friends).
1607 * @param cbAddr The size of the address.
1608 */
1609int rtSocketBindRawAddr(RTSOCKET hSocket, void const *pvAddr, size_t cbAddr)
1610{
1611 /*
1612 * Validate input.
1613 */
1614 RTSOCKETINT *pThis = hSocket;
1615 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1616 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
1617 AssertPtrReturn(pvAddr, VERR_INVALID_POINTER);
1618 AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
1619
1620 int rc;
1621 if (bind(pThis->hNative, (struct sockaddr const *)pvAddr, (int)cbAddr) == 0)
1622 rc = VINF_SUCCESS;
1623 else
1624 rc = rtSocketError();
1625
1626 rtSocketUnlock(pThis);
1627 return rc;
1628}
1629
1630
1631
1632/**
1633 * Wrapper around listen.
1634 *
1635 * @returns IPRT status code.
1636 * @param hSocket The socket handle.
1637 * @param cMaxPending The max number of pending connections.
1638 */
1639int rtSocketListen(RTSOCKET hSocket, int cMaxPending)
1640{
1641 /*
1642 * Validate input.
1643 */
1644 RTSOCKETINT *pThis = hSocket;
1645 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1646 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
1647 AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
1648
1649 int rc = VINF_SUCCESS;
1650 if (listen(pThis->hNative, cMaxPending) != 0)
1651 rc = rtSocketError();
1652
1653 rtSocketUnlock(pThis);
1654 return rc;
1655}
1656
1657
1658/**
1659 * Wrapper around accept.
1660 *
1661 * @returns IPRT status code.
1662 * @param hSocket The socket handle.
1663 * @param phClient Where to return the client socket handle on
1664 * success.
1665 * @param pAddr Where to return the client address.
1666 * @param pcbAddr On input this gives the size buffer size of what
1667 * @a pAddr point to. On return this contains the
1668 * size of what's stored at @a pAddr.
1669 */
1670int rtSocketAccept(RTSOCKET hSocket, PRTSOCKET phClient, struct sockaddr *pAddr, size_t *pcbAddr)
1671{
1672 /*
1673 * Validate input.
1674 * Only lock the socket temporarily while we get the native handle, so that
1675 * we can safely shutdown and destroy the socket from a different thread.
1676 */
1677 RTSOCKETINT *pThis = hSocket;
1678 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1679 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
1680 AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
1681
1682 /*
1683 * Call accept().
1684 */
1685 rtSocketErrorReset();
1686 int rc = VINF_SUCCESS;
1687#ifdef RT_OS_WINDOWS
1688 int cbAddr = (int)*pcbAddr;
1689#else
1690 socklen_t cbAddr = *pcbAddr;
1691#endif
1692 RTSOCKETNATIVE hNativeClient = accept(pThis->hNative, pAddr, &cbAddr);
1693 if (hNativeClient != NIL_RTSOCKETNATIVE)
1694 {
1695 *pcbAddr = cbAddr;
1696
1697 /*
1698 * Wrap the client socket.
1699 */
1700 rc = rtSocketCreateForNative(phClient, hNativeClient);
1701 if (RT_FAILURE(rc))
1702 {
1703#ifdef RT_OS_WINDOWS
1704 closesocket(hNativeClient);
1705#else
1706 close(hNativeClient);
1707#endif
1708 }
1709 }
1710 else
1711 rc = rtSocketError();
1712
1713 rtSocketUnlock(pThis);
1714 return rc;
1715}
1716
1717
1718/**
1719 * Wrapper around connect.
1720 *
1721 * @returns IPRT status code.
1722 * @param hSocket The socket handle.
1723 * @param pAddr The socket address to connect to.
1724 * @param cMillies Number of milliseconds to wait for the connect attempt to complete.
1725 * Use RT_INDEFINITE_WAIT to wait for ever.
1726 * Use RT_TCPCLIENTCONNECT_DEFAULT_WAIT to wait for the default time
1727 * configured on the running system.
1728 */
1729int rtSocketConnect(RTSOCKET hSocket, PCRTNETADDR pAddr, RTMSINTERVAL cMillies)
1730{
1731 /*
1732 * Validate input.
1733 */
1734 RTSOCKETINT *pThis = hSocket;
1735 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1736 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
1737 AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
1738
1739 RTSOCKADDRUNION u;
1740 int cbAddr;
1741 int rc = rtSocketAddrFromNetAddr(pAddr, &u, sizeof(u), &cbAddr);
1742 if (RT_SUCCESS(rc))
1743 {
1744 if (cMillies == RT_SOCKETCONNECT_DEFAULT_WAIT)
1745 {
1746 if (connect(pThis->hNative, &u.Addr, cbAddr) != 0)
1747 rc = rtSocketError();
1748 }
1749 else
1750 {
1751 /*
1752 * Switch the socket to nonblocking mode, initiate the connect
1753 * and wait for the socket to become writable or until the timeout
1754 * expires.
1755 */
1756 rc = rtSocketSwitchBlockingMode(pThis, false /* fBlocking */);
1757 if (RT_SUCCESS(rc))
1758 {
1759 if (connect(pThis->hNative, &u.Addr, cbAddr) != 0)
1760 {
1761 rc = rtSocketError();
1762 if (rc == VERR_TRY_AGAIN || rc == VERR_NET_IN_PROGRESS)
1763 {
1764 int rcSock = 0;
1765 fd_set FdSetWriteable;
1766 struct timeval TvTimeout;
1767
1768 TvTimeout.tv_sec = cMillies / RT_MS_1SEC;
1769 TvTimeout.tv_usec = (cMillies % RT_MS_1SEC) * RT_US_1MS;
1770
1771 FD_ZERO(&FdSetWriteable);
1772 FD_SET(pThis->hNative, &FdSetWriteable);
1773 do
1774 {
1775 rcSock = select(pThis->hNative + 1, NULL, &FdSetWriteable, NULL,
1776 cMillies == RT_INDEFINITE_WAIT || cMillies >= INT_MAX
1777 ? NULL
1778 : &TvTimeout);
1779 if (rcSock > 0)
1780 {
1781 int iSockError = 0;
1782 socklen_t cbSockOpt = sizeof(iSockError);
1783 rcSock = getsockopt(pThis->hNative, SOL_SOCKET, SO_ERROR, (char *)&iSockError, &cbSockOpt);
1784 if (rcSock == 0)
1785 {
1786 if (iSockError == 0)
1787 rc = VINF_SUCCESS;
1788 else
1789 {
1790#ifdef RT_OS_WINDOWS
1791 rc = RTErrConvertFromWin32(iSockError);
1792#else
1793 rc = RTErrConvertFromErrno(iSockError);
1794#endif
1795 }
1796 }
1797 else
1798 rc = rtSocketError();
1799 }
1800 else if (rcSock == 0)
1801 rc = VERR_TIMEOUT;
1802 else
1803 rc = rtSocketError();
1804 } while (rc == VERR_INTERRUPTED);
1805 }
1806 }
1807
1808 rtSocketSwitchBlockingMode(pThis, true /* fBlocking */);
1809 }
1810 }
1811 }
1812
1813 rtSocketUnlock(pThis);
1814 return rc;
1815}
1816
1817
1818/**
1819 * Wrapper around setsockopt.
1820 *
1821 * @returns IPRT status code.
1822 * @param hSocket The socket handle.
1823 * @param iLevel The protocol level, e.g. IPPORTO_TCP.
1824 * @param iOption The option, e.g. TCP_NODELAY.
1825 * @param pvValue The value buffer.
1826 * @param cbValue The size of the value pointed to by pvValue.
1827 */
1828int rtSocketSetOpt(RTSOCKET hSocket, int iLevel, int iOption, void const *pvValue, int cbValue)
1829{
1830 /*
1831 * Validate input.
1832 */
1833 RTSOCKETINT *pThis = hSocket;
1834 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1835 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
1836 AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
1837
1838 int rc = VINF_SUCCESS;
1839 if (setsockopt(pThis->hNative, iLevel, iOption, (const char *)pvValue, cbValue) != 0)
1840 rc = rtSocketError();
1841
1842 rtSocketUnlock(pThis);
1843 return rc;
1844}
1845
1846
1847/**
1848 * Internal RTPollSetAdd helper that returns the handle that should be added to
1849 * the pollset.
1850 *
1851 * @returns Valid handle on success, INVALID_HANDLE_VALUE on failure.
1852 * @param hSocket The socket handle.
1853 * @param fEvents The events we're polling for.
1854 * @param phNative Where to put the primary handle.
1855 */
1856int rtSocketPollGetHandle(RTSOCKET hSocket, uint32_t fEvents, PRTHCINTPTR phNative)
1857{
1858 RTSOCKETINT *pThis = hSocket;
1859 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1860 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, VERR_INVALID_HANDLE);
1861#ifdef RT_OS_WINDOWS
1862 AssertReturn(rtSocketTryLock(pThis), VERR_CONCURRENT_ACCESS);
1863
1864 int rc = VINF_SUCCESS;
1865 if (pThis->hEvent != WSA_INVALID_EVENT)
1866 *phNative = (RTHCINTPTR)pThis->hEvent;
1867 else
1868 {
1869 pThis->hEvent = WSACreateEvent();
1870 *phNative = (RTHCINTPTR)pThis->hEvent;
1871 if (pThis->hEvent == WSA_INVALID_EVENT)
1872 rc = rtSocketError();
1873 }
1874
1875 rtSocketUnlock(pThis);
1876 return rc;
1877
1878#else /* !RT_OS_WINDOWS */
1879 *phNative = (RTHCUINTPTR)pThis->hNative;
1880 return VINF_SUCCESS;
1881#endif /* !RT_OS_WINDOWS */
1882}
1883
1884#ifdef RT_OS_WINDOWS
1885
1886/**
1887 * Undos the harm done by WSAEventSelect.
1888 *
1889 * @returns IPRT status code.
1890 * @param pThis The socket handle.
1891 */
1892static int rtSocketPollClearEventAndRestoreBlocking(RTSOCKETINT *pThis)
1893{
1894 int rc = VINF_SUCCESS;
1895 if (pThis->fSubscribedEvts)
1896 {
1897 if (WSAEventSelect(pThis->hNative, WSA_INVALID_EVENT, 0) == 0)
1898 {
1899 pThis->fSubscribedEvts = 0;
1900
1901 /*
1902 * Switch back to blocking mode if that was the state before the
1903 * operation.
1904 */
1905 if (pThis->fBlocking)
1906 {
1907 u_long fNonBlocking = 0;
1908 int rc2 = ioctlsocket(pThis->hNative, FIONBIO, &fNonBlocking);
1909 if (rc2 != 0)
1910 {
1911 rc = rtSocketError();
1912 AssertMsgFailed(("%Rrc; rc2=%d\n", rc, rc2));
1913 }
1914 }
1915 }
1916 else
1917 {
1918 rc = rtSocketError();
1919 AssertMsgFailed(("%Rrc\n", rc));
1920 }
1921 }
1922 return rc;
1923}
1924
1925
1926/**
1927 * Updates the mask of events we're subscribing to.
1928 *
1929 * @returns IPRT status code.
1930 * @param pThis The socket handle.
1931 * @param fEvents The events we want to subscribe to.
1932 */
1933static int rtSocketPollUpdateEvents(RTSOCKETINT *pThis, uint32_t fEvents)
1934{
1935 LONG fNetworkEvents = 0;
1936 if (fEvents & RTPOLL_EVT_READ)
1937 fNetworkEvents |= FD_READ;
1938 if (fEvents & RTPOLL_EVT_WRITE)
1939 fNetworkEvents |= FD_WRITE;
1940 if (fEvents & RTPOLL_EVT_ERROR)
1941 fNetworkEvents |= FD_CLOSE;
1942 LogFlowFunc(("fNetworkEvents=%#x\n", fNetworkEvents));
1943 if (WSAEventSelect(pThis->hNative, pThis->hEvent, fNetworkEvents) == 0)
1944 {
1945 pThis->fSubscribedEvts = fEvents;
1946 return VINF_SUCCESS;
1947 }
1948
1949 int rc = rtSocketError();
1950 AssertMsgFailed(("fNetworkEvents=%#x rc=%Rrc\n", fNetworkEvents, rtSocketError()));
1951 return rc;
1952}
1953
1954#endif /* RT_OS_WINDOWS */
1955
1956
1957#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
1958
1959/**
1960 * Checks for pending events.
1961 *
1962 * @returns Event mask or 0.
1963 * @param pThis The socket handle.
1964 * @param fEvents The desired events.
1965 */
1966static uint32_t rtSocketPollCheck(RTSOCKETINT *pThis, uint32_t fEvents)
1967{
1968 uint32_t fRetEvents = 0;
1969
1970 LogFlowFunc(("pThis=%#p fEvents=%#x\n", pThis, fEvents));
1971
1972# ifdef RT_OS_WINDOWS
1973 /* Make sure WSAEnumNetworkEvents returns what we want. */
1974 int rc = VINF_SUCCESS;
1975 if ((pThis->fSubscribedEvts & fEvents) != fEvents)
1976 rc = rtSocketPollUpdateEvents(pThis, pThis->fSubscribedEvts | fEvents);
1977
1978 /* Get the event mask, ASSUMES that WSAEnumNetworkEvents doesn't clear stuff. */
1979 WSANETWORKEVENTS NetEvts;
1980 RT_ZERO(NetEvts);
1981 if (WSAEnumNetworkEvents(pThis->hNative, pThis->hEvent, &NetEvts) == 0)
1982 {
1983 if ( (NetEvts.lNetworkEvents & FD_READ)
1984 && (fEvents & RTPOLL_EVT_READ)
1985 && NetEvts.iErrorCode[FD_READ_BIT] == 0)
1986 fRetEvents |= RTPOLL_EVT_READ;
1987
1988 if ( (NetEvts.lNetworkEvents & FD_WRITE)
1989 && (fEvents & RTPOLL_EVT_WRITE)
1990 && NetEvts.iErrorCode[FD_WRITE_BIT] == 0)
1991 fRetEvents |= RTPOLL_EVT_WRITE;
1992
1993 if (fEvents & RTPOLL_EVT_ERROR)
1994 {
1995 if (NetEvts.lNetworkEvents & FD_CLOSE)
1996 fRetEvents |= RTPOLL_EVT_ERROR;
1997 else
1998 for (uint32_t i = 0; i < FD_MAX_EVENTS; i++)
1999 if ( (NetEvts.lNetworkEvents & (1L << i))
2000 && NetEvts.iErrorCode[i] != 0)
2001 fRetEvents |= RTPOLL_EVT_ERROR;
2002 }
2003 }
2004 else
2005 rc = rtSocketError();
2006
2007 /* Fall back on select if we hit an error above. */
2008 if (RT_FAILURE(rc))
2009 {
2010
2011 }
2012
2013#else /* RT_OS_OS2 */
2014 int aFds[4] = { pThis->hNative, pThis->hNative, pThis->hNative, -1 };
2015 int rc = os2_select(aFds, 1, 1, 1, 0);
2016 if (rc > 0)
2017 {
2018 if (aFds[0] == pThis->hNative)
2019 fRetEvents |= RTPOLL_EVT_READ;
2020 if (aFds[1] == pThis->hNative)
2021 fRetEvents |= RTPOLL_EVT_WRITE;
2022 if (aFds[2] == pThis->hNative)
2023 fRetEvents |= RTPOLL_EVT_ERROR;
2024 fRetEvents &= fEvents;
2025 }
2026#endif /* RT_OS_OS2 */
2027
2028 LogFlowFunc(("fRetEvents=%#x\n", fRetEvents));
2029 return fRetEvents;
2030}
2031
2032
2033/**
2034 * Internal RTPoll helper that polls the socket handle and, if @a fNoWait is
2035 * clear, starts whatever actions we've got running during the poll call.
2036 *
2037 * @returns 0 if no pending events, actions initiated if @a fNoWait is clear.
2038 * Event mask (in @a fEvents) and no actions if the handle is ready
2039 * already.
2040 * UINT32_MAX (asserted) if the socket handle is busy in I/O or a
2041 * different poll set.
2042 *
2043 * @param hSocket The socket handle.
2044 * @param hPollSet The poll set handle (for access checks).
2045 * @param fEvents The events we're polling for.
2046 * @param fFinalEntry Set if this is the final entry for this handle
2047 * in this poll set. This can be used for dealing
2048 * with duplicate entries.
2049 * @param fNoWait Set if it's a zero-wait poll call. Clear if
2050 * we'll wait for an event to occur.
2051 *
2052 * @remarks There is a potential race wrt duplicate handles when @a fNoWait is
2053 * @c true, we don't currently care about that oddity...
2054 */
2055uint32_t rtSocketPollStart(RTSOCKET hSocket, RTPOLLSET hPollSet, uint32_t fEvents, bool fFinalEntry, bool fNoWait)
2056{
2057 RTSOCKETINT *pThis = hSocket;
2058 AssertPtrReturn(pThis, UINT32_MAX);
2059 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, UINT32_MAX);
2060 /** @todo This isn't quite sane. Replace by critsect and open up concurrent
2061 * reads and writes! */
2062 if (rtSocketTryLock(pThis))
2063 pThis->hPollSet = hPollSet;
2064 else
2065 {
2066 AssertReturn(pThis->hPollSet == hPollSet, UINT32_MAX);
2067 ASMAtomicIncU32(&pThis->cUsers);
2068 }
2069
2070 /* (rtSocketPollCheck will reset the event object). */
2071# ifdef RT_OS_WINDOWS
2072 uint32_t fRetEvents = pThis->fEventsSaved;
2073 pThis->fEventsSaved = 0; /* Reset */
2074 fRetEvents |= rtSocketPollCheck(pThis, fEvents);
2075
2076 if ( !fRetEvents
2077 && !fNoWait)
2078 {
2079 pThis->fPollEvts |= fEvents;
2080 if ( fFinalEntry
2081 && pThis->fSubscribedEvts != pThis->fPollEvts)
2082 {
2083 int rc = rtSocketPollUpdateEvents(pThis, pThis->fPollEvts);
2084 if (RT_FAILURE(rc))
2085 {
2086 pThis->fPollEvts = 0;
2087 fRetEvents = UINT32_MAX;
2088 }
2089 }
2090 }
2091# else
2092 uint32_t fRetEvents = rtSocketPollCheck(pThis, fEvents);
2093# endif
2094
2095 if (fRetEvents || fNoWait)
2096 {
2097 if (pThis->cUsers == 1)
2098 {
2099# ifdef RT_OS_WINDOWS
2100 rtSocketPollClearEventAndRestoreBlocking(pThis);
2101# endif
2102 pThis->hPollSet = NIL_RTPOLLSET;
2103 }
2104 ASMAtomicDecU32(&pThis->cUsers);
2105 }
2106
2107 return fRetEvents;
2108}
2109
2110
2111/**
2112 * Called after a WaitForMultipleObjects returned in order to check for pending
2113 * events and stop whatever actions that rtSocketPollStart() initiated.
2114 *
2115 * @returns Event mask or 0.
2116 *
2117 * @param hSocket The socket handle.
2118 * @param fEvents The events we're polling for.
2119 * @param fFinalEntry Set if this is the final entry for this handle
2120 * in this poll set. This can be used for dealing
2121 * with duplicate entries. Only keep in mind that
2122 * this method is called in reverse order, so the
2123 * first call will have this set (when the entire
2124 * set was processed).
2125 * @param fHarvestEvents Set if we should check for pending events.
2126 */
2127uint32_t rtSocketPollDone(RTSOCKET hSocket, uint32_t fEvents, bool fFinalEntry, bool fHarvestEvents)
2128{
2129 RTSOCKETINT *pThis = hSocket;
2130 AssertPtrReturn(pThis, 0);
2131 AssertReturn(pThis->u32Magic == RTSOCKET_MAGIC, 0);
2132 Assert(pThis->cUsers > 0);
2133 Assert(pThis->hPollSet != NIL_RTPOLLSET);
2134
2135 /* Harvest events and clear the event mask for the next round of polling. */
2136 uint32_t fRetEvents = rtSocketPollCheck(pThis, fEvents);
2137# ifdef RT_OS_WINDOWS
2138 pThis->fPollEvts = 0;
2139
2140 /*
2141 * Save the write event if required.
2142 * It is only posted once and might get lost if the another source in the
2143 * pollset with a higher priority has pending events.
2144 */
2145 if ( !fHarvestEvents
2146 && fRetEvents)
2147 {
2148 pThis->fEventsSaved = fRetEvents;
2149 fRetEvents = 0;
2150 }
2151# endif
2152
2153 /* Make the socket blocking again and unlock the handle. */
2154 if (pThis->cUsers == 1)
2155 {
2156# ifdef RT_OS_WINDOWS
2157 rtSocketPollClearEventAndRestoreBlocking(pThis);
2158# endif
2159 pThis->hPollSet = NIL_RTPOLLSET;
2160 }
2161 ASMAtomicDecU32(&pThis->cUsers);
2162 return fRetEvents;
2163}
2164
2165#endif /* RT_OS_WINDOWS || RT_OS_OS2 */
2166
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