debian/patches/03_ipv6.dpatch

   1 #! /bin/sh /usr/share/dpatch/dpatch-run
   2 ## 03_ipv6.dpatch by Lionel Elie Mamane <lionel@mamane.lu>
   3 ##
   4 ## All lines beginning with `## DP:' are a description of the patch.
   5 ## DP: privoxy_CVS_20030523_ipv6_5.patch.bz2 from
   6 ## DP: ftp://ftp.deepspace6.net/pub/ds6/sources/privoxy/privoxy_CVS_20030523_ipv6_5.patch.bz2
   7 ## DP: adapted to the 3.0 branch of privoxy by Roland Rosenfeld
   8 ## DP: adapted to 3.0.4 by higuita, but i'm no programmer, so i hope i
   9 ## DP: didnt broke anything :)
  10 ## DP: adapted to 3.0.6 by Petr Písa?? petrp@users.sf.net found on
  11 ## DP: http://xpisar.wz.cz/privoxy-ipv6/ Use privoxy-3.0.6-stable-ipv6.diff.bz2
  12 ## DP: and stripped
  13
  14 @DPATCH@
  15 diff -urNad privoxy~/GNUmakefile.in privoxy/GNUmakefile.in
  16 --- privoxy~/GNUmakefile.in
  17 +++ privoxy/GNUmakefile.in
  18 @@ -187,7 +187,7 @@
  19  C_SRC  = actions.c cgi.c cgiedit.c cgisimple.c deanimate.c encode.c \
  20           errlog.c filters.c gateway.c jbsockets.c jcc.c killpopup.c \
  21           list.c loadcfg.c loaders.c miscutil.c parsers.c ssplit.c \
  22 -         urlmatch.c
  23 +         urlmatch.c addrlist.c jb_socket_set.c
  24
  25  C_OBJS = $(C_SRC:.c=.@OBJEXT@)
  26  C_HDRS = $(C_SRC:.c=.h) project.h actionlist.h
  27 @@ -241,7 +241,7 @@
  28  SPECIAL_CFLAGS = @SPECIAL_CFLAGS@
  29
  30  # Add your flags here
  31 -OTHER_CFLAGS =
  32 +OTHER_CFLAGS = -DINET6
  33
  34  CFLAGS = @CFLAGS@ @CPPFLAGS@ $(OTHER_CFLAGS) $(SPECIAL_CFLAGS) -Wall \
  35           @STATIC_PCRE_ONLY@ -Ipcre
  36 diff -urNad privoxy~/addrlist.c privoxy/addrlist.c
  37 --- privoxy~/addrlist.c
  38 +++ privoxy/addrlist.c
  39 @@ -0,0 +1,198 @@
  40 +const char addrlist_rcs[] = "$Id: $";
  41 +/*********************************************************************
  42 + *
  43 + * File        :  $Source: $
  44 + *
  45 + * Purpose     :  Declares functions to handle lists of network addresses.
  46 + *                Functions declared include:
  47 + *                   `destroy_addr_list', head_addr_list and `tail_addr_list'
  48 + *
  49 + * Copyright   :  Written by and Copyright (C) 2002 Lionel Elie Mamane
  50 + *                <lionel@mamane.lu>
  51 + *
  52 + *                This program is free software; you can redistribute it
  53 + *                and/or modify it under the terms of the GNU General
  54 + *                Public License as published by the Free Software
  55 + *                Foundation; either version 2 of the License, or (at
  56 + *                your option) any later version.
  57 + *
  58 + *                This program is distributed in the hope that it will
  59 + *                be useful, but WITHOUT ANY WARRANTY; without even the
  60 + *                implied warranty of MERCHANTABILITY or FITNESS FOR A
  61 + *                PARTICULAR PURPOSE.  See the GNU General Public
  62 + *                License for more details.
  63 + *
  64 + *                The GNU General Public License should be included with
  65 + *                this file.  If not, you can view it at
  66 + *                http://www.gnu.org/copyleft/gpl.html
  67 + *                or write to the Free Software Foundation, Inc., 59
  68 + *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  69 + *
  70 + * Revisions   :
  71 + *    $Log: addrlist.c,v $
  72 + *
  73 + *********************************************************************/
  74 +
  75 +#include "addrlist.h"
  76 +#include <sys/types.h>
  77 +#include <sys/socket.h>
  78 +#include <netdb.h>
  79 +#include <string.h>
  80 +
  81 +/*********************************************************************
  82 + *
  83 + * Function    :  acceptable
  84 + *
  85 + * Description :  Test wheter an address is acceptable for our use
  86 + *                Currently, this means either an IPv4 or an IPv6 address
  87 + *
  88 + * Parameters  :
  89 + *          0  :  addr = the address to test
  90 + *
  91 + * Returns     :  0             = false / no
  92 + *                anything else = true / yes
  93 + *
  94 + *********************************************************************/
  95 +static int acceptable (struct sockaddr_storage *addr)
  96 +{
  97 +   switch(addr->ss_family)
  98 +   {
  99 +   case AF_INET:
 100 +#ifdef INET6
 101 +   case AF_INET6:
 102 +#endif
 103 +      return !0;
 104 +   default:
 105 +      return 0;
 106 +   }
 107 +}
 108 +
 109 +/*********************************************************************
 110 + *
 111 + * Function    :  skim
 112 + *
 113 + * Description :  Get the first acceptable address in head position
 114 + *                Assumes there is one
 115 + *
 116 + * Parameters  :
 117 + *          0  :  l = the list to skim
 118 + *
 119 + * Returns     :  the skimmed list
 120 + *
 121 + *********************************************************************/
 122 +static addr_list *skim (addr_list *l)
 123 +{
 124 +   if (acceptable((struct sockaddr_storage*)l->ai_addr))
 125 +      return l;
 126 +   return skim(l->ai_next);
 127 +}
 128 +
 129 +/*********************************************************************
 130 + *
 131 + * Function    :  tail_addr_list
 132 + *
 133 + * Description :  Get the tail of an address list
 134 + *
 135 + * Parameters  :
 136 + *          0  :  l = the list to get the tail of
 137 + *
 138 + * Returns     :  the tail of the list
 139 + *                If the list has no tail (i.e. is nil), unspecified
 140 + *                behaviour
 141 + *
 142 + *********************************************************************/
 143 +addr_list *tail_addr_list(addr_list *l)
 144 +{
 145 +   return skim(l)->ai_next;
 146 +}
 147 +
 148 +/*********************************************************************
 149 + *
 150 + * Function    :  head_addr_list
 151 + *
 152 + * Description :  Get the head of an address list
 153 + *
 154 + * Parameters  :
 155 + *          0  :  l = the list to get the head of
 156 + *
 157 + * Returns     :  the head of the list
 158 + *                If the list has no head (i.e. is nil), unspecified
 159 + *                behaviour
 160 + *
 161 + *********************************************************************/
 162 +struct sockaddr_storage *head_addr_list(addr_list *l)
 163 +{
 164 +   return (struct sockaddr_storage *)skim(l)->ai_addr;
 165 +}
 166 +
 167 +/*********************************************************************
 168 + *
 169 + * Function    :  cpy_head_addr_list
 170 + *
 171 + * Description :  Copy the head of an address list to the given destination
 172 + *
 173 + * Parameters  :
 174 + *          0  :  l = the list to get the head of
 175 + *          1  :  r = where to put the result
 176 + *
 177 + * Returns     :  Nothing
 178 + *                If the list has no head (i.e. is nil), unspecified
 179 + *                behaviour
 180 + *
 181 + *********************************************************************/
 182 +void cpy_head_addr_list(addr_list *l, struct sockaddr_storage *r, size_t *addrlen)
 183 +{
 184 +   addr_list *sl = skim(l);
 185 +   memcpy(r, sl->ai_addr, sl->ai_addrlen);
 186 +   *addrlen = sl->ai_addrlen;
 187 +}
 188 +
 189 +/*********************************************************************
 190 + *
 191 + * Function    :  destroy_addr_list
 192 + *
 193 + * Description :  Unallocate memory allocated to an address list
 194 + *
 195 + * Parameters  :
 196 + *          0  :  l = the list to unallocate
 197 + *
 198 + * Returns     :  nothing
 199 + *
 200 + *********************************************************************/
 201 +void destroy_addr_list(addr_list *l)
 202 +{
 203 +   freeaddrinfo(l);
 204 +}
 205 +
 206 +/*********************************************************************
 207 + *
 208 + * Function    :  is_nil_addr_list
 209 + *
 210 + * Description :  Test wheter a list is nil (empty)
 211 + *
 212 + * Parameters  :
 213 + *          0  :  l = the list to test
 214 + *
 215 + * Returns     :  0             = false if list has a head,
 216 + *                anything else = true if list is nil
 217 + *
 218 + *********************************************************************/
 219 +int is_nil_addr_list(addr_list *l)
 220 +{
 221 +   /* We are searching for a witness of non-nilness (modulo acceptability)
 222 +    * If none is found, the list is nil
 223 +    */
 224 +   if (l==NULL)
 225 +      /* Empty list*/
 226 +      return !0;
 227 +   if (acceptable(head_addr_list(l)))
 228 +      /* Witness found */
 229 +      return 0;
 230 +   return is_nil_addr_list(l->ai_next);
 231 +}
 232 +
 233 +/*
 234 +  Local Variables:
 235 +  tab-width: 3
 236 +  end:
 237 +*/
 238 diff -urNad privoxy~/addrlist.h privoxy/addrlist.h
 239 --- privoxy~/addrlist.h
 240 +++ privoxy/addrlist.h
 241 @@ -0,0 +1,56 @@
 242 +#ifndef ADDR_LIST_H_INCLUDED
 243 +#define ADDR_LIST_H_INCLUDED
 244 +#define ADDR_LIST_H_VERSION "$Id: $"
 245 +/*********************************************************************
 246 + *
 247 + * File        :  $Source: $
 248 + *
 249 + * Purpose     :  Declares functions to handle lists of network addresses.
 250 + *                Functions declared include:
 251 + *                   `destroy_addr_list', head_addr_list and `tail_addr_list'
 252 + *
 253 + * Copyright   :  Written by and Copyright (C) 2002 Lionel Elie Mamane
 254 + *                <lionel@mamane.lu>
 255 + *
 256 + *                This program is free software; you can redistribute it
 257 + *                and/or modify it under the terms of the GNU General
 258 + *                Public License as published by the Free Software
 259 + *                Foundation; either version 2 of the License, or (at
 260 + *                your option) any later version.
 261 + *
 262 + *                This program is distributed in the hope that it will
 263 + *                be useful, but WITHOUT ANY WARRANTY; without even the
 264 + *                implied warranty of MERCHANTABILITY or FITNESS FOR A
 265 + *                PARTICULAR PURPOSE.  See the GNU General Public
 266 + *                License for more details.
 267 + *
 268 + *                The GNU General Public License should be included with
 269 + *                this file.  If not, you can view it at
 270 + *                http://www.gnu.org/copyleft/gpl.html
 271 + *                or write to the Free Software Foundation, Inc., 59
 272 + *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 273 + *
 274 + * Revisions   :
 275 + *    $Log: addrlist.h,v $
 276 + *
 277 + *********************************************************************/
 278 +
 279 +#include <sys/socket.h>
 280 +
 281 +typedef struct addrinfo addr_list;
 282 +
 283 +addr_list *tail_addr_list(addr_list *l);
 284 +struct sockaddr_storage *head_addr_list(addr_list *l);
 285 +void cpy_head_addr_list(addr_list *l, struct sockaddr_storage *r, size_t *addrlen);
 286 +void destroy_addr_list(addr_list *l);
 287 +int is_nil_addr_list(addr_list *l);
 288 +
 289 +#define freez_addr_list(X)  { if(X) { destroy_addr_list(X); X = NULL ; } }
 290 +
 291 +#endif /* ndef LIST_H_INCLUDED */
 292 +
 293 +/*
 294 +  Local Variables:
 295 +  tab-width: 3
 296 +  end:
 297 +*/
 298 diff -urNad privoxy~/cgi.c privoxy/cgi.c
 299 --- privoxy~/cgi.c
 300 +++ privoxy/cgi.c
 301 @@ -14,6 +14,9 @@
 302   * Copyright   :  Written by and Copyright (C) 2001 the SourceForge
 303   *                Privoxy team. http://www.privoxy.org/
 304   *
 305 + *                Modified by Lionel Elie Mamane <lionel@mamane.lu>
 306 + *                for IPv6 support on 8 December 2002, 24 January 2003.
 307 + *
 308   *                Based on the Internet Junkbuster originally written
 309   *                by and Copyright (C) 1997 Anonymous Coders and
 310   *                Junkbusters Corporation.  http://www.junkbusters.com
 311 @@ -2259,7 +2262,6 @@
 312   *********************************************************************/
 313  struct map *default_exports(const struct client_state *csp, const char *caller)
 314  {
 315 -   char buf[20];
 316     jb_err err;
 317     struct map * exports;
 318     int local_help_exists = 0;
 319 @@ -2295,8 +2297,7 @@
 320     if (!err) err = map_block_killer(exports, "can-toggle");
 321  #endif
 322
 323 -   snprintf(buf, 20, "%d", csp->config->hport);
 324 -   if (!err) err = map(exports, "my-port", 1, buf, 1);
 325 +   if (!err) err = map(exports, "my-port", 1, csp->my_port_str, 1);
 326
 327     if(!strcmp(CODE_STATUS, "stable"))
 328     {
 329 diff -urNad privoxy~/errlog.c privoxy/errlog.c
 330 --- privoxy~/errlog.c
 331 +++ privoxy/errlog.c
 332 @@ -746,6 +746,13 @@
 333              break;
 334           case 'E':
 335              /* Non-standard: Print error code from errno */
 336 +            /* TODO
 337 +             * This is not only not standard, but clashes
 338 +             * with the E modifier on the GNU (and possibly
 339 +             * other systems): It means double (floating point)
 340 +             * number in exponential notation, with capital E
 341 +             * for mantiss / exponenent separator
 342 +             */
 343  #ifdef _WIN32
 344              ival = WSAGetLastError();
 345              sval = w32_socket_strerr(ival, tempbuf);
 346 diff -urNad privoxy~/filters.c privoxy/filters.c
 347 --- privoxy~/filters.c
 348 +++ privoxy/filters.c
 349 @@ -15,6 +15,9 @@
 350   * Copyright   :  Written by and Copyright (C) 2001, 2004 the SourceForge
 351   *                Privoxy team. http://www.privoxy.org/
 352   *
 353 + *                Modified by Lionel Elie Mamane <lionel@mamane.lu>
 354 + *                for IPv6 support on 8 December 2002, 24 January 2003.
 355 + *
 356   *                Based on the Internet Junkbuster originally written
 357   *                by and Copyright (C) 1997 Anonymous Coders and
 358   *                Junkbusters Corporation.  http://www.junkbusters.com
 359 @@ -471,6 +474,9 @@
 360  #include <ctype.h>
 361  #include <string.h>
 362  #include <assert.h>
 363 +#ifdef INET6
 364 +#include <netdb.h>
 365 +#endif
 366
 367  #ifndef _WIN32
 368  #ifndef __OS2__
 369 @@ -505,17 +511,119 @@
 370
 371  const char filters_h_rcs[] = FILTERS_H_VERSION;
 372
 373 -/* Fix a problem with Solaris.  There should be no effect on other
 374 - * platforms.
 375 - * Solaris's isspace() is a macro which uses it's argument directly
 376 - * as an array index.  Therefore we need to make sure that high-bit
 377 - * characters generate +ve values, and ideally we also want to make
 378 - * the argument match the declared parameter type of "int".
 379 - */
 380 -#define ijb_isdigit(__X) isdigit((int)(unsigned char)(__X))
 381 +#ifdef FEATURE_ACL
 382 +/*********************************************************************
 383 + *
 384 + * Function    :  addr_equal_under_mask
 385 + *
 386 + * Description :  Are these addresses equal modulo this mask?
 387 + *                Assumes the second argument is already in
 388 + *                mask-normal form
 389 + *
 390 + * Parameters  :
 391 + *          0  :  addr1 = First address to compare
 392 + *          1  :  addr2 = Second address to compare
 393 + *                        MUST be in mask-normal form
 394 + *          2  :  mask = for IPv4 addresses, a bitmask
 395 + *                       for IPv6 addresses, a prefixlen in bits
 396 + *
 397 + * Returns     : 0 = FALSE (not equal) and non-zero = TRUE (equal)
 398 + *
 399 + *********************************************************************/
 400 +static
 401 +int
 402 +addr_equal_under_mask(struct sockaddr_storage *addr1, struct sockaddr_storage *addr2, unsigned long  mask)
 403 +{
 404 +   if (!mask)
 405 +       return 1;
 406
 407 +   /* only identical families can be compared */
 408 +   /* TODO: Should we code the special case of "IPv4 addresses as IPv6 addresses"? */
 409 +   if (addr1->ss_family != addr2-> ss_family)
 410 +     {
 411 +       /*fprintf(stderr, "equal_under_mask: diff sa_family: %d %d\n",
 412 +         sa1->sa_family, sa2-> sa_family); */
 413 +       return 0;
 414 +     }
 415 +
 416 +   switch (addr1->ss_family)
 417 +      {
 418 +      case AF_INET:
 419 +         {
 420 +            /* IPv4 - mask is a bitmask */
 421 +            struct sockaddr_in *sin1 = (struct sockaddr_in *)addr1;
 422 +            struct sockaddr_in *sin2 = (struct sockaddr_in *)addr2;
 423 +
 424 +            /*fprintf(stderr, "AF_INET: %08x %08x %08x\n",
 425 +              sin1->sin_addr.s_addr,
 426 +              sin2->sin_addr.s_addr,
 427 +              mask); */
 428 +            return (sin1->sin_addr.s_addr & mask) == sin2->sin_addr.s_addr;
 429 +         }
 430 +         break;
 431 +#ifdef INET6
 432 +      case AF_INET6:
 433 +         {
 434 +            /* IPv6 - mask is a prefixlength in bits. */
 435 +            struct sockaddr_in6 *sin1 = (struct sockaddr_in6 *)addr1;
 436 +            struct sockaddr_in6 *sin2 = (struct sockaddr_in6 *)addr2;
 437 +            char bitmask;
 438 +            char *a1, *a2;
 439 +            const int maskbytes = mask / 8;
 440 +            static char m[] = { 0x00, 0x80, 0xC0, 0xE0,
 441 +                                0xF0, 0xF8, 0xFC, 0xFE };
 442 +/*             { */
 443 +/*                int i; */
 444 +/*                fprintf(stderr, "PF_INET6: "); */
 445 +/*                for (i = 0; i < 16; i++) { */
 446 +/*                   fprintf(stderr, "%02x ", sin1->sin6_addr.s6_addr[i]); */
 447 +/*                } */
 448 +/*                fprintf(stderr, "   "); */
 449 +/*                for (i = 0; i < 16; i++) { */
 450 +/*                   fprintf(stderr, "%02x ", sin2->sin6_addr.s6_addr[i]); */
 451 +/*                } */
 452 +/*                fprintf(stderr, "mask %d scopeids %x %x\n", mask, sin1->sin6_scope_id, sin2->sin6_scope_id); */
 453 +/*             } */
 454 +            /* should we compare scope ids and such too? */
 455 +            /*
 456 +             * LEM: I see no reason for this comparison
 457 +             * Quite the contrary: A client coming to us with
 458 +             * a small-scope address should be able to a bigger-scope
 459 +             * address.
 460 +             */
 461 +/*             if (sin1->sin6_scope_id != sin2->sin6_scope_id) */
 462 +/*                return 0; */
 463 +
 464 +            if (mask > 128ul)
 465 +            {
 466 +               log_error(LOG_LEVEL_ERROR, "%s%d", "Tried to compare IPv6 addresses with invalid prefixlen: ", mask);
 467 +               return 0;
 468 +            }
 469 +
 470 +            a1 = sin1->sin6_addr.s6_addr;
 471 +            a2 = sin2->sin6_addr.s6_addr;
 472 +
 473 +            if (memcmp(a1, a2, maskbytes) != 0)
 474 +               return 0;
 475 +
 476 +            mask %= 8;
 477 +            /* This special case is necessary for when mask==128
 478 +               else, we would go over the array size in a1/a2
 479 +             */
 480 +            if (mask==0)
 481 +               return 1;
 482 +
 483 +            bitmask = m[mask];
 484 +
 485 +            return (a1[maskbytes] & bitmask) == a2[maskbytes];
 486 +      }
 487 +         break;
 488 +#endif
 489 +      default:
 490 +         return 0;
 491 +      }
 492 +}
 493
 494 -#ifdef FEATURE_ACL
 495  /*********************************************************************
 496   *
 497   * Function    :  block_acl
 498 @@ -545,7 +653,7 @@
 499     /* search the list */
 500     while (acl != NULL)
 501     {
 502 -      if ((csp->ip_addr_long & acl->src->mask) == acl->src->addr)
 503 +      if (addr_equal_under_mask(&csp->ip_addr_addr, &acl->src->addr, acl->src->mask))
 504        {
 505           if (dst == NULL)
 506           {
 507 @@ -555,8 +663,8 @@
 508                 return(0);
 509              }
 510           }
 511 -         else if ( ((dst->addr & acl->dst->mask) == acl->dst->addr)
 512 -           && ((dst->port == acl->dst->port) || (acl->dst->port == 0)))
 513 +         else if ( addr_equal_under_mask(&dst->addr, &acl->dst->addr, acl->dst->mask)
 514 +                   && ((dst->port == acl->dst->port) || (acl->dst->port == 0)))
 515           {
 516              if (acl->action == ACL_PERMIT)
 517              {
 518 @@ -575,81 +683,249 @@
 519
 520  }
 521
 522 -
 523  /*********************************************************************
 524   *
 525 - * Function    :  acl_addr
 526 + * Function    :  fill_acl_addr_mask
 527   *
 528 - * Description :  Called from `load_config' to parse an ACL address.
 529 + * Description :  Fill in the mask-related members of a
 530 + *                struct access_control_addr
 531   *
 532   * Parameters  :
 533 - *          1  :  aspec = String specifying ACL address.
 534 - *          2  :  aca = struct access_control_addr to fill in.
 535 + *          0  :  aca = struct access_control_addr to fill in.
 536 + *          1  :  masklength = mask length.
 537   *
 538 - * Returns     :  0 => Ok, everything else is an error.
 539 + * Returns     :  nothing
 540   *
 541   *********************************************************************/
 542 -int acl_addr(char *aspec, struct access_control_addr *aca)
 543 +void fill_acl_addr_mask(struct access_control_addr *aca, int masklength)
 544  {
 545 -   int i, masklength, port;
 546 -   char *p;
 547 +   int pf;
 548
 549 -   masklength = 32;
 550 -   port       =  0;
 551 +   pf = aca->addr.ss_family;
 552
 553 -   if ((p = strchr(aspec, '/')) != NULL)
 554 +   switch (pf)
 555     {
 556 -      *p++ = '\0';
 557 -
 558 -      if (ijb_isdigit(*p) == 0)
 559 +   case PF_INET:
 560 +      /* build the netmask */
 561 +      if (masklength == -1)
 562 +         masklength = 32;
 563 +      aca->mask = 0;
 564 +      for(pf=1; pf <= masklength ; ++pf)
 565        {
 566 -         return(-1);
 567 +         aca->mask |= (1 << (32 - pf));
 568        }
 569 -      masklength = atoi(p);
 570 -   }
 571 +      aca->mask = htonl(aca->mask);
 572 +
 573 +      /* now mask off the host portion of the ip address
 574 +       * (i.e. save on the network portion of the address).
 575 +       */
 576 +      ((struct sockaddr_in*) &aca->addr)->sin_addr.s_addr &= aca->mask;
 577 +      aca->port = ((struct sockaddr_in*) &aca->addr)->sin_port;
 578 +      break;
 579 +#ifdef INET6
 580 +   case PF_INET6:
 581 +      {
 582 +         static char m[] = { 0x00, 0x80, 0xC0, 0xE0,
 583 +                             0xF0, 0xF8, 0xFC, 0xFE };
 584 +         int i;
 585 +         struct sockaddr_in6 *sa6 = (struct sockaddr_in6*)&aca->addr;
 586
 587 -   if ((masklength < 0) || (masklength > 32))
 588 -   {
 589 -      return(-1);
 590 +         aca->mask = (masklength == -1) ? masklength : 128 ;
 591 +         /* now mask off the host portion of the ip address
 592 +          * (i.e. save on the network portion of the address).
 593 +          */
 594 +         i = aca->mask / 8;
 595 +         if (i < 16)
 596 +         {
 597 +            sa6->sin6_addr.s6_addr[i] &= m[aca->mask % 8];
 598 +            /* The following loop is not strictly necessary,
 599 +               because of the way addr_equal_under_mask is
 600 +               written. Better safe than sorry, though:
 601 +               New code might make the full mask-normal
 602 +               form assumption.
 603 +             */
 604 +            for(++i; i < 16 ; ++i)
 605 +               sa6->sin6_addr.s6_addr[i] = 0;
 606 +         }
 607 +         aca -> port = sa6->sin6_port;
 608 +         break;
 609 +      }
 610 +#endif
 611 +   default:
 612 +      /* FATAL because access_control_addr's are created only with adresses
 613 +         deemed 'acceptable' by the addr_list stuff, thus currently IPv4 and
 614 +         IPv6.
 615 +       */
 616 +      log_error(LOG_LEVEL_FATAL,"%s%d","Unknown address family in ACL address: ",pf);
 617     }
 618 +}
 619
 620 -   if ((p = strchr(aspec, ':')) != NULL)
 621 -   {
 622 -      *p++ = '\0';
 623 +/*********************************************************************
 624 + *
 625 + * Function    :  acl_addrs
 626 + *
 627 + * Description :  Parse an ACL address (adress + mask prefix)
 628 + *                Resolve the parsed address
 629 + *                Describe errors in *proxy_args.
 630 + *
 631 + * Parameters  :
 632 + *          0  :  aspec = the string containing the ACL address/mask
 633 + *          1  :  masklength = pointer used to return the mask
 634 + *          2  :  proxy_args = Pointer to string to append description of errors to.
 635 + *          3  :  type = type of ACL adress (source / destination).
 636 + *                       Used for error reporting.
 637 + *
 638 + * Returns     :  the list of adresses the ACL address resolves to
 639 + *
 640 + *********************************************************************/
 641 +static addr_list *acl_addrs(char *aspec, int *masklength, char**proxy_args, const char *type)
 642 +{
 643 +   char *host;
 644 +   char *port;
 645 +   int pf;
 646
 647 -      if (ijb_isdigit(*p) == 0)
 648 -      {
 649 -         return(-1);
 650 -      }
 651 -      port = atoi(p);
 652 +   pf = -1;
 653 +   if (parse_pf_ip_netmask(aspec, &host, &port, &pf, masklength) != 0)
 654 +   {
 655 +      log_error(LOG_LEVEL_ERROR, "Invalid %s IP for (deny|permit)-access "
 656 +                "directive in configuration file: \"%s\"", type, aspec);
 657 +      string_append(proxy_args,"<br>\nWARNING: Invalid ");
 658 +      string_append(proxy_args, type);
 659 +      string_append(proxy_args," IP for (deny|permit)-access directive"
 660 +                    " in configuration file: \"");
 661 +      string_append(proxy_args, aspec);
 662 +      string_append(proxy_args,"\"<br><br>\n");
 663 +      return NULL;
 664     }
 665
 666 -   aca->port = port;
 667 +   return resolve_hostname_to_ip(host, port, pf);
 668 +}
 669
 670 -   aca->addr = ntohl(resolve_hostname_to_ip(aspec));
 671 +/*********************************************************************
 672 + *
 673 + * Function    :  add_one_to_acl_list
 674 + *
 675 + * Description :  Add one entry to an access_control_list.
 676 + *
 677 + * Parameters  :
 678 + *          0  :  l = the list to add to
 679 + *          1  :  action = ACL_DENY or ACL_PERMIT
 680 + *          2  :  src_addrs = the head of this list will be used as source
 681 + *                            in the ACL entry.
 682 + *          3  :  dst_addrs = the head of this list will be used as destination
 683 + *                            in the ACL entry.
 684 + *                            NULL for none
 685 + *          4  :  src_masklength = mask length for the source
 686 + *          5  :  src_masklength = mask length for the destination
 687 + *
 688 + * Returns     :  the new list
 689 + *
 690 + *********************************************************************/
 691 +struct access_control_list *add_one_to_acl_list(struct access_control_list *l, short action,
 692 +                                                addr_list *src_addrs, addr_list *dst_addrs,
 693 +                                                int src_masklength, int dst_masklength)
 694 +{
 695 +   struct access_control_list *cur_acl;
 696 +   /* allocate a new node */
 697 +   cur_acl = (struct access_control_list *) zalloc(sizeof(*cur_acl));
 698
 699 -   if (aca->addr == INADDR_NONE)
 700 +   if (cur_acl == NULL)
 701     {
 702 -      return(-1);
 703 +      log_error(LOG_LEVEL_FATAL, "can't allocate memory for configuration");
 704 +      /* Never get here - LOG_LEVEL_FATAL causes program exit */
 705 +      return l;
 706     }
 707
 708 -   /* build the netmask */
 709 -   aca->mask = 0;
 710 -   for (i=1; i <= masklength ; i++)
 711 +   cur_acl->action = action;
 712 +
 713 +   cpy_head_addr_list(src_addrs, &cur_acl->src->addr, &cur_acl->src->addrlen);
 714 +   fill_acl_addr_mask(cur_acl->src, src_masklength);
 715 +   if (dst_addrs != NULL)
 716     {
 717 -      aca->mask |= (1 << (32 - i));
 718 +      cpy_head_addr_list(dst_addrs, &cur_acl->dst->addr, &cur_acl->dst->addrlen);
 719 +      fill_acl_addr_mask(cur_acl->src, src_masklength);
 720     }
 721
 722 -   /* now mask off the host portion of the ip address
 723 -    * (i.e. save on the network portion of the address).
 724 +   /*
 725 +    * Add it to the list.  Note we reverse the list to get the
 726 +    * behaviour the user expects.  With both the ACL and
 727 +    * actions file, the last match wins.  However, the internal
 728 +    * implementations are different:  The actions file is stored
 729 +    * in the same order as the file, and scanned completely.
 730 +    * With the ACL, we reverse the order as we load it, then
 731 +    * when we scan it we stop as soon as we get a match.
 732      */
 733 -   aca->addr = aca->addr & aca->mask;
 734 +   cur_acl->next  = l;
 735
 736 -   return(0);
 737 +   return cur_acl;
 738 +}
 739 +
 740 +/*********************************************************************
 741 + *
 742 + * Function    :  add_to_acl_list
 743 + *
 744 + * Description :  Add entries to an access_control_list.
 745 + *                Describe errors in *proxy_args.
 746 + *
 747 + * Parameters  :
 748 + *          0  :  l = the list to add to
 749 + *          1  :  action = ACL_DENY or ACL_PERMIT
 750 + *          2  :  src_spec = String giving the source of the acl entry
 751 + *          3  :  dst_spec = String giving the destination of the acl entry,
 752 + *                           or NULL
 753 + *          4  :  proxy_args = Pointer to string to append description of errors to.
 754 + *
 755 + * Returns     :  the new list
 756 + *
 757 + *********************************************************************/
 758 +struct access_control_list *add_to_acl_list(struct access_control_list *l,
 759 +                                            short action,
 760 +                                            char *src_spec,
 761 +                                            char *dst_spec,
 762 +                                            char **proxy_args)
 763 +{
 764 +   int src_masklength, dst_masklength;
 765 +   addr_list *src_addrs, *dst_addrs;
 766 +   addr_list *src_addrs_remaining, *dst_addrs_remaining;
 767 +
 768 +   src_addrs = acl_addrs(src_spec, &src_masklength, proxy_args, "source");
 769 +   if (is_nil_addr_list(src_addrs))
 770 +   {
 771 +      log_error(LOG_LEVEL_ERROR, "Source of ACL resolves to no address",dst_spec);
 772 +      return l;
 773 +   }
 774 +   if (dst_spec != NULL)
 775 +   {
 776 +      dst_addrs = acl_addrs(dst_spec, &dst_masklength, proxy_args, "destination");
 777 +      if (is_nil_addr_list(dst_addrs))
 778 +      {
 779 +         log_error(LOG_LEVEL_ERROR, "Destination of ACL resolves to no address",dst_spec);
 780 +         destroy_addr_list(src_addrs);
 781 +         return l;
 782 +      }
 783 +   }
 784 +   else
 785 +      dst_addrs = NULL;
 786 +
 787 +   for(src_addrs_remaining = src_addrs;
 788 +       is_nil_addr_list(src_addrs);
 789 +       src_addrs_remaining=tail_addr_list(src_addrs_remaining))
 790 +   {
 791 +      if (dst_addrs == NULL)
 792 +         l = add_one_to_acl_list(l, action, src_addrs_remaining, NULL, src_masklength,0);
 793 +      else for(dst_addrs_remaining = dst_addrs;
 794 +               is_nil_addr_list(dst_addrs);
 795 +               dst_addrs_remaining=tail_addr_list(dst_addrs_remaining))
 796 +         l = add_one_to_acl_list(l, action, src_addrs_remaining, dst_addrs_remaining,
 797 +                                 src_masklength, dst_masklength);
 798 +   }
 799 +   destroy_addr_list(src_addrs);
 800 +   destroy_addr_list(dst_addrs);
 801
 802 +   return l;
 803  }
 804 -#endif /* def FEATURE_ACL */
 805
 806 +#endif /* def FEATURE_ACL */
 807
 808  /*********************************************************************
 809   *
 810 diff -urNad privoxy~/filters.h privoxy/filters.h
 811 --- privoxy~/filters.h
 812 +++ privoxy/filters.h
 813 @@ -15,6 +15,9 @@
 814   * Copyright   :  Written by and Copyright (C) 2001, 2004 the SourceForge
 815   *                Privoxy team. http://www.privoxy.org/
 816   *
 817 + *                Modified by Lionel Elie Mamane <lionel@mamane.lu>
 818 + *                for IPv6 support on 8 December 2002, 24 January 2003.
 819 + *
 820   *                Based on the Internet Junkbuster originally written
 821   *                by and Copyright (C) 1997 Anonymous Coders and
 822   *                Junkbusters Corporation.  http://www.junkbusters.com
 823 @@ -234,7 +237,11 @@
 824   */
 825  #ifdef FEATURE_ACL
 826  extern int block_acl(struct access_control_addr *dst, struct client_state *csp);
 827 -extern int acl_addr(char *aspec, struct access_control_addr *aca);
 828 +extern struct access_control_list *add_to_acl_list(struct access_control_list *l,
 829 +                                                   short action,
 830 +                                                   char *src_spec,
 831 +                                                   char *dst_spec,
 832 +                                                   char **proxy_args);
 833  #endif /* def FEATURE_ACL */
 834  extern int match_portlist(const char *portlist, int port);
 835
 836 diff -urNad privoxy~/gateway.c privoxy/gateway.c
 837 --- privoxy~/gateway.c
 838 +++ privoxy/gateway.c
 839 @@ -10,6 +10,9 @@
 840   * Copyright   :  Written by and Copyright (C) 2001 the SourceForge
 841   *                Privoxy team. http://www.privoxy.org/
 842   *
 843 + *                Modified by Lionel Elie Mamane <lionel@mamane.lu>
 844 + *                for IPv6 support on 8 December 2002, 24 January 2003.
 845 + *
 846   *                Based on the Internet Junkbuster originally written
 847   *                by and Copyright (C) 1997 Anonymous Coders and
 848   *                Junkbusters Corporation.  http://www.junkbusters.com
 849 @@ -203,12 +206,14 @@
 850   * Returns     :  JB_INVALID_SOCKET => failure, else it is the socket file descriptor.
 851   *
 852   *********************************************************************/
 853 -jb_socket forwarded_connect(const struct forward_spec * fwd,
 854 +jb_socket forwarded_connect(const struct forward_spec *fwd,
 855                              struct http_request *http,
 856                              struct client_state *csp)
 857  {
 858     const char * dest_host;
 859 -   int dest_port;
 860 +   const char * dest_port_str;
 861 +   unsigned long dest_port;
 862 +   int dest_pf;
 863
 864     /* Figure out if we need to connect to the web server or a HTTP proxy. */
 865     if (fwd->forward_host)
 866 @@ -216,19 +221,23 @@
 867        /* HTTP proxy */
 868        dest_host = fwd->forward_host;
 869        dest_port = fwd->forward_port;
 870 +      dest_port_str = fwd->forward_port_str;
 871 +      dest_pf = fwd->forward_family;
 872     }
 873     else
 874     {
 875        /* Web server */
 876        dest_host = http->host;
 877        dest_port = http->port;
 878 +      dest_port_str = http->port_str;
 879 +      dest_pf = PF_UNSPEC;
 880     }
 881
 882     /* Connect, maybe using a SOCKS proxy */
 883     switch (fwd->type)
 884     {
 885        case SOCKS_NONE:
 886 -         return (connect_to(dest_host, dest_port, csp));
 887 +         return (connect_to(dest_host, dest_port_str, dest_port, dest_pf, csp));
 888
 889        case SOCKS_4:
 890        case SOCKS_4A:
 891 @@ -262,74 +271,19 @@
 892   * Returns     :  JB_INVALID_SOCKET => failure, else a socket file descriptor.
 893   *
 894   *********************************************************************/
 895 -static jb_socket socks4_connect(const struct forward_spec * fwd,
 896 -                                const char * target_host,
 897 -                                int target_port,
 898 -                                struct client_state *csp)
 899 +static jb_socket socks4_connect_one_ip(const struct forward_spec * fwd,
 900 +                                       unsigned long web_server_addr,
 901 +                                       int target_port,
 902 +                                       struct client_state *csp,
 903 +                                       size_t csiz,
 904 +                                       char *cbuf)
 905  {
 906 -   int web_server_addr;
 907 -   char cbuf[BUFFER_SIZE];
 908     char sbuf[BUFFER_SIZE];
 909 -   struct socks_op    *c = (struct socks_op    *)cbuf;
 910     struct socks_reply *s = (struct socks_reply *)sbuf;
 911 -   size_t n;
 912 -   size_t csiz;
 913 +   struct socks_reply *c = (struct socks_reply *)cbuf;
 914     jb_socket sfd;
 915 -   int err = 0;
 916     char *errstr;
 917
 918 -   if ((fwd->gateway_host == NULL) || (*fwd->gateway_host == '\0'))
 919 -   {
 920 -      log_error(LOG_LEVEL_CONNECT, "socks4_connect: NULL gateway host specified");
 921 -      err = 1;
 922 -   }
 923 -
 924 -   if (fwd->gateway_port <= 0)
 925 -   {
 926 -      log_error(LOG_LEVEL_CONNECT, "socks4_connect: invalid gateway port specified");
 927 -      err = 1;
 928 -   }
 929 -
 930 -   if (err)
 931 -   {
 932 -      errno = EINVAL;
 933 -      return(JB_INVALID_SOCKET);
 934 -   }
 935 -
 936 -   /* build a socks request for connection to the web server */
 937 -
 938 -   strcpy((char *)&(c->userid), socks_userid);
 939 -
 940 -   csiz = sizeof(*c) + sizeof(socks_userid) - 1;
 941 -
 942 -   switch (fwd->type)
 943 -   {
 944 -      case SOCKS_4:
 945 -         web_server_addr = htonl(resolve_hostname_to_ip(target_host));
 946 -         if (web_server_addr == INADDR_NONE)
 947 -         {
 948 -            log_error(LOG_LEVEL_CONNECT, "socks4_connect: could not resolve target host %s", target_host);
 949 -            return(JB_INVALID_SOCKET);
 950 -         }
 951 -         break;
 952 -      case SOCKS_4A:
 953 -         web_server_addr = 0x00000001;
 954 -         n = csiz + strlen(target_host) + 1;
 955 -         if (n > sizeof(cbuf))
 956 -         {
 957 -            errno = EINVAL;
 958 -            return(JB_INVALID_SOCKET);
 959 -         }
 960 -         strcpy(cbuf + csiz, target_host);
 961 -         csiz = n;
 962 -         break;
 963 -      default:
 964 -         /* Should never get here */
 965 -         log_error(LOG_LEVEL_FATAL, "SOCKS4 impossible internal error - bad SOCKS type.");
 966 -         errno = EINVAL;
 967 -         return(JB_INVALID_SOCKET);
 968 -   }
 969 -
 970     c->vn          = 4;
 971     c->cd          = 1;
 972     c->dstport[0]  = (target_port       >> 8  ) & 0xff;
 973 @@ -340,7 +294,7 @@
 974     c->dstip[3]    = (web_server_addr         ) & 0xff;
 975
 976     /* pass the request to the socks server */
 977 -   sfd = connect_to(fwd->gateway_host, fwd->gateway_port, csp);
 978 +   sfd = connect_to(fwd->gateway_host, fwd->gateway_port_str, fwd->gateway_port, PF_INET ,csp);
 979
 980     if (sfd == JB_INVALID_SOCKET)
 981     {
 982 @@ -395,6 +349,92 @@
 983
 984  }
 985
 986 +static jb_socket socks4_connect(const struct forward_spec * fwd,
 987 +                                const char * target_host,
 988 +                                int target_port,
 989 +                                struct client_state *csp)
 990 +{
 991 +   char cbuf[BUFFER_SIZE];
 992 +   struct socks_op    *c = (struct socks_op    *)cbuf;
 993 +   size_t csiz;
 994 +   int err = 0;
 995 +
 996 +   /**
 997 +    * SOCKS4 is IPv4-specific. At least I think so.
 998 +    */
 999 +   if ((fwd->gateway_host == NULL) || (*fwd->gateway_host == '\0'))
1000 +   {
1001 +      log_error(LOG_LEVEL_CONNECT, "socks4_connect: NULL gateway host specified");
1002 +      err = 1;
1003 +   }
1004 +
1005 +   if (fwd->gateway_port <= 0)
1006 +   {
1007 +      log_error(LOG_LEVEL_CONNECT, "socks4_connect: invalid gateway port specified");
1008 +      err = 1;
1009 +   }
1010 +
1011 +   if (err)
1012 +   {
1013 +      errno = EINVAL;
1014 +      return(JB_INVALID_SOCKET);
1015 +   }
1016 +
1017 +   /* build a socks request for connection to the web server */
1018 +
1019 +   strcpy((char *)&(c->userid), socks_userid);
1020 +
1021 +   csiz = sizeof(*c) + sizeof(socks_userid) - 1;
1022 +
1023 +   switch (fwd->type)
1024 +   {
1025 +      case SOCKS_4:
1026 +      {
1027 +         addr_list *web_server_addrs = resolve_hostname_to_ip(target_host,NULL,PF_INET);
1028 +         jb_socket return_value = JB_INVALID_SOCKET;
1029 +         if (is_nil_addr_list(web_server_addrs))
1030 +         {
1031 +            log_error(LOG_LEVEL_CONNECT, "socks4_connect: could not resolve target host %s", target_host);
1032 +         }
1033 +         else
1034 +         {
1035 +            addr_list *addrs_to_try;
1036 +
1037 +            for(addrs_to_try = web_server_addrs;
1038 +                !is_nil_addr_list(addrs_to_try);
1039 +                addrs_to_try = tail_addr_list(addrs_to_try))
1040 +            {
1041 +               const unsigned long web_server_addr = ((struct sockaddr_in*) head_addr_list(addrs_to_try))->sin_addr.s_addr;
1042 +               return_value=socks4_connect_one_ip(fwd, web_server_addr, target_port, csp, csiz, cbuf);
1043 +               if(return_value != JB_INVALID_SOCKET)
1044 +                  break;
1045 +            }
1046 +         }
1047 +         destroy_addr_list(web_server_addrs);
1048 +         return return_value;
1049 +         break;
1050 +      }
1051 +      case SOCKS_4A:
1052 +      {
1053 +         size_t n;
1054 +         n = csiz + strlen(target_host) + 1;
1055 +         if (n > sizeof(cbuf))
1056 +         {
1057 +            errno = EINVAL;
1058 +            return(JB_INVALID_SOCKET);
1059 +         }
1060 +         strcpy(cbuf + csiz, target_host);
1061 +         csiz = n;
1062 +         return socks4_connect_one_ip(fwd, 0x00000001, target_port, csp, csiz, cbuf);
1063 +         break;
1064 +      }
1065 +      default:
1066 +         /* Should never get here */
1067 +         log_error(LOG_LEVEL_FATAL, "SOCKS4 impossible internal error - bad SOCKS type.");
1068 +         errno = EINVAL;
1069 +         return(JB_INVALID_SOCKET);
1070 +   }
1071 +}
1072
1073  /*
1074    Local Variables:
1075 diff -urNad privoxy~/jb_socket_set.c privoxy/jb_socket_set.c
1076 --- privoxy~/jb_socket_set.c
1077 +++ privoxy/jb_socket_set.c
1078 @@ -0,0 +1,174 @@
1079 +const char jb_socket_set_rcs[] = "$Id: $";
1080 +/*********************************************************************
1081 + *
1082 + * File        :  $Source: $
1083 + *
1084 + * Purpose     :  Declares functions to handle sets of sockets
1085 + *
1086 + * Copyright   :  Written by and Copyright (C) 2002 Lionel Elie Mamane
1087 + *                <lionel@mamane.lu>
1088 + *
1089 + *                This program is free software; you can redistribute it
1090 + *                and/or modify it under the terms of the GNU General
1091 + *                Public License as published by the Free Software
1092 + *                Foundation; either version 2 of the License, or (at
1093 + *                your option) any later version.
1094 + *
1095 + *                This program is distributed in the hope that it will
1096 + *                be useful, but WITHOUT ANY WARRANTY; without even the
1097 + *                implied warranty of MERCHANTABILITY or FITNESS FOR A
1098 + *                PARTICULAR PURPOSE.  See the GNU General Public
1099 + *                License for more details.
1100 + *
1101 + *                The GNU General Public License should be included with
1102 + *                this file.  If not, you can view it at
1103 + *                http://www.gnu.org/copyleft/gpl.html
1104 + *                or write to the Free Software Foundation, Inc., 59
1105 + *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.
1106 + *
1107 + * Revisions   :
1108 + *    $Log: jb_socket_set.c,v $
1109 + *
1110 + *********************************************************************/
1111 +
1112 +#include "jb_socket_set.h"
1113 +#include <sys/time.h>
1114 +#include <sys/types.h>
1115 +#include <unistd.h>
1116 +#include "project.h"
1117 +
1118 +/*********************************************************************
1119 + *
1120 + * Function    :  jb_socket_set_add
1121 + *
1122 + * Description :  Add a socket to the set
1123 + *
1124 + * Parameters  :
1125 + *          0  :  l = the set to add to
1126 + *          1  :  the elemen to add to the set
1127 + *
1128 + * Returns     :  0 on success
1129 + *                non-0 on failure
1130 + *
1131 + *********************************************************************/
1132 +
1133 +int jb_socket_set_add(jb_socket_set *l, jb_socket e)
1134 +{
1135 +   if (l->data==NULL)
1136 +   {
1137 +      l->size=2;
1138 +      l->data=malloc(l->size * sizeof(jb_socket));
1139 +      if (l->data==NULL)
1140 +      {
1141 +         l->size = 0;
1142 +         return -1;
1143 +      }
1144 +      l->occupied=0;
1145 +   }
1146 +   l->data[(l->occupied)++] = e;
1147 +   if (l->occupied == l->size)
1148 +   {
1149 +      jb_socket *new_data;
1150 +      l->size *= 2;
1151 +      new_data = realloc(l->data,l->size * sizeof(jb_socket));
1152 +      if (new_data == NULL)
1153 +      {
1154 +         /* Not enough memory to continue. Cancel changes. */
1155 +         l->data[--(l->occupied)] = JB_INVALID_SOCKET;
1156 +         l->size /= 2;
1157 +         return -1;
1158 +      }
1159 +      l->data = new_data;
1160 +   }
1161 +   l->data[l->occupied] = JB_INVALID_SOCKET;
1162 +   return 0;
1163 +}
1164 +
1165 +/*********************************************************************
1166 + *
1167 + * Function    :  destroy_jb_socket_set
1168 + *
1169 + * Description :  Unallocate memory allocated to a socket set
1170 + *
1171 + * Parameters  :
1172 + *          0  :  l = the set to unallocate
1173 + *
1174 + * Returns     :  nothing
1175 + *
1176 + *********************************************************************/
1177 +void destroy_jb_socket_set(jb_socket_set *l)
1178 +{
1179 +   free(l->data);
1180 +   init_jb_socket_set(l);
1181 +}
1182 +/*********************************************************************
1183 + *
1184 + * Function    :  is_empty_jb_socket_set
1185 + *
1186 + * Description :  Test wheter a set is empty
1187 + *
1188 + * Parameters  :
1189 + *          0  :  l = the set to test
1190 + *
1191 + * Returns     :  0             = false if set has a head,
1192 + *                anything else = true if set is nil
1193 + *
1194 + *********************************************************************/
1195 +int is_nil_jb_socket_set(jb_socket_set *l)
1196 +{
1197 +   return (l->occupied == 0);
1198 +}
1199 +
1200 +/*********************************************************************
1201 + *
1202 + * Function    :  init_jb_socket_set
1203 + *
1204 + * Description :  Init a set to empty
1205 + *
1206 + * Parameters  :
1207 + *          0  :  l = the set to init
1208 + *
1209 + *********************************************************************/
1210 +void init_jb_socket_set(jb_socket_set *l)
1211 +{
1212 +   l->data=NULL;
1213 +   l->size=0;
1214 +   l->occupied=0;
1215 +}
1216 +
1217 +/*********************************************************************
1218 + *
1219 + * Function    :  jb_socket_set_iteration_begin
1220 + *
1221 + * Description :  Return an iterator on the set
1222 + *
1223 + * Parameters  :
1224 + *          0  :  l = the set
1225 + *
1226 + *********************************************************************/
1227 +jb_socket_set_iterate_state jb_socket_set_iteration_begin(jb_socket_set *l)
1228 +{
1229 +   return l->data;
1230 +}
1231 +
1232 +/*********************************************************************
1233 + *
1234 + * Function    :  jb_socket_set_iteration_next
1235 + *
1236 + * Description :  Return value pointed to by iterator and step
1237 + *                iterator to next position
1238 + *
1239 + * Parameters  :
1240 + *          0  :  s = the iterator
1241 + *
1242 + *********************************************************************/
1243 +jb_socket jb_socket_set_iteration_next(jb_socket_set_iterate_state*s)
1244 +{
1245 +   return(*((*s)++));
1246 +}
1247 +
1248 +/*
1249 +  Local Variables:
1250 +  tab-width: 3
1251 +  end:
1252 +*/
1253 diff -urNad privoxy~/jb_socket_set.h privoxy/jb_socket_set.h
1254 --- privoxy~/jb_socket_set.h
1255 +++ privoxy/jb_socket_set.h
1256 @@ -0,0 +1,71 @@
1257 +#ifndef JB_SOCKET_SET_H_INCLUDED
1258 +#define JB_SOCKET_SET_H_INCLUDED
1259 +#define JB_SOCKET_SET_H_VERSION "$Id: $"
1260 +/*********************************************************************
1261 + *
1262 + * File        :  $Source: $
1263 + *
1264 + * Purpose     :  Declares functions to handle sets of sockets
1265 + *
1266 + * Copyright   :  Written by and Copyright (C) 2002 Lionel Elie Mamane
1267 + *                <lionel@mamane.lu>
1268 + *
1269 + *                This program is free software; you can redistribute it
1270 + *                and/or modify it under the terms of the GNU General
1271 + *                Public License as published by the Free Software
1272 + *                Foundation; either version 2 of the License, or (at
1273 + *                your option) any later version.
1274 + *
1275 + *                This program is distributed in the hope that it will
1276 + *                be useful, but WITHOUT ANY WARRANTY; without even the
1277 + *                implied warranty of MERCHANTABILITY or FITNESS FOR A
1278 + *                PARTICULAR PURPOSE.  See the GNU General Public
1279 + *                License for more details.
1280 + *
1281 + *                The GNU General Public License should be included with
1282 + *                this file.  If not, you can view it at
1283 + *                http://www.gnu.org/copyleft/gpl.html
1284 + *                or write to the Free Software Foundation, Inc., 59
1285 + *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.
1286 + *
1287 + * Revisions   :
1288 + *    $Log: jb_socket_set.h,v $
1289 + *
1290 + *********************************************************************/
1291 +#include <sys/time.h>
1292 +#include <sys/types.h>
1293 +#include <unistd.h>
1294 +#include "project.h"
1295 +
1296 +struct jb_socket_set_struct
1297 +{
1298 +   unsigned int size; /* size allocated*/
1299 +   unsigned int occupied; /* size occupied - 1 == index of final JB_INVALID_SOCKET
1300 +                             == number of sockets in the set */
1301 +   jb_socket *data; /* Array containing the sockets, JB_INVALID_SOCKET-terminated */
1302 +};
1303 +
1304 +typedef struct jb_socket_set_struct jb_socket_set;
1305 +typedef const jb_socket* jb_socket_set_iterate_state;
1306 +
1307 +void init_jb_socket_set(jb_socket_set*);
1308 +
1309 +jb_socket_set_iterate_state jb_socket_set_iteration_begin(jb_socket_set *);
1310 +jb_socket jb_socket_set_iteration_next(jb_socket_set_iterate_state*);
1311 +
1312 +int jb_socket_set_add(jb_socket_set*, jb_socket);
1313 +
1314 +void destroy_jb_socket_set(jb_socket_set *l);
1315 +int is_empty_jb_socket_set(jb_socket_set *l);
1316 +
1317 +#define freez_jb_socket_set(X)  { if(X) { destroy_jb_socket_set(X); X = NULL ; } }
1318 +
1319 +int jb_select(jb_socket_set *readfds, jb_socket_set *writefds, jb_socket_set *exceptfds, struct timeval *timeout);
1320 +
1321 +#endif /* ndef JB_SOCKET_SET_H_INCLUDED */
1322 +
1323 +/*
1324 +  Local Variables:
1325 +  tab-width: 3
1326 +  end:
1327 +*/
1328 diff -urNad privoxy~/jbsockets.c privoxy/jbsockets.c
1329 --- privoxy~/jbsockets.c
1330 +++ privoxy/jbsockets.c
1331 @@ -11,6 +11,10 @@
1332   * Copyright   :  Written by and Copyright (C) 2001 the SourceForge
1333   *                Privoxy team. http://www.privoxy.org/
1334   *
1335 + *                Modified by Lionel Elie Mamane <lionel@mamane.lu>
1336 + *                for IPv6 support on 8-9 December 2002, 24 January 2003,
1337 + *                13 February 2003.
1338 + *
1339   *                Based on the Internet Junkbuster originally written
1340   *                by and Copyright (C) 1997 Anonymous Coders and
1341   *                Junkbusters Corporation.  http://www.junkbusters.com
1342 @@ -285,6 +289,7 @@
1343  #include "jbsockets.h"
1344  #include "filters.h"
1345  #include "errlog.h"
1346 +#include "addrlist.h"
1347
1348  const char jbsockets_h_rcs[] = JBSOCKETS_H_VERSION;
1349
1350 @@ -297,141 +302,194 @@
1351   *                that this is allowed according to ACL.
1352   *
1353   * Parameters  :
1354 - *          1  :  host = hostname to connect to
1355 - *          2  :  portnum = port to connent on
1356 + *          0  :  host = hostname to connect to
1357 + *          1  :  port = port to connect on, as string
1358 + *          2  :  portnum = port to connect on, as integer
1359   *          3  :  csp = Current client state (buffers, headers, etc...)
1360 - *                      Not modified, only used for source IP and ACL.
1361   *
1362   * Returns     :  JB_INVALID_SOCKET => failure, else it is the socket
1363   *                file descriptor.
1364   *
1365   *********************************************************************/
1366 -jb_socket connect_to(const char *host, int portnum, struct client_state *csp)
1367 +jb_socket connect_to_one_ip(struct sockaddr_storage *addr, size_t addrlen, const char *host, unsigned long portnum, struct client_state *csp)
1368  {
1369 -   struct sockaddr_in inaddr;
1370 -   jb_socket fd;
1371 -   int addr;
1372 -   fd_set wfds;
1373 -   struct timeval tv[1];
1374 -#if !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA)
1375 -   int   flags;
1376 -#endif /* !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA) */
1377 -
1378  #ifdef FEATURE_ACL
1379 -   struct access_control_addr dst[1];
1380 -#endif /* def FEATURE_ACL */
1381 -
1382 -   memset((char *)&inaddr, 0, sizeof inaddr);
1383 -
1384 -   if ((addr = resolve_hostname_to_ip(host)) == INADDR_NONE)
1385 +   if (csp)
1386     {
1387 -      csp->http->host_ip_addr_str = strdup("unknown");
1388 -      return(JB_INVALID_SOCKET);
1389 -   }
1390 +      struct access_control_addr dst[1];
1391 +      char hostname[NI_MAXHOST];
1392 +      char port[NI_MAXSERV];
1393 +      if (getnameinfo((struct sockaddr*)addr, addrlen, hostname, NI_MAXHOST,
1394 +                      port, NI_MAXSERV, NI_NUMERICHOST | NI_NUMERICSERV) != 0)
1395 +      {
1396 +         log_error(LOG_LEVEL_ERROR, "connect: Could not get string address and port back from sockaddr because %E");
1397 +         strncpy(hostname,"unknown",NI_MAXHOST);
1398 +         strncpy(port,"unknown",NI_MAXSERV);
1399 +      }
1400
1401 -#ifdef FEATURE_ACL
1402 -   dst->addr = ntohl((unsigned long) addr);
1403 -   dst->port = portnum;
1404 +      csp->http->host_ip_addr_str = strdup(hostname);
1405
1406 -   if (block_acl(dst, csp))
1407 -   {
1408 +      dst->addr = *addr;
1409 +      dst->addrlen = addrlen;
1410 +      dst->port = portnum;
1411 +
1412 +      if (block_acl(dst, csp))
1413 +      {
1414  #ifdef __OS2__
1415 -      errno = SOCEPERM;
1416 +         errno = SOCEPERM;
1417  #else
1418 -      errno = EPERM;
1419 +         errno = EPERM;
1420  #endif
1421 -      return(JB_INVALID_SOCKET);
1422 -   }
1423 -#endif /* def FEATURE_ACL */
1424 +         return(JB_INVALID_SOCKET);
1425 +      }
1426
1427 -   inaddr.sin_addr.s_addr = addr;
1428 -   inaddr.sin_family      = AF_INET;
1429 -   csp->http->host_ip_addr_str = strdup(inet_ntoa(inaddr.sin_addr));
1430
1431 -#ifndef _WIN32
1432 -   if (sizeof(inaddr.sin_port) == sizeof(short))
1433 -#endif /* ndef _WIN32 */
1434 -   {
1435 -      inaddr.sin_port = htons((unsigned short) portnum);
1436     }
1437 -#ifndef _WIN32
1438 -   else
1439 +#endif /* def FEATURE_ACL */
1440 +
1441     {
1442 -      inaddr.sin_port = htonl((unsigned long)portnum);
1443 -   }
1444 -#endif /* ndef _WIN32 */
1445 +      jb_socket fd;
1446
1447  #ifdef _WIN32
1448 -   if ((fd = socket(inaddr.sin_family, SOCK_STREAM, 0)) == JB_INVALID_SOCKET)
1449 +      if ((fd = socket(addr->ss_family, SOCK_STREAM, 0)) == JB_INVALID_SOCKET)
1450  #else
1451 -   if ((fd = socket(inaddr.sin_family, SOCK_STREAM, 0)) < 0)
1452 +      if ((fd = socket(addr->ss_family, SOCK_STREAM, 6)) < 0)
1453  #endif
1454 -   {
1455 -      return(JB_INVALID_SOCKET);
1456 -   }
1457 +      {
1458 +         return(JB_INVALID_SOCKET);
1459 +      }
1460
1461  #ifdef TCP_NODELAY
1462 -   {  /* turn off TCP coalescence */
1463 -      int mi = 1;
1464 -      setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *) &mi, sizeof (int));
1465 -   }
1466 +      {  /* turn off TCP coalescence */
1467 +         int mi = 1;
1468 +         setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, (char *) &mi, sizeof (int));
1469 +      }
1470  #endif /* def TCP_NODELAY */
1471
1472  #if !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA) && !defined(__OS2__)
1473 -   if ((flags = fcntl(fd, F_GETFL, 0)) != -1)
1474 -   {
1475 -      flags |= O_NDELAY;
1476 -      fcntl(fd, F_SETFL, flags);
1477 -   }
1478 +      {
1479 +         int flags;
1480 +
1481 +         if ((flags = fcntl(fd, F_GETFL, 0)) != -1)
1482 +         {
1483 +            flags |= O_NDELAY;
1484 +            fcntl(fd, F_SETFL, flags);
1485 +         }
1486 +      }
1487  #endif /* !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA) && !defined(__OS2__) */
1488
1489 -   while (connect(fd, (struct sockaddr *) & inaddr, sizeof inaddr) == JB_INVALID_SOCKET)
1490 -   {
1491 +      while (connect(fd, (struct sockaddr *) addr, addrlen) == JB_INVALID_SOCKET)
1492 +      {
1493  #ifdef _WIN32
1494 -      if (errno == WSAEINPROGRESS)
1495 +         if (errno == WSAEINPROGRESS)
1496  #elif __OS2__
1497 -      if (sock_errno() == EINPROGRESS)
1498 +         if (sock_errno() == EINPROGRESS)
1499  #else /* ifndef _WIN32 */
1500 -      if (errno == EINPROGRESS)
1501 +         if (errno == EINPROGRESS)
1502  #endif /* ndef _WIN32 || __OS2__ */
1503 -      {
1504 -         break;
1505 -      }
1506 +         {
1507 +            break;
1508 +         }
1509
1510  #ifdef __OS2__
1511 -      if (sock_errno() != EINTR)
1512 +         if (sock_errno() != EINTR)
1513  #else
1514 -      if (errno != EINTR)
1515 +         if (errno != EINTR)
1516  #endif /* __OS2__ */
1517 +         {
1518 +            close_socket(fd);
1519 +            return(JB_INVALID_SOCKET);
1520 +         }
1521 +      }
1522 +
1523 +#if !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA) && !defined(__OS2__)
1524        {
1525 -         close_socket(fd);
1526 -         return(JB_INVALID_SOCKET);
1527 +         int flags;
1528 +         if ((flags = fcntl(fd, F_GETFL, 0)) != -1)
1529 +         {
1530 +            flags &= ~O_NDELAY;
1531 +            fcntl(fd, F_SETFL, flags);
1532 +         }
1533        }
1534 -   }
1535 +#endif /* !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA) && !defined(__OS2__) */
1536
1537 +      {
1538 +         fd_set wfds;
1539 +         struct timeval tv[1];
1540 +
1541 +         /* wait for connection to complete */
1542 +         FD_ZERO(&wfds);
1543 +         FD_SET(fd, &wfds);
1544 +
1545 +         tv->tv_sec  = 30;
1546 +         tv->tv_usec = 0;
1547 +
1548 +         /* MS Windows uses int, not SOCKET, for the 1st arg of select(). Wierd! */
1549 +         if (select((int)fd + 1, NULL, &wfds, NULL, tv) <= 0)
1550 +         {
1551 +            close_socket(fd);
1552 +            return(JB_INVALID_SOCKET);
1553 +         }
1554  #if !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA) && !defined(__OS2__)
1555 -   if (flags != -1)
1556 -   {
1557 -      flags &= ~O_NDELAY;
1558 -      fcntl(fd, F_SETFL, flags);
1559 -   }
1560 +         else
1561 +         {
1562 +            int connect_result;
1563 +            socklen_t connect_result_len = sizeof connect_result;
1564 +
1565 +            if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &connect_result, &connect_result_len) != 0)
1566 +            {
1567 +               log_error(LOG_LEVEL_ERROR, "Could not determine whether connection to %s port %d was successful because %E. Assuming failure.",
1568 +                         csp->http->host_ip_addr_str, portnum);
1569 +               close_socket(fd);
1570 +               return(JB_INVALID_SOCKET);
1571 +            }
1572 +            else if( connect_result != 0 )
1573 +            {
1574 +               log_error(LOG_LEVEL_CONNECT, "Connection to %s port %d failed because %s.",
1575 +                         csp->http->host_ip_addr_str, portnum, strerror(connect_result));
1576 +               close_socket(fd);
1577 +               return(JB_INVALID_SOCKET);
1578 +            }
1579 +         }
1580  #endif /* !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA) && !defined(__OS2__) */
1581 +      }
1582 +      return(fd);
1583 +   }
1584 +}
1585
1586 -   /* wait for connection to complete */
1587 -   FD_ZERO(&wfds);
1588 -   FD_SET(fd, &wfds);
1589 +jb_socket connect_to(const char *host, const char *port, unsigned long portnum, int pf, struct client_state *csp)
1590 +{
1591 +   jb_socket fd = JB_INVALID_SOCKET;
1592 +   struct sockaddr_storage addr;
1593 +   addr_list *addrs, *addrs_to_try;
1594
1595 -   tv->tv_sec  = 30;
1596 -   tv->tv_usec = 0;
1597 +   addrs = resolve_hostname_to_ip(host,port,pf);
1598
1599 -   /* MS Windows uses int, not SOCKET, for the 1st arg of select(). Wierd! */
1600 -   if (select((int)fd + 1, NULL, &wfds, NULL, tv) <= 0)
1601 +   if (is_nil_addr_list(addrs))
1602     {
1603 -      close_socket(fd);
1604 -      return(JB_INVALID_SOCKET);
1605 +      errno = EINVAL;
1606 +      return fd;
1607 +   }
1608 +
1609 +   for(addrs_to_try=addrs;
1610 +       !is_nil_addr_list(addrs_to_try);
1611 +       addrs_to_try = tail_addr_list(addrs_to_try))
1612 +   {
1613 +      size_t addrlen;
1614 +      memset((char *)&addr, 0, sizeof addr);
1615 +      cpy_head_addr_list(addrs_to_try, &addr,&addrlen);
1616 +      fd = connect_to_one_ip(&addr, addrlen, host, portnum, csp);
1617 +      if (fd != JB_INVALID_SOCKET)
1618 +         break;
1619     }
1620 -   return(fd);
1621
1622 +   if (fd == JB_INVALID_SOCKET)
1623 +   {
1624 +      csp->http->host_ip_addr_str = strdup("unknown");
1625 +   }
1626 +
1627 +   destroy_addr_list(addrs);
1628 +   return fd;
1629  }
1630
1631
1632 @@ -571,55 +629,30 @@
1633
1634  /*********************************************************************
1635   *
1636 - * Function    :  bind_port
1637 + * Function    :  bind_port_one_ip
1638   *
1639   * Description :  Call socket, set socket options, and listen.
1640 - *                Called by listen_loop to "boot up" our proxy address.
1641   *
1642   * Parameters  :
1643 - *          1  :  hostnam = TCP/IP address to bind/listen to
1644 - *          2  :  portnum = port to listen on
1645 - *          3  :  pfd = pointer used to return file descriptor.
1646 + *          0  :  addr = TCP/IP address and port to bind/listen to
1647 + *          1  :  fds = jb_socket_set where the new socket should go
1648   *
1649 - * Returns     :  if success, returns 0 and sets *pfd.
1650 + * Returns     :  if success returns 0 and adds sockets to fds.
1651   *                if failure, returns -3 if address is in use,
1652 - *                                    -2 if address unresolvable,
1653 + *                                    -2 if memory error
1654   *                                    -1 otherwise
1655   *********************************************************************/
1656 -int bind_port(const char *hostnam, int portnum, jb_socket *pfd)
1657 +int bind_port_one_ip(struct sockaddr *addr, const socklen_t addr_len, jb_socket_set *fds)
1658  {
1659 -   struct sockaddr_in inaddr;
1660     jb_socket fd;
1661 +   int flags;
1662  #ifndef _WIN32
1663     int one = 1;
1664  #endif /* ndef _WIN32 */
1665
1666 -   *pfd = JB_INVALID_SOCKET;
1667 -
1668 -   memset((char *)&inaddr, '\0', sizeof inaddr);
1669 -
1670 -   inaddr.sin_family      = AF_INET;
1671 -   inaddr.sin_addr.s_addr = resolve_hostname_to_ip(hostnam);
1672 -
1673 -   if (inaddr.sin_addr.s_addr == INADDR_NONE)
1674 -   {
1675 -      return(-2);
1676 -   }
1677 -
1678 -#ifndef _WIN32
1679 -   if (sizeof(inaddr.sin_port) == sizeof(short))
1680 -#endif /* ndef _WIN32 */
1681 -   {
1682 -      inaddr.sin_port = htons((unsigned short) portnum);
1683 -   }
1684 -#ifndef _WIN32
1685 -   else
1686 -   {
1687 -      inaddr.sin_port = htonl((unsigned long) portnum);
1688 -   }
1689 -#endif /* ndef _WIN32 */
1690 +   fd = JB_INVALID_SOCKET;
1691
1692 -   fd = socket(AF_INET, SOCK_STREAM, 0);
1693 +   fd = socket(addr->sa_family, SOCK_STREAM, 6);
1694
1695  #ifdef _WIN32
1696     if (fd == JB_INVALID_SOCKET)
1697 @@ -645,8 +678,17 @@
1698      */
1699     setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *)&one, sizeof(one));
1700  #endif /* ndef _WIN32 */
1701 -
1702 -   if (bind(fd, (struct sockaddr *)&inaddr, sizeof(inaddr)) < 0)
1703 +   /* As we are now listening on more than one socket,
1704 +    * this is important: The only way to be sure accept
1705 +    * won't block!!
1706 +    */
1707 +   if ((flags = fcntl(fd, F_GETFL, 0)) != -1)
1708 +   {
1709 +      flags |= O_NONBLOCK;
1710 +      fcntl(fd, F_SETFL, flags);
1711 +   }
1712 +
1713 +   if (bind (fd, addr, addr_len) < 0)
1714     {
1715  #ifdef _WIN32
1716        errno = WSAGetLastError();
1717 @@ -665,7 +707,7 @@
1718        }
1719     }
1720
1721 -   while (listen(fd, 5) == -1)
1722 +   while (listen(fd, 25) == -1)
1723     {
1724        if (errno != EINTR)
1725        {
1726 @@ -673,7 +715,11 @@
1727        }
1728     }
1729
1730 -   *pfd = fd;
1731 +   if (jb_socket_set_add(fds,fd) != 0)
1732 +   {
1733 +      close_socket(fd);
1734 +      return -2;
1735 +   }
1736     return 0;
1737
1738  }
1739 @@ -681,6 +727,91 @@
1740
1741  /*********************************************************************
1742   *
1743 + * Function    :  bind_port
1744 + *
1745 + * Description :  Call bind_port_one_ip on all addresses host resolves to
1746 + *                Called by listen_loop to "boot up" our proxy address.
1747 + *
1748 + * Parameters  :
1749 + *          0  :  host = TCP/IP hostname to bind/listen to
1750 + *          1  :  port = port to listen to, as string
1751 + *          2  :  fds = socket set the sockets should be added to
1752 + *
1753 + * Returns     :  if success on at least one address resolving from hostnam,
1754 + *                 returns 0 and adds sockets to fds.
1755 + *                if failure, returns non-zero
1756 + *********************************************************************/
1757 +int bind_port(const char *host, const char *port, int pf, jb_socket_set *fds)
1758 +{
1759 +   int result;
1760 +   int failure = 1;
1761 +   struct sockaddr_storage addr;
1762 +   struct sockaddr * const addr_addr = (struct sockaddr *)&addr;
1763 +   addr_list *addrs, *addrs_to_try;
1764 +
1765 +   const char * const log_host = (host != NULL) ? host : "ADDR_ANY";
1766 +
1767 +   addrs = resolve_hostname_to_ip(host,port,pf);
1768 +
1769 +   if (is_nil_addr_list(addrs))
1770 +      log_error(LOG_LEVEL_ERROR, "can't bind to %s:%s: "
1771 +                "Name resolution didn't give any address",
1772 +                log_host, port);
1773 +
1774 +   log_error(LOG_LEVEL_INFO, "Binding to %s:%s...",  log_host, port);
1775 +
1776 +   for(addrs_to_try=addrs;
1777 +       !is_nil_addr_list(addrs_to_try);
1778 +       addrs_to_try = tail_addr_list(addrs_to_try))
1779 +   {
1780 +      char numeric_hostname[NI_MAXHOST];
1781 +      char numeric_port[NI_MAXSERV];
1782 +      size_t addrlen;
1783 +      memset((char *)addr_addr, 0, sizeof addr);
1784 +      cpy_head_addr_list(addrs_to_try, &addr, &addrlen);
1785 +      result = getnameinfo(addr_addr, addrlen, numeric_hostname, NI_MAXHOST,
1786 +                           numeric_port, NI_MAXSERV, NI_NUMERICHOST | NI_NUMERICSERV);
1787 +      if (result != 0)
1788 +      {
1789 +         log_error(LOG_LEVEL_ERROR, "bind: Could not get string address and port back from sockaddr because %E");
1790 +         strncpy(numeric_hostname,"unknown",NI_MAXHOST);
1791 +         strncpy(numeric_port,"unknown",NI_MAXSERV);
1792 +      }
1793 +      result = bind_port_one_ip(addr_addr, addrlen, fds);
1794 +      if( result == 0 )
1795 +      {
1796 +         failure = 0;
1797 +         log_error(LOG_LEVEL_INFO, "Successfully bound to %s:%s", numeric_hostname, numeric_port);
1798 +      }
1799 +      else
1800 +      {
1801 +         switch(result)
1802 +         {
1803 +         case -3 :
1804 +            log_error(LOG_LEVEL_ERROR, "can't bind to %s:%s (%s:%s): "
1805 +                      "There may be another Privoxy or some other "
1806 +                      "proxy running on port %s",
1807 +                      log_host, port, numeric_hostname, numeric_port, numeric_port);
1808 +            break;
1809 +         case -2 :
1810 +            log_error(LOG_LEVEL_ERROR, "can't bind to %s:%s (%s:%s): "
1811 +                      "Out of memory",
1812 +                      log_host, port, numeric_hostname, numeric_port);
1813 +            break;
1814 +         default :
1815 +            log_error(LOG_LEVEL_ERROR, "can't bind to %s:%s: because %E",
1816 +                      log_host, numeric_port);
1817 +         }
1818 +      }
1819 +   }
1820 +
1821 +   destroy_addr_list(addrs);
1822 +   return failure;
1823 +}
1824 +
1825 +
1826 +/*********************************************************************
1827 + *
1828   * Function    :  accept_connection
1829   *
1830   * Description :  Accepts a connection on a socket.  Socket must have
1831 @@ -697,8 +828,7 @@
1832   *********************************************************************/
1833  int accept_connection(struct client_state * csp, jb_socket fd)
1834  {
1835 -   struct sockaddr_in client, server;
1836 -   struct hostent *host = NULL;
1837 +   struct sockaddr_storage client, server;
1838     jb_socket afd;
1839  #if defined(_WIN32) || defined(__OS2__) || defined(__APPLE_CC__) || defined(AMIGA)
1840     /* Wierdness - fix a warning. */
1841 @@ -706,15 +836,7 @@
1842  #else
1843     socklen_t c_length, s_length;
1844  #endif
1845 -#if defined(HAVE_GETHOSTBYADDR_R_8_ARGS) ||  defined(HAVE_GETHOSTBYADDR_R_7_ARGS) || defined(HAVE_GETHOSTBYADDR_R_5_ARGS)
1846 -   struct hostent result;
1847 -#if defined(HAVE_GETHOSTBYADDR_R_5_ARGS)
1848 -   struct hostent_data hdata;
1849 -#else
1850 -   char hbuf[HOSTENT_BUFFER_SIZE];
1851 -   int thd_err;
1852 -#endif /* def HAVE_GETHOSTBYADDR_R_5_ARGS */
1853 -#endif /* def HAVE_GETHOSTBYADDR_R_(8|7|5)_ARGS */
1854 +   int flags;
1855
1856     c_length = s_length = sizeof(client);
1857
1858 @@ -734,6 +856,12 @@
1859        return 0;
1860     }
1861  #endif
1862 +   /* If we inherited O_NONBLOCK from the listening fd, unset it */
1863 +   if ((flags = fcntl(fd, F_GETFL, 0)) != -1)
1864 +   {
1865 +      flags &= ~O_NONBLOCK;
1866 +      fcntl(fd, F_SETFL, flags);
1867 +   }
1868
1869     /*
1870      * Determine the IP-Adress that the client used to reach us
1871 @@ -741,49 +869,50 @@
1872      */
1873     if (!getsockname(afd, (struct sockaddr *) &server, &s_length))
1874     {
1875 -      csp->my_ip_addr_str = strdup(inet_ntoa(server.sin_addr));
1876 -#if defined(HAVE_GETHOSTBYADDR_R_8_ARGS)
1877 -      gethostbyaddr_r((const char *)&server.sin_addr,
1878 -                      sizeof(server.sin_addr), AF_INET,
1879 -                      &result, hbuf, HOSTENT_BUFFER_SIZE,
1880 -                      &host, &thd_err);
1881 -#elif defined(HAVE_GETHOSTBYADDR_R_7_ARGS)
1882 -      host = gethostbyaddr_r((const char *)&server.sin_addr,
1883 -                      sizeof(server.sin_addr), AF_INET,
1884 -                      &result, hbuf, HOSTENT_BUFFER_SIZE, &thd_err);
1885 -#elif defined(HAVE_GETHOSTBYADDR_R_5_ARGS)
1886 -      if (0 == gethostbyaddr_r((const char *)&server.sin_addr,
1887 -                               sizeof(server.sin_addr), AF_INET,
1888 -                               &result, &hdata))
1889 +      char hostname[NI_MAXHOST];
1890 +      char port[NI_MAXSERV];
1891 +
1892 +      if (getnameinfo((struct sockaddr *)&server, s_length, hostname, NI_MAXHOST,
1893 +                      port, NI_MAXSERV, NI_NUMERICHOST | NI_NUMERICSERV) != 0)
1894        {
1895 -         host = &result;
1896 +         log_error(LOG_LEVEL_ERROR, "accept: Could not get string address and port back from server sockaddr because %E");
1897 +         strncpy(hostname,"unknown IP",NI_MAXHOST);
1898 +         strncpy(port,"unknown port",NI_MAXSERV);
1899        }
1900 -      else
1901 +      csp->my_ip_addr_str = strdup(hostname);
1902 +      csp->my_port_str = strdup(port);
1903 +
1904 +      if (getnameinfo((struct sockaddr *)&server, s_length, hostname, NI_MAXHOST, NULL, 0, NI_NAMEREQD) != 0)
1905        {
1906 -         host = NULL;
1907 +         log_error(LOG_LEVEL_ERROR, "accept: Could not get my own hostname because %E");
1908 +         strncpy(hostname,"unknown host",NI_MAXHOST);
1909        }
1910 -#elif FEATURE_PTHREAD
1911 -      pthread_mutex_lock(&gethostbyaddr_mutex);
1912 -      host = gethostbyaddr((const char *)&server.sin_addr,
1913 -                           sizeof(server.sin_addr), AF_INET);
1914 -      pthread_mutex_unlock(&gethostbyaddr_mutex);
1915 -#else
1916 -      host = gethostbyaddr((const char *)&server.sin_addr,
1917 -                           sizeof(server.sin_addr), AF_INET);
1918 -#endif
1919 -      if (host == NULL)
1920 +      csp->my_hostname = strdup(hostname);
1921 +   }
1922 +   else
1923 +   {
1924 +      log_error(LOG_LEVEL_ERROR, "accept: Could not get sockaddr from socket fd because %E");
1925 +   }
1926 +
1927 +   csp->cfd    = afd;
1928 +   {
1929 +      char hostname[NI_MAXHOST];
1930 +
1931 +      if (getnameinfo((struct sockaddr *)&client, c_length, hostname, NI_MAXHOST, NULL, 0, NI_NUMERICHOST) != 0)
1932        {
1933 -         log_error(LOG_LEVEL_ERROR, "Unable to get my own hostname: %E\n");
1934 +         log_error(LOG_LEVEL_ERROR, "accept: Could not get client IP address string because %E");
1935 +         strncpy(hostname,"unknown IP",NI_MAXHOST);
1936        }
1937 -      else
1938 +      csp->my_ip_addr_str = strdup(hostname);
1939 +
1940 +      if (getnameinfo((struct sockaddr *)&server, s_length, hostname, NI_MAXHOST, NULL, 0, 0) != 0)
1941        {
1942 -         csp->my_hostname = strdup(host->h_name);
1943 +         log_error(LOG_LEVEL_ERROR, "accept: Could not get my own hostname because %E");
1944 +         strncpy(hostname,"unknown host",NI_MAXHOST);
1945        }
1946 +      csp->ip_addr_str = strdup(hostname);
1947     }
1948 -
1949 -   csp->cfd    = afd;
1950 -   csp->ip_addr_str  = strdup(inet_ntoa(client.sin_addr));
1951 -   csp->ip_addr_long = ntohl(client.sin_addr.s_addr);
1952 +   csp->ip_addr_addr = client;
1953
1954     return 1;
1955
1956 @@ -794,108 +923,48 @@
1957   *
1958   * Function    :  resolve_hostname_to_ip
1959   *
1960 - * Description :  Resolve a hostname to an internet tcp/ip address.
1961 - *                NULL or an empty string resolve to INADDR_ANY.
1962 + * Description :  Resolve a hostname to a list of internet tcp/ip addresses.
1963   *
1964   * Parameters  :
1965 - *          1  :  host = hostname to resolve
1966 + *          0  :  host = hostname to resolve
1967 + *          1  :  result = where to store the result
1968 + *          2  :  pf = preferred address family. PF_UNSPEC for no preference (recommended).
1969   *
1970 - * Returns     :  INADDR_NONE => failure, INADDR_ANY or tcp/ip address if succesful.
1971 + * Returns     :  A (possibly empty) list of adresses
1972   *
1973   *********************************************************************/
1974 -unsigned long resolve_hostname_to_ip(const char *host)
1975 -{
1976 -   struct sockaddr_in inaddr;
1977 -   struct hostent *hostp;
1978 +addr_list *resolve_hostname_to_ip(const char *host, const char *port, int pf)
1979 + {
1980 +   /* TODO
1981 +    * Do all supported platforms have "getaddrinfo"?
1982 +    */
1983 +
1984 +   struct addrinfo hints, *res0;
1985 +   int result;
1986     unsigned int dns_retries = 0;
1987 -#if defined(HAVE_GETHOSTBYNAME_R_6_ARGS) || defined(HAVE_GETHOSTBYNAME_R_5_ARGS) || defined(HAVE_GETHOSTBYNAME_R_3_ARGS)
1988 -   struct hostent result;
1989 -#if defined(HAVE_GETHOSTBYNAME_R_6_ARGS) || defined(HAVE_GETHOSTBYNAME_R_5_ARGS)
1990 -   char hbuf[HOSTENT_BUFFER_SIZE];
1991 -   int thd_err;
1992 -#else /* defined(HAVE_GETHOSTBYNAME_R_3_ARGS) */
1993 -   struct hostent_data hdata;
1994 -#endif /* def HAVE_GETHOSTBYNAME_R_(6|5)_ARGS */
1995 -#endif /* def HAVE_GETHOSTBYNAME_R_(6|5|3)_ARGS */
1996
1997 -   if ((host == NULL) || (*host == '\0'))
1998 -   {
1999 -      return(INADDR_ANY);
2000 -   }
2001 -
2002 -   memset((char *) &inaddr, 0, sizeof inaddr);
2003 -
2004 -   if ((inaddr.sin_addr.s_addr = inet_addr(host)) == -1)
2005 -   {
2006 -#if defined(HAVE_GETHOSTBYNAME_R_6_ARGS)
2007 -       while ( gethostbyname_r(host, &result, hbuf,
2008 -                      HOSTENT_BUFFER_SIZE, &hostp, &thd_err)
2009 -               && (thd_err == TRY_AGAIN) && (dns_retries++ < 10) )
2010 -      {
2011 -         log_error(LOG_LEVEL_ERROR, "Timeout #%u while trying to resolve %s. Trying again.",
2012 -                                                dns_retries, host);
2013 -      }
2014 -#elif defined(HAVE_GETHOSTBYNAME_R_5_ARGS)
2015 -      hostp = gethostbyname_r(host, &result, hbuf,
2016 -                      HOSTENT_BUFFER_SIZE, &thd_err);
2017 -#elif defined(HAVE_GETHOSTBYNAME_R_3_ARGS)
2018 -      if (0 == gethostbyname_r(host, &result, &hdata))
2019 -      {
2020 -         hostp = &result;
2021 -      }
2022 -      else
2023 -      {
2024 -         hostp = NULL;
2025 -      }
2026 -#elif FEATURE_PTHREAD
2027 -      pthread_mutex_lock(&gethostbyname_mutex);
2028 -      while ( NULL == (hostp = gethostbyname(host))
2029 -            && (h_errno == TRY_AGAIN) && (dns_retries++ < 10) )
2030 -      {
2031 -         log_error(LOG_LEVEL_ERROR, "Timeout #%u while trying to resolve %s. Trying again.",
2032 -                                                dns_retries, host);
2033 -      }
2034 -      pthread_mutex_unlock(&gethostbyname_mutex);
2035 -#else
2036 -      while ( NULL == (hostp = gethostbyname(host))
2037 -            && (h_errno == TRY_AGAIN) && (dns_retries++ < 10) )
2038 -      {
2039 -         log_error(LOG_LEVEL_ERROR, "Timeout #%u while trying to resolve %s. Trying again.",
2040 -                                                dns_retries, host);
2041 -      }
2042 -#endif /* def HAVE_GETHOSTBYNAME_R_(6|5|3)_ARGS */
2043 -      /*
2044 -       * On Mac OSX, if a domain exists but doesn't have a type A
2045 -       * record associated with it, the h_addr member of the struct
2046 -       * hostent returned by gethostbyname is NULL, even if h_length
2047 -       * is 4. Therefore the second test below.
2048 -       */
2049 -      if (hostp == NULL || hostp->h_addr == NULL)
2050 -      {
2051 -         errno = EINVAL;
2052 -         log_error(LOG_LEVEL_ERROR, "could not resolve hostname %s", host);
2053 -         return(INADDR_NONE);
2054 -      }
2055 -      if (hostp->h_addrtype != AF_INET)
2056 -      {
2057 -#ifdef _WIN32
2058 -         errno = WSAEPROTOTYPE;
2059 -#else
2060 -         errno = EPROTOTYPE;
2061 -#endif
2062 -         log_error(LOG_LEVEL_ERROR, "hostname %s resolves to unknown address type.", host);
2063 -         return(INADDR_NONE);
2064 -      }
2065 -      memcpy(
2066 -         (char *) &inaddr.sin_addr,
2067 -         (char *) hostp->h_addr,
2068 -         sizeof(inaddr.sin_addr)
2069 -      );
2070 +   memset(&hints, 0, sizeof(hints));
2071 +   hints.ai_family = pf;
2072 +   hints.ai_socktype = SOCK_STREAM;
2073 +
2074 +   while ((result = getaddrinfo(host, port, &hints, &res0))
2075 +          && (result == EAI_AGAIN) && (dns_retries++ < 10)) {
2076 +      log_error(LOG_LEVEL_ERROR, "Timeout #%u while trying to resolve %s. Trying again.",
2077 +                dns_retries, host);
2078     }
2079 -   return(inaddr.sin_addr.s_addr);
2080 -
2081 -}
2082 -
2083 +   if ( result != 0 )
2084 +     {
2085 +      log_error(LOG_LEVEL_ERROR, "could not resolve hostname %s because %s", host,gai_strerror(result));
2086 +      if (result == EAI_SYSTEM)
2087 +         log_error(LOG_LEVEL_ERROR, "The system error is %E");
2088 +      return NULL;
2089 +     }
2090 +   else
2091 +      if (res0==0)
2092 +         log_error(LOG_LEVEL_ERROR, "Problem in resolving hostname %s: succeeded, but no information returned", host);
2093 +
2094 +   return res0;
2095 + }
2096
2097  /*
2098    Local Variables:
2099 diff -urNad privoxy~/jbsockets.h privoxy/jbsockets.h
2100 --- privoxy~/jbsockets.h
2101 +++ privoxy/jbsockets.h
2102 @@ -13,6 +13,9 @@
2103   * Copyright   :  Written by and Copyright (C) 2001 the SourceForge
2104   *                Privoxy team. http://www.privoxy.org/
2105   *
2106 + *                Modified by Lionel Elie Mamane <lionel@mamane.lu>
2107 + *                for IPv6 support on 8 December 2002, 24 January 2003.
2108 + *
2109   *                Based on the Internet Junkbuster originally written
2110   *                by and Copyright (C) 1997 Anonymous Coders and
2111   *                Junkbusters Corporation.  http://www.junkbusters.com
2112 @@ -104,9 +107,11 @@
2113  extern "C" {
2114  #endif
2115
2116 +#include "addrlist.h"
2117 +
2118  struct client_state;
2119
2120 -extern jb_socket connect_to(const char *host, int portnum, struct client_state *csp);
2121 +extern jb_socket connect_to(const char *host, const char *port, unsigned long portnum, int pf, struct client_state *csp);
2122  #ifdef AMIGA
2123  extern int write_socket(jb_socket fd, const char *buf, ssize_t n);
2124  #else
2125 @@ -115,10 +120,10 @@
2126  extern int read_socket(jb_socket fd, char *buf, int n);
2127  extern void close_socket(jb_socket fd);
2128
2129 -extern int bind_port(const char *hostnam, int portnum, jb_socket *pfd);
2130 +extern int bind_port(const char *host, const char *port, int pf, jb_socket_set *fds);
2131  extern int accept_connection(struct client_state * csp, jb_socket fd);
2132
2133 -extern unsigned long resolve_hostname_to_ip(const char *host);
2134 +extern addr_list *resolve_hostname_to_ip(const char *host, const char *port, int pf);
2135
2136  /* Revision control strings from this header and associated .c file */
2137  extern const char jbsockets_rcs[];
2138 diff -urNad privoxy~/jcc.c privoxy/jcc.c
2139 --- privoxy~/jcc.c
2140 +++ privoxy/jcc.c
2141 @@ -767,6 +767,7 @@
2142  #include "cgi.h"
2143  #include "loadcfg.h"
2144  #include "urlmatch.h"
2145 +#include "jb_socket_set.h"
2146
2147  const char jcc_h_rcs[] = JCC_H_VERSION;
2148  const char project_h_rcs[] = PROJECT_H_VERSION;
2149 @@ -2338,61 +2339,78 @@
2150   * Returns     :  Port that was opened.
2151   *
2152   *********************************************************************/
2153 -static jb_socket bind_port_helper(struct configuration_spec * config)
2154 +static void bind_port_helper(struct configuration_spec * config, jb_socket_set *bfds)
2155  {
2156     int result;
2157 -   jb_socket bfd;
2158 +   struct bind_spec *bs;
2159 +   unsigned int bs_index;
2160 +   int never_bound;
2161
2162 -   if ( (config->haddr != NULL)
2163 -     && (config->haddr[0] == '1')
2164 -     && (config->haddr[1] == '2')
2165 -     && (config->haddr[2] == '7')
2166 -     && (config->haddr[3] == '.') )
2167 -   {
2168 -      log_error(LOG_LEVEL_INFO, "Listening on port %d for local connections only",
2169 -                config->hport);
2170 -   }
2171 -   else if (config->haddr == NULL)
2172 -   {
2173 -      log_error(LOG_LEVEL_INFO, "Listening on port %d on all IP addresses",
2174 -                config->hport);
2175 -   }
2176 -   else
2177 +   never_bound = 1;
2178 +   for (bs_index = 0; bs_index < config->hspecs_occupied;++bs_index)
2179     {
2180 -      log_error(LOG_LEVEL_INFO, "Listening on port %d on IP address %s",
2181 -                config->hport, config->haddr);
2182 -   }
2183 +      bs = &config->hspecs[bs_index];
2184 +
2185 +      /* This check misses about a trillion zillion different manners to describe
2186 +         the local interface in IPv6. Who cares? */
2187 +      if ( (bs->haddr != NULL)
2188 +           && (((bs->haddr[0] == '1')
2189 +                && (bs->haddr[1] == '2')
2190 +                && (bs->haddr[2] == '7')
2191 +                && (bs->haddr[3] == '.'))
2192 +               || ((bs->haddr[0] == ':')
2193 +                   && (bs->haddr[1] == ':')
2194 +                   && (bs->haddr[2] == '1'))))
2195 +      {
2196 +         log_error(LOG_LEVEL_INFO, "Listening on port %s for local connections only",
2197 +                   bs->hport);
2198 +      }
2199 +      else if (bs->haddr == NULL || bs->haddr[0]=='\0')
2200 +      {
2201 +         log_error(LOG_LEVEL_INFO, "Listening on port %s on all IP addresses",
2202 +                   bs->hport);
2203 +      }
2204 +      else
2205 +      {
2206 +         log_error(LOG_LEVEL_INFO, "Listening on port %s on IP address %s",
2207 +                   bs->hport, bs->haddr);
2208 +      }
2209
2210 -   result = bind_port(config->haddr, config->hport, &bfd);
2211 +      result = bind_port(bs->haddr, bs->hport, bs->pf, bfds);
2212
2213 -   if (result < 0)
2214 -   {
2215 -      switch(result)
2216 +      if (result != 0)
2217        {
2218 +         switch(result)
2219 +         {
2220           case -3 :
2221 -            log_error(LOG_LEVEL_FATAL, "can't bind to %s:%d: "
2222 +            log_error(LOG_LEVEL_ERROR, "can't bind to %s:%s: "
2223                 "There may be another Privoxy or some other "
2224 -               "proxy running on port %d",
2225 -               (NULL != config->haddr) ? config->haddr : "INADDR_ANY",
2226 -                      config->hport, config->hport);
2227 +               "proxy running on port %s",
2228 +               (NULL != bs->haddr) ? bs->haddr : "INADDR_ANY",
2229 +                      bs->hport, bs->hport);
2230 +            break;
2231
2232           case -2 :
2233 -            log_error(LOG_LEVEL_FATAL, "can't bind to %s:%d: "
2234 +            log_error(LOG_LEVEL_ERROR, "can't bind to %s:%s: "
2235                 "The hostname is not resolvable",
2236 -               (NULL != config->haddr) ? config->haddr : "INADDR_ANY", config->hport);
2237 +               (NULL != bs->haddr) ? bs->haddr : "INADDR_ANY", bs->hport);
2238 +            break;
2239
2240           default :
2241 -            log_error(LOG_LEVEL_FATAL, "can't bind to %s:%d: because %E",
2242 -               (NULL != config->haddr) ? config->haddr : "INADDR_ANY", config->hport);
2243 +            log_error(LOG_LEVEL_ERROR, "can't bind to %s:%s: because %E",
2244 +               (NULL != bs->haddr) ? bs->haddr : "INADDR_ANY", bs->hport);
2245 +         }
2246        }
2247 +      else
2248 +         never_bound = 0;
2249 +   }
2250
2251 +   if(never_bound)
2252 +   {
2253 +      log_error(LOG_LEVEL_FATAL, "Couldn't bind at all - bailing out");
2254        /* shouldn't get here */
2255 -      return JB_INVALID_SOCKET;
2256     }
2257 -
2258     config->need_bind = 0;
2259 -
2260 -   return bfd;
2261  }
2262
2263
2264 @@ -2421,12 +2439,18 @@
2265  static void listen_loop(void)
2266  {
2267     struct client_state *csp = NULL;
2268 -   jb_socket bfd;
2269 +   jb_socket_set bfds;
2270 +   fd_set bfds_fs;
2271 +   jb_socket_set_iterate_state bfds_iterate_state;
2272 +   jb_socket bfd_current;
2273     struct configuration_spec * config;
2274
2275 +   init_jb_socket_set(&bfds);
2276 +
2277     config = load_config();
2278
2279 -   bfd = bind_port_helper(config);
2280 +   bind_port_helper(config,&bfds);
2281 +   bfd_current=JB_INVALID_SOCKET;
2282
2283  #ifdef FEATURE_GRACEFUL_TERMINATION
2284     while (!g_terminate)
2285 @@ -2500,14 +2524,55 @@
2286            * that this will hurt people's feelings.
2287            */
2288
2289 -         close_socket(bfd);
2290 +         jb_socket_set_iterate_state s;
2291 +         jb_socket bfd;
2292 +         s=jb_socket_set_iteration_begin(&bfds);
2293 +         for(bfd=jb_socket_set_iteration_next(&s);bfd!=JB_INVALID_SOCKET;bfd=jb_socket_set_iteration_next(&s))
2294 +         {
2295 +            close_socket(bfd);
2296 +         }
2297 +         destroy_jb_socket_set(&bfds);
2298 +         bind_port_helper(config,&bfds);
2299 +         /* We have a new set of fd's to accept. Restart iteration over bfds. */
2300 +         bfd_current = JB_INVALID_SOCKET;
2301 +      }
2302
2303 -         bfd = bind_port_helper(config);
2304 +      /* Here: select call on listening sockets: bfd=sockets */
2305 +      if (bfd_current == JB_INVALID_SOCKET)
2306 +      {
2307 +         jb_socket max;
2308 +         log_error(LOG_LEVEL_CONNECT, "select connections ... ");
2309 +         bfds_iterate_state=jb_socket_set_iteration_begin(&bfds);
2310 +         FD_ZERO(&bfds_fs);
2311 +         max = 0;
2312 +         for(bfd_current=jb_socket_set_iteration_next(&bfds_iterate_state);
2313 +             bfd_current!=JB_INVALID_SOCKET;
2314 +             bfd_current=jb_socket_set_iteration_next(&bfds_iterate_state))
2315 +         {
2316 +            FD_SET(bfd_current,&bfds_fs);
2317 +            if (bfd_current >= max)
2318 +               max = bfd_current + 1;
2319 +         }
2320 +         if(!select(max,&bfds_fs,NULL,NULL,NULL))
2321 +         {
2322 +            log_error(LOG_LEVEL_CONNECT, "select failed: %E");
2323 +            bfd_current=JB_INVALID_SOCKET;
2324 +            continue;
2325 +         }
2326 +         log_error(LOG_LEVEL_CONNECT, "OK");
2327 +         bfds_iterate_state=jb_socket_set_iteration_begin(&bfds);
2328 +         bfd_current=jb_socket_set_iteration_next(&bfds_iterate_state);
2329 +      }
2330 +      if (!FD_ISSET(bfd_current,&bfds_fs))
2331 +      {
2332 +         bfd_current=jb_socket_set_iteration_next(&bfds_iterate_state);
2333 +         freez(csp);
2334 +         continue;
2335        }
2336
2337        log_error(LOG_LEVEL_CONNECT, "accept connection ... ");
2338
2339 -      if (!accept_connection(csp, bfd))
2340 +      if (!accept_connection(csp, bfd_current))
2341        {
2342           log_error(LOG_LEVEL_CONNECT, "accept failed: %E");
2343
2344 @@ -2525,6 +2590,8 @@
2345           log_error(LOG_LEVEL_CONNECT, "OK");
2346        }
2347
2348 +      bfd_current=jb_socket_set_iteration_next(&bfds_iterate_state);
2349 +
2350  #ifdef FEATURE_TOGGLE
2351        if (global_toggle_state)
2352        {
2353 diff -urNad privoxy~/loadcfg.c privoxy/loadcfg.c
2354 --- privoxy~/loadcfg.c
2355 +++ privoxy/loadcfg.c
2356 @@ -11,6 +11,9 @@
2357   * Copyright   :  Written by and Copyright (C) 2001 the SourceForge
2358   *                Privoxy team. http://www.privoxy.org/
2359   *
2360 + *                Modified by Lionel Elie Mamane <lionel@mamane.lu>
2361 + *                for IPv6 support on 8 December 2002, 24 January 2003.
2362 + *
2363   *                Based on the Internet Junkbuster originally written
2364   *                by and Copyright (C) 1997 Anonymous Coders and
2365   *                Junkbusters Corporation.  http://www.junkbusters.com
2366 @@ -408,6 +411,7 @@
2367  #include "encode.h"
2368  #include "urlmatch.h"
2369  #include "cgi.h"
2370 +#include "parsers.h"
2371
2372  const char loadcfg_h_rcs[] = LOADCFG_H_VERSION;
2373
2374 @@ -527,8 +531,8 @@
2375        struct forward_spec * next_fwd = cur_fwd->next;
2376        free_url_spec(cur_fwd->url);
2377
2378 -      freez(cur_fwd->gateway_host);
2379 -      freez(cur_fwd->forward_host);
2380 +      freez(cur_fwd->gateway_malloc);
2381 +      freez(cur_fwd->forward_malloc);
2382        free(cur_fwd);
2383        cur_fwd = next_fwd;
2384     }
2385 @@ -545,7 +549,16 @@
2386     freez(config->confdir);
2387     freez(config->logdir);
2388
2389 -   freez(config->haddr);
2390 +   if(config -> hspecs != NULL)
2391 +   {
2392 +      int i;
2393 +      for (i=0; i < config->hspecs_occupied; ++i)
2394 +      {
2395 +         freez(config->hspecs[i].haddr);
2396 +         freez(config->hspecs[i].hport);
2397 +      }
2398 +   }
2399 +   freez(config->hspecs);
2400     freez(config->logfile);
2401
2402     for (i = 0; i < MAX_AF_FILES; i++)
2403 @@ -612,6 +625,28 @@
2404   * Returns     :  The configuration_spec, or NULL on error.
2405   *
2406   *********************************************************************/
2407 +static void fail_load_config_memory(struct file_list *fs, struct configuration_spec *config)
2408 +{
2409 +   freez(fs->filename);
2410 +   freez(fs);
2411 +   if (config != NULL)
2412 +   {
2413 +      if(config -> hspecs != NULL)
2414 +      {
2415 +         int i;
2416 +         for (i=0; i < config->hspecs_occupied; ++i)
2417 +         {
2418 +            freez(config->hspecs[i].haddr);
2419 +            freez(config->hspecs[i].hport);
2420 +         }
2421 +      }
2422 +      freez(config -> hspecs);
2423 +   }
2424 +   freez(config);
2425 +   log_error(LOG_LEVEL_FATAL, "can't allocate memory for configuration");
2426 +   /* Never get here - LOG_LEVEL_FATAL causes program exit */
2427 +}
2428 +
2429  struct configuration_spec * load_config(void)
2430  {
2431     char buf[BUFFER_SIZE];
2432 @@ -643,12 +678,7 @@
2433     fs->f = config = (struct configuration_spec *)zalloc(sizeof(*config));
2434
2435     if (config==NULL)
2436 -   {
2437 -      freez(fs->filename);
2438 -      freez(fs);
2439 -      log_error(LOG_LEVEL_FATAL, "can't allocate memory for configuration");
2440 -      /* Never get here - LOG_LEVEL_FATAL causes program exit */
2441 -   }
2442 +      fail_load_config_memory(fs,config);
2443
2444     /*
2445      * This is backwards from how it's usually done.
2446 @@ -665,7 +695,7 @@
2447      * Set to defaults
2448      */
2449     config->multi_threaded            = 1;
2450 -   config->hport                     = HADDR_PORT;
2451 +   config->hspecs                    = NULL;
2452     config->buffer_limit              = 4096 * 1024;
2453     config->usermanual                = strdup(USER_MANUAL_URL);
2454     config->proxy_args                = strdup("");
2455 @@ -684,9 +714,6 @@
2456        char cmd[BUFFER_SIZE];
2457        char arg[BUFFER_SIZE];
2458        char tmp[BUFFER_SIZE];
2459 -#ifdef FEATURE_ACL
2460 -      struct access_control_list *cur_acl;
2461 -#endif /* def FEATURE_ACL */
2462        struct forward_spec *cur_fwd;
2463        int vec_count;
2464        char *vec[3];
2465 @@ -797,74 +824,23 @@
2466   * *************************************************************************/
2467  #ifdef FEATURE_ACL
2468           case hash_deny_access:
2469 -            vec_count = ssplit(arg, " \t", vec, SZ(vec), 1, 1);
2470 -
2471 -            if ((vec_count != 1) && (vec_count != 2))
2472 -            {
2473 -               log_error(LOG_LEVEL_ERROR, "Wrong number of parameters for "
2474 -                     "deny-access directive in configuration file.");
2475 -               string_append(&config->proxy_args,
2476 -                  "<br>\nWARNING: Wrong number of parameters for "
2477 -                  "deny-access directive in configuration file.<br><br>\n");
2478 -               continue;
2479 -            }
2480 -
2481 -            /* allocate a new node */
2482 -            cur_acl = (struct access_control_list *) zalloc(sizeof(*cur_acl));
2483 -
2484 -            if (cur_acl == NULL)
2485 -            {
2486 -               log_error(LOG_LEVEL_FATAL, "can't allocate memory for configuration");
2487 -               /* Never get here - LOG_LEVEL_FATAL causes program exit */
2488 -               continue;
2489 -            }
2490 -            cur_acl->action = ACL_DENY;
2491 -
2492 -            if (acl_addr(vec[0], cur_acl->src) < 0)
2493 -            {
2494 -               log_error(LOG_LEVEL_ERROR, "Invalid source IP for deny-access "
2495 -                     "directive in configuration file: \"%s\"", vec[0]);
2496 -               string_append(&config->proxy_args,
2497 -                  "<br>\nWARNING: Invalid source IP for deny-access directive"
2498 -                  " in configuration file: \"");
2499 -               string_append(&config->proxy_args,
2500 -                  vec[0]);
2501 -               string_append(&config->proxy_args,
2502 -                  "\"<br><br>\n");
2503 -               freez(cur_acl);
2504 -               continue;
2505 -            }
2506 -            if (vec_count == 2)
2507 +            switch (ssplit(arg, " \t", vec, SZ(vec), 1, 1))
2508              {
2509 -               if (acl_addr(vec[1], cur_acl->dst) < 0)
2510 -               {
2511 -                  log_error(LOG_LEVEL_ERROR, "Invalid destination IP for deny-access "
2512 -                        "directive in configuration file: \"%s\"", vec[0]);
2513 -                  string_append(&config->proxy_args,
2514 -                     "<br>\nWARNING: Invalid destination IP for deny-access directive"
2515 -                     " in configuration file: \"");
2516 -                  string_append(&config->proxy_args,
2517 -                     vec[0]);
2518 +               case 1:
2519 +                  config->acl = add_to_acl_list(config->acl, ACL_DENY, vec[0], NULL, &config->proxy_args);
2520 +                  break;
2521 +               case 2:
2522 +                  config->acl = add_to_acl_list(config->acl, ACL_DENY, vec[0], vec[1], &config->proxy_args);
2523 +                  break;
2524 +               default:
2525 +                  log_error(LOG_LEVEL_ERROR, "Wrong number of parameters for "
2526 +                            "deny-access directive in configuration file.");
2527                    string_append(&config->proxy_args,
2528 -                     "\"<br><br>\n");
2529 -                  freez(cur_acl);
2530 -                  continue;
2531 -               }
2532 +                                "<br>\nWARNING: Wrong number of parameters for "
2533 +                                "deny-access directive in configuration file.<br><br>\n");
2534              }
2535 -
2536 -            /*
2537 -             * Add it to the list.  Note we reverse the list to get the
2538 -             * behaviour the user expects.  With both the ACL and
2539 -             * actions file, the last match wins.  However, the internal
2540 -             * implementations are different:  The actions file is stored
2541 -             * in the same order as the file, and scanned completely.
2542 -             * With the ACL, we reverse the order as we load it, then
2543 -             * when we scan it we stop as soon as we get a match.
2544 -             */
2545 -            cur_acl->next  = config->acl;
2546 -            config->acl = cur_acl;
2547 -
2548              continue;
2549 +
2550  #endif /* def FEATURE_ACL */
2551
2552  /* *************************************************************************
2553 @@ -984,16 +960,18 @@
2554
2555              if (strcmp(p, ".") != 0)
2556              {
2557 -               cur_fwd->forward_host = strdup(p);
2558 +               cur_fwd->forward_malloc = strdup(p);
2559 +               cur_fwd->forward_family = -1;
2560
2561 -               if (NULL != (p = strchr(cur_fwd->forward_host, ':')))
2562 -               {
2563 -                  *p++ = '\0';
2564 -                  cur_fwd->forward_port = atoi(p);
2565 -               }
2566 +               parse_pf_ip(cur_fwd->forward_malloc,
2567 +                           &cur_fwd->forward_host,
2568 +                           &cur_fwd->forward_port_str,
2569 +                           &cur_fwd->forward_family);
2570 +               cur_fwd->forward_port = atoi(cur_fwd->forward_port_str);
2571
2572                 if (cur_fwd->forward_port <= 0)
2573                 {
2574 +                  cur_fwd->forward_port_str = "8000";
2575                    cur_fwd->forward_port = 8000;
2576                 }
2577              }
2578 @@ -1047,15 +1025,27 @@
2579
2580              if (strcmp(p, ".") != 0)
2581              {
2582 -               cur_fwd->gateway_host = strdup(p);
2583 +               /* SOCKS is IPv4-specific */
2584 +               int pf = PF_INET;
2585
2586 -               if (NULL != (p = strchr(cur_fwd->gateway_host, ':')))
2587 +               cur_fwd->gateway_malloc = strdup(p);
2588 +               if (parse_pf_ip(cur_fwd->gateway_malloc,
2589 +                               &cur_fwd->gateway_host,
2590 +                               &cur_fwd->gateway_port_str,
2591 +                               &pf) != 0)
2592                 {
2593 -                  *p++ = '\0';
2594 -                  cur_fwd->gateway_port = atoi(p);
2595 +                 log_error(LOG_LEVEL_ERROR, "Could not parse forward-socks4 host: %s",p);
2596 +                 cur_fwd->gateway_host = NULL;
2597 +                 cur_fwd->gateway_port_str = NULL;
2598 +                 freez(cur_fwd->gateway_malloc);
2599 +                 continue;
2600                 }
2601 +
2602 +               cur_fwd->gateway_port = atoi(cur_fwd->gateway_port_str);
2603 +
2604                 if (cur_fwd->gateway_port <= 0)
2605                 {
2606 +                  cur_fwd->gateway_port_str = "1080";
2607                    cur_fwd->gateway_port = 1080;
2608                 }
2609              }
2610 @@ -1065,16 +1055,26 @@
2611
2612              if (strcmp(p, ".") != 0)
2613              {
2614 -               cur_fwd->forward_host = strdup(p);
2615 +               cur_fwd->forward_malloc = strdup(p);
2616 +               cur_fwd->forward_family = -1;
2617
2618 -               if (NULL != (p = strchr(cur_fwd->forward_host, ':')))
2619 +               parse_pf_ip(cur_fwd->forward_malloc,
2620 +                           &cur_fwd->forward_host,
2621 +                           &cur_fwd->forward_port_str,
2622 +                           &cur_fwd->forward_family);
2623 +               cur_fwd->forward_port = atoi(cur_fwd->forward_port_str);
2624 +
2625 +               if (cur_fwd->forward_port <= 0)
2626                 {
2627 -                  *p++ = '\0';
2628 -                  cur_fwd->forward_port = atoi(p);
2629 +                  cur_fwd->forward_port_str = "8000";
2630 +                  cur_fwd->forward_port = 8000;
2631                 }
2632
2633 +               cur_fwd->forward_port = atoi(p);
2634 +
2635                 if (cur_fwd->forward_port <= 0)
2636                 {
2637 +                  cur_fwd->forward_port_str = "8000";
2638                    cur_fwd->forward_port = 8000;
2639                 }
2640              }
2641 @@ -1126,16 +1126,30 @@
2642              /* Parse the SOCKS proxy host[:port] */
2643              p = vec[1];
2644
2645 -            cur_fwd->gateway_host = strdup(p);
2646 -
2647 -            if (NULL != (p = strchr(cur_fwd->gateway_host, ':')))
2648 -            {
2649 -               *p++ = '\0';
2650 -               cur_fwd->gateway_port = atoi(p);
2651 -            }
2652 -            if (cur_fwd->gateway_port <= 0)
2653              {
2654 -               cur_fwd->gateway_port = 1080;
2655 +               /* SOCKS is IPv4-specific */
2656 +               int pf = PF_INET;
2657 +
2658 +               cur_fwd->gateway_malloc = strdup(p);
2659 +               if (parse_pf_ip(cur_fwd->gateway_malloc,
2660 +                               &cur_fwd->gateway_host,
2661 +                               &cur_fwd->gateway_port_str,
2662 +                               &pf) != 0)
2663 +               {
2664 +                 log_error(LOG_LEVEL_ERROR, "Could not parse forward-socks4a host: %s",p);
2665 +                 cur_fwd->gateway_host = NULL;
2666 +                 cur_fwd->gateway_port_str = NULL;
2667 +                 freez(cur_fwd->gateway_malloc);
2668 +                 continue;
2669 +               }
2670 +
2671 +               cur_fwd->gateway_port = atoi(cur_fwd->gateway_port_str);
2672 +
2673 +               if (cur_fwd->gateway_port <= 0)
2674 +               {
2675 +                  cur_fwd->gateway_port_str = "1080";
2676 +                  cur_fwd->gateway_port = 1080;
2677 +               }
2678              }
2679
2680              /* Parse the parent HTTP proxy host[:port] */
2681 @@ -1143,16 +1157,26 @@
2682
2683              if (strcmp(p, ".") != 0)
2684              {
2685 -               cur_fwd->forward_host = strdup(p);
2686 +               cur_fwd->forward_malloc = strdup(p);
2687 +               cur_fwd->forward_family = -1;
2688
2689 -               if (NULL != (p = strchr(cur_fwd->forward_host, ':')))
2690 +               parse_pf_ip(cur_fwd->forward_malloc,
2691 +                           &cur_fwd->forward_host,
2692 +                           &cur_fwd->forward_port_str,
2693 +                           &cur_fwd->forward_family);
2694 +               cur_fwd->forward_port = atoi(cur_fwd->forward_port_str);
2695 +
2696 +               if (cur_fwd->forward_port <= 0)
2697                 {
2698 -                  *p++ = '\0';
2699 -                  cur_fwd->forward_port = atoi(p);
2700 +                  cur_fwd->forward_port_str = "8000";
2701 +                  cur_fwd->forward_port = 8000;
2702                 }
2703
2704 +               cur_fwd->forward_port = atoi(p);
2705 +
2706                 if (cur_fwd->forward_port <= 0)
2707                 {
2708 +                  cur_fwd->forward_port_str = "8000";
2709                    cur_fwd->forward_port = 8000;
2710                 }
2711              }
2712 @@ -1185,10 +1209,49 @@
2713   * listen-address [ip][:port]
2714   * *************************************************************************/
2715           case hash_listen_address :
2716 -            freez(config->haddr);
2717 -            config->haddr = strdup(arg);
2718 +         {
2719 +            struct bind_spec *bs;
2720 +            char *arg_cpy;
2721 +            if (config->hspecs == NULL)
2722 +            {
2723 +               /* This is the first we'll bind to */
2724 +               config->hspecs = calloc(2,sizeof(struct bind_spec));
2725 +               if (config->hspecs == NULL)
2726 +                  fail_load_config_memory(fs,config);
2727 +               config->hspecs_size = 2;
2728 +               config->hspecs_occupied = 0;
2729 +            }
2730 +
2731 +            arg_cpy = strdup(arg);
2732 +            if (arg_cpy == NULL)
2733 +               fail_load_config_memory(fs,config);
2734 +            if (config->hspecs_occupied == config->hspecs_size)
2735 +              {
2736 +                struct bind_spec *new_hspecs;
2737 +                config->hspecs_size *= 2;
2738 +                new_hspecs = realloc(config->hspecs,config->hspecs_size * sizeof(struct bind_spec));
2739 +                if (new_hspecs == NULL)
2740 +                  {
2741 +                    /* Not enough memory to continue. Cancel changes. */
2742 +                    config->hspecs_size /= 2;
2743 +                    fail_load_config_memory(fs,config);
2744 +                  }
2745 +                config->hspecs = new_hspecs;
2746 +              }
2747 +            bs = &config->hspecs[(config->hspecs_occupied)++];
2748 +            bs->pf = -1;
2749 +            parse_pf_ip(arg,&bs->haddr,&bs->hport,&bs->pf);
2750 +            if (*bs->haddr == '\0')
2751 +            {
2752 +               bs->haddr = NULL;
2753 +            }
2754 +            else
2755 +            {
2756 +               (bs->haddr = strdup(bs->haddr));
2757 +            }
2758 +            bs->hport = strdup(bs->hport);
2759              continue;
2760 -
2761 +         }
2762  /* *************************************************************************
2763   * logdir directory-name
2764   * *************************************************************************/
2765 @@ -1211,75 +1274,21 @@
2766   * *************************************************************************/
2767  #ifdef FEATURE_ACL
2768           case hash_permit_access:
2769 -            vec_count = ssplit(arg, " \t", vec, SZ(vec), 1, 1);
2770 -
2771 -            if ((vec_count != 1) && (vec_count != 2))
2772 -            {
2773 -               log_error(LOG_LEVEL_ERROR, "Wrong number of parameters for "
2774 -                     "permit-access directive in configuration file.");
2775 -               string_append(&config->proxy_args,
2776 -                  "<br>\nWARNING: Wrong number of parameters for "
2777 -                  "permit-access directive in configuration file.<br><br>\n");
2778 -
2779 -               continue;
2780 -            }
2781 -
2782 -            /* allocate a new node */
2783 -            cur_acl = (struct access_control_list *) zalloc(sizeof(*cur_acl));
2784 -
2785 -            if (cur_acl == NULL)
2786 -            {
2787 -               log_error(LOG_LEVEL_FATAL, "can't allocate memory for configuration");
2788 -               /* Never get here - LOG_LEVEL_FATAL causes program exit */
2789 -               continue;
2790 -            }
2791 -            cur_acl->action = ACL_PERMIT;
2792 -
2793 -            if (acl_addr(vec[0], cur_acl->src) < 0)
2794 -            {
2795 -               log_error(LOG_LEVEL_ERROR, "Invalid source IP for permit-access "
2796 -                     "directive in configuration file: \"%s\"", vec[0]);
2797 -               string_append(&config->proxy_args,
2798 -                  "<br>\nWARNING: Invalid source IP for permit-access directive"
2799 -                  " in configuration file: \"");
2800 -               string_append(&config->proxy_args,
2801 -                  vec[0]);
2802 -               string_append(&config->proxy_args,
2803 -                  "\"<br><br>\n");
2804 -               freez(cur_acl);
2805 -               continue;
2806 -            }
2807 -            if (vec_count == 2)
2808 +            switch (ssplit(arg, " \t", vec, SZ(vec), 1, 1))
2809              {
2810 -               if (acl_addr(vec[1], cur_acl->dst) < 0)
2811 -               {
2812 -                  log_error(LOG_LEVEL_ERROR, "Invalid destination IP for "
2813 -                        "permit-access directive in configuration file: \"%s\"",
2814 -                        vec[0]);
2815 -                  string_append(&config->proxy_args,
2816 -                     "<br>\nWARNING: Invalid destination IP for permit-access directive"
2817 -                     " in configuration file: \"");
2818 -                  string_append(&config->proxy_args,
2819 -                     vec[0]);
2820 +               case 1:
2821 +                  config->acl = add_to_acl_list(config->acl, ACL_PERMIT, vec[0], NULL, &config->proxy_args);
2822 +                  break;
2823 +               case 2:
2824 +                  config->acl = add_to_acl_list(config->acl, ACL_PERMIT, vec[0], vec[1], &config->proxy_args);
2825 +                  break;
2826 +               default:
2827 +                  log_error(LOG_LEVEL_ERROR, "Wrong number of parameters for "
2828 +                            "permit-access directive in configuration file.");
2829                    string_append(&config->proxy_args,
2830 -                     "\"<br><br>\n");
2831 -                  freez(cur_acl);
2832 -                  continue;
2833 -               }
2834 +                                "<br>\nWARNING: Wrong number of parameters for "
2835 +                                "permit-access directive in configuration file.<br><br>\n");
2836              }
2837 -
2838 -            /*
2839 -             * Add it to the list.  Note we reverse the list to get the
2840 -             * behaviour the user expects.  With both the ACL and
2841 -             * actions file, the last match wins.  However, the internal
2842 -             * implementations are different:  The actions file is stored
2843 -             * in the same order as the file, and scanned completely.
2844 -             * With the ACL, we reverse the order as we load it, then
2845 -             * when we scan it we stop as soon as we get a match.
2846 -             */
2847 -            cur_acl->next  = config->acl;
2848 -            config->acl = cur_acl;
2849 -
2850              continue;
2851  #endif /* def FEATURE_ACL */
2852
2853 @@ -1519,32 +1528,33 @@
2854     }
2855  #endif /* def FEATURE_COOKIE_JAR */
2856
2857 -   if ( NULL == config->haddr )
2858 -   {
2859 -      config->haddr = strdup( HADDR_DEFAULT );
2860 -   }
2861 -
2862 -   if ( NULL != config->haddr )
2863 +   if ( config->hspecs == NULL )
2864     {
2865 -      if (NULL != (p = strchr(config->haddr, ':')))
2866 -      {
2867 -         *p++ = '\0';
2868 -         if (*p)
2869 -         {
2870 -            config->hport = atoi(p);
2871 -         }
2872 -      }
2873 -
2874 -      if (config->hport <= 0)
2875 -      {
2876 -         *--p = ':';
2877 -         log_error(LOG_LEVEL_FATAL, "invalid bind port spec %s", config->haddr);
2878 -         /* Never get here - LOG_LEVEL_FATAL causes program exit */
2879 -      }
2880 -      if (*config->haddr == '\0')
2881 -      {
2882 -         config->haddr = NULL;
2883 -      }
2884 +      /* No listen-address set. The default is localhost on port 8118, on IPv4
2885 +         and (if INET6 is defined) IPv6.
2886 +       */
2887 +      struct bind_spec *bs;
2888 +#ifdef INET6
2889 +      config->hspecs = calloc(2,sizeof(struct bind_spec));
2890 +      if (config->hspecs == NULL)
2891 +         fail_load_config_memory(fs,config);
2892 +      config->hspecs_size=2;
2893 +      config->hspecs_occupied=1;
2894 +      bs = &config->hspecs[0];
2895 +      bs->haddr = strdup("::1");
2896 +      bs->hport = strdup("8118");
2897 +      bs->pf = PF_UNSPEC;
2898 +#else
2899 +      config->hspecs = calloc(1,sizeof(struct bind_spec));
2900 +      if (config->hspecs == NULL)
2901 +         fail_load_config_memory(fs,config);
2902 +      config->hspecs_size=1;
2903 +      config->hspecs_occupied=0;
2904 +#endif
2905 +      bs = &config->hspecs[config->hspecs_occupied++];
2906 +      bs->haddr = strdup("127.0.0.1");
2907 +      bs->hport = strdup("8118");
2908 +      bs->pf = PF_UNSPEC;
2909     }
2910
2911     /*
2912 @@ -1586,31 +1596,29 @@
2913        struct configuration_spec * oldcfg = (struct configuration_spec *)
2914                                             current_configfile->f;
2915        /*
2916 -       * Check if config->haddr,hport == oldcfg->haddr,hport
2917 -       *
2918 -       * The following could be written more compactly as a single,
2919 -       * (unreadably long) if statement.
2920 +       * Check if the listening addresses have changed
2921         */
2922        config->need_bind = 0;
2923 -      if (config->hport != oldcfg->hport)
2924 -      {
2925 -         config->need_bind = 1;
2926 -      }
2927 -      else if (config->haddr == NULL)
2928 +      if (config -> hspecs_occupied == oldcfg -> hspecs_occupied)
2929        {
2930 -         if (oldcfg->haddr != NULL)
2931 +         int bs_index;
2932 +         struct bind_spec *hspec;
2933 +         struct bind_spec *oldhspec;
2934 +         hspec = config -> hspecs;
2935 +         oldhspec = oldcfg -> hspecs;
2936 +         for(bs_index = 0; bs_index < oldcfg->hspecs_occupied; ++bs_index)
2937           {
2938 -            config->need_bind = 1;
2939 +           if (strcmp(hspec[bs_index].haddr,oldhspec[bs_index].haddr) != 0
2940 +               || strcmp(hspec[bs_index].hport,oldhspec[bs_index].hport) != 0
2941 +               || hspec[bs_index].pf != hspec[bs_index].pf)
2942 +           {
2943 +              config -> need_bind = 1;
2944 +              break;
2945 +           }
2946           }
2947        }
2948 -      else if (oldcfg->haddr == NULL)
2949 -      {
2950 -         config->need_bind = 1;
2951 -      }
2952 -      else if (0 != strcmp(config->haddr, oldcfg->haddr))
2953 -      {
2954 -         config->need_bind = 1;
2955 -      }
2956 +      else
2957 +         config-> need_bind = 1;
2958
2959        current_configfile->unloader = unload_configfile;
2960     }
2961 diff -urNad privoxy~/loaders.c privoxy/loaders.c
2962 --- privoxy~/loaders.c
2963 +++ privoxy/loaders.c
2964 @@ -11,6 +11,9 @@
2965   * Copyright   :  Written by and Copyright (C) 2001 the SourceForge
2966   *                Privoxy team. http://www.privoxy.org/
2967   *
2968 + *                Modified by Lionel Elie Mamane <lionel@mamane.lu>
2969 + *                for IPv6 support on 8 December 2002, 24 January 2003.
2970 + *
2971   *                Based on the Internet Junkbuster originally written
2972   *                by and Copyright (C) 1997 Anonymous Coders and
2973   *                Junkbusters Corporation.  http://www.junkbusters.com
2974 @@ -465,6 +468,7 @@
2975
2976           freez(csp->ip_addr_str);
2977           freez(csp->my_ip_addr_str);
2978 +         freez(csp->my_port_str);
2979           freez(csp->my_hostname);
2980           freez(csp->x_forwarded);
2981           freez(csp->iob->buf);
2982 diff -urNad privoxy~/miscutil.h privoxy/miscutil.h
2983 --- privoxy~/miscutil.h
2984 +++ privoxy/miscutil.h
2985 @@ -162,6 +162,15 @@
2986
2987  #include "project.h"
2988
2989 +/* Fix a problem with Solaris.  There should be no effect on other
2990 + * platforms.
2991 + * Solaris's isspace() is a macro which uses it's argument directly
2992 + * as an array index.  Therefore we need to make sure that high-bit
2993 + * characters generate +ve values, and ideally we also want to make
2994 + * the argument match the declared parameter type of "int".
2995 + */
2996 +#define ijb_isdigit(__X) isdigit((int)(unsigned char)(__X))
2997 +
2998  #if defined(__cplusplus)
2999  extern "C" {
3000  #endif
3001 diff -urNad privoxy~/parsers.c privoxy/parsers.c
3002 --- privoxy~/parsers.c
3003 +++ privoxy/parsers.c
3004 @@ -16,6 +16,9 @@
3005   * Copyright   :  Written by and Copyright (C) 2001 the SourceForge
3006   *                Privoxy team. http://www.privoxy.org/
3007   *
3008 + *                Modified by Lionel Elie Mamane <lionel@mamane.lu>
3009 + *                for IPv6 support on 24 January 2003.
3010 + *
3011   *                Based on the Internet Junkbuster originally written
3012   *                by and Copyright (C) 1997 Anonymous Coders and
3013   *                Junkbusters Corporation.  http://www.junkbusters.com
3014 @@ -1951,6 +1954,167 @@
3015     return JB_ERR_OK;
3016  }
3017
3018 +/*********************************************************************
3019 + *
3020 + * Function    :  parse_pf_ip_netmask
3021 + *
3022 + * Description :  Parse an IPv{4,6} litteral or hostname
3023 + *                with optional port and optional explicit family
3024 + *                and optional netmask
3025 + *
3026 + * Parameters  :
3027 + *          0  :  string = the string to parse
3028 + *          1  :  host = Is set to point to the hostname or IP literal
3029 + *                       part
3030 + *          2  :  port = Is set to point to the port part,
3031 + *                       or NULL if no port in string
3032 + *          3  :  pf = pointer used to return the address family
3033 + *                     pf is a value-result argument:
3034 + *                     If it is set to -1, then parse_pf_ip will set it
3035 + *                      to the address family of the pf_ip string
3036 + *                     else, it won't touch it, and fail if the two
3037 + *                      cannot match
3038 + *          4  :  pointer used to return the mask length
3039 + *                Set to -1 if no mask
3040 + *
3041 + * Returns     :  0 on success
3042 + *
3043 + *********************************************************************/
3044 +int parse_pf_ip_netmask(char *string, char **host, char **port, int *pf, int *masklength)
3045 +{
3046 +   int i;
3047 +   char *p;
3048 +
3049 +   *masklength = -1;
3050 +
3051 +   if ((p = strchr(string, '/')) != NULL)
3052 +   {
3053 +      *p++ = '\0';
3054 +
3055 +      if (ijb_isdigit(*p) == 0)
3056 +      {
3057 +         return -1;
3058 +      }
3059 +      i = atoi(p);
3060 +      if ( i < 0 )
3061 +         return -1;
3062 +      *masklength = i;
3063 +   }
3064 +
3065 +   return parse_pf_ip(string, host, port, pf);
3066 +}
3067 +
3068 +/*********************************************************************
3069 + *
3070 + * Function    :  parse_pf_ip
3071 + *
3072 + * Description :  Parse an IPv{4,6} litteral or hostname
3073 + *                with optional port and optional explicit family
3074 + *
3075 + * Parameters  :
3076 + *          0  :  string = the string to parse
3077 + *          1  :  host = Is set to point to the hostname or IP literal
3078 + *                       part
3079 + *          2  :  port = Is set to point to the port part,
3080 + *                       or NULL if no port in string
3081 + *          3  :  pf = pointer used to return the address family
3082 + *                     pf is a value-result argument:
3083 + *                     If it is set to -1, then parse_pf_ip will set it
3084 + *                      to the address family of the pf_ip string
3085 + *                     else, it won't touch it, and fail if the two
3086 + *                      cannot match
3087 + *
3088 + * Returns     :  0 on success
3089 + *
3090 + *********************************************************************/
3091 +int parse_pf_ip(char *string, char **host, char **port, int *pf)
3092 +{
3093 +   if (pf != NULL && *pf == -1)
3094 +      *pf = PF_UNSPEC;
3095 +
3096 +   /* See if we want to override the default protocol family */
3097 +   if (strncmpic(string, "ipv4:", 5) == 0)
3098 +   {
3099 +      string += 5;
3100 +      if (pf!=NULL)
3101 +      {
3102 +         if(*pf==PF_INET || *pf==PF_UNSPEC)
3103 +            *pf = AF_INET;
3104 +         else
3105 +         {
3106 +            log_error(LOG_LEVEL_ERROR,"%s","IPv4 address found where other awaited");
3107 +            return -2;
3108 +         }
3109 +      }
3110 +   }
3111 +   else if (strncmpic(string, "ipv6:", 5) == 0)
3112 +   {
3113 +#ifdef INET6
3114 +      string += 5;
3115 +      if(*pf==PF_INET6 || *pf==PF_UNSPEC)
3116 +         *pf = AF_INET6;
3117 +      else
3118 +      {
3119 +        log_error(LOG_LEVEL_ERROR,"%s","IPv6 address found where other awaited");
3120 +        return -2;
3121 +      }
3122 +#else
3123 +      log_error(LOG_LEVEL_ERROR,"%s","This privoxy hasn't IPv6 support");
3124 +      return -1;
3125 +#endif
3126 +   }
3127 +   return parse_ip(string, host, port);
3128 +}
3129 +
3130 +/*********************************************************************
3131 + *
3132 + * Function    :  parse_ip
3133 + *
3134 + * Description :  Parse an IPv{4,6} litteral or hostname
3135 + *                with optional port
3136 + *
3137 + * Parameters  :
3138 + *          0  :  string = the string to parse
3139 + *          1  :  host = Is set to point to the hostname or IP literal
3140 + *                       part
3141 + *          2  :  port = Is set to point to the port part,
3142 + *                       or NULL if no port in string
3143 + * Returns     :  0 on success
3144 + *
3145 + *********************************************************************/
3146 +int parse_ip(char *string, char **host, char **port)
3147 +{
3148 +   char *p;
3149 +   int skip;
3150 +
3151 +   /* allow IPv6 address literal: [numbers:with:colons]:port/mask */
3152 +   if (string[0] == '[' && (p = strchr(string, ']')))
3153 +   {
3154 +      *p++ = '\0';
3155 +      skip = 1;
3156 +   }
3157 +   else
3158 +   {
3159 +      p = string;
3160 +      skip = 0;
3161 +   }
3162 +
3163 +   if (host != NULL)
3164 +      *host = string + skip;
3165 +
3166 +   for(;*p != '\0'; ++p)
3167 +   {
3168 +      if (*p == ':')
3169 +      {
3170 +         *p++ = '\0';
3171 +         break;
3172 +      }
3173 +   }
3174 +   if (port != NULL)
3175 +      *port = p;
3176 +   return 0;
3177 +}
3178 +
3179
3180  /*********************************************************************
3181   *
3182 diff -urNad privoxy~/parsers.h privoxy/parsers.h
3183 --- privoxy~/parsers.h
3184 +++ privoxy/parsers.h
3185 @@ -19,6 +19,9 @@
3186   * Copyright   :  Written by and Copyright (C) 2001 the SourceForge
3187   *                Privoxy team. http://www.privoxy.org/
3188   *
3189 + *                Modified by Lionel Elie Mamane <lionel@mamane.lu>
3190 + *                for IPv6 support on 24 January 2003.
3191 + *
3192   *                Based on the Internet Junkbuster originally written
3193   *                by and Copyright (C) 1997 Anonymous Coders and
3194   *                Junkbusters Corporation.  http://www.junkbusters.com
3195 @@ -270,6 +273,10 @@
3196  extern jb_err server_last_modified   (struct client_state *csp, char **header);
3197  extern jb_err server_content_disposition(struct client_state *csp, char **header);
3198
3199 +extern int parse_pf_ip_netmask(char *string, char **host, char **port, int *pf, int *masklength);
3200 +extern int parse_pf_ip(char *string, char ** host, char ** port, int *pf);
3201 +extern int parse_ip(char *string, char ** host, char** port);
3202 +
3203  #ifdef FEATURE_FORCE_LOAD
3204  extern int strclean(const char *string, const char *substring);
3205  #endif /* def FEATURE_FORCE_LOAD */
3206 diff -urNad privoxy~/project.h privoxy/project.h
3207 --- privoxy~/project.h
3208 +++ privoxy/project.h
3209 @@ -607,6 +607,20 @@
3210
3211  #endif /* ndef _WIN32 */
3212
3213 +#include "jb_socket_set.h"
3214 +
3215 +#ifdef INET6
3216 +/**
3217 + * Get from the operating system structures big enough
3218 + * to put a network address in, namely sockaddr_storage
3219 + */
3220 +#include <sys/socket.h>
3221 +/**
3222 + * If no IPv6 support, just use the old sockaddr
3223 + */
3224 +#else
3225 +#define sockaddr_storage   sockaddr
3226 +#endif
3227
3228  /**
3229   * A standard error code.  This should be JB_ERR_OK or one of the JB_ERR_xxx
3230 @@ -681,19 +695,6 @@
3231   */
3232  #define FOREVER 1
3233
3234 -/**
3235 - * Default IP address to listen on, as a string.
3236 - * Set to "127.0.0.1".
3237 - */
3238 -#define HADDR_DEFAULT   "127.0.0.1"
3239 -
3240 -/**
3241 - * Default port to listen on, as a number.
3242 - * Set to 8118.
3243 - */
3244 -#define HADDR_PORT      8118
3245 -
3246 -
3247  /* Forward def for struct client_state */
3248  struct configuration_spec;
3249
3250 @@ -772,13 +773,16 @@
3251     char *ver;      /**< Protocol version */
3252     int status;     /**< HTTP Status */
3253
3254 +   char *host_port_malloc;     /**< malloc used for place wher host and port_str are */
3255     char *host;     /**< Host part of URL */
3256     int   port;     /**< Port of URL or 80 (default) */
3257 +   char *port_str; /**< Port of URL, as string */
3258     char *path;     /**< Path of URL */
3259     char *hostport; /**< host[:port] */
3260     int   ssl;      /**< Flag if protocol is https */
3261
3262 -   char *host_ip_addr_str; /**< String with dotted decimal representation
3263 +   char *host_ip_addr_str; /**< String with dotted decimal representation (IPv4)
3264 +                                or hexadecimal colon-separated (IPv6)
3265                                  of host's IP. NULL before connect_to() */
3266
3267     char  *dbuffer; /**< Buffer with '\0'-delimited domain name.           */
3268 @@ -1158,13 +1162,16 @@
3269         As a string. */
3270     char *ip_addr_str;
3271     /** Client PC's IP address, as reported by the accept() function.
3272 -       As a number. */
3273 -   long  ip_addr_long;
3274 +       As an address. */
3275 +   struct sockaddr_storage ip_addr_addr;
3276
3277     /** Our IP address. I.e. the IP address that the client used to reach us,
3278         as a string. */
3279     char *my_ip_addr_str;
3280
3281 +   /** Our  port. I.e. the port the client used to reach us */
3282 +   char *my_port_str;
3283 +
3284     /** Our hostname. I.e. the reverse DNS of the IP address that the client
3285         used to reach us, as a string. */
3286     char *my_hostname;
3287 @@ -1339,18 +1346,33 @@
3288     /** Connection type.  Must be SOCKS_NONE, SOCKS_4, or SOCKS_4A. */
3289     int   type;
3290
3291 +   /** pointer returned by the malloc used for gateway_host and gateway_port_str */
3292 +   char *gateway_malloc;
3293 +
3294     /** SOCKS server hostname.  Only valid if "type" is SOCKS_4 or SOCKS_4A. */
3295     char *gateway_host;
3296
3297     /** SOCKS server port. */
3298     int   gateway_port;
3299
3300 +   /** SOCKS server port, as string. */
3301 +   char *gateway_port_str;
3302 +
3303 +   /** pointer returned by the malloc used for forward_host and forward_port_str */
3304 +   char *forward_malloc;
3305 +
3306 +   /** Parent HTTP proxy address family. */
3307 +   int forward_family;
3308 +
3309     /** Parent HTTP proxy hostname, or NULL for none. */
3310     char *forward_host;
3311
3312     /** Parent HTTP proxy port. */
3313     int   forward_port;
3314
3315 +   /** Parent HTTP proxy port as string. */
3316 +   char *forward_port_str;
3317 +
3318     /** Next entry in the linked list. */
3319     struct forward_spec *next;
3320  };
3321 @@ -1359,7 +1381,7 @@
3322  /**
3323   * Initializer for a static struct forward_spec.
3324   */
3325 -#define FORWARD_SPEC_INITIALIZER { { URL_SPEC_INITIALIZER }, 0, NULL, 0, NULL, 0, NULL }
3326 +#define FORWARD_SPEC_INITIALIZER { { URL_SPEC_INITIALIZER }, 0, NULL, NULL, 0, NULL, NULL, 0, NULL, 0, NULL, NULL}
3327
3328
3329  /**
3330 @@ -1388,7 +1410,8 @@
3331   */
3332  struct access_control_addr
3333  {
3334 -   unsigned long addr;  /**< The IP address as an integer. */
3335 +   struct sockaddr_storage addr; /**< The IP address. */
3336 +   size_t addrlen;
3337     unsigned long mask;  /**< The network mask as an integer. */
3338     unsigned long port;  /**< The port number. */
3339  };
3340 @@ -1423,6 +1446,17 @@
3341  /** configuration_spec::feature_flags: HTTP-header-based toggle. */
3342  #define RUNTIME_FEATURE_HTTP_TOGGLE       4
3343
3344 +struct bind_spec
3345 +{
3346 +   /** IP address to bind to. */
3347 +   char *haddr;
3348 +
3349 +   /** Port to bind to. */
3350 +   char *hport;
3351 +
3352 +   /** Address family */
3353 +   int pf;
3354 +};
3355  /**
3356   * Data loaded from the configuration file.
3357   *
3358 @@ -1486,11 +1520,13 @@
3359
3360  #endif /* def FEATURE_COOKIE_JAR */
3361
3362 -   /** IP address to bind to.  Defaults to HADDR_DEFAULT == 127.0.0.1. */
3363 -   const char *haddr;
3364 -
3365 -   /** Port to bind to.  Defaults to HADDR_PORT == 8118. */
3366 -   int         hport;
3367 +   /* IP addresses and ports to bind to.
3368 +       Defaults to HSPECS_DEFAULT == {ipv4:127.0.0.1:8118, ipv6:[::1]:8118}. */
3369 +   struct bind_spec *hspecs;
3370 +   /* size allocated */
3371 +   unsigned int hspecs_size;
3372 +   /* number of entries */
3373 +   unsigned int hspecs_occupied;
3374
3375     /** Size limit for IOB */
3376     size_t buffer_limit;
3377 diff -urNad privoxy~/urlmatch.c privoxy/urlmatch.c
3378 --- privoxy~/urlmatch.c
3379 +++ privoxy/urlmatch.c
3380 @@ -137,6 +137,7 @@
3381  #include "ssplit.h"
3382  #include "miscutil.h"
3383  #include "errlog.h"
3384 +#include "parsers.h"
3385
3386  const char urlmatch_h_rcs[] = URLMATCH_H_VERSION;
3387
3388 @@ -160,7 +161,7 @@
3389     freez(http->cmd);
3390     freez(http->ocmd);
3391     freez(http->gpc);
3392 -   freez(http->host);
3393 +   freez(http->host_port_malloc);
3394     freez(http->url);
3395     freez(http->hostport);
3396     freez(http->path);
3397 @@ -302,8 +303,6 @@
3398      */
3399     {
3400        char *buf;
3401 -      char *host;
3402 -      char *port;
3403
3404        buf = strdup(http->hostport);
3405        if (buf == NULL)
3406 @@ -311,38 +310,34 @@
3407           return JB_ERR_MEMORY;
3408        }
3409
3410 +      http->host_port_malloc = buf;
3411 +
3412        /* check if url contains username and/or password */
3413 -      host = strchr(buf, '@');
3414 -      if (host != NULL)
3415 +      buf = strchr(buf, '@');
3416 +      if (buf != NULL)
3417        {
3418           /* Contains username/password, skip it and the @ sign. */
3419 -         host++;
3420 +         buf++;
3421        }
3422        else
3423        {
3424           /* No username or password. */
3425 -         host = buf;
3426 +         buf = http->host_port_malloc;
3427        }
3428
3429 -      /* check if url contains port */
3430 -      port = strchr(host, ':');
3431 -      if (port != NULL)
3432 +      parse_ip(buf,&http->host,&http->port_str);
3433 +
3434 +      if (*http->port_str != '\0')
3435        {
3436 -         /* Contains port */
3437 -         /* Terminate hostname and point to start of port string */
3438 -         *port++ = '\0';
3439 -         http->port = atoi(port);
3440 +         http->port = atoi(http->port_str);
3441        }
3442        else
3443        {
3444           /* No port specified. */
3445 +         http->port_str = (http->ssl ? "143" : "80");
3446           http->port = (http->ssl ? 443 : 80);
3447        }
3448
3449 -      http->host = strdup(host);
3450 -
3451 -      free(buf);
3452 -
3453        if (http->host == NULL)
3454        {
3455           return JB_ERR_MEMORY;
3456 @@ -666,9 +661,8 @@
3457   *                               written to system log)
3458   *
3459   *********************************************************************/
3460 -jb_err create_url_spec(struct url_spec * url, const char * buf)
3461 +jb_err create_url_spec(struct url_spec * url, char * buf)
3462  {
3463 -   char *p;
3464
3465     assert(url);
3466     assert(buf);
3467 @@ -685,21 +679,24 @@
3468     {
3469        return JB_ERR_MEMORY;
3470     }
3471 -
3472 -   if ((p = strchr(buf, '/')) != NULL)
3473     {
3474 -      if (NULL == (url->path = strdup(p)))
3475 +      char *p;
3476 +
3477 +      if ((p = strchr(buf, '/')) != NULL)
3478        {
3479 -         freez(url->spec);
3480 -         return JB_ERR_MEMORY;
3481 +         if (NULL == (url->path = strdup(p)))
3482 +         {
3483 +            freez(url->spec);
3484 +            return JB_ERR_MEMORY;
3485 +         }
3486 +         url->pathlen = strlen(url->path);
3487 +         *p = '\0';
3488 +      }
3489 +      else
3490 +      {
3491 +         url->path    = NULL;
3492 +         url->pathlen = 0;
3493        }
3494 -      url->pathlen = strlen(url->path);
3495 -      *p = '\0';
3496 -   }
3497 -   else
3498 -   {
3499 -      url->path    = NULL;
3500 -      url->pathlen = 0;
3501     }
3502     if (url->path)
3503     {
3504 @@ -739,14 +736,11 @@
3505           return JB_ERR_PARSE;
3506        }
3507     }
3508 -   if ((p = strchr(buf, ':')) == NULL)
3509 -   {
3510 -      url->port = 0;
3511 -   }
3512 -   else
3513 +
3514     {
3515 -      *p++ = '\0';
3516 -      url->port = atoi(p);
3517 +     char *p;
3518 +     parse_ip(buf,&buf,&p);
3519 +     url->port = atoi(p);
3520     }
3521
3522     if (buf[0] != '\0')
3523 @@ -779,12 +773,13 @@
3524           return JB_ERR_MEMORY;
3525        }
3526
3527 -      /*
3528 -       * Map to lower case
3529 -       */
3530 -      for (p = url->dbuffer; *p ; p++)
3531        {
3532 -         *p = tolower((int)(unsigned char)*p);
3533 +         char* p;
3534 +         /* map to lower case */
3535 +         for (p = url->dbuffer; *p ; p++)
3536 +         {
3537 +            *p = tolower((int)(unsigned char)*p);
3538 +         }
3539        }
3540
3541        /*
3542 diff -urNad privoxy~/urlmatch.h privoxy/urlmatch.h
3543 --- privoxy~/urlmatch.h
3544 +++ privoxy/urlmatch.h
3545 @@ -83,7 +83,7 @@
3546  extern int url_match(const struct url_spec *pattern,
3547                       const struct http_request *url);
3548
3549 -extern jb_err create_url_spec(struct url_spec * url, const char * buf);
3550 +extern jb_err create_url_spec(struct url_spec * url, char * buf);
3551  extern void free_url_spec(struct url_spec *url);
3552
3553