1 /****************************************************************************
2 * *
3 * GNAT COMPILER COMPONENTS *
4 * *
5 * S O C K E T *
6 * *
7 * C Implementation File *
8 * *
9 * Copyright (C) 2003-2019, Free Software Foundation, Inc. *
10 * *
11 * GNAT is free software; you can redistribute it and/or modify it under *
12 * terms of the GNU General Public License as published by the Free Soft- *
13 * ware Foundation; either version 3, or (at your option) any later ver- *
14 * sion. GNAT is distributed in the hope that it will be useful, but WITH- *
15 * OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY *
16 * or FITNESS FOR A PARTICULAR PURPOSE. *
17 * *
18 * As a special exception under Section 7 of GPL version 3, you are granted *
19 * additional permissions described in the GCC Runtime Library Exception, *
20 * version 3.1, as published by the Free Software Foundation. *
21 * *
22 * You should have received a copy of the GNU General Public License and *
23 * a copy of the GCC Runtime Library Exception along with this program; *
24 * see the files COPYING3 and COPYING.RUNTIME respectively. If not, see *
25 * <http://www.gnu.org/licenses/>. *
26 * *
27 * GNAT was originally developed by the GNAT team at New York University. *
28 * Extensive contributions were provided by Ada Core Technologies Inc. *
29 * *
30 ****************************************************************************/
31
32 /* This file provides a portable binding to the sockets API */
33
34 #define ATTRIBUTE_UNUSED __attribute__((unused))
35
36 /* Ensure access to errno is thread safe. */
37 #ifndef _REENTRANT
38 #define _REENTRANT
39 #endif
40 #define _THREAD_SAFE
41
42 #include "gsocket.h"
43
44 #if defined (__FreeBSD__) || defined (__DragonFly__) \
45 || defined (__NetBSD__) || defined (__OpenBSD__)
46 typedef unsigned int IOCTL_Req_T;
47 #else
48 typedef int IOCTL_Req_T;
49 #endif
50
51 #if defined(HAVE_SOCKETS)
52
53 /* Include all the necessary system-specific headers and define the
54 * necessary macros (shared with gen-oscons).
55 */
56
57 #if !defined(SO_NOSIGPIPE) && !defined (MSG_NOSIGNAL)
58 #include <signal.h>
59 #endif
60 /* Required if we will be calling signal() in __gnat_disable_all_sigpipes() */
61
62 #include "raise.h"
63 /* Required for __gnat_malloc() */
64
65 #include <string.h>
66 /* Required for memcpy() */
67
68 extern void __gnat_disable_sigpipe (int fd);
69 extern void __gnat_disable_all_sigpipes (void);
70 extern int __gnat_create_signalling_fds (int *fds);
71 extern int __gnat_read_signalling_fd (int rsig);
72 extern int __gnat_write_signalling_fd (int wsig);
73 extern void __gnat_close_signalling_fd (int sig);
74 extern void __gnat_last_socket_in_set (fd_set *, int *);
75 extern void __gnat_get_socket_from_set (fd_set *, int *, int *);
76 extern void __gnat_insert_socket_in_set (fd_set *, int);
77 extern int __gnat_is_socket_in_set (fd_set *, int);
78 extern fd_set *__gnat_new_socket_set (fd_set *);
79 extern void __gnat_remove_socket_from_set (fd_set *, int);
80 extern void __gnat_reset_socket_set (fd_set *);
81 extern int __gnat_get_h_errno (void);
82 extern int __gnat_socket_ioctl (int, IOCTL_Req_T, int *);
83
84 extern char * __gnat_servent_s_name (struct servent *);
85 extern char * __gnat_servent_s_alias (struct servent *, int index);
86 extern unsigned short __gnat_servent_s_port (struct servent *);
87 extern char * __gnat_servent_s_proto (struct servent *);
88
89 extern char * __gnat_hostent_h_name (struct hostent *);
90 extern char * __gnat_hostent_h_alias (struct hostent *, int);
91 extern int __gnat_hostent_h_addrtype (struct hostent *);
92 extern int __gnat_hostent_h_length (struct hostent *);
93 extern char * __gnat_hostent_h_addr (struct hostent *, int);
94
95 extern int __gnat_getaddrinfo(
96 const char *node,
97 const char *service,
98 const struct addrinfo *hints,
99 struct addrinfo **res);
100 int __gnat_getnameinfo(
101 const struct sockaddr *sa, socklen_t salen,
102 char *host, size_t hostlen,
103 char *serv, size_t servlen, int flags);
104 extern void __gnat_freeaddrinfo(struct addrinfo *res);
105 extern const char * __gnat_gai_strerror(int errcode);
106
107 #ifndef HAVE_INET_PTON
108 extern int __gnat_inet_pton (int, const char *, void *);
109 #endif
110
111 #ifndef HAVE_INET_NTOP
112 extern const char *
113 __gnat_inet_ntop(int, const void *, char *, socklen_t);
114 #endif
115
116 /* Disable the sending of SIGPIPE for writes on a broken stream */
117
118 void
__gnat_disable_sigpipe(int fd ATTRIBUTE_UNUSED)119 __gnat_disable_sigpipe (int fd ATTRIBUTE_UNUSED)
120 {
121 #ifdef SO_NOSIGPIPE
122 int val = 1;
123 (void) setsockopt (fd, SOL_SOCKET, SO_NOSIGPIPE, &val, sizeof val);
124 #endif
125 }
126
127 void
__gnat_disable_all_sigpipes(void)128 __gnat_disable_all_sigpipes (void)
129 {
130 #if !defined(SO_NOSIGPIPE) && !defined(MSG_NOSIGNAL) && defined(SIGPIPE)
131 (void) signal (SIGPIPE, SIG_IGN);
132 #endif
133 }
134
135 #if defined (_WIN32) || defined (__vxworks)
136 /*
137 * Signalling FDs operations are implemented in Ada for these platforms
138 * (see subunit GNAT.Sockets.Thin.Signalling_Fds).
139 */
140 #else
141 /*
142 * Create a pair of connected file descriptors fds[0] and fds[1] used for
143 * signalling by a Selector object. fds[0] is the read end, and fds[1] the
144 * write end.
145 */
146 int
__gnat_create_signalling_fds(int * fds)147 __gnat_create_signalling_fds (int *fds) {
148 return pipe (fds);
149 }
150
151 /*
152 * Read one byte of data from rsig, the read end of a pair of signalling fds
153 * created by __gnat_create_signalling_fds.
154 */
155 int
__gnat_read_signalling_fd(int rsig)156 __gnat_read_signalling_fd (int rsig) {
157 char c;
158 return read (rsig, &c, 1);
159 }
160
161 /*
162 * Write one byte of data to wsig, the write end of a pair of signalling fds
163 * created by __gnat_create_signalling_fds.
164 */
165 int
__gnat_write_signalling_fd(int wsig)166 __gnat_write_signalling_fd (int wsig) {
167 char c = 0;
168 return write (wsig, &c, 1);
169 }
170
171 /*
172 * Close one end of a pair of signalling fds
173 */
174 void
__gnat_close_signalling_fd(int sig)175 __gnat_close_signalling_fd (int sig) {
176 (void) close (sig);
177 }
178 #endif
179
180 /*
181 * Handling of gethostbyname, gethostbyaddr, getservbyname and getservbyport
182 * =========================================================================
183 *
184 * This module exposes __gnat_getXXXbyYYY operations with the same signature
185 * as the reentrant variant getXXXbyYYY_r.
186 *
187 * On platforms where getXXXbyYYY is intrinsically reentrant, the provided user
188 * buffer argument is ignored.
189 *
190 * When getXXXbyYYY is not reentrant but getXXXbyYYY_r exists, the latter is
191 * used, and the provided buffer argument must point to a valid, thread-local
192 * buffer (usually on the caller's stack).
193 *
194 * When getXXXbyYYY is not reentrant and no reentrant getXXXbyYYY_r variant
195 * is available, the non-reentrant getXXXbyYYY is called, the provided user
196 * buffer is ignored, and the caller is expected to take care of mutual
197 * exclusion.
198 */
199
200 #ifdef HAVE_GETxxxBYyyy_R
201 int
__gnat_gethostbyname(const char * name,struct hostent * ret,char * buf,size_t buflen,int * h_errnop)202 __gnat_gethostbyname (const char *name,
203 struct hostent *ret, char *buf, size_t buflen,
204 int *h_errnop)
205 {
206 struct hostent *rh;
207 int ri;
208
209 #if defined(__linux__) || defined(__GLIBC__) || defined(__rtems__)
210 (void) gethostbyname_r (name, ret, buf, buflen, &rh, h_errnop);
211 #else
212 rh = gethostbyname_r (name, ret, buf, buflen, h_errnop);
213 #endif
214 ri = (rh == NULL) ? -1 : 0;
215 return ri;
216 }
217
218 int
__gnat_gethostbyaddr(const char * addr,int len,int type,struct hostent * ret,char * buf,size_t buflen,int * h_errnop)219 __gnat_gethostbyaddr (const char *addr, int len, int type,
220 struct hostent *ret, char *buf, size_t buflen,
221 int *h_errnop)
222 {
223 struct hostent *rh;
224 int ri;
225
226 #if defined(__linux__) || defined(__GLIBC__) || defined(__rtems__)
227 (void) gethostbyaddr_r (addr, len, type, ret, buf, buflen, &rh, h_errnop);
228 #else
229 rh = gethostbyaddr_r (addr, len, type, ret, buf, buflen, h_errnop);
230 #endif
231 ri = (rh == NULL) ? -1 : 0;
232 return ri;
233 }
234
235 int
__gnat_getservbyname(const char * name,const char * proto,struct servent * ret,char * buf,size_t buflen)236 __gnat_getservbyname (const char *name, const char *proto,
237 struct servent *ret, char *buf, size_t buflen)
238 {
239 struct servent *rh;
240 int ri;
241
242 #if defined(__linux__) || defined(__GLIBC__) || defined(__rtems__)
243 (void) getservbyname_r (name, proto, ret, buf, buflen, &rh);
244 #else
245 rh = getservbyname_r (name, proto, ret, buf, buflen);
246 #endif
247 ri = (rh == NULL) ? -1 : 0;
248 return ri;
249 }
250
251 int
__gnat_getservbyport(int port,const char * proto,struct servent * ret,char * buf,size_t buflen)252 __gnat_getservbyport (int port, const char *proto,
253 struct servent *ret, char *buf, size_t buflen)
254 {
255 struct servent *rh;
256 int ri;
257
258 #if defined(__linux__) || defined(__GLIBC__) || defined(__rtems__)
259 (void) getservbyport_r (port, proto, ret, buf, buflen, &rh);
260 #else
261 rh = getservbyport_r (port, proto, ret, buf, buflen);
262 #endif
263 ri = (rh == NULL) ? -1 : 0;
264 return ri;
265 }
266 #elif defined (__vxworks)
267 static char vxw_h_name[MAXHOSTNAMELEN + 1];
268 static char *vxw_h_aliases[1] = { NULL };
269 static int vxw_h_addr;
270 static char *vxw_h_addr_list[2] = { (char*) &vxw_h_addr, NULL };
271
272 int
__gnat_gethostbyname(const char * name,struct hostent * ret,char * buf,size_t buflen,int * h_errnop)273 __gnat_gethostbyname (const char *name,
274 struct hostent *ret, char *buf, size_t buflen,
275 int *h_errnop)
276 {
277 vxw_h_addr = hostGetByName (name);
278 if (vxw_h_addr == ERROR) {
279 *h_errnop = __gnat_get_h_errno ();
280 return -1;
281 }
282 ret->h_name = name;
283 ret->h_aliases = &vxw_h_aliases;
284 ret->h_addrtype = AF_INET;
285 ret->h_length = 4;
286 ret->h_addr_list = &vxw_h_addr_list;
287 return 0;
288 }
289
290 int
__gnat_gethostbyaddr(const char * addr,int len,int type,struct hostent * ret,char * buf,size_t buflen,int * h_errnop)291 __gnat_gethostbyaddr (const char *addr, int len, int type,
292 struct hostent *ret, char *buf, size_t buflen,
293 int *h_errnop)
294 {
295 if (type != AF_INET) {
296 *h_errnop = EAFNOSUPPORT;
297 return -1;
298 }
299
300 if (addr == NULL || len != 4) {
301 *h_errnop = EINVAL;
302 return -1;
303 }
304
305 if (hostGetByAddr (*(int*)addr, &vxw_h_name) != OK) {
306 *h_errnop = __gnat_get_h_errno ();
307 return -1;
308 }
309
310 vxw_h_addr = addr;
311
312 ret->h_name = &vxw_h_name;
313 ret->h_aliases = &vxw_h_aliases;
314 ret->h_addrtype = AF_INET;
315 ret->h_length = 4;
316 ret->h_addr_list = &vxw_h_addr_list;
317 }
318
319 int
__gnat_getservbyname(const char * name,const char * proto,struct servent * ret,char * buf,size_t buflen)320 __gnat_getservbyname (const char *name, const char *proto,
321 struct servent *ret, char *buf, size_t buflen)
322 {
323 /* Not available under VxWorks */
324 return -1;
325 }
326
327 int
__gnat_getservbyport(int port,const char * proto,struct servent * ret,char * buf,size_t buflen)328 __gnat_getservbyport (int port, const char *proto,
329 struct servent *ret, char *buf, size_t buflen)
330 {
331 /* Not available under VxWorks */
332 return -1;
333 }
334 #else
335 int
__gnat_gethostbyname(const char * name,struct hostent * ret,char * buf,size_t buflen,int * h_errnop)336 __gnat_gethostbyname (const char *name,
337 struct hostent *ret, char *buf, size_t buflen,
338 int *h_errnop)
339 {
340 struct hostent *rh;
341 rh = gethostbyname (name);
342 if (rh == NULL) {
343 *h_errnop = __gnat_get_h_errno ();
344 return -1;
345 }
346 *ret = *rh;
347 *h_errnop = 0;
348 return 0;
349 }
350
351 int
__gnat_gethostbyaddr(const char * addr,int len,int type,struct hostent * ret,char * buf,size_t buflen,int * h_errnop)352 __gnat_gethostbyaddr (const char *addr, int len, int type,
353 struct hostent *ret, char *buf, size_t buflen,
354 int *h_errnop)
355 {
356 struct hostent *rh;
357 rh = gethostbyaddr (addr, len, type);
358 if (rh == NULL) {
359 *h_errnop = __gnat_get_h_errno ();
360 return -1;
361 }
362 *ret = *rh;
363 *h_errnop = 0;
364 return 0;
365 }
366
367 int
__gnat_getservbyname(const char * name,const char * proto,struct servent * ret,char * buf,size_t buflen)368 __gnat_getservbyname (const char *name, const char *proto,
369 struct servent *ret, char *buf, size_t buflen)
370 {
371 struct servent *rh;
372 rh = getservbyname (name, proto);
373 if (rh == NULL)
374 return -1;
375 *ret = *rh;
376 return 0;
377 }
378
379 int
__gnat_getservbyport(int port,const char * proto,struct servent * ret,char * buf,size_t buflen)380 __gnat_getservbyport (int port, const char *proto,
381 struct servent *ret, char *buf, size_t buflen)
382 {
383 struct servent *rh;
384 rh = getservbyport (port, proto);
385 if (rh == NULL)
386 return -1;
387 *ret = *rh;
388 return 0;
389 }
390 #endif
391
392 /* Find the largest socket in the socket set SET. This is needed for
393 `select'. LAST is the maximum value for the largest socket. This hint is
394 used to avoid scanning very large socket sets. On return, LAST is the
395 actual largest socket in the socket set. */
396
397 void
__gnat_last_socket_in_set(fd_set * set,int * last)398 __gnat_last_socket_in_set (fd_set *set, int *last)
399 {
400 int s;
401 int l;
402 l = -1;
403
404 #ifdef _WIN32
405 /* More efficient method for NT. */
406 for (s = 0; s < set->fd_count; s++)
407 if ((int) set->fd_array[s] > l)
408 l = set->fd_array[s];
409
410 #else
411
412 for (s = *last; s != -1; s--)
413 if (FD_ISSET (s, set))
414 {
415 l = s;
416 break;
417 }
418 #endif
419
420 *last = l;
421 }
422
423 /* Get last socket and remove it from the socket set SET. LAST is the
424 maximum value of the largest socket. This hint is used to avoid scanning
425 very large socket sets. On return, LAST is set to the actual largest
426 socket in the socket set. */
427
428 void
__gnat_get_socket_from_set(fd_set * set,int * last,int * socket)429 __gnat_get_socket_from_set (fd_set *set, int *last, int *socket)
430 {
431 *socket = *last;
432 FD_CLR (*socket, set);
433 __gnat_last_socket_in_set (set, last);
434 }
435
436 /* Insert SOCKET in the socket set SET. */
437
438 void
__gnat_insert_socket_in_set(fd_set * set,int socket)439 __gnat_insert_socket_in_set (fd_set *set, int socket)
440 {
441 FD_SET (socket, set);
442 }
443
444 /* Check whether a given SOCKET is in the socket set SET. */
445
446 int
__gnat_is_socket_in_set(fd_set * set,int socket)447 __gnat_is_socket_in_set (fd_set *set, int socket)
448 {
449 return FD_ISSET (socket, set);
450 }
451
452 /* Remove SOCKET from the socket set SET. */
453
454 void
__gnat_remove_socket_from_set(fd_set * set,int socket)455 __gnat_remove_socket_from_set (fd_set *set, int socket)
456 {
457 FD_CLR (socket, set);
458 }
459
460 /* Reset SET */
461 void
__gnat_reset_socket_set(fd_set * set)462 __gnat_reset_socket_set (fd_set *set)
463 {
464 FD_ZERO (set);
465 }
466
467 /* Get the value of the last host error */
468
469 int
__gnat_get_h_errno(void)470 __gnat_get_h_errno (void) {
471 #ifdef __vxworks
472 int vxw_errno = errno;
473
474 switch (vxw_errno) {
475 case 0:
476 return 0;
477
478 #ifdef S_hostLib_HOST_NOT_FOUND
479 case S_hostLib_HOST_NOT_FOUND:
480 #endif
481 case S_hostLib_UNKNOWN_HOST:
482 return HOST_NOT_FOUND;
483
484 #ifdef S_hostLib_TRY_AGAIN
485 case S_hostLib_TRY_AGAIN:
486 return TRY_AGAIN;
487 #endif
488
489 #ifdef S_hostLib_NO_RECOVERY
490 case S_hostLib_NO_RECOVERY:
491 #endif
492 #ifdef S_hostLib_NETDB_INTERNAL
493 case S_hostLib_NETDB_INTERNAL:
494 #endif
495 case S_hostLib_INVALID_PARAMETER:
496 return NO_RECOVERY;
497
498 default:
499 return -1;
500 }
501
502 #elif defined (__rtems__)
503 /* At this stage in the tool build, no networking .h files are available.
504 * Newlib does not provide networking .h files and RTEMS is not built yet.
505 * So we need to explicitly extern h_errno to access it.
506 */
507 extern int h_errno;
508 return h_errno;
509
510 #else
511 return h_errno;
512 #endif
513 }
514
515 /* Wrapper for ioctl(2), which is a variadic function */
516
517 int
__gnat_socket_ioctl(int fd,IOCTL_Req_T req,int * arg)518 __gnat_socket_ioctl (int fd, IOCTL_Req_T req, int *arg) {
519 #if defined (_WIN32)
520 return ioctlsocket (fd, req, arg);
521 #elif defined (__APPLE__)
522 /*
523 * On Darwin, req is an unsigned long, and we want to convert without sign
524 * extension to get the proper bit pattern in the case of a 64 bit kernel.
525 */
526 return ioctl (fd, (unsigned int) req, arg);
527 #else
528 return ioctl (fd, req, arg);
529 #endif
530 }
531
532 #ifndef HAVE_INET_PTON
533
534 int
__gnat_inet_pton(int af,const char * src,void * dst)535 __gnat_inet_pton (int af, const char *src, void *dst) {
536 switch (af) {
537 #if defined (_WIN32) && defined (AF_INET6)
538 case AF_INET6:
539 #endif
540 case AF_INET:
541 break;
542 default:
543 errno = EAFNOSUPPORT;
544 return -1;
545 }
546
547 #if defined (__vxworks)
548 return (inet_aton (src, dst) == OK);
549
550 #elif defined (_WIN32)
551 struct sockaddr_storage ss;
552 int sslen = sizeof ss;
553 int rc;
554
555 ss.ss_family = af;
556 rc = WSAStringToAddressA (src, af, NULL, (struct sockaddr *)&ss, &sslen);
557 if (rc == 0) {
558 switch (af) {
559 case AF_INET:
560 *(struct in_addr *)dst = ((struct sockaddr_in *)&ss)->sin_addr;
561 break;
562 #ifdef AF_INET6
563 case AF_INET6:
564 *(struct in6_addr *)dst = ((struct sockaddr_in6 *)&ss)->sin6_addr;
565 break;
566 #endif
567 }
568 }
569 return (rc == 0);
570
571 #elif defined (__hpux__)
572 in_addr_t addr;
573 int rc = -1;
574
575 if (src == NULL || dst == NULL) {
576 errno = EINVAL;
577
578 } else if (!strcmp (src, "255.255.255.255")) {
579 addr = 0xffffffff;
580 rc = 1;
581
582 } else {
583 addr = inet_addr (src);
584 rc = (addr != 0xffffffff);
585 }
586 if (rc == 1) {
587 *(in_addr_t *)dst = addr;
588 }
589 return rc;
590 #endif
591 }
592 #endif
593
594 #ifndef HAVE_INET_NTOP
595
596 const char *
__gnat_inet_ntop(int af,const void * src,char * dst,socklen_t size)597 __gnat_inet_ntop(int af, const void *src, char *dst, socklen_t size)
598 {
599 #ifdef _WIN32
600 struct sockaddr_storage ss;
601 int sslen = sizeof ss;
602 memset(&ss, 0, sslen);
603 ss.ss_family = af;
604
605 switch (af) {
606 case AF_INET6:
607 ((struct sockaddr_in6 *)&ss)->sin6_addr = *(struct in6_addr *)src;
608 break;
609 case AF_INET:
610 ((struct sockaddr_in *)&ss)->sin_addr = *(struct in_addr *)src;
611 break;
612 default:
613 errno = EAFNOSUPPORT;
614 return NULL;
615 }
616
617 DWORD sz = size;
618
619 if (WSAAddressToStringA((struct sockaddr*)&ss, sslen, 0, dst, &sz) != 0) {
620 return NULL;
621 }
622 return dst;
623 #else
624 return NULL;
625 #endif
626 }
627 #endif
628
629 /*
630 * Accessor functions for struct hostent.
631 */
632
__gnat_hostent_h_name(struct hostent * h)633 char * __gnat_hostent_h_name (struct hostent * h) {
634 return h->h_name;
635 }
636
__gnat_hostent_h_alias(struct hostent * h,int index)637 char * __gnat_hostent_h_alias (struct hostent * h, int index) {
638 return h->h_aliases[index];
639 }
640
__gnat_hostent_h_addrtype(struct hostent * h)641 int __gnat_hostent_h_addrtype (struct hostent * h) {
642 return h->h_addrtype;
643 }
644
__gnat_hostent_h_length(struct hostent * h)645 int __gnat_hostent_h_length (struct hostent * h) {
646 return h->h_length;
647 }
648
__gnat_hostent_h_addr(struct hostent * h,int index)649 char * __gnat_hostent_h_addr (struct hostent * h, int index) {
650 return h->h_addr_list[index];
651 }
652
653 /*
654 * Accessor functions for struct servent.
655 *
656 * These are needed because servent has different representations on different
657 * platforms, and we don't want to deal with that on the Ada side. For example,
658 * on Linux, we have (see /usr/include netdb.h):
659 *
660 * struct servent
661 * {
662 * char *s_name;
663 * char **s_aliases;
664 * int s_port;
665 * char *s_proto;
666 * };
667 *
668 * and on Windows (see mingw's socket.h):
669 *
670 * struct servent {
671 * char *s_name;
672 * char **s_aliases;
673 * #ifdef _WIN64
674 * char *s_proto;
675 * short s_port;
676 * #else
677 * short s_port;
678 * char *s_proto;
679 * #endif
680 * };
681 */
682
683 char *
__gnat_servent_s_name(struct servent * s)684 __gnat_servent_s_name (struct servent * s)
685 {
686 return s->s_name;
687 }
688
689 char *
__gnat_servent_s_alias(struct servent * s,int index)690 __gnat_servent_s_alias (struct servent * s, int index)
691 {
692 return s->s_aliases[index];
693 }
694
695 unsigned short
__gnat_servent_s_port(struct servent * s)696 __gnat_servent_s_port (struct servent * s)
697 {
698 return s->s_port;
699 }
700
701 char *
__gnat_servent_s_proto(struct servent * s)702 __gnat_servent_s_proto (struct servent * s)
703 {
704 return s->s_proto;
705 }
706
707 #if defined(AF_INET6) && !defined(__rtems__)
708
__gnat_getaddrinfo(const char * node,const char * service,const struct addrinfo * hints,struct addrinfo ** res)709 int __gnat_getaddrinfo(
710 const char *node,
711 const char *service,
712 const struct addrinfo *hints,
713 struct addrinfo **res)
714 {
715 return getaddrinfo(node, service, hints, res);
716 }
717
__gnat_getnameinfo(const struct sockaddr * sa,socklen_t salen,char * host,size_t hostlen,char * serv,size_t servlen,int flags)718 int __gnat_getnameinfo(
719 const struct sockaddr *sa, socklen_t salen,
720 char *host, size_t hostlen,
721 char *serv, size_t servlen, int flags)
722 {
723 return getnameinfo(sa, salen, host, hostlen, serv, servlen, flags);
724 }
725
__gnat_freeaddrinfo(struct addrinfo * res)726 void __gnat_freeaddrinfo(struct addrinfo *res) {
727 freeaddrinfo(res);
728 }
729
__gnat_gai_strerror(int errcode)730 const char * __gnat_gai_strerror(int errcode) {
731 #if defined(_WIN32) || defined(__vxworks)
732 // gai_strerror thread usafe on Windows and is not available on some vxWorks
733 // versions
734
735 switch (errcode) {
736 case EAI_AGAIN:
737 return "Temporary failure in name resolution.";
738 case EAI_BADFLAGS:
739 return "Invalid value for ai_flags.";
740 case EAI_FAIL:
741 return "Nonrecoverable failure in name resolution.";
742 case EAI_FAMILY:
743 return "The ai_family member is not supported.";
744 case EAI_MEMORY:
745 return "Memory allocation failure.";
746 #ifdef EAI_NODATA
747 // Could be not defined under the vxWorks
748 case EAI_NODATA:
749 return "No address associated with nodename.";
750 #endif
751 #if EAI_NODATA != EAI_NONAME
752 /* with mingw64 runtime EAI_NODATA and EAI_NONAME have the same value.
753 This applies to both win32 and win64 */
754 case EAI_NONAME:
755 return "Neither nodename nor servname provided, or not known.";
756 #endif
757 case EAI_SERVICE:
758 return "The servname parameter is not supported for ai_socktype.";
759 case EAI_SOCKTYPE:
760 return "The ai_socktype member is not supported.";
761 #ifdef EAI_SYSTEM
762 // Could be not defined, at least on Windows
763 case EAI_SYSTEM:
764 return "System error returned in errno";
765 #endif
766 default:
767 return "Unknown error.";
768 }
769 #else
770 return gai_strerror(errcode);
771 #endif
772 }
773
774 #else
775
__gnat_getaddrinfo(const char * node,const char * service,const struct addrinfo * hints,struct addrinfo ** res)776 int __gnat_getaddrinfo(
777 const char *node,
778 const char *service,
779 const struct addrinfo *hints,
780 struct addrinfo **res)
781 {
782 return -1;
783 }
784
__gnat_getnameinfo(const struct sockaddr * sa,socklen_t salen,char * host,size_t hostlen,char * serv,size_t servlen,int flags)785 int __gnat_getnameinfo(
786 const struct sockaddr *sa, socklen_t salen,
787 char *host, size_t hostlen,
788 char *serv, size_t servlen, int flags)
789 {
790 return -1;
791 }
792
__gnat_freeaddrinfo(struct addrinfo * res)793 void __gnat_freeaddrinfo(struct addrinfo *res) {
794 }
795
__gnat_gai_strerror(int errcode)796 const char * __gnat_gai_strerror(int errcode) {
797 return "getaddinfo functions family is not supported";
798 }
799
800 #endif
801
__gnat_minus_500ms()802 int __gnat_minus_500ms() {
803 #if defined (_WIN32)
804 // Windows Server 2019 and Windows 8.0 do not need 500 millisecond socket
805 // timeout correction.
806 return !(IsWindows8OrGreater() && !IsWindowsServer()
807 || IsWindowsVersionOrGreater(10, 0, 17763));
808 #else
809 return 0;
810 #endif
811 }
812
813 #endif /* defined(HAVE_SOCKETS) */
814