Add changes for 3.0.28 stable
[privoxy.git] / loadcfg.c
1 /*********************************************************************
2  *
3  * File        :  $Source: /cvsroot/ijbswa/current/loadcfg.c,v $
4  *
5  * Purpose     :  Loads settings from the configuration file into
6  *                global variables.  This file contains both the
7  *                routine to load the configuration and the global
8  *                variables it writes to.
9  *
10  * Copyright   :  Written by and Copyright (C) 2001-2017 the
11  *                Privoxy team. http://www.privoxy.org/
12  *
13  *                Based on the Internet Junkbuster originally written
14  *                by and Copyright (C) 1997 Anonymous Coders and
15  *                Junkbusters Corporation.  http://www.junkbusters.com
16  *
17  *                This program is free software; you can redistribute it
18  *                and/or modify it under the terms of the GNU General
19  *                Public License as published by the Free Software
20  *                Foundation; either version 2 of the License, or (at
21  *                your option) any later version.
22  *
23  *                This program is distributed in the hope that it will
24  *                be useful, but WITHOUT ANY WARRANTY; without even the
25  *                implied warranty of MERCHANTABILITY or FITNESS FOR A
26  *                PARTICULAR PURPOSE.  See the GNU General Public
27  *                License for more details.
28  *
29  *                The GNU General Public License should be included with
30  *                this file.  If not, you can view it at
31  *                http://www.gnu.org/copyleft/gpl.html
32  *                or write to the Free Software Foundation, Inc., 59
33  *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.
34  *
35  *********************************************************************/
36
37
38 #include "config.h"
39
40 #include <stdio.h>
41 #include <sys/types.h>
42 #include <stdlib.h>
43 #include <string.h>
44 #include <signal.h>
45 #include <fcntl.h>
46 #include <errno.h>
47 #include <ctype.h>
48 #include <assert.h>
49
50 #ifdef _WIN32
51
52 # ifndef STRICT
53 #  define STRICT
54 # endif
55 # include <winsock2.h>
56 # include <windows.h>
57
58 # include "win32.h"
59 # ifndef _WIN_CONSOLE
60 #  include "w32log.h"
61 # endif /* ndef _WIN_CONSOLE */
62
63 #else /* ifndef _WIN32 */
64
65 #ifndef __OS2__
66 # include <unistd.h>
67 # include <sys/wait.h>
68 #endif
69 # include <sys/time.h>
70 # include <sys/stat.h>
71 # include <signal.h>
72
73 #endif
74
75 #include "project.h"
76 #include "loadcfg.h"
77 #include "list.h"
78 #include "jcc.h"
79 #include "filters.h"
80 #include "loaders.h"
81 #include "miscutil.h"
82 #include "errlog.h"
83 #include "ssplit.h"
84 #include "encode.h"
85 #include "urlmatch.h"
86 #include "cgi.h"
87 #include "gateway.h"
88 #ifdef FEATURE_CLIENT_TAGS
89 #include "client-tags.h"
90 #endif
91
92 /*
93  * Default number of seconds after which an
94  * open connection will no longer be reused.
95  */
96 #define DEFAULT_KEEP_ALIVE_TIMEOUT 180
97
98 /*
99  * Default backlog passed to listen().
100  */
101 #define DEFAULT_LISTEN_BACKLOG 128
102
103 #ifdef FEATURE_TOGGLE
104 /* Privoxy is enabled by default. */
105 int global_toggle_state = 1;
106 #endif /* def FEATURE_TOGGLE */
107
108 /* The filename of the configfile */
109 const char *configfile  = NULL;
110
111 /*
112  * CGI functions will later need access to the invocation args,
113  * so we will make argc and argv global.
114  */
115 int Argc = 0;
116 char * const * Argv = NULL;
117
118 static struct file_list *current_configfile = NULL;
119
120
121 /*
122  * This takes the "cryptic" hash of each keyword and aliases them to
123  * something a little more readable.  This also makes changing the
124  * hash values easier if they should change or the hash algorthm changes.
125  * Use the included "hash" program to find out what the hash will be
126  * for any string supplied on the command line.  (Or just put it in the
127  * config file and read the number from the error message in the log).
128  *
129  * Please keep this list sorted alphabetically (but with the Windows
130  * console and GUI specific options last).
131  */
132
133 #define hash_actions_file                1196306641U /* "actionsfile" */
134 #define hash_accept_intercepted_requests 1513024973U /* "accept-intercepted-requests" */
135 #define hash_admin_address               4112573064U /* "admin-address" */
136 #define hash_allow_cgi_request_crunching  258915987U /* "allow-cgi-request-crunching" */
137 #define hash_buffer_limit                1881726070U /* "buffer-limit */
138 #define hash_client_header_order         2701453514U /* "client-header-order" */
139 #define hash_client_specific_tag         3353703383U /* "client-specific-tag" */
140 #define hash_client_tag_lifetime          647957580U /* "client-tag-lifetime" */
141 #define hash_compression_level           2464423563U /* "compression-level" */
142 #define hash_confdir                        1978389U /* "confdir" */
143 #define hash_connection_sharing          1348841265U /* "connection-sharing" */
144 #define hash_debug                            78263U /* "debug" */
145 #define hash_default_server_timeout      2530089913U /* "default-server-timeout" */
146 #define hash_deny_access                 1227333715U /* "deny-access" */
147 #define hash_enable_accept_filter        2909040407U /* "enable-accept-filter" */
148 #define hash_enable_edit_actions         2517097536U /* "enable-edit-actions" */
149 #define hash_enable_compression          3943696946U /* "enable-compression" */
150 #define hash_enable_proxy_authentication_forwarding 4040610791U /* enable-proxy-authentication-forwarding */
151 #define hash_enable_remote_toggle        2979744683U /* "enable-remote-toggle" */
152 #define hash_enable_remote_http_toggle    110543988U /* "enable-remote-http-toggle" */
153 #define hash_enforce_blocks              1862427469U /* "enforce-blocks" */
154 #define hash_filterfile                   250887266U /* "filterfile" */
155 #define hash_forward                        2029845U /* "forward" */
156 #define hash_forward_socks4              3963965521U /* "forward-socks4" */
157 #define hash_forward_socks4a             2639958518U /* "forward-socks4a" */
158 #define hash_forward_socks5              3963965522U /* "forward-socks5" */
159 #define hash_forward_socks5t             2639958542U /* "forward-socks5t" */
160 #define hash_forwarded_connect_retries    101465292U /* "forwarded-connect-retries" */
161 #define hash_handle_as_empty_returns_ok  1444873247U /* "handle-as-empty-doc-returns-ok" */
162 #define hash_hostname                      10308071U /* "hostname" */
163 #define hash_keep_alive_timeout          3878599515U /* "keep-alive-timeout" */
164 #define hash_listen_address              1255650842U /* "listen-address" */
165 #define hash_listen_backlog              1255655735U /* "listen-backlog" */
166 #define hash_logdir                          422889U /* "logdir" */
167 #define hash_logfile                        2114766U /* "logfile" */
168 #define hash_max_client_connections      3595884446U /* "max-client-connections" */
169 #define hash_permit_access               3587953268U /* "permit-access" */
170 #define hash_proxy_info_url              3903079059U /* "proxy-info-url" */
171 #define hash_receive_buffer_size         2880297454U /* "receive-buffer-size */
172 #define hash_single_threaded             4250084780U /* "single-threaded" */
173 #define hash_socket_timeout              1809001761U /* "socket-timeout" */
174 #define hash_split_large_cgi_forms        671658948U /* "split-large-cgi-forms" */
175 #define hash_suppress_blocklists         1948693308U /* "suppress-blocklists" */
176 #define hash_templdir                      11067889U /* "templdir" */
177 #define hash_temporary_directory         1824125181U /* "temporary-directory" */
178 #define hash_tolerate_pipelining         1360286620U /* "tolerate-pipelining" */
179 #define hash_toggle                          447966U /* "toggle" */
180 #define hash_trust_info_url               430331967U /* "trust-info-url" */
181 #define hash_trust_x_forwarded_for       2971537414U /* "trust-x-forwarded-for" */
182 #define hash_trusted_cgi_referrer        4270883427U /* "trusted-cgi-referrer" */
183 #define hash_trustfile                     56494766U /* "trustfile" */
184 #define hash_usermanual                  1416668518U /* "user-manual" */
185 #define hash_activity_animation          1817904738U /* "activity-animation" */
186 #define hash_close_button_minimizes      3651284693U /* "close-button-minimizes" */
187 #define hash_hide_console                2048809870U /* "hide-console" */
188 #define hash_log_buffer_size             2918070425U /* "log-buffer-size" */
189 #define hash_log_font_name               2866730124U /* "log-font-name" */
190 #define hash_log_font_size               2866731014U /* "log-font-size" */
191 #define hash_log_highlight_messages      4032101240U /* "log-highlight-messages" */
192 #define hash_log_max_lines               2868344173U /* "log-max-lines" */
193 #define hash_log_messages                2291744899U /* "log-messages" */
194 #define hash_show_on_task_bar             215410365U /* "show-on-task-bar" */
195
196
197 static void savearg(char *command, char *argument, struct configuration_spec * config);
198 #ifdef FEATURE_CLIENT_TAGS
199 static void free_client_specific_tags(struct client_tag_spec *tag_list);
200 #endif
201
202 /*********************************************************************
203  *
204  * Function    :  unload_configfile
205  *
206  * Description :  Free the config structure and all components.
207  *
208  * Parameters  :
209  *          1  :  data: struct configuration_spec to unload
210  *
211  * Returns     :  N/A
212  *
213  *********************************************************************/
214 static void unload_configfile (void * data)
215 {
216    struct configuration_spec * config = (struct configuration_spec *)data;
217    struct forward_spec *cur_fwd = config->forward;
218    int i;
219
220 #ifdef FEATURE_ACL
221    struct access_control_list *cur_acl = config->acl;
222
223    while (cur_acl != NULL)
224    {
225       struct access_control_list * next_acl = cur_acl->next;
226       free(cur_acl);
227       cur_acl = next_acl;
228    }
229    config->acl = NULL;
230 #endif /* def FEATURE_ACL */
231
232    while (cur_fwd != NULL)
233    {
234       struct forward_spec * next_fwd = cur_fwd->next;
235       free_pattern_spec(cur_fwd->url);
236
237       freez(cur_fwd->gateway_host);
238       freez(cur_fwd->forward_host);
239       free(cur_fwd);
240       cur_fwd = next_fwd;
241    }
242    config->forward = NULL;
243
244    freez(config->confdir);
245    freez(config->logdir);
246    freez(config->templdir);
247    freez(config->hostname);
248 #ifdef FEATURE_EXTERNAL_FILTERS
249    freez(config->temporary_directory);
250 #endif
251
252    for (i = 0; i < MAX_LISTENING_SOCKETS; i++)
253    {
254       freez(config->haddr[i]);
255    }
256    freez(config->logfile);
257
258    for (i = 0; i < MAX_AF_FILES; i++)
259    {
260       freez(config->actions_file_short[i]);
261       freez(config->actions_file[i]);
262       freez(config->re_filterfile_short[i]);
263       freez(config->re_filterfile[i]);
264    }
265
266    list_remove_all(config->ordered_client_headers);
267
268    freez(config->admin_address);
269    freez(config->proxy_info_url);
270    freez(config->proxy_args);
271    freez(config->usermanual);
272    freez(config->trusted_cgi_referrer);
273
274 #ifdef FEATURE_TRUST
275    freez(config->trustfile);
276    list_remove_all(config->trust_info);
277 #endif /* def FEATURE_TRUST */
278
279 #ifdef FEATURE_CLIENT_TAGS
280    free_client_specific_tags(config->client_tags);
281 #endif
282
283    freez(config);
284 }
285
286
287 #ifdef FEATURE_GRACEFUL_TERMINATION
288 /*********************************************************************
289  *
290  * Function    :  unload_current_config_file
291  *
292  * Description :  Unloads current config file - reset to state at
293  *                beginning of program.
294  *
295  * Parameters  :  None
296  *
297  * Returns     :  N/A
298  *
299  *********************************************************************/
300 void unload_current_config_file(void)
301 {
302    if (current_configfile)
303    {
304       current_configfile->unloader = unload_configfile;
305       current_configfile = NULL;
306    }
307 }
308 #endif
309
310
311 #ifdef FEATURE_CLIENT_TAGS
312 /*********************************************************************
313  *
314  * Function    :  register_tag
315  *
316  * Description :  Registers a client-specific-tag and its description
317  *
318  * Parameters  :
319  *          1  :  config: The tag list
320  *          2  :  name:  The name of the client-specific-tag
321  *          3  :  description: The human-readable description for the tag
322  *
323  * Returns     :  N/A
324  *
325  *********************************************************************/
326 static void register_tag(struct client_tag_spec *tag_list,
327    const char *name, const char *description)
328 {
329    struct client_tag_spec *new_tag;
330    struct client_tag_spec *last_tag;
331
332    last_tag = tag_list;
333    while (last_tag->next != NULL)
334    {
335       last_tag = last_tag->next;
336    }
337    if (last_tag->name == NULL)
338    {
339       /* First entry */
340       new_tag = last_tag;
341    }
342    else
343    {
344       new_tag = zalloc_or_die(sizeof(struct client_tag_spec));
345    }
346    new_tag->name = strdup_or_die(name);
347    new_tag->description = strdup_or_die(description);
348    if (new_tag != last_tag)
349    {
350       last_tag->next = new_tag;
351    }
352 }
353
354
355 /*********************************************************************
356  *
357  * Function    :  free_client_specific_tags
358  *
359  * Description :  Frees client-specific tags and their descriptions
360  *
361  * Parameters  :
362  *          1  :  tag_list: The tag list to free
363  *
364  * Returns     :  N/A
365  *
366  *********************************************************************/
367 static void free_client_specific_tags(struct client_tag_spec *tag_list)
368 {
369    struct client_tag_spec *this_tag;
370    struct client_tag_spec *next_tag;
371
372    next_tag = tag_list;
373    do
374    {
375       this_tag = next_tag;
376       next_tag = next_tag->next;
377
378       freez(this_tag->name);
379       freez(this_tag->description);
380
381       if (this_tag != tag_list)
382       {
383          freez(this_tag);
384       }
385    } while (next_tag != NULL);
386 }
387 #endif /* def FEATURE_CLIENT_TAGS */
388
389
390 /*********************************************************************
391  *
392  * Function    :  parse_numeric_value
393  *
394  * Description :  Parse the value of a directive that can only have
395  *                a single numeric value. Terminates with a fatal error
396  *                if the value is NULL or not numeric.
397  *
398  * Parameters  :
399  *          1  :  name:  The name of the directive. Used for log messages.
400  *          2  :  value: The value to parse
401  *
402  *
403  * Returns     :  The numerical value as integer
404  *
405  *********************************************************************/
406 static int parse_numeric_value(const char *name, const char *value)
407 {
408    int number;
409    char *endptr;
410
411    assert(name != NULL);
412    assert(value != NULL);
413
414    if ((value == NULL) || (*value == '\0'))
415    {
416       log_error(LOG_LEVEL_FATAL, "Directive %s used without argument", name);
417    }
418
419    number = (int)strtol(value, &endptr, 0);
420    if (*endptr != '\0')
421    {
422       log_error(LOG_LEVEL_FATAL,
423          "Directive '%s' used with non-numerical value: '%s'", name, value);
424    }
425
426    return number;
427
428 }
429
430
431 /*********************************************************************
432  *
433  * Function    :  parse_toggle_value
434  *
435  * Description :  Parse the value of a directive that can only be
436  *                enabled or disabled. Terminates with a fatal error
437  *                if the value is NULL or something other than 0 or 1.
438  *
439  * Parameters  :
440  *          1  :  name:  The name of the directive. Used for log messages.
441  *          2  :  value: The value to parse
442  *
443  *
444  * Returns     :  The numerical toggle state
445  *
446  *********************************************************************/
447 static int parse_toggle_state(const char *name, const char *value)
448 {
449    int toggle_state;
450    assert(name != NULL);
451    assert(value != NULL);
452
453    if ((value == NULL) || (*value == '\0'))
454    {
455       log_error(LOG_LEVEL_FATAL, "Directive %s used without argument", name);
456    }
457
458    toggle_state = atoi(value);
459
460    /*
461     * Also check the length as atoi() doesn't mind
462     * garbage after a valid integer, but we do.
463     */
464    if (((toggle_state != 0) && (toggle_state != 1)) || (strlen(value) != 1))
465    {
466       log_error(LOG_LEVEL_FATAL,
467          "Directive %s used with invalid argument '%s'. Use either '0' or '1'.",
468          name, value);
469    }
470
471    return toggle_state;
472
473 }
474
475
476 /*********************************************************************
477  *
478  * Function    :  parse_client_header_order
479  *
480  * Description :  Parse the value of the header-order directive
481  *
482  * Parameters  :
483  *          1  :  ordered_header_list:  List to insert the ordered
484  *                                      headers into.
485  *          2  :  ordered_headers:  The ordered header names separated
486  *                                  by spaces or tabs.
487  *
488  *
489  * Returns     :  N/A
490  *
491  *********************************************************************/
492 static void parse_client_header_order(struct list *ordered_header_list, const char *ordered_headers)
493 {
494    char *original_headers_copy;
495    char **vector;
496    size_t max_segments;
497    int number_of_headers;
498    int i;
499
500    assert(ordered_header_list != NULL);
501    assert(ordered_headers != NULL);
502
503    if (ordered_headers == NULL)
504    {
505       log_error(LOG_LEVEL_FATAL, "header-order used without argument");
506    }
507
508    /*
509     * XXX: This estimate is guaranteed to be high enough as we
510     *      let ssplit() ignore empty fields, but also a bit wasteful.
511     *      The same hack is used in get_last_url() so it looks like
512     *      a real solution is needed.
513     */
514    max_segments = strlen(ordered_headers) / 2;
515    if (max_segments == 0)
516    {
517       max_segments = 1;
518    }
519    vector = malloc_or_die(max_segments * sizeof(char *));
520
521    original_headers_copy = strdup_or_die(ordered_headers);
522
523    number_of_headers = ssplit(original_headers_copy, "\t ", vector, max_segments);
524    if (number_of_headers == -1)
525    {
526       log_error(LOG_LEVEL_FATAL, "Failed to split ordered headers");
527    }
528
529    for (i = 0; i < number_of_headers; i++)
530    {
531       if (JB_ERR_OK != enlist(ordered_header_list, vector[i]))
532       {
533          log_error(LOG_LEVEL_FATAL,
534             "Failed to enlist ordered header: %s", vector[i]);
535       }
536    }
537
538    freez(vector);
539    freez(original_headers_copy);
540
541    return;
542
543 }
544
545
546 /*********************************************************************
547  *
548  * Function    :  load_config
549  *
550  * Description :  Load the config file and all parameters.
551  *
552  *                XXX: more than thousand lines long
553  *                and thus in serious need of refactoring.
554  *
555  * Parameters  :  None
556  *
557  * Returns     :  The configuration_spec, or NULL on error.
558  *
559  *********************************************************************/
560 struct configuration_spec * load_config(void)
561 {
562    char *buf = NULL;
563    char *p, *q;
564    FILE *configfp = NULL;
565    struct configuration_spec * config = NULL;
566    struct client_state * fake_csp;
567    struct file_list *fs;
568    unsigned long linenum = 0;
569    int i;
570    char *logfile = NULL;
571
572    if (!check_file_changed(current_configfile, configfile, &fs))
573    {
574       /* No need to load */
575       return ((struct configuration_spec *)current_configfile->f);
576    }
577    if (NULL == fs)
578    {
579       log_error(LOG_LEVEL_FATAL,
580          "can't check configuration file '%s':  %E", configfile);
581       return NULL;
582    }
583
584    if (NULL != current_configfile)
585    {
586       log_error(LOG_LEVEL_INFO, "Reloading configuration file '%s'", configfile);
587    }
588
589 #ifdef FEATURE_TOGGLE
590    global_toggle_state = 1;
591 #endif /* def FEATURE_TOGGLE */
592
593    fs->f = config = zalloc_or_die(sizeof(*config));
594
595    /*
596     * This is backwards from how it's usually done.
597     * Following the usual pattern, "fs" would be stored in a member
598     * variable in "csp", and then we'd access "config" from "fs->f",
599     * using a cast.  However, "config" is used so often that a
600     * cast each time would be very ugly, and the extra indirection
601     * would waste CPU cycles.  Therefore we store "config" in
602     * "csp->config", and "fs" in "csp->config->config_file_list".
603     */
604    config->config_file_list = fs;
605
606    /*
607     * Set to defaults
608     */
609    config->multi_threaded            = 1;
610    config->buffer_limit              = 4096 * 1024;
611    config->receive_buffer_size       = BUFFER_SIZE;
612    config->usermanual                = strdup_or_die(USER_MANUAL_URL);
613    config->proxy_args                = strdup_or_die("");
614    config->forwarded_connect_retries = 0;
615 #ifdef FEATURE_CLIENT_TAGS
616    config->client_tag_lifetime       = 60;
617 #endif
618    config->trust_x_forwarded_for     = 0;
619 #if defined(FEATURE_ACCEPT_FILTER) && defined(SO_ACCEPTFILTER)
620    config->enable_accept_filter      = 0;
621 #endif
622    config->listen_backlog            = DEFAULT_LISTEN_BACKLOG;
623    config->trusted_cgi_referrer      = NULL;
624    /*
625     * 128 client sockets ought to be enough for everybody who can't
626     * be bothered to read the documentation to figure out how to
627     * increase the limit.
628     */
629    config->max_client_connections    = 128;
630    config->socket_timeout            = 300; /* XXX: Should be a macro. */
631 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
632    config->default_server_timeout    = 0;
633    config->keep_alive_timeout        = DEFAULT_KEEP_ALIVE_TIMEOUT;
634    config->feature_flags            &= ~RUNTIME_FEATURE_CONNECTION_KEEP_ALIVE;
635    config->feature_flags            &= ~RUNTIME_FEATURE_CONNECTION_SHARING;
636 #endif
637    config->feature_flags            &= ~RUNTIME_FEATURE_CGI_TOGGLE;
638    config->feature_flags            &= ~RUNTIME_FEATURE_SPLIT_LARGE_FORMS;
639    config->feature_flags            &= ~RUNTIME_FEATURE_ACCEPT_INTERCEPTED_REQUESTS;
640    config->feature_flags            &= ~RUNTIME_FEATURE_EMPTY_DOC_RETURNS_OK;
641    config->feature_flags            &= ~RUNTIME_FEATURE_FORWARD_PROXY_AUTHENTICATION_HEADERS;
642 #ifdef FEATURE_COMPRESSION
643    config->feature_flags            &= ~RUNTIME_FEATURE_COMPRESSION;
644    /*
645     * XXX: Run some benchmarks to see if there are better default values.
646     */
647    config->compression_level         = 1;
648 #endif
649    config->feature_flags            &= ~RUNTIME_FEATURE_TOLERATE_PIPELINING;
650
651    configfp = fopen(configfile, "r");
652    if (NULL == configfp)
653    {
654       log_error(LOG_LEVEL_FATAL,
655          "can't open configuration file '%s':  %E", configfile);
656       /* Never get here - LOG_LEVEL_FATAL causes program exit */
657    }
658
659    while (read_config_line(configfp, &linenum, &buf) != NULL)
660    {
661       char cmd[BUFFER_SIZE];
662       char arg[BUFFER_SIZE];
663       char tmp[BUFFER_SIZE];
664 #ifdef FEATURE_ACL
665       struct access_control_list *cur_acl;
666 #endif /* def FEATURE_ACL */
667       struct forward_spec *cur_fwd;
668       int vec_count;
669       char *vec[3];
670       unsigned int directive_hash;
671
672       strlcpy(tmp, buf, sizeof(tmp));
673
674       /* Copy command (i.e. up to space or tab) into cmd */
675       p = buf;
676       q = cmd;
677       while (*p && (*p != ' ') && (*p != '\t'))
678       {
679          *q++ = *p++;
680       }
681       *q = '\0';
682
683       /* Skip over the whitespace in buf */
684       while (*p && ((*p == ' ') || (*p == '\t')))
685       {
686          p++;
687       }
688
689       /* Copy the argument into arg */
690       if (strlcpy(arg, p, sizeof(arg)) >= sizeof(arg))
691       {
692          log_error(LOG_LEVEL_FATAL, "Config line too long: %s", buf);
693       }
694
695       /* Should never happen, but check this anyway */
696       if (*cmd == '\0')
697       {
698          freez(buf);
699          continue;
700       }
701
702       /* Make sure the command field is lower case */
703       for (p = cmd; *p; p++)
704       {
705          if (privoxy_isupper(*p))
706          {
707             *p = (char)privoxy_tolower(*p);
708          }
709       }
710
711       directive_hash = hash_string(cmd);
712       switch (directive_hash)
713       {
714 /* *************************************************************************
715  * actionsfile actions-file-name
716  * In confdir by default
717  * *************************************************************************/
718          case hash_actions_file :
719             i = 0;
720             while ((i < MAX_AF_FILES) && (NULL != config->actions_file[i]))
721             {
722                i++;
723             }
724
725             if (i >= MAX_AF_FILES)
726             {
727                log_error(LOG_LEVEL_FATAL, "Too many 'actionsfile' directives in config file - limit is %d.\n"
728                   "(You can increase this limit by changing MAX_AF_FILES in project.h and recompiling).",
729                   MAX_AF_FILES);
730             }
731             config->actions_file_short[i] = strdup_or_die(arg);
732             config->actions_file[i] = make_path(config->confdir, arg);
733
734             break;
735 /* *************************************************************************
736  * accept-intercepted-requests
737  * *************************************************************************/
738          case hash_accept_intercepted_requests:
739             if (parse_toggle_state(cmd, arg) == 1)
740             {
741                config->feature_flags |= RUNTIME_FEATURE_ACCEPT_INTERCEPTED_REQUESTS;
742             }
743             else
744             {
745                config->feature_flags &= ~RUNTIME_FEATURE_ACCEPT_INTERCEPTED_REQUESTS;
746             }
747             break;
748
749 /* *************************************************************************
750  * admin-address email-address
751  * *************************************************************************/
752          case hash_admin_address :
753             freez(config->admin_address);
754             config->admin_address = strdup_or_die(arg);
755             break;
756
757 /* *************************************************************************
758  * allow-cgi-request-crunching
759  * *************************************************************************/
760          case hash_allow_cgi_request_crunching:
761             if (parse_toggle_state(cmd, arg) == 1)
762             {
763                config->feature_flags |= RUNTIME_FEATURE_CGI_CRUNCHING;
764             }
765             else
766             {
767                config->feature_flags &= ~RUNTIME_FEATURE_CGI_CRUNCHING;
768             }
769             break;
770
771 /* *************************************************************************
772  * buffer-limit n
773  * *************************************************************************/
774          case hash_buffer_limit :
775             config->buffer_limit = (size_t)(1024 * parse_numeric_value(cmd, arg));
776             break;
777
778 /* *************************************************************************
779  * client-header-order header-1 header-2 ... header-n
780  * *************************************************************************/
781          case hash_client_header_order:
782             list_remove_all(config->ordered_client_headers);
783             parse_client_header_order(config->ordered_client_headers, arg);
784             break;
785
786 /* *************************************************************************
787  * client-specific-tag tag-name description
788  * *************************************************************************/
789 #ifdef FEATURE_CLIENT_TAGS
790          case hash_client_specific_tag:
791             {
792                char *name;
793                char *description;
794
795                name = arg;
796                description = strstr(arg, " ");
797                if (description == NULL)
798                {
799                   log_error(LOG_LEVEL_FATAL,
800                      "client-specific-tag '%s' lacks a description.", name);
801                }
802                *description = '\0';
803                /*
804                 * The length is limited because we don't want truncated
805                 * HTML caused by the cgi interface using static buffer
806                 * sizes.
807                 */
808                if (strlen(name) > CLIENT_TAG_LENGTH_MAX)
809                {
810                   log_error(LOG_LEVEL_FATAL,
811                      "client-specific-tag '%s' is longer than %d characters.",
812                      name, CLIENT_TAG_LENGTH_MAX);
813                }
814                description++;
815                register_tag(config->client_tags, name, description);
816             }
817             break;
818 #endif /* def FEATURE_CLIENT_TAGS */
819
820 /* *************************************************************************
821  * client-tag-lifetime ttl
822  * *************************************************************************/
823 #ifdef FEATURE_CLIENT_TAGS
824          case hash_client_tag_lifetime:
825          {
826             int ttl = parse_numeric_value(cmd, arg);
827             if (0 <= ttl)
828             {
829                config->client_tag_lifetime = (unsigned)ttl;
830             }
831             else
832             {
833                log_error(LOG_LEVEL_FATAL,
834                   "client-tag-lifetime can't be negative.");
835             }
836             break;
837          }
838 #endif /* def FEATURE_CLIENT_TAGS */
839
840 /* *************************************************************************
841  * confdir directory-name
842  * *************************************************************************/
843          case hash_confdir :
844             freez(config->confdir);
845             config->confdir = make_path(NULL, arg);
846             break;
847
848 /* *************************************************************************
849  * compression-level 0-9
850  * *************************************************************************/
851 #ifdef FEATURE_COMPRESSION
852          case hash_compression_level :
853          {
854             int compression_level = parse_numeric_value(cmd, arg);
855             if (-1 <= compression_level && compression_level <= 9)
856             {
857                config->compression_level = compression_level;
858             }
859             else
860             {
861                log_error(LOG_LEVEL_FATAL,
862                   "Invalid compression-level value: %s", arg);
863             }
864             break;
865          }
866 #endif
867
868 /* *************************************************************************
869  * connection-sharing (0|1)
870  * *************************************************************************/
871 #ifdef FEATURE_CONNECTION_SHARING
872          case hash_connection_sharing :
873             if (parse_toggle_state(cmd, arg) == 1)
874             {
875                config->feature_flags |= RUNTIME_FEATURE_CONNECTION_SHARING;
876             }
877             else
878             {
879                config->feature_flags &= ~RUNTIME_FEATURE_CONNECTION_SHARING;
880             }
881             break;
882 #endif
883
884 /* *************************************************************************
885  * debug n
886  * Specifies debug level, multiple values are ORed together.
887  * *************************************************************************/
888          case hash_debug :
889             config->debug |= parse_numeric_value(cmd, arg);
890             break;
891
892 /* *************************************************************************
893  * default-server-timeout timeout
894  * *************************************************************************/
895 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
896          case hash_default_server_timeout :
897          {
898             int timeout = parse_numeric_value(cmd, arg);
899             if (0 <= timeout)
900             {
901                config->default_server_timeout = (unsigned int)timeout;
902             }
903             else
904             {
905                log_error(LOG_LEVEL_FATAL,
906                   "Invalid default-server-timeout value: %s", arg);
907             }
908             break;
909          }
910 #endif
911
912 /* *************************************************************************
913  * deny-access source-ip[/significant-bits] [dest-ip[/significant-bits]]
914  * *************************************************************************/
915 #ifdef FEATURE_ACL
916          case hash_deny_access:
917             strlcpy(tmp, arg, sizeof(tmp));
918             vec_count = ssplit(tmp, " \t", vec, SZ(vec));
919
920             if ((vec_count != 1) && (vec_count != 2))
921             {
922                log_error(LOG_LEVEL_ERROR, "Wrong number of parameters for "
923                      "deny-access directive in configuration file.");
924                string_append(&config->proxy_args,
925                   "<br>\nWARNING: Wrong number of parameters for "
926                   "deny-access directive in configuration file.<br><br>\n");
927                break;
928             }
929
930             /* allocate a new node */
931             cur_acl = zalloc_or_die(sizeof(*cur_acl));
932             cur_acl->action = ACL_DENY;
933
934             if (acl_addr(vec[0], cur_acl->src) < 0)
935             {
936                log_error(LOG_LEVEL_ERROR, "Invalid source address, port or netmask "
937                   "for deny-access directive in configuration file: \"%s\"", vec[0]);
938                string_append(&config->proxy_args,
939                   "<br>\nWARNING: Invalid source address, port or netmask "
940                   "for deny-access directive in configuration file: \"");
941                string_append(&config->proxy_args,
942                   vec[0]);
943                string_append(&config->proxy_args,
944                   "\"<br><br>\n");
945                freez(cur_acl);
946                break;
947             }
948             if (vec_count == 2)
949             {
950                if (acl_addr(vec[1], cur_acl->dst) < 0)
951                {
952                   log_error(LOG_LEVEL_ERROR, "Invalid destination address, port or netmask "
953                      "for deny-access directive in configuration file: \"%s\"", vec[1]);
954                   string_append(&config->proxy_args,
955                      "<br>\nWARNING: Invalid destination address, port or netmask "
956                      "for deny-access directive in configuration file: \"");
957                   string_append(&config->proxy_args,
958                      vec[1]);
959                   string_append(&config->proxy_args,
960                      "\"<br><br>\n");
961                   freez(cur_acl);
962                   break;
963                }
964             }
965 #ifdef HAVE_RFC2553
966             else
967             {
968                cur_acl->wildcard_dst = 1;
969             }
970 #endif /* def HAVE_RFC2553 */
971
972             /*
973              * Add it to the list.  Note we reverse the list to get the
974              * behaviour the user expects.  With both the ACL and
975              * actions file, the last match wins.  However, the internal
976              * implementations are different:  The actions file is stored
977              * in the same order as the file, and scanned completely.
978              * With the ACL, we reverse the order as we load it, then
979              * when we scan it we stop as soon as we get a match.
980              */
981             cur_acl->next  = config->acl;
982             config->acl = cur_acl;
983
984             break;
985 #endif /* def FEATURE_ACL */
986
987 #if defined(FEATURE_ACCEPT_FILTER) && defined(SO_ACCEPTFILTER)
988 /* *************************************************************************
989  * enable-accept-filter 0|1
990  * *************************************************************************/
991          case hash_enable_accept_filter :
992             config->enable_accept_filter = parse_toggle_state(cmd, arg);
993             break;
994 #endif /* defined(FEATURE_ACCEPT_FILTER) && defined(SO_ACCEPTFILTER) */
995
996 /* *************************************************************************
997  * enable-edit-actions 0|1
998  * *************************************************************************/
999 #ifdef FEATURE_CGI_EDIT_ACTIONS
1000          case hash_enable_edit_actions:
1001             if (parse_toggle_state(cmd, arg) == 1)
1002             {
1003                config->feature_flags |= RUNTIME_FEATURE_CGI_EDIT_ACTIONS;
1004             }
1005             else
1006             {
1007                config->feature_flags &= ~RUNTIME_FEATURE_CGI_EDIT_ACTIONS;
1008             }
1009             break;
1010 #endif /* def FEATURE_CGI_EDIT_ACTIONS */
1011
1012 /* *************************************************************************
1013  * enable-compression 0|1
1014  * *************************************************************************/
1015 #ifdef FEATURE_COMPRESSION
1016          case hash_enable_compression:
1017             if (parse_toggle_state(cmd, arg) == 1)
1018             {
1019                config->feature_flags |= RUNTIME_FEATURE_COMPRESSION;
1020             }
1021             else
1022             {
1023                config->feature_flags &= ~RUNTIME_FEATURE_COMPRESSION;
1024             }
1025             break;
1026 #endif /* def FEATURE_COMPRESSION */
1027
1028 /* *************************************************************************
1029  * enable-proxy-authentication-forwarding 0|1
1030  * *************************************************************************/
1031          case hash_enable_proxy_authentication_forwarding:
1032             if (parse_toggle_state(cmd, arg) == 1)
1033             {
1034                config->feature_flags |= RUNTIME_FEATURE_FORWARD_PROXY_AUTHENTICATION_HEADERS;
1035             }
1036             else
1037             {
1038                config->feature_flags &= ~RUNTIME_FEATURE_FORWARD_PROXY_AUTHENTICATION_HEADERS;
1039             }
1040             break;
1041
1042 /* *************************************************************************
1043  * enable-remote-toggle 0|1
1044  * *************************************************************************/
1045 #ifdef FEATURE_TOGGLE
1046          case hash_enable_remote_toggle:
1047             if (parse_toggle_state(cmd, arg) == 1)
1048             {
1049                config->feature_flags |= RUNTIME_FEATURE_CGI_TOGGLE;
1050             }
1051             else
1052             {
1053                config->feature_flags &= ~RUNTIME_FEATURE_CGI_TOGGLE;
1054             }
1055             break;
1056 #endif /* def FEATURE_TOGGLE */
1057
1058 /* *************************************************************************
1059  * enable-remote-http-toggle 0|1
1060  * *************************************************************************/
1061          case hash_enable_remote_http_toggle:
1062             if (parse_toggle_state(cmd, arg) == 1)
1063             {
1064                config->feature_flags |= RUNTIME_FEATURE_HTTP_TOGGLE;
1065             }
1066             else
1067             {
1068                config->feature_flags &= ~RUNTIME_FEATURE_HTTP_TOGGLE;
1069             }
1070             break;
1071
1072 /* *************************************************************************
1073  * enforce-blocks 0|1
1074  * *************************************************************************/
1075          case hash_enforce_blocks:
1076 #ifdef FEATURE_FORCE_LOAD
1077             if (parse_toggle_state(cmd, arg) == 1)
1078             {
1079                config->feature_flags |= RUNTIME_FEATURE_ENFORCE_BLOCKS;
1080             }
1081             else
1082             {
1083                config->feature_flags &= ~RUNTIME_FEATURE_ENFORCE_BLOCKS;
1084             }
1085 #else
1086             log_error(LOG_LEVEL_ERROR, "Ignoring directive 'enforce-blocks'. "
1087                "FEATURE_FORCE_LOAD is disabled, blocks will always be enforced.");
1088 #endif /* def FEATURE_FORCE_LOAD */
1089             break;
1090
1091 /* *************************************************************************
1092  * filterfile file-name
1093  * In confdir by default.
1094  * *************************************************************************/
1095          case hash_filterfile :
1096             i = 0;
1097             while ((i < MAX_AF_FILES) && (NULL != config->re_filterfile[i]))
1098             {
1099                i++;
1100             }
1101
1102             if (i >= MAX_AF_FILES)
1103             {
1104                log_error(LOG_LEVEL_FATAL, "Too many 'filterfile' directives in config file - limit is %d.\n"
1105                   "(You can increase this limit by changing MAX_AF_FILES in project.h and recompiling).",
1106                   MAX_AF_FILES);
1107             }
1108             config->re_filterfile_short[i] = strdup_or_die(arg);
1109             config->re_filterfile[i] = make_path(config->confdir, arg);
1110
1111             break;
1112
1113 /* *************************************************************************
1114  * forward url-pattern (.|http-proxy-host[:port])
1115  * *************************************************************************/
1116          case hash_forward:
1117             strlcpy(tmp, arg, sizeof(tmp));
1118             vec_count = ssplit(tmp, " \t", vec, SZ(vec));
1119
1120             if (vec_count != 2)
1121             {
1122                log_error(LOG_LEVEL_ERROR, "Wrong number of parameters for forward "
1123                      "directive in configuration file.");
1124                string_append(&config->proxy_args,
1125                   "<br>\nWARNING: Wrong number of parameters for "
1126                   "forward directive in configuration file.");
1127                break;
1128             }
1129
1130             /* allocate a new node */
1131             cur_fwd = zalloc_or_die(sizeof(*cur_fwd));
1132             cur_fwd->type = SOCKS_NONE;
1133
1134             /* Save the URL pattern */
1135             if (create_pattern_spec(cur_fwd->url, vec[0]))
1136             {
1137                log_error(LOG_LEVEL_ERROR, "Bad URL specifier for forward "
1138                      "directive in configuration file.");
1139                string_append(&config->proxy_args,
1140                   "<br>\nWARNING: Bad URL specifier for "
1141                   "forward directive in configuration file.");
1142                freez(cur_fwd);
1143                break;
1144             }
1145
1146             /* Parse the parent HTTP proxy host:port */
1147             p = vec[1];
1148
1149             if (strcmp(p, ".") != 0)
1150             {
1151                cur_fwd->forward_port = 8000;
1152                parse_forwarder_address(p, &cur_fwd->forward_host,
1153                   &cur_fwd->forward_port);
1154             }
1155
1156             /* Add to list. */
1157             cur_fwd->next = config->forward;
1158             config->forward = cur_fwd;
1159
1160             break;
1161
1162 /* *************************************************************************
1163  * forward-socks4 url-pattern socks-proxy[:port] (.|http-proxy[:port])
1164  * *************************************************************************/
1165          case hash_forward_socks4:
1166             strlcpy(tmp, arg, sizeof(tmp));
1167             vec_count = ssplit(tmp, " \t", vec, SZ(vec));
1168
1169             if (vec_count != 3)
1170             {
1171                log_error(LOG_LEVEL_ERROR, "Wrong number of parameters for "
1172                      "forward-socks4 directive in configuration file.");
1173                string_append(&config->proxy_args,
1174                   "<br>\nWARNING: Wrong number of parameters for "
1175                   "forward-socks4 directive in configuration file.");
1176                break;
1177             }
1178
1179             /* allocate a new node */
1180             cur_fwd = zalloc_or_die(sizeof(*cur_fwd));
1181             cur_fwd->type = SOCKS_4;
1182
1183             /* Save the URL pattern */
1184             if (create_pattern_spec(cur_fwd->url, vec[0]))
1185             {
1186                log_error(LOG_LEVEL_ERROR, "Bad URL specifier for forward-socks4 "
1187                      "directive in configuration file.");
1188                string_append(&config->proxy_args,
1189                   "<br>\nWARNING: Bad URL specifier for "
1190                   "forward-socks4 directive in configuration file.");
1191                freez(cur_fwd);
1192                break;
1193             }
1194
1195             /* Parse the SOCKS proxy host[:port] */
1196             p = vec[1];
1197
1198             /* XXX: This check looks like a bug. */
1199             if (strcmp(p, ".") != 0)
1200             {
1201                cur_fwd->gateway_port = 1080;
1202                parse_forwarder_address(p, &cur_fwd->gateway_host,
1203                   &cur_fwd->gateway_port);
1204             }
1205
1206             /* Parse the parent HTTP proxy host[:port] */
1207             p = vec[2];
1208
1209             if (strcmp(p, ".") != 0)
1210             {
1211                cur_fwd->forward_port = 8000;
1212                parse_forwarder_address(p, &cur_fwd->forward_host,
1213                   &cur_fwd->forward_port);
1214             }
1215
1216             /* Add to list. */
1217             cur_fwd->next = config->forward;
1218             config->forward = cur_fwd;
1219
1220             break;
1221
1222 /* *************************************************************************
1223  * forward-socks4a url-pattern socks-proxy[:port] (.|http-proxy[:port])
1224  * *************************************************************************/
1225          case hash_forward_socks4a:
1226          case hash_forward_socks5:
1227          case hash_forward_socks5t:
1228             strlcpy(tmp, arg, sizeof(tmp));
1229             vec_count = ssplit(tmp, " \t", vec, SZ(vec));
1230
1231             if (vec_count != 3)
1232             {
1233                log_error(LOG_LEVEL_ERROR,
1234                   "Wrong number of parameters for %s in configuration file.",
1235                   cmd);
1236                string_append(&config->proxy_args,
1237                   "<br>\nWARNING: Wrong number of parameters for ");
1238                string_append(&config->proxy_args, cmd);
1239                string_append(&config->proxy_args,
1240                   "directive in configuration file.");
1241                break;
1242             }
1243
1244             /* allocate a new node */
1245             cur_fwd = zalloc_or_die(sizeof(*cur_fwd));
1246
1247             if (directive_hash == hash_forward_socks4a)
1248             {
1249                cur_fwd->type = SOCKS_4A;
1250             }
1251             else if (directive_hash == hash_forward_socks5)
1252             {
1253                cur_fwd->type = SOCKS_5;
1254             }
1255             else
1256             {
1257                assert(directive_hash == hash_forward_socks5t);
1258                cur_fwd->type = SOCKS_5T;
1259             }
1260
1261             /* Save the URL pattern */
1262             if (create_pattern_spec(cur_fwd->url, vec[0]))
1263             {
1264                log_error(LOG_LEVEL_ERROR,
1265                   "Bad URL specifier for %s in configuration file.",
1266                   cmd);
1267                string_append(&config->proxy_args,
1268                   "<br>\nWARNING: Bad URL specifier for ");
1269                string_append(&config->proxy_args, cmd);
1270                string_append(&config->proxy_args,
1271                   "directive in configuration file.");
1272                freez(cur_fwd);
1273                break;
1274             }
1275
1276             /* Parse the SOCKS proxy host[:port] */
1277             p = vec[1];
1278
1279             cur_fwd->gateway_port = 1080;
1280             parse_forwarder_address(p, &cur_fwd->gateway_host,
1281                &cur_fwd->gateway_port);
1282
1283             /* Parse the parent HTTP proxy host[:port] */
1284             p = vec[2];
1285
1286             if (strcmp(p, ".") != 0)
1287             {
1288                cur_fwd->forward_port = 8000;
1289                parse_forwarder_address(p, &cur_fwd->forward_host,
1290                   &cur_fwd->forward_port);
1291             }
1292
1293             /* Add to list. */
1294             cur_fwd->next = config->forward;
1295             config->forward = cur_fwd;
1296
1297             break;
1298
1299 /* *************************************************************************
1300  * forwarded-connect-retries n
1301  * *************************************************************************/
1302          case hash_forwarded_connect_retries :
1303             config->forwarded_connect_retries = parse_numeric_value(cmd, arg);
1304             break;
1305
1306 /* *************************************************************************
1307  * handle-as-empty-doc-returns-ok 0|1
1308  *
1309  * Workaround for firefox hanging on blocked javascript pages.
1310  *   Block with the "+handle-as-empty-document" flag and set the
1311  *   "handle-as-empty-doc-returns-ok" run-time config flag so that
1312  *   Privoxy returns a 200/OK status instead of a 403/Forbidden status
1313  *   to the browser for blocked pages.
1314  ***************************************************************************/
1315          case hash_handle_as_empty_returns_ok:
1316             if (parse_toggle_state(cmd, arg) == 1)
1317             {
1318                config->feature_flags |= RUNTIME_FEATURE_EMPTY_DOC_RETURNS_OK;
1319             }
1320             else
1321             {
1322                config->feature_flags &= ~RUNTIME_FEATURE_EMPTY_DOC_RETURNS_OK;
1323             }
1324             break;
1325
1326 /* *************************************************************************
1327  * hostname hostname-to-show-on-cgi-pages
1328  * *************************************************************************/
1329          case hash_hostname :
1330             freez(config->hostname);
1331             config->hostname = strdup_or_die(arg);
1332             break;
1333
1334 /* *************************************************************************
1335  * keep-alive-timeout timeout
1336  * *************************************************************************/
1337 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
1338          case hash_keep_alive_timeout :
1339          {
1340             int timeout = parse_numeric_value(cmd, arg);
1341             if (0 < timeout)
1342             {
1343                config->feature_flags |= RUNTIME_FEATURE_CONNECTION_KEEP_ALIVE;
1344                config->keep_alive_timeout = (unsigned int)timeout;
1345             }
1346             else
1347             {
1348                config->feature_flags &= ~RUNTIME_FEATURE_CONNECTION_KEEP_ALIVE;
1349             }
1350             break;
1351          }
1352 #endif
1353
1354 /* *************************************************************************
1355  * listen-address [ip][:port]
1356  * *************************************************************************/
1357          case hash_listen_address :
1358             i = 0;
1359             while ((i < MAX_LISTENING_SOCKETS) && (NULL != config->haddr[i]))
1360             {
1361                i++;
1362             }
1363
1364             if (i >= MAX_LISTENING_SOCKETS)
1365             {
1366                log_error(LOG_LEVEL_FATAL, "Too many 'listen-address' directives in config file - limit is %d.\n"
1367                   "(You can increase this limit by changing MAX_LISTENING_SOCKETS in project.h and recompiling).",
1368                   MAX_LISTENING_SOCKETS);
1369             }
1370             config->haddr[i] = strdup_or_die(arg);
1371             break;
1372
1373 /* *************************************************************************
1374  * listen-backlog n
1375  * *************************************************************************/
1376          case hash_listen_backlog :
1377             /*
1378              * We don't enfore an upper or lower limit because on
1379              * many platforms all values are valid and negative
1380              * number mean "use the highest value allowed".
1381              */
1382             config->listen_backlog = parse_numeric_value(cmd, arg);
1383             break;
1384
1385 /* *************************************************************************
1386  * logdir directory-name
1387  * *************************************************************************/
1388          case hash_logdir :
1389             freez(config->logdir);
1390             config->logdir = make_path(NULL, arg);
1391             break;
1392
1393 /* *************************************************************************
1394  * logfile log-file-name
1395  * In logdir by default
1396  * *************************************************************************/
1397          case hash_logfile :
1398             if (daemon_mode)
1399             {
1400                logfile = make_path(config->logdir, arg);
1401                if (NULL == logfile)
1402                {
1403                   log_error(LOG_LEVEL_FATAL, "Out of memory while creating logfile path");
1404                }
1405             }
1406             break;
1407
1408 /* *************************************************************************
1409  * max-client-connections number
1410  * *************************************************************************/
1411          case hash_max_client_connections :
1412          {
1413             int max_client_connections = parse_numeric_value(cmd, arg);
1414
1415 #if !defined(_WIN32) && !defined(HAVE_POLL)
1416             /*
1417              * Reject values below 1 for obvious reasons and values above
1418              * FD_SETSIZE/2 because Privoxy needs two sockets to serve
1419              * client connections that need forwarding.
1420              *
1421              * We ignore the fact that the first three file descriptors
1422              * are usually set to /dev/null, one is used for logging
1423              * and yet another file descriptor is required to load
1424              * config files.
1425              */
1426             if ((max_client_connections < 1) || (FD_SETSIZE/2 < max_client_connections))
1427             {
1428                log_error(LOG_LEVEL_FATAL, "max-client-connections value %d"
1429                   " is invalid. Value needs to be above 1 and below %d"
1430                   " (FD_SETSIZE/2).", max_client_connections, FD_SETSIZE/2);
1431             }
1432 #else
1433             /*
1434              * The Windows libc uses FD_SETSIZE for an array used
1435              * by select(), but has no problems with file descriptors
1436              * above the limit as long as no more than FD_SETSIZE are
1437              * passed to select().
1438              * https://msdn.microsoft.com/en-us/library/windows/desktop/ms739169%28v=vs.85%29.aspx
1439              *
1440              * On platforms were we use poll() we don't have to enforce
1441              * an upper connection limit either.
1442              *
1443              * XXX: Do OS/2 etc. belong here as well?
1444              */
1445             if (max_client_connections < 1)
1446             {
1447                log_error(LOG_LEVEL_FATAL, "max-client-connections value"
1448                   " has to be a number above 1. %d is invalid.",
1449                   max_client_connections);
1450             }
1451 #endif
1452             config->max_client_connections = max_client_connections;
1453             break;
1454          }
1455
1456 /* *************************************************************************
1457  * permit-access source-ip[/significant-bits] [dest-ip[/significant-bits]]
1458  * *************************************************************************/
1459 #ifdef FEATURE_ACL
1460          case hash_permit_access:
1461             strlcpy(tmp, arg, sizeof(tmp));
1462             vec_count = ssplit(tmp, " \t", vec, SZ(vec));
1463
1464             if ((vec_count != 1) && (vec_count != 2))
1465             {
1466                log_error(LOG_LEVEL_ERROR, "Wrong number of parameters for "
1467                      "permit-access directive in configuration file.");
1468                string_append(&config->proxy_args,
1469                   "<br>\nWARNING: Wrong number of parameters for "
1470                   "permit-access directive in configuration file.<br><br>\n");
1471
1472                break;
1473             }
1474
1475             /* allocate a new node */
1476             cur_acl = zalloc_or_die(sizeof(*cur_acl));
1477             cur_acl->action = ACL_PERMIT;
1478
1479             if (acl_addr(vec[0], cur_acl->src) < 0)
1480             {
1481                log_error(LOG_LEVEL_ERROR, "Invalid source address, port or netmask "
1482                   "for permit-access directive in configuration file: \"%s\"", vec[0]);
1483                string_append(&config->proxy_args,
1484                   "<br>\nWARNING: Invalid source address, port or netmask for "
1485                   "permit-access directive in configuration file: \"");
1486                string_append(&config->proxy_args,
1487                   vec[0]);
1488                string_append(&config->proxy_args,
1489                   "\"<br><br>\n");
1490                freez(cur_acl);
1491                break;
1492             }
1493             if (vec_count == 2)
1494             {
1495                if (acl_addr(vec[1], cur_acl->dst) < 0)
1496                {
1497                   log_error(LOG_LEVEL_ERROR, "Invalid destination address, port or netmask "
1498                      "for permit-access directive in configuration file: \"%s\"", vec[1]);
1499                   string_append(&config->proxy_args,
1500                      "<br>\nWARNING: Invalid destination address, port or netmask for "
1501                      "permit-access directive in configuration file: \"");
1502                   string_append(&config->proxy_args,
1503                      vec[1]);
1504                   string_append(&config->proxy_args,
1505                      "\"<br><br>\n");
1506                   freez(cur_acl);
1507                   break;
1508                }
1509             }
1510 #ifdef HAVE_RFC2553
1511             else
1512             {
1513                cur_acl->wildcard_dst = 1;
1514             }
1515 #endif /* def HAVE_RFC2553 */
1516
1517             /*
1518              * Add it to the list.  Note we reverse the list to get the
1519              * behaviour the user expects.  With both the ACL and
1520              * actions file, the last match wins.  However, the internal
1521              * implementations are different:  The actions file is stored
1522              * in the same order as the file, and scanned completely.
1523              * With the ACL, we reverse the order as we load it, then
1524              * when we scan it we stop as soon as we get a match.
1525              */
1526             cur_acl->next  = config->acl;
1527             config->acl = cur_acl;
1528
1529             break;
1530 #endif /* def FEATURE_ACL */
1531
1532 /* *************************************************************************
1533  * proxy-info-url url
1534  * *************************************************************************/
1535          case hash_proxy_info_url :
1536             freez(config->proxy_info_url);
1537             config->proxy_info_url = strdup_or_die(arg);
1538             break;
1539
1540
1541 /* *************************************************************************
1542  * receive-buffer-size n
1543  * *************************************************************************/
1544          case hash_receive_buffer_size :
1545             config->receive_buffer_size = (size_t)parse_numeric_value(cmd, arg);
1546             if (config->receive_buffer_size < BUFFER_SIZE)
1547             {
1548                log_error(LOG_LEVEL_INFO,
1549                   "receive-buffer-size %d seems low and may cause problems."
1550                   "Consider setting it to at least %d.",
1551                   config->receive_buffer_size, BUFFER_SIZE);
1552             }
1553             break;
1554
1555 /* *************************************************************************
1556  * single-threaded 0|1
1557  * *************************************************************************/
1558          case hash_single_threaded :
1559             config->multi_threaded =  0 == parse_toggle_state(cmd, arg);
1560             break;
1561
1562 /* *************************************************************************
1563  * socket-timeout numer_of_seconds
1564  * *************************************************************************/
1565          case hash_socket_timeout :
1566          {
1567             int socket_timeout = parse_numeric_value(cmd, arg);
1568             if (0 <= socket_timeout)
1569             {
1570                config->socket_timeout = socket_timeout;
1571             }
1572             else
1573             {
1574                log_error(LOG_LEVEL_FATAL, "Invalid socket-timeout: '%s'", arg);
1575             }
1576             break;
1577          }
1578
1579 /* *************************************************************************
1580  * split-large-cgi-forms
1581  * *************************************************************************/
1582          case hash_split_large_cgi_forms :
1583             if (parse_toggle_state(cmd, arg) == 1)
1584             {
1585                config->feature_flags |= RUNTIME_FEATURE_SPLIT_LARGE_FORMS;
1586             }
1587             else
1588             {
1589                config->feature_flags &= ~RUNTIME_FEATURE_SPLIT_LARGE_FORMS;
1590             }
1591             break;
1592
1593 /* *************************************************************************
1594  * templdir directory-name
1595  * *************************************************************************/
1596          case hash_templdir :
1597             freez(config->templdir);
1598             config->templdir = make_path(NULL, arg);
1599             break;
1600
1601 #ifdef FEATURE_EXTERNAL_FILTERS
1602 /* *************************************************************************
1603  * temporary-directory directory-name
1604  * *************************************************************************/
1605          case hash_temporary_directory :
1606             freez(config->temporary_directory);
1607             config->temporary_directory = make_path(NULL, arg);
1608             break;
1609 #endif
1610
1611 /* *************************************************************************
1612  * tolerate-pipelining (0|1)
1613  * *************************************************************************/
1614          case hash_tolerate_pipelining :
1615             if (parse_toggle_state(cmd, arg) == 1)
1616             {
1617                config->feature_flags |= RUNTIME_FEATURE_TOLERATE_PIPELINING;
1618             }
1619             else
1620             {
1621                config->feature_flags &= ~RUNTIME_FEATURE_TOLERATE_PIPELINING;
1622             }
1623             break;
1624
1625 /* *************************************************************************
1626  * toggle (0|1)
1627  * *************************************************************************/
1628 #ifdef FEATURE_TOGGLE
1629          case hash_toggle :
1630             global_toggle_state = parse_toggle_state(cmd, arg);
1631             break;
1632 #endif /* def FEATURE_TOGGLE */
1633
1634 /* *************************************************************************
1635  * trust-info-url url
1636  * *************************************************************************/
1637 #ifdef FEATURE_TRUST
1638          case hash_trust_info_url :
1639             enlist(config->trust_info, arg);
1640             break;
1641 #endif /* def FEATURE_TRUST */
1642
1643 /* *************************************************************************
1644  * trust-x-forwarded-for (0|1)
1645  * *************************************************************************/
1646          case hash_trust_x_forwarded_for :
1647             config->trust_x_forwarded_for = parse_toggle_state(cmd, arg);
1648             break;
1649
1650 /* *************************************************************************
1651  * trusted-cgi-referrer http://www.example.org/some/path.html
1652  * *************************************************************************/
1653          case hash_trusted_cgi_referrer :
1654             /*
1655              * We don't validate the specified referrer as
1656              * it's only used for string comparison.
1657              */
1658             freez(config->trusted_cgi_referrer);
1659             config->trusted_cgi_referrer = strdup_or_die(arg);
1660             break;
1661
1662 /* *************************************************************************
1663  * trustfile filename
1664  * (In confdir by default.)
1665  * *************************************************************************/
1666 #ifdef FEATURE_TRUST
1667          case hash_trustfile :
1668             freez(config->trustfile);
1669             config->trustfile = make_path(config->confdir, arg);
1670             break;
1671 #endif /* def FEATURE_TRUST */
1672
1673 /* *************************************************************************
1674  * usermanual url
1675  * *************************************************************************/
1676          case hash_usermanual :
1677             /*
1678              * XXX: If this isn't the first config directive, the
1679              * show-status page links to the website documentation
1680              * for the directives that were already parsed. Lame.
1681              */
1682             freez(config->usermanual);
1683             config->usermanual = strdup_or_die(arg);
1684             break;
1685
1686 /* *************************************************************************
1687  * Win32 Console options:
1688  * *************************************************************************/
1689
1690 /* *************************************************************************
1691  * hide-console
1692  * *************************************************************************/
1693 #ifdef _WIN_CONSOLE
1694          case hash_hide_console :
1695             hideConsole = 1;
1696             break;
1697 #endif /*def _WIN_CONSOLE*/
1698
1699
1700 /* *************************************************************************
1701  * Win32 GUI options:
1702  * *************************************************************************/
1703
1704 #if defined(_WIN32) && ! defined(_WIN_CONSOLE)
1705 /* *************************************************************************
1706  * activity-animation (0|1)
1707  * *************************************************************************/
1708          case hash_activity_animation :
1709             g_bShowActivityAnimation = parse_toggle_state(cmd, arg);
1710             break;
1711
1712 /* *************************************************************************
1713  *  close-button-minimizes (0|1)
1714  * *************************************************************************/
1715          case hash_close_button_minimizes :
1716             g_bCloseHidesWindow = parse_toggle_state(cmd, arg);
1717             break;
1718
1719 /* *************************************************************************
1720  * log-buffer-size (0|1)
1721  * *************************************************************************/
1722          case hash_log_buffer_size :
1723             g_bLimitBufferSize = parse_toggle_state(cmd, arg);
1724             break;
1725
1726 /* *************************************************************************
1727  * log-font-name fontname
1728  * *************************************************************************/
1729          case hash_log_font_name :
1730             if (strlcpy(g_szFontFaceName, arg,
1731                    sizeof(g_szFontFaceName)) >= sizeof(g_szFontFaceName))
1732             {
1733                log_error(LOG_LEVEL_FATAL,
1734                   "log-font-name argument '%s' is longer than %u characters.",
1735                   arg, sizeof(g_szFontFaceName)-1);
1736             }
1737             break;
1738
1739 /* *************************************************************************
1740  * log-font-size n
1741  * *************************************************************************/
1742          case hash_log_font_size :
1743             g_nFontSize = parse_numeric_value(cmd, arg);
1744             break;
1745
1746 /* *************************************************************************
1747  * log-highlight-messages (0|1)
1748  * *************************************************************************/
1749          case hash_log_highlight_messages :
1750             g_bHighlightMessages = parse_toggle_state(cmd, arg);
1751             break;
1752
1753 /* *************************************************************************
1754  * log-max-lines n
1755  * *************************************************************************/
1756          case hash_log_max_lines :
1757             g_nMaxBufferLines = parse_numeric_value(cmd, arg);
1758             break;
1759
1760 /* *************************************************************************
1761  * log-messages (0|1)
1762  * *************************************************************************/
1763          case hash_log_messages :
1764             g_bLogMessages = parse_toggle_state(cmd, arg);
1765             break;
1766
1767 /* *************************************************************************
1768  * show-on-task-bar (0|1)
1769  * *************************************************************************/
1770          case hash_show_on_task_bar :
1771             g_bShowOnTaskBar = parse_toggle_state(cmd, arg);
1772             break;
1773
1774 #endif /* defined(_WIN32) && ! defined(_WIN_CONSOLE) */
1775
1776
1777 /* *************************************************************************
1778  * Warnings about unsupported features
1779  * *************************************************************************/
1780 #ifndef FEATURE_ACL
1781          case hash_deny_access:
1782 #endif /* ndef FEATURE_ACL */
1783 #ifndef FEATURE_CGI_EDIT_ACTIONS
1784          case hash_enable_edit_actions:
1785 #endif /* ndef FEATURE_CGI_EDIT_ACTIONS */
1786 #ifndef FEATURE_TOGGLE
1787          case hash_enable_remote_toggle:
1788 #endif /* ndef FEATURE_TOGGLE */
1789 #ifndef FEATURE_ACL
1790          case hash_permit_access:
1791 #endif /* ndef FEATURE_ACL */
1792 #ifndef FEATURE_TOGGLE
1793          case hash_toggle :
1794 #endif /* ndef FEATURE_TOGGLE */
1795 #ifndef FEATURE_TRUST
1796          case hash_trustfile :
1797          case hash_trust_info_url :
1798 #endif /* ndef FEATURE_TRUST */
1799
1800 #ifndef _WIN_CONSOLE
1801          case hash_hide_console :
1802 #endif /* ndef _WIN_CONSOLE */
1803
1804 #if defined(_WIN_CONSOLE) || ! defined(_WIN32)
1805          case hash_activity_animation :
1806          case hash_close_button_minimizes :
1807          case hash_log_buffer_size :
1808          case hash_log_font_name :
1809          case hash_log_font_size :
1810          case hash_log_highlight_messages :
1811          case hash_log_max_lines :
1812          case hash_log_messages :
1813          case hash_show_on_task_bar :
1814 #endif /* defined(_WIN_CONSOLE) || ! defined(_WIN32) */
1815             /* These warnings are annoying - so hide them. -- Jon */
1816             /* log_error(LOG_LEVEL_INFO, "Unsupported directive \"%s\" ignored.", cmd); */
1817             break;
1818
1819 /* *************************************************************************/
1820          default :
1821 /* *************************************************************************/
1822             /*
1823              * I decided that I liked this better as a warning than an
1824              * error.  To change back to an error, just change log level
1825              * to LOG_LEVEL_FATAL.
1826              */
1827             log_error(LOG_LEVEL_ERROR, "Ignoring unrecognized directive "
1828                "'%s' (%uU) in line %lu in configuration file (%s).",
1829                buf, directive_hash, linenum, configfile);
1830             string_append(&config->proxy_args,
1831                " <strong class='warning'>Warning: Ignoring unrecognized directive:</strong>");
1832             break;
1833
1834 /* *************************************************************************/
1835       } /* end switch(hash_string(cmd)) */
1836
1837       /* Save the argument for the show-status page. */
1838       savearg(cmd, arg, config);
1839       freez(buf);
1840    } /* end while (read_config_line(...)) */
1841
1842    fclose(configfp);
1843
1844    set_debug_level(config->debug);
1845
1846    freez(config->logfile);
1847
1848    if (daemon_mode)
1849    {
1850       if (NULL != logfile)
1851       {
1852          config->logfile = logfile;
1853          init_error_log(Argv[0], config->logfile);
1854       }
1855       else
1856       {
1857          disable_logging();
1858       }
1859    }
1860
1861 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
1862    if (config->default_server_timeout > config->keep_alive_timeout)
1863    {
1864       log_error(LOG_LEVEL_ERROR,
1865          "Reducing the default-server-timeout from %d to the keep-alive-timeout %d.",
1866          config->default_server_timeout, config->keep_alive_timeout);
1867       config->default_server_timeout = config->keep_alive_timeout;
1868    }
1869 #endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
1870
1871 #ifdef FEATURE_CONNECTION_SHARING
1872    if (config->feature_flags & RUNTIME_FEATURE_CONNECTION_KEEP_ALIVE)
1873    {
1874       if (!config->multi_threaded)
1875       {
1876          /*
1877           * While we could use keep-alive without multiple threads
1878           * if we didn't bother with enforcing the connection timeout,
1879           * that might make Tor users sad, even though they shouldn't
1880           * enable the single-threaded option anyway.
1881           *
1882           * XXX: We could still use Proxy-Connection: keep-alive.
1883           */
1884          config->feature_flags &= ~RUNTIME_FEATURE_CONNECTION_KEEP_ALIVE;
1885          log_error(LOG_LEVEL_ERROR,
1886             "Config option single-threaded disables connection keep-alive.");
1887       }
1888    }
1889    else if ((config->feature_flags & RUNTIME_FEATURE_CONNECTION_SHARING))
1890    {
1891       log_error(LOG_LEVEL_ERROR, "Config option connection-sharing "
1892          "has no effect if keep-alive-timeout isn't set.");
1893       config->feature_flags &= ~RUNTIME_FEATURE_CONNECTION_SHARING;
1894    }
1895 #endif /* def FEATURE_CONNECTION_SHARING */
1896
1897    if (NULL == config->proxy_args)
1898    {
1899       log_error(LOG_LEVEL_FATAL, "Out of memory loading config - insufficient memory for config->proxy_args");
1900    }
1901
1902    if (config->re_filterfile[0])
1903    {
1904       add_loader(load_re_filterfiles, config);
1905    }
1906
1907    if (config->actions_file[0])
1908    {
1909       add_loader(load_action_files, config);
1910    }
1911
1912 #ifdef FEATURE_TRUST
1913    if (config->trustfile)
1914    {
1915       add_loader(load_trustfile, config);
1916    }
1917 #endif /* def FEATURE_TRUST */
1918
1919    if (NULL == config->haddr[0])
1920    {
1921       config->haddr[0] = strdup_or_die(HADDR_DEFAULT);
1922    }
1923
1924    for (i = 0; i < MAX_LISTENING_SOCKETS && NULL != config->haddr[i]; i++)
1925    {
1926       if ((*config->haddr[i] == '[')
1927          && (NULL != (p = strchr(config->haddr[i], ']')))
1928          && (p[1] == ':')
1929          && (0 < (config->hport[i] = atoi(p + 2))))
1930       {
1931          *p = '\0';
1932          memmove((void *)config->haddr[i], config->haddr[i] + 1,
1933             (size_t)(p - config->haddr[i]));
1934       }
1935       else if (NULL != (p = strchr(config->haddr[i], ':'))
1936          && (0 < (config->hport[i] = atoi(p + 1))))
1937       {
1938          *p = '\0';
1939       }
1940       else
1941       {
1942          log_error(LOG_LEVEL_FATAL, "invalid bind port spec %s", config->haddr[i]);
1943          /* Never get here - LOG_LEVEL_FATAL causes program exit */
1944       }
1945       if (*config->haddr[i] == '\0')
1946       {
1947          /*
1948           * Only the port specified. We stored it in config->hport[i]
1949           * and don't need its text representation anymore.
1950           * Use config->hport[i] == 0 to iterate listening addresses since
1951           * now.
1952           */
1953          freez(config->haddr[i]);
1954       }
1955    }
1956
1957    /*
1958     * Want to run all the loaders once now.
1959     *
1960     * Need to set up a fake csp, so they can get to the config.
1961     */
1962    fake_csp = zalloc_or_die(sizeof(*fake_csp));
1963    fake_csp->config = config;
1964
1965    if (run_loader(fake_csp))
1966    {
1967       freez(fake_csp);
1968       log_error(LOG_LEVEL_FATAL, "A loader failed while loading config file. Exiting.");
1969       /* Never get here - LOG_LEVEL_FATAL causes program exit */
1970    }
1971    freez(fake_csp);
1972
1973 /* FIXME: this is a kludge for win32 */
1974 #if defined(_WIN32) && !defined (_WIN_CONSOLE)
1975
1976    g_default_actions_file = config->actions_file[1]; /* FIXME Hope this is default.action */
1977    g_user_actions_file  = config->actions_file[2];  /* FIXME Hope this is user.action */
1978    g_default_filterfile = config->re_filterfile[0]; /* FIXME Hope this is default.filter */
1979    g_user_filterfile    = config->re_filterfile[1]; /* FIXME Hope this is user.filter */
1980
1981 #ifdef FEATURE_TRUST
1982    g_trustfile        = config->trustfile;
1983 #endif /* def FEATURE_TRUST */
1984
1985
1986 #endif /* defined(_WIN32) && !defined (_WIN_CONSOLE) */
1987 /* FIXME: end kludge */
1988
1989
1990    if (current_configfile == NULL)
1991    {
1992       config->need_bind = 1;
1993    }
1994    else
1995    {
1996       struct configuration_spec * oldcfg = (struct configuration_spec *)
1997                                            current_configfile->f;
1998       /*
1999        * Check if config->haddr[i],hport[i] == oldcfg->haddr[i],hport[i]
2000        */
2001       config->need_bind = 0;
2002
2003       for (i = 0; i < MAX_LISTENING_SOCKETS; i++)
2004       {
2005          if (config->hport[i] != oldcfg->hport[i])
2006          {
2007             config->need_bind = 1;
2008          }
2009          else if (config->haddr[i] == NULL)
2010          {
2011             if (oldcfg->haddr[i] != NULL)
2012             {
2013                config->need_bind = 1;
2014             }
2015          }
2016          else if (oldcfg->haddr[i] == NULL)
2017          {
2018             config->need_bind = 1;
2019          }
2020          else if (0 != strcmp(config->haddr[i], oldcfg->haddr[i]))
2021          {
2022             config->need_bind = 1;
2023          }
2024       }
2025
2026       current_configfile->unloader = unload_configfile;
2027    }
2028
2029    fs->next = files->next;
2030    files->next = fs;
2031
2032    current_configfile = fs;
2033
2034    return (config);
2035 }
2036
2037
2038 /*********************************************************************
2039  *
2040  * Function    :  savearg
2041  *
2042  * Description :  Called from `load_config'.  It saves each non-empty
2043  *                and non-comment line from config into
2044  *                config->proxy_args.  This is used to create the
2045  *                show-status page.  On error, frees
2046  *                config->proxy_args and sets it to NULL
2047  *
2048  * Parameters  :
2049  *          1  :  command = config setting that was found
2050  *          2  :  argument = the setting's argument (if any)
2051  *          3  :  config = Configuration to save into.
2052  *
2053  * Returns     :  N/A
2054  *
2055  *********************************************************************/
2056 static void savearg(char *command, char *argument, struct configuration_spec * config)
2057 {
2058    char * buf;
2059    char * s;
2060
2061    assert(command);
2062    assert(argument);
2063
2064    /*
2065     * Add config option name embedded in
2066     * link to its section in the user-manual
2067     */
2068    buf = strdup_or_die("\n<a href=\"");
2069    if (!strncmpic(config->usermanual, "file://", 7) ||
2070        !strncmpic(config->usermanual, "http", 4))
2071    {
2072       string_append(&buf, config->usermanual);
2073    }
2074    else
2075    {
2076       string_append(&buf, "http://" CGI_SITE_2_HOST "/user-manual/");
2077    }
2078    string_append(&buf, CONFIG_HELP_PREFIX);
2079    string_join  (&buf, string_toupper(command));
2080    string_append(&buf, "\">");
2081    string_append(&buf, command);
2082    string_append(&buf, "</a> ");
2083
2084    if (NULL == buf)
2085    {
2086       freez(config->proxy_args);
2087       return;
2088    }
2089
2090    if ((NULL != argument) && ('\0' != *argument))
2091    {
2092       s = html_encode(argument);
2093       if (NULL == s)
2094       {
2095          freez(buf);
2096          freez(config->proxy_args);
2097          return;
2098       }
2099
2100       if (strncmpic(argument, "http://", 7) == 0)
2101       {
2102          string_append(&buf, "<a href=\"");
2103          string_append(&buf, s);
2104          string_append(&buf, "\">");
2105          string_join  (&buf, s);
2106          string_append(&buf, "</a>");
2107       }
2108       else
2109       {
2110          string_join  (&buf, s);
2111       }
2112    }
2113
2114    string_append(&buf, "<br>");
2115    string_join(&config->proxy_args, buf);
2116 }
2117
2118
2119 /*
2120   Local Variables:
2121   tab-width: 3
2122   end:
2123 */