jbsockets.c

   1 const char jbsockets_rcs[] = "$Id: jbsockets.c,v 1.72 2010/02/15 15:14:10 fabiankeil Exp $";
   2 /*********************************************************************
   3  *
   4  * File        :  $Source: /cvsroot/ijbswa/current/jbsockets.c,v $
   5  *
   6  * Purpose     :  Contains wrappers for system-specific sockets code,
   7  *                so that the rest of Junkbuster can be more
   8  *                OS-independent.  Contains #ifdefs to make this work
   9  *                on many platforms.
  10  *
  11  * Copyright   :  Written by and Copyright (C) 2001-2009 the
  12  *                Privoxy team. http://www.privoxy.org/
  13  *
  14  *                Based on the Internet Junkbuster originally written
  15  *                by and Copyright (C) 1997 Anonymous Coders and
  16  *                Junkbusters Corporation.  http://www.junkbusters.com
  17  *
  18  *                This program is free software; you can redistribute it
  19  *                and/or modify it under the terms of the GNU General
  20  *                Public License as published by the Free Software
  21  *                Foundation; either version 2 of the License, or (at
  22  *                your option) any later version.
  23  *
  24  *                This program is distributed in the hope that it will
  25  *                be useful, but WITHOUT ANY WARRANTY; without even the
  26  *                implied warranty of MERCHANTABILITY or FITNESS FOR A
  27  *                PARTICULAR PURPOSE.  See the GNU General Public
  28  *                License for more details.
  29  *
  30  *                The GNU General Public License should be included with
  31  *                this file.  If not, you can view it at
  32  *                http://www.gnu.org/copyleft/gpl.html
  33  *                or write to the Free Software Foundation, Inc., 59
  34  *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  35  *
  36  *********************************************************************/
  37
  38
  39 #include "config.h"
  40
  41 #include <stdlib.h>
  42 #include <stdio.h>
  43 #include <string.h>
  44 #include <errno.h>
  45 #include <fcntl.h>
  46 #include <sys/types.h>
  47
  48 #ifdef _WIN32
  49
  50 #ifndef STRICT
  51 #define STRICT
  52 #endif
  53 #include <windows.h>
  54 #include <sys/timeb.h>
  55 #include <io.h>
  56
  57 #else
  58
  59 #ifndef __OS2__
  60 #include <unistd.h>
  61 #endif
  62 #include <sys/time.h>
  63 #include <netinet/in.h>
  64 #include <sys/ioctl.h>
  65 #include <netdb.h>
  66 #include <sys/socket.h>
  67
  68 #ifndef __BEOS__
  69 #include <netinet/tcp.h>
  70 #ifndef __OS2__
  71 #include <arpa/inet.h>
  72 #endif
  73 #else
  74 #include <socket.h>
  75 #endif
  76
  77 #if defined(__EMX__) || defined (__OS2__)
  78 #include <sys/select.h>  /* OS/2/EMX needs a little help with select */
  79 #ifdef __OS2__
  80 #include <nerrno.h>
  81 #endif
  82 #endif
  83
  84 #endif
  85
  86 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
  87 #ifdef HAVE_POLL
  88 #ifdef __GLIBC__
  89 #include <sys/poll.h>
  90 #else
  91 #include <poll.h>
  92 #endif /* def __GLIBC__ */
  93 #endif /* HAVE_POLL */
  94 #endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
  95
  96 #include "project.h"
  97
  98 /* For mutex semaphores only */
  99 #include "jcc.h"
 100
 101 #include "jbsockets.h"
 102 #include "filters.h"
 103 #include "errlog.h"
 104
 105 /* Mac OSX doesn't define AI_NUMERICSESRV */
 106 #ifndef AI_NUMERICSERV
 107 #define AI_NUMERICSERV 0
 108 #endif
 109
 110 const char jbsockets_h_rcs[] = JBSOCKETS_H_VERSION;
 111
 112 /*
 113  * Maximum number of gethostbyname(_r) retries in case of
 114  * soft errors (TRY_AGAIN).
 115  * XXX: Does it make sense to make this a config option?
 116  */
 117 #define MAX_DNS_RETRIES 10
 118
 119 #define MAX_LISTEN_BACKLOG 128
 120
 121
 122 /*********************************************************************
 123  *
 124  * Function    :  connect_to
 125  *
 126  * Description :  Open a socket and connect to it.  Will check
 127  *                that this is allowed according to ACL.
 128  *
 129  * Parameters  :
 130  *          1  :  host = hostname to connect to
 131  *          2  :  portnum = port to connent on (XXX: should be unsigned)
 132  *          3  :  csp = Current client state (buffers, headers, etc...)
 133  *                      Not modified, only used for source IP and ACL.
 134  *
 135  * Returns     :  JB_INVALID_SOCKET => failure, else it is the socket
 136  *                file descriptor.
 137  *
 138  *********************************************************************/
 139 #ifdef HAVE_RFC2553
 140 /* Getaddrinfo implementation */
 141 jb_socket connect_to(const char *host, int portnum, struct client_state *csp)
 142 {
 143    struct addrinfo hints, *result, *rp;
 144    char service[6];
 145    int retval;
 146    jb_socket fd;
 147    fd_set wfds;
 148    struct timeval tv[1];
 149 #if !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA)
 150    int   flags;
 151 #endif /* !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA) */
 152    int connect_failed;
 153
 154 #ifdef FEATURE_ACL
 155    struct access_control_addr dst[1];
 156 #endif /* def FEATURE_ACL */
 157
 158    retval = snprintf(service, sizeof(service), "%d", portnum);
 159    if ((-1 == retval) || (sizeof(service) <= retval))
 160    {
 161       log_error(LOG_LEVEL_ERROR,
 162          "Port number (%d) ASCII decimal representation doesn't fit into 6 bytes",
 163          portnum);
 164       csp->http->host_ip_addr_str = strdup("unknown");
 165       return(JB_INVALID_SOCKET);
 166    }
 167
 168    memset((char *)&hints, 0, sizeof(hints));
 169    hints.ai_family = AF_UNSPEC;
 170    hints.ai_socktype = SOCK_STREAM;
 171    hints.ai_flags = AI_NUMERICSERV; /* avoid service look-up */
 172 #ifdef AI_ADDRCONFIG
 173    hints.ai_flags |= AI_ADDRCONFIG;
 174 #endif
 175    if ((retval = getaddrinfo(host, service, &hints, &result)))
 176    {
 177       log_error(LOG_LEVEL_INFO,
 178          "Can not resolve %s: %s", host, gai_strerror(retval));
 179       /* XXX: Should find a better way to propagate this error. */
 180       errno = EINVAL;
 181       csp->http->host_ip_addr_str = strdup("unknown");
 182       return(JB_INVALID_SOCKET);
 183    }
 184
 185    for (rp = result; rp != NULL; rp = rp->ai_next)
 186    {
 187
 188 #ifdef FEATURE_ACL
 189       memcpy(&dst->addr, rp->ai_addr, rp->ai_addrlen);
 190
 191       if (block_acl(dst, csp))
 192       {
 193 #ifdef __OS2__
 194          errno = SOCEPERM;
 195 #else
 196          errno = EPERM;
 197 #endif
 198          continue;
 199       }
 200 #endif /* def FEATURE_ACL */
 201
 202       csp->http->host_ip_addr_str = malloc(NI_MAXHOST);
 203       if (NULL == csp->http->host_ip_addr_str)
 204       {
 205          log_error(LOG_LEVEL_ERROR,
 206             "Out of memory while getting the server IP address.");
 207          return JB_INVALID_SOCKET;
 208       }
 209       retval = getnameinfo(rp->ai_addr, rp->ai_addrlen,
 210          csp->http->host_ip_addr_str, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
 211       if (!csp->http->host_ip_addr_str || retval)
 212       {
 213          log_error(LOG_LEVEL_ERROR,
 214             "Can not save csp->http->host_ip_addr_str: %s",
 215             (csp->http->host_ip_addr_str) ?
 216             gai_strerror(retval) : "Insufficient memory");
 217          freez(csp->http->host_ip_addr_str);
 218          continue;
 219       }
 220
 221 #ifdef _WIN32
 222       if ((fd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol)) ==
 223             JB_INVALID_SOCKET)
 224 #else
 225       if ((fd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol)) < 0)
 226 #endif
 227       {
 228          continue;
 229       }
 230
 231 #ifdef TCP_NODELAY
 232       {  /* turn off TCP coalescence */
 233          int mi = 1;
 234          setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *) &mi, sizeof (int));
 235       }
 236 #endif /* def TCP_NODELAY */
 237
 238 #if !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA) && !defined(__OS2__)
 239       if ((flags = fcntl(fd, F_GETFL, 0)) != -1)
 240       {
 241          flags |= O_NDELAY;
 242          fcntl(fd, F_SETFL, flags);
 243       }
 244 #endif /* !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA) && !defined(__OS2__) */
 245
 246       connect_failed = 0;
 247       while (connect(fd, rp->ai_addr, rp->ai_addrlen) == JB_INVALID_SOCKET)
 248       {
 249 #ifdef _WIN32
 250          if (errno == WSAEINPROGRESS)
 251 #elif __OS2__
 252          if (sock_errno() == EINPROGRESS)
 253 #else /* ifndef _WIN32 */
 254          if (errno == EINPROGRESS)
 255 #endif /* ndef _WIN32 || __OS2__ */
 256          {
 257             break;
 258          }
 259
 260 #ifdef __OS2__
 261          if (sock_errno() != EINTR)
 262 #else
 263          if (errno != EINTR)
 264 #endif /* __OS2__ */
 265          {
 266             close_socket(fd);
 267             connect_failed = 1;
 268             break;
 269          }
 270       }
 271       if (connect_failed)
 272       {
 273          continue;
 274       }
 275
 276 #if !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA) && !defined(__OS2__)
 277       if (flags != -1)
 278       {
 279          flags &= ~O_NDELAY;
 280          fcntl(fd, F_SETFL, flags);
 281       }
 282 #endif /* !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA) && !defined(__OS2__) */
 283
 284       /* wait for connection to complete */
 285       FD_ZERO(&wfds);
 286       FD_SET(fd, &wfds);
 287
 288       tv->tv_sec  = 30;
 289       tv->tv_usec = 0;
 290
 291       /* MS Windows uses int, not SOCKET, for the 1st arg of select(). Wierd! */
 292       if ((select((int)fd + 1, NULL, &wfds, NULL, tv) > 0)
 293          && FD_ISSET(fd, &wfds))
 294       {
 295          /*
 296           * See Linux connect(2) man page for more info
 297           * about connecting on non-blocking socket.
 298           */
 299          int socket_in_error;
 300          socklen_t optlen = sizeof(socket_in_error);
 301          if (!getsockopt(fd, SOL_SOCKET, SO_ERROR, &socket_in_error, &optlen))
 302          {
 303             if (!socket_in_error)
 304             {
 305                /* Connection established, no need to try other addresses. */
 306                break;
 307             }
 308             log_error(LOG_LEVEL_CONNECT, "Could not connect to [%s]:%s: %s.",
 309                csp->http->host_ip_addr_str, service, strerror(socket_in_error));
 310          }
 311          else
 312          {
 313             log_error(LOG_LEVEL_ERROR, "Could not get the state of "
 314                "the connection to [%s]:%s: %s; dropping connection.",
 315                csp->http->host_ip_addr_str, service, strerror(errno));
 316          }
 317       }
 318
 319       /* Connection failed, try next address */
 320       close_socket(fd);
 321    }
 322
 323    freeaddrinfo(result);
 324    if (!rp)
 325    {
 326       log_error(LOG_LEVEL_CONNECT, "Could not connect to [%s]:%s.",
 327          host, service);
 328       return(JB_INVALID_SOCKET);
 329    }
 330    log_error(LOG_LEVEL_CONNECT, "Connected to %s[%s]:%s.",
 331       host, csp->http->host_ip_addr_str, service);
 332
 333    return(fd);
 334
 335 }
 336
 337 #else /* ndef HAVE_RFC2553 */
 338 /* Pre-getaddrinfo implementation */
 339
 340 jb_socket connect_to(const char *host, int portnum, struct client_state *csp)
 341 {
 342    struct sockaddr_in inaddr;
 343    jb_socket fd;
 344    unsigned int addr;
 345    fd_set wfds;
 346    struct timeval tv[1];
 347 #if !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA)
 348    int   flags;
 349 #endif /* !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA) */
 350
 351 #ifdef FEATURE_ACL
 352    struct access_control_addr dst[1];
 353 #endif /* def FEATURE_ACL */
 354
 355    memset((char *)&inaddr, 0, sizeof inaddr);
 356
 357    if ((addr = resolve_hostname_to_ip(host)) == INADDR_NONE)
 358    {
 359       csp->http->host_ip_addr_str = strdup("unknown");
 360       return(JB_INVALID_SOCKET);
 361    }
 362
 363 #ifdef FEATURE_ACL
 364    dst->addr = ntohl(addr);
 365    dst->port = portnum;
 366
 367    if (block_acl(dst, csp))
 368    {
 369 #ifdef __OS2__
 370       errno = SOCEPERM;
 371 #else
 372       errno = EPERM;
 373 #endif
 374       return(JB_INVALID_SOCKET);
 375    }
 376 #endif /* def FEATURE_ACL */
 377
 378    inaddr.sin_addr.s_addr = addr;
 379    inaddr.sin_family      = AF_INET;
 380    csp->http->host_ip_addr_str = strdup(inet_ntoa(inaddr.sin_addr));
 381
 382 #ifndef _WIN32
 383    if (sizeof(inaddr.sin_port) == sizeof(short))
 384 #endif /* ndef _WIN32 */
 385    {
 386       inaddr.sin_port = htons((unsigned short) portnum);
 387    }
 388 #ifndef _WIN32
 389    else
 390    {
 391       inaddr.sin_port = htonl((unsigned long)portnum);
 392    }
 393 #endif /* ndef _WIN32 */
 394
 395 #ifdef _WIN32
 396    if ((fd = socket(inaddr.sin_family, SOCK_STREAM, 0)) == JB_INVALID_SOCKET)
 397 #else
 398    if ((fd = socket(inaddr.sin_family, SOCK_STREAM, 0)) < 0)
 399 #endif
 400    {
 401       return(JB_INVALID_SOCKET);
 402    }
 403
 404 #ifdef TCP_NODELAY
 405    {  /* turn off TCP coalescence */
 406       int mi = 1;
 407       setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *) &mi, sizeof (int));
 408    }
 409 #endif /* def TCP_NODELAY */
 410
 411 #if !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA) && !defined(__OS2__)
 412    if ((flags = fcntl(fd, F_GETFL, 0)) != -1)
 413    {
 414       flags |= O_NDELAY;
 415       fcntl(fd, F_SETFL, flags);
 416    }
 417 #endif /* !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA) && !defined(__OS2__) */
 418
 419    while (connect(fd, (struct sockaddr *) & inaddr, sizeof inaddr) == JB_INVALID_SOCKET)
 420    {
 421 #ifdef _WIN32
 422       if (errno == WSAEINPROGRESS)
 423 #elif __OS2__
 424       if (sock_errno() == EINPROGRESS)
 425 #else /* ifndef _WIN32 */
 426       if (errno == EINPROGRESS)
 427 #endif /* ndef _WIN32 || __OS2__ */
 428       {
 429          break;
 430       }
 431
 432 #ifdef __OS2__
 433       if (sock_errno() != EINTR)
 434 #else
 435       if (errno != EINTR)
 436 #endif /* __OS2__ */
 437       {
 438          close_socket(fd);
 439          return(JB_INVALID_SOCKET);
 440       }
 441    }
 442
 443 #if !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA) && !defined(__OS2__)
 444    if (flags != -1)
 445    {
 446       flags &= ~O_NDELAY;
 447       fcntl(fd, F_SETFL, flags);
 448    }
 449 #endif /* !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA) && !defined(__OS2__) */
 450
 451    /* wait for connection to complete */
 452    FD_ZERO(&wfds);
 453    FD_SET(fd, &wfds);
 454
 455    tv->tv_sec  = 30;
 456    tv->tv_usec = 0;
 457
 458    /* MS Windows uses int, not SOCKET, for the 1st arg of select(). Wierd! */
 459    if (select((int)fd + 1, NULL, &wfds, NULL, tv) <= 0)
 460    {
 461       close_socket(fd);
 462       return(JB_INVALID_SOCKET);
 463    }
 464    return(fd);
 465
 466 }
 467 #endif /* ndef HAVE_RFC2553 */
 468
 469
 470 /*********************************************************************
 471  *
 472  * Function    :  write_socket
 473  *
 474  * Description :  Write the contents of buf (for n bytes) to socket fd.
 475  *
 476  * Parameters  :
 477  *          1  :  fd = file descriptor (aka. handle) of socket to write to.
 478  *          2  :  buf = pointer to data to be written.
 479  *          3  :  len = length of data to be written to the socket "fd".
 480  *
 481  * Returns     :  0 on success (entire buffer sent).
 482  *                nonzero on error.
 483  *
 484  *********************************************************************/
 485 #ifdef AMIGA
 486 int write_socket(jb_socket fd, const char *buf, ssize_t len)
 487 #else
 488 int write_socket(jb_socket fd, const char *buf, size_t len)
 489 #endif
 490 {
 491    if (len == 0)
 492    {
 493       return 0;
 494    }
 495
 496    if (len < 0) /* constant condition - size_t isn't ever negative */
 497    {
 498       return 1;
 499    }
 500
 501    log_error(LOG_LEVEL_LOG, "%N", len, buf);
 502
 503 #if defined(_WIN32)
 504    return (send(fd, buf, (int)len, 0) != (int)len);
 505 #elif defined(__BEOS__) || defined(AMIGA)
 506    return (send(fd, buf, len, 0) != len);
 507 #elif defined(__OS2__)
 508    /*
 509     * Break the data up into SOCKET_SEND_MAX chunks for sending...
 510     * OS/2 seemed to complain when the chunks were too large.
 511     */
 512 #define SOCKET_SEND_MAX 65000
 513    {
 514       int write_len = 0, send_len, send_rc = 0, i = 0;
 515       while ((i < len) && (send_rc != -1))
 516       {
 517          if ((i + SOCKET_SEND_MAX) > len)
 518             send_len = len - i;
 519          else
 520             send_len = SOCKET_SEND_MAX;
 521          send_rc = send(fd,(char*)buf + i, send_len, 0);
 522          if (send_rc == -1)
 523             return 1;
 524          i = i + send_len;
 525       }
 526       return 0;
 527    }
 528 #else
 529    return (write(fd, buf, len) != len);
 530 #endif
 531
 532 }
 533
 534
 535 /*********************************************************************
 536  *
 537  * Function    :  read_socket
 538  *
 539  * Description :  Read from a TCP/IP socket in a platform independent way.
 540  *
 541  * Parameters  :
 542  *          1  :  fd = file descriptor of the socket to read
 543  *          2  :  buf = pointer to buffer where data will be written
 544  *                Must be >= len bytes long.
 545  *          3  :  len = maximum number of bytes to read
 546  *
 547  * Returns     :  On success, the number of bytes read is returned (zero
 548  *                indicates end of file), and the file position is advanced
 549  *                by this number.  It is not an error if this number is
 550  *                smaller than the number of bytes requested; this may hap-
 551  *                pen for example because fewer bytes are actually available
 552  *                right now (maybe because we were close to end-of-file, or
 553  *                because we are reading from a pipe, or from a terminal,
 554  *                or because read() was interrupted by a signal).  On error,
 555  *                -1 is returned, and errno is set appropriately.  In this
 556  *                case it is left unspecified whether the file position (if
 557  *                any) changes.
 558  *
 559  *********************************************************************/
 560 int read_socket(jb_socket fd, char *buf, int len)
 561 {
 562    if (len <= 0)
 563    {
 564       return(0);
 565    }
 566
 567 #if defined(_WIN32)
 568    return(recv(fd, buf, len, 0));
 569 #elif defined(__BEOS__) || defined(AMIGA) || defined(__OS2__)
 570    return(recv(fd, buf, (size_t)len, 0));
 571 #else
 572    return((int)read(fd, buf, (size_t)len));
 573 #endif
 574 }
 575
 576
 577 /*********************************************************************
 578  *
 579  * Function    :  data_is_available
 580  *
 581  * Description :  Waits for data to arrive on a socket.
 582  *
 583  * Parameters  :
 584  *          1  :  fd = file descriptor of the socket to read
 585  *          2  :  seconds_to_wait = number of seconds after which we give up.
 586  *
 587  * Returns     :  TRUE if data arrived in time,
 588  *                FALSE otherwise.
 589  *
 590  *********************************************************************/
 591 int data_is_available(jb_socket fd, int seconds_to_wait)
 592 {
 593    char buf[10];
 594    fd_set rfds;
 595    struct timeval timeout;
 596    int n;
 597
 598    memset(&timeout, 0, sizeof(timeout));
 599    timeout.tv_sec = seconds_to_wait;
 600
 601 #ifdef __OS2__
 602    /* Copy and pasted from jcc.c ... */
 603    memset(&rfds, 0, sizeof(fd_set));
 604 #else
 605    FD_ZERO(&rfds);
 606 #endif
 607    FD_SET(fd, &rfds);
 608
 609    n = select(fd+1, &rfds, NULL, NULL, &timeout);
 610
 611    /*
 612     * XXX: Do we care about the different error conditions?
 613     */
 614    return ((n == 1) && (1 == recv(fd, buf, 1, MSG_PEEK)));
 615 }
 616
 617
 618 /*********************************************************************
 619  *
 620  * Function    :  close_socket
 621  *
 622  * Description :  Closes a TCP/IP socket
 623  *
 624  * Parameters  :
 625  *          1  :  fd = file descriptor of socket to be closed
 626  *
 627  * Returns     :  void
 628  *
 629  *********************************************************************/
 630 void close_socket(jb_socket fd)
 631 {
 632 #if defined(_WIN32) || defined(__BEOS__)
 633    closesocket(fd);
 634 #elif defined(AMIGA)
 635    CloseSocket(fd);
 636 #elif defined(__OS2__)
 637    soclose(fd);
 638 #else
 639    close(fd);
 640 #endif
 641
 642 }
 643
 644
 645 /*********************************************************************
 646  *
 647  * Function    :  bind_port
 648  *
 649  * Description :  Call socket, set socket options, and listen.
 650  *                Called by listen_loop to "boot up" our proxy address.
 651  *
 652  * Parameters  :
 653  *          1  :  hostnam = TCP/IP address to bind/listen to
 654  *          2  :  portnum = port to listen on
 655  *          3  :  pfd = pointer used to return file descriptor.
 656  *
 657  * Returns     :  if success, returns 0 and sets *pfd.
 658  *                if failure, returns -3 if address is in use,
 659  *                                    -2 if address unresolvable,
 660  *                                    -1 otherwise
 661  *********************************************************************/
 662 int bind_port(const char *hostnam, int portnum, jb_socket *pfd)
 663 {
 664 #ifdef HAVE_RFC2553
 665    struct addrinfo hints;
 666    struct addrinfo *result, *rp;
 667    /*
 668     * XXX: portnum should be a string to allow symbolic service
 669     * names in the configuration file and to avoid the following
 670     * int2string.
 671     */
 672    char servnam[6];
 673    int retval;
 674 #else
 675    struct sockaddr_in inaddr;
 676 #endif /* def HAVE_RFC2553 */
 677    jb_socket fd;
 678 #ifndef _WIN32
 679    int one = 1;
 680 #endif /* ndef _WIN32 */
 681
 682    *pfd = JB_INVALID_SOCKET;
 683
 684 #ifdef HAVE_RFC2553
 685    retval = snprintf(servnam, sizeof(servnam), "%d", portnum);
 686    if ((-1 == retval) || (sizeof(servnam) <= retval))
 687    {
 688       log_error(LOG_LEVEL_ERROR,
 689          "Port number (%d) ASCII decimal representation doesn't fit into 6 bytes",
 690          portnum);
 691       return -1;
 692    }
 693
 694    memset(&hints, 0, sizeof(struct addrinfo));
 695    if (hostnam == NULL)
 696    {
 697       /*
 698        * XXX: This is a hack. The right thing to do
 699        * would be to bind to both AF_INET and AF_INET6.
 700        * This will also fail if there is no AF_INET
 701        * version available.
 702        */
 703       hints.ai_family = AF_INET;
 704    }
 705    else
 706    {
 707       hints.ai_family = AF_UNSPEC;
 708    }
 709    hints.ai_socktype = SOCK_STREAM;
 710    hints.ai_flags = AI_PASSIVE;
 711 #ifdef AI_ADDRCONFIG
 712    hints.ai_flags |= AI_ADDRCONFIG;
 713 #endif
 714    hints.ai_protocol = 0; /* Realy any stream protocol or TCP only */
 715    hints.ai_canonname = NULL;
 716    hints.ai_addr = NULL;
 717    hints.ai_next = NULL;
 718
 719    if ((retval = getaddrinfo(hostnam, servnam, &hints, &result)))
 720    {
 721       log_error(LOG_LEVEL_ERROR,
 722          "Can not resolve %s: %s", hostnam, gai_strerror(retval));
 723       return -2;
 724    }
 725 #else
 726    memset((char *)&inaddr, '\0', sizeof inaddr);
 727
 728    inaddr.sin_family      = AF_INET;
 729    inaddr.sin_addr.s_addr = resolve_hostname_to_ip(hostnam);
 730
 731    if (inaddr.sin_addr.s_addr == INADDR_NONE)
 732    {
 733       return(-2);
 734    }
 735
 736 #ifndef _WIN32
 737    if (sizeof(inaddr.sin_port) == sizeof(short))
 738 #endif /* ndef _WIN32 */
 739    {
 740       inaddr.sin_port = htons((unsigned short) portnum);
 741    }
 742 #ifndef _WIN32
 743    else
 744    {
 745       inaddr.sin_port = htonl((unsigned long) portnum);
 746    }
 747 #endif /* ndef _WIN32 */
 748 #endif /* def HAVE_RFC2553 */
 749
 750 #ifdef HAVE_RFC2553
 751    for (rp = result; rp != NULL; rp = rp->ai_next)
 752    {
 753       fd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
 754 #else
 755    fd = socket(AF_INET, SOCK_STREAM, 0);
 756 #endif /* def HAVE_RFC2553 */
 757
 758 #ifdef _WIN32
 759    if (fd == JB_INVALID_SOCKET)
 760 #else
 761    if (fd < 0)
 762 #endif
 763    {
 764 #ifdef HAVE_RFC2553
 765       continue;
 766 #else
 767       return(-1);
 768 #endif
 769    }
 770
 771 #ifndef _WIN32
 772    /*
 773     * This is not needed for Win32 - in fact, it stops
 774     * duplicate instances of Privoxy from being caught.
 775     *
 776     * On UNIX, we assume the user is sensible enough not
 777     * to start Privoxy multiple times on the same IP.
 778     * Without this, stopping and restarting Privoxy
 779     * from a script fails.
 780     * Note: SO_REUSEADDR is meant to only take over
 781     * sockets which are *not* in listen state in Linux,
 782     * e.g. sockets in TIME_WAIT. YMMV.
 783     */
 784    setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *)&one, sizeof(one));
 785 #endif /* ndef _WIN32 */
 786
 787 #ifdef HAVE_RFC2553
 788    if (bind(fd, rp->ai_addr, rp->ai_addrlen) < 0)
 789 #else
 790    if (bind(fd, (struct sockaddr *)&inaddr, sizeof(inaddr)) < 0)
 791 #endif
 792    {
 793 #ifdef _WIN32
 794       errno = WSAGetLastError();
 795       if (errno == WSAEADDRINUSE)
 796 #else
 797       if (errno == EADDRINUSE)
 798 #endif
 799       {
 800 #ifdef HAVE_RFC2553
 801          freeaddrinfo(result);
 802 #endif
 803          close_socket(fd);
 804          return(-3);
 805       }
 806       else
 807       {
 808          close_socket(fd);
 809 #ifndef HAVE_RFC2553
 810          return(-1);
 811       }
 812    }
 813 #else
 814       }
 815    }
 816    else
 817    {
 818       /* bind() succeeded, escape from for-loop */
 819       /*
 820        * XXX: Support multiple listening sockets (e.g. localhost
 821        * resolves to AF_INET and AF_INET6, but only the first address
 822        * is used
 823        */
 824       break;
 825    }
 826    }
 827
 828    freeaddrinfo(result);
 829    if (rp == NULL)
 830    {
 831       /* All bind()s failed */
 832       return(-1);
 833    }
 834 #endif /* ndef HAVE_RFC2553 */
 835
 836    while (listen(fd, MAX_LISTEN_BACKLOG) == -1)
 837    {
 838       if (errno != EINTR)
 839       {
 840          return(-1);
 841       }
 842    }
 843
 844    *pfd = fd;
 845    return 0;
 846
 847 }
 848
 849
 850 /*********************************************************************
 851  *
 852  * Function    :  get_host_information
 853  *
 854  * Description :  Determines the IP address the client used to
 855  *                reach us and the hostname associated with it.
 856  *
 857  *                XXX: Most of the code has been copy and pasted
 858  *                from accept_connection() and not all of the
 859  *                ifdefs paths have been tested afterwards.
 860  *
 861  * Parameters  :
 862  *          1  :  afd = File descriptor returned from accept().
 863  *          2  :  ip_address = Pointer to return the pointer to
 864  *                             the ip address string.
 865  *          3  :  hostname =   Pointer to return the pointer to
 866  *                             the hostname or NULL if the caller
 867  *                             isn't interested in it.
 868  *
 869  * Returns     :  void.
 870  *
 871  *********************************************************************/
 872 void get_host_information(jb_socket afd, char **ip_address, char **hostname)
 873 {
 874 #ifdef HAVE_RFC2553
 875    struct sockaddr_storage server;
 876    int retval;
 877 #else
 878    struct sockaddr_in server;
 879    struct hostent *host = NULL;
 880 #endif /* HAVE_RFC2553 */
 881 #if defined(_WIN32) || defined(__OS2__) || defined(__APPLE_CC__) || defined(AMIGA)
 882    /* according to accept_connection() this fixes a warning. */
 883    int s_length, s_length_provided;
 884 #else
 885    socklen_t s_length, s_length_provided;
 886 #endif
 887 #ifndef HAVE_RFC2553
 888 #if defined(HAVE_GETHOSTBYADDR_R_8_ARGS) ||  defined(HAVE_GETHOSTBYADDR_R_7_ARGS) || defined(HAVE_GETHOSTBYADDR_R_5_ARGS)
 889    struct hostent result;
 890 #if defined(HAVE_GETHOSTBYADDR_R_5_ARGS)
 891    struct hostent_data hdata;
 892 #else
 893    char hbuf[HOSTENT_BUFFER_SIZE];
 894    int thd_err;
 895 #endif /* def HAVE_GETHOSTBYADDR_R_5_ARGS */
 896 #endif /* def HAVE_GETHOSTBYADDR_R_(8|7|5)_ARGS */
 897 #endif /* ifndef HAVE_RFC2553 */
 898    s_length = s_length_provided = sizeof(server);
 899
 900    if (NULL != hostname)
 901    {
 902       *hostname = NULL;
 903    }
 904    *ip_address = NULL;
 905
 906    if (!getsockname(afd, (struct sockaddr *) &server, &s_length))
 907    {
 908       if (s_length > s_length_provided)
 909       {
 910          log_error(LOG_LEVEL_ERROR, "getsockname() truncated server address");
 911          return;
 912       }
 913 #ifdef HAVE_RFC2553
 914       *ip_address = malloc(NI_MAXHOST);
 915       if (NULL == *ip_address)
 916       {
 917          log_error(LOG_LEVEL_ERROR,
 918             "Out of memory while getting the client's IP address.");
 919          return;
 920       }
 921       retval = getnameinfo((struct sockaddr *) &server, s_length,
 922          *ip_address, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
 923       if (retval)
 924       {
 925          log_error(LOG_LEVEL_ERROR,
 926             "Unable to print my own IP address: %s", gai_strerror(retval));
 927          freez(*ip_address);
 928          return;
 929       }
 930 #else
 931       *ip_address = strdup(inet_ntoa(server.sin_addr));
 932 #endif /* HAVE_RFC2553 */
 933       if (NULL == hostname)
 934       {
 935          /*
 936           * We're done here, the caller isn't
 937           * interested in knowing the hostname.
 938           */
 939          return;
 940       }
 941
 942 #ifdef HAVE_RFC2553
 943       *hostname = malloc(NI_MAXHOST);
 944       if (NULL == *hostname)
 945       {
 946          log_error(LOG_LEVEL_ERROR,
 947             "Out of memory while getting the client's hostname.");
 948          return;
 949       }
 950       retval = getnameinfo((struct sockaddr *) &server, s_length,
 951          *hostname, NI_MAXHOST, NULL, 0, NI_NAMEREQD);
 952       if (retval)
 953       {
 954          log_error(LOG_LEVEL_ERROR,
 955             "Unable to resolve my own IP address: %s", gai_strerror(retval));
 956          freez(*hostname);
 957       }
 958 #else
 959 #if defined(HAVE_GETHOSTBYADDR_R_8_ARGS)
 960       gethostbyaddr_r((const char *)&server.sin_addr,
 961                       sizeof(server.sin_addr), AF_INET,
 962                       &result, hbuf, HOSTENT_BUFFER_SIZE,
 963                       &host, &thd_err);
 964 #elif defined(HAVE_GETHOSTBYADDR_R_7_ARGS)
 965       host = gethostbyaddr_r((const char *)&server.sin_addr,
 966                       sizeof(server.sin_addr), AF_INET,
 967                       &result, hbuf, HOSTENT_BUFFER_SIZE, &thd_err);
 968 #elif defined(HAVE_GETHOSTBYADDR_R_5_ARGS)
 969       if (0 == gethostbyaddr_r((const char *)&server.sin_addr,
 970                                sizeof(server.sin_addr), AF_INET,
 971                                &result, &hdata))
 972       {
 973          host = &result;
 974       }
 975       else
 976       {
 977          host = NULL;
 978       }
 979 #elif defined(MUTEX_LOCKS_AVAILABLE)
 980       privoxy_mutex_lock(&resolver_mutex);
 981       host = gethostbyaddr((const char *)&server.sin_addr,
 982                            sizeof(server.sin_addr), AF_INET);
 983       privoxy_mutex_unlock(&resolver_mutex);
 984 #else
 985       host = gethostbyaddr((const char *)&server.sin_addr,
 986                            sizeof(server.sin_addr), AF_INET);
 987 #endif
 988       if (host == NULL)
 989       {
 990          log_error(LOG_LEVEL_ERROR, "Unable to get my own hostname: %E\n");
 991       }
 992       else
 993       {
 994          *hostname = strdup(host->h_name);
 995       }
 996 #endif /* else def HAVE_RFC2553 */
 997    }
 998
 999    return;
1000 }
1001
1002
1003 /*********************************************************************
1004  *
1005  * Function    :  accept_connection
1006  *
1007  * Description :  Accepts a connection on a socket.  Socket must have
1008  *                been created using bind_port().
1009  *
1010  * Parameters  :
1011  *          1  :  csp = Client state, cfd, ip_addr_str, and
1012  *                ip_addr_long will be set by this routine.
1013  *          2  :  fd  = file descriptor returned from bind_port
1014  *
1015  * Returns     :  when a connection is accepted, it returns 1 (TRUE).
1016  *                On an error it returns 0 (FALSE).
1017  *
1018  *********************************************************************/
1019 int accept_connection(struct client_state * csp, jb_socket fd)
1020 {
1021 #ifdef HAVE_RFC2553
1022    /* XXX: client is stored directly into csp->tcp_addr */
1023 #define client (csp->tcp_addr)
1024    int retval;
1025 #else
1026    struct sockaddr_in client;
1027 #endif
1028    jb_socket afd;
1029 #if defined(_WIN32) || defined(__OS2__) || defined(__APPLE_CC__) || defined(AMIGA)
1030    /* Wierdness - fix a warning. */
1031    int c_length;
1032 #else
1033    socklen_t c_length;
1034 #endif
1035
1036    c_length = sizeof(client);
1037
1038 #ifdef _WIN32
1039    afd = accept (fd, (struct sockaddr *) &client, &c_length);
1040    if (afd == JB_INVALID_SOCKET)
1041    {
1042       return 0;
1043    }
1044 #else
1045    do
1046    {
1047 #if defined(FEATURE_ACCEPT_FILTER) && defined(SO_ACCEPTFILTER)
1048       struct accept_filter_arg af_options;
1049       bzero(&af_options, sizeof(af_options));
1050       strlcpy(af_options.af_name, "httpready", sizeof(af_options.af_name));
1051       setsockopt(fd, SOL_SOCKET, SO_ACCEPTFILTER, &af_options, sizeof(af_options));
1052 #endif
1053       afd = accept (fd, (struct sockaddr *) &client, &c_length);
1054    } while (afd < 1 && errno == EINTR);
1055    if (afd < 0)
1056    {
1057       return 0;
1058    }
1059 #endif
1060
1061    csp->cfd = afd;
1062 #ifdef HAVE_RFC2553
1063    csp->ip_addr_str = malloc(NI_MAXHOST);
1064    if (NULL == csp->ip_addr_str)
1065    {
1066       log_error(LOG_LEVEL_ERROR,
1067          "Out of memory while getting the client's IP address.");
1068       return 0;
1069    }
1070    retval = getnameinfo((struct sockaddr *) &client, c_length,
1071          csp->ip_addr_str, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
1072    if (!csp->ip_addr_str || retval)
1073    {
1074       log_error(LOG_LEVEL_ERROR, "Can not save csp->ip_addr_str: %s",
1075             (csp->ip_addr_str) ? gai_strerror(retval) : "Insuffcient memory");
1076       freez(csp->ip_addr_str);
1077    }
1078 #undef client
1079 #else
1080    csp->ip_addr_str  = strdup(inet_ntoa(client.sin_addr));
1081    csp->ip_addr_long = ntohl(client.sin_addr.s_addr);
1082 #endif /* def HAVE_RFC2553 */
1083
1084    return 1;
1085
1086 }
1087
1088
1089 /*********************************************************************
1090  *
1091  * Function    :  resolve_hostname_to_ip
1092  *
1093  * Description :  Resolve a hostname to an internet tcp/ip address.
1094  *                NULL or an empty string resolve to INADDR_ANY.
1095  *
1096  * Parameters  :
1097  *          1  :  host = hostname to resolve
1098  *
1099  * Returns     :  INADDR_NONE => failure, INADDR_ANY or tcp/ip address if succesful.
1100  *
1101  *********************************************************************/
1102 unsigned long resolve_hostname_to_ip(const char *host)
1103 {
1104    struct sockaddr_in inaddr;
1105    struct hostent *hostp;
1106    unsigned int dns_retries = 0;
1107 #if defined(HAVE_GETHOSTBYNAME_R_6_ARGS) || defined(HAVE_GETHOSTBYNAME_R_5_ARGS) || defined(HAVE_GETHOSTBYNAME_R_3_ARGS)
1108    struct hostent result;
1109 #if defined(HAVE_GETHOSTBYNAME_R_6_ARGS) || defined(HAVE_GETHOSTBYNAME_R_5_ARGS)
1110    char hbuf[HOSTENT_BUFFER_SIZE];
1111    int thd_err;
1112 #else /* defined(HAVE_GETHOSTBYNAME_R_3_ARGS) */
1113    struct hostent_data hdata;
1114 #endif /* def HAVE_GETHOSTBYNAME_R_(6|5)_ARGS */
1115 #endif /* def HAVE_GETHOSTBYNAME_R_(6|5|3)_ARGS */
1116
1117    if ((host == NULL) || (*host == '\0'))
1118    {
1119       return(INADDR_ANY);
1120    }
1121
1122    memset((char *) &inaddr, 0, sizeof inaddr);
1123
1124    if ((inaddr.sin_addr.s_addr = inet_addr(host)) == -1)
1125    {
1126 #if defined(HAVE_GETHOSTBYNAME_R_6_ARGS)
1127       while (gethostbyname_r(host, &result, hbuf,
1128                 HOSTENT_BUFFER_SIZE, &hostp, &thd_err)
1129              && (thd_err == TRY_AGAIN) && (dns_retries++ < MAX_DNS_RETRIES))
1130       {
1131          log_error(LOG_LEVEL_ERROR,
1132             "Timeout #%u while trying to resolve %s. Trying again.",
1133             dns_retries, host);
1134       }
1135 #elif defined(HAVE_GETHOSTBYNAME_R_5_ARGS)
1136       while (NULL == (hostp = gethostbyname_r(host, &result,
1137                                  hbuf, HOSTENT_BUFFER_SIZE, &thd_err))
1138              && (thd_err == TRY_AGAIN) && (dns_retries++ < MAX_DNS_RETRIES))
1139       {
1140          log_error(LOG_LEVEL_ERROR,
1141             "Timeout #%u while trying to resolve %s. Trying again.",
1142             dns_retries, host);
1143       }
1144 #elif defined(HAVE_GETHOSTBYNAME_R_3_ARGS)
1145       /*
1146        * XXX: Doesn't retry in case of soft errors.
1147        * Does this gethostbyname_r version set h_errno?
1148        */
1149       if (0 == gethostbyname_r(host, &result, &hdata))
1150       {
1151          hostp = &result;
1152       }
1153       else
1154       {
1155          hostp = NULL;
1156       }
1157 #elif defined(MUTEX_LOCKS_AVAILABLE)
1158       privoxy_mutex_lock(&resolver_mutex);
1159       while (NULL == (hostp = gethostbyname(host))
1160              && (h_errno == TRY_AGAIN) && (dns_retries++ < MAX_DNS_RETRIES))
1161       {
1162          log_error(LOG_LEVEL_ERROR,
1163             "Timeout #%u while trying to resolve %s. Trying again.",
1164             dns_retries, host);
1165       }
1166       privoxy_mutex_unlock(&resolver_mutex);
1167 #else
1168       while (NULL == (hostp = gethostbyname(host))
1169              && (h_errno == TRY_AGAIN) && (dns_retries++ < MAX_DNS_RETRIES))
1170       {
1171          log_error(LOG_LEVEL_ERROR,
1172             "Timeout #%u while trying to resolve %s. Trying again.",
1173             dns_retries, host);
1174       }
1175 #endif /* def HAVE_GETHOSTBYNAME_R_(6|5|3)_ARGS */
1176       /*
1177        * On Mac OSX, if a domain exists but doesn't have a type A
1178        * record associated with it, the h_addr member of the struct
1179        * hostent returned by gethostbyname is NULL, even if h_length
1180        * is 4. Therefore the second test below.
1181        */
1182       if (hostp == NULL || hostp->h_addr == NULL)
1183       {
1184          errno = EINVAL;
1185          log_error(LOG_LEVEL_ERROR, "could not resolve hostname %s", host);
1186          return(INADDR_NONE);
1187       }
1188       if (hostp->h_addrtype != AF_INET)
1189       {
1190 #ifdef _WIN32
1191          errno = WSAEPROTOTYPE;
1192 #else
1193          errno = EPROTOTYPE;
1194 #endif
1195          log_error(LOG_LEVEL_ERROR, "hostname %s resolves to unknown address type.", host);
1196          return(INADDR_NONE);
1197       }
1198       memcpy(
1199          (char *) &inaddr.sin_addr,
1200          (char *) hostp->h_addr,
1201          sizeof(inaddr.sin_addr)
1202       );
1203    }
1204    return(inaddr.sin_addr.s_addr);
1205
1206 }
1207
1208
1209 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
1210 /*********************************************************************
1211  *
1212  * Function    :  socket_is_still_alive
1213  *
1214  * Description :  Figures out whether or not a socket is still alive.
1215  *
1216  * Parameters  :
1217  *          1  :  sfd = The socket to check.
1218  *
1219  * Returns     :  TRUE for yes, otherwise FALSE.
1220  *
1221  *********************************************************************/
1222 int socket_is_still_alive(jb_socket sfd)
1223 {
1224    char buf[10];
1225    int no_data_waiting;
1226
1227 #ifdef HAVE_POLL
1228    int poll_result;
1229    struct pollfd poll_fd[1];
1230
1231    memset(poll_fd, 0, sizeof(poll_fd));
1232    poll_fd[0].fd = sfd;
1233    poll_fd[0].events = POLLIN;
1234
1235    poll_result = poll(poll_fd, 1, 0);
1236
1237    if (-1 == poll_result)
1238    {
1239       log_error(LOG_LEVEL_CONNECT, "Polling socket %d failed.", sfd);
1240       return FALSE;
1241    }
1242    no_data_waiting = !(poll_fd[0].revents & POLLIN);
1243 #else
1244    fd_set readable_fds;
1245    struct timeval timeout;
1246    int ret;
1247
1248    memset(&timeout, '\0', sizeof(timeout));
1249    FD_ZERO(&readable_fds);
1250    FD_SET(sfd, &readable_fds);
1251
1252    ret = select((int)sfd+1, &readable_fds, NULL, NULL, &timeout);
1253    if (ret < 0)
1254    {
1255       log_error(LOG_LEVEL_CONNECT, "select() on socket %d failed: %E", sfd);
1256       return FALSE;
1257    }
1258    no_data_waiting = !FD_ISSET(sfd, &readable_fds);
1259 #endif /* def HAVE_POLL */
1260
1261    return (no_data_waiting || (1 == recv(sfd, buf, 1, MSG_PEEK)));
1262 }
1263 #endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
1264
1265
1266 /*
1267   Local Variables:
1268   tab-width: 3
1269   end:
1270 */