jbsockets.c

   1 const char jbsockets_rcs[] = "$Id: jbsockets.c,v 1.47 2008/03/26 18:07:07 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-2007 the SourceForge
  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  * Revisions   :
  37  *    $Log: jbsockets.c,v $
  38  *    Revision 1.47  2008/03/26 18:07:07  fabiankeil
  39  *    Add hostname directive. Closes PR#1918189.
  40  *
  41  *    Revision 1.46  2008/03/21 11:13:57  fabiankeil
  42  *    Only gather host information if it's actually needed.
  43  *    Also move the code out of accept_connection() so it's less likely
  44  *    to delay other incoming connections if the host is misconfigured.
  45  *
  46  *    Revision 1.45  2007/09/30 16:59:22  fabiankeil
  47  *    Set the maximum listen() backlog to 128. Apparently SOMAXCONN is
  48  *    neither high enough, nor a hard limit on mingw32. Again for BR#1795281.
  49  *
  50  *    Revision 1.44  2007/09/15 13:01:31  fabiankeil
  51  *    Increase listen() backlog to SOMAXCONN (or 128) to decrease
  52  *    chances of dropped connections under load. Problem reported
  53  *    and fix suggested by nobody in BR#1795281.
  54  *
  55  *    Revision 1.43  2007/06/01 18:16:36  fabiankeil
  56  *    Use the same mutex for gethostbyname() and gethostbyaddr() to prevent
  57  *    deadlocks and crashes on OpenBSD and possibly other OS with neither
  58  *    gethostbyname_r() nor gethostaddr_r(). Closes BR#1729174.
  59  *    Thanks to Ralf Horstmann for report and solution.
  60  *
  61  *    Revision 1.42  2007/04/01 17:37:07  fabiankeil
  62  *    - Add DNS retries for Solaris and other systems
  63  *      whose gethostbyname_r version takes five arguments.
  64  *    - Move maximum number of DNS retries into a macro.
  65  *
  66  *    Revision 1.41  2006/11/13 19:05:51  fabiankeil
  67  *    Make pthread mutex locking more generic. Instead of
  68  *    checking for OSX and OpenBSD, check for FEATURE_PTHREAD
  69  *    and use mutex locking unless there is an _r function
  70  *    available. Better safe than sorry.
  71  *
  72  *    Fixes "./configure --disable-pthread" and should result
  73  *    in less threading-related problems on pthread-using platforms,
  74  *    but it still doesn't fix BR#1122404.
  75  *
  76  *    Revision 1.40  2006/09/02 15:36:42  fabiankeil
  77  *    Follow the OpenBSD port's lead and protect the resolve
  78  *    functions on OpenBSD as well.
  79  *
  80  *    Revision 1.39  2006/08/03 02:46:41  david__schmidt
  81  *    Incorporate Fabian Keil's patch work:\rhttp://www.fabiankeil.de/sourcecode/privoxy/
  82  *
  83  *    Revision 1.38  2006/07/18 14:48:46  david__schmidt
  84  *    Reorganizing the repository: swapping out what was HEAD (the old 3.1 branch)
  85  *    with what was really the latest development (the v_3_0_branch branch)
  86  *
  87  *    Revision 1.35.2.8  2006/01/21 16:16:08  david__schmidt
  88  *    Thanks to  Edward Carrel for his patch to modernize OSX's\rpthreads support.  See bug #1409623.
  89  *
  90  *    Revision 1.35.2.7  2005/05/07 21:50:55  david__schmidt
  91  *    A few memory leaks plugged (mostly on error paths)
  92  *
  93  *    Revision 1.35.2.6  2003/12/17 16:34:40  oes
  94  *    Cosmetics
  95  *
  96  *    Revision 1.35.2.5  2003/04/29 11:32:54  oes
  97  *    Don't rely on h_addr being non-NULL after gethostbyname.
  98  *    Works around an oddness in Max OSX and closes bug #724796
  99  *
 100  *    Revision 1.35.2.4  2003/04/04 12:40:20  oes
 101  *    Made sure the errno set by bind, not close[socket] is used in
 102  *    bind_port. Probably fixes bugs #713777, #705562.
 103  *
 104  *    Revision 1.35.2.3  2003/03/07 03:41:04  david__schmidt
 105  *    Wrapping all *_r functions (the non-_r versions of them) with mutex semaphores for OSX.  Hopefully this will take care of all of those pesky crash reports.
 106  *
 107  *    Revision 1.35.2.2  2002/11/20 14:37:24  oes
 108  *    Fixed Win32 error logging in bind_port.
 109  *    Thanks to Oliver Stoeneberg for the hint.
 110  *
 111  *    Revision 1.35.2.1  2002/05/26 23:41:27  joergs
 112  *    AmigaOS: Fixed wrong type of len in write_socket()
 113  *
 114  *    Revision 1.35  2002/04/26 15:50:04  joergs
 115  *    AmigaOS: No socklen_t, added AMIGA to the systems using int instead.
 116  *
 117  *    Revision 1.34  2002/04/08 20:31:41  swa
 118  *    fixed JB spelling
 119  *
 120  *    Revision 1.33  2002/04/03 16:02:18  gliptak
 121  *    Correcting compile warning with older gcc
 122  *
 123  *    Revision 1.32  2002/03/31 17:18:59  jongfoster
 124  *    Win32 only: Enabling STRICT to fix a VC++ compile warning.
 125  *
 126  *    Revision 1.31  2002/03/29 03:33:13  david__schmidt
 127  *    Fix Mac OSX compiler warnings
 128  *
 129  *    Revision 1.30  2002/03/27 14:32:43  david__schmidt
 130  *    More compiler warning message maintenance
 131  *
 132  *    Revision 1.29  2002/03/26 22:29:54  swa
 133  *    we have a new homepage!
 134  *
 135  *    Revision 1.28  2002/03/24 13:25:43  swa
 136  *    name change related issues
 137  *
 138  *    Revision 1.27  2002/03/13 00:27:05  jongfoster
 139  *    Killing warnings
 140  *
 141  *    Revision 1.26  2002/03/11 22:07:02  david__schmidt
 142  *    OS/2 port maintenance:
 143  *    - Fixed EMX build - it had decayed a little
 144  *    - Fixed inexplicable crash during FD_ZERO - must be due to a bad macro.
 145  *      substituted a memset for now.
 146  *
 147  *    Revision 1.25  2002/03/09 20:03:52  jongfoster
 148  *    - Making various functions return int rather than size_t.
 149  *      (Undoing a recent change).  Since size_t is unsigned on
 150  *      Windows, functions like read_socket that return -1 on
 151  *      error cannot return a size_t.
 152  *
 153  *      THIS WAS A MAJOR BUG - it caused frequent, unpredictable
 154  *      crashes, and also frequently caused JB to jump to 100%
 155  *      CPU and stay there.  (Because it thought it had just
 156  *      read ((unsigned)-1) == 4Gb of data...)
 157  *
 158  *    - The signature of write_socket has changed, it now simply
 159  *      returns success=0/failure=nonzero.
 160  *
 161  *    - Trying to get rid of a few warnings --with-debug on
 162  *      Windows, I've introduced a new type "jb_socket".  This is
 163  *      used for the socket file descriptors.  On Windows, this
 164  *      is SOCKET (a typedef for unsigned).  Everywhere else, it's
 165  *      an int.  The error value can't be -1 any more, so it's
 166  *      now JB_INVALID_SOCKET (which is -1 on UNIX, and in
 167  *      Windows it maps to the #define INVALID_SOCKET.)
 168  *
 169  *    - The signature of bind_port has changed.
 170  *
 171  *    Revision 1.24  2002/03/07 03:51:36  oes
 172  *     - Improved handling of failed DNS lookups
 173  *     - Fixed compiler warnings etc
 174  *
 175  *    Revision 1.23  2002/03/05 00:36:01  jongfoster
 176  *    Fixing bug 514988 - unable to restart Junkbuster
 177  *
 178  *    Revision 1.22  2002/03/04 02:08:02  david__schmidt
 179  *    Enable web editing of actions file on OS/2 (it had been broken all this time!)
 180  *
 181  *    Revision 1.21  2002/01/09 14:32:33  oes
 182  *    Added support for gethostbyname_r and gethostbyaddr_r.
 183  *
 184  *    Revision 1.20  2001/11/16 00:48:48  jongfoster
 185  *    Enabling duplicate-socket detection for all platforms, not
 186  *    just Win32.
 187  *
 188  *    Revision 1.19  2001/10/25 03:40:47  david__schmidt
 189  *    Change in porting tactics: OS/2's EMX porting layer doesn't allow multiple
 190  *    threads to call select() simultaneously.  So, it's time to do a real, live,
 191  *    native OS/2 port.  See defines for __EMX__ (the porting layer) vs. __OS2__
 192  *    (native). Both versions will work, but using __OS2__ offers multi-threading.
 193  *
 194  *    Revision 1.18  2001/09/21 23:02:02  david__schmidt
 195  *    Cleaning up 2 compiler warnings on OS/2.
 196  *
 197  *    Revision 1.17  2001/09/13 20:11:46  jongfoster
 198  *    Fixing 2 compiler warnings under Win32
 199  *
 200  *    Revision 1.16  2001/07/30 22:08:36  jongfoster
 201  *    Tidying up #defines:
 202  *    - All feature #defines are now of the form FEATURE_xxx
 203  *    - Permanently turned off WIN_GUI_EDIT
 204  *    - Permanently turned on WEBDAV and SPLIT_PROXY_ARGS
 205  *
 206  *    Revision 1.15  2001/07/29 17:40:43  jongfoster
 207  *    Fixed compiler warning by adding a cast
 208  *
 209  *    Revision 1.14  2001/07/18 13:47:59  oes
 210  *    Eliminated dirty hack for getsockbyname()
 211  *
 212  *    Revision 1.13  2001/07/15 13:56:57  jongfoster
 213  *    Removing unused local variable.
 214  *
 215  *    Revision 1.12  2001/07/01 17:04:11  oes
 216  *    Bugfix: accept_connection no longer uses the obsolete hstrerror() function
 217  *
 218  *    Revision 1.11  2001/06/29 21:45:41  oes
 219  *    Indentation, CRLF->LF, Tab-> Space
 220  *
 221  *    Revision 1.10  2001/06/29 13:29:15  oes
 222  *    - Added remote (server) host IP to csp->http->host_ip_addr_str
 223  *    - Added detection of local socket IP and fqdn
 224  *    - Removed logentry from cancelled commit
 225  *
 226  *    Revision 1.9  2001/06/07 23:06:09  jongfoster
 227  *    The host parameter to connect_to() is now const.
 228  *
 229  *    Revision 1.8  2001/06/03 19:12:07  oes
 230  *    filled comment
 231  *
 232  *    Revision 1.7  2001/05/28 16:14:00  jongfoster
 233  *    Fixing bug in LOG_LEVEL_LOG
 234  *
 235  *    Revision 1.6  2001/05/26 17:28:32  jongfoster
 236  *    Fixed LOG_LEVEL_LOG
 237  *
 238  *    Revision 1.5  2001/05/26 15:26:15  jongfoster
 239  *    ACL feature now provides more security by immediately dropping
 240  *    connections from untrusted hosts.
 241  *
 242  *    Revision 1.4  2001/05/26 00:37:42  jongfoster
 243  *    Cosmetic indentation correction.
 244  *
 245  *    Revision 1.3  2001/05/25 21:57:54  jongfoster
 246  *    Now gives a warning under Windows if you try to bind
 247  *    it to a port that's already in use.
 248  *
 249  *    Revision 1.2  2001/05/17 23:01:01  oes
 250  *     - Cleaned CRLF's from the sources and related files
 251  *
 252  *    Revision 1.1.1.1  2001/05/15 13:58:54  oes
 253  *    Initial import of version 2.9.3 source tree
 254  *
 255  *
 256  *********************************************************************/
 257 \f
 258
 259 #include "config.h"
 260
 261 #include <stdlib.h>
 262 #include <stdio.h>
 263 #include <string.h>
 264 #include <errno.h>
 265 #include <fcntl.h>
 266 #include <sys/types.h>
 267
 268 #ifdef _WIN32
 269
 270 #ifndef STRICT
 271 #define STRICT
 272 #endif
 273 #include <windows.h>
 274 #include <sys/timeb.h>
 275 #include <io.h>
 276
 277 #else
 278
 279 #ifndef __OS2__
 280 #include <unistd.h>
 281 #endif
 282 #include <sys/time.h>
 283 #include <netinet/in.h>
 284 #include <sys/ioctl.h>
 285 #include <netdb.h>
 286 #include <sys/socket.h>
 287
 288 #ifndef __BEOS__
 289 #include <netinet/tcp.h>
 290 #ifndef __OS2__
 291 #include <arpa/inet.h>
 292 #endif
 293 #else
 294 #include <socket.h>
 295 #endif
 296
 297 #if defined(__EMX__) || defined (__OS2__)
 298 #include <sys/select.h>  /* OS/2/EMX needs a little help with select */
 299 #ifdef __OS2__
 300 #include <nerrno.h>
 301 #endif
 302 #endif
 303
 304 #endif
 305
 306 #include "project.h"
 307
 308 #ifdef FEATURE_PTHREAD
 309 #include "jcc.h"
 310 /* jcc.h is for mutex semaphores only */
 311 #endif /* def FEATURE_PTHREAD */
 312
 313 #include "jbsockets.h"
 314 #include "filters.h"
 315 #include "errlog.h"
 316
 317 const char jbsockets_h_rcs[] = JBSOCKETS_H_VERSION;
 318
 319 /*
 320  * Maximum number of gethostbyname(_r) retries in case of
 321  * soft errors (TRY_AGAIN).
 322  * XXX: Does it make sense to make this a config option?
 323  */
 324 #define MAX_DNS_RETRIES 10
 325
 326 #define MAX_LISTEN_BACKLOG 128
 327
 328
 329 /*********************************************************************
 330  *
 331  * Function    :  connect_to
 332  *
 333  * Description :  Open a socket and connect to it.  Will check
 334  *                that this is allowed according to ACL.
 335  *
 336  * Parameters  :
 337  *          1  :  host = hostname to connect to
 338  *          2  :  portnum = port to connent on
 339  *          3  :  csp = Current client state (buffers, headers, etc...)
 340  *                      Not modified, only used for source IP and ACL.
 341  *
 342  * Returns     :  JB_INVALID_SOCKET => failure, else it is the socket
 343  *                file descriptor.
 344  *
 345  *********************************************************************/
 346 jb_socket connect_to(const char *host, int portnum, struct client_state *csp)
 347 {
 348    struct sockaddr_in inaddr;
 349    jb_socket fd;
 350    int addr;
 351    fd_set wfds;
 352    struct timeval tv[1];
 353 #if !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA)
 354    int   flags;
 355 #endif /* !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA) */
 356
 357 #ifdef FEATURE_ACL
 358    struct access_control_addr dst[1];
 359 #endif /* def FEATURE_ACL */
 360
 361    memset((char *)&inaddr, 0, sizeof inaddr);
 362
 363    if ((addr = resolve_hostname_to_ip(host)) == INADDR_NONE)
 364    {
 365       csp->http->host_ip_addr_str = strdup("unknown");
 366       return(JB_INVALID_SOCKET);
 367    }
 368
 369 #ifdef FEATURE_ACL
 370    dst->addr = ntohl((unsigned long) addr);
 371    dst->port = portnum;
 372
 373    if (block_acl(dst, csp))
 374    {
 375 #ifdef __OS2__
 376       errno = SOCEPERM;
 377 #else
 378       errno = EPERM;
 379 #endif
 380       return(JB_INVALID_SOCKET);
 381    }
 382 #endif /* def FEATURE_ACL */
 383
 384    inaddr.sin_addr.s_addr = addr;
 385    inaddr.sin_family      = AF_INET;
 386    csp->http->host_ip_addr_str = strdup(inet_ntoa(inaddr.sin_addr));
 387
 388 #ifndef _WIN32
 389    if (sizeof(inaddr.sin_port) == sizeof(short))
 390 #endif /* ndef _WIN32 */
 391    {
 392       inaddr.sin_port = htons((unsigned short) portnum);
 393    }
 394 #ifndef _WIN32
 395    else
 396    {
 397       inaddr.sin_port = htonl((unsigned long)portnum);
 398    }
 399 #endif /* ndef _WIN32 */
 400
 401 #ifdef _WIN32
 402    if ((fd = socket(inaddr.sin_family, SOCK_STREAM, 0)) == JB_INVALID_SOCKET)
 403 #else
 404    if ((fd = socket(inaddr.sin_family, SOCK_STREAM, 0)) < 0)
 405 #endif
 406    {
 407       return(JB_INVALID_SOCKET);
 408    }
 409
 410 #ifdef TCP_NODELAY
 411    {  /* turn off TCP coalescence */
 412       int mi = 1;
 413       setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *) &mi, sizeof (int));
 414    }
 415 #endif /* def TCP_NODELAY */
 416
 417 #if !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA) && !defined(__OS2__)
 418    if ((flags = fcntl(fd, F_GETFL, 0)) != -1)
 419    {
 420       flags |= O_NDELAY;
 421       fcntl(fd, F_SETFL, flags);
 422    }
 423 #endif /* !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA) && !defined(__OS2__) */
 424
 425    while (connect(fd, (struct sockaddr *) & inaddr, sizeof inaddr) == JB_INVALID_SOCKET)
 426    {
 427 #ifdef _WIN32
 428       if (errno == WSAEINPROGRESS)
 429 #elif __OS2__
 430       if (sock_errno() == EINPROGRESS)
 431 #else /* ifndef _WIN32 */
 432       if (errno == EINPROGRESS)
 433 #endif /* ndef _WIN32 || __OS2__ */
 434       {
 435          break;
 436       }
 437
 438 #ifdef __OS2__
 439       if (sock_errno() != EINTR)
 440 #else
 441       if (errno != EINTR)
 442 #endif /* __OS2__ */
 443       {
 444          close_socket(fd);
 445          return(JB_INVALID_SOCKET);
 446       }
 447    }
 448
 449 #if !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA) && !defined(__OS2__)
 450    if (flags != -1)
 451    {
 452       flags &= ~O_NDELAY;
 453       fcntl(fd, F_SETFL, flags);
 454    }
 455 #endif /* !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA) && !defined(__OS2__) */
 456
 457    /* wait for connection to complete */
 458    FD_ZERO(&wfds);
 459    FD_SET(fd, &wfds);
 460
 461    tv->tv_sec  = 30;
 462    tv->tv_usec = 0;
 463
 464    /* MS Windows uses int, not SOCKET, for the 1st arg of select(). Wierd! */
 465    if (select((int)fd + 1, NULL, &wfds, NULL, tv) <= 0)
 466    {
 467       close_socket(fd);
 468       return(JB_INVALID_SOCKET);
 469    }
 470    return(fd);
 471
 472 }
 473
 474
 475 /*********************************************************************
 476  *
 477  * Function    :  write_socket
 478  *
 479  * Description :  Write the contents of buf (for n bytes) to socket fd.
 480  *
 481  * Parameters  :
 482  *          1  :  fd = file descriptor (aka. handle) of socket to write to.
 483  *          2  :  buf = pointer to data to be written.
 484  *          3  :  len = length of data to be written to the socket "fd".
 485  *
 486  * Returns     :  0 on success (entire buffer sent).
 487  *                nonzero on error.
 488  *
 489  *********************************************************************/
 490 #ifdef AMIGA
 491 int write_socket(jb_socket fd, const char *buf, ssize_t len)
 492 #else
 493 int write_socket(jb_socket fd, const char *buf, size_t len)
 494 #endif
 495 {
 496    if (len == 0)
 497    {
 498       return 0;
 499    }
 500
 501    if (len < 0) /* constant condition - size_t isn't ever negative */
 502    {
 503       return 1;
 504    }
 505
 506    log_error(LOG_LEVEL_LOG, "%N", len, buf);
 507
 508 #if defined(_WIN32)
 509    return (send(fd, buf, (int)len, 0) != (int)len);
 510 #elif defined(__BEOS__) || defined(AMIGA)
 511    return (send(fd, buf, len, 0) != len);
 512 #elif defined(__OS2__)
 513    /*
 514     * Break the data up into SOCKET_SEND_MAX chunks for sending...
 515     * OS/2 seemed to complain when the chunks were too large.
 516     */
 517 #define SOCKET_SEND_MAX 65000
 518    {
 519       int write_len = 0, send_len, send_rc = 0, i = 0;
 520       while ((i < len) && (send_rc != -1))
 521       {
 522          if ((i + SOCKET_SEND_MAX) > len)
 523             send_len = len - i;
 524          else
 525             send_len = SOCKET_SEND_MAX;
 526          send_rc = send(fd,(char*)buf + i, send_len, 0);
 527          if (send_rc == -1)
 528             return 1;
 529          i = i + send_len;
 530       }
 531       return 0;
 532    }
 533 #else
 534    return (write(fd, buf, len) != len);
 535 #endif
 536
 537 }
 538
 539
 540 /*********************************************************************
 541  *
 542  * Function    :  read_socket
 543  *
 544  * Description :  Read from a TCP/IP socket in a platform independent way.
 545  *
 546  * Parameters  :
 547  *          1  :  fd = file descriptor of the socket to read
 548  *          2  :  buf = pointer to buffer where data will be written
 549  *                Must be >= len bytes long.
 550  *          3  :  len = maximum number of bytes to read
 551  *
 552  * Returns     :  On success, the number of bytes read is returned (zero
 553  *                indicates end of file), and the file position is advanced
 554  *                by this number.  It is not an error if this number is
 555  *                smaller than the number of bytes requested; this may hap-
 556  *                pen for example because fewer bytes are actually available
 557  *                right now (maybe because we were close to end-of-file, or
 558  *                because we are reading from a pipe, or from a terminal,
 559  *                or because read() was interrupted by a signal).  On error,
 560  *                -1 is returned, and errno is set appropriately.  In this
 561  *                case it is left unspecified whether the file position (if
 562  *                any) changes.
 563  *
 564  *********************************************************************/
 565 int read_socket(jb_socket fd, char *buf, int len)
 566 {
 567    if (len <= 0)
 568    {
 569       return(0);
 570    }
 571
 572 #if defined(_WIN32)
 573    return(recv(fd, buf, len, 0));
 574 #elif defined(__BEOS__) || defined(AMIGA) || defined(__OS2__)
 575    return(recv(fd, buf, (size_t)len, 0));
 576 #else
 577    return(read(fd, buf, (size_t)len));
 578 #endif
 579 }
 580
 581
 582 /*********************************************************************
 583  *
 584  * Function    :  close_socket
 585  *
 586  * Description :  Closes a TCP/IP socket
 587  *
 588  * Parameters  :
 589  *          1  :  fd = file descriptor of socket to be closed
 590  *
 591  * Returns     :  void
 592  *
 593  *********************************************************************/
 594 void close_socket(jb_socket fd)
 595 {
 596 #if defined(_WIN32) || defined(__BEOS__)
 597    closesocket(fd);
 598 #elif defined(AMIGA)
 599    CloseSocket(fd);
 600 #elif defined(__OS2__)
 601    soclose(fd);
 602 #else
 603    close(fd);
 604 #endif
 605
 606 }
 607
 608
 609 /*********************************************************************
 610  *
 611  * Function    :  bind_port
 612  *
 613  * Description :  Call socket, set socket options, and listen.
 614  *                Called by listen_loop to "boot up" our proxy address.
 615  *
 616  * Parameters  :
 617  *          1  :  hostnam = TCP/IP address to bind/listen to
 618  *          2  :  portnum = port to listen on
 619  *          3  :  pfd = pointer used to return file descriptor.
 620  *
 621  * Returns     :  if success, returns 0 and sets *pfd.
 622  *                if failure, returns -3 if address is in use,
 623  *                                    -2 if address unresolvable,
 624  *                                    -1 otherwise
 625  *********************************************************************/
 626 int bind_port(const char *hostnam, int portnum, jb_socket *pfd)
 627 {
 628    struct sockaddr_in inaddr;
 629    jb_socket fd;
 630 #ifndef _WIN32
 631    int one = 1;
 632 #endif /* ndef _WIN32 */
 633
 634    *pfd = JB_INVALID_SOCKET;
 635
 636    memset((char *)&inaddr, '\0', sizeof inaddr);
 637
 638    inaddr.sin_family      = AF_INET;
 639    inaddr.sin_addr.s_addr = resolve_hostname_to_ip(hostnam);
 640
 641    if (inaddr.sin_addr.s_addr == INADDR_NONE)
 642    {
 643       return(-2);
 644    }
 645
 646 #ifndef _WIN32
 647    if (sizeof(inaddr.sin_port) == sizeof(short))
 648 #endif /* ndef _WIN32 */
 649    {
 650       inaddr.sin_port = htons((unsigned short) portnum);
 651    }
 652 #ifndef _WIN32
 653    else
 654    {
 655       inaddr.sin_port = htonl((unsigned long) portnum);
 656    }
 657 #endif /* ndef _WIN32 */
 658
 659    fd = socket(AF_INET, SOCK_STREAM, 0);
 660
 661 #ifdef _WIN32
 662    if (fd == JB_INVALID_SOCKET)
 663 #else
 664    if (fd < 0)
 665 #endif
 666    {
 667       return(-1);
 668    }
 669
 670 #ifndef _WIN32
 671    /*
 672     * This is not needed for Win32 - in fact, it stops
 673     * duplicate instances of Privoxy from being caught.
 674     *
 675     * On UNIX, we assume the user is sensible enough not
 676     * to start Privoxy multiple times on the same IP.
 677     * Without this, stopping and restarting Privoxy
 678     * from a script fails.
 679     * Note: SO_REUSEADDR is meant to only take over
 680     * sockets which are *not* in listen state in Linux,
 681     * e.g. sockets in TIME_WAIT. YMMV.
 682     */
 683    setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *)&one, sizeof(one));
 684 #endif /* ndef _WIN32 */
 685
 686    if (bind(fd, (struct sockaddr *)&inaddr, sizeof(inaddr)) < 0)
 687    {
 688 #ifdef _WIN32
 689       errno = WSAGetLastError();
 690       if (errno == WSAEADDRINUSE)
 691 #else
 692       if (errno == EADDRINUSE)
 693 #endif
 694       {
 695          close_socket(fd);
 696          return(-3);
 697       }
 698       else
 699       {
 700          close_socket(fd);
 701          return(-1);
 702       }
 703    }
 704
 705    while (listen(fd, MAX_LISTEN_BACKLOG) == -1)
 706    {
 707       if (errno != EINTR)
 708       {
 709          return(-1);
 710       }
 711    }
 712
 713    *pfd = fd;
 714    return 0;
 715
 716 }
 717
 718
 719 /*********************************************************************
 720  *
 721  * Function    :  get_host_information
 722  *
 723  * Description :  Determines the IP address the client used to
 724  *                reach us and the hostname associated with it.
 725  *
 726  *                XXX: Most of the code has been copy and pasted
 727  *                from accept_connection() and not all of the
 728  *                ifdefs paths have been tested afterwards.
 729  *
 730  * Parameters  :
 731  *          1  :  afd = File descriptor returned from accept().
 732  *          2  :  ip_address = Pointer to return the pointer to
 733  *                             the ip address string.
 734  *          3  :  hostname =   Pointer to return the pointer to
 735  *                             the hostname or NULL if the caller
 736  *                             isn't interested in it.
 737  *
 738  * Returns     :  void.
 739  *
 740  *********************************************************************/
 741 void get_host_information(jb_socket afd, char **ip_address, char **hostname)
 742 {
 743    struct sockaddr_in server;
 744    struct hostent *host = NULL;
 745 #if defined(_WIN32) || defined(__OS2__) || defined(__APPLE_CC__) || defined(AMIGA)
 746    /* according to accept_connection() this fixes a warning. */
 747    int s_length;
 748 #else
 749    socklen_t s_length;
 750 #endif
 751 #if defined(HAVE_GETHOSTBYADDR_R_8_ARGS) ||  defined(HAVE_GETHOSTBYADDR_R_7_ARGS) || defined(HAVE_GETHOSTBYADDR_R_5_ARGS)
 752    struct hostent result;
 753 #if defined(HAVE_GETHOSTBYADDR_R_5_ARGS)
 754    struct hostent_data hdata;
 755 #else
 756    char hbuf[HOSTENT_BUFFER_SIZE];
 757    int thd_err;
 758 #endif /* def HAVE_GETHOSTBYADDR_R_5_ARGS */
 759 #endif /* def HAVE_GETHOSTBYADDR_R_(8|7|5)_ARGS */
 760    s_length = sizeof(server);
 761
 762    if (NULL != hostname)
 763    {
 764       *hostname = NULL;
 765    }
 766    *ip_address = NULL;
 767
 768    if (!getsockname(afd, (struct sockaddr *) &server, &s_length))
 769    {
 770       *ip_address = strdup(inet_ntoa(server.sin_addr));
 771
 772       if (NULL == hostname)
 773       {
 774          /*
 775           * We're done here, the caller isn't
 776           * interested in knowing the hostname.
 777           */
 778          return;
 779       }
 780 #if defined(HAVE_GETHOSTBYADDR_R_8_ARGS)
 781       gethostbyaddr_r((const char *)&server.sin_addr,
 782                       sizeof(server.sin_addr), AF_INET,
 783                       &result, hbuf, HOSTENT_BUFFER_SIZE,
 784                       &host, &thd_err);
 785 #elif defined(HAVE_GETHOSTBYADDR_R_7_ARGS)
 786       host = gethostbyaddr_r((const char *)&server.sin_addr,
 787                       sizeof(server.sin_addr), AF_INET,
 788                       &result, hbuf, HOSTENT_BUFFER_SIZE, &thd_err);
 789 #elif defined(HAVE_GETHOSTBYADDR_R_5_ARGS)
 790       if (0 == gethostbyaddr_r((const char *)&server.sin_addr,
 791                                sizeof(server.sin_addr), AF_INET,
 792                                &result, &hdata))
 793       {
 794          host = &result;
 795       }
 796       else
 797       {
 798          host = NULL;
 799       }
 800 #elif FEATURE_PTHREAD
 801       privoxy_mutex_lock(&resolver_mutex);
 802       host = gethostbyaddr((const char *)&server.sin_addr,
 803                            sizeof(server.sin_addr), AF_INET);
 804       privoxy_mutex_unlock(&resolver_mutex);
 805 #else
 806       host = gethostbyaddr((const char *)&server.sin_addr,
 807                            sizeof(server.sin_addr), AF_INET);
 808 #endif
 809       if (host == NULL)
 810       {
 811          log_error(LOG_LEVEL_ERROR, "Unable to get my own hostname: %E\n");
 812       }
 813       else
 814       {
 815          *hostname = strdup(host->h_name);
 816       }
 817    }
 818
 819    return;
 820 }
 821
 822
 823 /*********************************************************************
 824  *
 825  * Function    :  accept_connection
 826  *
 827  * Description :  Accepts a connection on a socket.  Socket must have
 828  *                been created using bind_port().
 829  *
 830  * Parameters  :
 831  *          1  :  csp = Client state, cfd, ip_addr_str, and
 832  *                ip_addr_long will be set by this routine.
 833  *          2  :  fd  = file descriptor returned from bind_port
 834  *
 835  * Returns     :  when a connection is accepted, it returns 1 (TRUE).
 836  *                On an error it returns 0 (FALSE).
 837  *
 838  *********************************************************************/
 839 int accept_connection(struct client_state * csp, jb_socket fd)
 840 {
 841    struct sockaddr_in client;
 842    jb_socket afd;
 843 #if defined(_WIN32) || defined(__OS2__) || defined(__APPLE_CC__) || defined(AMIGA)
 844    /* Wierdness - fix a warning. */
 845    int c_length;
 846 #else
 847    socklen_t c_length;
 848 #endif
 849
 850    c_length = sizeof(client);
 851
 852 #ifdef _WIN32
 853    afd = accept (fd, (struct sockaddr *) &client, &c_length);
 854    if (afd == JB_INVALID_SOCKET)
 855    {
 856       return 0;
 857    }
 858 #else
 859    do
 860    {
 861       afd = accept (fd, (struct sockaddr *) &client, &c_length);
 862    } while (afd < 1 && errno == EINTR);
 863    if (afd < 0)
 864    {
 865       return 0;
 866    }
 867 #endif
 868
 869    csp->cfd = afd;
 870    csp->ip_addr_str  = strdup(inet_ntoa(client.sin_addr));
 871    csp->ip_addr_long = ntohl(client.sin_addr.s_addr);
 872
 873    return 1;
 874
 875 }
 876
 877
 878 /*********************************************************************
 879  *
 880  * Function    :  resolve_hostname_to_ip
 881  *
 882  * Description :  Resolve a hostname to an internet tcp/ip address.
 883  *                NULL or an empty string resolve to INADDR_ANY.
 884  *
 885  * Parameters  :
 886  *          1  :  host = hostname to resolve
 887  *
 888  * Returns     :  INADDR_NONE => failure, INADDR_ANY or tcp/ip address if succesful.
 889  *
 890  *********************************************************************/
 891 unsigned long resolve_hostname_to_ip(const char *host)
 892 {
 893    struct sockaddr_in inaddr;
 894    struct hostent *hostp;
 895    unsigned int dns_retries = 0;
 896 #if defined(HAVE_GETHOSTBYNAME_R_6_ARGS) || defined(HAVE_GETHOSTBYNAME_R_5_ARGS) || defined(HAVE_GETHOSTBYNAME_R_3_ARGS)
 897    struct hostent result;
 898 #if defined(HAVE_GETHOSTBYNAME_R_6_ARGS) || defined(HAVE_GETHOSTBYNAME_R_5_ARGS)
 899    char hbuf[HOSTENT_BUFFER_SIZE];
 900    int thd_err;
 901 #else /* defined(HAVE_GETHOSTBYNAME_R_3_ARGS) */
 902    struct hostent_data hdata;
 903 #endif /* def HAVE_GETHOSTBYNAME_R_(6|5)_ARGS */
 904 #endif /* def HAVE_GETHOSTBYNAME_R_(6|5|3)_ARGS */
 905
 906    if ((host == NULL) || (*host == '\0'))
 907    {
 908       return(INADDR_ANY);
 909    }
 910
 911    memset((char *) &inaddr, 0, sizeof inaddr);
 912
 913    if ((inaddr.sin_addr.s_addr = inet_addr(host)) == -1)
 914    {
 915 #if defined(HAVE_GETHOSTBYNAME_R_6_ARGS)
 916       while (gethostbyname_r(host, &result, hbuf,
 917                 HOSTENT_BUFFER_SIZE, &hostp, &thd_err)
 918              && (thd_err == TRY_AGAIN) && (dns_retries++ < MAX_DNS_RETRIES))
 919       {
 920          log_error(LOG_LEVEL_ERROR,
 921             "Timeout #%u while trying to resolve %s. Trying again.",
 922             dns_retries, host);
 923       }
 924 #elif defined(HAVE_GETHOSTBYNAME_R_5_ARGS)
 925       while (NULL == (hostp = gethostbyname_r(host, &result,
 926                                  hbuf, HOSTENT_BUFFER_SIZE, &thd_err))
 927              && (thd_err == TRY_AGAIN) && (dns_retries++ < MAX_DNS_RETRIES))
 928       {
 929          log_error(LOG_LEVEL_ERROR,
 930             "Timeout #%u while trying to resolve %s. Trying again.",
 931             dns_retries, host);
 932       }
 933 #elif defined(HAVE_GETHOSTBYNAME_R_3_ARGS)
 934       /*
 935        * XXX: Doesn't retry in case of soft errors.
 936        * Does this gethostbyname_r version set h_errno?
 937        */
 938       if (0 == gethostbyname_r(host, &result, &hdata))
 939       {
 940          hostp = &result;
 941       }
 942       else
 943       {
 944          hostp = NULL;
 945       }
 946 #elif FEATURE_PTHREAD
 947       privoxy_mutex_lock(&resolver_mutex);
 948       while (NULL == (hostp = gethostbyname(host))
 949              && (h_errno == TRY_AGAIN) && (dns_retries++ < MAX_DNS_RETRIES))
 950       {
 951          log_error(LOG_LEVEL_ERROR,
 952             "Timeout #%u while trying to resolve %s. Trying again.",
 953             dns_retries, host);
 954       }
 955       privoxy_mutex_unlock(&resolver_mutex);
 956 #else
 957       while (NULL == (hostp = gethostbyname(host))
 958              && (h_errno == TRY_AGAIN) && (dns_retries++ < MAX_DNS_RETRIES))
 959       {
 960          log_error(LOG_LEVEL_ERROR,
 961             "Timeout #%u while trying to resolve %s. Trying again.",
 962             dns_retries, host);
 963       }
 964 #endif /* def HAVE_GETHOSTBYNAME_R_(6|5|3)_ARGS */
 965       /*
 966        * On Mac OSX, if a domain exists but doesn't have a type A
 967        * record associated with it, the h_addr member of the struct
 968        * hostent returned by gethostbyname is NULL, even if h_length
 969        * is 4. Therefore the second test below.
 970        */
 971       if (hostp == NULL || hostp->h_addr == NULL)
 972       {
 973          errno = EINVAL;
 974          log_error(LOG_LEVEL_ERROR, "could not resolve hostname %s", host);
 975          return(INADDR_NONE);
 976       }
 977       if (hostp->h_addrtype != AF_INET)
 978       {
 979 #ifdef _WIN32
 980          errno = WSAEPROTOTYPE;
 981 #else
 982          errno = EPROTOTYPE;
 983 #endif
 984          log_error(LOG_LEVEL_ERROR, "hostname %s resolves to unknown address type.", host);
 985          return(INADDR_NONE);
 986       }
 987       memcpy(
 988          (char *) &inaddr.sin_addr,
 989          (char *) hostp->h_addr,
 990          sizeof(inaddr.sin_addr)
 991       );
 992    }
 993    return(inaddr.sin_addr.s_addr);
 994
 995 }
 996
 997
 998 /*
 999   Local Variables:
1000   tab-width: 3
1001   end:
1002 */