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