FreeRDP
Loading...
Searching...
No Matches
winsock.c
1
20#include <winpr/config.h>
21
22#include <winpr/assert.h>
23#include <winpr/crt.h>
24#include <winpr/synch.h>
25
26#include <winpr/winsock.h>
27
28#ifdef WINPR_HAVE_UNISTD_H
29#include <unistd.h>
30#endif
31#ifdef WINPR_HAVE_SYS_FILIO_H
32#include <sys/filio.h>
33#endif
34#ifdef WINPR_HAVE_SYS_SOCKIO_H
35#include <sys/sockio.h>
36#endif
37
38#ifndef _WIN32
39#include <fcntl.h>
40#endif
41
42#ifdef __APPLE__
43#define WSAIOCTL_IFADDRS
44#include <ifaddrs.h>
45#endif
46
232#ifdef _WIN32
233
234#if (_WIN32_WINNT < 0x0600)
235
236PCSTR winpr_inet_ntop(INT Family, PVOID pAddr, PSTR pStringBuf, size_t StringBufSize)
237{
238 if (Family == AF_INET)
239 {
240 struct sockaddr_in in = { 0 };
241
242 in.sin_family = AF_INET;
243 memcpy(&in.sin_addr, pAddr, sizeof(struct in_addr));
244 getnameinfo((struct sockaddr*)&in, sizeof(struct sockaddr_in), pStringBuf, StringBufSize,
245 NULL, 0, NI_NUMERICHOST);
246 return pStringBuf;
247 }
248 else if (Family == AF_INET6)
249 {
250 struct sockaddr_in6 in = { 0 };
251
252 in.sin6_family = AF_INET6;
253 memcpy(&in.sin6_addr, pAddr, sizeof(struct in_addr6));
254 getnameinfo((struct sockaddr*)&in, sizeof(struct sockaddr_in6), pStringBuf, StringBufSize,
255 NULL, 0, NI_NUMERICHOST);
256 return pStringBuf;
257 }
258
259 return NULL;
260}
261
262INT winpr_inet_pton(INT Family, PCSTR pszAddrString, PVOID pAddrBuf)
263{
264 SOCKADDR_STORAGE addr;
265 int addr_len = sizeof(addr);
266
267 if ((Family != AF_INET) && (Family != AF_INET6))
268 return -1;
269
270 if (WSAStringToAddressA((char*)pszAddrString, Family, NULL, (struct sockaddr*)&addr,
271 &addr_len) != 0)
272 return 0;
273
274 if (Family == AF_INET)
275 {
276 memcpy(pAddrBuf, &((struct sockaddr_in*)&addr)->sin_addr, sizeof(struct in_addr));
277 }
278 else if (Family == AF_INET6)
279 {
280 memcpy(pAddrBuf, &((struct sockaddr_in6*)&addr)->sin6_addr, sizeof(struct in6_addr));
281 }
282
283 return 1;
284}
285
286#endif /* (_WIN32_WINNT < 0x0600) */
287
288#else /* _WIN32 */
289
290#include <netdb.h>
291#include <errno.h>
292#include <sys/ioctl.h>
293#include <sys/socket.h>
294#include <netinet/in.h>
295#include <netinet/tcp.h>
296#include <net/if.h>
297
298#ifndef MSG_NOSIGNAL
299#define MSG_NOSIGNAL 0
300#endif
301
302int WSAStartup(WORD wVersionRequired, LPWSADATA lpWSAData)
303{
304 WINPR_ASSERT(lpWSAData);
305
306 ZeroMemory(lpWSAData, sizeof(WSADATA));
307 lpWSAData->wVersion = wVersionRequired;
308 lpWSAData->wHighVersion = MAKEWORD(2, 2);
309 return 0; /* success */
310}
311
312int WSACleanup(void)
313{
314 return 0; /* success */
315}
316
317void WSASetLastError(int iError)
318{
319 switch (iError)
320 {
321 /* Base error codes */
322 case WSAEINTR:
323 errno = EINTR;
324 break;
325
326 case WSAEBADF:
327 errno = EBADF;
328 break;
329
330 case WSAEACCES:
331 errno = EACCES;
332 break;
333
334 case WSAEFAULT:
335 errno = EFAULT;
336 break;
337
338 case WSAEINVAL:
339 errno = EINVAL;
340 break;
341
342 case WSAEMFILE:
343 errno = EMFILE;
344 break;
345
346 /* BSD sockets error codes */
347
348 case WSAEWOULDBLOCK:
349 errno = EWOULDBLOCK;
350 break;
351
352 case WSAEINPROGRESS:
353 errno = EINPROGRESS;
354 break;
355
356 case WSAEALREADY:
357 errno = EALREADY;
358 break;
359
360 case WSAENOTSOCK:
361 errno = ENOTSOCK;
362 break;
363
364 case WSAEDESTADDRREQ:
365 errno = EDESTADDRREQ;
366 break;
367
368 case WSAEMSGSIZE:
369 errno = EMSGSIZE;
370 break;
371
372 case WSAEPROTOTYPE:
373 errno = EPROTOTYPE;
374 break;
375
376 case WSAENOPROTOOPT:
377 errno = ENOPROTOOPT;
378 break;
379
380 case WSAEPROTONOSUPPORT:
381 errno = EPROTONOSUPPORT;
382 break;
383
384 case WSAESOCKTNOSUPPORT:
385 errno = ESOCKTNOSUPPORT;
386 break;
387
388 case WSAEOPNOTSUPP:
389 errno = EOPNOTSUPP;
390 break;
391
392 case WSAEPFNOSUPPORT:
393 errno = EPFNOSUPPORT;
394 break;
395
396 case WSAEAFNOSUPPORT:
397 errno = EAFNOSUPPORT;
398 break;
399
400 case WSAEADDRINUSE:
401 errno = EADDRINUSE;
402 break;
403
404 case WSAEADDRNOTAVAIL:
405 errno = EADDRNOTAVAIL;
406 break;
407
408 case WSAENETDOWN:
409 errno = ENETDOWN;
410 break;
411
412 case WSAENETUNREACH:
413 errno = ENETUNREACH;
414 break;
415
416 case WSAENETRESET:
417 errno = ENETRESET;
418 break;
419
420 case WSAECONNABORTED:
421 errno = ECONNABORTED;
422 break;
423
424 case WSAECONNRESET:
425 errno = ECONNRESET;
426 break;
427
428 case WSAENOBUFS:
429 errno = ENOBUFS;
430 break;
431
432 case WSAEISCONN:
433 errno = EISCONN;
434 break;
435
436 case WSAENOTCONN:
437 errno = ENOTCONN;
438 break;
439
440 case WSAESHUTDOWN:
441 errno = ESHUTDOWN;
442 break;
443
444 case WSAETOOMANYREFS:
445 errno = ETOOMANYREFS;
446 break;
447
448 case WSAETIMEDOUT:
449 errno = ETIMEDOUT;
450 break;
451
452 case WSAECONNREFUSED:
453 errno = ECONNREFUSED;
454 break;
455
456 case WSAELOOP:
457 errno = ELOOP;
458 break;
459
460 case WSAENAMETOOLONG:
461 errno = ENAMETOOLONG;
462 break;
463
464 case WSAEHOSTDOWN:
465 errno = EHOSTDOWN;
466 break;
467
468 case WSAEHOSTUNREACH:
469 errno = EHOSTUNREACH;
470 break;
471
472 case WSAENOTEMPTY:
473 errno = ENOTEMPTY;
474 break;
475#ifdef EPROCLIM
476
477 case WSAEPROCLIM:
478 errno = EPROCLIM;
479 break;
480#endif
481
482 case WSAEUSERS:
483 errno = EUSERS;
484 break;
485
486 case WSAEDQUOT:
487 errno = EDQUOT;
488 break;
489
490 case WSAESTALE:
491 errno = ESTALE;
492 break;
493
494 case WSAEREMOTE:
495 errno = EREMOTE;
496 break;
497 default:
498 break;
499 }
500}
501
502int WSAGetLastError(void)
503{
504 int iError = 0;
505
506 switch (errno)
507 {
508 /* Base error codes */
509 case EINTR:
510 iError = WSAEINTR;
511 break;
512
513 case EBADF:
514 iError = WSAEBADF;
515 break;
516
517 case EACCES:
518 iError = WSAEACCES;
519 break;
520
521 case EFAULT:
522 iError = WSAEFAULT;
523 break;
524
525 case EINVAL:
526 iError = WSAEINVAL;
527 break;
528
529 case EMFILE:
530 iError = WSAEMFILE;
531 break;
532
533 /* BSD sockets error codes */
534
535 case EWOULDBLOCK:
536 iError = WSAEWOULDBLOCK;
537 break;
538
539 case EINPROGRESS:
540 iError = WSAEINPROGRESS;
541 break;
542
543 case EALREADY:
544 iError = WSAEALREADY;
545 break;
546
547 case ENOTSOCK:
548 iError = WSAENOTSOCK;
549 break;
550
551 case EDESTADDRREQ:
552 iError = WSAEDESTADDRREQ;
553 break;
554
555 case EMSGSIZE:
556 iError = WSAEMSGSIZE;
557 break;
558
559 case EPROTOTYPE:
560 iError = WSAEPROTOTYPE;
561 break;
562
563 case ENOPROTOOPT:
564 iError = WSAENOPROTOOPT;
565 break;
566
567 case EPROTONOSUPPORT:
568 iError = WSAEPROTONOSUPPORT;
569 break;
570
571 case ESOCKTNOSUPPORT:
572 iError = WSAESOCKTNOSUPPORT;
573 break;
574
575 case EOPNOTSUPP:
576 iError = WSAEOPNOTSUPP;
577 break;
578
579 case EPFNOSUPPORT:
580 iError = WSAEPFNOSUPPORT;
581 break;
582
583 case EAFNOSUPPORT:
584 iError = WSAEAFNOSUPPORT;
585 break;
586
587 case EADDRINUSE:
588 iError = WSAEADDRINUSE;
589 break;
590
591 case EADDRNOTAVAIL:
592 iError = WSAEADDRNOTAVAIL;
593 break;
594
595 case ENETDOWN:
596 iError = WSAENETDOWN;
597 break;
598
599 case ENETUNREACH:
600 iError = WSAENETUNREACH;
601 break;
602
603 case ENETRESET:
604 iError = WSAENETRESET;
605 break;
606
607 case ECONNABORTED:
608 iError = WSAECONNABORTED;
609 break;
610
611 case ECONNRESET:
612 iError = WSAECONNRESET;
613 break;
614
615 case ENOBUFS:
616 iError = WSAENOBUFS;
617 break;
618
619 case EISCONN:
620 iError = WSAEISCONN;
621 break;
622
623 case ENOTCONN:
624 iError = WSAENOTCONN;
625 break;
626
627 case ESHUTDOWN:
628 iError = WSAESHUTDOWN;
629 break;
630
631 case ETOOMANYREFS:
632 iError = WSAETOOMANYREFS;
633 break;
634
635 case ETIMEDOUT:
636 iError = WSAETIMEDOUT;
637 break;
638
639 case ECONNREFUSED:
640 iError = WSAECONNREFUSED;
641 break;
642
643 case ELOOP:
644 iError = WSAELOOP;
645 break;
646
647 case ENAMETOOLONG:
648 iError = WSAENAMETOOLONG;
649 break;
650
651 case EHOSTDOWN:
652 iError = WSAEHOSTDOWN;
653 break;
654
655 case EHOSTUNREACH:
656 iError = WSAEHOSTUNREACH;
657 break;
658
659 case ENOTEMPTY:
660 iError = WSAENOTEMPTY;
661 break;
662#ifdef EPROCLIM
663
664 case EPROCLIM:
665 iError = WSAEPROCLIM;
666 break;
667#endif
668
669 case EUSERS:
670 iError = WSAEUSERS;
671 break;
672
673 case EDQUOT:
674 iError = WSAEDQUOT;
675 break;
676
677 case ESTALE:
678 iError = WSAESTALE;
679 break;
680
681 case EREMOTE:
682 iError = WSAEREMOTE;
683 break;
684 /* Special cases */
685#if (EAGAIN != EWOULDBLOCK)
686
687 case EAGAIN:
688 iError = WSAEWOULDBLOCK;
689 break;
690#endif
691#if defined(EPROTO)
692
693 case EPROTO:
694 iError = WSAECONNRESET;
695 break;
696#endif
697 default:
698 break;
699 }
700
720 return iError;
721}
722
723HANDLE WSACreateEvent(void)
724{
725 return CreateEvent(NULL, TRUE, FALSE, NULL);
726}
727
728BOOL WSASetEvent(HANDLE hEvent)
729{
730 return SetEvent(hEvent);
731}
732
733BOOL WSAResetEvent(WINPR_ATTR_UNUSED HANDLE hEvent)
734{
735 /* POSIX systems auto reset the socket,
736 * if no more data is available. */
737 return TRUE;
738}
739
740BOOL WSACloseEvent(HANDLE hEvent)
741{
742 BOOL status = CloseHandle(hEvent);
743
744 if (!status)
745 SetLastError(6);
746
747 return status;
748}
749
750int WSAEventSelect(SOCKET s, WSAEVENT hEventObject, LONG lNetworkEvents)
751{
752 u_long arg = 1;
753 ULONG mode = 0;
754
755 if (_ioctlsocket(s, FIONBIO, &arg) != 0)
756 return SOCKET_ERROR;
757
758 if (arg == 0)
759 return 0;
760
761 if (lNetworkEvents & FD_READ)
762 mode |= WINPR_FD_READ;
763
764 if (lNetworkEvents & FD_WRITE)
765 mode |= WINPR_FD_WRITE;
766
767 if (SetEventFileDescriptor(hEventObject, (int)s, mode) < 0)
768 return SOCKET_ERROR;
769
770 return 0;
771}
772
773DWORD WSAWaitForMultipleEvents(DWORD cEvents, const HANDLE* lphEvents, BOOL fWaitAll,
774 DWORD dwTimeout, BOOL fAlertable)
775{
776 return WaitForMultipleObjectsEx(cEvents, lphEvents, fWaitAll, dwTimeout, fAlertable);
777}
778
779SOCKET WSASocketA(int af, int type, int protocol,
780 WINPR_ATTR_UNUSED LPWSAPROTOCOL_INFOA lpProtocolInfo, WINPR_ATTR_UNUSED GROUP g,
781 WINPR_ATTR_UNUSED DWORD dwFlags)
782{
783 SOCKET s = 0;
784 s = _socket(af, type, protocol);
785 return s;
786}
787
788SOCKET WSASocketW(int af, int type, int protocol, LPWSAPROTOCOL_INFOW lpProtocolInfo, GROUP g,
789 DWORD dwFlags)
790{
791 return WSASocketA(af, type, protocol, (LPWSAPROTOCOL_INFOA)lpProtocolInfo, g, dwFlags);
792}
793
794int WSAIoctl(SOCKET s, DWORD dwIoControlCode, WINPR_ATTR_UNUSED LPVOID lpvInBuffer,
795 WINPR_ATTR_UNUSED DWORD cbInBuffer, LPVOID lpvOutBuffer, DWORD cbOutBuffer,
796 LPDWORD lpcbBytesReturned, WINPR_ATTR_UNUSED LPWSAOVERLAPPED lpOverlapped,
797 WINPR_ATTR_UNUSED LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
798{
799 int fd = 0;
800 int index = 0;
801 ULONG nFlags = 0;
802 size_t offset = 0;
803 size_t ifreq_len = 0;
804 struct ifreq* ifreq = NULL;
805 struct ifconf ifconf = { 0 };
806 char address[128] = { 0 };
807 char broadcast[128] = { 0 };
808 char netmask[128] = { 0 };
809 char buffer[4096] = { 0 };
810 size_t numInterfaces = 0;
811 size_t maxNumInterfaces = 0;
812 INTERFACE_INFO* pInterface = NULL;
813 INTERFACE_INFO* pInterfaces = NULL;
814 struct sockaddr_in* pAddress = NULL;
815 struct sockaddr_in* pBroadcast = NULL;
816 struct sockaddr_in* pNetmask = NULL;
817
818 if ((dwIoControlCode != SIO_GET_INTERFACE_LIST) ||
819 (!lpvOutBuffer || !cbOutBuffer || !lpcbBytesReturned))
820 {
821 WSASetLastError(WSAEINVAL);
822 return SOCKET_ERROR;
823 }
824
825 fd = (int)s;
826 pInterfaces = (INTERFACE_INFO*)lpvOutBuffer;
827 maxNumInterfaces = cbOutBuffer / sizeof(INTERFACE_INFO);
828#ifdef WSAIOCTL_IFADDRS
829 {
830 struct ifaddrs* ifap = NULL;
831
832 if (getifaddrs(&ifap) != 0)
833 {
834 WSASetLastError(WSAENETDOWN);
835 return SOCKET_ERROR;
836 }
837
838 index = 0;
839 numInterfaces = 0;
840
841 for (struct ifaddrs* ifa = ifap; ifa; ifa = ifa->ifa_next)
842 {
843 pInterface = &pInterfaces[index];
844 pAddress = (struct sockaddr_in*)&pInterface->iiAddress;
845 pBroadcast = (struct sockaddr_in*)&pInterface->iiBroadcastAddress;
846 pNetmask = (struct sockaddr_in*)&pInterface->iiNetmask;
847 nFlags = 0;
848
849 if (ifa->ifa_flags & IFF_UP)
850 nFlags |= _IFF_UP;
851
852 if (ifa->ifa_flags & IFF_BROADCAST)
853 nFlags |= _IFF_BROADCAST;
854
855 if (ifa->ifa_flags & IFF_LOOPBACK)
856 nFlags |= _IFF_LOOPBACK;
857
858 if (ifa->ifa_flags & IFF_POINTOPOINT)
859 nFlags |= _IFF_POINTTOPOINT;
860
861 if (ifa->ifa_flags & IFF_MULTICAST)
862 nFlags |= _IFF_MULTICAST;
863
864 pInterface->iiFlags = nFlags;
865
866 if (ifa->ifa_addr)
867 {
868 if ((ifa->ifa_addr->sa_family != AF_INET) && (ifa->ifa_addr->sa_family != AF_INET6))
869 continue;
870
871 getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr), address, sizeof(address), 0, 0,
872 NI_NUMERICHOST);
873 inet_pton(ifa->ifa_addr->sa_family, address, (void*)&pAddress->sin_addr);
874 }
875 else
876 {
877 ZeroMemory(pAddress, sizeof(struct sockaddr_in));
878 }
879
880 if (ifa->ifa_dstaddr)
881 {
882 if ((ifa->ifa_dstaddr->sa_family != AF_INET) &&
883 (ifa->ifa_dstaddr->sa_family != AF_INET6))
884 continue;
885
886 getnameinfo(ifa->ifa_dstaddr, sizeof(struct sockaddr), broadcast, sizeof(broadcast),
887 0, 0, NI_NUMERICHOST);
888 inet_pton(ifa->ifa_dstaddr->sa_family, broadcast, (void*)&pBroadcast->sin_addr);
889 }
890 else
891 {
892 ZeroMemory(pBroadcast, sizeof(struct sockaddr_in));
893 }
894
895 if (ifa->ifa_netmask)
896 {
897 if ((ifa->ifa_netmask->sa_family != AF_INET) &&
898 (ifa->ifa_netmask->sa_family != AF_INET6))
899 continue;
900
901 getnameinfo(ifa->ifa_netmask, sizeof(struct sockaddr), netmask, sizeof(netmask), 0,
902 0, NI_NUMERICHOST);
903 inet_pton(ifa->ifa_netmask->sa_family, netmask, (void*)&pNetmask->sin_addr);
904 }
905 else
906 {
907 ZeroMemory(pNetmask, sizeof(struct sockaddr_in));
908 }
909
910 numInterfaces++;
911 index++;
912 }
913
914 *lpcbBytesReturned = (DWORD)(numInterfaces * sizeof(INTERFACE_INFO));
915 freeifaddrs(ifap);
916 return 0;
917 }
918#endif
919 ifconf.ifc_len = sizeof(buffer);
920 ifconf.ifc_buf = buffer;
921
922 if (ioctl(fd, SIOCGIFCONF, &ifconf) != 0)
923 {
924 WSASetLastError(WSAENETDOWN);
925 return SOCKET_ERROR;
926 }
927
928 index = 0;
929 offset = 0;
930 numInterfaces = 0;
931 ifreq = ifconf.ifc_req;
932
933 while ((ifconf.ifc_len >= 0) && (offset < (size_t)ifconf.ifc_len) &&
934 (numInterfaces < maxNumInterfaces))
935 {
936 pInterface = &pInterfaces[index];
937 pAddress = (struct sockaddr_in*)&pInterface->iiAddress;
938 pBroadcast = (struct sockaddr_in*)&pInterface->iiBroadcastAddress;
939 pNetmask = (struct sockaddr_in*)&pInterface->iiNetmask;
940
941 if (ioctl(fd, SIOCGIFFLAGS, ifreq) != 0)
942 goto next_ifreq;
943
944 nFlags = 0;
945
946 if (ifreq->ifr_flags & IFF_UP)
947 nFlags |= _IFF_UP;
948
949 if (ifreq->ifr_flags & IFF_BROADCAST)
950 nFlags |= _IFF_BROADCAST;
951
952 if (ifreq->ifr_flags & IFF_LOOPBACK)
953 nFlags |= _IFF_LOOPBACK;
954
955 if (ifreq->ifr_flags & IFF_POINTOPOINT)
956 nFlags |= _IFF_POINTTOPOINT;
957
958 if (ifreq->ifr_flags & IFF_MULTICAST)
959 nFlags |= _IFF_MULTICAST;
960
961 pInterface->iiFlags = nFlags;
962
963 if (ioctl(fd, SIOCGIFADDR, ifreq) != 0)
964 goto next_ifreq;
965
966 if ((ifreq->ifr_addr.sa_family != AF_INET) && (ifreq->ifr_addr.sa_family != AF_INET6))
967 goto next_ifreq;
968
969 getnameinfo(&ifreq->ifr_addr, sizeof(ifreq->ifr_addr), address, sizeof(address), 0, 0,
970 NI_NUMERICHOST);
971 inet_pton(ifreq->ifr_addr.sa_family, address, (void*)&pAddress->sin_addr);
972
973 if (ioctl(fd, SIOCGIFBRDADDR, ifreq) != 0)
974 goto next_ifreq;
975
976 if ((ifreq->ifr_addr.sa_family != AF_INET) && (ifreq->ifr_addr.sa_family != AF_INET6))
977 goto next_ifreq;
978
979 getnameinfo(&ifreq->ifr_addr, sizeof(ifreq->ifr_addr), broadcast, sizeof(broadcast), 0, 0,
980 NI_NUMERICHOST);
981 inet_pton(ifreq->ifr_addr.sa_family, broadcast, (void*)&pBroadcast->sin_addr);
982
983 if (ioctl(fd, SIOCGIFNETMASK, ifreq) != 0)
984 goto next_ifreq;
985
986 if ((ifreq->ifr_addr.sa_family != AF_INET) && (ifreq->ifr_addr.sa_family != AF_INET6))
987 goto next_ifreq;
988
989 getnameinfo(&ifreq->ifr_addr, sizeof(ifreq->ifr_addr), netmask, sizeof(netmask), 0, 0,
990 NI_NUMERICHOST);
991 inet_pton(ifreq->ifr_addr.sa_family, netmask, (void*)&pNetmask->sin_addr);
992 numInterfaces++;
993 next_ifreq:
994#if !defined(__linux__) && !defined(__sun__) && !defined(__CYGWIN__) && !defined(EMSCRIPTEN)
995 ifreq_len = IFNAMSIZ + ifreq->ifr_addr.sa_len;
996#else
997 ifreq_len = sizeof(*ifreq);
998#endif
999 ifreq = (struct ifreq*)&((BYTE*)ifreq)[ifreq_len];
1000 offset += ifreq_len;
1001 index++;
1002 }
1003
1004 *lpcbBytesReturned = (DWORD)(numInterfaces * sizeof(INTERFACE_INFO));
1005 return 0;
1006}
1007
1008SOCKET _accept(SOCKET s, struct sockaddr* addr, int* addrlen)
1009{
1010 int fd = WINPR_ASSERTING_INT_CAST(int, s);
1011 socklen_t s_addrlen = (socklen_t)*addrlen;
1012 const int status = accept(fd, addr, &s_addrlen);
1013 *addrlen = (int)s_addrlen;
1014 return (SOCKET)status;
1015}
1016
1017int _bind(SOCKET s, const struct sockaddr* addr, int namelen)
1018{
1019 int status = 0;
1020 int fd = (int)s;
1021 status = bind(fd, addr, (socklen_t)namelen);
1022
1023 if (status < 0)
1024 return SOCKET_ERROR;
1025
1026 return status;
1027}
1028
1029int closesocket(SOCKET s)
1030{
1031 int status = 0;
1032 int fd = (int)s;
1033 status = close(fd);
1034 return status;
1035}
1036
1037int _connect(SOCKET s, const struct sockaddr* name, int namelen)
1038{
1039 int status = 0;
1040 int fd = (int)s;
1041 status = connect(fd, name, (socklen_t)namelen);
1042
1043 if (status < 0)
1044 return SOCKET_ERROR;
1045
1046 return status;
1047}
1048
1049// NOLINTNEXTLINE(readability-non-const-parameter)
1050int _ioctlsocket(SOCKET s, long cmd, u_long* argp)
1051{
1052 int fd = (int)s;
1053
1054 if (cmd == FIONBIO)
1055 {
1056 int flags = 0;
1057
1058 if (!argp)
1059 return SOCKET_ERROR;
1060
1061 flags = fcntl(fd, F_GETFL);
1062
1063 if (flags == -1)
1064 return SOCKET_ERROR;
1065
1066 if (*argp)
1067 (void)fcntl(fd, F_SETFL, flags | O_NONBLOCK);
1068 else
1069 (void)fcntl(fd, F_SETFL, flags & ~(O_NONBLOCK));
1070 }
1071
1072 return 0;
1073}
1074
1075int _getpeername(SOCKET s, struct sockaddr* name, int* namelen)
1076{
1077 int status = 0;
1078 int fd = (int)s;
1079 socklen_t s_namelen = (socklen_t)*namelen;
1080 status = getpeername(fd, name, &s_namelen);
1081 *namelen = (int)s_namelen;
1082 return status;
1083}
1084
1085int _getsockname(SOCKET s, struct sockaddr* name, int* namelen)
1086{
1087 int status = 0;
1088 int fd = (int)s;
1089 socklen_t s_namelen = (socklen_t)*namelen;
1090 status = getsockname(fd, name, &s_namelen);
1091 *namelen = (int)s_namelen;
1092 return status;
1093}
1094
1095int _getsockopt(SOCKET s, int level, int optname, char* optval, int* optlen)
1096{
1097 int status = 0;
1098 int fd = (int)s;
1099 socklen_t s_optlen = (socklen_t)*optlen;
1100 status = getsockopt(fd, level, optname, (void*)optval, &s_optlen);
1101 *optlen = (int)s_optlen;
1102 return status;
1103}
1104
1105u_long _htonl(u_long hostlong)
1106{
1107 WINPR_ASSERT(hostlong <= UINT32_MAX);
1108 return htonl((UINT32)hostlong);
1109}
1110
1111u_short _htons(u_short hostshort)
1112{
1113 return htons(hostshort);
1114}
1115
1116unsigned long _inet_addr(const char* cp)
1117{
1118 return WINPR_ASSERTING_INT_CAST(unsigned long, inet_addr(cp));
1119}
1120
1121char* _inet_ntoa(struct in_addr in)
1122{
1123 // NOLINTNEXTLINE(concurrency-mt-unsafe)
1124 return inet_ntoa(in);
1125}
1126
1127int _listen(SOCKET s, int backlog)
1128{
1129 int status = 0;
1130 int fd = (int)s;
1131 status = listen(fd, backlog);
1132 return status;
1133}
1134
1135u_long _ntohl(u_long netlong)
1136{
1137 WINPR_ASSERT((netlong & 0xFFFFFFFF00000000ULL) == 0);
1138 return ntohl((UINT32)netlong);
1139}
1140
1141u_short _ntohs(u_short netshort)
1142{
1143 return ntohs(netshort);
1144}
1145
1146int _recv(SOCKET s, char* buf, int len, int flags)
1147{
1148 int status = 0;
1149 int fd = (int)s;
1150 status = (int)recv(fd, (void*)buf, (size_t)len, flags);
1151 return status;
1152}
1153
1154int _recvfrom(SOCKET s, char* buf, int len, int flags, struct sockaddr* from, int* fromlen)
1155{
1156 int status = 0;
1157 int fd = (int)s;
1158 socklen_t s_fromlen = (socklen_t)*fromlen;
1159 status = (int)recvfrom(fd, (void*)buf, (size_t)len, flags, from, &s_fromlen);
1160 *fromlen = (int)s_fromlen;
1161 return status;
1162}
1163
1164int _select(int nfds, fd_set* readfds, fd_set* writefds, fd_set* exceptfds,
1165 const struct timeval* timeout)
1166{
1167 int status = 0;
1168 union
1169 {
1170 const struct timeval* cpv;
1171 struct timeval* pv;
1172 } cnv;
1173 cnv.cpv = timeout;
1174 do
1175 {
1176 status = select(nfds, readfds, writefds, exceptfds, cnv.pv);
1177 } while ((status < 0) && (errno == EINTR));
1178
1179 return status;
1180}
1181
1182int _send(SOCKET s, const char* buf, int len, int flags)
1183{
1184 int status = 0;
1185 int fd = (int)s;
1186 flags |= MSG_NOSIGNAL;
1187 status = (int)send(fd, (const void*)buf, (size_t)len, flags);
1188 return status;
1189}
1190
1191int _sendto(SOCKET s, const char* buf, int len, int flags, const struct sockaddr* to, int tolen)
1192{
1193 int status = 0;
1194 int fd = (int)s;
1195 status = (int)sendto(fd, (const void*)buf, (size_t)len, flags, to, (socklen_t)tolen);
1196 return status;
1197}
1198
1199int _setsockopt(SOCKET s, int level, int optname, const char* optval, int optlen)
1200{
1201 int status = 0;
1202 int fd = (int)s;
1203 status = setsockopt(fd, level, optname, (const void*)optval, (socklen_t)optlen);
1204 return status;
1205}
1206
1207int _shutdown(SOCKET s, int how)
1208{
1209 int status = 0;
1210 int fd = (int)s;
1211 int s_how = -1;
1212
1213 switch (how)
1214 {
1215 case SD_RECEIVE:
1216 s_how = SHUT_RD;
1217 break;
1218
1219 case SD_SEND:
1220 s_how = SHUT_WR;
1221 break;
1222
1223 case SD_BOTH:
1224 s_how = SHUT_RDWR;
1225 break;
1226 default:
1227 break;
1228 }
1229
1230 if (s_how < 0)
1231 return SOCKET_ERROR;
1232
1233 status = shutdown(fd, s_how);
1234 return status;
1235}
1236
1237SOCKET _socket(int af, int type, int protocol)
1238{
1239 int fd = 0;
1240 SOCKET s = 0;
1241 fd = socket(af, type, protocol);
1242
1243 if (fd < 0)
1244 return INVALID_SOCKET;
1245
1246 s = (SOCKET)fd;
1247 return s;
1248}
1249
1250struct hostent* _gethostbyaddr(const char* addr, int len, int type)
1251{
1252 struct hostent* host = NULL;
1253 // NOLINTNEXTLINE(concurrency-mt-unsafe)
1254 host = gethostbyaddr((const void*)addr, (socklen_t)len, type);
1255 return host;
1256}
1257
1258struct hostent* _gethostbyname(const char* name)
1259{
1260 // NOLINTNEXTLINE(concurrency-mt-unsafe)
1261 struct hostent* host = gethostbyname(name);
1262 return host;
1263}
1264
1265int _gethostname(char* name, int namelen)
1266{
1267 int status = 0;
1268 status = gethostname(name, (size_t)namelen);
1269 return status;
1270}
1271
1272struct servent* /* codespell:ignore servent */ _getservbyport(int port, const char* proto)
1273{
1274 // NOLINTNEXTLINE(concurrency-mt-unsafe)
1275 return getservbyport(port, proto);
1276}
1277
1278struct servent* /* codespell:ignore servent */
1279_getservbyname(const char* name, const char* proto) // codespell:ignore servent
1280
1281{
1282 // NOLINTNEXTLINE(concurrency-mt-unsafe)
1283 return getservbyname(name, proto);
1284}
1285
1286struct protoent* _getprotobynumber(int number)
1287{
1288 // NOLINTNEXTLINE(concurrency-mt-unsafe)
1289 return getprotobynumber(number);
1290}
1291
1292struct protoent* _getprotobyname(const char* name)
1293{
1294 // NOLINTNEXTLINE(concurrency-mt-unsafe)
1295 return getprotobyname(name);
1296}
1297
1298#endif /* _WIN32 */
INTERFACE_INFO
Definition winsock.h:204
WSAPROTOCOL_INFOA
Definition winsock.h:222
WSAPROTOCOL_INFOW
Definition winsock.h:246