src/cache_cf.cc

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