开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 代理服务器 > 查看源码
cache_cf.c
资源名称：squid-2.2.devel3-src.tar.gz　[点击查看]
上传用户：liugui
上传日期：2007-01-04
资源大小：822k
文件大小：40k
源码类别：

代理服务器

开发平台：

Unix_Linux

cache_cf.c：源码内容
  2. /*
  3.  * $Id: cache_cf.c,v 1.324.2.2 1999/02/14 00:23:09 wessels Exp $
  4.  *
  5.  * DEBUG: section 3     Configuration File Parsing
  6.  * AUTHOR: Harvest Derived
  7.  *
  8.  * SQUID Internet Object Cache  http://squid.nlanr.net/Squid/
  9.  * ----------------------------------------------------------
  10.  *
  11.  *  Squid is the result of efforts by numerous individuals from the
  12.  *  Internet community.  Development is led by Duane Wessels of the
  13.  *  National Laboratory for Applied Network Research and funded by the
  14.  *  National Science Foundation.  Squid is Copyrighted (C) 1998 by
  15.  *  Duane Wessels and the University of California San Diego.  Please
  16.  *  see the COPYRIGHT file for full details.  Squid incorporates
  17.  *  software developed and/or copyrighted by other sources.  Please see
  18.  *  the CREDITS file for full details.
  19.  *
  20.  *  This program is free software; you can redistribute it and/or modify
  21.  *  it under the terms of the GNU General Public License as published by
  22.  *  the Free Software Foundation; either version 2 of the License, or
  23.  *  (at your option) any later version.
  24.  *  
  25.  *  This program is distributed in the hope that it will be useful,
  26.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  27.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  28.  *  GNU General Public License for more details.
  29.  *  
  30.  *  You should have received a copy of the GNU General Public License
  31.  *  along with this program; if not, write to the Free Software
  32.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
  33.  *
  34.  */
  36. #include "squid.h"
  38. #if SQUID_SNMP
  39. #include "snmp.h"
  40. #endif
  42. static const char *const T_SECOND_STR = "second";
  43. static const char *const T_MINUTE_STR = "minute";
  44. static const char *const T_HOUR_STR = "hour";
  45. static const char *const T_DAY_STR = "day";
  46. static const char *const T_WEEK_STR = "week";
  47. static const char *const T_FORTNIGHT_STR = "fortnight";
  48. static const char *const T_MONTH_STR = "month";
  49. static const char *const T_YEAR_STR = "year";
  50. static const char *const T_DECADE_STR = "decade";
  52. static const char *const B_BYTES_STR = "bytes";
  53. static const char *const B_KBYTES_STR = "KB";
  54. static const char *const B_MBYTES_STR = "MB";
  55. static const char *const B_GBYTES_STR = "GB";
  57. static const char *const list_sep = ", tnr";
  59. static int http_header_first = 0;
  61. static void self_destruct(void);
  63. static void configDoConfigure(void);
  64. static void parse_refreshpattern(refresh_t **);
  65. static int parseTimeUnits(const char *unit);
  66. static void parseTimeLine(time_t * tptr, const char *units);
  67. static void parse_ushort(u_short * var);
  68. static void parse_string(char **);
  69. static void parse_wordlist(wordlist **);
  70. static void default_all(void);
  71. static void defaults_if_none(void);
  72. static int parse_line(char *);
  73. static void parseBytesLine(size_t * bptr, const char *units);
  74. static size_t parseBytesUnits(const char *unit);
  75. static void free_all(void);
  76. static void requirePathnameExists(const char *name, const char *path);
  77. static OBJH dump_config;
  78. static void dump_http_header(StoreEntry * entry, const char *name, HttpHeaderMask header);
  79. static void parse_http_header(HttpHeaderMask * header);
  80. static void free_http_header(HttpHeaderMask * header);
  82. static void
  83. self_destruct(void)
  84. {
  85.     fatalf("Bungled %s line %d: %s",
  86. cfg_filename, config_lineno, config_input_line);
  87. }
  89. void
  90. wordlistDestroy(wordlist ** list)
  91. {
  92.     wordlist *w = NULL;
  93.     while ((w = *list) != NULL) {
  94. *list = w->next;
  95. safe_free(w->key);
  96. memFree(w, MEM_WORDLIST);
  97.     }
  98.     *list = NULL;
  99. }
  101. wordlist *
  102. wordlistAdd(wordlist ** list, const char *key)
  103. {
  104.     while (*list)
  105. list = &(*list)->next;
  106.     *list = memAllocate(MEM_WORDLIST);
  107.     (*list)->key = xstrdup(key);
  108.     (*list)->next = NULL;
  109.     return *list;
  110. }
  112. void
  113. wordlistCat(const wordlist * w, MemBuf * mb)
  114. {
  115.     while (NULL != w) {
  116. memBufPrintf(mb, "%sn", w->key);
  117. w = w->next;
  118.     }
  119. }
  121. void
  122. intlistDestroy(intlist ** list)
  123. {
  124.     intlist *w = NULL;
  125.     intlist *n = NULL;
  126.     for (w = *list; w; w = n) {
  127. n = w->next;
  128. memFree(w, MEM_INTLIST);
  129.     }
  130.     *list = NULL;
  131. }
  133. int
  134. intlistFind(intlist * list, int i)
  135. {
  136.     intlist *w = NULL;
  137.     for (w = list; w; w = w->next)
  138. if (w->i == i)
  139.     return 1;
  140.     return 0;
  141. }
  144. /*
  145.  * Use this #define in all the parse*() functions.  Assumes char *token is
  146.  * defined
  147.  */
  149. #define GetInteger(var) 
  150. token = strtok(NULL, w_space); 
  151. if( token == NULL) 
  152. self_destruct(); 
  153. if (sscanf(token, "%d", &var) != 1) 
  154. self_destruct();
  156. int
  157. parseConfigFile(const char *file_name)
  158. {
  159.     FILE *fp = NULL;
  160.     char *token = NULL;
  161.     char *tmp_line;
  162.     int err_count = 0;
  163.     free_all();
  164.     default_all();
  165.     if ((fp = fopen(file_name, "r")) == NULL)
  166. fatalf("Unable to open configuration file: %s: %s",
  167.     file_name, xstrerror());
  168.     cfg_filename = file_name;
  169.     if ((token = strrchr(cfg_filename, '/')))
  170. cfg_filename = token + 1;
  171.     memset(config_input_line, '', BUFSIZ);
  172.     config_lineno = 0;
  173.     while (fgets(config_input_line, BUFSIZ, fp)) {
  174. config_lineno++;
  175. if ((token = strchr(config_input_line, 'n')))
  176.     *token = '';
  177. if (config_input_line[0] == '#')
  178.     continue;
  179. if (config_input_line[0] == '')
  180.     continue;
  181. debug(3, 5) ("Processing: '%s'n", config_input_line);
  182. tmp_line = xstrdup(config_input_line);
  183. if (!parse_line(tmp_line)) {
  184.     debug(3, 0) ("parseConfigFile: line %d unrecognized: '%s'n",
  185. config_lineno,
  186. config_input_line);
  187.     err_count++;
  188. }
  189. safe_free(tmp_line);
  190.     }
  191.     fclose(fp);
  192.     defaults_if_none();
  193.     configDoConfigure();
  194.     cachemgrRegister("config",
  195. "Current Squid Configuration",
  196. dump_config,
  197. 1, 1);
  198.     return err_count;
  199. }
  201. static void
  202. configDoConfigure(void)
  203. {
  204.     LOCAL_ARRAY(char, buf, BUFSIZ);
  205.     memset(&Config2, '', sizeof(SquidConfig2));
  206.     /* init memory as early as possible */
  207.     memConfigure();
  208.     /* Sanity checks */
  209.     if (Config.cacheSwap.swapDirs == NULL)
  210. fatal("No cache_dir's specified in config file");
  211.     /* calculate Config.Swap.maxSize */
  212.     storeDirConfigure();
  213.     if (Config.Swap.maxSize < (Config.memMaxSize >> 10))
  214. fatal("cache_swap is lower than cache_mem");
  215.     if (Config.Announce.period > 0) {
  216. Config.onoff.announce = 1;
  217.     } else if (Config.Announce.period < 1) {
  218. Config.Announce.period = 86400 * 365; /* one year */
  219. Config.onoff.announce = 0;
  220.     }
  221.     if (Config.dnsChildren < 1)
  222. fatal("No dnsservers allocated");
  223.     if (Config.dnsChildren > DefaultDnsChildrenMax) {
  224. debug(3, 0) ("WARNING: dns_children was set to a bad value: %dn",
  225.     Config.dnsChildren);
  226. debug(3, 0) ("Setting it to the maximum (%d).n",
  227.     DefaultDnsChildrenMax);
  228. Config.dnsChildren = DefaultDnsChildrenMax;
  229.     }
  230.     if (Config.Program.redirect) {
  231. if (Config.redirectChildren < 1) {
  232.     Config.redirectChildren = 0;
  233.     safe_free(Config.Program.redirect);
  234. } else if (Config.redirectChildren > DefaultRedirectChildrenMax) {
  235.     debug(3, 0) ("WARNING: redirect_children was set to a bad value: %dn",
  236. Config.redirectChildren);
  237.     debug(3, 0) ("Setting it to the maximum (%d).n", DefaultRedirectChildrenMax);
  238.     Config.redirectChildren = DefaultRedirectChildrenMax;
  239. }
  240.     }
  241.     if (Config.Program.authenticate) {
  242. if (Config.authenticateChildren < 1) {
  243.     Config.authenticateChildren = 0;
  244.     wordlistDestroy(&Config.Program.authenticate);
  245. } else if (Config.authenticateChildren > DefaultAuthenticateChildrenMax) {
  246.     debug(3, 0) ("WARNING: authenticate_children was set to a bad value: %dn",
  247. Config.authenticateChildren);
  248.     debug(3, 0) ("Setting it to the maximum (%d).n", DefaultAuthenticateChildrenMax);
  249.     Config.authenticateChildren = DefaultAuthenticateChildrenMax;
  250. }
  251.     }
  252.     if (Config.Accel.host) {
  253. snprintf(buf, BUFSIZ, "http://%s:%d", Config.Accel.host, Config.Accel.port);
  254. Config2.Accel.prefix = xstrdup(buf);
  255. Config2.Accel.on = 1;
  256.     }
  257.     if (Config.appendDomain)
  258. if (*Config.appendDomain != '.')
  259.     fatal("append_domain must begin with a '.'");
  260.     if (Config.errHtmlText == NULL)
  261. Config.errHtmlText = xstrdup(null_string);
  262.     storeConfigure();
  263.     if (Config2.Accel.on && !strcmp(Config.Accel.host, "virtual"))
  264. vhost_mode = 1;
  265.     if (Config.Port.http == NULL)
  266. fatal("No http_port specified!");
  267.     snprintf(ThisCache, sizeof(ThisCache), "%s:%d (%s)",
  268. uniqueHostname(),
  269. (int) Config.Port.http->i,
  270. full_appname_string);
  271.     /*
  272.      * the extra space is for loop detection in client_side.c -- we search
  273.      * for substrings in the Via header.
  274.      */
  275.     snprintf(ThisCache2, sizeof(ThisCache), " %s:%d (%s)",
  276. uniqueHostname(),
  277. (int) Config.Port.http->i,
  278. full_appname_string);
  279.     if (!Config.udpMaxHitObjsz || Config.udpMaxHitObjsz > SQUID_UDP_SO_SNDBUF)
  280. Config.udpMaxHitObjsz = SQUID_UDP_SO_SNDBUF;
  281.     if (Config.appendDomain)
  282. Config.appendDomainLen = strlen(Config.appendDomain);
  283.     else
  284. Config.appendDomainLen = 0;
  285.     safe_free(debug_options)
  286. debug_options = xstrdup(Config.debugOptions);
  287.     if (Config.retry.timeout < 5)
  288. fatal("minimum_retry_timeout must be at least 5 seconds");
  289.     if (Config.retry.maxtries > 10)
  290. fatal("maximum_single_addr_tries cannot be larger than 10");
  291.     if (Config.retry.maxtries < 1) {
  292. debug(3, 0) ("WARNING: resetting 'maximum_single_addr_tries to 1n");
  293. Config.retry.maxtries = 1;
  294.     }
  295.     if (Config.referenceAge < 300) {
  296. debug(3, 0) ("WARNING: resetting 'reference_age' to 1 weekn");
  297. Config.referenceAge = 86400 * 7;
  298.     }
  299.     requirePathnameExists("MIME Config Table", Config.mimeTablePathname);
  300.     requirePathnameExists("cache_dns_program", Config.Program.dnsserver);
  301.     requirePathnameExists("unlinkd_program", Config.Program.unlinkd);
  302.     if (Config.Program.redirect)
  303. requirePathnameExists("redirect_program", Config.Program.redirect);
  304.     if (Config.Program.authenticate)
  305. requirePathnameExists("authenticate_program", Config.Program.authenticate->key);
  306.     requirePathnameExists("Icon Directory", Config.icons.directory);
  307.     requirePathnameExists("Error Directory", Config.errorDirectory);
  308. #if HTTP_VIOLATIONS
  309.     {
  310. const refresh_t *R;
  311. for (R = Config.Refresh; R; R = R->next) {
  312.     if (!R->flags.override_expire)
  313. continue;
  314.     debug(22, 1) ("WARNING: use of 'override-expire' in 'refresh_pattern' violates HTTPn");
  315.     break;
  316. }
  317. for (R = Config.Refresh; R; R = R->next) {
  318.     if (!R->flags.override_lastmod)
  319. continue;
  320.     debug(22, 1) ("WARNING: use of 'override-lastmod' in 'refresh_pattern' violates HTTPn");
  321.     break;
  322. }
  323.     }
  324. #endif
  325.     if (Config.Wais.relayHost) {
  326. if (Config.Wais.peer)
  327.     cbdataFree(Config.Wais.peer);
  328. Config.Wais.peer = memAllocate(MEM_PEER);
  329. cbdataAdd(Config.Wais.peer, peerDestroy, MEM_PEER);
  330. Config.Wais.peer->host = Config.Wais.relayHost;
  331. Config.Wais.peer->http_port = Config.Wais.relayPort;
  332.     }
  333. }
  335. /* Parse a time specification from the config file.  Store the
  336.  * result in 'tptr', after converting it to 'units' */
  337. static void
  338. parseTimeLine(time_t * tptr, const char *units)
  339. {
  340.     char *token;
  341.     double d;
  342.     time_t m;
  343.     time_t u;
  344.     if ((u = parseTimeUnits(units)) == 0)
  345. self_destruct();
  346.     if ((token = strtok(NULL, w_space)) == NULL)
  347. self_destruct();
  348.     d = atof(token);
  349.     m = u; /* default to 'units' if none specified */
  350.     if (0 == d)
  351. (void) 0;
  352.     else if ((token = strtok(NULL, w_space)) == NULL)
  353. debug(3, 0) ("WARNING: No units on '%s', assuming %f %sn",
  354.     config_input_line, d, units);
  355.     else if ((m = parseTimeUnits(token)) == 0)
  356. self_destruct();
  357.     *tptr = m * d / u;
  358. }
  360. static int
  361. parseTimeUnits(const char *unit)
  362. {
  363.     if (!strncasecmp(unit, T_SECOND_STR, strlen(T_SECOND_STR)))
  364. return 1;
  365.     if (!strncasecmp(unit, T_MINUTE_STR, strlen(T_MINUTE_STR)))
  366. return 60;
  367.     if (!strncasecmp(unit, T_HOUR_STR, strlen(T_HOUR_STR)))
  368. return 3600;
  369.     if (!strncasecmp(unit, T_DAY_STR, strlen(T_DAY_STR)))
  370. return 86400;
  371.     if (!strncasecmp(unit, T_WEEK_STR, strlen(T_WEEK_STR)))
  372. return 86400 * 7;
  373.     if (!strncasecmp(unit, T_FORTNIGHT_STR, strlen(T_FORTNIGHT_STR)))
  374. return 86400 * 14;
  375.     if (!strncasecmp(unit, T_MONTH_STR, strlen(T_MONTH_STR)))
  376. return 86400 * 30;
  377.     if (!strncasecmp(unit, T_YEAR_STR, strlen(T_YEAR_STR)))
  378. return 86400 * 365.2522;
  379.     if (!strncasecmp(unit, T_DECADE_STR, strlen(T_DECADE_STR)))
  380. return 86400 * 365.2522 * 10;
  381.     debug(3, 1) ("parseTimeUnits: unknown time unit '%s'n", unit);
  382.     return 0;
  383. }
  385. static void
  386. parseBytesLine(size_t * bptr, const char *units)
  387. {
  388.     char *token;
  389.     double d;
  390.     size_t m;
  391.     size_t u;
  392.     if ((u = parseBytesUnits(units)) == 0)
  393. self_destruct();
  394.     if ((token = strtok(NULL, w_space)) == NULL)
  395. self_destruct();
  396.     d = atof(token);
  397.     m = u; /* default to 'units' if none specified */
  398.     if (0 == d)
  399. (void) 0;
  400.     else if ((token = strtok(NULL, w_space)) == NULL)
  401. debug(3, 0) ("WARNING: No units on '%s', assuming %f %sn",
  402.     config_input_line, d, units);
  403.     else if ((m = parseBytesUnits(token)) == 0)
  404. self_destruct();
  405.     *bptr = m * d / u;
  406. }
  408. static size_t
  409. parseBytesUnits(const char *unit)
  410. {
  411.     if (!strncasecmp(unit, B_BYTES_STR, strlen(B_BYTES_STR)))
  412. return 1;
  413.     if (!strncasecmp(unit, B_KBYTES_STR, strlen(B_KBYTES_STR)))
  414. return 1 << 10;
  415.     if (!strncasecmp(unit, B_MBYTES_STR, strlen(B_MBYTES_STR)))
  416. return 1 << 20;
  417.     if (!strncasecmp(unit, B_GBYTES_STR, strlen(B_GBYTES_STR)))
  418. return 1 << 30;
  419.     debug(3, 1) ("parseBytesUnits: unknown bytes unit '%s'n", unit);
  420.     return 0;
  421. }
  423. /*****************************************************************************
  424.  * Max
  425.  *****************************************************************************/
  427. static void
  428. dump_acl(StoreEntry * entry, const char *name, acl * ae)
  429. {
  430.     wordlist *w;
  431.     wordlist *v;
  432.     while (ae != NULL) {
  433. debug(3, 3) ("dump_acl: %s %sn", name, ae->name);
  434. v = w = aclDumpGeneric(ae);
  435. while (v != NULL) {
  436.     debug(3, 3) ("dump_acl: %s %s %sn", name, ae->name, v->key);
  437.     storeAppendPrintf(entry, "%s %s %s %sn",
  438. name,
  439. ae->name,
  440. aclTypeToStr(ae->type),
  441. v->key);
  442.     v = v->next;
  443. }
  444. wordlistDestroy(&w);
  445. ae = ae->next;
  446.     }
  447. }
  449. static void
  450. parse_acl(acl ** ae)
  451. {
  452.     aclParseAclLine(ae);
  453. }
  455. static void
  456. free_acl(acl ** ae)
  457. {
  458.     aclDestroyAcls(ae);
  459. }
  461. static void
  462. dump_acl_access(StoreEntry * entry, const char *name, acl_access * head)
  463. {
  464.     acl_list *l;
  465.     while (head != NULL) {
  466. storeAppendPrintf(entry, "%s %s",
  467.     name,
  468.     head->allow ? "Allow" : "Deny");
  469. for (l = head->acl_list; l != NULL; l = l->next) {
  470.     storeAppendPrintf(entry, " %s%s",
  471. l->op ? null_string : "!",
  472. l->acl->name);
  473. }
  474. storeAppendPrintf(entry, "n");
  475. head = head->next;
  476.     }
  477. }
  479. static void
  480. parse_acl_access(acl_access ** head)
  481. {
  482.     aclParseAccessLine(head);
  483. }
  485. static void
  486. free_acl_access(acl_access ** head)
  487. {
  488.     aclDestroyAccessList(head);
  489. }
  491. static void
  492. dump_address(StoreEntry * entry, const char *name, struct in_addr addr)
  493. {
  494.     storeAppendPrintf(entry, "%s %sn", name, inet_ntoa(addr));
  495. }
  497. static void
  498. parse_address(struct in_addr *addr)
  499. {
  500.     const struct hostent *hp;
  501.     char *token = strtok(NULL, w_space);
  503.     if (token == NULL)
  504. self_destruct();
  505.     if (safe_inet_addr(token, addr) == 1)
  506. (void) 0;
  507.     else if ((hp = gethostbyname(token))) /* dont use ipcache */
  508. *addr = inaddrFromHostent(hp);
  509.     else
  510. self_destruct();
  511. }
  513. static void
  514. free_address(struct in_addr *addr)
  515. {
  516.     memset(addr, '', sizeof(struct in_addr));
  517. }
  519. #if DELAY_POOLS
  521. /* do nothing - free_delay_pool_count is the magic free function.
  522.  * this is why delay_pool_count isn't just marked TYPE: ushort
  523.  */
  524. #define free_delay_pool_class(X)
  525. #define free_delay_pool_access(X)
  526. #define free_delay_pool_rates(X)
  527. #define dump_delay_pool_class(X, Y, Z)
  528. #define dump_delay_pool_access(X, Y, Z)
  529. #define dump_delay_pool_rates(X, Y, Z)
  531. static void
  532. free_delay_pool_count(delayConfig * cfg)
  533. {
  534.     int i;
  536.     if (!cfg->pools)
  537. return;
  538.     for (i = 0; i < cfg->pools; i++) {
  539. if (cfg->class[i]) {
  540.     delayFreeDelayPool(i);
  541.     safe_free(cfg->rates[i]);
  542. }
  543. aclDestroyAccessList(&cfg->access[i]);
  544.     }
  545.     delayFreeDelayData();
  546.     xfree(cfg->class);
  547.     xfree(cfg->rates);
  548.     xfree(cfg->access);
  549.     memset(cfg, 0, sizeof(*cfg));
  550. }
  552. static void
  553. dump_delay_pool_count(StoreEntry * entry, const char *name, delayConfig cfg)
  554. {
  555.     int i;
  556.     LOCAL_ARRAY(char, nom, 32);
  558.     if (!cfg.pools) {
  559. storeAppendPrintf(entry, "%s 0n", name);
  560. return;
  561.     }
  562.     storeAppendPrintf(entry, "%s %dn", name, cfg.pools);
  563.     for (i = 0; i < cfg.pools; i++) {
  564. storeAppendPrintf(entry, "delay_class %d %dn", i + 1, cfg.class[i]);
  565. snprintf(nom, 32, "delay_access %d", i + 1);
  566. dump_acl_access(entry, nom, cfg.access[i]);
  567. if (cfg.class[i] >= 1)
  568.     storeAppendPrintf(entry, "delay_parameters %d %d/%d", i + 1,
  569. cfg.rates[i]->aggregate.restore_bps,
  570. cfg.rates[i]->aggregate.max_bytes);
  571. if (cfg.class[i] >= 3)
  572.     storeAppendPrintf(entry, " %d/%d",
  573. cfg.rates[i]->network.restore_bps,
  574. cfg.rates[i]->network.max_bytes);
  575. if (cfg.class[i] >= 2)
  576.     storeAppendPrintf(entry, " %d/%d",
  577. cfg.rates[i]->individual.restore_bps,
  578. cfg.rates[i]->individual.max_bytes);
  579. if (cfg.class[i] >= 1)
  580.     storeAppendPrintf(entry, "n");
  581.     }
  582. }
  584. static void
  585. parse_delay_pool_count(delayConfig * cfg)
  586. {
  587.     if (cfg->pools) {
  588. debug(3, 0) ("parse_delay_pool_count: multiple delay_pools lines, aborting all previous delay_pools confign");
  589. free_delay_pool_count(cfg);
  590.     }
  591.     parse_ushort(&cfg->pools);
  592.     delayInitDelayData(cfg->pools);
  593.     cfg->class = xcalloc(cfg->pools, sizeof(u_char));
  594.     cfg->rates = xcalloc(cfg->pools, sizeof(delaySpecSet *));
  595.     cfg->access = xcalloc(cfg->pools, sizeof(acl_access *));
  596. }
  598. static void
  599. parse_delay_pool_class(delayConfig * cfg)
  600. {
  601.     ushort pool, class;
  603.     parse_ushort(&pool);
  604.     if (pool < 1 || pool > cfg->pools) {
  605. debug(3, 0) ("parse_delay_pool_class: Ignoring pool %d not in 1 .. %dn", pool, cfg->pools);
  606. return;
  607.     }
  608.     parse_ushort(&class);
  609.     if (class < 1 || class > 3) {
  610. debug(3, 0) ("parse_delay_pool_class: Ignoring pool %d class %d not in 1 .. 3n", pool, class);
  611. return;
  612.     }
  613.     pool--;
  614.     if (cfg->class[pool]) {
  615. delayFreeDelayPool(pool);
  616. safe_free(cfg->rates[pool]);
  617.     }
  618.     cfg->rates[pool] = xmalloc(class * sizeof(delaySpec));
  619.     cfg->class[pool] = class;
  620.     cfg->rates[pool]->aggregate.restore_bps = cfg->rates[pool]->aggregate.max_bytes = -1;
  621.     if (cfg->class[pool] >= 3)
  622. cfg->rates[pool]->network.restore_bps = cfg->rates[pool]->network.max_bytes = -1;
  623.     if (cfg->class[pool] >= 2)
  624. cfg->rates[pool]->individual.restore_bps = cfg->rates[pool]->individual.max_bytes = -1;
  625.     delayCreateDelayPool(pool, class);
  626. }
  628. static void
  629. parse_delay_pool_rates(delayConfig * cfg)
  630. {
  631.     ushort pool, class;
  632.     int i;
  633.     delaySpec *ptr;
  634.     char *token;
  636.     parse_ushort(&pool);
  637.     if (pool < 1 || pool > cfg->pools) {
  638. debug(3, 0) ("parse_delay_pool_rates: Ignoring pool %d not in 1 .. %dn", pool, cfg->pools);
  639. return;
  640.     }
  641.     pool--;
  642.     class = cfg->class[pool];
  643.     if (class == 0) {
  644. debug(3, 0) ("parse_delay_pool_rates: Ignoring pool %d attempt to set rates with class not setn", pool + 1);
  645. return;
  646.     }
  647.     ptr = (delaySpec *) cfg->rates[pool];
  648.     /* read in "class" sets of restore,max pairs */
  649.     while (class--) {
  650. token = strtok(NULL, "/");
  651. if (token == NULL)
  652.     self_destruct();
  653. if (sscanf(token, "%d", &i) != 1)
  654.     self_destruct();
  655. ptr->restore_bps = i;
  656. GetInteger(i);
  657. ptr->max_bytes = i;
  658. ptr++;
  659.     }
  660.     class = cfg->class[pool];
  661.     /* if class is 3, swap around network and individual */
  662.     if (class == 3) {
  663. delaySpec tmp;
  665. tmp = cfg->rates[pool]->individual;
  666. cfg->rates[pool]->individual = cfg->rates[pool]->network;
  667. cfg->rates[pool]->network = tmp;
  668.     }
  669.     /* initialize the delay pools */
  670.     delayInitDelayPool(pool, class, cfg->rates[pool]);
  671. }
  673. static void
  674. parse_delay_pool_access(delayConfig * cfg)
  675. {
  676.     ushort pool;
  678.     parse_ushort(&pool);
  679.     if (pool < 1 || pool > cfg->pools) {
  680. debug(3, 0) ("parse_delay_pool_rates: Ignoring pool %d not in 1 .. %dn", pool, cfg->pools);
  681. return;
  682.     }
  683.     aclParseAccessLine(&cfg->access[pool - 1]);
  684. }
  685. #endif
  687. static void
  688. dump_http_header(StoreEntry * entry, const char *name, HttpHeaderMask header)
  689. {
  690.     storeAppendPrintf(entry, "%sn", name);
  691. }
  693. static void
  694. parse_http_header(HttpHeaderMask * header)
  695. {
  696.     int allowed, id;
  697.     char *t = NULL;
  699.     if ((t = strtok(NULL, w_space)) == NULL) {
  700. debug(3, 0) ("%s line %d: %sn",
  701.     cfg_filename, config_lineno, config_input_line);
  702. debug(3, 0) ("parse_http_header: missing 'allow' or 'deny'.n");
  703. return;
  704.     }
  705.     if (!strcmp(t, "allow"))
  706. allowed = 1;
  707.     else if (!strcmp(t, "deny"))
  708. allowed = 0;
  709.     else {
  710. debug(3, 0) ("%s line %d: %sn",
  711.     cfg_filename, config_lineno, config_input_line);
  712. debug(3, 0) ("parse_http_header: expecting 'allow' or 'deny', got '%s'.n", t);
  713. return;
  714.     }
  716.     if (!http_header_first) {
  717. http_header_first = 1;
  718. if (allowed)
  719.     httpHeaderMaskInit(header, 0xFF);
  720.     }
  721.     while ((t = strtok(NULL, w_space))) {
  722. if ((id = httpHeaderIdByNameDef(t, strlen(t))) == -1)
  723.     id = HDR_OTHER;
  724. if (allowed)
  725.     CBIT_CLR(*header, id);
  726. else
  727.     CBIT_SET(*header, id);
  728.     }
  729. }
  731. static void
  732. free_http_header(HttpHeaderMask * header)
  733. {
  734.     httpHeaderMaskInit(header, 0);
  735. }
  737. static void
  738. dump_cachedir(StoreEntry * entry, const char *name, cacheSwap swap)
  739. {
  740.     SwapDir *s;
  741.     int i;
  742.     for (i = 0; i < swap.n_configured; i++) {
  743. s = swap.swapDirs + i;
  744. storeAppendPrintf(entry, "%s %s %d %d %dn",
  745.     name,
  746.     s->path,
  747.     s->max_size >> 10,
  748.     s->l1,
  749.     s->l2);
  750.     }
  751. }
  753. static int
  754. check_null_cachedir(cacheSwap swap)
  755. {
  756.     return swap.swapDirs == NULL;
  757. }
  759. static int
  760. check_null_string(char *s)
  761. {
  762.     return s == NULL;
  763. }
  765. static void
  766. parse_cachedir(cacheSwap * swap)
  767. {
  768.     char *token;
  769.     char *path;
  770.     int i;
  771.     int size;
  772.     int l1;
  773.     int l2;
  774.     unsigned int read_only = 0;
  775.     SwapDir *tmp = NULL;
  776.     if ((path = strtok(NULL, w_space)) == NULL)
  777. self_destruct();
  778.     GetInteger(i);
  779.     size = i << 10; /* Mbytes to kbytes */
  780.     if (size <= 0)
  781. fatal("parse_cachedir: invalid size value");
  782.     GetInteger(i);
  783.     l1 = i;
  784.     if (l1 <= 0)
  785. fatal("parse_cachedir: invalid level 1 directories value");
  786.     GetInteger(i);
  787.     l2 = i;
  788.     if (l2 <= 0)
  789. fatal("parse_cachedir: invalid level 2 directories value");
  790.     if ((token = strtok(NULL, w_space)))
  791. if (!strcasecmp(token, "read-only"))
  792.     read_only = 1;
  793.     for (i = 0; i < swap->n_configured; i++) {
  794. tmp = swap->swapDirs + i;
  795. if (!strcmp(path, tmp->path)) {
  796.     /* just reconfigure it */
  797.     if (size == tmp->max_size)
  798. debug(3, 1) ("Cache dir '%s' size remains unchanged at %d KBn",
  799.     path, size);
  800.     else
  801. debug(3, 1) ("Cache dir '%s' size changed to %d KBn",
  802.     path, size);
  803.     tmp->max_size = size;
  804.     if (tmp->flags.read_only != read_only)
  805. debug(3, 1) ("Cache dir '%s' now %sn",
  806.     path, read_only ? "Read-Only" : "Read-Write");
  807.     tmp->flags.read_only = read_only;
  808.     return;
  809. }
  810.     }
  811.     if (swap->swapDirs == NULL) {
  812. swap->n_allocated = 4;
  813. swap->swapDirs = xcalloc(swap->n_allocated, sizeof(SwapDir));
  814.     }
  815.     if (swap->n_allocated == swap->n_configured) {
  816. swap->n_allocated <<= 1;
  817. tmp = xcalloc(swap->n_allocated, sizeof(SwapDir));
  818. xmemcpy(tmp, swap->swapDirs, swap->n_configured * sizeof(SwapDir));
  819. xfree(swap->swapDirs);
  820. swap->swapDirs = tmp;
  821.     }
  822.     tmp = swap->swapDirs + swap->n_configured;
  823.     tmp->path = xstrdup(path);
  824.     tmp->max_size = size;
  825.     tmp->l1 = l1;
  826.     tmp->l2 = l2;
  827.     tmp->flags.read_only = read_only;
  828.     tmp->swaplog_fd = -1;
  829.     swap->n_configured++;
  830. }
  832. static void
  833. free_cachedir(cacheSwap * swap)
  834. {
  835.     SwapDir *s;
  836.     int i;
  837.     /* DON'T FREE THESE FOR RECONFIGURE */
  838.     if (reconfiguring)
  839. return;
  840.     for (i = 0; i < swap->n_configured; i++) {
  841. s = swap->swapDirs + i;
  842. if (s->swaplog_fd > -1) {
  843.     file_close(s->swaplog_fd);
  844.     s->swaplog_fd = -1;
  845. }
  846. xfree(s->path);
  847. filemapFreeMemory(s->map);
  848.     }
  849.     safe_free(swap->swapDirs);
  850.     swap->swapDirs = NULL;
  851.     swap->n_allocated = 0;
  852.     swap->n_configured = 0;
  853. }
  855. const char *
  856. peer_type_str(const peer_t type)
  857. {
  858.     switch (type) {
  859.     case PEER_PARENT:
  860. return "parent";
  861. break;
  862.     case PEER_SIBLING:
  863. return "sibling";
  864. break;
  865.     case PEER_MULTICAST:
  866. return "multicast";
  867. break;
  868.     default:
  869. return "unknown";
  870. break;
  871.     }
  872. }
  874. static void
  875. dump_peer(StoreEntry * entry, const char *name, peer * p)
  876. {
  877.     domain_ping *d;
  878.     acl_access *a;
  879.     domain_type *t;
  880.     LOCAL_ARRAY(char, xname, 128);
  881.     while (p != NULL) {
  882. storeAppendPrintf(entry, "%s %s %s %d %d",
  883.     name,
  884.     p->host,
  885.     neighborTypeStr(p),
  886.     p->http_port,
  887.     p->icp.port);
  888. dump_peer_options(entry, p);
  889. for (d = p->peer_domain; d; d = d->next) {
  890.     storeAppendPrintf(entry, "cache_peer_domain %s %s%sn",
  891. p->host,
  892. d->do_ping ? null_string : "!",
  893. d->domain);
  894. }
  895. if ((a = p->access)) {
  896.     snprintf(xname, 128, "cache_peer_access %s", p->host);
  897.     dump_acl_access(entry, xname, p->access);
  898. }
  899. for (t = p->typelist; t; t = t->next) {
  900.     storeAppendPrintf(entry, "neighbor_type_domain %s %s %sn",
  901. p->host,
  902. peer_type_str(t->type),
  903. t->domain);
  904. }
  905. p = p->next;
  906.     }
  907. }
  909. static void
  910. parse_peer(peer ** head)
  911. {
  912.     char *token = NULL;
  913.     peer *p;
  914.     int i;
  915.     ushortlist *u;
  916.     const char *me = null_string; /* XXX */
  917.     p = memAllocate(MEM_PEER);
  918.     p->http_port = CACHE_HTTP_PORT;
  919.     p->icp.port = CACHE_ICP_PORT;
  920.     p->weight = 1;
  921.     p->stats.logged_state = PEER_ALIVE;
  922.     if ((token = strtok(NULL, w_space)) == NULL)
  923. self_destruct();
  924.     p->host = xstrdup(token);
  925.     if ((token = strtok(NULL, w_space)) == NULL)
  926. self_destruct();
  927.     p->type = parseNeighborType(token);
  928.     GetInteger(i);
  929.     p->http_port = (u_short) i;
  930.     GetInteger(i);
  931.     p->icp.port = (u_short) i;
  932.     if (strcmp(p->host, me) == 0) {
  933. for (u = Config.Port.http; u; u = u->next) {
  934.     if (p->http_port != u->i)
  935. continue;
  936.     debug(15, 0) ("parse_peer: Peer looks like myself: %s %s/%d/%dn",
  937. p->type, p->host, p->http_port, p->icp.port);
  938.     self_destruct();
  939. }
  940.     }
  941.     while ((token = strtok(NULL, w_space))) {
  942. if (!strcasecmp(token, "proxy-only")) {
  943.     p->options.proxy_only = 1;
  944. } else if (!strcasecmp(token, "no-query")) {
  945.     p->options.no_query = 1;
  946. } else if (!strcasecmp(token, "no-digest")) {
  947.     p->options.no_digest = 1;
  948. } else if (!strcasecmp(token, "multicast-responder")) {
  949.     p->options.mcast_responder = 1;
  950. } else if (!strncasecmp(token, "weight=", 7)) {
  951.     p->weight = atoi(token + 7);
  952. } else if (!strcasecmp(token, "closest-only")) {
  953.     p->options.closest_only = 1;
  954. } else if (!strncasecmp(token, "ttl=", 4)) {
  955.     p->mcast.ttl = atoi(token + 4);
  956.     if (p->mcast.ttl < 0)
  957. p->mcast.ttl = 0;
  958.     if (p->mcast.ttl > 128)
  959. p->mcast.ttl = 128;
  960. } else if (!strcasecmp(token, "default")) {
  961.     p->options.default_parent = 1;
  962. } else if (!strcasecmp(token, "round-robin")) {
  963.     p->options.roundrobin = 1;
  964. #if USE_HTCP
  965. } else if (!strcasecmp(token, "htcp")) {
  966.     p->options.htcp = 1;
  967. #endif
  968. } else if (!strcasecmp(token, "no-netdb-exchange")) {
  969.     p->options.no_netdb_exchange = 1;
  970. #if USE_CARP
  971. } else if (!strncasecmp(token, "carp-load-factor=", 17)) {
  972.     if (p->type != PEER_PARENT)
  973. debug(3, 0) ("parse_peer: Ignoring carp-load-factor for non-parent %s/%dn", p->host, p->http_port);
  974.     else
  975. p->carp.load_factor = atof(token + 17);
  976. #endif
  977. #if DELAY_POOLS
  978. } else if (!strcasecmp(token, "no-delay")) {
  979.     p->options.no_delay = 1;
  980. #endif
  981. } else if (!strncasecmp(token, "login=", 6)) {
  982.     p->login = xstrdup(token + 6);
  983. } else {
  984.     debug(3, 0) ("parse_peer: token='%s'n", token);
  985.     self_destruct();
  986. }
  987.     }
  988.     if (p->weight < 1)
  989. p->weight = 1;
  990.     p->icp.version = ICP_VERSION_CURRENT;
  991.     p->tcp_up = PEER_TCP_MAGIC_COUNT;
  992. #if USE_CARP
  993.     if (p->carp.load_factor) {
  994. /* calculate this peers hash for use in CARP */
  995. p->carp.hash = 0;
  996. for (token = p->host; *token != 0; token++)
  997.     p->carp.hash += (p->carp.hash << 19) + *token;
  998.     }
  999. #endif
  1000.     cbdataAdd(p, peerDestroy, MEM_PEER); /* must preceed peerDigestCreate */
  1001. #if USE_CACHE_DIGESTS
  1002.     if (!p->options.no_digest) {
  1003. p->digest = peerDigestCreate(p);
  1004. cbdataLock(p->digest); /* so we know when/if digest disappears */
  1005.     }
  1006. #endif
  1007.     while (*head != NULL)
  1008. head = &(*head)->next;
  1009.     *head = p;
  1010.     Config.npeers++;
  1011. }
  1013. static void
  1014. free_peer(peer ** P)
  1015. {
  1016.     peer *p;
  1017.     while ((p = *P) != NULL) {
  1018. *P = p->next;
  1019. #if USE_CACHE_DIGESTS
  1020. if (p->digest)
  1021.     cbdataUnlock(p->digest);
  1022. p->digest = NULL;
  1023. #endif
  1024. cbdataFree(p);
  1025.     }
  1026.     Config.npeers = 0;
  1027. }
  1029. static void
  1030. dump_cachemgrpasswd(StoreEntry * entry, const char *name, cachemgr_passwd * list)
  1031. {
  1032.     wordlist *w;
  1033.     while (list != NULL) {
  1034. if (strcmp(list->passwd, "none") && strcmp(list->passwd, "disable"))
  1035.     storeAppendPrintf(entry, "%s XXXXXXXXXX", name);
  1036. else
  1037.     storeAppendPrintf(entry, "%s %s", name, list->passwd);
  1038. for (w = list->actions; w != NULL; w = w->next) {
  1039.     storeAppendPrintf(entry, " %s", w->key);
  1040. }
  1041. storeAppendPrintf(entry, "n");
  1042. list = list->next;
  1043.     }
  1044. }
  1046. static void
  1047. parse_cachemgrpasswd(cachemgr_passwd ** head)
  1048. {
  1049.     char *passwd = NULL;
  1050.     wordlist *actions = NULL;
  1051.     cachemgr_passwd *p;
  1052.     cachemgr_passwd **P;
  1053.     parse_string(&passwd);
  1054.     parse_wordlist(&actions);
  1055.     p = xcalloc(1, sizeof(cachemgr_passwd));
  1056.     p->passwd = passwd;
  1057.     p->actions = actions;
  1058.     for (P = head; *P; P = &(*P)->next);
  1059.     *P = p;
  1060. }
  1062. static void
  1063. free_cachemgrpasswd(cachemgr_passwd ** head)
  1064. {
  1065.     cachemgr_passwd *p;
  1066.     while ((p = *head) != NULL) {
  1067. *head = p->next;
  1068. xfree(p->passwd);
  1069. wordlistDestroy(&p->actions);
  1070. xfree(p);
  1071.     }
  1072. }
  1074. static void
  1075. dump_denyinfo(StoreEntry * entry, const char *name, acl_deny_info_list * var)
  1076. {
  1077.     acl_name_list *a;
  1078.     while (var != NULL) {
  1079. storeAppendPrintf(entry, "%s %s", name, var->err_page_name);
  1080. for (a = var->acl_list; a != NULL; a = a->next)
  1081.     storeAppendPrintf(entry, " %s", a->name);
  1082. storeAppendPrintf(entry, "n");
  1083. var = var->next;
  1084.     }
  1085. }
  1087. static void
  1088. parse_denyinfo(acl_deny_info_list ** var)
  1089. {
  1090.     aclParseDenyInfoLine(var);
  1091. }
  1093. void
  1094. free_denyinfo(acl_deny_info_list ** list)
  1095. {
  1096.     acl_deny_info_list *a = NULL;
  1097.     acl_deny_info_list *a_next = NULL;
  1098.     acl_name_list *l = NULL;
  1099.     acl_name_list *l_next = NULL;
  1100.     for (a = *list; a; a = a_next) {
  1101. for (l = a->acl_list; l; l = l_next) {
  1102.     l_next = l->next;
  1103.     safe_free(l);
  1104. }
  1105. a_next = a->next;
  1106. safe_free(a);
  1107.     }
  1108.     *list = NULL;
  1109. }
  1111. static void
  1112. parse_peer_access(void)
  1113. {
  1114.     char *host = NULL;
  1115.     peer *p;
  1116.     if (!(host = strtok(NULL, w_space)))
  1117. self_destruct();
  1118.     if ((p = peerFindByName(host)) == NULL) {
  1119. debug(15, 0) ("%s, line %d: No cache_peer '%s'n",
  1120.     cfg_filename, config_lineno, host);
  1121. return;
  1122.     }
  1123.     aclParseAccessLine(&p->access);
  1124. }
  1126. static void
  1127. parse_hostdomain(void)
  1128. {
  1129.     char *host = NULL;
  1130.     char *domain = NULL;
  1131.     if (!(host = strtok(NULL, w_space)))
  1132. self_destruct();
  1133.     while ((domain = strtok(NULL, list_sep))) {
  1134. domain_ping *l = NULL;
  1135. domain_ping **L = NULL;
  1136. peer *p;
  1137. if ((p = peerFindByName(host)) == NULL) {
  1138.     debug(15, 0) ("%s, line %d: No cache_peer '%s'n",
  1139. cfg_filename, config_lineno, host);
  1140.     continue;
  1141. }
  1142. l = xcalloc(1, sizeof(domain_ping));
  1143. l->do_ping = 1;
  1144. if (*domain == '!') { /* check for !.edu */
  1145.     l->do_ping = 0;
  1146.     domain++;
  1147. }
  1148. l->domain = xstrdup(domain);
  1149. for (L = &(p->peer_domain); *L; L = &((*L)->next));
  1150. *L = l;
  1151.     }
  1152. }
  1154. static void
  1155. parse_hostdomaintype(void)
  1156. {
  1157.     char *host = NULL;
  1158.     char *type = NULL;
  1159.     char *domain = NULL;
  1160.     if (!(host = strtok(NULL, w_space)))
  1161. self_destruct();
  1162.     if (!(type = strtok(NULL, w_space)))
  1163. self_destruct();
  1164.     while ((domain = strtok(NULL, list_sep))) {
  1165. domain_type *l = NULL;
  1166. domain_type **L = NULL;
  1167. peer *p;
  1168. if ((p = peerFindByName(host)) == NULL) {
  1169.     debug(15, 0) ("%s, line %d: No cache_peer '%s'n",
  1170. cfg_filename, config_lineno, host);
  1171.     return;
  1172. }
  1173. l = xcalloc(1, sizeof(domain_type));
  1174. l->type = parseNeighborType(type);
  1175. l->domain = xstrdup(domain);
  1176. for (L = &(p->typelist); *L; L = &((*L)->next));
  1177. *L = l;
  1178.     }
  1179. }
  1181. static void
  1182. dump_ushortlist(StoreEntry * entry, const char *name, ushortlist * u)
  1183. {
  1184.     while (u) {
  1185. storeAppendPrintf(entry, "%s %dn", name, (int) u->i);
  1186. u = u->next;
  1187.     }
  1188. }
  1190. static int
  1191. check_null_ushortlist(ushortlist * u)
  1192. {
  1193.     return u == NULL;
  1194. }
  1196. static void
  1197. parse_ushortlist(ushortlist ** P)
  1198. {
  1199.     char *token;
  1200.     int i;
  1201.     ushortlist *u;
  1202.     ushortlist **U;
  1203.     while ((token = strtok(NULL, w_space))) {
  1204. if (sscanf(token, "%d", &i) != 1)
  1205.     self_destruct();
  1206. if (i < 0)
  1207.     i = 0;
  1208. u = xcalloc(1, sizeof(ushortlist));
  1209. u->i = (u_short) i;
  1210. for (U = P; *U; U = &(*U)->next);
  1211. *U = u;
  1212.     }
  1213. }
  1215. static void
  1216. free_ushortlist(ushortlist ** P)
  1217. {
  1218.     ushortlist *u;
  1219.     while ((u = *P) != NULL) {
  1220. *P = u->next;
  1221. xfree(u);
  1222.     }
  1223. }
  1225. static void
  1226. dump_int(StoreEntry * entry, const char *name, int var)
  1227. {
  1228.     storeAppendPrintf(entry, "%s %dn", name, var);
  1229. }
  1231. static void
  1232. parse_int(int *var)
  1233. {
  1234.     char *token;
  1235.     int i;
  1236.     GetInteger(i);
  1237.     *var = i;
  1238. }
  1240. static void
  1241. free_int(int *var)
  1242. {
  1243.     *var = 0;
  1244. }
  1246. static void
  1247. dump_onoff(StoreEntry * entry, const char *name, int var)
  1248. {
  1249.     storeAppendPrintf(entry, "%s %sn", name, var ? "on" : "off");
  1250. }
  1252. static void
  1253. parse_onoff(int *var)
  1254. {
  1255.     char *token = strtok(NULL, w_space);
  1257.     if (token == NULL)
  1258. self_destruct();
  1259.     if (!strcasecmp(token, "on") || !strcasecmp(token, "enable"))
  1260. *var = 1;
  1261.     else
  1262. *var = 0;
  1263. }
  1265. #define free_onoff free_int
  1266. #define free_httpanonymizer free_int
  1267. #define dump_eol dump_string
  1268. #define free_eol free_string
  1270. static void
  1271. dump_refreshpattern(StoreEntry * entry, const char *name, refresh_t * head)
  1272. {
  1273.     while (head != NULL) {
  1274. storeAppendPrintf(entry, "%s%s %s %d %d%% %dn",
  1275.     name,
  1276.     head->flags.icase ? " -i" : null_string,
  1277.     head->pattern,
  1278.     (int) head->min / 60,
  1279.     (int) (100.0 * head->pct + 0.5),
  1280.     (int) head->max / 60);
  1281. #if HTTP_VIOLATIONS
  1282. if (head->flags.override_expire)
  1283.     storeAppendPrintf(entry, " override-expire");
  1284. if (head->flags.override_lastmod)
  1285.     storeAppendPrintf(entry, " override-lastmod");
  1286. if (head->flags.reload_into_ims)
  1287.     storeAppendPrintf(entry, " reload-into-ims");
  1288. if (head->flags.ignore_reload)
  1289.     storeAppendPrintf(entry, " ignore-reload");
  1290. #endif
  1291. storeAppendPrintf(entry, "n");
  1292. head = head->next;
  1293.     }
  1294. }
  1296. static void
  1297. parse_refreshpattern(refresh_t ** head)
  1298. {
  1299.     char *token;
  1300.     char *pattern;
  1301.     time_t min = 0;
  1302.     double pct = 0.0;
  1303.     time_t max = 0;
  1304. #if HTTP_VIOLATIONS
  1305.     int override_expire = 0;
  1306.     int override_lastmod = 0;
  1307.     int reload_into_ims = 0;
  1308.     int ignore_reload = 0;
  1309. #endif
  1310.     int i;
  1311.     refresh_t *t;
  1312.     regex_t comp;
  1313.     int errcode;
  1314.     int flags = REG_EXTENDED | REG_NOSUB;
  1315.     if ((token = strtok(NULL, w_space)) == NULL)
  1316. self_destruct();
  1317.     if (strcmp(token, "-i") == 0) {
  1318. flags |= REG_ICASE;
  1319. token = strtok(NULL, w_space);
  1320.     } else if (strcmp(token, "+i") == 0) {
  1321. flags &= ~REG_ICASE;
  1322. token = strtok(NULL, w_space);
  1323.     }
  1324.     if (token == NULL)
  1325. self_destruct();
  1326.     pattern = xstrdup(token);
  1327.     GetInteger(i); /* token: min */
  1328.     min = (time_t) (i * 60); /* convert minutes to seconds */
  1329.     GetInteger(i); /* token: pct */
  1330.     pct = (double) i / 100.0;
  1331.     GetInteger(i); /* token: max */
  1332.     max = (time_t) (i * 60); /* convert minutes to seconds */
  1333.     /* Options */
  1334.     while ((token = strtok(NULL, w_space)) != NULL) {
  1335. #if HTTP_VIOLATIONS
  1336. if (!strcmp(token, "override-expire"))
  1337.     override_expire = 1;
  1338. else if (!strcmp(token, "override-lastmod"))
  1339.     override_lastmod = 1;
  1340. else if (!strcmp(token, "reload-into-ims")) {
  1341.     reload_into_ims = 1;
  1342.     refresh_nocache_hack = 1;
  1343.     /* tell client_side.c that this is used */
  1344. } else if (!strcmp(token, "ignore-reload")) {
  1345.     ignore_reload = 1;
  1346.     refresh_nocache_hack = 1;
  1347.     /* tell client_side.c that this is used */
  1348. } else
  1349. #endif
  1350.     debug(22, 0) ("redreshAddToList: Unknown option '%s': %sn",
  1351. pattern, token);
  1352.     }
  1353.     if ((errcode = regcomp(&comp, pattern, flags)) != 0) {
  1354. char errbuf[256];
  1355. regerror(errcode, &comp, errbuf, sizeof errbuf);
  1356. debug(22, 0) ("%s line %d: %sn",
  1357.     cfg_filename, config_lineno, config_input_line);
  1358. debug(22, 0) ("refreshAddToList: Invalid regular expression '%s': %sn",
  1359.     pattern, errbuf);
  1360. return;
  1361.     }
  1362.     pct = pct < 0.0 ? 0.0 : pct;
  1363.     max = max < 0 ? 0 : max;
  1364.     t = xcalloc(1, sizeof(refresh_t));
  1365.     t->pattern = (char *) xstrdup(pattern);
  1366.     t->compiled_pattern = comp;
  1367.     t->min = min;
  1368.     t->pct = pct;
  1369.     t->max = max;
  1370.     if (flags & REG_ICASE)
  1371. t->flags.icase = 1;
  1372. #if HTTP_VIOLATIONS
  1373.     if (override_expire)
  1374. t->flags.override_expire = 1;
  1375.     if (override_lastmod)
  1376. t->flags.override_lastmod = 1;
  1377.     if (reload_into_ims)
  1378. t->flags.reload_into_ims = 1;
  1379.     if (ignore_reload)
  1380. t->flags.ignore_reload = 1;
  1381. #endif
  1382.     t->next = NULL;
  1383.     while (*head)
  1384. head = &(*head)->next;
  1385.     *head = t;
  1386.     safe_free(pattern);
  1387. }
  1389. static void
  1390. free_refreshpattern(refresh_t ** head)
  1391. {
  1392.     refresh_t *t;
  1393.     while ((t = *head) != NULL) {
  1394. *head = t->next;
  1395. safe_free(t->pattern);
  1396. regfree(&t->compiled_pattern);
  1397. safe_free(t);
  1398.     }
  1399. }
  1401. static void
  1402. dump_string(StoreEntry * entry, const char *name, char *var)
  1403. {
  1404.     if (var != NULL)
  1405. storeAppendPrintf(entry, "%s %sn", name, var);
  1406. }
  1408. static void
  1409. parse_string(char **var)
  1410. {
  1411.     char *token = strtok(NULL, w_space);
  1412.     safe_free(*var);
  1413.     if (token == NULL)
  1414. self_destruct();
  1415.     *var = xstrdup(token);
  1416. }
  1418. static void
  1419. free_string(char **var)
  1420. {
  1421.     safe_free(*var);
  1422. }
  1424. static void
  1425. parse_eol(char *volatile *var)
  1426. {
  1427.     char *token = strtok(NULL, null_string);
  1428.     safe_free(*var);
  1429.     if (token == NULL)
  1430. self_destruct();
  1431.     *var = xstrdup(token);
  1432. }
  1434. static void
  1435. dump_time_t(StoreEntry * entry, const char *name, time_t var)
  1436. {
  1437.     storeAppendPrintf(entry, "%s %d secondsn", name, (int) var);
  1438. }
  1440. static void
  1441. parse_time_t(time_t * var)
  1442. {
  1443.     parseTimeLine(var, T_SECOND_STR);
  1444. }
  1446. static void
  1447. free_time_t(time_t * var)
  1448. {
  1449.     *var = 0;
  1450. }
  1452. static void
  1453. dump_size_t(StoreEntry * entry, const char *name, size_t var)
  1454. {
  1455.     storeAppendPrintf(entry, "%s %dn", name, (int) var);
  1456. }
  1458. static void
  1459. dump_b_size_t(StoreEntry * entry, const char *name, size_t var)
  1460. {
  1461.     storeAppendPrintf(entry, "%s %d %sn", name, (int) var, B_BYTES_STR);
  1462. }
  1464. static void
  1465. dump_kb_size_t(StoreEntry * entry, const char *name, size_t var)
  1466. {
  1467.     storeAppendPrintf(entry, "%s %d %sn", name, (int) var, B_KBYTES_STR);
  1468. }
  1470. static void
  1471. parse_size_t(size_t * var)
  1472. {
  1473.     char *token;
  1474.     int i;
  1475.     GetInteger(i);
  1476.     *var = (size_t) i;
  1477. }
  1479. static void
  1480. parse_b_size_t(size_t * var)
  1481. {
  1482.     parseBytesLine(var, B_BYTES_STR);
  1483. }
  1485. static void
  1486. parse_kb_size_t(size_t * var)
  1487. {
  1488.     parseBytesLine(var, B_KBYTES_STR);
  1489. }
  1491. static void
  1492. free_size_t(size_t * var)
  1493. {
  1494.     *var = 0;
  1495. }
  1497. #define free_b_size_t free_size_t
  1498. #define free_kb_size_t free_size_t
  1499. #define free_mb_size_t free_size_t
  1500. #define free_gb_size_t free_size_t
  1502. static void
  1503. dump_ushort(StoreEntry * entry, const char *name, u_short var)
  1504. {
  1505.     storeAppendPrintf(entry, "%s %dn", name, var);
  1506. }
  1508. static void
  1509. free_ushort(u_short * u)
  1510. {
  1511.     *u = 0;
  1512. }
  1514. static void
  1515. parse_ushort(u_short * var)
  1516. {
  1517.     char *token;
  1518.     int i;
  1520.     GetInteger(i);
  1521.     if (i < 0)
  1522. i = 0;
  1523.     *var = (u_short) i;
  1524. }
  1526. static void
  1527. dump_wordlist(StoreEntry * entry, const char *name, wordlist * list)
  1528. {
  1529.     while (list != NULL) {
  1530. storeAppendPrintf(entry, "%s %sn", name, list->key);
  1531. list = list->next;
  1532.     }
  1533. }
  1535. static void
  1536. parse_wordlist(wordlist ** list)
  1537. {
  1538.     char *token;
  1539.     while ((token = strtok(NULL, w_space)))
  1540. wordlistAdd(list, token);
  1541. }
  1543. static int
  1544. check_null_wordlist(wordlist * w)
  1545. {
  1546.     return w == NULL;
  1547. }
  1549. static int
  1550. check_null_acl_access(acl_access * a)
  1551. {
  1552.     return a == NULL;
  1553. }
  1555. #define free_wordlist wordlistDestroy
  1557. #define free_uri_whitespace free_int
  1559. static void
  1560. parse_uri_whitespace(int *var)
  1561. {
  1562.     char *token = strtok(NULL, w_space);
  1563.     if (token == NULL)
  1564. self_destruct();
  1565.     if (!strcasecmp(token, "deny"))
  1566. *var = URI_WHITESPACE_DENY;
  1567.     else if (!strcasecmp(token, "allow"))
  1568. *var = URI_WHITESPACE_ALLOW;
  1569.     else if (!strcasecmp(token, "encode"))
  1570. *var = URI_WHITESPACE_ENCODE;
  1571.     else if (!strcasecmp(token, "chop"))
  1572. *var = URI_WHITESPACE_CHOP;
  1573.     else
  1574. self_destruct();
  1575. }
  1578. static void
  1579. dump_uri_whitespace(StoreEntry * entry, const char *name, int var)
  1580. {
  1581.     char *s;
  1582.     if (var == URI_WHITESPACE_ALLOW)
  1583. s = "allow";
  1584.     else if (var == URI_WHITESPACE_ENCODE)
  1585. s = "encode";
  1586.     else if (var == URI_WHITESPACE_CHOP)
  1587. s = "chop";
  1588.     else
  1589. s = "deny";
  1590.     storeAppendPrintf(entry, "%s %sn", name, s);
  1591. }
  1593. #include "cf_parser.c"
  1595. peer_t
  1596. parseNeighborType(const char *s)
  1597. {
  1598.     if (!strcasecmp(s, "parent"))
  1599. return PEER_PARENT;
  1600.     if (!strcasecmp(s, "neighbor"))
  1601. return PEER_SIBLING;
  1602.     if (!strcasecmp(s, "neighbour"))
  1603. return PEER_SIBLING;
  1604.     if (!strcasecmp(s, "sibling"))
  1605. return PEER_SIBLING;
  1606.     if (!strcasecmp(s, "multicast"))
  1607. return PEER_MULTICAST;
  1608.     debug(15, 0) ("WARNING: Unknown neighbor type: %sn", s);
  1609.     return PEER_SIBLING;
  1610. }
  1612. void
  1613. configFreeMemory(void)
  1614. {
  1615.     free_all();
  1616. }
  1618. static void
  1619. requirePathnameExists(const char *name, const char *path)
  1620. {
  1621.     struct stat sb;
  1622.     assert(path != NULL);
  1623.     if (stat(path, &sb) < 0)
  1624. fatalf("%s: %s", path, xstrerror());
  1625. }