src/cache_cf.cc

   1 /*
   2  * $Id$
   3  *
   4  * DEBUG: section 03    Configuration File Parsing
   5  * AUTHOR: Harvest Derived
   6  *
   7  * SQUID Web Proxy Cache          http://www.squid-cache.org/
   8  * ----------------------------------------------------------
   9  *
  10  *  Squid is the result of efforts by numerous individuals from
  11  *  the Internet community; see the CONTRIBUTORS file for full
  12  *  details.   Many organizations have provided support for Squid's
  13  *  development; see the SPONSORS file for full details.  Squid is
  14  *  Copyrighted (C) 2001 by the Regents of the University of
  15  *  California; see the COPYRIGHT file for full details.  Squid
  16  *  incorporates software developed and/or copyrighted by other
  17  *  sources; see the CREDITS file for full details.
  18  *
  19  *  This program is free software; you can redistribute it and/or modify
  20  *  it under the terms of the GNU General Public License as published by
  21  *  the Free Software Foundation; either version 2 of the License, or
  22  *  (at your option) any later version.
  23  *
  24  *  This program is distributed in the hope that it will be useful,
  25  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  26  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  27  *  GNU General Public License for more details.
  28  *
  29  *  You should have received a copy of the GNU General Public License
  30  *  along with this program; if not, write to the Free Software
  31  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
  32  *
  33  */
  34
  35 #include "squid.h"
  36
  37 #include "acl/Acl.h"
  38 #include "acl/Gadgets.h"
  39 #include "acl/MethodData.h"
  40 #if USE_ADAPTATION
  41 #include "adaptation/Config.h"
  42 #endif
  43 #if ICAP_CLIENT
  44 #include "adaptation/icap/Config.h"
  45 #endif
  46 #if USE_ECAP
  47 #include "adaptation/ecap/Config.h"
  48 #endif
  49 #if USE_SSL
  50 #include "ssl/support.h"
  51 #include "ssl/Config.h"
  52 #endif
  53 #if USE_AUTH
  54 #include "auth/Config.h"
  55 #include "auth/Scheme.h"
  56 #endif
  57 #include "ConfigParser.h"
  58 #include "CpuAffinityMap.h"
  59 #include "eui/Config.h"
  60 #if USE_SQUID_ESI
  61 #include "esi/Parser.h"
  62 #endif
  63 #include "format/Format.h"
  64 #include "HttpRequestMethod.h"
  65 #include "ident/Config.h"
  66 #include "ip/Intercept.h"
  67 #include "ip/QosConfig.h"
  68 #include "ip/tools.h"
  69 #include "log/Config.h"
  70 #include "MemBuf.h"
  71 #include "mgr/Registration.h"
  72 #include "Parsing.h"
  73 #include "ProtoPort.h"
  74 #include "rfc1738.h"
  75 #if SQUID_SNMP
  76 #include "snmp.h"
  77 #endif
  78 #include "Store.h"
  79 #include "StoreFileSystem.h"
  80 #include "SwapDir.h"
  81 #include "wordlist.h"
  82 #include "ipc/Kids.h"
  83
  84 #if HAVE_GLOB_H
  85 #include <glob.h>
  86 #endif
  87
  88 #if HAVE_LIMITS_H
  89 #include <limits>
  90 #endif
  91
  92 #if USE_SSL
  93 #include "ssl/gadgets.h"
  94 #endif
  95
  96 #if USE_ADAPTATION
  97 static void parse_adaptation_service_set_type();
  98 static void parse_adaptation_service_chain_type();
  99 static void parse_adaptation_access_type();
 100 #endif
 101
 102 #if ICAP_CLIENT
 103 static void parse_icap_service_type(Adaptation::Icap::Config *);
 104 static void dump_icap_service_type(StoreEntry *, const char *, const Adaptation::Icap::Config &);
 105 static void free_icap_service_type(Adaptation::Icap::Config *);
 106 static void parse_icap_class_type();
 107 static void parse_icap_access_type();
 108
 109 static void parse_icap_service_failure_limit(Adaptation::Icap::Config *);
 110 static void dump_icap_service_failure_limit(StoreEntry *, const char *, const Adaptation::Icap::Config &);
 111 static void free_icap_service_failure_limit(Adaptation::Icap::Config *);
 112 #endif
 113
 114 #if USE_ECAP
 115 static void parse_ecap_service_type(Adaptation::Ecap::Config *);
 116 static void dump_ecap_service_type(StoreEntry *, const char *, const Adaptation::Ecap::Config &);
 117 static void free_ecap_service_type(Adaptation::Ecap::Config *);
 118 #endif
 119
 120 CBDATA_TYPE(peer);
 121
 122 static const char *const T_MILLISECOND_STR = "millisecond";
 123 static const char *const T_SECOND_STR = "second";
 124 static const char *const T_MINUTE_STR = "minute";
 125 static const char *const T_HOUR_STR = "hour";
 126 static const char *const T_DAY_STR = "day";
 127 static const char *const T_WEEK_STR = "week";
 128 static const char *const T_FORTNIGHT_STR = "fortnight";
 129 static const char *const T_MONTH_STR = "month";
 130 static const char *const T_YEAR_STR = "year";
 131 static const char *const T_DECADE_STR = "decade";
 132
 133 static const char *const B_BYTES_STR = "bytes";
 134 static const char *const B_KBYTES_STR = "KB";
 135 static const char *const B_MBYTES_STR = "MB";
 136 static const char *const B_GBYTES_STR = "GB";
 137
 138 static const char *const list_sep = ", \t\n\r";
 139
 140 static void parse_access_log(customlog ** customlog_definitions);
 141 static int check_null_access_log(customlog *customlog_definitions);
 142 static void dump_access_log(StoreEntry * entry, const char *name, customlog * definitions);
 143 static void free_access_log(customlog ** definitions);
 144
 145 static void update_maxobjsize(void);
 146 static void configDoConfigure(void);
 147 static void parse_refreshpattern(refresh_t **);
 148 static uint64_t parseTimeUnits(const char *unit,  bool allowMsec);
 149 static void parseTimeLine(time_msec_t * tptr, const char *units, bool allowMsec);
 150 static void parse_u_short(unsigned short * var);
 151 static void parse_string(char **);
 152 static void default_all(void);
 153 static void defaults_if_none(void);
 154 static int parse_line(char *);
 155 static void parse_obsolete(const char *);
 156 static void parseBytesLine(size_t * bptr, const char *units);
 157 #if USE_SSL
 158 static void parseBytesOptionValue(size_t * bptr, const char *units, char const * value);
 159 #endif
 160 #if !USE_DNSSERVERS
 161 static void parseBytesLineSigned(ssize_t * bptr, const char *units);
 162 #endif
 163 static size_t parseBytesUnits(const char *unit);
 164 static void free_all(void);
 165 void requirePathnameExists(const char *name, const char *path);
 166 static OBJH dump_config;
 167 #if USE_HTTP_VIOLATIONS
 168 static void dump_http_header_access(StoreEntry * entry, const char *name, header_mangler header[]);
 169 static void parse_http_header_access(header_mangler header[]);
 170 static void free_http_header_access(header_mangler header[]);
 171 static void dump_http_header_replace(StoreEntry * entry, const char *name, header_mangler header[]);
 172 static void parse_http_header_replace(header_mangler * header);
 173 static void free_http_header_replace(header_mangler * header);
 174 #endif
 175 static void parse_denyinfo(acl_deny_info_list ** var);
 176 static void dump_denyinfo(StoreEntry * entry, const char *name, acl_deny_info_list * var);
 177 static void free_denyinfo(acl_deny_info_list ** var);
 178
 179 #if USE_WCCPv2
 180 static void parse_IpAddress_list(Ip::Address_list **);
 181 static void dump_IpAddress_list(StoreEntry *, const char *, const Ip::Address_list *);
 182 static void free_IpAddress_list(Ip::Address_list **);
 183 #if CURRENTLY_UNUSED
 184 static int check_null_IpAddress_list(const Ip::Address_list *);
 185 #endif /* CURRENTLY_UNUSED */
 186 #endif /* USE_WCCPv2 */
 187
 188 static void parse_http_port_list(http_port_list **);
 189 static void dump_http_port_list(StoreEntry *, const char *, const http_port_list *);
 190 static void free_http_port_list(http_port_list **);
 191
 192 #if USE_SSL
 193 static void parse_https_port_list(https_port_list **);
 194 static void dump_https_port_list(StoreEntry *, const char *, const https_port_list *);
 195 static void free_https_port_list(https_port_list **);
 196 #if 0
 197 static int check_null_https_port_list(const https_port_list *);
 198 #endif
 199 #endif /* USE_SSL */
 200
 201 static void parse_b_size_t(size_t * var);
 202 static void parse_b_int64_t(int64_t * var);
 203
 204 static bool parseNamedIntList(const char *data, const String &name, Vector<int> &list);
 205
 206 static void parse_CpuAffinityMap(CpuAffinityMap **const cpuAffinityMap);
 207 static void dump_CpuAffinityMap(StoreEntry *const entry, const char *const name, const CpuAffinityMap *const cpuAffinityMap);
 208 static void free_CpuAffinityMap(CpuAffinityMap **const cpuAffinityMap);
 209
 210 static int parseOneConfigFile(const char *file_name, unsigned int depth);
 211
 212 /*
 213  * LegacyParser is a parser for legacy code that uses the global
 214  * approach.  This is static so that it is only exposed to cache_cf.
 215  * Other modules needing access to a ConfigParser should have it
 216  * provided to them in their parserFOO methods.
 217  */
 218 static ConfigParser LegacyParser = ConfigParser();
 219
 220 void
 221 self_destruct(void)
 222 {
 223     LegacyParser.destruct();
 224 }
 225
 226 static void
 227 update_maxobjsize(void)
 228 {
 229     int i;
 230     int64_t ms = -1;
 231
 232     for (i = 0; i < Config.cacheSwap.n_configured; i++) {
 233         assert (Config.cacheSwap.swapDirs[i].getRaw());
 234
 235         if (dynamic_cast<SwapDir *>(Config.cacheSwap.swapDirs[i].getRaw())->
 236                 max_objsize > ms)
 237             ms = dynamic_cast<SwapDir *>(Config.cacheSwap.swapDirs[i].getRaw())->max_objsize;
 238     }
 239     store_maxobjsize = ms;
 240 }
 241
 242 static void
 243 SetConfigFilename(char const *file_name, bool is_pipe)
 244 {
 245     cfg_filename = file_name;
 246
 247     char const *token;
 248
 249     if (is_pipe)
 250         cfg_filename = file_name + 1;
 251     else if ((token = strrchr(cfg_filename, '/')))
 252         cfg_filename = token + 1;
 253 }
 254
 255 static const char*
 256 skip_ws(const char* s)
 257 {
 258     while (xisspace(*s))
 259         ++s;
 260
 261     return s;
 262 }
 263
 264 static int
 265 parseManyConfigFiles(char* files, int depth)
 266 {
 267     int error_count = 0;
 268     char* saveptr = NULL;
 269 #if HAVE_GLOB
 270     char *path;
 271     glob_t globbuf;
 272     int i;
 273     memset(&globbuf, 0, sizeof(globbuf));
 274     for (path = strwordtok(files, &saveptr); path; path = strwordtok(NULL, &saveptr)) {
 275         if (glob(path, globbuf.gl_pathc ? GLOB_APPEND : 0, NULL, &globbuf) != 0) {
 276             fatalf("Unable to find configuration file: %s: %s",
 277                    path, xstrerror());
 278         }
 279     }
 280     for (i = 0; i < (int)globbuf.gl_pathc; i++) {
 281         error_count += parseOneConfigFile(globbuf.gl_pathv[i], depth);
 282     }
 283     globfree(&globbuf);
 284 #else
 285     char* file = strwordtok(files, &saveptr);
 286     while (file != NULL) {
 287         error_count += parseOneConfigFile(file, depth);
 288         file = strwordtok(NULL, &saveptr);
 289     }
 290 #endif /* HAVE_GLOB */
 291     return error_count;
 292 }
 293
 294 static void
 295 ReplaceSubstr(char*& str, int& len, unsigned substrIdx, unsigned substrLen, const char* newSubstr)
 296 {
 297     assert(str != NULL);
 298     assert(newSubstr != NULL);
 299
 300     unsigned newSubstrLen = strlen(newSubstr);
 301     if (newSubstrLen > substrLen)
 302         str = (char*)realloc(str, len - substrLen + newSubstrLen + 1);
 303
 304     // move tail part including zero
 305     memmove(str + substrIdx + newSubstrLen, str + substrIdx + substrLen, len - substrIdx - substrLen + 1);
 306     // copy new substring in place
 307     memcpy(str + substrIdx, newSubstr, newSubstrLen);
 308
 309     len = strlen(str);
 310 }
 311
 312 static void
 313 SubstituteMacro(char*& line, int& len, const char* macroName, const char* substStr)
 314 {
 315     assert(line != NULL);
 316     assert(macroName != NULL);
 317     assert(substStr != NULL);
 318     unsigned macroNameLen = strlen(macroName);
 319     while (const char* macroPos = strstr(line, macroName)) // we would replace all occurrences
 320         ReplaceSubstr(line, len, macroPos - line, macroNameLen, substStr);
 321 }
 322
 323 static void
 324 ProcessMacros(char*& line, int& len)
 325 {
 326     SubstituteMacro(line, len, "${process_name}", TheKidName);
 327     SubstituteMacro(line, len, "${process_number}", xitoa(KidIdentifier));
 328 }
 329
 330 static void
 331 trim_trailing_ws(char* str)
 332 {
 333     assert(str != NULL);
 334     unsigned i = strlen(str);
 335     while ((i > 0) && xisspace(str[i - 1]))
 336         --i;
 337     str[i] = '\0';
 338 }
 339
 340 static const char*
 341 FindStatement(const char* line, const char* statement)
 342 {
 343     assert(line != NULL);
 344     assert(statement != NULL);
 345
 346     const char* str = skip_ws(line);
 347     unsigned len = strlen(statement);
 348     if (strncmp(str, statement, len) == 0) {
 349         str += len;
 350         if (*str == '\0')
 351             return str;
 352         else if (xisspace(*str))
 353             return skip_ws(str);
 354     }
 355
 356     return NULL;
 357 }
 358
 359 static bool
 360 StrToInt(const char* str, long& number)
 361 {
 362     assert(str != NULL);
 363
 364     char* end;
 365     number = strtol(str, &end, 0);
 366
 367     return (end != str) && (*end == '\0'); // returns true if string contains nothing except number
 368 }
 369
 370 static bool
 371 EvalBoolExpr(const char* expr)
 372 {
 373     assert(expr != NULL);
 374     if (strcmp(expr, "true") == 0) {
 375         return true;
 376     } else if (strcmp(expr, "false") == 0) {
 377         return false;
 378     } else if (const char* equation = strchr(expr, '=')) {
 379         const char* rvalue = skip_ws(equation + 1);
 380         char* lvalue = (char*)xmalloc(equation - expr + 1);
 381         xstrncpy(lvalue, expr, equation - expr + 1);
 382         trim_trailing_ws(lvalue);
 383
 384         long number1;
 385         if (!StrToInt(lvalue, number1))
 386             fatalf("String is not a integer number: '%s'\n", lvalue);
 387         long number2;
 388         if (!StrToInt(rvalue, number2))
 389             fatalf("String is not a integer number: '%s'\n", rvalue);
 390
 391         xfree(lvalue);
 392         return number1 == number2;
 393     }
 394     fatalf("Unable to evaluate expression '%s'\n", expr);
 395     return false; // this place cannot be reached
 396 }
 397
 398 static int
 399 parseOneConfigFile(const char *file_name, unsigned int depth)
 400 {
 401     FILE *fp = NULL;
 402     const char *orig_cfg_filename = cfg_filename;
 403     const int orig_config_lineno = config_lineno;
 404     char *token = NULL;
 405     char *tmp_line = NULL;
 406     int tmp_line_len = 0;
 407     int err_count = 0;
 408     int is_pipe = 0;
 409
 410     debugs(3, 1, "Processing Configuration File: " << file_name << " (depth " << depth << ")");
 411     if (depth > 16) {
 412         fatalf("WARNING: can't include %s: includes are nested too deeply (>16)!\n", file_name);
 413         return 1;
 414     }
 415
 416     if (file_name[0] == '!' || file_name[0] == '|') {
 417         fp = popen(file_name + 1, "r");
 418         is_pipe = 1;
 419     } else {
 420         fp = fopen(file_name, "r");
 421     }
 422
 423     if (fp == NULL)
 424         fatalf("Unable to open configuration file: %s: %s", file_name, xstrerror());
 425
 426 #if _SQUID_WINDOWS_
 427     setmode(fileno(fp), O_TEXT);
 428 #endif
 429
 430     SetConfigFilename(file_name, bool(is_pipe));
 431
 432     memset(config_input_line, '\0', BUFSIZ);
 433
 434     config_lineno = 0;
 435
 436     Vector<bool> if_states;
 437     while (fgets(config_input_line, BUFSIZ, fp)) {
 438         config_lineno++;
 439
 440         if ((token = strchr(config_input_line, '\n')))
 441             *token = '\0';
 442
 443         if ((token = strchr(config_input_line, '\r')))
 444             *token = '\0';
 445
 446         // strip any prefix whitespace off the line.
 447         const char *p = skip_ws(config_input_line);
 448         if (config_input_line != p)
 449             memmove(config_input_line, p, strlen(p)+1);
 450
 451         if (strncmp(config_input_line, "#line ", 6) == 0) {
 452             static char new_file_name[1024];
 453             static char *file;
 454             static char new_lineno;
 455             token = config_input_line + 6;
 456             new_lineno = strtol(token, &file, 0) - 1;
 457
 458             if (file == token)
 459                 continue;       /* Not a valid #line directive, may be a comment */
 460
 461             while (*file && xisspace((unsigned char) *file))
 462                 file++;
 463
 464             if (*file) {
 465                 if (*file != '"')
 466                     continue;   /* Not a valid #line directive, may be a comment */
 467
 468                 xstrncpy(new_file_name, file + 1, sizeof(new_file_name));
 469
 470                 if ((token = strchr(new_file_name, '"')))
 471                     *token = '\0';
 472
 473                 cfg_filename = new_file_name;
 474             }
 475
 476             config_lineno = new_lineno;
 477         }
 478
 479         if (config_input_line[0] == '#')
 480             continue;
 481
 482         if (config_input_line[0] == '\0')
 483             continue;
 484
 485         const char* append = tmp_line_len ? skip_ws(config_input_line) : config_input_line;
 486
 487         size_t append_len = strlen(append);
 488
 489         tmp_line = (char*)xrealloc(tmp_line, tmp_line_len + append_len + 1);
 490
 491         strcpy(tmp_line + tmp_line_len, append);
 492
 493         tmp_line_len += append_len;
 494
 495         if (tmp_line[tmp_line_len-1] == '\\') {
 496             debugs(3, 5, "parseConfigFile: tmp_line='" << tmp_line << "'");
 497             tmp_line[--tmp_line_len] = '\0';
 498             continue;
 499         }
 500
 501         trim_trailing_ws(tmp_line);
 502         ProcessMacros(tmp_line, tmp_line_len);
 503         debugs(3, (opt_parse_cfg_only?1:5), "Processing: " << tmp_line);
 504
 505         if (const char* expr = FindStatement(tmp_line, "if")) {
 506             if_states.push_back(EvalBoolExpr(expr)); // store last if-statement meaning
 507         } else if (FindStatement(tmp_line, "endif")) {
 508             if (!if_states.empty())
 509                 if_states.pop_back(); // remove last if-statement meaning
 510             else
 511                 fatalf("'endif' without 'if'\n");
 512         } else if (FindStatement(tmp_line, "else")) {
 513             if (!if_states.empty())
 514                 if_states.back() = !if_states.back();
 515             else
 516                 fatalf("'else' without 'if'\n");
 517         } else if (if_states.empty() || if_states.back()) { // test last if-statement meaning if present
 518             /* Handle includes here */
 519             if (tmp_line_len >= 9 && strncmp(tmp_line, "include", 7) == 0 && xisspace(tmp_line[7])) {
 520                 err_count += parseManyConfigFiles(tmp_line + 8, depth + 1);
 521             } else if (!parse_line(tmp_line)) {
 522                 debugs(3, 0, HERE << cfg_filename << ":" << config_lineno << " unrecognized: '" << tmp_line << "'");
 523                 err_count++;
 524             }
 525         }
 526
 527         safe_free(tmp_line);
 528         tmp_line_len = 0;
 529
 530     }
 531     if (!if_states.empty())
 532         fatalf("if-statement without 'endif'\n");
 533
 534     if (is_pipe) {
 535         int ret = pclose(fp);
 536
 537         if (ret != 0)
 538             fatalf("parseConfigFile: '%s' failed with exit code %d\n", file_name, ret);
 539     } else {
 540         fclose(fp);
 541     }
 542
 543     cfg_filename = orig_cfg_filename;
 544     config_lineno = orig_config_lineno;
 545
 546     return err_count;
 547 }
 548
 549 int
 550 parseConfigFile(const char *file_name)
 551 {
 552     int err_count = 0;
 553
 554     debugs(5, 4, HERE);
 555
 556     configFreeMemory();
 557
 558     ACLMethodData::ThePurgeCount = 0;
 559     default_all();
 560
 561     err_count = parseOneConfigFile(file_name, 0);
 562
 563     defaults_if_none();
 564
 565     /*
 566      * We must call configDoConfigure() before leave_suid() because
 567      * configDoConfigure() is where we turn username strings into
 568      * uid values.
 569      */
 570     configDoConfigure();
 571
 572     if (!Config.chroot_dir) {
 573         leave_suid();
 574         setUmask(Config.umask);
 575         _db_init(Debug::cache_log, Debug::debugOptions);
 576         enter_suid();
 577     }
 578
 579     if (opt_send_signal == -1) {
 580         Mgr::RegisterAction("config",
 581                             "Current Squid Configuration",
 582                             dump_config,
 583                             1, 1);
 584     }
 585
 586     return err_count;
 587 }
 588
 589
 590 static void
 591 configDoConfigure(void)
 592 {
 593     memset(&Config2, '\0', sizeof(SquidConfig2));
 594     /* init memory as early as possible */
 595     memConfigure();
 596     /* Sanity checks */
 597
 598     if (Config.cacheSwap.swapDirs == NULL) {
 599         /* Memory-only cache probably in effect. */
 600         /* turn off the cache rebuild delays... */
 601         StoreController::store_dirs_rebuilding = 0;
 602     }
 603
 604     if (Debug::rotateNumber < 0) {
 605         Debug::rotateNumber = Config.Log.rotateNumber;
 606     }
 607
 608 #if SIZEOF_OFF_T <= 4
 609     if (Config.Store.maxObjectSize > 0x7FFF0000) {
 610         debugs(3, 0, "WARNING: This Squid binary can not handle files larger than 2GB. Limiting maximum_object_size to just below 2GB");
 611         Config.Store.maxObjectSize = 0x7FFF0000;
 612     }
 613 #endif
 614     if (0 == Store::Root().maxSize())
 615         /* people might want a zero-sized cache on purpose */
 616         (void) 0;
 617     else if (Store::Root().maxSize() < Config.memMaxSize)
 618         /* This is bogus. folk with NULL caches will want this */
 619         debugs(3, 0, "WARNING cache_mem is larger than total disk cache space!");
 620
 621     if (Config.Announce.period > 0) {
 622         Config.onoff.announce = 1;
 623     } else if (Config.Announce.period < 1) {
 624         Config.Announce.period = 86400 * 365;   /* one year */
 625         Config.onoff.announce = 0;
 626     }
 627
 628     if (Config.onoff.httpd_suppress_version_string)
 629         visible_appname_string = (char *)appname_string;
 630     else
 631         visible_appname_string = (char const *)APP_FULLNAME;
 632
 633 #if USE_DNSSERVERS
 634
 635     if (Config.dnsChildren.n_max < 1)
 636         fatal("No dnsservers allocated");
 637
 638 #endif
 639
 640     if (Config.Program.redirect) {
 641         if (Config.redirectChildren.n_max < 1) {
 642             Config.redirectChildren.n_max = 0;
 643             wordlistDestroy(&Config.Program.redirect);
 644         }
 645     }
 646
 647     if (Config.appendDomain)
 648         if (*Config.appendDomain != '.')
 649             fatal("append_domain must begin with a '.'");
 650
 651     if (Config.errHtmlText == NULL)
 652         Config.errHtmlText = xstrdup(null_string);
 653
 654 #if !HAVE_SETRLIMIT || !defined(RLIMIT_NOFILE)
 655     if (Config.max_filedescriptors > 0) {
 656         debugs(0, DBG_IMPORTANT, "WARNING: max_filedescriptors disabled. Operating System setrlimit(RLIMIT_NOFILE) is missing.");
 657     }
 658 #elif USE_SELECT || USE_SELECT_WIN32
 659     if (Config.max_filedescriptors > FD_SETSIZE) {
 660         debugs(0, DBG_IMPORTANT, "WARNING: max_filedescriptors limited to " << FD_SETSIZE << " by select() algorithm.");
 661     }
 662 #endif
 663
 664     storeConfigure();
 665
 666     snprintf(ThisCache, sizeof(ThisCache), "%s (%s)",
 667              uniqueHostname(),
 668              visible_appname_string);
 669
 670     /*
 671      * the extra space is for loop detection in client_side.c -- we search
 672      * for substrings in the Via header.
 673      */
 674     snprintf(ThisCache2, sizeof(ThisCache), " %s (%s)",
 675              uniqueHostname(),
 676              visible_appname_string);
 677
 678     /* Use visible_hostname as default surrogate_id */
 679     if (!Config.Accel.surrogate_id) {
 680         const char *t = getMyHostname();
 681         Config.Accel.surrogate_id = xstrdup( (t?t:"unset-id") );
 682     }
 683
 684     if (!Config.udpMaxHitObjsz || Config.udpMaxHitObjsz > SQUID_UDP_SO_SNDBUF)
 685         Config.udpMaxHitObjsz = SQUID_UDP_SO_SNDBUF;
 686
 687     if (Config.appendDomain)
 688         Config.appendDomainLen = strlen(Config.appendDomain);
 689     else
 690         Config.appendDomainLen = 0;
 691
 692     if (Config.connect_retries > 10) {
 693         debugs(0,DBG_CRITICAL, "WARNING: connect_retries cannot be larger than 10. Resetting to 10.");
 694         Config.connect_retries = 10;
 695     }
 696
 697     requirePathnameExists("MIME Config Table", Config.mimeTablePathname);
 698 #if USE_DNSSERVERS
 699
 700     requirePathnameExists("cache_dns_program", Config.Program.dnsserver);
 701 #endif
 702 #if USE_UNLINKD
 703
 704     requirePathnameExists("unlinkd_program", Config.Program.unlinkd);
 705 #endif
 706     requirePathnameExists("logfile_daemon", Log::TheConfig.logfile_daemon);
 707     if (Config.Program.redirect)
 708         requirePathnameExists("redirect_program", Config.Program.redirect->key);
 709
 710     requirePathnameExists("Icon Directory", Config.icons.directory);
 711
 712     if (Config.errorDirectory)
 713         requirePathnameExists("Error Directory", Config.errorDirectory);
 714
 715 #if USE_HTTP_VIOLATIONS
 716
 717     {
 718         const refresh_t *R;
 719
 720         for (R = Config.Refresh; R; R = R->next) {
 721             if (!R->flags.override_expire)
 722                 continue;
 723
 724             debugs(22, 1, "WARNING: use of 'override-expire' in 'refresh_pattern' violates HTTP");
 725
 726             break;
 727         }
 728
 729         for (R = Config.Refresh; R; R = R->next) {
 730             if (!R->flags.override_lastmod)
 731                 continue;
 732
 733             debugs(22, 1, "WARNING: use of 'override-lastmod' in 'refresh_pattern' violates HTTP");
 734
 735             break;
 736         }
 737
 738         for (R = Config.Refresh; R; R = R->next) {
 739             if (!R->flags.reload_into_ims)
 740                 continue;
 741
 742             debugs(22, 1, "WARNING: use of 'reload-into-ims' in 'refresh_pattern' violates HTTP");
 743
 744             break;
 745         }
 746
 747         for (R = Config.Refresh; R; R = R->next) {
 748             if (!R->flags.ignore_reload)
 749                 continue;
 750
 751             debugs(22, 1, "WARNING: use of 'ignore-reload' in 'refresh_pattern' violates HTTP");
 752
 753             break;
 754         }
 755
 756         for (R = Config.Refresh; R; R = R->next) {
 757             if (!R->flags.ignore_no_cache)
 758                 continue;
 759
 760             debugs(22, 1, "WARNING: use of 'ignore-no-cache' in 'refresh_pattern' violates HTTP");
 761
 762             break;
 763         }
 764
 765         for (R = Config.Refresh; R; R = R->next) {
 766             if (!R->flags.ignore_no_store)
 767                 continue;
 768
 769             debugs(22, 1, "WARNING: use of 'ignore-no-store' in 'refresh_pattern' violates HTTP");
 770
 771             break;
 772         }
 773
 774         for (R = Config.Refresh; R; R = R->next) {
 775             if (!R->flags.ignore_must_revalidate)
 776                 continue;
 777             debugs(22, 1, "WARNING: use of 'ignore-must-revalidate' in 'refresh_pattern' violates HTTP");
 778             break;
 779         }
 780
 781         for (R = Config.Refresh; R; R = R->next) {
 782             if (!R->flags.ignore_private)
 783                 continue;
 784
 785             debugs(22, 1, "WARNING: use of 'ignore-private' in 'refresh_pattern' violates HTTP");
 786
 787             break;
 788         }
 789
 790         for (R = Config.Refresh; R; R = R->next) {
 791             if (!R->flags.ignore_auth)
 792                 continue;
 793
 794             debugs(22, 1, "WARNING: use of 'ignore-auth' in 'refresh_pattern' violates HTTP");
 795
 796             break;
 797         }
 798
 799     }
 800 #endif
 801 #if !USE_HTTP_VIOLATIONS
 802     Config.onoff.via = 1;
 803 #else
 804
 805     if (!Config.onoff.via)
 806         debugs(22, 1, "WARNING: HTTP requires the use of Via");
 807
 808 #endif
 809
 810     // we enable runtime PURGE checks if there is at least one PURGE method ACL
 811     // TODO: replace with a dedicated "purge" ACL option?
 812     Config2.onoff.enable_purge = (ACLMethodData::ThePurgeCount > 0);
 813
 814     Config2.onoff.mangle_request_headers = httpReqHdrManglersConfigured();
 815
 816     if (geteuid() == 0) {
 817         if (NULL != Config.effectiveUser) {
 818
 819             struct passwd *pwd = getpwnam(Config.effectiveUser);
 820
 821             if (NULL == pwd) {
 822                 /*
 823                  * Andres Kroonmaa <andre@online.ee>:
 824                  * Some getpwnam() implementations (Solaris?) require
 825                  * an available FD < 256 for opening a FILE* to the
 826                  * passwd file.
 827                  * DW:
 828                  * This should be safe at startup, but might still fail
 829                  * during reconfigure.
 830                  */
 831                 fatalf("getpwnam failed to find userid for effective user '%s'",
 832                        Config.effectiveUser);
 833                 return;
 834             }
 835
 836             Config2.effectiveUserID = pwd->pw_uid;
 837
 838             Config2.effectiveGroupID = pwd->pw_gid;
 839
 840 #if HAVE_PUTENV
 841
 842             if (pwd->pw_dir && *pwd->pw_dir) {
 843                 int len;
 844                 char *env_str = (char *)xcalloc((len = strlen(pwd->pw_dir) + 6), 1);
 845                 snprintf(env_str, len, "HOME=%s", pwd->pw_dir);
 846                 putenv(env_str);
 847             }
 848
 849 #endif
 850
 851         }
 852     } else {
 853         Config2.effectiveUserID = geteuid();
 854         Config2.effectiveGroupID = getegid();
 855     }
 856
 857     if (NULL != Config.effectiveGroup) {
 858
 859         struct group *grp = getgrnam(Config.effectiveGroup);
 860
 861         if (NULL == grp) {
 862             fatalf("getgrnam failed to find groupid for effective group '%s'",
 863                    Config.effectiveGroup);
 864             return;
 865         }
 866
 867         Config2.effectiveGroupID = grp->gr_gid;
 868     }
 869
 870     HttpRequestMethod::Configure(Config);
 871 #if USE_SSL
 872
 873     debugs(3, 1, "Initializing https proxy context");
 874
 875     Config.ssl_client.sslContext = sslCreateClientContext(Config.ssl_client.cert, Config.ssl_client.key, Config.ssl_client.version, Config.ssl_client.cipher, Config.ssl_client.options, Config.ssl_client.flags, Config.ssl_client.cafile, Config.ssl_client.capath, Config.ssl_client.crlfile);
 876
 877     {
 878
 879         peer *p;
 880
 881         for (p = Config.peers; p != NULL; p = p->next) {
 882             if (p->use_ssl) {
 883                 debugs(3, 1, "Initializing cache_peer " << p->name << " SSL context");
 884                 p->sslContext = sslCreateClientContext(p->sslcert, p->sslkey, p->sslversion, p->sslcipher, p->ssloptions, p->sslflags, p->sslcafile, p->sslcapath, p->sslcrlfile);
 885             }
 886         }
 887     }
 888
 889     {
 890
 891         http_port_list *s;
 892
 893         for (s = Config.Sockaddr.http; s != NULL; s = (http_port_list *) s->next) {
 894             if (!s->cert && !s->key)
 895                 continue;
 896
 897             debugs(3, 1, "Initializing http_port " << s->http.s << " SSL context");
 898
 899             s->staticSslContext.reset(
 900                 sslCreateServerContext(s->cert, s->key,
 901                                        s->version, s->cipher, s->options, s->sslflags, s->clientca,
 902                                        s->cafile, s->capath, s->crlfile, s->dhfile,
 903                                        s->sslContextSessionId));
 904
 905             Ssl::readCertAndPrivateKeyFromFiles(s->signingCert, s->signPkey, s->cert, s->key);
 906         }
 907     }
 908
 909     {
 910
 911         https_port_list *s;
 912
 913         for (s = Config.Sockaddr.https; s != NULL; s = (https_port_list *) s->http.next) {
 914             debugs(3, 1, "Initializing https_port " << s->http.s << " SSL context");
 915
 916             s->staticSslContext.reset(
 917                 sslCreateServerContext(s->cert, s->key,
 918                                        s->version, s->cipher, s->options, s->sslflags, s->clientca,
 919                                        s->cafile, s->capath, s->crlfile, s->dhfile,
 920                                        s->sslContextSessionId));
 921         }
 922     }
 923
 924 #endif
 925
 926     // prevent infinite fetch loops in the request parser
 927     // due to buffer full but not enough data recived to finish parse
 928     if (Config.maxRequestBufferSize <= Config.maxRequestHeaderSize) {
 929         fatalf("Client request buffer of %u bytes cannot hold a request with %u bytes of headers." \
 930                " Change client_request_buffer_max or request_header_max_size limits.",
 931                (uint32_t)Config.maxRequestBufferSize, (uint32_t)Config.maxRequestHeaderSize);
 932     }
 933
 934 #if USE_AUTH
 935     /*
 936      * disable client side request pipelining. There is a race with
 937      * Negotiate and NTLM when the client sends a second request on an
 938      * connection before the authenticate challenge is sent. With
 939      * pipelining OFF, the client may fail to authenticate, but squid's
 940      * state will be preserved.
 941      */
 942     if (Config.onoff.pipeline_prefetch) {
 943         Auth::Config *nego = Auth::Config::Find("Negotiate");
 944         Auth::Config *ntlm = Auth::Config::Find("NTLM");
 945         if ((nego && nego->active()) || (ntlm && ntlm->active())) {
 946             debugs(3, DBG_IMPORTANT, "WARNING: pipeline_prefetch breaks NTLM and Negotiate authentication. Forced OFF.");
 947             Config.onoff.pipeline_prefetch = 0;
 948         }
 949     }
 950 #endif
 951 }
 952
 953 /** Parse a line containing an obsolete directive.
 954  * To upgrade it where possible instead of just "Bungled config" for
 955  * directives which cannot be marked as simply aliases of the some name.
 956  * For example if the parameter order and content has changed.
 957  * Or if the directive has been completely removed.
 958  */
 959 void
 960 parse_obsolete(const char *name)
 961 {
 962     // Directives which have been radically changed rather than removed
 963     if (!strcmp(name, "url_rewrite_concurrency")) {
 964         int cval;
 965         parse_int(&cval);
 966         debugs(3, DBG_CRITICAL, "WARNING: url_rewrite_concurrency upgrade overriding url_rewrite_children settings.");
 967         Config.redirectChildren.concurrency = cval;
 968     }
 969 }
 970
 971 /* Parse a time specification from the config file.  Store the
 972  * result in 'tptr', after converting it to 'units' */
 973 static void
 974 parseTimeLine(time_msec_t * tptr, const char *units,  bool allowMsec)
 975 {
 976     char *token;
 977     double d;
 978     time_msec_t m;
 979     time_msec_t u;
 980
 981     if ((u = parseTimeUnits(units, allowMsec)) == 0)
 982         self_destruct();
 983
 984     if ((token = strtok(NULL, w_space)) == NULL)
 985         self_destruct();
 986
 987     d = xatof(token);
 988
 989     m = u;                      /* default to 'units' if none specified */
 990
 991     if (0 == d)
 992         (void) 0;
 993     else if ((token = strtok(NULL, w_space)) == NULL)
 994         debugs(3, 0, "WARNING: No units on '" <<
 995                config_input_line << "', assuming " <<
 996                d << " " << units  );
 997     else if ((m = parseTimeUnits(token, allowMsec)) == 0)
 998         self_destruct();
 999
1000     *tptr = static_cast<time_msec_t>(m * d);
1001 }
1002
1003 static uint64_t
1004 parseTimeUnits(const char *unit, bool allowMsec)
1005 {
1006     if (allowMsec && !strncasecmp(unit, T_MILLISECOND_STR, strlen(T_MILLISECOND_STR)))
1007         return 1;
1008
1009     if (!strncasecmp(unit, T_SECOND_STR, strlen(T_SECOND_STR)))
1010         return 1000;
1011
1012     if (!strncasecmp(unit, T_MINUTE_STR, strlen(T_MINUTE_STR)))
1013         return 60 * 1000;
1014
1015     if (!strncasecmp(unit, T_HOUR_STR, strlen(T_HOUR_STR)))
1016         return 3600 * 1000;
1017
1018     if (!strncasecmp(unit, T_DAY_STR, strlen(T_DAY_STR)))
1019         return 86400 * 1000;
1020
1021     if (!strncasecmp(unit, T_WEEK_STR, strlen(T_WEEK_STR)))
1022         return 86400 * 7 * 1000;
1023
1024     if (!strncasecmp(unit, T_FORTNIGHT_STR, strlen(T_FORTNIGHT_STR)))
1025         return 86400 * 14 * 1000;
1026
1027     if (!strncasecmp(unit, T_MONTH_STR, strlen(T_MONTH_STR)))
1028         return static_cast<uint64_t>(86400) * 30 * 1000;
1029
1030     if (!strncasecmp(unit, T_YEAR_STR, strlen(T_YEAR_STR)))
1031         return static_cast<uint64_t>(86400 * 1000 * 365.2522);
1032
1033     if (!strncasecmp(unit, T_DECADE_STR, strlen(T_DECADE_STR)))
1034         return static_cast<uint64_t>(86400 * 1000 * 365.2522 * 10);
1035
1036     debugs(3, 1, "parseTimeUnits: unknown time unit '" << unit << "'");
1037
1038     return 0;
1039 }
1040
1041 static void
1042 parseBytesLine64(int64_t * bptr, const char *units)
1043 {
1044     char *token;
1045     double d;
1046     int64_t m;
1047     int64_t u;
1048
1049     if ((u = parseBytesUnits(units)) == 0) {
1050         self_destruct();
1051         return;
1052     }
1053
1054     if ((token = strtok(NULL, w_space)) == NULL) {
1055         self_destruct();
1056         return;
1057     }
1058
1059     if (strcmp(token, "none") == 0 || strcmp(token, "-1") == 0) {
1060         *bptr = -1;
1061         return;
1062     }
1063
1064     d = xatof(token);
1065
1066     m = u;                      /* default to 'units' if none specified */
1067
1068     if (0.0 == d)
1069         (void) 0;
1070     else if ((token = strtok(NULL, w_space)) == NULL)
1071         debugs(3, 0, "WARNING: No units on '" <<
1072                config_input_line << "', assuming " <<
1073                d << " " <<  units  );
1074     else if ((m = parseBytesUnits(token)) == 0) {
1075         self_destruct();
1076         return;
1077     }
1078
1079     *bptr = static_cast<int64_t>(m * d / u);
1080
1081     if (static_cast<double>(*bptr) * 2 != m * d / u * 2)
1082         self_destruct();
1083 }
1084
1085
1086 static void
1087 parseBytesLine(size_t * bptr, const char *units)
1088 {
1089     char *token;
1090     double d;
1091     int m;
1092     int u;
1093
1094     if ((u = parseBytesUnits(units)) == 0) {
1095         self_destruct();
1096         return;
1097     }
1098
1099     if ((token = strtok(NULL, w_space)) == NULL) {
1100         self_destruct();
1101         return;
1102     }
1103
1104     if (strcmp(token, "none") == 0 || strcmp(token, "-1") == 0) {
1105         *bptr = static_cast<size_t>(-1);
1106         return;
1107     }
1108
1109     d = xatof(token);
1110
1111     m = u;                      /* default to 'units' if none specified */
1112
1113     if (0.0 == d)
1114         (void) 0;
1115     else if ((token = strtok(NULL, w_space)) == NULL)
1116         debugs(3, 0, "WARNING: No units on '" <<
1117                config_input_line << "', assuming " <<
1118                d << " " <<  units  );
1119     else if ((m = parseBytesUnits(token)) == 0) {
1120         self_destruct();
1121         return;
1122     }
1123
1124     *bptr = static_cast<size_t>(m * d / u);
1125
1126     if (static_cast<double>(*bptr) * 2 != m * d / u * 2)
1127         self_destruct();
1128 }
1129
1130 #if !USE_DNSSERVERS
1131 static void
1132 parseBytesLineSigned(ssize_t * bptr, const char *units)
1133 {
1134     char *token;
1135     double d;
1136     int m;
1137     int u;
1138
1139     if ((u = parseBytesUnits(units)) == 0) {
1140         self_destruct();
1141         return;
1142     }
1143
1144     if ((token = strtok(NULL, w_space)) == NULL) {
1145         self_destruct();
1146         return;
1147     }
1148
1149     if (strcmp(token, "none") == 0 || token[0] == '-' /* -N */) {
1150         *bptr = -1;
1151         return;
1152     }
1153
1154     d = xatof(token);
1155
1156     m = u;                      /* default to 'units' if none specified */
1157
1158     if (0.0 == d)
1159         (void) 0;
1160     else if ((token = strtok(NULL, w_space)) == NULL)
1161         debugs(3, 0, "WARNING: No units on '" <<
1162                config_input_line << "', assuming " <<
1163                d << " " <<  units  );
1164     else if ((m = parseBytesUnits(token)) == 0) {
1165         self_destruct();
1166         return;
1167     }
1168
1169     *bptr = static_cast<size_t>(m * d / u);
1170
1171     if (static_cast<double>(*bptr) * 2 != m * d / u * 2)
1172         self_destruct();
1173 }
1174 #endif
1175
1176 #if USE_SSL
1177 /**
1178  * Parse bytes from a string.
1179  * Similar to the parseBytesLine function but parses the string value instead of
1180  * the current token value.
1181  */
1182 static void parseBytesOptionValue(size_t * bptr, const char *units, char const * value)
1183 {
1184     int u;
1185     if ((u = parseBytesUnits(units)) == 0) {
1186         self_destruct();
1187         return;
1188     }
1189
1190     // Find number from string beginning.
1191     char const * number_begin = value;
1192     char const * number_end = value;
1193
1194     while ((*number_end >= '0' && *number_end <= '9')) {
1195         number_end++;
1196     }
1197
1198     String number;
1199     number.limitInit(number_begin, number_end - number_begin);
1200
1201     int d = xatoi(number.termedBuf());
1202     int m;
1203     if ((m = parseBytesUnits(number_end)) == 0) {
1204         self_destruct();
1205         return;
1206     }
1207
1208     *bptr = static_cast<size_t>(m * d / u);
1209     if (static_cast<double>(*bptr) * 2 != m * d / u * 2)
1210         self_destruct();
1211 }
1212 #endif
1213
1214 static size_t
1215 parseBytesUnits(const char *unit)
1216 {
1217     if (!strncasecmp(unit, B_BYTES_STR, strlen(B_BYTES_STR)))
1218         return 1;
1219
1220     if (!strncasecmp(unit, B_KBYTES_STR, strlen(B_KBYTES_STR)))
1221         return 1 << 10;
1222
1223     if (!strncasecmp(unit, B_MBYTES_STR, strlen(B_MBYTES_STR)))
1224         return 1 << 20;
1225
1226     if (!strncasecmp(unit, B_GBYTES_STR, strlen(B_GBYTES_STR)))
1227         return 1 << 30;
1228
1229     debugs(3, DBG_CRITICAL, "WARNING: Unknown bytes unit '" << unit << "'");
1230
1231     return 0;
1232 }
1233
1234 /*****************************************************************************
1235  * Max
1236  *****************************************************************************/
1237
1238 static void
1239 dump_acl(StoreEntry * entry, const char *name, ACL * ae)
1240 {
1241     wordlist *w;
1242     wordlist *v;
1243
1244     while (ae != NULL) {
1245         debugs(3, 3, "dump_acl: " << name << " " << ae->name);
1246         storeAppendPrintf(entry, "%s %s %s ",
1247                           name,
1248                           ae->name,
1249                           ae->typeString());
1250         v = w = ae->dump();
1251
1252         while (v != NULL) {
1253             debugs(3, 3, "dump_acl: " << name << " " << ae->name << " " << v->key);
1254             storeAppendPrintf(entry, "%s ", v->key);
1255             v = v->next;
1256         }
1257
1258         storeAppendPrintf(entry, "\n");
1259         wordlistDestroy(&w);
1260         ae = ae->next;
1261     }
1262 }
1263
1264 static void
1265 parse_acl(ACL ** ae)
1266 {
1267     ACL::ParseAclLine(LegacyParser, ae);
1268 }
1269
1270 static void
1271 free_acl(ACL ** ae)
1272 {
1273     aclDestroyAcls(ae);
1274 }
1275
1276 void
1277 dump_acl_list(StoreEntry * entry, ACLList * head)
1278 {
1279     ACLList *l;
1280
1281     for (l = head; l; l = l->next) {
1282         storeAppendPrintf(entry, " %s%s",
1283                           l->op ? null_string : "!",
1284                           l->_acl->name);
1285     }
1286 }
1287
1288 void
1289 dump_acl_access(StoreEntry * entry, const char *name, acl_access * head)
1290 {
1291     acl_access *l;
1292
1293     for (l = head; l; l = l->next) {
1294         storeAppendPrintf(entry, "%s %s",
1295                           name,
1296                           l->allow ? "Allow" : "Deny");
1297         dump_acl_list(entry, l->aclList);
1298         storeAppendPrintf(entry, "\n");
1299     }
1300 }
1301
1302 static void
1303 parse_acl_access(acl_access ** head)
1304 {
1305     aclParseAccessLine(LegacyParser, head);
1306 }
1307
1308 static void
1309 free_acl_access(acl_access ** head)
1310 {
1311     aclDestroyAccessList(head);
1312 }
1313
1314 static void
1315 dump_address(StoreEntry * entry, const char *name, Ip::Address &addr)
1316 {
1317     char buf[MAX_IPSTRLEN];
1318     storeAppendPrintf(entry, "%s %s\n", name, addr.NtoA(buf,MAX_IPSTRLEN) );
1319 }
1320
1321 static void
1322 parse_address(Ip::Address *addr)
1323 {
1324     char *token = strtok(NULL, w_space);
1325
1326     if (!token) {
1327         self_destruct();
1328         return;
1329     }
1330
1331     if (!strcmp(token,"any_addr")) {
1332         addr->SetAnyAddr();
1333         (void) 0;
1334     } else if ( (!strcmp(token,"no_addr")) || (!strcmp(token,"full_mask")) ) {
1335         addr->SetNoAddr();
1336         (void) 0;
1337     } else
1338         *addr = token;
1339 }
1340
1341 static void
1342 free_address(Ip::Address *addr)
1343 {
1344     addr->SetEmpty();
1345 }
1346
1347 CBDATA_TYPE(acl_address);
1348
1349 static void
1350 dump_acl_address(StoreEntry * entry, const char *name, acl_address * head)
1351 {
1352     char buf[MAX_IPSTRLEN];
1353     acl_address *l;
1354
1355     for (l = head; l; l = l->next) {
1356         if (!l->addr.IsAnyAddr())
1357             storeAppendPrintf(entry, "%s %s", name, l->addr.NtoA(buf,MAX_IPSTRLEN));
1358         else
1359             storeAppendPrintf(entry, "%s autoselect", name);
1360
1361         dump_acl_list(entry, l->aclList);
1362
1363         storeAppendPrintf(entry, "\n");
1364     }
1365 }
1366
1367 static void
1368 freed_acl_address(void *data)
1369 {
1370     acl_address *l = static_cast<acl_address *>(data);
1371     aclDestroyAclList(&l->aclList);
1372 }
1373
1374 static void
1375 parse_acl_address(acl_address ** head)
1376 {
1377     acl_address *l;
1378     acl_address **tail = head;  /* sane name below */
1379     CBDATA_INIT_TYPE_FREECB(acl_address, freed_acl_address);
1380     l = cbdataAlloc(acl_address);
1381     parse_address(&l->addr);
1382     aclParseAclList(LegacyParser, &l->aclList);
1383
1384     while (*tail)
1385         tail = &(*tail)->next;
1386
1387     *tail = l;
1388 }
1389
1390 static void
1391 free_acl_address(acl_address ** head)
1392 {
1393     while (*head) {
1394         acl_address *l = *head;
1395         *head = l->next;
1396         cbdataFree(l);
1397     }
1398 }
1399
1400 CBDATA_TYPE(acl_tos);
1401
1402 static void
1403 dump_acl_tos(StoreEntry * entry, const char *name, acl_tos * head)
1404 {
1405     acl_tos *l;
1406
1407     for (l = head; l; l = l->next) {
1408         if (l->tos > 0)
1409             storeAppendPrintf(entry, "%s 0x%02X", name, l->tos);
1410         else
1411             storeAppendPrintf(entry, "%s none", name);
1412
1413         dump_acl_list(entry, l->aclList);
1414
1415         storeAppendPrintf(entry, "\n");
1416     }
1417 }
1418
1419 static void
1420 freed_acl_tos(void *data)
1421 {
1422     acl_tos *l = static_cast<acl_tos *>(data);
1423     aclDestroyAclList(&l->aclList);
1424 }
1425
1426 static void
1427 parse_acl_tos(acl_tos ** head)
1428 {
1429     acl_tos *l;
1430     acl_tos **tail = head;      /* sane name below */
1431     unsigned int tos;           /* Initially uint for strtoui. Casted to tos_t before return */
1432     char *token = strtok(NULL, w_space);
1433
1434     if (!token) {
1435         self_destruct();
1436         return;
1437     }
1438
1439     if (!xstrtoui(token, NULL, &tos, 0, std::numeric_limits<tos_t>::max())) {
1440         self_destruct();
1441         return;
1442     }
1443
1444     CBDATA_INIT_TYPE_FREECB(acl_tos, freed_acl_tos);
1445
1446     l = cbdataAlloc(acl_tos);
1447
1448     l->tos = (tos_t)tos;
1449
1450     aclParseAclList(LegacyParser, &l->aclList);
1451
1452     while (*tail)
1453         tail = &(*tail)->next;
1454
1455     *tail = l;
1456 }
1457
1458 static void
1459 free_acl_tos(acl_tos ** head)
1460 {
1461     while (*head) {
1462         acl_tos *l = *head;
1463         *head = l->next;
1464         l->next = NULL;
1465         cbdataFree(l);
1466     }
1467 }
1468
1469 #if SO_MARK && USE_LIBCAP
1470
1471 CBDATA_TYPE(acl_nfmark);
1472
1473 static void
1474 dump_acl_nfmark(StoreEntry * entry, const char *name, acl_nfmark * head)
1475 {
1476     acl_nfmark *l;
1477
1478     for (l = head; l; l = l->next) {
1479         if (l->nfmark > 0)
1480             storeAppendPrintf(entry, "%s 0x%02X", name, l->nfmark);
1481         else
1482             storeAppendPrintf(entry, "%s none", name);
1483
1484         dump_acl_list(entry, l->aclList);
1485
1486         storeAppendPrintf(entry, "\n");
1487     }
1488 }
1489
1490 static void
1491 freed_acl_nfmark(void *data)
1492 {
1493     acl_nfmark *l = static_cast<acl_nfmark *>(data);
1494     aclDestroyAclList(&l->aclList);
1495 }
1496
1497 static void
1498 parse_acl_nfmark(acl_nfmark ** head)
1499 {
1500     acl_nfmark *l;
1501     acl_nfmark **tail = head;   /* sane name below */
1502     nfmark_t mark;
1503     char *token = strtok(NULL, w_space);
1504
1505     if (!token) {
1506         self_destruct();
1507         return;
1508     }
1509
1510     if (!xstrtoui(token, NULL, &mark, 0, std::numeric_limits<nfmark_t>::max())) {
1511         self_destruct();
1512         return;
1513     }
1514
1515     CBDATA_INIT_TYPE_FREECB(acl_nfmark, freed_acl_nfmark);
1516
1517     l = cbdataAlloc(acl_nfmark);
1518
1519     l->nfmark = mark;
1520
1521     aclParseAclList(LegacyParser, &l->aclList);
1522
1523     while (*tail)
1524         tail = &(*tail)->next;
1525
1526     *tail = l;
1527 }
1528
1529 static void
1530 free_acl_nfmark(acl_nfmark ** head)
1531 {
1532     while (*head) {
1533         acl_nfmark *l = *head;
1534         *head = l->next;
1535         l->next = NULL;
1536         cbdataFree(l);
1537     }
1538 }
1539 #endif /* SO_MARK */
1540
1541 CBDATA_TYPE(acl_size_t);
1542
1543 static void
1544 dump_acl_b_size_t(StoreEntry * entry, const char *name, acl_size_t * head)
1545 {
1546     acl_size_t *l;
1547
1548     for (l = head; l; l = l->next) {
1549         if (l->size != -1)
1550             storeAppendPrintf(entry, "%s %d %s\n", name, (int) l->size, B_BYTES_STR);
1551         else
1552             storeAppendPrintf(entry, "%s none", name);
1553
1554         dump_acl_list(entry, l->aclList);
1555
1556         storeAppendPrintf(entry, "\n");
1557     }
1558 }
1559
1560 static void
1561 freed_acl_b_size_t(void *data)
1562 {
1563     acl_size_t *l = static_cast<acl_size_t *>(data);
1564     aclDestroyAclList(&l->aclList);
1565 }
1566
1567 static void
1568 parse_acl_b_size_t(acl_size_t ** head)
1569 {
1570     acl_size_t *l;
1571     acl_size_t **tail = head;   /* sane name below */
1572
1573     CBDATA_INIT_TYPE_FREECB(acl_size_t, freed_acl_b_size_t);
1574
1575     l = cbdataAlloc(acl_size_t);
1576
1577     parse_b_int64_t(&l->size);
1578
1579     aclParseAclList(LegacyParser, &l->aclList);
1580
1581     while (*tail)
1582         tail = &(*tail)->next;
1583
1584     *tail = l;
1585 }
1586
1587 static void
1588 free_acl_b_size_t(acl_size_t ** head)
1589 {
1590     while (*head) {
1591         acl_size_t *l = *head;
1592         *head = l->next;
1593         l->next = NULL;
1594         cbdataFree(l);
1595     }
1596 }
1597
1598 #if USE_DELAY_POOLS
1599
1600 #include "DelayPools.h"
1601 #include "DelayConfig.h"
1602 /* do nothing - free_delay_pool_count is the magic free function.
1603  * this is why delay_pool_count isn't just marked TYPE: u_short
1604  */
1605 #define free_delay_pool_class(X)
1606 #define free_delay_pool_access(X)
1607 #define free_delay_pool_rates(X)
1608 #define dump_delay_pool_class(X, Y, Z)
1609 #define dump_delay_pool_access(X, Y, Z)
1610 #define dump_delay_pool_rates(X, Y, Z)
1611
1612 static void
1613 free_delay_pool_count(DelayConfig * cfg)
1614 {
1615     cfg->freePoolCount();
1616 }
1617
1618 static void
1619 dump_delay_pool_count(StoreEntry * entry, const char *name, DelayConfig &cfg)
1620 {
1621     cfg.dumpPoolCount (entry, name);
1622 }
1623
1624 static void
1625 parse_delay_pool_count(DelayConfig * cfg)
1626 {
1627     cfg->parsePoolCount();
1628 }
1629
1630 static void
1631 parse_delay_pool_class(DelayConfig * cfg)
1632 {
1633     cfg->parsePoolClass();
1634 }
1635
1636 static void
1637 parse_delay_pool_rates(DelayConfig * cfg)
1638 {
1639     cfg->parsePoolRates();
1640 }
1641
1642 static void
1643 parse_delay_pool_access(DelayConfig * cfg)
1644 {
1645     cfg->parsePoolAccess(LegacyParser);
1646 }
1647
1648 #endif
1649
1650 #if USE_DELAY_POOLS
1651 #include "ClientDelayConfig.h"
1652 /* do nothing - free_client_delay_pool_count is the magic free function.
1653  * this is why client_delay_pool_count isn't just marked TYPE: u_short
1654  */
1655
1656 #define free_client_delay_pool_access(X)
1657 #define free_client_delay_pool_rates(X)
1658 #define dump_client_delay_pool_access(X, Y, Z)
1659 #define dump_client_delay_pool_rates(X, Y, Z)
1660
1661 static void
1662 free_client_delay_pool_count(ClientDelayConfig * cfg)
1663 {
1664     cfg->freePoolCount();
1665 }
1666
1667 static void
1668 dump_client_delay_pool_count(StoreEntry * entry, const char *name, ClientDelayConfig &cfg)
1669 {
1670     cfg.dumpPoolCount (entry, name);
1671 }
1672
1673 static void
1674 parse_client_delay_pool_count(ClientDelayConfig * cfg)
1675 {
1676     cfg->parsePoolCount();
1677 }
1678
1679 static void
1680 parse_client_delay_pool_rates(ClientDelayConfig * cfg)
1681 {
1682     cfg->parsePoolRates();
1683 }
1684
1685 static void
1686 parse_client_delay_pool_access(ClientDelayConfig * cfg)
1687 {
1688     cfg->parsePoolAccess(LegacyParser);
1689 }
1690 #endif
1691
1692 #if USE_HTTP_VIOLATIONS
1693 static void
1694 dump_http_header_access(StoreEntry * entry, const char *name, header_mangler header[])
1695 {
1696     int i;
1697
1698     for (i = 0; i < HDR_ENUM_END; i++) {
1699         if (header[i].access_list != NULL) {
1700             storeAppendPrintf(entry, "%s ", name);
1701             dump_acl_access(entry, httpHeaderNameById(i),
1702                             header[i].access_list);
1703         }
1704     }
1705 }
1706
1707 static void
1708 parse_http_header_access(header_mangler header[])
1709 {
1710     int id, i;
1711     char *t = NULL;
1712
1713     if ((t = strtok(NULL, w_space)) == NULL) {
1714         debugs(3, 0, "" << cfg_filename << " line " << config_lineno << ": " << config_input_line);
1715         debugs(3, 0, "parse_http_header_access: missing header name.");
1716         return;
1717     }
1718
1719     /* Now lookup index of header. */
1720     id = httpHeaderIdByNameDef(t, strlen(t));
1721
1722     if (strcmp(t, "All") == 0)
1723         id = HDR_ENUM_END;
1724     else if (strcmp(t, "Other") == 0)
1725         id = HDR_OTHER;
1726     else if (id == -1) {
1727         debugs(3, 0, "" << cfg_filename << " line " << config_lineno << ": " << config_input_line);
1728         debugs(3, 0, "parse_http_header_access: unknown header name '" << t << "'");
1729         return;
1730     }
1731
1732     if (id != HDR_ENUM_END) {
1733         parse_acl_access(&header[id].access_list);
1734     } else {
1735         char *next_string = t + strlen(t) - 1;
1736         *next_string = 'A';
1737         *(next_string + 1) = ' ';
1738
1739         for (i = 0; i < HDR_ENUM_END; i++) {
1740             char *new_string = xstrdup(next_string);
1741             strtok(new_string, w_space);
1742             parse_acl_access(&header[i].access_list);
1743             safe_free(new_string);
1744         }
1745     }
1746 }
1747
1748 static void
1749 free_http_header_access(header_mangler header[])
1750 {
1751     int i;
1752
1753     for (i = 0; i < HDR_ENUM_END; i++) {
1754         free_acl_access(&header[i].access_list);
1755     }
1756 }
1757
1758 static void
1759 dump_http_header_replace(StoreEntry * entry, const char *name, header_mangler
1760                          header[])
1761 {
1762     int i;
1763
1764     for (i = 0; i < HDR_ENUM_END; i++) {
1765         if (NULL == header[i].replacement)
1766             continue;
1767
1768         storeAppendPrintf(entry, "%s %s %s\n", name, httpHeaderNameById(i),
1769                           header[i].replacement);
1770     }
1771 }
1772
1773 static void
1774 parse_http_header_replace(header_mangler header[])
1775 {
1776     int id, i;
1777     char *t = NULL;
1778
1779     if ((t = strtok(NULL, w_space)) == NULL) {
1780         debugs(3, 0, "" << cfg_filename << " line " << config_lineno << ": " << config_input_line);
1781         debugs(3, 0, "parse_http_header_replace: missing header name.");
1782         return;
1783     }
1784
1785     /* Now lookup index of header. */
1786     id = httpHeaderIdByNameDef(t, strlen(t));
1787
1788     if (strcmp(t, "All") == 0)
1789         id = HDR_ENUM_END;
1790     else if (strcmp(t, "Other") == 0)
1791         id = HDR_OTHER;
1792     else if (id == -1) {
1793         debugs(3, 0, "" << cfg_filename << " line " << config_lineno << ": " << config_input_line);
1794         debugs(3, 0, "parse_http_header_replace: unknown header name " << t << ".");
1795
1796         return;
1797     }
1798
1799     if (id != HDR_ENUM_END) {
1800         if (header[id].replacement != NULL)
1801             safe_free(header[id].replacement);
1802
1803         header[id].replacement = xstrdup(t + strlen(t) + 1);
1804     } else {
1805         for (i = 0; i < HDR_ENUM_END; i++) {
1806             if (header[i].replacement != NULL)
1807                 safe_free(header[i].replacement);
1808
1809             header[i].replacement = xstrdup(t + strlen(t) + 1);
1810         }
1811     }
1812 }
1813
1814 static void
1815 free_http_header_replace(header_mangler header[])
1816 {
1817     int i;
1818
1819     for (i = 0; i < HDR_ENUM_END; i++) {
1820         if (header[i].replacement != NULL)
1821             safe_free(header[i].replacement);
1822     }
1823 }
1824
1825 #endif
1826
1827 static void
1828 dump_cachedir(StoreEntry * entry, const char *name, SquidConfig::_cacheSwap swap)
1829 {
1830     SwapDir *s;
1831     int i;
1832     assert (entry);
1833
1834     for (i = 0; i < swap.n_configured; i++) {
1835         s = dynamic_cast<SwapDir *>(swap.swapDirs[i].getRaw());
1836         if (!s) continue;
1837         storeAppendPrintf(entry, "%s %s %s", name, s->type(), s->path);
1838         s->dump(*entry);
1839         storeAppendPrintf(entry, "\n");
1840     }
1841 }
1842
1843 static int
1844 check_null_string(char *s)
1845 {
1846     return s == NULL;
1847 }
1848
1849 #if USE_AUTH
1850 static void
1851 parse_authparam(Auth::ConfigVector * config)
1852 {
1853     char *type_str;
1854     char *param_str;
1855
1856     if ((type_str = strtok(NULL, w_space)) == NULL)
1857         self_destruct();
1858
1859     if ((param_str = strtok(NULL, w_space)) == NULL)
1860         self_destruct();
1861
1862     /* find a configuration for the scheme in the currently parsed configs... */
1863     Auth::Config *schemeCfg = Auth::Config::Find(type_str);
1864
1865     if (schemeCfg == NULL) {
1866         /* Create a configuration based on the scheme info */
1867         Auth::Scheme::Pointer theScheme = Auth::Scheme::Find(type_str);
1868
1869         if (theScheme == NULL) {
1870             debugs(3, DBG_CRITICAL, "Parsing Config File: Unknown authentication scheme '" << type_str << "'.");
1871             self_destruct();
1872         }
1873
1874         config->push_back(theScheme->createConfig());
1875         schemeCfg = Auth::Config::Find(type_str);
1876         if (schemeCfg == NULL) {
1877             debugs(3, DBG_CRITICAL, "Parsing Config File: Corruption configuring authentication scheme '" << type_str << "'.");
1878             self_destruct();
1879         }
1880     }
1881
1882     schemeCfg->parse(schemeCfg, config->size(), param_str);
1883 }
1884
1885 static void
1886 free_authparam(Auth::ConfigVector * cfg)
1887 {
1888     /* Wipe the Auth globals and Detach/Destruct component config + state. */
1889     cfg->clean();
1890
1891     /* remove our pointers to the probably-dead sub-configs */
1892     while (cfg->size()) {
1893         cfg->pop_back();
1894     }
1895
1896     /* on reconfigure initialize new auth schemes for the new config. */
1897     if (reconfiguring) {
1898         Auth::Init();
1899     }
1900 }
1901
1902 static void
1903 dump_authparam(StoreEntry * entry, const char *name, Auth::ConfigVector cfg)
1904 {
1905     for (Auth::ConfigVector::iterator  i = cfg.begin(); i != cfg.end(); ++i)
1906         (*i)->dump(entry, name, (*i));
1907 }
1908 #endif /* USE_AUTH */
1909
1910 /* TODO: just return the object, the # is irrelevant */
1911 static int
1912 find_fstype(char *type)
1913 {
1914     for (size_t i = 0; i < StoreFileSystem::FileSystems().size(); ++i)
1915         if (strcasecmp(type, StoreFileSystem::FileSystems().items[i]->type()) == 0)
1916             return (int)i;
1917
1918     return (-1);
1919 }
1920
1921 static void
1922 parse_cachedir(SquidConfig::_cacheSwap * swap)
1923 {
1924     char *type_str;
1925     char *path_str;
1926     RefCount<SwapDir> sd;
1927     int i;
1928     int fs;
1929
1930     if ((type_str = strtok(NULL, w_space)) == NULL)
1931         self_destruct();
1932
1933     if ((path_str = strtok(NULL, w_space)) == NULL)
1934         self_destruct();
1935
1936     fs = find_fstype(type_str);
1937
1938     if (fs < 0)
1939         self_destruct();
1940
1941     /* reconfigure existing dir */
1942
1943     for (i = 0; i < swap->n_configured; i++) {
1944         assert (swap->swapDirs[i].getRaw());
1945
1946         if ((strcasecmp(path_str, dynamic_cast<SwapDir *>(swap->swapDirs[i].getRaw())->path)) == 0) {
1947             /* this is specific to on-fs Stores. The right
1948              * way to handle this is probably to have a mapping
1949              * from paths to stores, and have on-fs stores
1950              * register with that, and lookip in that in their
1951              * own setup logic. RBC 20041225. TODO.
1952              */
1953
1954             sd = dynamic_cast<SwapDir *>(swap->swapDirs[i].getRaw());
1955
1956             if (sd->type() != StoreFileSystem::FileSystems().items[fs]->type()) {
1957                 debugs(3, 0, "ERROR: Can't change type of existing cache_dir " <<
1958                        sd->type() << " " << sd->path << " to " << type_str << ". Restart required");
1959                 return;
1960             }
1961
1962             sd->reconfigure (i, path_str);
1963
1964             update_maxobjsize();
1965
1966             return;
1967         }
1968     }
1969
1970     /* new cache_dir */
1971     if (swap->n_configured > 63) {
1972         /* 7 bits, signed */
1973         debugs(3, DBG_CRITICAL, "WARNING: There is a fixed maximum of 63 cache_dir entries Squid can handle.");
1974         debugs(3, DBG_CRITICAL, "WARNING: '" << path_str << "' is one to many.");
1975         self_destruct();
1976         return;
1977     }
1978
1979     allocate_new_swapdir(swap);
1980
1981     swap->swapDirs[swap->n_configured] = StoreFileSystem::FileSystems().items[fs]->createSwapDir();
1982
1983     sd = dynamic_cast<SwapDir *>(swap->swapDirs[swap->n_configured].getRaw());
1984
1985     /* parse the FS parameters and options */
1986     sd->parse(swap->n_configured, path_str);
1987
1988     ++swap->n_configured;
1989
1990     if (sd->needsDiskStrand())
1991         ++swap->n_strands;
1992
1993     /* Update the max object size */
1994     update_maxobjsize();
1995 }
1996
1997 static const char *
1998 peer_type_str(const peer_t type)
1999 {
2000     const char * result;
2001
2002     switch (type) {
2003
2004     case PEER_PARENT:
2005         result = "parent";
2006         break;
2007
2008     case PEER_SIBLING:
2009         result = "sibling";
2010         break;
2011
2012     case PEER_MULTICAST:
2013         result = "multicast";
2014         break;
2015
2016     default:
2017         result = "unknown";
2018         break;
2019     }
2020
2021     return result;
2022 }
2023
2024 static void
2025 dump_peer(StoreEntry * entry, const char *name, peer * p)
2026 {
2027     domain_ping *d;
2028     domain_type *t;
2029     LOCAL_ARRAY(char, xname, 128);
2030
2031     while (p != NULL) {
2032         storeAppendPrintf(entry, "%s %s %s %d %d name=%s",
2033                           name,
2034                           p->host,
2035                           neighborTypeStr(p),
2036                           p->http_port,
2037                           p->icp.port,
2038                           p->name);
2039         dump_peer_options(entry, p);
2040
2041         for (d = p->peer_domain; d; d = d->next) {
2042             storeAppendPrintf(entry, "cache_peer_domain %s %s%s\n",
2043                               p->host,
2044                               d->do_ping ? null_string : "!",
2045                               d->domain);
2046         }
2047
2048         if (p->access) {
2049             snprintf(xname, 128, "cache_peer_access %s", p->name);
2050             dump_acl_access(entry, xname, p->access);
2051         }
2052
2053         for (t = p->typelist; t; t = t->next) {
2054             storeAppendPrintf(entry, "neighbor_type_domain %s %s %s\n",
2055                               p->host,
2056                               peer_type_str(t->type),
2057                               t->domain);
2058         }
2059
2060         p = p->next;
2061     }
2062 }
2063
2064 /**
2065  * utility function to prevent getservbyname() being called with a numeric value
2066  * on Windows at least it returns garage results.
2067  */
2068 static bool
2069 isUnsignedNumeric(const char *str, size_t len)
2070 {
2071     if (len < 1) return false;
2072
2073     for (; len >0 && *str; str++, len--) {
2074         if (! isdigit(*str))
2075             return false;
2076     }
2077     return true;
2078 }
2079
2080 /**
2081  \param proto   'tcp' or 'udp' for protocol
2082  \returns       Port the named service is supposed to be listening on.
2083  */
2084 static unsigned short
2085 GetService(const char *proto)
2086 {
2087     struct servent *port = NULL;
2088     /** Parses a port number or service name from the squid.conf */
2089     char *token = strtok(NULL, w_space);
2090     if (token == NULL) {
2091         self_destruct();
2092         return 0; /* NEVER REACHED */
2093     }
2094     /** Returns either the service port number from /etc/services */
2095     if ( !isUnsignedNumeric(token, strlen(token)) )
2096         port = getservbyname(token, proto);
2097     if (port != NULL) {
2098         return ntohs((unsigned short)port->s_port);
2099     }
2100     /** Or a numeric translation of the config text. */
2101     return xatos(token);
2102 }
2103
2104 /**
2105  \returns       Port the named TCP service is supposed to be listening on.
2106  \copydoc GetService(const char *proto)
2107  */
2108 inline unsigned short
2109 GetTcpService(void)
2110 {
2111     return GetService("tcp");
2112 }
2113
2114 /**
2115  \returns       Port the named UDP service is supposed to be listening on.
2116  \copydoc GetService(const char *proto)
2117  */
2118 inline unsigned short
2119 GetUdpService(void)
2120 {
2121     return GetService("udp");
2122 }
2123
2124 static void
2125 parse_peer(peer ** head)
2126 {
2127     char *token = NULL;
2128     peer *p;
2129     CBDATA_INIT_TYPE_FREECB(peer, peerDestroy);
2130     p = cbdataAlloc(peer);
2131     p->http_port = CACHE_HTTP_PORT;
2132     p->icp.port = CACHE_ICP_PORT;
2133     p->weight = 1;
2134     p->basetime = 0;
2135     p->stats.logged_state = PEER_ALIVE;
2136
2137     if ((token = strtok(NULL, w_space)) == NULL)
2138         self_destruct();
2139
2140     p->host = xstrdup(token);
2141
2142     p->name = xstrdup(token);
2143
2144     if ((token = strtok(NULL, w_space)) == NULL)
2145         self_destruct();
2146
2147     p->type = parseNeighborType(token);
2148
2149     if (p->type == PEER_MULTICAST) {
2150         p->options.no_digest = 1;
2151         p->options.no_netdb_exchange = 1;
2152     }
2153
2154     p->http_port = GetTcpService();
2155
2156     if (!p->http_port)
2157         self_destruct();
2158
2159     p->icp.port = GetUdpService();
2160     p->connection_auth = 2;    /* auto */
2161
2162     while ((token = strtok(NULL, w_space))) {
2163         if (!strcasecmp(token, "proxy-only")) {
2164             p->options.proxy_only = 1;
2165         } else if (!strcasecmp(token, "no-query")) {
2166             p->options.no_query = 1;
2167         } else if (!strcasecmp(token, "background-ping")) {
2168             p->options.background_ping = 1;
2169         } else if (!strcasecmp(token, "no-digest")) {
2170             p->options.no_digest = 1;
2171         } else if (!strcasecmp(token, "no-tproxy")) {
2172             p->options.no_tproxy = 1;
2173         } else if (!strcasecmp(token, "multicast-responder")) {
2174             p->options.mcast_responder = 1;
2175 #if PEER_MULTICAST_SIBLINGS
2176         } else if (!strcasecmp(token, "multicast-siblings")) {
2177             p->options.mcast_siblings = 1;
2178 #endif
2179         } else if (!strncasecmp(token, "weight=", 7)) {
2180             p->weight = xatoi(token + 7);
2181         } else if (!strncasecmp(token, "basetime=", 9)) {
2182             p->basetime = xatoi(token + 9);
2183         } else if (!strcasecmp(token, "closest-only")) {
2184             p->options.closest_only = 1;
2185         } else if (!strncasecmp(token, "ttl=", 4)) {
2186             p->mcast.ttl = xatoi(token + 4);
2187
2188             if (p->mcast.ttl < 0)
2189                 p->mcast.ttl = 0;
2190
2191             if (p->mcast.ttl > 128)
2192                 p->mcast.ttl = 128;
2193         } else if (!strcasecmp(token, "default")) {
2194             p->options.default_parent = 1;
2195         } else if (!strcasecmp(token, "round-robin")) {
2196             p->options.roundrobin = 1;
2197         } else if (!strcasecmp(token, "weighted-round-robin")) {
2198             p->options.weighted_roundrobin = 1;
2199 #if USE_HTCP
2200         } else if (!strcasecmp(token, "htcp")) {
2201             p->options.htcp = 1;
2202         } else if (!strncasecmp(token, "htcp=", 5) || !strncasecmp(token, "htcp-", 5)) {
2203             /* Note: The htcp- form is deprecated, replaced by htcp= */
2204             p->options.htcp = 1;
2205             char *tmp = xstrdup(token+5);
2206             char *mode, *nextmode;
2207             for (mode = nextmode = tmp; mode; mode = nextmode) {
2208                 nextmode = strchr(mode, ',');
2209                 if (nextmode)
2210                     *nextmode++ = '\0';
2211                 if (!strcasecmp(mode, "no-clr")) {
2212                     if (p->options.htcp_only_clr)
2213                         fatalf("parse_peer: can't set htcp-no-clr and htcp-only-clr simultaneously");
2214                     p->options.htcp_no_clr = 1;
2215                 } else if (!strcasecmp(mode, "no-purge-clr")) {
2216                     p->options.htcp_no_purge_clr = 1;
2217                 } else if (!strcasecmp(mode, "only-clr")) {
2218                     if (p->options.htcp_no_clr)
2219                         fatalf("parse_peer: can't set htcp no-clr and only-clr simultaneously");
2220                     p->options.htcp_only_clr = 1;
2221                 } else if (!strcasecmp(mode, "forward-clr")) {
2222                     p->options.htcp_forward_clr = 1;
2223                 } else if (!strcasecmp(mode, "oldsquid")) {
2224                     p->options.htcp_oldsquid = 1;
2225                 } else {
2226                     fatalf("invalid HTCP mode '%s'", mode);
2227                 }
2228             }
2229             safe_free(tmp);
2230 #endif
2231         } else if (!strcasecmp(token, "no-netdb-exchange")) {
2232             p->options.no_netdb_exchange = 1;
2233
2234         } else if (!strcasecmp(token, "carp")) {
2235             if (p->type != PEER_PARENT)
2236                 fatalf("parse_peer: non-parent carp peer %s/%d\n", p->host, p->http_port);
2237
2238             p->options.carp = 1;
2239         } else if (!strncasecmp(token, "carp-key=", 9)) {
2240             if (p->options.carp != 1)
2241                 fatalf("parse_peer: carp-key specified on non-carp peer %s/%d\n", p->host, p->http_port);
2242             p->options.carp_key.set=1;
2243             char *nextkey=token+strlen("carp-key="), *key=nextkey;
2244             for (; key; key = nextkey) {
2245                 nextkey=strchr(key,',');
2246                 if (nextkey) ++nextkey; // skip the comma, any
2247                 if (0==strncasecmp(key,"scheme",6)) {
2248                     p->options.carp_key.scheme=1;
2249                 } else if (0==strncasecmp(key,"host",4)) {
2250                     p->options.carp_key.host=1;
2251                 } else if (0==strncasecmp(key,"port",4)) {
2252                     p->options.carp_key.port=1;
2253                 } else if (0==strncasecmp(key,"path",4)) {
2254                     p->options.carp_key.path=1;
2255                 } else if (0==strncasecmp(key,"params",6)) {
2256                     p->options.carp_key.params=1;
2257                 } else {
2258                     fatalf("invalid carp-key '%s'",key);
2259                 }
2260             }
2261         } else if (!strcasecmp(token, "userhash")) {
2262 #if USE_AUTH
2263             if (p->type != PEER_PARENT)
2264                 fatalf("parse_peer: non-parent userhash peer %s/%d\n", p->host, p->http_port);
2265
2266             p->options.userhash = 1;
2267 #else
2268             fatalf("parse_peer: userhash requires authentication. peer %s/%d\n", p->host, p->http_port);
2269 #endif
2270         } else if (!strcasecmp(token, "sourcehash")) {
2271             if (p->type != PEER_PARENT)
2272                 fatalf("parse_peer: non-parent sourcehash peer %s/%d\n", p->host, p->http_port);
2273
2274             p->options.sourcehash = 1;
2275
2276         } else if (!strcasecmp(token, "no-delay")) {
2277 #if USE_DELAY_POOLS
2278             p->options.no_delay = 1;
2279 #else
2280             debugs(0, DBG_CRITICAL, "WARNING: cache_peer option 'no-delay' requires --enable-delay-pools");
2281 #endif
2282         } else if (!strncasecmp(token, "login=", 6)) {
2283             p->login = xstrdup(token + 6);
2284             rfc1738_unescape(p->login);
2285         } else if (!strncasecmp(token, "connect-timeout=", 16)) {
2286             p->connect_timeout = xatoi(token + 16);
2287         } else if (!strncasecmp(token, "connect-fail-limit=", 19)) {
2288             p->connect_fail_limit = xatoi(token + 19);
2289 #if USE_CACHE_DIGESTS
2290         } else if (!strncasecmp(token, "digest-url=", 11)) {
2291             p->digest_url = xstrdup(token + 11);
2292 #endif
2293
2294         } else if (!strcasecmp(token, "allow-miss")) {
2295             p->options.allow_miss = 1;
2296         } else if (!strncasecmp(token, "max-conn=", 9)) {
2297             p->max_conn = xatoi(token + 9);
2298         } else if (!strcasecmp(token, "originserver")) {
2299             p->options.originserver = 1;
2300         } else if (!strncasecmp(token, "name=", 5)) {
2301             safe_free(p->name);
2302
2303             if (token[5])
2304                 p->name = xstrdup(token + 5);
2305         } else if (!strncasecmp(token, "forceddomain=", 13)) {
2306             safe_free(p->domain);
2307
2308             if (token[13])
2309                 p->domain = xstrdup(token + 13);
2310
2311 #if USE_SSL
2312
2313         } else if (strcmp(token, "ssl") == 0) {
2314             p->use_ssl = 1;
2315         } else if (strncmp(token, "sslcert=", 8) == 0) {
2316             safe_free(p->sslcert);
2317             p->sslcert = xstrdup(token + 8);
2318         } else if (strncmp(token, "sslkey=", 7) == 0) {
2319             safe_free(p->sslkey);
2320             p->sslkey = xstrdup(token + 7);
2321         } else if (strncmp(token, "sslversion=", 11) == 0) {
2322             p->sslversion = atoi(token + 11);
2323         } else if (strncmp(token, "ssloptions=", 11) == 0) {
2324             safe_free(p->ssloptions);
2325             p->ssloptions = xstrdup(token + 11);
2326         } else if (strncmp(token, "sslcipher=", 10) == 0) {
2327             safe_free(p->sslcipher);
2328             p->sslcipher = xstrdup(token + 10);
2329         } else if (strncmp(token, "sslcafile=", 10) == 0) {
2330             safe_free(p->sslcafile);
2331             p->sslcafile = xstrdup(token + 10);
2332         } else if (strncmp(token, "sslcapath=", 10) == 0) {
2333             safe_free(p->sslcapath);
2334             p->sslcapath = xstrdup(token + 10);
2335         } else if (strncmp(token, "sslcrlfile=", 11) == 0) {
2336             safe_free(p->sslcrlfile);
2337             p->sslcapath = xstrdup(token + 10);
2338         } else if (strncmp(token, "sslflags=", 9) == 0) {
2339             safe_free(p->sslflags);
2340             p->sslflags = xstrdup(token + 9);
2341         } else if (strncmp(token, "ssldomain=", 10) == 0) {
2342             safe_free(p->ssldomain);
2343             p->ssldomain = xstrdup(token + 10);
2344 #endif
2345
2346         } else if (strcmp(token, "front-end-https") == 0) {
2347             p->front_end_https = 1;
2348         } else if (strcmp(token, "front-end-https=on") == 0) {
2349             p->front_end_https = 1;
2350         } else if (strcmp(token, "front-end-https=auto") == 0) {
2351             p->front_end_https = 2;
2352         } else if (strcmp(token, "connection-auth=off") == 0) {
2353             p->connection_auth = 0;
2354         } else if (strcmp(token, "connection-auth") == 0) {
2355             p->connection_auth = 1;
2356         } else if (strcmp(token, "connection-auth=on") == 0) {
2357             p->connection_auth = 1;
2358         } else if (strcmp(token, "connection-auth=auto") == 0) {
2359             p->connection_auth = 2;
2360         } else {
2361             debugs(3, 0, "parse_peer: token='" << token << "'");
2362             self_destruct();
2363         }
2364     }
2365
2366     if (peerFindByName(p->name))
2367         fatalf("ERROR: cache_peer %s specified twice\n", p->name);
2368
2369     if (p->weight < 1)
2370         p->weight = 1;
2371
2372     if (p->connect_fail_limit < 1)
2373         p->connect_fail_limit = 10;
2374
2375     p->icp.version = ICP_VERSION_CURRENT;
2376
2377     p->testing_now = false;
2378
2379 #if USE_CACHE_DIGESTS
2380
2381     if (!p->options.no_digest) {
2382         /* XXX This looks odd.. who has the original pointer
2383          * then?
2384          */
2385         PeerDigest *pd = peerDigestCreate(p);
2386         p->digest = cbdataReference(pd);
2387     }
2388
2389 #endif
2390
2391     p->index =  ++Config.npeers;
2392
2393     while (*head != NULL)
2394         head = &(*head)->next;
2395
2396     *head = p;
2397
2398     peerClearRRStart();
2399 }
2400
2401 static void
2402 free_peer(peer ** P)
2403 {
2404     peer *p;
2405
2406     while ((p = *P) != NULL) {
2407         *P = p->next;
2408 #if USE_CACHE_DIGESTS
2409
2410         cbdataReferenceDone(p->digest);
2411 #endif
2412
2413         cbdataFree(p);
2414     }
2415
2416     Config.npeers = 0;
2417 }
2418
2419 static void
2420 dump_cachemgrpasswd(StoreEntry * entry, const char *name, cachemgr_passwd * list)
2421 {
2422     wordlist *w;
2423
2424     while (list != NULL) {
2425         if (strcmp(list->passwd, "none") && strcmp(list->passwd, "disable"))
2426             storeAppendPrintf(entry, "%s XXXXXXXXXX", name);
2427         else
2428             storeAppendPrintf(entry, "%s %s", name, list->passwd);
2429
2430         for (w = list->actions; w != NULL; w = w->next) {
2431             storeAppendPrintf(entry, " %s", w->key);
2432         }
2433
2434         storeAppendPrintf(entry, "\n");
2435         list = list->next;
2436     }
2437 }
2438
2439 static void
2440 parse_cachemgrpasswd(cachemgr_passwd ** head)
2441 {
2442     char *passwd = NULL;
2443     wordlist *actions = NULL;
2444     cachemgr_passwd *p;
2445     cachemgr_passwd **P;
2446     parse_string(&passwd);
2447     parse_wordlist(&actions);
2448     p = static_cast<cachemgr_passwd *>(xcalloc(1, sizeof(cachemgr_passwd)));
2449     p->passwd = passwd;
2450     p->actions = actions;
2451
2452     for (P = head; *P; P = &(*P)->next) {
2453         /*
2454          * See if any of the actions from this line already have a
2455          * password from previous lines.  The password checking
2456          * routines in cache_manager.c take the the password from
2457          * the first cachemgr_passwd struct that contains the
2458          * requested action.  Thus, we should warn users who might
2459          * think they can have two passwords for the same action.
2460          */
2461         wordlist *w;
2462         wordlist *u;
2463
2464         for (w = (*P)->actions; w; w = w->next) {
2465             for (u = actions; u; u = u->next) {
2466                 if (strcmp(w->key, u->key))
2467                     continue;
2468
2469                 debugs(0, 0, "WARNING: action '" << u->key << "' (line " << config_lineno << ") already has a password");
2470             }
2471         }
2472     }
2473
2474     *P = p;
2475 }
2476
2477 static void
2478 free_cachemgrpasswd(cachemgr_passwd ** head)
2479 {
2480     cachemgr_passwd *p;
2481
2482     while ((p = *head) != NULL) {
2483         *head = p->next;
2484         xfree(p->passwd);
2485         wordlistDestroy(&p->actions);
2486         xfree(p);
2487     }
2488 }
2489
2490 static void
2491 dump_denyinfo(StoreEntry * entry, const char *name, acl_deny_info_list * var)
2492 {
2493     acl_name_list *a;
2494
2495     while (var != NULL) {
2496         storeAppendPrintf(entry, "%s %s", name, var->err_page_name);
2497
2498         for (a = var->acl_list; a != NULL; a = a->next)
2499             storeAppendPrintf(entry, " %s", a->name);
2500
2501         storeAppendPrintf(entry, "\n");
2502
2503         var = var->next;
2504     }
2505 }
2506
2507 static void
2508 parse_denyinfo(acl_deny_info_list ** var)
2509 {
2510     aclParseDenyInfoLine(var);
2511 }
2512
2513 void
2514 free_denyinfo(acl_deny_info_list ** list)
2515 {
2516     acl_deny_info_list *a = NULL;
2517     acl_deny_info_list *a_next = NULL;
2518     acl_name_list *l = NULL;
2519     acl_name_list *l_next = NULL;
2520
2521     for (a = *list; a; a = a_next) {
2522         for (l = a->acl_list; l; l = l_next) {
2523             l_next = l->next;
2524             memFree(l, MEM_ACL_NAME_LIST);
2525             l = NULL;
2526         }
2527
2528         a_next = a->next;
2529         memFree(a, MEM_ACL_DENY_INFO_LIST);
2530         a = NULL;
2531     }
2532
2533     *list = NULL;
2534 }
2535
2536 static void
2537 parse_peer_access(void)
2538 {
2539     char *host = NULL;
2540     peer *p;
2541
2542     if (!(host = strtok(NULL, w_space)))
2543         self_destruct();
2544
2545     if ((p = peerFindByName(host)) == NULL) {
2546         debugs(15, 0, "" << cfg_filename << ", line " << config_lineno << ": No cache_peer '" << host << "'");
2547         return;
2548     }
2549
2550     aclParseAccessLine(LegacyParser, &p->access);
2551 }
2552
2553 static void
2554 parse_hostdomain(void)
2555 {
2556     char *host = NULL;
2557     char *domain = NULL;
2558
2559     if (!(host = strtok(NULL, w_space)))
2560         self_destruct();
2561
2562     while ((domain = strtok(NULL, list_sep))) {
2563         domain_ping *l = NULL;
2564         domain_ping **L = NULL;
2565         peer *p;
2566
2567         if ((p = peerFindByName(host)) == NULL) {
2568             debugs(15, 0, "" << cfg_filename << ", line " << config_lineno << ": No cache_peer '" << host << "'");
2569             continue;
2570         }
2571
2572         l = static_cast<domain_ping *>(xcalloc(1, sizeof(domain_ping)));
2573         l->do_ping = 1;
2574
2575         if (*domain == '!') {   /* check for !.edu */
2576             l->do_ping = 0;
2577             domain++;
2578         }
2579
2580         l->domain = xstrdup(domain);
2581
2582         for (L = &(p->peer_domain); *L; L = &((*L)->next));
2583         *L = l;
2584     }
2585 }
2586
2587 static void
2588 parse_hostdomaintype(void)
2589 {
2590     char *host = NULL;
2591     char *type = NULL;
2592     char *domain = NULL;
2593
2594     if (!(host = strtok(NULL, w_space)))
2595         self_destruct();
2596
2597     if (!(type = strtok(NULL, w_space)))
2598         self_destruct();
2599
2600     while ((domain = strtok(NULL, list_sep))) {
2601         domain_type *l = NULL;
2602         domain_type **L = NULL;
2603         peer *p;
2604
2605         if ((p = peerFindByName(host)) == NULL) {
2606             debugs(15, 0, "" << cfg_filename << ", line " << config_lineno << ": No cache_peer '" << host << "'");
2607             return;
2608         }
2609
2610         l = static_cast<domain_type *>(xcalloc(1, sizeof(domain_type)));
2611         l->type = parseNeighborType(type);
2612         l->domain = xstrdup(domain);
2613
2614         for (L = &(p->typelist); *L; L = &((*L)->next));
2615         *L = l;
2616     }
2617 }
2618
2619 static void
2620 dump_int(StoreEntry * entry, const char *name, int var)
2621 {
2622     storeAppendPrintf(entry, "%s %d\n", name, var);
2623 }
2624
2625 void
2626 parse_int(int *var)
2627 {
2628     int i;
2629     i = GetInteger();
2630     *var = i;
2631 }
2632
2633 static void
2634 free_int(int *var)
2635 {
2636     *var = 0;
2637 }
2638
2639 static void
2640 dump_onoff(StoreEntry * entry, const char *name, int var)
2641 {
2642     storeAppendPrintf(entry, "%s %s\n", name, var ? "on" : "off");
2643 }
2644
2645 void
2646 parse_onoff(int *var)
2647 {
2648     char *token = strtok(NULL, w_space);
2649
2650     if (token == NULL)
2651         self_destruct();
2652
2653     if (!strcasecmp(token, "on") || !strcasecmp(token, "enable"))
2654         *var = 1;
2655     else
2656         *var = 0;
2657 }
2658
2659 #define free_onoff free_int
2660
2661 static void
2662 dump_tristate(StoreEntry * entry, const char *name, int var)
2663 {
2664     const char *state;
2665
2666     if (var > 0)
2667         state = "on";
2668     else if (var < 0)
2669         state = "warn";
2670     else
2671         state = "off";
2672
2673     storeAppendPrintf(entry, "%s %s\n", name, state);
2674 }
2675
2676 static void
2677 parse_tristate(int *var)
2678 {
2679     char *token = strtok(NULL, w_space);
2680
2681     if (token == NULL)
2682         self_destruct();
2683
2684     if (!strcasecmp(token, "on") || !strcasecmp(token, "enable"))
2685         *var = 1;
2686     else if (!strcasecmp(token, "warn"))
2687         *var = -1;
2688     else
2689         *var = 0;
2690 }
2691
2692 #define free_tristate free_int
2693
2694 static void
2695 dump_refreshpattern(StoreEntry * entry, const char *name, refresh_t * head)
2696 {
2697     while (head != NULL) {
2698         storeAppendPrintf(entry, "%s%s %s %d %d%% %d",
2699                           name,
2700                           head->flags.icase ? " -i" : null_string,
2701                           head->pattern,
2702                           (int) head->min / 60,
2703                           (int) (100.0 * head->pct + 0.5),
2704                           (int) head->max / 60);
2705
2706         if (head->max_stale >= 0)
2707             storeAppendPrintf(entry, " max-stale=%d", head->max_stale);
2708
2709         if (head->flags.refresh_ims)
2710             storeAppendPrintf(entry, " refresh-ims");
2711
2712         if (head->flags.store_stale)
2713             storeAppendPrintf(entry, " store-stale");
2714
2715 #if USE_HTTP_VIOLATIONS
2716
2717         if (head->flags.override_expire)
2718             storeAppendPrintf(entry, " override-expire");
2719
2720         if (head->flags.override_lastmod)
2721             storeAppendPrintf(entry, " override-lastmod");
2722
2723         if (head->flags.reload_into_ims)
2724             storeAppendPrintf(entry, " reload-into-ims");
2725
2726         if (head->flags.ignore_reload)
2727             storeAppendPrintf(entry, " ignore-reload");
2728
2729         if (head->flags.ignore_no_cache)
2730             storeAppendPrintf(entry, " ignore-no-cache");
2731
2732         if (head->flags.ignore_no_store)
2733             storeAppendPrintf(entry, " ignore-no-store");
2734
2735         if (head->flags.ignore_must_revalidate)
2736             storeAppendPrintf(entry, " ignore-must-revalidate");
2737
2738         if (head->flags.ignore_private)
2739             storeAppendPrintf(entry, " ignore-private");
2740
2741         if (head->flags.ignore_auth)
2742             storeAppendPrintf(entry, " ignore-auth");
2743
2744 #endif
2745
2746         storeAppendPrintf(entry, "\n");
2747
2748         head = head->next;
2749     }
2750 }
2751
2752 static void
2753 parse_refreshpattern(refresh_t ** head)
2754 {
2755     char *token;
2756     char *pattern;
2757     time_t min = 0;
2758     double pct = 0.0;
2759     time_t max = 0;
2760     int refresh_ims = 0;
2761     int store_stale = 0;
2762     int max_stale = -1;
2763
2764 #if USE_HTTP_VIOLATIONS
2765
2766     int override_expire = 0;
2767     int override_lastmod = 0;
2768     int reload_into_ims = 0;
2769     int ignore_reload = 0;
2770     int ignore_no_cache = 0;
2771     int ignore_no_store = 0;
2772     int ignore_must_revalidate = 0;
2773     int ignore_private = 0;
2774     int ignore_auth = 0;
2775 #endif
2776
2777     int i;
2778     refresh_t *t;
2779     regex_t comp;
2780     int errcode;
2781     int flags = REG_EXTENDED | REG_NOSUB;
2782
2783     if ((token = strtok(NULL, w_space)) == NULL) {
2784         self_destruct();
2785         return;
2786     }
2787
2788     if (strcmp(token, "-i") == 0) {
2789         flags |= REG_ICASE;
2790         token = strtok(NULL, w_space);
2791     } else if (strcmp(token, "+i") == 0) {
2792         flags &= ~REG_ICASE;
2793         token = strtok(NULL, w_space);
2794     }
2795
2796     if (token == NULL) {
2797         self_destruct();
2798         return;
2799     }
2800
2801     pattern = xstrdup(token);
2802
2803     i = GetInteger();           /* token: min */
2804
2805     /* catch negative and insanely huge values close to 32-bit wrap */
2806     if (i < 0) {
2807         debugs(3, DBG_IMPORTANT, "WARNING: refresh_pattern minimum age negative. Cropped back to zero.");
2808         i = 0;
2809     }
2810     if (i > 60*24*365) {
2811         debugs(3, DBG_IMPORTANT, "WARNING: refresh_pattern minimum age too high. Cropped back to 1 year.");
2812         i = 60*24*365;
2813     }
2814
2815     min = (time_t) (i * 60);    /* convert minutes to seconds */
2816
2817     i = GetInteger();           /* token: pct */
2818
2819     pct = (double) i / 100.0;
2820
2821     i = GetInteger();           /* token: max */
2822
2823     /* catch negative and insanely huge values close to 32-bit wrap */
2824     if (i < 0) {
2825         debugs(3, DBG_IMPORTANT, "WARNING: refresh_pattern maximum age negative. Cropped back to zero.");
2826         i = 0;
2827     }
2828     if (i > 60*24*365) {
2829         debugs(3, DBG_IMPORTANT, "WARNING: refresh_pattern maximum age too high. Cropped back to 1 year.");
2830         i = 60*24*365;
2831     }
2832
2833     max = (time_t) (i * 60);    /* convert minutes to seconds */
2834
2835     /* Options */
2836     while ((token = strtok(NULL, w_space)) != NULL) {
2837         if (!strcmp(token, "refresh-ims")) {
2838             refresh_ims = 1;
2839         } else if (!strcmp(token, "store-stale")) {
2840             store_stale = 1;
2841         } else if (!strncmp(token, "max-stale=", 10)) {
2842             max_stale = atoi(token + 10);
2843 #if USE_HTTP_VIOLATIONS
2844
2845         } else if (!strcmp(token, "override-expire"))
2846             override_expire = 1;
2847         else if (!strcmp(token, "override-lastmod"))
2848             override_lastmod = 1;
2849         else if (!strcmp(token, "ignore-no-cache"))
2850             ignore_no_cache = 1;
2851         else if (!strcmp(token, "ignore-no-store"))
2852             ignore_no_store = 1;
2853         else if (!strcmp(token, "ignore-must-revalidate"))
2854             ignore_must_revalidate = 1;
2855         else if (!strcmp(token, "ignore-private"))
2856             ignore_private = 1;
2857         else if (!strcmp(token, "ignore-auth"))
2858             ignore_auth = 1;
2859         else if (!strcmp(token, "reload-into-ims")) {
2860             reload_into_ims = 1;
2861             refresh_nocache_hack = 1;
2862             /* tell client_side.c that this is used */
2863         } else if (!strcmp(token, "ignore-reload")) {
2864             ignore_reload = 1;
2865             refresh_nocache_hack = 1;
2866             /* tell client_side.c that this is used */
2867 #endif
2868
2869         } else
2870             debugs(22, 0, "refreshAddToList: Unknown option '" << pattern << "': " << token);
2871     }
2872
2873     if ((errcode = regcomp(&comp, pattern, flags)) != 0) {
2874         char errbuf[256];
2875         regerror(errcode, &comp, errbuf, sizeof errbuf);
2876         debugs(22, 0, "" << cfg_filename << " line " << config_lineno << ": " << config_input_line);
2877         debugs(22, 0, "refreshAddToList: Invalid regular expression '" << pattern << "': " << errbuf);
2878         return;
2879     }
2880
2881     pct = pct < 0.0 ? 0.0 : pct;
2882     max = max < 0 ? 0 : max;
2883     t = static_cast<refresh_t *>(xcalloc(1, sizeof(refresh_t)));
2884     t->pattern = (char *) xstrdup(pattern);
2885     t->compiled_pattern = comp;
2886     t->min = min;
2887     t->pct = pct;
2888     t->max = max;
2889
2890     if (flags & REG_ICASE)
2891         t->flags.icase = 1;
2892
2893     if (refresh_ims)
2894         t->flags.refresh_ims = 1;
2895
2896     if (store_stale)
2897         t->flags.store_stale = 1;
2898
2899     t->max_stale = max_stale;
2900
2901 #if USE_HTTP_VIOLATIONS
2902
2903     if (override_expire)
2904         t->flags.override_expire = 1;
2905
2906     if (override_lastmod)
2907         t->flags.override_lastmod = 1;
2908
2909     if (reload_into_ims)
2910         t->flags.reload_into_ims = 1;
2911
2912     if (ignore_reload)
2913         t->flags.ignore_reload = 1;
2914
2915     if (ignore_no_cache)
2916         t->flags.ignore_no_cache = 1;
2917
2918     if (ignore_no_store)
2919         t->flags.ignore_no_store = 1;
2920
2921     if (ignore_must_revalidate)
2922         t->flags.ignore_must_revalidate = 1;
2923
2924     if (ignore_private)
2925         t->flags.ignore_private = 1;
2926
2927     if (ignore_auth)
2928         t->flags.ignore_auth = 1;
2929
2930 #endif
2931
2932     t->next = NULL;
2933
2934     while (*head)
2935         head = &(*head)->next;
2936
2937     *head = t;
2938
2939     safe_free(pattern);
2940 }
2941
2942 static void
2943 free_refreshpattern(refresh_t ** head)
2944 {
2945     refresh_t *t;
2946
2947     while ((t = *head) != NULL) {
2948         *head = t->next;
2949         safe_free(t->pattern);
2950         regfree(&t->compiled_pattern);
2951         safe_free(t);
2952     }
2953
2954 #if USE_HTTP_VIOLATIONS
2955     refresh_nocache_hack = 0;
2956
2957 #endif
2958 }
2959
2960 static void
2961 dump_string(StoreEntry * entry, const char *name, char *var)
2962 {
2963     if (var != NULL)
2964         storeAppendPrintf(entry, "%s %s\n", name, var);
2965 }
2966
2967 static void
2968 parse_string(char **var)
2969 {
2970     char *token = strtok(NULL, w_space);
2971     safe_free(*var);
2972
2973     if (token == NULL)
2974         self_destruct();
2975
2976     *var = xstrdup(token);
2977 }
2978
2979 void
2980 ConfigParser::ParseString(char **var)
2981 {
2982     parse_string(var);
2983 }
2984
2985 void
2986 ConfigParser::ParseString(String *var)
2987 {
2988     char *token = strtok(NULL, w_space);
2989
2990     if (token == NULL)
2991         self_destruct();
2992
2993     var->reset(token);
2994 }
2995
2996 static void
2997 free_string(char **var)
2998 {
2999     safe_free(*var);
3000 }
3001
3002 void
3003 parse_eol(char *volatile *var)
3004 {
3005     if (!var) {
3006         self_destruct();
3007         return;
3008     }
3009
3010     unsigned char *token = (unsigned char *) strtok(NULL, null_string);
3011     safe_free(*var);
3012
3013     if (!token) {
3014         self_destruct();
3015         return;
3016     }
3017
3018     while (*token && xisspace(*token))
3019         token++;
3020
3021     if (!*token) {
3022         self_destruct();
3023         return;
3024     }
3025
3026     *var = xstrdup((char *) token);
3027 }
3028
3029 #define dump_eol dump_string
3030 #define free_eol free_string
3031
3032 static void
3033 dump_time_t(StoreEntry * entry, const char *name, time_t var)
3034 {
3035     storeAppendPrintf(entry, "%s %d seconds\n", name, (int) var);
3036 }
3037
3038 void
3039 parse_time_t(time_t * var)
3040 {
3041     time_msec_t tval;
3042     parseTimeLine(&tval, T_SECOND_STR, false);
3043     *var = static_cast<time_t>(tval/1000);
3044 }
3045
3046 static void
3047 free_time_t(time_t * var)
3048 {
3049     *var = 0;
3050 }
3051
3052 static void
3053 dump_time_msec(StoreEntry * entry, const char *name, time_msec_t var)
3054 {
3055     if (var % 1000)
3056         storeAppendPrintf(entry, "%s %"PRId64" milliseconds\n", name, var);
3057     else
3058         storeAppendPrintf(entry, "%s %d seconds\n", name, (int)(var/1000) );
3059 }
3060
3061 void
3062 parse_time_msec(time_msec_t * var)
3063 {
3064     parseTimeLine(var, T_SECOND_STR, true);
3065 }
3066
3067 static void
3068 free_time_msec(time_msec_t * var)
3069 {
3070     *var = 0;
3071 }
3072
3073 #if UNUSED_CODE
3074 static void
3075 dump_size_t(StoreEntry * entry, const char *name, size_t var)
3076 {
3077     storeAppendPrintf(entry, "%s %d\n", name, (int) var);
3078 }
3079 #endif
3080
3081 static void
3082 dump_b_size_t(StoreEntry * entry, const char *name, size_t var)
3083 {
3084     storeAppendPrintf(entry, "%s %d %s\n", name, (int) var, B_BYTES_STR);
3085 }
3086
3087 #if !USE_DNSSERVERS
3088 static void
3089 dump_b_ssize_t(StoreEntry * entry, const char *name, ssize_t var)
3090 {
3091     storeAppendPrintf(entry, "%s %d %s\n", name, (int) var, B_BYTES_STR);
3092 }
3093 #endif
3094
3095 #if UNUSED_CODE
3096 static void
3097 dump_kb_size_t(StoreEntry * entry, const char *name, size_t var)
3098 {
3099     storeAppendPrintf(entry, "%s %d %s\n", name, (int) var, B_KBYTES_STR);
3100 }
3101 #endif
3102
3103 static void
3104 dump_b_int64_t(StoreEntry * entry, const char *name, int64_t var)
3105 {
3106     storeAppendPrintf(entry, "%s %"PRId64" %s\n", name, var, B_BYTES_STR);
3107 }
3108
3109 static void
3110 dump_kb_int64_t(StoreEntry * entry, const char *name, int64_t var)
3111 {
3112     storeAppendPrintf(entry, "%s %"PRId64" %s\n", name, var, B_KBYTES_STR);
3113 }
3114
3115 #if UNUSED_CODE
3116 static void
3117 parse_size_t(size_t * var)
3118 {
3119     int i;
3120     i = GetInteger();
3121     *var = (size_t) i;
3122 }
3123 #endif
3124
3125 static void
3126 parse_b_size_t(size_t * var)
3127 {
3128     parseBytesLine(var, B_BYTES_STR);
3129 }
3130
3131 #if !USE_DNSSERVERS
3132 static void
3133 parse_b_ssize_t(ssize_t * var)
3134 {
3135     parseBytesLineSigned(var, B_BYTES_STR);
3136 }
3137 #endif
3138
3139 #if UNUSED_CODE
3140 static void
3141 parse_kb_size_t(size_t * var)
3142 {
3143     parseBytesLine(var, B_KBYTES_STR);
3144 }
3145 #endif
3146
3147 static void
3148 parse_b_int64_t(int64_t * var)
3149 {
3150     parseBytesLine64(var, B_BYTES_STR);
3151 }
3152
3153 static void
3154 parse_kb_int64_t(int64_t * var)
3155 {
3156     parseBytesLine64(var, B_KBYTES_STR);
3157 }
3158
3159 static void
3160 free_size_t(size_t * var)
3161 {
3162     *var = 0;
3163 }
3164
3165 #if !USE_DNSSERVERS
3166 static void
3167 free_ssize_t(ssize_t * var)
3168 {
3169     *var = 0;
3170 }
3171 #endif
3172
3173 static void
3174 free_b_int64_t(int64_t * var)
3175 {
3176     *var = 0;
3177 }
3178
3179 #define free_b_size_t free_size_t
3180 #define free_b_ssize_t free_ssize_t
3181 #define free_kb_size_t free_size_t
3182 #define free_mb_size_t free_size_t
3183 #define free_gb_size_t free_size_t
3184 #define free_kb_int64_t free_b_int64_t
3185
3186 static void
3187 dump_u_short(StoreEntry * entry, const char *name, unsigned short var)
3188 {
3189     storeAppendPrintf(entry, "%s %d\n", name, var);
3190 }
3191
3192 static void
3193 free_u_short(unsigned short * u)
3194 {
3195     *u = 0;
3196 }
3197
3198 static void
3199 parse_u_short(unsigned short * var)
3200 {
3201     ConfigParser::ParseUShort(var);
3202 }
3203
3204 void
3205 ConfigParser::ParseUShort(unsigned short *var)
3206 {
3207     *var = GetShort();
3208 }
3209
3210 void
3211 ConfigParser::ParseBool(bool *var)
3212 {
3213     int i = GetInteger();
3214
3215     if (0 == i)
3216         *var = false;
3217     else if (1 == i)
3218         *var = true;
3219     else
3220         self_destruct();
3221 }
3222
3223 static void
3224 dump_wordlist(StoreEntry * entry, const char *name, wordlist * list)
3225 {
3226     while (list != NULL) {
3227         storeAppendPrintf(entry, "%s %s\n", name, list->key);
3228         list = list->next;
3229     }
3230 }
3231
3232 void
3233 ConfigParser::ParseWordList(wordlist ** list)
3234 {
3235     parse_wordlist(list);
3236 }
3237
3238 void
3239 parse_wordlist(wordlist ** list)
3240 {
3241     char *token;
3242     char *t = strtok(NULL, "");
3243
3244     while ((token = strwordtok(NULL, &t)))
3245         wordlistAdd(list, token);
3246 }
3247
3248 #if 0 /* now unused */
3249 static int
3250 check_null_wordlist(wordlist * w)
3251 {
3252     return w == NULL;
3253 }
3254 #endif
3255
3256 static int
3257 check_null_acl_access(acl_access * a)
3258 {
3259     return a == NULL;
3260 }
3261
3262 #define free_wordlist wordlistDestroy
3263
3264 #define free_uri_whitespace free_int
3265
3266 static void
3267 parse_uri_whitespace(int *var)
3268 {
3269     char *token = strtok(NULL, w_space);
3270
3271     if (token == NULL)
3272         self_destruct();
3273
3274     if (!strcasecmp(token, "strip"))
3275         *var = URI_WHITESPACE_STRIP;
3276     else if (!strcasecmp(token, "deny"))
3277         *var = URI_WHITESPACE_DENY;
3278     else if (!strcasecmp(token, "allow"))
3279         *var = URI_WHITESPACE_ALLOW;
3280     else if (!strcasecmp(token, "encode"))
3281         *var = URI_WHITESPACE_ENCODE;
3282     else if (!strcasecmp(token, "chop"))
3283         *var = URI_WHITESPACE_CHOP;
3284     else
3285         self_destruct();
3286 }
3287
3288 static void
3289 dump_uri_whitespace(StoreEntry * entry, const char *name, int var)
3290 {
3291     const char *s;
3292
3293     if (var == URI_WHITESPACE_ALLOW)
3294         s = "allow";
3295     else if (var == URI_WHITESPACE_ENCODE)
3296         s = "encode";
3297     else if (var == URI_WHITESPACE_CHOP)
3298         s = "chop";
3299     else if (var == URI_WHITESPACE_DENY)
3300         s = "deny";
3301     else
3302         s = "strip";
3303
3304     storeAppendPrintf(entry, "%s %s\n", name, s);
3305 }
3306
3307 static void
3308 free_removalpolicy(RemovalPolicySettings ** settings)
3309 {
3310     if (!*settings)
3311         return;
3312
3313     free_string(&(*settings)->type);
3314
3315     free_wordlist(&(*settings)->args);
3316
3317     delete *settings;
3318
3319     *settings = NULL;
3320 }
3321
3322 static void
3323 parse_removalpolicy(RemovalPolicySettings ** settings)
3324 {
3325     if (*settings)
3326         free_removalpolicy(settings);
3327
3328     *settings = new RemovalPolicySettings;
3329
3330     parse_string(&(*settings)->type);
3331
3332     parse_wordlist(&(*settings)->args);
3333 }
3334
3335 static void
3336 dump_removalpolicy(StoreEntry * entry, const char *name, RemovalPolicySettings * settings)
3337 {
3338     wordlist *args;
3339     storeAppendPrintf(entry, "%s %s", name, settings->type);
3340     args = settings->args;
3341
3342     while (args) {
3343         storeAppendPrintf(entry, " %s", args->key);
3344         args = args->next;
3345     }
3346
3347     storeAppendPrintf(entry, "\n");
3348 }
3349
3350 void
3351 YesNoNone::configure(bool beSet)
3352 {
3353     option = beSet ? +1 : -1;
3354 }
3355
3356 YesNoNone::operator void*() const
3357 {
3358     assert(option != 0); // must call configure() first
3359     return option > 0 ? (void*)this : NULL;
3360 }
3361
3362
3363 inline void
3364 free_YesNoNone(YesNoNone *)
3365 {
3366     // do nothing: no explicit cleanup is required
3367 }
3368
3369 static void
3370 parse_YesNoNone(YesNoNone *option)
3371 {
3372     int value = 0;
3373     parse_onoff(&value);
3374     option->configure(value > 0);
3375 }
3376
3377 static void
3378 dump_YesNoNone(StoreEntry * entry, const char *name, YesNoNone &option)
3379 {
3380     if (option.configured())
3381         dump_onoff(entry, name, option ? 1 : 0);
3382 }
3383
3384 static void
3385 free_memcachemode(SquidConfig * config)
3386 {
3387     return;
3388 }
3389
3390 static void
3391 parse_memcachemode(SquidConfig * config)
3392 {
3393     char *token = strtok(NULL, w_space);
3394     if (!token)
3395         self_destruct();
3396
3397     if (strcmp(token, "always") == 0) {
3398         Config.onoff.memory_cache_first = 1;
3399         Config.onoff.memory_cache_disk = 1;
3400     } else if (strcmp(token, "disk") == 0) {
3401         Config.onoff.memory_cache_first = 0;
3402         Config.onoff.memory_cache_disk = 1;
3403     } else if (strncmp(token, "net", 3) == 0) {
3404         Config.onoff.memory_cache_first = 1;
3405         Config.onoff.memory_cache_disk = 0;
3406     } else if (strcmp(token, "never") == 0) {
3407         Config.onoff.memory_cache_first = 0;
3408         Config.onoff.memory_cache_disk = 0;
3409     } else
3410         self_destruct();
3411 }
3412
3413 static void
3414 dump_memcachemode(StoreEntry * entry, const char *name, SquidConfig &config)
3415 {
3416     storeAppendPrintf(entry, "%s ", name);
3417     if (Config.onoff.memory_cache_first && Config.onoff.memory_cache_disk)
3418         storeAppendPrintf(entry, "always");
3419     else if (!Config.onoff.memory_cache_first && Config.onoff.memory_cache_disk)
3420         storeAppendPrintf(entry, "disk");
3421     else if (Config.onoff.memory_cache_first && !Config.onoff.memory_cache_disk)
3422         storeAppendPrintf(entry, "network");
3423     else if (!Config.onoff.memory_cache_first && !Config.onoff.memory_cache_disk)
3424         storeAppendPrintf(entry, "none");
3425     storeAppendPrintf(entry, "\n");
3426 }
3427
3428 #include "cf_parser.cci"
3429
3430 peer_t
3431 parseNeighborType(const char *s)
3432 {
3433     if (!strcasecmp(s, "parent"))
3434         return PEER_PARENT;
3435
3436     if (!strcasecmp(s, "neighbor"))
3437         return PEER_SIBLING;
3438
3439     if (!strcasecmp(s, "neighbour"))
3440         return PEER_SIBLING;
3441
3442     if (!strcasecmp(s, "sibling"))
3443         return PEER_SIBLING;
3444
3445     if (!strcasecmp(s, "multicast"))
3446         return PEER_MULTICAST;
3447
3448     debugs(15, 0, "WARNING: Unknown neighbor type: " << s);
3449
3450     return PEER_SIBLING;
3451 }
3452
3453 #if USE_WCCPv2
3454 static void
3455 parse_IpAddress_list(Ip::Address_list ** head)
3456 {
3457     char *token;
3458     Ip::Address_list *s;
3459     Ip::Address ipa;
3460
3461     while ((token = strtok(NULL, w_space))) {
3462         if (GetHostWithPort(token, &ipa)) {
3463
3464             while (*head)
3465                 head = &(*head)->next;
3466
3467             s = static_cast<Ip::Address_list *>(xcalloc(1, sizeof(*s)));
3468             s->s = ipa;
3469
3470             *head = s;
3471         } else
3472             self_destruct();
3473     }
3474 }
3475
3476 static void
3477 dump_IpAddress_list(StoreEntry * e, const char *n, const Ip::Address_list * s)
3478 {
3479     char ntoabuf[MAX_IPSTRLEN];
3480
3481     while (s) {
3482         storeAppendPrintf(e, "%s %s\n",
3483                           n,
3484                           s->s.NtoA(ntoabuf,MAX_IPSTRLEN));
3485         s = s->next;
3486     }
3487 }
3488
3489 static void
3490 free_IpAddress_list(Ip::Address_list ** head)
3491 {
3492     if (*head) delete *head;
3493     *head = NULL;
3494 }
3495
3496 #if CURRENTLY_UNUSED
3497 /* This code was previously used by http_port. Left as it really should
3498  * be used by icp_port and htcp_port
3499  */
3500 static int
3501 check_null_IpAddress_list(const Ip::Address_list * s)
3502 {
3503     return NULL == s;
3504 }
3505
3506 #endif /* CURRENTLY_UNUSED */
3507 #endif /* USE_WCCPv2 */
3508
3509 CBDATA_CLASS_INIT(http_port_list);
3510
3511 static void
3512 parse_http_port_specification(http_port_list * s, char *token)
3513 {
3514     char *host = NULL;
3515     unsigned short port = 0;
3516     char *t = NULL;
3517     char *junk = NULL;
3518
3519     s->disable_pmtu_discovery = DISABLE_PMTU_OFF;
3520     s->name = xstrdup(token);
3521     s->connection_auth_disabled = false;
3522
3523     if (*token == '[') {
3524         /* [ipv6]:port */
3525         host = token + 1;
3526         t = strchr(host, ']');
3527         if (!t) {
3528             debugs(3, 0, "http(s)_port: missing ']' on IPv6 address: " << token);
3529             self_destruct();
3530         }
3531         *t++ = '\0';
3532         if (*t != ':') {
3533             debugs(3, 0, "http(s)_port: missing Port in: " << token);
3534             self_destruct();
3535         }
3536         if (!Ip::EnableIpv6) {
3537             debugs(3, DBG_CRITICAL, "FATAL: http(s)_port: IPv6 is not available.");
3538             self_destruct();
3539         }
3540         port = xatos(t + 1);
3541     } else if ((t = strchr(token, ':'))) {
3542         /* host:port */
3543         /* ipv4:port */
3544         host = token;
3545         *t = '\0';
3546         port = xatos(t + 1);
3547
3548     } else if ((port = strtol(token, &junk, 10)), !*junk) {
3549         /* port */
3550         debugs(3, 3, "http(s)_port: found Listen on Port: " << port);
3551     } else {
3552         debugs(3, 0, "http(s)_port: missing Port: " << token);
3553         self_destruct();
3554     }
3555
3556     if (port == 0) {
3557         debugs(3, 0, "http(s)_port: Port cannot be 0: " << token);
3558         self_destruct();
3559     }
3560
3561     if (NULL == host) {
3562         s->s.SetAnyAddr();
3563         s->s.SetPort(port);
3564         if (!Ip::EnableIpv6)
3565             s->s.SetIPv4();
3566         debugs(3, 3, "http(s)_port: found Listen on wildcard address: *:" << s->s.GetPort() );
3567     } else if ( (s->s = host) ) { /* check/parse numeric IPA */
3568         s->s.SetPort(port);
3569         if (!Ip::EnableIpv6)
3570             s->s.SetIPv4();
3571         debugs(3, 3, "http(s)_port: Listen on Host/IP: " << host << " --> " << s->s);
3572     } else if ( s->s.GetHostByName(host) ) { /* check/parse for FQDN */
3573         /* dont use ipcache */
3574         s->defaultsite = xstrdup(host);
3575         s->s.SetPort(port);
3576         if (!Ip::EnableIpv6)
3577             s->s.SetIPv4();
3578         debugs(3, 3, "http(s)_port: found Listen as Host " << s->defaultsite << " on IP: " << s->s);
3579     } else {
3580         debugs(3, 0, "http(s)_port: failed to resolve Host/IP: " << host);
3581         self_destruct();
3582     }
3583 }
3584
3585 static void
3586 parse_http_port_option(http_port_list * s, char *token)
3587 {
3588     /* modes first */
3589
3590     if (strcmp(token, "accel") == 0) {
3591         if (s->intercepted || s->spoof_client_ip) {
3592             debugs(3, DBG_CRITICAL, "FATAL: http(s)_port: Accelerator mode requires its own port. It cannot be shared with other modes.");
3593             self_destruct();
3594         }
3595         s->accel = s->vhost = 1;
3596     } else if (strcmp(token, "transparent") == 0 || strcmp(token, "intercept") == 0) {
3597         if (s->accel || s->spoof_client_ip) {
3598             debugs(3, DBG_CRITICAL, "FATAL: http(s)_port: Intercept mode requires its own interception port. It cannot be shared with other modes.");
3599             self_destruct();
3600         }
3601         s->intercepted = 1;
3602         Ip::Interceptor.StartInterception();
3603         /* Log information regarding the port modes under interception. */
3604         debugs(3, DBG_IMPORTANT, "Starting Authentication on port " << s->s);
3605         debugs(3, DBG_IMPORTANT, "Disabling Authentication on port " << s->s << " (interception enabled)");
3606
3607         /* INET6: until transparent REDIRECT works on IPv6 SOCKET, force wildcard to IPv4 */
3608         if (Ip::EnableIpv6)
3609             debugs(3, DBG_IMPORTANT, "Disabling IPv6 on port " << s->s << " (interception enabled)");
3610         if ( !s->s.SetIPv4() ) {
3611             debugs(3, DBG_CRITICAL, "FATAL: http(s)_port: IPv6 addresses cannot NAT intercept (protocol does not provide NAT)" << s->s );
3612             self_destruct();
3613         }
3614     } else if (strcmp(token, "tproxy") == 0) {
3615         if (s->intercepted || s->accel) {
3616             debugs(3,DBG_CRITICAL, "FATAL: http(s)_port: TPROXY option requires its own interception port. It cannot be shared with other modes.");
3617             self_destruct();
3618         }
3619         s->spoof_client_ip = 1;
3620         Ip::Interceptor.StartTransparency();
3621         /* Log information regarding the port modes under transparency. */
3622         debugs(3, DBG_IMPORTANT, "Starting IP Spoofing on port " << s->s);
3623         debugs(3, DBG_IMPORTANT, "Disabling Authentication on port " << s->s << " (IP spoofing enabled)");
3624
3625         if (!Ip::Interceptor.ProbeForTproxy(s->s)) {
3626             debugs(3, DBG_CRITICAL, "FATAL: http(s)_port: TPROXY support in the system does not work.");
3627             self_destruct();
3628         }
3629
3630     } else if (strncmp(token, "defaultsite=", 12) == 0) {
3631         if (!s->accel) {
3632             debugs(3, DBG_CRITICAL, "FATAL: http(s)_port: defaultsite option requires Acceleration mode flag.");
3633             self_destruct();
3634         }
3635         safe_free(s->defaultsite);
3636         s->defaultsite = xstrdup(token + 12);
3637     } else if (strcmp(token, "vhost") == 0) {
3638         if (!s->accel) {
3639             debugs(3, DBG_CRITICAL, "WARNING: http(s)_port: vhost option is deprecated. Use 'accel' mode flag instead.");
3640         }
3641         s->accel = s->vhost = 1;
3642     } else if (strcmp(token, "no-vhost") == 0) {
3643         if (!s->accel) {
3644             debugs(3, DBG_IMPORTANT, "ERROR: http(s)_port: no-vhost option requires Acceleration mode flag.");
3645         }
3646         s->vhost = 0;
3647     } else if (strcmp(token, "vport") == 0) {
3648         if (!s->accel) {
3649             debugs(3, DBG_CRITICAL, "FATAL: http(s)_port: vport option requires Acceleration mode flag.");
3650             self_destruct();
3651         }
3652         s->vport = -1;
3653     } else if (strncmp(token, "vport=", 6) == 0) {
3654         if (!s->accel) {
3655             debugs(3, DBG_CRITICAL, "FATAL: http(s)_port: vport option requires Acceleration mode flag.");
3656             self_destruct();
3657         }
3658         s->vport = xatos(token + 6);
3659     } else if (strncmp(token, "protocol=", 9) == 0) {
3660         if (!s->accel) {
3661             debugs(3, DBG_CRITICAL, "FATAL: http(s)_port: protocol option requires Acceleration mode flag.");
3662             self_destruct();
3663         }
3664         s->protocol = xstrdup(token + 9);
3665     } else if (strcmp(token, "allow-direct") == 0) {
3666         if (!s->accel) {
3667             debugs(3, DBG_CRITICAL, "FATAL: http(s)_port: allow-direct option requires Acceleration mode flag.");
3668             self_destruct();
3669         }
3670         s->allow_direct = 1;
3671     } else if (strcmp(token, "act-as-origin") == 0) {
3672         if (!s->accel) {
3673             debugs(3, DBG_IMPORTANT, "ERROR: http(s)_port: act-as-origin option requires Acceleration mode flag.");
3674         } else
3675             s->actAsOrigin = 1;
3676     } else if (strcmp(token, "ignore-cc") == 0) {
3677 #if !USE_HTTP_VIOLATIONS
3678         if (!s->accel) {
3679             debugs(3, DBG_CRITICAL, "FATAL: http(s)_port: ignore-cc option requires Scceleration mode flag.");
3680             self_destruct();
3681         }
3682 #endif
3683         s->ignore_cc = 1;
3684     } else if (strncmp(token, "name=", 5) == 0) {
3685         safe_free(s->name);
3686         s->name = xstrdup(token + 5);
3687     } else if (strcmp(token, "no-connection-auth") == 0) {
3688         s->connection_auth_disabled = true;
3689     } else if (strcmp(token, "connection-auth=off") == 0) {
3690         s->connection_auth_disabled = true;
3691     } else if (strcmp(token, "connection-auth") == 0) {
3692         s->connection_auth_disabled = false;
3693     } else if (strcmp(token, "connection-auth=on") == 0) {
3694         s->connection_auth_disabled = false;
3695     } else if (strncmp(token, "disable-pmtu-discovery=", 23) == 0) {
3696         if (!strcasecmp(token + 23, "off"))
3697             s->disable_pmtu_discovery = DISABLE_PMTU_OFF;
3698         else if (!strcasecmp(token + 23, "transparent"))
3699             s->disable_pmtu_discovery = DISABLE_PMTU_TRANSPARENT;
3700         else if (!strcasecmp(token + 23, "always"))
3701             s->disable_pmtu_discovery = DISABLE_PMTU_ALWAYS;
3702         else
3703             self_destruct();
3704     } else if (strcmp(token, "ipv4") == 0) {
3705         if ( !s->s.SetIPv4() ) {
3706             debugs(3, DBG_CRITICAL, "FATAL: http(s)_port: IPv6 addresses cannot be used as IPv4-Only. " << s->s );
3707             self_destruct();
3708         }
3709     } else if (strcmp(token, "tcpkeepalive") == 0) {
3710         s->tcp_keepalive.enabled = 1;
3711     } else if (strncmp(token, "tcpkeepalive=", 13) == 0) {
3712         char *t = token + 13;
3713         s->tcp_keepalive.enabled = 1;
3714         s->tcp_keepalive.idle = atoi(t);
3715         t = strchr(t, ',');
3716         if (t) {
3717             t++;
3718             s->tcp_keepalive.interval = atoi(t);
3719             t = strchr(t, ',');
3720         }
3721         if (t) {
3722             t++;
3723             s->tcp_keepalive.timeout = atoi(t);
3724             t = strchr(t, ',');
3725         }
3726 #if USE_SSL
3727     } else if (strcasecmp(token, "sslBump") == 0) {
3728         debugs(3, DBG_CRITICAL, "WARNING: '" << token << "' is deprecated " <<
3729                "in http_port. Use 'ssl-bump' instead.");
3730         s->sslBump = 1; // accelerated when bumped, otherwise not
3731     } else if (strcmp(token, "ssl-bump") == 0) {
3732         s->sslBump = 1; // accelerated when bumped, otherwise not
3733     } else if (strncmp(token, "cert=", 5) == 0) {
3734         safe_free(s->cert);
3735         s->cert = xstrdup(token + 5);
3736     } else if (strncmp(token, "key=", 4) == 0) {
3737         safe_free(s->key);
3738         s->key = xstrdup(token + 4);
3739     } else if (strncmp(token, "version=", 8) == 0) {
3740         s->version = xatoi(token + 8);
3741         if (s->version < 1 || s->version > 4)
3742             self_destruct();
3743     } else if (strncmp(token, "options=", 8) == 0) {
3744         safe_free(s->options);
3745         s->options = xstrdup(token + 8);
3746     } else if (strncmp(token, "cipher=", 7) == 0) {
3747         safe_free(s->cipher);
3748         s->cipher = xstrdup(token + 7);
3749     } else if (strncmp(token, "clientca=", 9) == 0) {
3750         safe_free(s->clientca);
3751         s->clientca = xstrdup(token + 9);
3752     } else if (strncmp(token, "cafile=", 7) == 0) {
3753         safe_free(s->cafile);
3754         s->cafile = xstrdup(token + 7);
3755     } else if (strncmp(token, "capath=", 7) == 0) {
3756         safe_free(s->capath);
3757         s->capath = xstrdup(token + 7);
3758     } else if (strncmp(token, "crlfile=", 8) == 0) {
3759         safe_free(s->crlfile);
3760         s->crlfile = xstrdup(token + 8);
3761     } else if (strncmp(token, "dhparams=", 9) == 0) {
3762         safe_free(s->dhfile);
3763         s->dhfile = xstrdup(token + 9);
3764     } else if (strncmp(token, "sslflags=", 9) == 0) {
3765         safe_free(s->sslflags);
3766         s->sslflags = xstrdup(token + 9);
3767     } else if (strncmp(token, "sslcontext=", 11) == 0) {
3768         safe_free(s->sslContextSessionId);
3769         s->sslContextSessionId = xstrdup(token + 11);
3770     } else if (strcmp(token, "generate-host-certificates") == 0) {
3771         s->generateHostCertificates = true;
3772     } else if (strcmp(token, "generate-host-certificates=on") == 0) {
3773         s->generateHostCertificates = true;
3774     } else if (strcmp(token, "generate-host-certificates=off") == 0) {
3775         s->generateHostCertificates = false;
3776     } else if (strncmp(token, "dynamic_cert_mem_cache_size=", 28) == 0) {
3777         parseBytesOptionValue(&s->dynamicCertMemCacheSize, B_BYTES_STR, token + 28);
3778 #endif
3779     } else {
3780         self_destruct();
3781     }
3782 }
3783
3784 static http_port_list *
3785 create_http_port(char *portspec)
3786 {
3787     http_port_list *s = new http_port_list("http");
3788     parse_http_port_specification(s, portspec);
3789     return s;
3790 }
3791
3792 void
3793 add_http_port(char *portspec)
3794 {
3795     http_port_list *s = create_http_port(portspec);
3796     // we may need to merge better of the above returns a list with clones
3797     assert(s->next == NULL);
3798     s->next = Config.Sockaddr.http;
3799     Config.Sockaddr.http = s;
3800 }
3801
3802 http_port_list *
3803 clone_http_port_list(http_port_list *a)
3804 {
3805     http_port_list *b = new http_port_list(a->protocol);
3806
3807     b->s = a->s;
3808     if (a->name)
3809         b->name = xstrdup(a->name);
3810     if (a->defaultsite)
3811         b->defaultsite = xstrdup(a->defaultsite);
3812
3813     b->intercepted = a->intercepted;
3814     b->spoof_client_ip = a->spoof_client_ip;
3815     b->accel = a->accel;
3816     b->allow_direct = a->allow_direct;
3817     b->vhost = a->vhost;
3818     b->sslBump = a->sslBump;
3819     b->vport = a->vport;
3820     b->connection_auth_disabled = a->connection_auth_disabled;
3821     b->disable_pmtu_discovery = a->disable_pmtu_discovery;
3822
3823     memcpy( &(b->tcp_keepalive), &(a->tcp_keepalive), sizeof(a->tcp_keepalive));
3824
3825 #if 0
3826     // AYJ: 2009-07-18: for now SSL does not clone. Configure separate ports with IPs and SSL settings
3827
3828 #if USE_SSL
3829     // XXX: temporary hack to ease move of SSL options to http_port
3830     http_port_list &http;
3831
3832     char *cert;
3833     char *key;
3834     int version;
3835     char *cipher;
3836     char *options;
3837     char *clientca;
3838     char *cafile;
3839     char *capath;
3840     char *crlfile;
3841     char *dhfile;
3842     char *sslflags;
3843     char *sslContextSessionId;
3844     SSL_CTX *sslContext;
3845 #endif
3846
3847 #endif /*0*/
3848
3849     return b;
3850 }
3851
3852 static void
3853 parse_http_port_list(http_port_list ** head)
3854 {
3855     char *token = strtok(NULL, w_space);
3856
3857     if (!token) {
3858         self_destruct();
3859         return;
3860     }
3861
3862     http_port_list *s = create_http_port(token);
3863
3864     /* parse options ... */
3865     while ((token = strtok(NULL, w_space))) {
3866         parse_http_port_option(s, token);
3867     }
3868
3869     if (Ip::EnableIpv6&IPV6_SPECIAL_SPLITSTACK && s->s.IsAnyAddr()) {
3870         // clone the port options from *s to *(s->next)
3871         s->next = clone_http_port_list(s);
3872         s->next->s.SetIPv4();
3873         debugs(3, 3, "http(s)_port: clone wildcard address for split-stack: " << s->s << " and " << s->next->s);
3874     }
3875
3876     while (*head)
3877         head = &(*head)->next;
3878
3879     *head = s;
3880 }
3881
3882 static void
3883 dump_generic_http_port(StoreEntry * e, const char *n, const http_port_list * s)
3884 {
3885     char buf[MAX_IPSTRLEN];
3886
3887     storeAppendPrintf(e, "%s %s",
3888                       n,
3889                       s->s.ToURL(buf,MAX_IPSTRLEN));
3890
3891     // MODES and specific sub-options.
3892     if (s->intercepted)
3893         storeAppendPrintf(e, " intercept");
3894
3895     else if (s->spoof_client_ip)
3896         storeAppendPrintf(e, " tproxy");
3897
3898     else if (s->accel) {
3899         storeAppendPrintf(e, " accel");
3900
3901         if (s->vhost)
3902             storeAppendPrintf(e, " vhost");
3903
3904         if (s->vport < 0)
3905             storeAppendPrintf(e, " vport");
3906         else if (s->vport > 0)
3907             storeAppendPrintf(e, " vport=%d", s->vport);
3908
3909         if (s->defaultsite)
3910             storeAppendPrintf(e, " defaultsite=%s", s->defaultsite);
3911
3912         if (s->protocol && strcmp(s->protocol,"http") != 0)
3913             storeAppendPrintf(e, " protocol=%s", s->protocol);
3914
3915         if (s->allow_direct)
3916             storeAppendPrintf(e, " allow-direct");
3917
3918         if (s->ignore_cc)
3919             storeAppendPrintf(e, " ignore-cc");
3920
3921     }
3922
3923     // Generic independent options
3924
3925     if (s->name)
3926         storeAppendPrintf(e, " name=%s", s->name);
3927
3928 #if USE_HTTP_VIOLATIONS
3929     if (!s->accel && s->ignore_cc)
3930         storeAppendPrintf(e, " ignore-cc");
3931 #endif
3932
3933     if (s->connection_auth_disabled)
3934         storeAppendPrintf(e, " connection-auth=off");
3935     else
3936         storeAppendPrintf(e, " connection-auth=on");
3937
3938     if (s->disable_pmtu_discovery != DISABLE_PMTU_OFF) {
3939         const char *pmtu;
3940
3941         if (s->disable_pmtu_discovery == DISABLE_PMTU_ALWAYS)
3942             pmtu = "always";
3943         else
3944             pmtu = "transparent";
3945
3946         storeAppendPrintf(e, " disable-pmtu-discovery=%s", pmtu);
3947     }
3948
3949     if (s->s.IsAnyAddr() && !s->s.IsIPv6())
3950         storeAppendPrintf(e, " ipv4");
3951
3952     if (s->tcp_keepalive.enabled) {
3953         if (s->tcp_keepalive.idle || s->tcp_keepalive.interval || s->tcp_keepalive.timeout) {
3954             storeAppendPrintf(e, " tcpkeepalive=%d,%d,%d", s->tcp_keepalive.idle, s->tcp_keepalive.interval, s->tcp_keepalive.timeout);
3955         } else {
3956             storeAppendPrintf(e, " tcpkeepalive");
3957         }
3958     }
3959
3960 #if USE_SSL
3961     if (s->sslBump)
3962         storeAppendPrintf(e, " ssl-bump");
3963
3964     if (s->cert)
3965         storeAppendPrintf(e, " cert=%s", s->cert);
3966
3967     if (s->key)
3968         storeAppendPrintf(e, " key=%s", s->key);
3969
3970     if (s->version)
3971         storeAppendPrintf(e, " version=%d", s->version);
3972
3973     if (s->options)
3974         storeAppendPrintf(e, " options=%s", s->options);
3975
3976     if (s->cipher)
3977         storeAppendPrintf(e, " cipher=%s", s->cipher);
3978
3979     if (s->cafile)
3980         storeAppendPrintf(e, " cafile=%s", s->cafile);
3981
3982     if (s->capath)
3983         storeAppendPrintf(e, " capath=%s", s->capath);
3984
3985     if (s->crlfile)
3986         storeAppendPrintf(e, " crlfile=%s", s->crlfile);
3987
3988     if (s->dhfile)
3989         storeAppendPrintf(e, " dhparams=%s", s->dhfile);
3990
3991     if (s->sslflags)
3992         storeAppendPrintf(e, " sslflags=%s", s->sslflags);
3993
3994     if (s->sslContextSessionId)
3995         storeAppendPrintf(e, " sslcontext=%s", s->sslContextSessionId);
3996
3997     if (s->generateHostCertificates)
3998         storeAppendPrintf(e, " generate-host-certificates");
3999
4000     if (s->dynamicCertMemCacheSize != std::numeric_limits<size_t>::max())
4001         storeAppendPrintf(e, "dynamic_cert_mem_cache_size=%lu%s\n", (unsigned long)s->dynamicCertMemCacheSize, B_BYTES_STR);
4002 #endif
4003 }
4004
4005 static void
4006 dump_http_port_list(StoreEntry * e, const char *n, const http_port_list * s)
4007 {
4008     while (s) {
4009         dump_generic_http_port(e, n, s);
4010         storeAppendPrintf(e, "\n");
4011         s = s->next;
4012     }
4013 }
4014
4015 static void
4016 free_http_port_list(http_port_list ** head)
4017 {
4018     http_port_list *s;
4019
4020     while ((s = *head) != NULL) {
4021         *head = s->next;
4022         delete s;
4023     }
4024 }
4025
4026 #if USE_SSL
4027
4028 // TODO: merge better with parse_http_port_list
4029 static void
4030 parse_https_port_list(https_port_list ** head)
4031 {
4032     char *token;
4033     https_port_list *s;
4034
4035     token = strtok(NULL, w_space);
4036
4037     if (!token)
4038         self_destruct();
4039
4040     s = new https_port_list;
4041     parse_http_port_specification(&s->http, token);
4042
4043     /* parse options ... */
4044     while ((token = strtok(NULL, w_space))) {
4045         parse_http_port_option(s, token);
4046     }
4047
4048     while (*head) {
4049         http_port_list ** headTmp = &(*head)->http.next;
4050         head = (https_port_list **)headTmp;
4051     }
4052
4053     *head = s;
4054 }
4055
4056 static void
4057 dump_https_port_list(StoreEntry * e, const char *n, const https_port_list * s)
4058 {
4059     dump_http_port_list(e, n, s);
4060 }
4061
4062 static void
4063 free_https_port_list(https_port_list ** head)
4064 {
4065     free_http_port_list((http_port_list**)head);
4066 }
4067
4068 #if 0
4069 static int
4070 check_null_https_port_list(const https_port_list * s)
4071 {
4072     return NULL == s;
4073 }
4074
4075 #endif
4076
4077 #endif /* USE_SSL */
4078
4079 void
4080 configFreeMemory(void)
4081 {
4082     free_all();
4083 #if USE_SSL
4084     SSL_CTX_free(Config.ssl_client.sslContext);
4085 #endif
4086 }
4087
4088 void
4089 requirePathnameExists(const char *name, const char *path)
4090 {
4091
4092     struct stat sb;
4093     char pathbuf[BUFSIZ];
4094     assert(path != NULL);
4095
4096     if (Config.chroot_dir && (geteuid() == 0)) {
4097         snprintf(pathbuf, BUFSIZ, "%s/%s", Config.chroot_dir, path);
4098         path = pathbuf;
4099     }
4100
4101     if (stat(path, &sb) < 0) {
4102         debugs(0, DBG_CRITICAL, (opt_parse_cfg_only?"FATAL ":"") << "ERROR: " << name << " " << path << ": " << xstrerror());
4103         // keep going to find more issues if we are only checking the config file with "-k parse"
4104         if (opt_parse_cfg_only)
4105             return;
4106         // this is fatal if it is found during startup or reconfigure
4107         if (opt_send_signal == -1 || opt_send_signal == SIGHUP)
4108             fatalf("%s %s: %s", name, path, xstrerror());
4109     }
4110 }
4111
4112 char *
4113 strtokFile(void)
4114 {
4115     return ConfigParser::strtokFile();
4116 }
4117
4118 #include "AccessLogEntry.h"
4119
4120 static void
4121 parse_access_log(customlog ** logs)
4122 {
4123     const char *filename, *logdef_name;
4124
4125     customlog *cl = (customlog *)xcalloc(1, sizeof(*cl));
4126
4127     if ((filename = strtok(NULL, w_space)) == NULL) {
4128         self_destruct();
4129         return;
4130     }
4131
4132     if (strcmp(filename, "none") == 0) {
4133         cl->type = Log::Format::CLF_NONE;
4134         aclParseAclList(LegacyParser, &cl->aclList);
4135         while (*logs)
4136             logs = &(*logs)->next;
4137         *logs = cl;
4138         return;
4139     }
4140
4141     if ((logdef_name = strtok(NULL, w_space)) == NULL)
4142         logdef_name = "squid";
4143
4144     debugs(3, 9, "Log definition name '" << logdef_name << "' file '" << filename << "'");
4145
4146     cl->filename = xstrdup(filename);
4147
4148     /* look for the definition pointer corresponding to this name */
4149     Format::Format *lf = Log::TheConfig.logformats;
4150
4151     while (lf != NULL) {
4152         debugs(3, 9, "Comparing against '" << lf->name << "'");
4153
4154         if (strcmp(lf->name, logdef_name) == 0)
4155             break;
4156
4157         lf = lf->next;
4158     }
4159
4160     if (lf != NULL) {
4161         cl->type = Log::Format::CLF_CUSTOM;
4162         cl->logFormat = lf;
4163     } else if (strcmp(logdef_name, "auto") == 0) {
4164         debugs(0,0, "WARNING: Log format 'auto' no longer exists. Using 'squid' instead.");
4165         cl->type = Log::Format::CLF_SQUID;
4166     } else if (strcmp(logdef_name, "squid") == 0) {
4167         cl->type = Log::Format::CLF_SQUID;
4168     } else if (strcmp(logdef_name, "common") == 0) {
4169         cl->type = Log::Format::CLF_COMMON;
4170     } else if (strcmp(logdef_name, "combined") == 0) {
4171         cl->type = Log::Format::CLF_COMBINED;
4172 #if ICAP_CLIENT
4173     } else if (strcmp(logdef_name, "icap_squid") == 0) {
4174         cl->type = Log::Format::CLF_ICAP_SQUID;
4175 #endif
4176     } else if (strcmp(logdef_name, "useragent") == 0) {
4177         cl->type = Log::Format::CLF_USERAGENT;
4178     } else if (strcmp(logdef_name, "referrer") == 0) {
4179         cl->type = Log::Format::CLF_REFERER;
4180     } else {
4181         debugs(3, 0, "Log format '" << logdef_name << "' is not defined");
4182         self_destruct();
4183         return;
4184     }
4185
4186     aclParseAclList(LegacyParser, &cl->aclList);
4187
4188     while (*logs)
4189         logs = &(*logs)->next;
4190
4191     *logs = cl;
4192 }
4193
4194 static int
4195 check_null_access_log(customlog *customlog_definitions)
4196 {
4197     return customlog_definitions == NULL;
4198 }
4199
4200 static void
4201 dump_access_log(StoreEntry * entry, const char *name, customlog * logs)
4202 {
4203     customlog *log;
4204
4205     for (log = logs; log; log = log->next) {
4206         storeAppendPrintf(entry, "%s ", name);
4207
4208         switch (log->type) {
4209
4210         case Log::Format::CLF_CUSTOM:
4211             storeAppendPrintf(entry, "%s %s", log->filename, log->logFormat->name);
4212             break;
4213
4214         case Log::Format::CLF_NONE:
4215             storeAppendPrintf(entry, "none");
4216             break;
4217
4218         case Log::Format::CLF_SQUID:
4219             storeAppendPrintf(entry, "%s squid", log->filename);
4220             break;
4221
4222         case Log::Format::CLF_COMBINED:
4223             storeAppendPrintf(entry, "%s combined", log->filename);
4224             break;
4225
4226         case Log::Format::CLF_COMMON:
4227             storeAppendPrintf(entry, "%s common", log->filename);
4228             break;
4229
4230 #if ICAP_CLIENT
4231         case Log::Format::CLF_ICAP_SQUID:
4232             storeAppendPrintf(entry, "%s icap_squid", log->filename);
4233             break;
4234 #endif
4235         case Log::Format::CLF_USERAGENT:
4236             storeAppendPrintf(entry, "%s useragent", log->filename);
4237             break;
4238
4239         case Log::Format::CLF_REFERER:
4240             storeAppendPrintf(entry, "%s referrer", log->filename);
4241             break;
4242
4243         case Log::Format::CLF_UNKNOWN:
4244             break;
4245         }
4246
4247         if (log->aclList)
4248             dump_acl_list(entry, log->aclList);
4249
4250         storeAppendPrintf(entry, "\n");
4251     }
4252 }
4253
4254 static void
4255 free_access_log(customlog ** definitions)
4256 {
4257     while (*definitions) {
4258         customlog *log = *definitions;
4259         *definitions = log->next;
4260
4261         log->logFormat = NULL;
4262         log->type = Log::Format::CLF_UNKNOWN;
4263
4264         if (log->aclList)
4265             aclDestroyAclList(&log->aclList);
4266
4267         safe_free(log->filename);
4268
4269         xfree(log);
4270     }
4271 }
4272
4273 /// parses list of integers form name=N1,N2,N3,...
4274 static bool
4275 parseNamedIntList(const char *data, const String &name, Vector<int> &list)
4276 {
4277     if (data && (strncmp(data, name.rawBuf(), name.size()) == 0)) {
4278         data += name.size();
4279         if (*data == '=') {
4280             while (true) {
4281                 ++data;
4282                 int value = 0;
4283                 if (!StringToInt(data, value, &data, 10))
4284                     break;
4285                 list.push_back(value);
4286                 if (*data == '\0' || *data != ',')
4287                     break;
4288             }
4289         }
4290     }
4291     return data && *data == '\0';
4292 }
4293
4294 static void
4295 parse_CpuAffinityMap(CpuAffinityMap **const cpuAffinityMap)
4296 {
4297 #if !HAVE_CPU_AFFINITY
4298     debugs(3, DBG_CRITICAL, "FATAL: Squid built with no CPU affinity " <<
4299            "support, do not set 'cpu_affinity_map'");
4300     self_destruct();
4301 #endif /* HAVE_CPU_AFFINITY */
4302
4303     if (!*cpuAffinityMap)
4304         *cpuAffinityMap = new CpuAffinityMap;
4305
4306     const char *const pToken = strtok(NULL, w_space);
4307     const char *const cToken = strtok(NULL, w_space);
4308     Vector<int> processes, cores;
4309     if (!parseNamedIntList(pToken, "process_numbers", processes)) {
4310         debugs(3, DBG_CRITICAL, "FATAL: bad 'process_numbers' parameter " <<
4311                "in 'cpu_affinity_map'");
4312         self_destruct();
4313     } else if (!parseNamedIntList(cToken, "cores", cores)) {
4314         debugs(3, DBG_CRITICAL, "FATAL: bad 'cores' parameter in " <<
4315                "'cpu_affinity_map'");
4316         self_destruct();
4317     } else if (!(*cpuAffinityMap)->add(processes, cores)) {
4318         debugs(3, DBG_CRITICAL, "FATAL: bad 'cpu_affinity_map'; " <<
4319                "process_numbers and cores lists differ in length or " <<
4320                "contain numbers <= 0");
4321         self_destruct();
4322     }
4323 }
4324
4325 static void
4326 dump_CpuAffinityMap(StoreEntry *const entry, const char *const name, const CpuAffinityMap *const cpuAffinityMap)
4327 {
4328     if (cpuAffinityMap) {
4329         storeAppendPrintf(entry, "%s process_numbers=", name);
4330         for (size_t i = 0; i < cpuAffinityMap->processes().size(); ++i) {
4331             storeAppendPrintf(entry, "%s%i", (i ? "," : ""),
4332                               cpuAffinityMap->processes()[i]);
4333         }
4334         storeAppendPrintf(entry, " cores=");
4335         for (size_t i = 0; i < cpuAffinityMap->processes().size(); ++i) {
4336             storeAppendPrintf(entry, "%s%i", (i ? "," : ""),
4337                               cpuAffinityMap->cores()[i]);
4338         }
4339         storeAppendPrintf(entry, "\n");
4340     }
4341 }
4342
4343 static void
4344 free_CpuAffinityMap(CpuAffinityMap **const cpuAffinityMap)
4345 {
4346     delete *cpuAffinityMap;
4347     *cpuAffinityMap = NULL;
4348 }
4349
4350 #if USE_ADAPTATION
4351
4352 static void
4353 parse_adaptation_service_set_type()
4354 {
4355     Adaptation::Config::ParseServiceSet();
4356 }
4357
4358 static void
4359 parse_adaptation_service_chain_type()
4360 {
4361     Adaptation::Config::ParseServiceChain();
4362 }
4363
4364 static void
4365 parse_adaptation_access_type()
4366 {
4367     Adaptation::Config::ParseAccess(LegacyParser);
4368 }
4369
4370 #endif /* USE_ADAPTATION */
4371
4372
4373 #if ICAP_CLIENT
4374
4375 static void
4376 parse_icap_service_type(Adaptation::Icap::Config * cfg)
4377 {
4378     cfg->parseService();
4379 }
4380
4381 static void
4382 free_icap_service_type(Adaptation::Icap::Config * cfg)
4383 {
4384     cfg->freeService();
4385 }
4386
4387 static void
4388 dump_icap_service_type(StoreEntry * entry, const char *name, const Adaptation::Icap::Config &cfg)
4389 {
4390     cfg.dumpService(entry, name);
4391 }
4392
4393 static void
4394 parse_icap_class_type()
4395 {
4396     debugs(93, 0, "WARNING: 'icap_class' is depricated. " <<
4397            "Use 'adaptation_service_set' instead");
4398     Adaptation::Config::ParseServiceSet();
4399 }
4400
4401 static void
4402 parse_icap_access_type()
4403 {
4404     debugs(93, 0, "WARNING: 'icap_access' is depricated. " <<
4405            "Use 'adaptation_access' instead");
4406     Adaptation::Config::ParseAccess(LegacyParser);
4407 }
4408
4409 #endif
4410
4411
4412 #if USE_ECAP
4413
4414 static void
4415 parse_ecap_service_type(Adaptation::Ecap::Config * cfg)
4416 {
4417     cfg->parseService();
4418 }
4419
4420 static void
4421 free_ecap_service_type(Adaptation::Ecap::Config * cfg)
4422 {
4423     cfg->freeService();
4424 }
4425
4426 static void
4427 dump_ecap_service_type(StoreEntry * entry, const char *name, const Adaptation::Ecap::Config &cfg)
4428 {
4429     cfg.dumpService(entry, name);
4430 }
4431
4432 #endif /* USE_ECAP */
4433
4434 #if ICAP_CLIENT
4435 static void parse_icap_service_failure_limit(Adaptation::Icap::Config *cfg)
4436 {
4437     char *token;
4438     time_t d;
4439     time_t m;
4440     cfg->service_failure_limit = GetInteger();
4441
4442     if ((token = strtok(NULL, w_space)) == NULL)
4443         return;
4444
4445     if (strcmp(token,"in") != 0) {
4446         debugs(3, 0, "expecting 'in' on'"  << config_input_line << "'");
4447         self_destruct();
4448     }
4449
4450     if ((token = strtok(NULL, w_space)) == NULL) {
4451         self_destruct();
4452     }
4453
4454     d = static_cast<time_t> (xatoi(token));
4455
4456     m = static_cast<time_t> (1);
4457
4458     if (0 == d)
4459         (void) 0;
4460     else if ((token = strtok(NULL, w_space)) == NULL) {
4461         debugs(3, 0, "No time-units on '" << config_input_line << "'");
4462         self_destruct();
4463     } else if ((m = parseTimeUnits(token, false)) == 0)
4464         self_destruct();
4465
4466     cfg->oldest_service_failure = (m * d);
4467 }
4468
4469 static void dump_icap_service_failure_limit(StoreEntry *entry, const char *name, const Adaptation::Icap::Config &cfg)
4470 {
4471     storeAppendPrintf(entry, "%s %d", name, cfg.service_failure_limit);
4472     if (cfg.oldest_service_failure > 0) {
4473         storeAppendPrintf(entry, " in %d seconds", (int)cfg.oldest_service_failure);
4474     }
4475     storeAppendPrintf(entry, "\n");
4476 }
4477
4478 static void free_icap_service_failure_limit(Adaptation::Icap::Config *cfg)
4479 {
4480     cfg->oldest_service_failure = 0;
4481     cfg->service_failure_limit = 0;
4482 }
4483
4484 #endif