gcc/ada/socket.c

   1 /****************************************************************************
   2  *                                                                          *
   3  *                         GNAT COMPILER COMPONENTS                         *
   4  *                                                                          *
   5  *                               S O C K E T                                *
   6  *                                                                          *
   7  *                          C Implementation File                           *
   8  *                                                                          *
   9  *          Copyright (C) 2003-2009, 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 #include "gsocket.h"
  35
  36 #ifdef VMS
  37 /*
  38  * For VMS, gsocket.h can't include sockets-related DEC C header files
  39  * when building the runtime (because these files are in a DEC C text library
  40  * (DECC$RTLDEF.TLB) not accessable to GCC). So, we generate a separate header
  41  * file along with s-oscons.ads and include it here.
  42  */
  43 # include "s-oscons.h"
  44
  45 /*
  46  * We also need the declaration of struct hostent/servent, which s-oscons
  47  * can't provide, so we copy it manually here. This needs to be kept in synch
  48  * with the definition of that structure in the DEC C headers, which
  49  * hopefully won't change frequently.
  50  */
  51 typedef char *__netdb_char_ptr __attribute__ (( mode (SI) ));
  52 typedef __netdb_char_ptr *__netdb_char_ptr_ptr __attribute__ (( mode (SI) ));
  53
  54 struct hostent {
  55   __netdb_char_ptr     h_name;
  56   __netdb_char_ptr_ptr h_aliases;
  57   int                  h_addrtype;
  58   int                  h_length;
  59   __netdb_char_ptr_ptr h_addr_list;
  60 };
  61
  62 struct servent {
  63   __netdb_char_ptr     s_name;
  64   __netdb_char_ptr_ptr s_aliases;
  65   int                  s_port;
  66   __netdb_char_ptr     s_proto;
  67 };
  68 #endif
  69
  70 #if defined(HAVE_SOCKETS)
  71
  72 /* Include all the necessary system-specific headers and define the
  73  * necessary macros (shared with gen-oscons).
  74  */
  75
  76 #if !defined(SO_NOSIGPIPE) && !defined (MSG_NOSIGNAL)
  77 #include <signal.h>
  78 #endif
  79 /* Required if we will be calling signal() in __gnat_disable_all_sigpipes() */
  80
  81 #include "raise.h"
  82 /* Required for __gnat_malloc() */
  83
  84 #include <string.h>
  85 /* Required for memcpy() */
  86
  87 extern void __gnat_disable_sigpipe (int fd);
  88 extern void __gnat_disable_all_sigpipes (void);
  89 extern int  __gnat_create_signalling_fds (int *fds);
  90 extern int  __gnat_read_signalling_fd (int rsig);
  91 extern int  __gnat_write_signalling_fd (int wsig);
  92 extern void  __gnat_close_signalling_fd (int sig);
  93 extern void __gnat_last_socket_in_set (fd_set *, int *);
  94 extern void __gnat_get_socket_from_set (fd_set *, int *, int *);
  95 extern void __gnat_insert_socket_in_set (fd_set *, int);
  96 extern int __gnat_is_socket_in_set (fd_set *, int);
  97 extern fd_set *__gnat_new_socket_set (fd_set *);
  98 extern void __gnat_remove_socket_from_set (fd_set *, int);
  99 extern void __gnat_reset_socket_set (fd_set *);
 100 extern int  __gnat_get_h_errno (void);
 101 extern int  __gnat_socket_ioctl (int, int, int *);
 102
 103 extern char * __gnat_servent_s_name (struct servent *);
 104 extern char * __gnat_servent_s_alias (struct servent *, int index);
 105 extern unsigned short __gnat_servent_s_port (struct servent *);
 106 extern char * __gnat_servent_s_proto (struct servent *);
 107
 108 extern char * __gnat_hostent_h_name (struct hostent *);
 109 extern char * __gnat_hostent_h_alias (struct hostent *, int);
 110 extern int __gnat_hostent_h_addrtype (struct hostent *);
 111 extern int __gnat_hostent_h_length (struct hostent *);
 112 extern char * __gnat_hostent_h_addr (struct hostent *, int);
 113
 114 #ifndef HAVE_INET_PTON
 115 extern int  __gnat_inet_pton (int, const char *, void *);
 116 #endif
 117 \f
 118 /* Disable the sending of SIGPIPE for writes on a broken stream */
 119
 120 void
 121 __gnat_disable_sigpipe (int fd)
 122 {
 123 #ifdef SO_NOSIGPIPE
 124   int val = 1;
 125   (void) setsockopt (fd, SOL_SOCKET, SO_NOSIGPIPE, &val, sizeof val);
 126 #endif
 127 }
 128
 129 void
 130 __gnat_disable_all_sigpipes (void)
 131 {
 132 #if !defined(SO_NOSIGPIPE) && !defined(MSG_NOSIGNAL) && defined(SIGPIPE)
 133   (void) signal (SIGPIPE, SIG_IGN);
 134 #endif
 135 }
 136 \f
 137 #if defined (_WIN32) || defined (__vxworks) || defined (VMS)
 138 /*
 139  * Signalling FDs operations are implemented in Ada for these platforms
 140  * (see subunit GNAT.Sockets.Thin.Signalling_Fds).
 141  */
 142 #else
 143 /*
 144  * Create a pair of connected file descriptors fds[0] and fds[1] used for
 145  * signalling by a Selector object. fds[0] is the read end, and fds[1] the
 146  * write end.
 147  */
 148 int
 149 __gnat_create_signalling_fds (int *fds) {
 150   return pipe (fds);
 151 }
 152 \f
 153 /*
 154  * Read one byte of data from rsig, the read end of a pair of signalling fds
 155  * created by __gnat_create_signalling_fds.
 156  */
 157 int
 158 __gnat_read_signalling_fd (int rsig) {
 159   char c;
 160   return read (rsig, &c, 1);
 161 }
 162 \f
 163 /*
 164  * Write one byte of data to wsig, the write end of a pair of signalling fds
 165  * created by __gnat_create_signalling_fds.
 166  */
 167 int
 168 __gnat_write_signalling_fd (int wsig) {
 169   char c = 0;
 170   return write (wsig, &c, 1);
 171 }
 172 \f
 173 /*
 174  * Close one end of a pair of signalling fds
 175  */
 176 void
 177 __gnat_close_signalling_fd (int sig) {
 178   (void) close (sig);
 179 }
 180 #endif
 181 \f
 182 /*
 183  * Handling of gethostbyname, gethostbyaddr, getservbyname and getservbyport
 184  * =========================================================================
 185  *
 186  * This module exposes __gnat_getXXXbyYYY operations with the same signature
 187  * as the reentrant variant getXXXbyYYY_r.
 188  *
 189  * On platforms where getXXXbyYYY is intrinsically reentrant, the provided user
 190  * buffer argument is ignored.
 191  *
 192  * When getXXXbyYYY is not reentrant but getXXXbyYYY_r exists, the latter is
 193  * used, and the provided buffer argument must point to a valid, thread-local
 194  * buffer (usually on the caller's stack).
 195  *
 196  * When getXXXbyYYY is not reentrant and no reentrant getXXXbyYYY_r variant
 197  * is available, the non-reentrant getXXXbyYYY is called, the provided user
 198  * buffer is ignored, and the caller is expected to take care of mutual
 199  * exclusion.
 200  */
 201
 202 #ifdef HAVE_GETxxxBYyyy_R
 203 int
 204 __gnat_gethostbyname (const char *name,
 205   struct hostent *ret, char *buf, size_t buflen,
 206   int *h_errnop)
 207 {
 208   struct hostent *rh;
 209   int ri;
 210
 211 #if defined(__linux__) || defined(__GLIBC__)
 212   (void) gethostbyname_r (name, ret, buf, buflen, &rh, h_errnop);
 213 #else
 214   rh = gethostbyname_r (name, ret, buf, buflen, h_errnop);
 215 #endif
 216   ri = (rh == NULL) ? -1 : 0;
 217   return ri;
 218 }
 219
 220 int
 221 __gnat_gethostbyaddr (const char *addr, int len, int type,
 222   struct hostent *ret, char *buf, size_t buflen,
 223   int *h_errnop)
 224 {
 225   struct hostent *rh;
 226   int ri;
 227
 228 #if defined(__linux__) || defined(__GLIBC__)
 229   (void) gethostbyaddr_r (addr, len, type, ret, buf, buflen, &rh, h_errnop);
 230 #else
 231   rh = gethostbyaddr_r (addr, len, type, ret, buf, buflen, h_errnop);
 232 #endif
 233   ri = (rh == NULL) ? -1 : 0;
 234   return ri;
 235 }
 236
 237 int
 238 __gnat_getservbyname (const char *name, const char *proto,
 239   struct servent *ret, char *buf, size_t buflen)
 240 {
 241   struct servent *rh;
 242   int ri;
 243
 244 #if defined(__linux__) || defined(__GLIBC__) || defined(__rtems__)
 245   (void) getservbyname_r (name, proto, ret, buf, buflen, &rh);
 246 #else
 247   rh = getservbyname_r (name, proto, ret, buf, buflen);
 248 #endif
 249   ri = (rh == NULL) ? -1 : 0;
 250   return ri;
 251 }
 252
 253 int
 254 __gnat_getservbyport (int port, const char *proto,
 255   struct servent *ret, char *buf, size_t buflen)
 256 {
 257   struct servent *rh;
 258   int ri;
 259
 260 #if defined(__linux__) || defined(__GLIBC__) || defined(__rtems__)
 261   (void) getservbyport_r (port, proto, ret, buf, buflen, &rh);
 262 #else
 263   rh = getservbyport_r (port, proto, ret, buf, buflen);
 264 #endif
 265   ri = (rh == NULL) ? -1 : 0;
 266   return ri;
 267 }
 268 #elif defined (__vxworks)
 269 static char vxw_h_name[MAXHOSTNAMELEN + 1];
 270 static char *vxw_h_aliases[1] = { NULL };
 271 static int vxw_h_addr;
 272 static char *vxw_h_addr_list[2] = { (char*) &vxw_h_addr, NULL };
 273
 274 int
 275 __gnat_gethostbyname (const char *name,
 276   struct hostent *ret, char *buf, size_t buflen,
 277   int *h_errnop)
 278 {
 279   vxw_h_addr = hostGetByName (name);
 280   if (vxw_h_addr == ERROR) {
 281     *h_errnop = __gnat_get_h_errno ();
 282     return -1;
 283   }
 284   ret->h_name      = name;
 285   ret->h_aliases   = &vxw_h_aliases;
 286   ret->h_addrtype  = AF_INET;
 287   ret->h_length    = 4;
 288   ret->h_addr_list = &vxw_h_addr_list;
 289   return 0;
 290 }
 291
 292 int
 293 __gnat_gethostbyaddr (const char *addr, int len, int type,
 294   struct hostent *ret, char *buf, size_t buflen,
 295   int *h_errnop)
 296 {
 297   if (type != AF_INET) {
 298     *h_errnop = EAFNOSUPPORT;
 299     return -1;
 300   }
 301
 302   if (addr == NULL || len != 4) {
 303     *h_errnop = EINVAL;
 304     return -1;
 305   }
 306
 307   if (hostGetByAddr (*(int*)addr, &vxw_h_name) != OK) {
 308     *h_errnop = __gnat_get_h_errno ();
 309     return -1;
 310   }
 311
 312   vxw_h_addr       = addr;
 313
 314   ret->h_name      = &vxw_h_name;
 315   ret->h_aliases   = &vxw_h_aliases;
 316   ret->h_addrtype  = AF_INET;
 317   ret->h_length    = 4;
 318   ret->h_addr_list = &vxw_h_addr_list;
 319 }
 320
 321 int
 322 __gnat_getservbyname (const char *name, const char *proto,
 323   struct servent *ret, char *buf, size_t buflen)
 324 {
 325   /* Not available under VxWorks */
 326   return -1;
 327 }
 328
 329 int
 330 __gnat_getservbyport (int port, const char *proto,
 331   struct servent *ret, char *buf, size_t buflen)
 332 {
 333   /* Not available under VxWorks */
 334   return -1;
 335 }
 336 #else
 337 int
 338 __gnat_gethostbyname (const char *name,
 339   struct hostent *ret, char *buf, size_t buflen,
 340   int *h_errnop)
 341 {
 342   struct hostent *rh;
 343   rh = gethostbyname (name);
 344   if (rh == NULL) {
 345     *h_errnop = __gnat_get_h_errno ();
 346     return -1;
 347   }
 348   *ret = *rh;
 349   *h_errnop = 0;
 350   return 0;
 351 }
 352
 353 int
 354 __gnat_gethostbyaddr (const char *addr, int len, int type,
 355   struct hostent *ret, char *buf, size_t buflen,
 356   int *h_errnop)
 357 {
 358   struct hostent *rh;
 359   rh = gethostbyaddr (addr, len, type);
 360   if (rh == NULL) {
 361     *h_errnop = __gnat_get_h_errno ();
 362     return -1;
 363   }
 364   *ret = *rh;
 365   *h_errnop = 0;
 366   return 0;
 367 }
 368
 369 int
 370 __gnat_getservbyname (const char *name, const char *proto,
 371   struct servent *ret, char *buf, size_t buflen)
 372 {
 373   struct servent *rh;
 374   rh = getservbyname (name, proto);
 375   if (rh == NULL)
 376     return -1;
 377   *ret = *rh;
 378   return 0;
 379 }
 380
 381 int
 382 __gnat_getservbyport (int port, const char *proto,
 383   struct servent *ret, char *buf, size_t buflen)
 384 {
 385   struct servent *rh;
 386   rh = getservbyport (port, proto);
 387   if (rh == NULL)
 388     return -1;
 389   *ret = *rh;
 390   return 0;
 391 }
 392 #endif
 393 \f
 394 /* Find the largest socket in the socket set SET. This is needed for
 395    `select'.  LAST is the maximum value for the largest socket. This hint is
 396    used to avoid scanning very large socket sets.  On return, LAST is the
 397    actual largest socket in the socket set. */
 398
 399 void
 400 __gnat_last_socket_in_set (fd_set *set, int *last)
 401 {
 402   int s;
 403   int l;
 404   l = -1;
 405
 406 #ifdef _WIN32
 407   /* More efficient method for NT. */
 408   for (s = 0; s < set->fd_count; s++)
 409     if ((int) set->fd_array[s] > l)
 410       l = set->fd_array[s];
 411
 412 #else
 413
 414   for (s = *last; s != -1; s--)
 415     if (FD_ISSET (s, set))
 416       {
 417         l = s;
 418         break;
 419       }
 420 #endif
 421
 422   *last = l;
 423 }
 424
 425 /* Get last socket and remove it from the socket set SET.  LAST is the
 426    maximum value of the largest socket.  This hint is used to avoid scanning
 427    very large socket sets.  On return, LAST is set to the actual largest
 428    socket in the socket set. */
 429
 430 void
 431 __gnat_get_socket_from_set (fd_set *set, int *last, int *socket)
 432 {
 433   *socket = *last;
 434   FD_CLR (*socket, set);
 435   __gnat_last_socket_in_set (set, last);
 436 }
 437
 438 /* Insert SOCKET in the socket set SET. */
 439
 440 void
 441 __gnat_insert_socket_in_set (fd_set *set, int socket)
 442 {
 443   FD_SET (socket, set);
 444 }
 445
 446 /* Check whether a given SOCKET is in the socket set SET. */
 447
 448 int
 449 __gnat_is_socket_in_set (fd_set *set, int socket)
 450 {
 451   return FD_ISSET (socket, set);
 452 }
 453
 454 /* Remove SOCKET from the socket set SET. */
 455
 456 void
 457 __gnat_remove_socket_from_set (fd_set *set, int socket)
 458 {
 459   FD_CLR (socket, set);
 460 }
 461
 462 /* Reset SET */
 463 void
 464 __gnat_reset_socket_set (fd_set *set)
 465 {
 466   FD_ZERO (set);
 467 }
 468
 469 /* Get the value of the last host error */
 470
 471 int
 472 __gnat_get_h_errno (void) {
 473 #ifdef __vxworks
 474   int vxw_errno = errno;
 475
 476   switch (vxw_errno) {
 477     case 0:
 478       return 0;
 479
 480 #ifdef S_hostLib_HOST_NOT_FOUND
 481     case S_hostLib_HOST_NOT_FOUND:
 482 #endif
 483     case S_hostLib_UNKNOWN_HOST:
 484       return HOST_NOT_FOUND;
 485
 486 #ifdef S_hostLib_TRY_AGAIN
 487     case S_hostLib_TRY_AGAIN:
 488       return TRY_AGAIN;
 489 #endif
 490
 491 #ifdef S_hostLib_NO_RECOVERY
 492     case S_hostLib_NO_RECOVERY:
 493 #endif
 494 #ifdef S_hostLib_NETDB_INTERNAL
 495     case S_hostLib_NETDB_INTERNAL:
 496 #endif
 497     case S_hostLib_INVALID_PARAMETER:
 498       return NO_RECOVERY;
 499
 500     default:
 501       return -1;
 502   }
 503
 504 #elif defined (VMS)
 505   /* h_errno is defined as follows in OpenVMS' version of <netdb.h>.
 506    * However this header file is not available when building the GNAT
 507    * runtime library using GCC, so we are hardcoding the definition
 508    * directly. Note that the returned address is thread-specific.
 509    */
 510   extern int *decc$h_errno_get_addr ();
 511   return *decc$h_errno_get_addr ();
 512
 513 #elif defined (__rtems__)
 514   /* At this stage in the tool build, no networking .h files are available.
 515    * Newlib does not provide networking .h files and RTEMS is not built yet.
 516    * So we need to explicitly extern h_errno to access it.
 517    */
 518   extern int h_errno;
 519   return h_errno;
 520
 521 #else
 522   return h_errno;
 523 #endif
 524 }
 525
 526 /* Wrapper for ioctl(2), which is a variadic function */
 527
 528 int
 529 __gnat_socket_ioctl (int fd, int req, int *arg) {
 530 #if defined (_WIN32)
 531   return ioctlsocket (fd, req, arg);
 532 #else
 533   return ioctl (fd, req, arg);
 534 #endif
 535 }
 536
 537 #ifndef HAVE_INET_PTON
 538
 539 #ifdef VMS
 540 # define in_addr_t int
 541 # define inet_addr decc$inet_addr
 542 #endif
 543
 544 int
 545 __gnat_inet_pton (int af, const char *src, void *dst) {
 546   switch (af) {
 547 #if defined (_WIN32) && defined (AF_INET6)
 548     case AF_INET6:
 549 #endif
 550     case AF_INET:
 551       break;
 552     default:
 553       errno = EAFNOSUPPORT;
 554       return -1;
 555   }
 556
 557 #if defined (__vxworks)
 558   return (inet_aton (src, dst) == OK);
 559
 560 #elif defined (_WIN32)
 561   struct sockaddr_storage ss;
 562   int sslen = sizeof ss;
 563   int rc;
 564
 565   ss.ss_family = af;
 566   rc = WSAStringToAddressA (src, af, NULL, (struct sockaddr *)&ss, &sslen);
 567   if (rc == 0) {
 568     switch (af) {
 569       case AF_INET:
 570         *(struct in_addr *)dst = ((struct sockaddr_in *)&ss)->sin_addr;
 571         break;
 572 #ifdef AF_INET6
 573       case AF_INET6:
 574         *(struct in6_addr *)dst = ((struct sockaddr_in6 *)&ss)->sin6_addr;
 575         break;
 576 #endif
 577     }
 578   }
 579   return (rc == 0);
 580
 581 #elif defined (__hpux__) || defined (VMS)
 582   in_addr_t addr;
 583   int rc = -1;
 584
 585   if (src == NULL || dst == NULL) {
 586     errno = EINVAL;
 587
 588   } else if (!strcmp (src, "255.255.255.255")) {
 589     addr = 0xffffffff;
 590     rc = 1;
 591
 592   } else {
 593     addr = inet_addr (src);
 594     rc = (addr != 0xffffffff);
 595   }
 596   if (rc == 1) {
 597     *(in_addr_t *)dst = addr;
 598   }
 599   return rc;
 600 #endif
 601 }
 602 #endif
 603
 604 /*
 605  * Accessor functions for struct hostent.
 606  */
 607
 608 char * __gnat_hostent_h_name (struct hostent * h) {
 609   return h->h_name;
 610 }
 611
 612 char * __gnat_hostent_h_alias (struct hostent * h, int index) {
 613   return h->h_aliases[index];
 614 }
 615
 616 int __gnat_hostent_h_addrtype (struct hostent * h) {
 617   return h->h_addrtype;
 618 }
 619
 620 int __gnat_hostent_h_length (struct hostent * h) {
 621   return h->h_length;
 622 }
 623
 624 char * __gnat_hostent_h_addr (struct hostent * h, int index) {
 625   return h->h_addr_list[index];
 626 }
 627
 628 /*
 629  * Accessor functions for struct servent.
 630  *
 631  * These are needed because servent has different representations on different
 632  * platforms, and we don't want to deal with that on the Ada side. For example,
 633  * on Linux, we have (see /usr/include netdb.h):
 634  *
 635  *   struct servent
 636  *   {
 637  *     char *s_name;
 638  *     char **s_aliases;
 639  *     int s_port;
 640  *     char *s_proto;
 641  *   };
 642  *
 643  * and on Windows (see mingw's socket.h):
 644  *
 645  *   struct servent {
 646  *     char *s_name;
 647  *     char **s_aliases;
 648  *   #ifdef _WIN64
 649  *     char *s_proto;
 650  *     short s_port;
 651  *   #else
 652  *     short s_port;
 653  *     char *s_proto;
 654  *   #endif
 655  *   };
 656  */
 657
 658 char *
 659 __gnat_servent_s_name (struct servent * s)
 660 {
 661   return s->s_name;
 662 }
 663
 664 char *
 665 __gnat_servent_s_alias (struct servent * s, int index)
 666 {
 667   return s->s_aliases[index];
 668 }
 669
 670 unsigned short
 671 __gnat_servent_s_port (struct servent * s)
 672 {
 673   return s->s_port;
 674 }
 675
 676 char *
 677 __gnat_servent_s_proto (struct servent * s)
 678 {
 679   return s->s_proto;
 680 }
 681
 682 #else
 683 # warning Sockets are not supported on this platform
 684 #endif /* defined(HAVE_SOCKETS) */