Allow metrics.torproject.org
[privoxy.git] / jbsockets.c
1 const char jbsockets_rcs[] = "$Id: jbsockets.c,v 1.71 2009/12/16 08:35:47 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_usable
1213  *
1214  * Description :  Decides whether or not an open socket is still usable.
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_usable(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 */