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

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

代理服务器

开发平台：

Unix_Linux

acl.c：源码内容
  2. /*
  3.  * $Id: acl.c,v 1.197.2.2 1999/02/12 19:38:21 wessels Exp $
  4.  *
  5.  * DEBUG: section 28    Access Control
  6.  * AUTHOR: Duane Wessels
  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"
  37. #include "splay.h"
  39. static int aclFromFile = 0;
  40. static FILE *aclFile;
  41. static hash_table *proxy_auth_cache = NULL;
  43. static void aclParseDomainList(void *curlist);
  44. static void aclParseIpList(void *curlist);
  45. static void aclParseIntlist(void *curlist);
  46. static void aclParseWordList(void *curlist);
  47. static void aclParseProtoList(void *curlist);
  48. static void aclParseMethodList(void *curlist);
  49. static void aclParseTimeSpec(void *curlist);
  50. static void aclParseIntRange(void *curlist);
  51. static char *strtokFile(void);
  52. static void aclDestroyAclList(acl_list * list);
  53. static void aclDestroyTimeList(acl_time_data * data);
  54. static void aclDestroyIntRange(intrange *);
  55. static FREE aclFreeProxyAuthUser;
  56. static struct _acl *aclFindByName(const char *name);
  57. static int aclMatchAcl(struct _acl *, aclCheck_t *);
  58. static int aclMatchIntegerRange(intrange * data, int i);
  59. static int aclMatchTime(acl_time_data * data, time_t when);
  60. static int aclMatchUser(wordlist * data, const char *ident);
  61. static int aclMatchIp(void *dataptr, struct in_addr c);
  62. static int aclMatchDomainList(void *dataptr, const char *);
  63. static int aclMatchIntegerRange(intrange * data, int i);
  64. #if SQUID_SNMP
  65. static int aclMatchWordList(wordlist *, const char *);
  66. #endif
  67. static squid_acl aclStrToType(const char *s);
  68. static int decode_addr(const char *, struct in_addr *, struct in_addr *);
  69. static void aclCheck(aclCheck_t * checklist);
  70. static void aclCheckCallback(aclCheck_t * checklist, allow_t answer);
  71. #if USE_IDENT
  72. static IDCB aclLookupIdentDone;
  73. #endif
  74. static IPH aclLookupDstIPDone;
  75. static IPH aclLookupDstIPforASNDone;
  76. static FQDNH aclLookupSrcFQDNDone;
  77. static FQDNH aclLookupDstFQDNDone;
  78. static void aclLookupProxyAuthStart(aclCheck_t * checklist);
  79. static void aclLookupProxyAuthDone(void *data, char *result);
  80. static wordlist *aclDumpIpList(void *);
  81. static wordlist *aclDumpDomainList(void *data);
  82. static wordlist *aclDumpTimeSpecList(acl_time_data *);
  83. static wordlist *aclDumpRegexList(relist * data);
  84. static wordlist *aclDumpIntlistList(intlist * data);
  85. static wordlist *aclDumpIntRangeList(intrange * data);
  86. static wordlist *aclDumpProtoList(intlist * data);
  87. static wordlist *aclDumpMethodList(intlist * data);
  88. static SPLAYCMP aclIpNetworkCompare;
  89. static SPLAYCMP aclHostDomainCompare;
  90. static SPLAYCMP aclDomainCompare;
  91. static SPLAYWALKEE aclDumpIpListWalkee;
  92. static SPLAYWALKEE aclDumpDomainListWalkee;
  93. static SPLAYFREE aclFreeIpData;
  95. #if USE_ARP_ACL
  96. static void aclParseArpList(void *curlist);
  97. static int decode_eth(const char *asc, char *eth);
  98. static int aclMatchArp(void *dataptr, struct in_addr c);
  99. static wordlist *aclDumpArpList(void *);
  100. static SPLAYCMP aclArpCompare;
  101. static SPLAYWALKEE aclDumpArpListWalkee;
  102. #endif
  104. static char *
  105. strtokFile(void)
  106. {
  107.     char *t, *fn;
  108.     LOCAL_ARRAY(char, buf, 256);
  110.   strtok_again:
  111.     if (!aclFromFile) {
  112. t = (strtok(NULL, w_space));
  113. if (t && (*t == '"' || *t == ''')) {
  114.     /* quote found, start reading from file */
  115.     fn = ++t;
  116.     while (*t && *t != '"' && *t != ''')
  117. t++;
  118.     *t = '';
  119.     if ((aclFile = fopen(fn, "r")) == NULL) {
  120. debug(28, 0) ("strtokFile: %s not foundn", fn);
  121. return (NULL);
  122.     }
  123.     aclFromFile = 1;
  124. } else {
  125.     return t;
  126. }
  127.     }
  128.     /* aclFromFile */
  129.     if (fgets(buf, 256, aclFile) == NULL) {
  130. /* stop reading from file */
  131. fclose(aclFile);
  132. aclFromFile = 0;
  133. goto strtok_again;
  134.     } else {
  135. t = buf;
  136. /* skip leading and trailing white space */
  137. t += strspn(buf, w_space);
  138. t[strcspn(t, w_space)] = '';
  139. /* skip comments */
  140. if (*t == '#')
  141.     goto strtok_again;
  142. /* skip blank lines */
  143. if (!*t)
  144.     goto strtok_again;
  145. return t;
  146.     }
  147. }
  149. static squid_acl
  150. aclStrToType(const char *s)
  151. {
  152.     if (!strcmp(s, "src"))
  153. return ACL_SRC_IP;
  154.     if (!strcmp(s, "dst"))
  155. return ACL_DST_IP;
  156.     if (!strcmp(s, "myip"))
  157. return ACL_MY_IP;
  158.     if (!strcmp(s, "domain"))
  159. return ACL_DST_DOMAIN;
  160.     if (!strcmp(s, "dstdomain"))
  161. return ACL_DST_DOMAIN;
  162.     if (!strcmp(s, "srcdomain"))
  163. return ACL_SRC_DOMAIN;
  164.     if (!strcmp(s, "dstdom_regex"))
  165. return ACL_DST_DOM_REGEX;
  166.     if (!strcmp(s, "srcdom_regex"))
  167. return ACL_SRC_DOM_REGEX;
  168.     if (!strcmp(s, "time"))
  169. return ACL_TIME;
  170.     if (!strcmp(s, "pattern"))
  171. return ACL_URLPATH_REGEX;
  172.     if (!strcmp(s, "urlpath_regex"))
  173. return ACL_URLPATH_REGEX;
  174.     if (!strcmp(s, "url_regex"))
  175. return ACL_URL_REGEX;
  176.     if (!strcmp(s, "port"))
  177. return ACL_URL_PORT;
  178. #if USE_IDENT
  179.     if (!strcmp(s, "ident"))
  180. return ACL_IDENT;
  181. #endif
  182.     if (!strncmp(s, "proto", 5))
  183. return ACL_PROTO;
  184.     if (!strcmp(s, "method"))
  185. return ACL_METHOD;
  186.     if (!strcmp(s, "browser"))
  187. return ACL_BROWSER;
  188.     if (!strcmp(s, "proxy_auth"))
  189. return ACL_PROXY_AUTH;
  190.     if (!strcmp(s, "src_as"))
  191. return ACL_SRC_ASN;
  192.     if (!strcmp(s, "dst_as"))
  193. return ACL_DST_ASN;
  194. #if SQUID_SNMP
  195.     if (!strcmp(s, "snmp_community"))
  196. return ACL_SNMP_COMMUNITY;
  197. #endif
  198.     if (!strcmp(s, "src_rtt"))
  199. return ACL_NETDB_SRC_RTT;
  200. #if USE_ARP_ACL
  201.     if (!strcmp(s, "arp"))
  202. return ACL_SRC_ARP;
  203. #endif
  204.     return ACL_NONE;
  205. }
  207. const char *
  208. aclTypeToStr(squid_acl type)
  209. {
  210.     if (type == ACL_SRC_IP)
  211. return "src";
  212.     if (type == ACL_DST_IP)
  213. return "dst";
  214.     if (type == ACL_MY_IP)
  215. return "myip";
  216.     if (type == ACL_DST_DOMAIN)
  217. return "dstdomain";
  218.     if (type == ACL_SRC_DOMAIN)
  219. return "srcdomain";
  220.     if (type == ACL_DST_DOM_REGEX)
  221. return "dstdom_regex";
  222.     if (type == ACL_SRC_DOM_REGEX)
  223. return "srcdom_regex";
  224.     if (type == ACL_TIME)
  225. return "time";
  226.     if (type == ACL_URLPATH_REGEX)
  227. return "urlpath_regex";
  228.     if (type == ACL_URL_REGEX)
  229. return "url_regex";
  230.     if (type == ACL_URL_PORT)
  231. return "port";
  232. #if USE_IDENT
  233.     if (type == ACL_IDENT)
  234. return "ident";
  235. #endif
  236.     if (type == ACL_PROTO)
  237. return "proto";
  238.     if (type == ACL_METHOD)
  239. return "method";
  240.     if (type == ACL_BROWSER)
  241. return "browser";
  242.     if (type == ACL_PROXY_AUTH)
  243. return "proxy_auth";
  244.     if (type == ACL_SRC_ASN)
  245. return "src_as";
  246.     if (type == ACL_DST_ASN)
  247. return "dst_as";
  248. #if SQUID_SNMP
  249.     if (type == ACL_SNMP_COMMUNITY)
  250. return "snmp_community";
  251. #endif
  252.     if (type == ACL_NETDB_SRC_RTT)
  253. return "src_rtt";
  254. #if USE_ARP_ACL
  255.     if (type == ACL_SRC_ARP)
  256. return "arp";
  257. #endif
  258.     return "ERROR";
  259. }
  261. static acl *
  262. aclFindByName(const char *name)
  263. {
  264.     acl *a;
  265.     for (a = Config.aclList; a; a = a->next)
  266. if (!strcasecmp(a->name, name))
  267.     return a;
  268.     return NULL;
  269. }
  271. static void
  272. aclParseIntlist(void *curlist)
  273. {
  274.     intlist **Tail;
  275.     intlist *q = NULL;
  276.     char *t = NULL;
  277.     for (Tail = curlist; *Tail; Tail = &((*Tail)->next));
  278.     while ((t = strtokFile())) {
  279. q = memAllocate(MEM_INTLIST);
  280. q->i = atoi(t);
  281. *(Tail) = q;
  282. Tail = &q->next;
  283.     }
  284. }
  286. static void
  287. aclParseIntRange(void *curlist)
  288. {
  289.     intrange **Tail;
  290.     intrange *q = NULL;
  291.     char *t = NULL;
  292.     for (Tail = curlist; *Tail; Tail = &((*Tail)->next));
  293.     while ((t = strtokFile())) {
  294. q = xcalloc(1, sizeof(intrange));
  295. q->i = atoi(t);
  296. t = strchr(t, '-');
  297. if (t && *(++t))
  298.     q->j = atoi(t);
  299. else
  300.     q->j = q->i;
  301. *(Tail) = q;
  302. Tail = &q->next;
  303.     }
  304. }
  306. static void
  307. aclParseProtoList(void *curlist)
  308. {
  309.     intlist **Tail;
  310.     intlist *q = NULL;
  311.     char *t = NULL;
  312.     for (Tail = curlist; *Tail; Tail = &((*Tail)->next));
  313.     while ((t = strtokFile())) {
  314. q = memAllocate(MEM_INTLIST);
  315. q->i = (int) urlParseProtocol(t);
  316. *(Tail) = q;
  317. Tail = &q->next;
  318.     }
  319. }
  321. static void
  322. aclParseMethodList(void *curlist)
  323. {
  324.     intlist **Tail;
  325.     intlist *q = NULL;
  326.     char *t = NULL;
  327.     for (Tail = curlist; *Tail; Tail = &((*Tail)->next));
  328.     while ((t = strtokFile())) {
  329. q = memAllocate(MEM_INTLIST);
  330. q->i = (int) urlParseMethod(t);
  331. if (q->i == METHOD_PURGE)
  332.     Config.onoff.enable_purge = 1;
  333. *(Tail) = q;
  334. Tail = &q->next;
  335.     }
  336. }
  338. /*
  339.  * Decode a ascii representation (asc) of a IP adress, and place
  340.  * adress and netmask information in addr and mask.
  341.  * This function should NOT be called if 'asc' is a hostname!
  342.  */
  343. static int
  344. decode_addr(const char *asc, struct in_addr *addr, struct in_addr *mask)
  345. {
  346.     u_num32 a;
  347.     int a1 = 0, a2 = 0, a3 = 0, a4 = 0;
  349.     switch (sscanf(asc, "%d.%d.%d.%d", &a1, &a2, &a3, &a4)) {
  350.     case 4: /* a dotted quad */
  351. if (!safe_inet_addr(asc, addr)) {
  352.     debug(28, 0) ("decode_addr: unsafe IP address: '%s'n", asc);
  353.     fatal("decode_addr: unsafe IP address");
  354. }
  355. break;
  356.     case 1: /* a significant bits value for a mask */
  357. if (a1 >= 0 && a1 < 33) {
  358.     addr->s_addr = a1 ? htonl(0xfffffffful << (32 - a1)) : 0;
  359.     break;
  360. }
  361.     default:
  362. debug(28, 0) ("decode_addr: Invalid IP address '%s'n", asc);
  363. return 0; /* This is not valid address */
  364.     }
  366.     if (mask != NULL) { /* mask == NULL if called to decode a netmask */
  368. /* Guess netmask */
  369. a = (u_num32) ntohl(addr->s_addr);
  370. if (!(a & 0xFFFFFFFFul))
  371.     mask->s_addr = htonl(0x00000000ul);
  372. else if (!(a & 0x00FFFFFF))
  373.     mask->s_addr = htonl(0xFF000000ul);
  374. else if (!(a & 0x0000FFFF))
  375.     mask->s_addr = htonl(0xFFFF0000ul);
  376. else if (!(a & 0x000000FF))
  377.     mask->s_addr = htonl(0xFFFFFF00ul);
  378. else
  379.     mask->s_addr = htonl(0xFFFFFFFFul);
  380.     }
  381.     return 1;
  382. }
  385. #define SCAN_ACL1       "%[0123456789.]-%[0123456789.]/%[0123456789.]"
  386. #define SCAN_ACL2       "%[0123456789.]-%[0123456789.]"
  387. #define SCAN_ACL3       "%[0123456789.]/%[0123456789.]"
  388. #define SCAN_ACL4       "%[0123456789.]"
  390. static acl_ip_data *
  391. aclParseIpData(const char *t)
  392. {
  393.     LOCAL_ARRAY(char, addr1, 256);
  394.     LOCAL_ARRAY(char, addr2, 256);
  395.     LOCAL_ARRAY(char, mask, 256);
  396.     acl_ip_data *q = memAllocate(MEM_ACL_IP_DATA);
  397.     acl_ip_data *r;
  398.     acl_ip_data **Q;
  399.     struct hostent *hp;
  400.     char **x;
  401.     debug(28, 5) ("aclParseIpData: %sn", t);
  402.     if (!strcasecmp(t, "all")) {
  403. q->addr1.s_addr = 0;
  404. q->addr2.s_addr = 0;
  405. q->mask.s_addr = 0;
  406. return q;
  407.     }
  408.     if (sscanf(t, SCAN_ACL1, addr1, addr2, mask) == 3) {
  409. (void) 0;
  410.     } else if (sscanf(t, SCAN_ACL2, addr1, addr2) == 2) {
  411. mask[0] = '';
  412.     } else if (sscanf(t, SCAN_ACL3, addr1, mask) == 2) {
  413. addr2[0] = '';
  414.     } else if (sscanf(t, SCAN_ACL4, addr1) == 1) {
  415. addr2[0] = '';
  416. mask[0] = '';
  417.     } else if (sscanf(t, "%[^/]/%s", addr1, mask) == 2) {
  418. addr2[0] = '';
  419.     } else if (sscanf(t, "%s", addr1) == 1) {
  420. /*
  421.  * Note, must use plain gethostbyname() here because at startup
  422.  * ipcache hasn't been initialized
  423.  */
  424. if ((hp = gethostbyname(addr1)) == NULL) {
  425.     debug(28, 0) ("aclParseIpData: Bad host/IP: '%s'n", t);
  426.     safe_free(q);
  427.     return NULL;
  428. }
  429. Q = &q;
  430. for (x = hp->h_addr_list; x != NULL && *x != NULL; x++) {
  431.     if ((r = *Q) == NULL)
  432. r = *Q = memAllocate(MEM_ACL_IP_DATA);
  433.     xmemcpy(&r->addr1.s_addr, *x, sizeof(r->addr1.s_addr));
  434.     r->addr2.s_addr = 0;
  435.     r->mask.s_addr = no_addr.s_addr; /* 255.255.255.255 */
  436.     Q = &r->next;
  437.     debug(28, 3) ("%s --> %sn", addr1, inet_ntoa(r->addr1));
  438. }
  439. return q;
  440.     } else {
  441. debug(28, 0) ("aclParseIpData: Bad host/IP: '%s'n", t);
  442. safe_free(q);
  443. return NULL;
  444.     }
  445.     /* Decode addr1 */
  446.     if (!decode_addr(addr1, &q->addr1, &q->mask)) {
  447. debug(28, 0) ("%s line %d: %sn",
  448.     cfg_filename, config_lineno, config_input_line);
  449. debug(28, 0) ("aclParseIpData: Ignoring invalid IP acl entry: unknown first address '%s'n", addr1);
  450. safe_free(q);
  451. return NULL;
  452.     }
  453.     /* Decode addr2 */
  454.     if (*addr2 && !decode_addr(addr2, &q->addr2, &q->mask)) {
  455. debug(28, 0) ("%s line %d: %sn",
  456.     cfg_filename, config_lineno, config_input_line);
  457. debug(28, 0) ("aclParseIpData: Ignoring invalid IP acl entry: unknown second address '%s'n", addr2);
  458. safe_free(q);
  459. return NULL;
  460.     }
  461.     /* Decode mask */
  462.     if (*mask && !decode_addr(mask, &q->mask, NULL)) {
  463. debug(28, 0) ("%s line %d: %sn",
  464.     cfg_filename, config_lineno, config_input_line);
  465. debug(28, 0) ("aclParseIpData: Ignoring invalid IP acl entry: unknown netmask '%s'n", mask);
  466. safe_free(q);
  467. return NULL;
  468.     }
  469.     q->addr1.s_addr &= q->mask.s_addr;
  470.     q->addr2.s_addr &= q->mask.s_addr;
  471.     /* 1.2.3.4/255.255.255.0  --> 1.2.3.0 */
  472.     return q;
  473. }
  475. /******************/
  476. /* aclParseIpList */
  477. /******************/
  479. static void
  480. aclParseIpList(void *curlist)
  481. {
  482.     char *t = NULL;
  483.     splayNode **Top = curlist;
  484.     acl_ip_data *q = NULL;
  485.     while ((t = strtokFile())) {
  486. q = aclParseIpData(t);
  487. while (q != NULL) {
  488.     *Top = splay_insert(q, *Top, aclIpNetworkCompare);
  489.     q = q->next;
  490. }
  491.     }
  492. }
  494. static void
  495. aclParseTimeSpec(void *curlist)
  496. {
  497.     acl_time_data *q = NULL;
  498.     acl_time_data **Tail;
  499.     int h1, m1, h2, m2;
  500.     char *t = NULL;
  501.     for (Tail = curlist; *Tail; Tail = &((*Tail)->next));
  502.     q = memAllocate(MEM_ACL_TIME_DATA);
  503.     while ((t = strtokFile())) {
  504. if (*t < '0' || *t > '9') {
  505.     /* assume its day-of-week spec */
  506.     while (*t) {
  507. switch (*t++) {
  508. case 'S':
  509.     q->weekbits |= ACL_SUNDAY;
  510.     break;
  511. case 'M':
  512.     q->weekbits |= ACL_MONDAY;
  513.     break;
  514. case 'T':
  515.     q->weekbits |= ACL_TUESDAY;
  516.     break;
  517. case 'W':
  518.     q->weekbits |= ACL_WEDNESDAY;
  519.     break;
  520. case 'H':
  521.     q->weekbits |= ACL_THURSDAY;
  522.     break;
  523. case 'F':
  524.     q->weekbits |= ACL_FRIDAY;
  525.     break;
  526. case 'A':
  527.     q->weekbits |= ACL_SATURDAY;
  528.     break;
  529. case 'D':
  530.     q->weekbits |= ACL_WEEKDAYS;
  531.     break;
  532. case '-':
  533.     /* ignore placeholder */
  534.     break;
  535. default:
  536.     debug(28, 0) ("%s line %d: %sn",
  537. cfg_filename, config_lineno, config_input_line);
  538.     debug(28, 0) ("aclParseTimeSpec: Bad Day '%c'n",
  539. *t);
  540.     break;
  541. }
  542.     }
  543. } else {
  544.     /* assume its time-of-day spec */
  545.     if (sscanf(t, "%d:%d-%d:%d", &h1, &m1, &h2, &m2) < 4) {
  546. debug(28, 0) ("%s line %d: %sn",
  547.     cfg_filename, config_lineno, config_input_line);
  548. debug(28, 0) ("aclParseTimeSpec: IGNORING Bad time rangen");
  549. xfree(q);
  550. return;
  551.     }
  552.     q->start = h1 * 60 + m1;
  553.     q->stop = h2 * 60 + m2;
  554.     if (q->start > q->stop) {
  555. debug(28, 0) ("%s line %d: %sn",
  556.     cfg_filename, config_lineno, config_input_line);
  557. debug(28, 0) ("aclParseTimeSpec: IGNORING Reversed time rangen");
  558. xfree(q);
  559. return;
  560.     }
  561. }
  562.     }
  563.     if (q->start == 0 && q->stop == 0)
  564. q->stop = 23 * 60 + 59;
  565.     if (q->weekbits == 0)
  566. q->weekbits = ACL_ALLWEEK;
  567.     *(Tail) = q;
  568.     Tail = &q->next;
  569. }
  571. void
  572. aclParseRegexList(void *curlist)
  573. {
  574.     relist **Tail;
  575.     relist *q = NULL;
  576.     char *t = NULL;
  577.     regex_t comp;
  578.     int errcode;
  579.     int flags = REG_EXTENDED | REG_NOSUB;
  580.     for (Tail = curlist; *Tail; Tail = &((*Tail)->next));
  581.     while ((t = strtokFile())) {
  582. if (strcmp(t, "-i") == 0) {
  583.     flags |= REG_ICASE;
  584.     continue;
  585. }
  586. if (strcmp(t, "+i") == 0) {
  587.     flags &= ~REG_ICASE;
  588.     continue;
  589. }
  590. if ((errcode = regcomp(&comp, t, flags)) != 0) {
  591.     char errbuf[256];
  592.     regerror(errcode, &comp, errbuf, sizeof errbuf);
  593.     debug(28, 0) ("%s line %d: %sn",
  594. cfg_filename, config_lineno, config_input_line);
  595.     debug(28, 0) ("aclParseRegexList: Invalid regular expression '%s': %sn",
  596. t, errbuf);
  597.     continue;
  598. }
  599. q = memAllocate(MEM_RELIST);
  600. q->pattern = xstrdup(t);
  601. q->regex = comp;
  602. *(Tail) = q;
  603. Tail = &q->next;
  604.     }
  605. }
  607. static void
  608. aclParseWordList(void *curlist)
  609. {
  610.     char *t = NULL;
  611.     while ((t = strtokFile()))
  612. wordlistAdd(curlist, t);
  613. }
  615. /**********************/
  616. /* aclParseDomainList */
  617. /**********************/
  619. static void
  620. aclParseDomainList(void *curlist)
  621. {
  622.     char *t = NULL;
  623.     splayNode **Top = curlist;
  624.     while ((t = strtokFile())) {
  625. Tolower(t);
  626. *Top = splay_insert(xstrdup(t), *Top, aclDomainCompare);
  627.     }
  628. }
  630. void
  631. aclParseAclLine(acl ** head)
  632. {
  633.     /* we're already using strtok() to grok the line */
  634.     char *t = NULL;
  635.     acl *A = NULL;
  636.     LOCAL_ARRAY(char, aclname, ACL_NAME_SZ);
  637.     squid_acl acltype;
  638.     int new_acl = 0;
  640.     /* snarf the ACL name */
  641.     if ((t = strtok(NULL, w_space)) == NULL) {
  642. debug(28, 0) ("%s line %d: %sn",
  643.     cfg_filename, config_lineno, config_input_line);
  644. debug(28, 0) ("aclParseAclLine: missing ACL name.n");
  645. return;
  646.     }
  647.     xstrncpy(aclname, t, ACL_NAME_SZ);
  648.     /* snarf the ACL type */
  649.     if ((t = strtok(NULL, w_space)) == NULL) {
  650. debug(28, 0) ("%s line %d: %sn",
  651.     cfg_filename, config_lineno, config_input_line);
  652. debug(28, 0) ("aclParseAclLine: missing ACL type.n");
  653. return;
  654.     }
  655.     if ((acltype = aclStrToType(t)) == ACL_NONE) {
  656. debug(28, 0) ("%s line %d: %sn",
  657.     cfg_filename, config_lineno, config_input_line);
  658. debug(28, 0) ("aclParseAclLine: Invalid ACL type '%s'n", t);
  659. return;
  660.     }
  661.     if ((A = aclFindByName(aclname)) == NULL) {
  662. debug(28, 3) ("aclParseAclLine: Creating ACL '%s'n", aclname);
  663. A = memAllocate(MEM_ACL);
  664. xstrncpy(A->name, aclname, ACL_NAME_SZ);
  665. A->type = acltype;
  666. A->cfgline = xstrdup(config_input_line);
  667. new_acl = 1;
  668.     } else {
  669. if (acltype != A->type) {
  670.     debug(28, 0) ("aclParseAclLine: ACL '%s' already exists with different type, skipping.n", A->name);
  671.     return;
  672. }
  673. debug(28, 3) ("aclParseAclLine: Appending to '%s'n", aclname);
  674. new_acl = 0;
  675.     }
  676.     switch (A->type) {
  677.     case ACL_SRC_IP:
  678.     case ACL_DST_IP:
  679.     case ACL_MY_IP:
  680. aclParseIpList(&A->data);
  681. break;
  682.     case ACL_SRC_DOMAIN:
  683.     case ACL_DST_DOMAIN:
  684. aclParseDomainList(&A->data);
  685. break;
  686.     case ACL_TIME:
  687. aclParseTimeSpec(&A->data);
  688. break;
  689.     case ACL_URL_REGEX:
  690.     case ACL_URLPATH_REGEX:
  691.     case ACL_SRC_DOM_REGEX:
  692.     case ACL_DST_DOM_REGEX:
  693. aclParseRegexList(&A->data);
  694. break;
  695.     case ACL_SRC_ASN:
  696.     case ACL_DST_ASN:
  697.     case ACL_NETDB_SRC_RTT:
  698. aclParseIntlist(&A->data);
  699. break;
  700.     case ACL_URL_PORT:
  701. aclParseIntRange(&A->data);
  702. break;
  703. #if USE_IDENT
  704.     case ACL_IDENT:
  705. aclParseWordList(&A->data);
  706. break;
  707. #endif
  708.     case ACL_PROTO:
  709. aclParseProtoList(&A->data);
  710. break;
  711.     case ACL_METHOD:
  712. aclParseMethodList(&A->data);
  713. break;
  714.     case ACL_BROWSER:
  715. aclParseRegexList(&A->data);
  716. break;
  717.     case ACL_PROXY_AUTH:
  718. aclParseWordList(&A->data);
  719. if (!proxy_auth_cache) {
  720.     /* First time around, 7921 should be big enough */
  721.     proxy_auth_cache = hash_create((HASHCMP *) strcmp, 7921, hash_string);
  722.     assert(proxy_auth_cache);
  723. }
  724. break;
  725. #if SQUID_SNMP
  726.     case ACL_SNMP_COMMUNITY:
  727. aclParseWordList(&A->data);
  728. break;
  729. #endif
  730. #if USE_ARP_ACL
  731.     case ACL_SRC_ARP:
  732. aclParseArpList(&A->data);
  733. break;
  734. #endif
  735.     case ACL_NONE:
  736.     default:
  737. fatal("Bad ACL type");
  738. break;
  739.     }
  740.     if (!new_acl)
  741. return;
  742.     if (A->data == NULL) {
  743. debug(28, 0) ("aclParseAclLine: IGNORING invalid ACL: %sn",
  744.     A->cfgline);
  745. xfree(A);
  746. return;
  747.     }
  748.     /* append */
  749.     while (*head)
  750. head = &(*head)->next;
  751.     *head = A;
  752. }
  754. /* does name lookup, returns page_id */
  755. int
  756. aclGetDenyInfoPage(acl_deny_info_list ** head, const char *name)
  757. {
  758.     acl_deny_info_list *A = NULL;
  759.     acl_name_list *L = NULL;
  761.     A = *head;
  762.     if (NULL == *head) /* empty list */
  763. return -1;
  764.     while (A) {
  765. L = A->acl_list;
  766. if (NULL == L) /* empty list should never happen, but in case */
  767.     continue;
  768. while (L) {
  769.     if (!strcmp(name, L->name))
  770. return A->err_page_id;
  771.     L = L->next;
  772. }
  773. A = A->next;
  774.     }
  775.     return -1;
  776. }
  778. /* does name lookup, returns if it is a proxy_auth acl */
  779. int
  780. aclIsProxyAuth(const char *name)
  781. {
  782.     acl *a = aclFindByName(name);
  783.     if (a)
  784. return a->type == ACL_PROXY_AUTH;
  785.     return 0;
  786. }
  789. /* maex@space.net (05.09.96)
  790.  *    get the info for redirecting "access denied" to info pages
  791.  *      TODO (probably ;-)
  792.  *      currently there is no optimization for
  793.  *      - more than one deny_info line with the same url
  794.  *      - a check, whether the given acl really is defined
  795.  *      - a check, whether an acl is added more than once for the same url
  796.  */
  798. void
  799. aclParseDenyInfoLine(acl_deny_info_list ** head)
  800. {
  801.     char *t = NULL;
  802.     acl_deny_info_list *A = NULL;
  803.     acl_deny_info_list *B = NULL;
  804.     acl_deny_info_list **T = NULL;
  805.     acl_name_list *L = NULL;
  806.     acl_name_list **Tail = NULL;
  808.     /* first expect a page name */
  809.     if ((t = strtok(NULL, w_space)) == NULL) {
  810. debug(28, 0) ("%s line %d: %sn",
  811.     cfg_filename, config_lineno, config_input_line);
  812. debug(28, 0) ("aclParseDenyInfoLine: missing 'error page' parameter.n");
  813. return;
  814.     }
  815.     A = xcalloc(1, sizeof(acl_deny_info_list));
  816.     A->err_page_id = errorReservePageId(t);
  817.     A->err_page_name = xstrdup(t);
  818.     A->next = (acl_deny_info_list *) NULL;
  819.     /* next expect a list of ACL names */
  820.     Tail = &A->acl_list;
  821.     while ((t = strtok(NULL, w_space))) {
  822. L = xcalloc(1, sizeof(acl_name_list));
  823. xstrncpy(L->name, t, ACL_NAME_SZ);
  824. *Tail = L;
  825. Tail = &L->next;
  826.     }
  827.     if (A->acl_list == NULL) {
  828. debug(28, 0) ("%s line %d: %sn",
  829.     cfg_filename, config_lineno, config_input_line);
  830. debug(28, 0) ("aclParseDenyInfoLine: deny_info line contains no ACL's, skippingn");
  831. xfree(A);
  832. return;
  833.     }
  834.     for (B = *head, T = head; B; T = &B->next, B = B->next); /* find the tail */
  835.     *T = A;
  836. }
  838. void
  839. aclParseAccessLine(acl_access ** head)
  840. {
  841.     char *t = NULL;
  842.     acl_access *A = NULL;
  843.     acl_access *B = NULL;
  844.     acl_access **T = NULL;
  845.     acl_list *L = NULL;
  846.     acl_list **Tail = NULL;
  847.     acl *a = NULL;
  849.     /* first expect either 'allow' or 'deny' */
  850.     if ((t = strtok(NULL, w_space)) == NULL) {
  851. debug(28, 0) ("%s line %d: %sn",
  852.     cfg_filename, config_lineno, config_input_line);
  853. debug(28, 0) ("aclParseAccessLine: missing 'allow' or 'deny'.n");
  854. return;
  855.     }
  856.     A = memAllocate(MEM_ACL_ACCESS);
  858.     if (!strcmp(t, "allow"))
  859. A->allow = 1;
  860.     else if (!strcmp(t, "deny"))
  861. A->allow = 0;
  862.     else {
  863. debug(28, 0) ("%s line %d: %sn",
  864.     cfg_filename, config_lineno, config_input_line);
  865. debug(28, 0) ("aclParseAccessLine: expecting 'allow' or 'deny', got '%s'.n", t);
  866. xfree(A);
  867. return;
  868.     }
  870.     /* next expect a list of ACL names, possibly preceeded
  871.      * by '!' for negation */
  872.     Tail = &A->acl_list;
  873.     while ((t = strtok(NULL, w_space))) {
  874. L = memAllocate(MEM_ACL_LIST);
  875. L->op = 1; /* defaults to non-negated */
  876. if (*t == '!') {
  877.     /* negated ACL */
  878.     L->op = 0;
  879.     t++;
  880. }
  881. debug(28, 3) ("aclParseAccessLine: looking for ACL name '%s'n", t);
  882. a = aclFindByName(t);
  883. if (a == NULL) {
  884.     debug(28, 0) ("%s line %d: %sn",
  885. cfg_filename, config_lineno, config_input_line);
  886.     debug(28, 0) ("aclParseAccessLine: ACL name '%s' not found.n", t);
  887.     xfree(L);
  888.     continue;
  889. }
  890. L->acl = a;
  891. *Tail = L;
  892. Tail = &L->next;
  893.     }
  894.     if (A->acl_list == NULL) {
  895. debug(28, 0) ("%s line %d: %sn",
  896.     cfg_filename, config_lineno, config_input_line);
  897. debug(28, 0) ("aclParseAccessLine: Access line contains no ACL's, skippingn");
  898. xfree(A);
  899. return;
  900.     }
  901.     A->cfgline = xstrdup(config_input_line);
  902.     /* Append to the end of this list */
  903.     for (B = *head, T = head; B; T = &B->next, B = B->next);
  904.     *T = A;
  905.     /* We lock _acl_access structures in aclCheck() */
  906.     cbdataAdd(A, memFree, MEM_ACL_ACCESS);
  907. }
  909. /**************/
  910. /* aclMatchIp */
  911. /**************/
  913. static int
  914. aclMatchIp(void *dataptr, struct in_addr c)
  915. {
  916.     splayNode **Top = dataptr;
  917.     *Top = splay_splay(&c, *Top, aclIpNetworkCompare);
  918.     debug(28, 3) ("aclMatchIp: '%s' %sn",
  919. inet_ntoa(c), splayLastResult ? "NOT found" : "found");
  920.     return !splayLastResult;
  921. }
  923. /**********************/
  924. /* aclMatchDomainList */
  925. /**********************/
  927. static int
  928. aclMatchDomainList(void *dataptr, const char *host)
  929. {
  930.     splayNode **Top = dataptr;
  931.     if (host == NULL)
  932. return 0;
  933.     debug(28, 3) ("aclMatchDomainList: checking '%s'n", host);
  934.     *Top = splay_splay(host, *Top, aclHostDomainCompare);
  935.     debug(28, 3) ("aclMatchDomainList: '%s' %sn",
  936. host, splayLastResult ? "NOT found" : "found");
  937.     return !splayLastResult;
  938. }
  940. int
  941. aclMatchRegex(relist * data, const char *word)
  942. {
  943.     relist *first, *prev;
  944.     if (word == NULL)
  945. return 0;
  946.     debug(28, 3) ("aclMatchRegex: checking '%s'n", word);
  947.     first = data;
  948.     prev = NULL;
  949.     while (data) {
  950. debug(28, 3) ("aclMatchRegex: looking for '%s'n", data->pattern);
  951. if (regexec(&data->regex, word, 0, 0, 0) == 0) {
  952.     if (prev != NULL) {
  953. /* shift the element just found to the second position
  954.  * in the list */
  955. prev->next = data->next;
  956. data->next = first->next;
  957. first->next = data;
  958.     }
  959.     return 1;
  960. }
  961. prev = data;
  962. data = data->next;
  963.     }
  964.     return 0;
  965. }
  967. static int
  968. aclMatchUser(wordlist * data, const char *user)
  969. {
  970.     if (user == NULL)
  971. return 0;
  972.     debug(28, 3) ("aclMatchUser: checking '%s'n", user);
  973.     while (data) {
  974. debug(28, 3) ("aclMatchUser: looking for '%s'n", data->key);
  975. if (strcmp(data->key, "REQUIRED") == 0 && *user != '' && strcmp(user, "-") != 0)
  976.     return 1;
  977. if (strcmp(data->key, user) == 0)
  978.     return 1;
  979. data = data->next;
  980.     }
  981.     return 0;
  982. }
  984. static int
  985. aclDecodeProxyAuth(const char *proxy_auth, char **user, char **password, char *buf, size_t bufsize)
  986. {
  987.     char *sent_auth;
  988.     char *cleartext;
  990.     if (proxy_auth == NULL)
  991. return 0;
  992.     if (strlen(proxy_auth) < SKIP_BASIC_SZ)
  993. return 0;
  994.     proxy_auth += SKIP_BASIC_SZ;
  995.     sent_auth = xstrdup(proxy_auth); /* username and password */
  996.     /* Trim trailing n before decoding */
  997.     strtok(sent_auth, "n");
  998.     /* Trim leading whitespace before decoding */
  999.     while (xisspace(*proxy_auth))
  1000. proxy_auth++;
  1001.     cleartext = uudecode(sent_auth);
  1002.     xfree(sent_auth);
  1003.     debug(28, 6) ("aclDecodeProxyAuth: cleartext = '%s'n", cleartext);
  1004.     xstrncpy(buf, cleartext, bufsize);
  1005.     xfree(cleartext);
  1006.     *user = buf;
  1007.     if ((*password = strchr(*user, ':')) != NULL)
  1008. *(*password)++ = '';
  1009.     if (*password == NULL) {
  1010. debug(28, 1) ("aclDecodeProxyAuth: no password in proxy authorization headern");
  1011. return 0;
  1012.     }
  1013.     return 1;
  1014. }
  1016. /* aclMatchProxyAuth can return three exit codes:
  1017.  * 0 : user denied access
  1018.  * 1 : user validated OK
  1019.  * -1 : check the password for this user via an external authenticator
  1020.  * -2 : invalid Proxy-authorization: header;
  1021.  * ask for Proxy-Authorization: header
  1022.  */
  1024. static int
  1025. aclMatchProxyAuth(wordlist * data, const char *proxy_auth, acl_proxy_auth_user * auth_user, aclCheck_t * checklist)
  1026. {
  1027.     /* checklist is used to register user name when identified, nothing else */
  1028.     LOCAL_ARRAY(char, login_buf, USER_IDENT_SZ);
  1029.     char *user, *password;
  1031.     if (!aclDecodeProxyAuth(proxy_auth, &user, &password, login_buf, sizeof(login_buf)))
  1032. /* No or invalid Proxy-Auth header */
  1033. return -2;
  1035.     debug(28, 5) ("aclMatchProxyAuth: checking user '%s'n", user);
  1037.     if (auth_user) {
  1038. /* This should be optimized to a boolean argument indicating that the
  1039.  * password is invalid, instead of passing full acl_proxy_auth_user
  1040.  * structures, and all messing with checklist->proxy_auth should
  1041.  * be restricted the functions that deal with the authenticator.
  1042.  */
  1043. assert(auth_user == checklist->auth_user);
  1044. checklist->auth_user = NULL; /* get rid of that special reference */
  1045. /* Check result from external validation */
  1046. if (auth_user->passwd_ok != 1) {
  1047.     /* password was checked but did not match */
  1048.     assert(auth_user->passwd_ok == 0);
  1049.     debug(28, 4) ("aclMatchProxyAuth: authentication failed for user '%s'n",
  1050. user);
  1051.     aclFreeProxyAuthUser(auth_user);
  1052.     /* copy username to request for logging on client-side unless ident
  1053.      * is known (do not override ident with false proxy auth names) */
  1054.     if (!*checklist->request->user_ident)
  1055. xstrncpy(checklist->request->user_ident, user, USER_IDENT_SZ);
  1056.     return -2;
  1057. } else {
  1058.     /* password was checked and did match */
  1059.     debug(28, 4) ("aclMatchProxyAuth: user '%s' validated OKn", user);
  1060.     /* store validated user in hash, after filling in expiretime */
  1061.     xstrncpy(checklist->request->user_ident, user, USER_IDENT_SZ);
  1062.     auth_user->expiretime = current_time.tv_sec + Config.authenticateTTL;
  1063.     hash_join(proxy_auth_cache, (hash_link *) auth_user);
  1064.     /* Continue checking below, as normal */
  1065. }
  1066.     }
  1067.     /* see if we already know this user */
  1068.     auth_user = hash_lookup(proxy_auth_cache, user);
  1070.     if (!auth_user) {
  1071. /* user not yet known, ask external authenticator */
  1072. debug(28, 4) ("aclMatchProxyAuth: user '%s' not yet knownn", user);
  1073. return -1;
  1074.     } else if ((0 == strcmp(auth_user->passwd, password)) &&
  1075. (auth_user->expiretime > current_time.tv_sec)) {
  1076. /* user already known and valid */
  1077. debug(28, 5) ("aclMatchProxyAuth: user '%s' previously validatedn",
  1078.     user);
  1079. /* copy username to request for logging on client-side */
  1080. xstrncpy(checklist->request->user_ident, user, USER_IDENT_SZ);
  1081. return aclMatchUser(data, user);
  1082.     } else {
  1083. /* password mismatch/timeout */
  1084. debug(28, 4) ("aclMatchProxyAuth: user '%s' password mismatch/timeoutn",
  1085.     user);
  1086. /* remove this user from the hash, making him unknown */
  1087. hash_remove_link(proxy_auth_cache, (hash_link *) auth_user);
  1088. aclFreeProxyAuthUser(auth_user);
  1089. /* ask the external authenticator in case the password is changed */
  1090. /* wrong password will be trapped above so this does not loop */
  1091. return -1;
  1092.     }
  1093.     /* NOTREACHED */
  1095. }
  1097. static void
  1098. aclLookupProxyAuthStart(aclCheck_t * checklist)
  1099. {
  1100.     LOCAL_ARRAY(char, login_buf, USER_IDENT_SZ);
  1101.     const char *proxy_auth;
  1102.     char *user, *password;
  1103.     int ok;
  1104.     acl_proxy_auth_user *auth_user;
  1105.     assert(!checklist->auth_user);
  1106.     if (!checklist->request->flags.accelerated) {
  1107. /* Proxy auth on proxy requests */
  1108. proxy_auth = httpHeaderGetStr(&checklist->request->header,
  1109.     HDR_PROXY_AUTHORIZATION);
  1110.     } else {
  1111. /* WWW auth on accelerated requests */
  1112. proxy_auth = httpHeaderGetStr(&checklist->request->header,
  1113.     HDR_AUTHORIZATION);
  1114.     }
  1115.     ok = aclDecodeProxyAuth(proxy_auth, &user, &password, login_buf,
  1116. sizeof(login_buf));
  1117.     /*
  1118.      * if aclDecodeProxyAuth() fails, the same call should have failed
  1119.      * in aclMatchProxyAuth, and we should never get this far.
  1120.      */
  1121.     assert(ok);
  1122.     debug(28, 4) ("aclLookupProxyAuthStart: going to ask authenticator on %sn", user);
  1123.     /* we must still check this user's password */
  1124.     auth_user = memAllocate(MEM_ACL_PROXY_AUTH_USER);
  1125.     auth_user->user = xstrdup(user);
  1126.     auth_user->passwd = xstrdup(password);
  1127.     auth_user->passwd_ok = -1;
  1128.     auth_user->expiretime = -1;
  1129.     checklist->auth_user = auth_user;
  1130.     authenticateStart(checklist->auth_user, aclLookupProxyAuthDone,
  1131. checklist);
  1132. }
  1134. static int
  1135. aclMatchInteger(intlist * data, int i)
  1136. {
  1137.     intlist *first, *prev;
  1138.     first = data;
  1139.     prev = NULL;
  1140.     while (data) {
  1141. if (data->i == i) {
  1142.     if (prev != NULL) {
  1143. /* shift the element just found to the second position
  1144.  * in the list */
  1145. prev->next = data->next;
  1146. data->next = first->next;
  1147. first->next = data;
  1148.     }
  1149.     return 1;
  1150. }
  1151. prev = data;
  1152. data = data->next;
  1153.     }
  1154.     return 0;
  1155. }
  1157. static int
  1158. aclMatchIntegerRange(intrange * data, int i)
  1159. {
  1160.     intrange *first, *prev;
  1161.     first = data;
  1162.     prev = NULL;
  1163.     while (data) {
  1164. if (i < data->i) {
  1165.     (void) 0;
  1166. } else if (i > data->j) {
  1167.     (void) 0;
  1168. } else {
  1169.     /* matched */
  1170.     if (prev != NULL) {
  1171. /* shift the element just found to the second position
  1172.  * in the list */
  1173. prev->next = data->next;
  1174. data->next = first->next;
  1175. first->next = data;
  1176.     }
  1177.     return 1;
  1178. }
  1179. prev = data;
  1180. data = data->next;
  1181.     }
  1182.     return 0;
  1183. }
  1185. static int
  1186. aclMatchTime(acl_time_data * data, time_t when)
  1187. {
  1188.     static time_t last_when = 0;
  1189.     static struct tm tm;
  1190.     time_t t;
  1191.     assert(data != NULL);
  1192.     if (when != last_when) {
  1193. last_when = when;
  1194. xmemcpy(&tm, localtime(&when), sizeof(struct tm));
  1195.     }
  1196.     t = (time_t) (tm.tm_hour * 60 + tm.tm_min);
  1197.     debug(28, 3) ("aclMatchTime: checking %d in %d-%d, weekbits=%xn",
  1198. (int) t, (int) data->start, (int) data->stop, data->weekbits);
  1200.     if (t < data->start || t > data->stop)
  1201. return 0;
  1202.     return data->weekbits & (1 << tm.tm_wday) ? 1 : 0;
  1203. }
  1205. #if SQUID_SNMP
  1206. static int
  1207. aclMatchWordList(wordlist * w, const char *word)
  1208. {
  1209.     debug(28, 3) ("aclMatchWordList: looking for '%s'n", word);
  1210.     while (w != NULL) {
  1211. debug(28, 3) ("aclMatchWordList: checking '%s'n", w->key);
  1212. if (!strcmp(w->key, word))
  1213.     return 1;
  1214. w = w->next;
  1215.     }
  1216.     return 0;
  1217. }
  1218. #endif
  1220. static int
  1221. aclMatchAcl(acl * ae, aclCheck_t * checklist)
  1222. {
  1223.     request_t *r = checklist->request;
  1224.     const ipcache_addrs *ia = NULL;
  1225.     const char *fqdn = NULL;
  1226.     char *esc_buf;
  1227.     const char *header;
  1228.     int k;
  1229.     if (!ae)
  1230. return 0;
  1231.     debug(28, 3) ("aclMatchAcl: checking '%s'n", ae->cfgline);
  1232.     switch (ae->type) {
  1233.     case ACL_SRC_IP:
  1234. return aclMatchIp(&ae->data, checklist->src_addr);
  1235. /* NOTREACHED */
  1236.     case ACL_MY_IP:
  1237. return aclMatchIp(&ae->data, checklist->my_addr);
  1238. /* NOTREACHED */
  1239.     case ACL_DST_IP:
  1240. ia = ipcache_gethostbyname(r->host, IP_LOOKUP_IF_MISS);
  1241. if (ia) {
  1242.     for (k = 0; k < (int) ia->count; k++) {
  1243. if (aclMatchIp(&ae->data, ia->in_addrs[k]))
  1244.     return 1;
  1245.     }
  1246.     return 0;
  1247. } else if (checklist->state[ACL_DST_IP] == ACL_LOOKUP_NONE) {
  1248.     debug(28, 3) ("aclMatchAcl: Can't yet compare '%s' ACL for '%s'n",
  1249. ae->name, r->host);
  1250.     checklist->state[ACL_DST_IP] = ACL_LOOKUP_NEEDED;
  1251.     return 0;
  1252. } else {
  1253.     return aclMatchIp(&ae->data, no_addr);
  1254. }
  1255. /* NOTREACHED */
  1256.     case ACL_DST_DOMAIN:
  1257. if ((ia = ipcacheCheckNumeric(r->host)) == NULL)
  1258.     return aclMatchDomainList(&ae->data, r->host);
  1259. fqdn = fqdncache_gethostbyaddr(ia->in_addrs[0], FQDN_LOOKUP_IF_MISS);
  1260. if (fqdn)
  1261.     return aclMatchDomainList(&ae->data, fqdn);
  1262. if (checklist->state[ACL_DST_DOMAIN] == ACL_LOOKUP_NONE) {
  1263.     debug(28, 3) ("aclMatchAcl: Can't yet compare '%s' ACL for '%s'n",
  1264. ae->name, inet_ntoa(ia->in_addrs[0]));
  1265.     checklist->state[ACL_DST_DOMAIN] = ACL_LOOKUP_NEEDED;
  1266.     return 0;
  1267. }
  1268. return aclMatchDomainList(&ae->data, "none");
  1269. /* NOTREACHED */
  1270.     case ACL_SRC_DOMAIN:
  1271. fqdn = fqdncache_gethostbyaddr(checklist->src_addr, FQDN_LOOKUP_IF_MISS);
  1272. if (fqdn) {
  1273.     return aclMatchDomainList(&ae->data, fqdn);
  1274. } else if (checklist->state[ACL_SRC_DOMAIN] == ACL_LOOKUP_NONE) {
  1275.     debug(28, 3) ("aclMatchAcl: Can't yet compare '%s' ACL for '%s'n",
  1276. ae->name, inet_ntoa(checklist->src_addr));
  1277.     checklist->state[ACL_SRC_DOMAIN] = ACL_LOOKUP_NEEDED;
  1278.     return 0;
  1279. }
  1280. return aclMatchDomainList(&ae->data, "none");
  1281. /* NOTREACHED */
  1282.     case ACL_DST_DOM_REGEX:
  1283. if ((ia = ipcacheCheckNumeric(r->host)) == NULL)
  1284.     return aclMatchRegex(ae->data, r->host);
  1285. fqdn = fqdncache_gethostbyaddr(ia->in_addrs[0], FQDN_LOOKUP_IF_MISS);
  1286. if (fqdn)
  1287.     return aclMatchRegex(ae->data, fqdn);
  1288. if (checklist->state[ACL_DST_DOMAIN] == ACL_LOOKUP_NONE) {
  1289.     debug(28, 3) ("aclMatchAcl: Can't yet compare '%s' ACL for '%s'n",
  1290. ae->name, inet_ntoa(ia->in_addrs[0]));
  1291.     checklist->state[ACL_DST_DOMAIN] = ACL_LOOKUP_NEEDED;
  1292.     return 0;
  1293. }
  1294. return aclMatchRegex(ae->data, "none");
  1295. /* NOTREACHED */
  1296.     case ACL_SRC_DOM_REGEX:
  1297. fqdn = fqdncache_gethostbyaddr(checklist->src_addr, FQDN_LOOKUP_IF_MISS);
  1298. if (fqdn) {
  1299.     return aclMatchRegex(ae->data, fqdn);
  1300. } else if (checklist->state[ACL_SRC_DOMAIN] == ACL_LOOKUP_NONE) {
  1301.     debug(28, 3) ("aclMatchAcl: Can't yet compare '%s' ACL for '%s'n",
  1302. ae->name, inet_ntoa(checklist->src_addr));
  1303.     checklist->state[ACL_SRC_DOMAIN] = ACL_LOOKUP_NEEDED;
  1304.     return 0;
  1305. }
  1306. return aclMatchRegex(ae->data, "none");
  1307. /* NOTREACHED */
  1308.     case ACL_TIME:
  1309. return aclMatchTime(ae->data, squid_curtime);
  1310. /* NOTREACHED */
  1311.     case ACL_URLPATH_REGEX:
  1312. esc_buf = xstrdup(strBuf(r->urlpath));
  1313. rfc1738_unescape(esc_buf);
  1314. k = aclMatchRegex(ae->data, esc_buf);
  1315. safe_free(esc_buf);
  1316. return k;
  1317. /* NOTREACHED */
  1318.     case ACL_URL_REGEX:
  1319. esc_buf = xstrdup(urlCanonical(r));
  1320. rfc1738_unescape(esc_buf);
  1321. k = aclMatchRegex(ae->data, esc_buf);
  1322. safe_free(esc_buf);
  1323. return k;
  1324. /* NOTREACHED */
  1325.     case ACL_URL_PORT:
  1326. return aclMatchIntegerRange(ae->data, r->port);
  1327. /* NOTREACHED */
  1328. #if USE_IDENT
  1329.     case ACL_IDENT:
  1330. if (checklist->ident[0]) {
  1331.     return aclMatchUser(ae->data, checklist->ident);
  1332. } else {
  1333.     checklist->state[ACL_IDENT] = ACL_LOOKUP_NEEDED;
  1334.     return 0;
  1335. }
  1336. /* NOTREACHED */
  1337. #endif
  1338.     case ACL_PROTO:
  1339. return aclMatchInteger(ae->data, r->protocol);
  1340. /* NOTREACHED */
  1341.     case ACL_METHOD:
  1342. return aclMatchInteger(ae->data, r->method);
  1343. /* NOTREACHED */
  1344.     case ACL_BROWSER:
  1345. return aclMatchRegex(ae->data, checklist->browser);
  1346. /* NOTREACHED */
  1347.     case ACL_PROXY_AUTH:
  1348. if (!r->flags.accelerated) {
  1349.     /* Proxy authorization on proxy requests */
  1350.     header = httpHeaderGetStr(&checklist->request->header,
  1351. HDR_PROXY_AUTHORIZATION);
  1352. } else if (r->flags.internal) {
  1353.     /* WWW authorization on accelerated internal requests */
  1354.     header = httpHeaderGetStr(&checklist->request->header,
  1355. HDR_AUTHORIZATION);
  1356. } else {
  1357. #if AUTH_ON_ACCELERATION
  1358.     /* WWW authorization on accelerated requests */
  1359.     header = httpHeaderGetStr(&checklist->request->header,
  1360. HDR_AUTHORIZATION);
  1361. #else
  1362.     debug(28, 1) ("aclMatchAcl: proxy_auth %s not applicable on accelerated requests.n", ae->name);
  1363.     return -1;
  1364. #endif
  1365. }
  1366. /*
  1367.  * Register that we used the proxy authentication header so that
  1368.  * it is not forwarded to the next proxy
  1369.  */
  1370. r->flags.used_proxy_auth = 1;
  1371. /* Check the password */
  1372. switch (aclMatchProxyAuth(ae->data,
  1373. header,
  1374. checklist->auth_user,
  1375. checklist)) {
  1376. case 0:
  1377.     /* Correct password, but was not allowed in this ACL */
  1378.     return 0;
  1379. case 1:
  1380.     /* user validated OK */
  1381.     return 1;
  1382. case -2:
  1383.     /* no such user OR we need a proxy authentication header */
  1384.     checklist->state[ACL_PROXY_AUTH] = ACL_PROXY_AUTH_NEEDED;
  1385.     /*
  1386.      * XXX This is a bit oddly done.. should perhaps use different
  1387.      * return codes here
  1388.      */
  1389.     return 0;
  1390. case -1:
  1391.     /*
  1392.      * we need to validate the password
  1393.      */
  1394.     checklist->state[ACL_PROXY_AUTH] = ACL_LOOKUP_NEEDED;
  1395.     return 0;
  1396. }
  1397. /* NOTREACHED */
  1398. #if SQUID_SNMP
  1399.     case ACL_SNMP_COMMUNITY:
  1400. return aclMatchWordList(ae->data, checklist->snmp_community);
  1401. #endif
  1402.     case ACL_SRC_ASN:
  1403. return asnMatchIp(ae->data, checklist->src_addr);
  1404.     case ACL_DST_ASN:
  1405. ia = ipcache_gethostbyname(r->host, IP_LOOKUP_IF_MISS);
  1406. if (ia) {
  1407.     for (k = 0; k < (int) ia->count; k++) {
  1408. if (asnMatchIp(ae->data, ia->in_addrs[k]))
  1409.     return 1;
  1410.     }
  1411.     return 0;
  1412. } else if (checklist->state[ACL_DST_ASN] == ACL_LOOKUP_NONE) {
  1413.     debug(28, 3) ("asnMatchAcl: Can't yet compare '%s' ACL for '%s'n",
  1414. ae->name, r->host);
  1415.     checklist->state[ACL_DST_ASN] = ACL_LOOKUP_NEEDED;
  1416. } else {
  1417.     return asnMatchIp(ae->data, no_addr);
  1418. }
  1419. return 0;
  1420. #if USE_ARP_ACL
  1421.     case ACL_SRC_ARP:
  1422. return aclMatchArp(&ae->data, checklist->src_addr);
  1423. #endif
  1424.     case ACL_NONE:
  1425.     default:
  1426. debug(28, 0) ("aclMatchAcl: '%s' has bad type %dn",
  1427.     ae->name, ae->type);
  1428. return 0;
  1429.     }
  1430.     /* NOTREACHED */
  1431. }
  1433. int
  1434. aclMatchAclList(const acl_list * list, aclCheck_t * checklist)
  1435. {
  1436.     while (list) {
  1437. AclMatchedName = list->acl->name;
  1438. debug(28, 3) ("aclMatchAclList: checking %s%sn",
  1439.     list->op ? null_string : "!", list->acl->name);
  1440. if (aclMatchAcl(list->acl, checklist) != list->op) {
  1441.     debug(28, 3) ("aclMatchAclList: returning 0n");
  1442.     return 0;
  1443. }
  1444. list = list->next;
  1445.     }
  1446.     debug(28, 3) ("aclMatchAclList: returning 1n");
  1447.     return 1;
  1448. }
  1450. int
  1451. aclCheckFast(const acl_access * A, aclCheck_t * checklist)
  1452. {
  1453.     int allow = 0;
  1454.     debug(28, 5) ("aclCheckFast: list: %pn", A);
  1455.     while (A) {
  1456. allow = A->allow;
  1457. if (aclMatchAclList(A->acl_list, checklist))
  1458.     return allow;
  1459. A = A->next;
  1460.     }
  1461.     debug(28, 5) ("aclCheckFast: no matches, returning: %dn", !allow);
  1462.     return !allow;
  1463. }
  1465. static void
  1466. aclCheck(aclCheck_t * checklist)
  1467. {
  1468.     allow_t allow = ACCESS_DENIED;
  1469.     const acl_access *A;
  1470.     int match;
  1471.     ipcache_addrs *ia;
  1472.     while ((A = checklist->access_list) != NULL) {
  1473. /*
  1474.  * If the _acl_access is no longer valid (i.e. its been
  1475.  * freed because of a reconfigure), then bail on this
  1476.  * access check.  For now, return ACCESS_DENIED.
  1477.  */
  1478. if (!cbdataValid(A)) {
  1479.     cbdataUnlock(A);
  1480.     break;
  1481. }
  1482. debug(28, 3) ("aclCheck: checking '%s'n", A->cfgline);
  1483. allow = A->allow;
  1484. match = aclMatchAclList(A->acl_list, checklist);
  1485. if (checklist->state[ACL_DST_IP] == ACL_LOOKUP_NEEDED) {
  1486.     checklist->state[ACL_DST_IP] = ACL_LOOKUP_PENDING;
  1487.     ipcache_nbgethostbyname(checklist->request->host,
  1488. aclLookupDstIPDone,
  1489. checklist);
  1490.     return;
  1491. } else if (checklist->state[ACL_DST_ASN] == ACL_LOOKUP_NEEDED) {
  1492.     checklist->state[ACL_DST_ASN] = ACL_LOOKUP_PENDING;
  1493.     ipcache_nbgethostbyname(checklist->request->host,
  1494. aclLookupDstIPforASNDone,
  1495. checklist);
  1496.     return;
  1497. } else if (checklist->state[ACL_SRC_DOMAIN] == ACL_LOOKUP_NEEDED) {
  1498.     checklist->state[ACL_SRC_DOMAIN] = ACL_LOOKUP_PENDING;
  1499.     fqdncache_nbgethostbyaddr(checklist->src_addr,
  1500. aclLookupSrcFQDNDone,
  1501. checklist);
  1502.     return;
  1503. } else if (checklist->state[ACL_DST_DOMAIN] == ACL_LOOKUP_NEEDED) {
  1504.     ia = ipcacheCheckNumeric(checklist->request->host);
  1505.     if (ia == NULL) {
  1506. checklist->state[ACL_DST_DOMAIN] = ACL_LOOKUP_DONE;
  1507. return;
  1508.     }
  1509.     checklist->dst_addr = ia->in_addrs[0];
  1510.     checklist->state[ACL_DST_DOMAIN] = ACL_LOOKUP_PENDING;
  1511.     fqdncache_nbgethostbyaddr(checklist->dst_addr,
  1512. aclLookupDstFQDNDone,
  1513. checklist);
  1514.     return;
  1515. } else if (checklist->state[ACL_PROXY_AUTH] == ACL_LOOKUP_NEEDED) {
  1516.     debug(28, 3) ("aclCheck: checking password via authenticatorn");
  1517.     aclLookupProxyAuthStart(checklist);
  1518.     checklist->state[ACL_PROXY_AUTH] = ACL_LOOKUP_PENDING;
  1519.     return;
  1520. } else if (checklist->state[ACL_PROXY_AUTH] == ACL_PROXY_AUTH_NEEDED) {
  1521.     /* Special case. Client is required to resend the request
  1522.      * with authentication. The request is denied.
  1523.      */
  1524.     allow = ACCESS_REQ_PROXY_AUTH;
  1525.     match = -1;
  1526. }
  1527. #if USE_IDENT
  1528. else if (checklist->state[ACL_IDENT] == ACL_LOOKUP_NEEDED) {
  1529.     debug(28, 3) ("aclCheck: Doing ident lookupn");
  1530.     if (cbdataValid(checklist->conn)) {
  1531. identStart(&checklist->conn->me, &checklist->conn->peer,
  1532.     aclLookupIdentDone, checklist);
  1533. checklist->state[ACL_IDENT] = ACL_LOOKUP_PENDING;
  1534. return;
  1535.     } else {
  1536. debug(28, 1) ("aclCheck: Can't start ident lookup. No client connectionn");
  1537. cbdataUnlock(checklist->conn);
  1538. checklist->conn = NULL;
  1539. allow = 0;
  1540. match = -1;
  1541.     }
  1542. }
  1543. #endif
  1544. /*
  1545.  * We are done with this _acl_access entry.  Either the request
  1546.  * is allowed, denied, requires authentication, or we move on to
  1547.  * the next entry.
  1548.  */
  1549. cbdataUnlock(A);
  1550. if (match) {
  1551.     debug(28, 3) ("aclCheck: match found, returning %dn", allow);
  1552.     aclCheckCallback(checklist, allow);
  1553.     return;
  1554. }
  1555. checklist->access_list = A->next;
  1556. /*
  1557.  * Lock the next _acl_access entry
  1558.  */
  1559. if (A->next)
  1560.     cbdataLock(A->next);
  1561.     }
  1562.     debug(28, 3) ("aclCheck: NO match found, returning %dn", !allow);
  1563.     aclCheckCallback(checklist, !allow);
  1564. }
  1566. void
  1567. aclChecklistFree(aclCheck_t * checklist)
  1568. {
  1569.     if (checklist->state[ACL_SRC_DOMAIN] == ACL_LOOKUP_PENDING)
  1570. fqdncacheUnregister(checklist->src_addr, checklist);
  1571.     if (checklist->state[ACL_DST_DOMAIN] == ACL_LOOKUP_PENDING)
  1572. fqdncacheUnregister(checklist->dst_addr, checklist);
  1573.     if (checklist->state[ACL_DST_IP] == ACL_LOOKUP_PENDING)
  1574. ipcacheUnregister(checklist->request->host, checklist);
  1575.     if (checklist->request)
  1576. requestUnlink(checklist->request);
  1577.     checklist->request = NULL;
  1578. #if USE_IDENT
  1579.     if (checklist->conn) {
  1580. cbdataUnlock(checklist->conn);
  1581. checklist->conn = NULL;
  1582.     }
  1583. #endif
  1584.     cbdataFree(checklist);
  1585. }
  1587. static void
  1588. aclCheckCallback(aclCheck_t * checklist, allow_t answer)
  1589. {
  1590.     debug(28, 3) ("aclCheckCallback: answer=%dn", answer);
  1591.     if (cbdataValid(checklist->callback_data))
  1592. checklist->callback(answer, checklist->callback_data);
  1593.     cbdataUnlock(checklist->callback_data);
  1594.     checklist->callback = NULL;
  1595.     checklist->callback_data = NULL;
  1596.     aclChecklistFree(checklist);
  1597. }
  1599. #if USE_IDENT
  1600. static void
  1601. aclLookupIdentDone(const char *ident, void *data)
  1602. {
  1603.     aclCheck_t *checklist = data;
  1604.     if (ident) {
  1605. xstrncpy(checklist->ident, ident, sizeof(checklist->ident));
  1606. xstrncpy(checklist->request->user_ident, ident, sizeof(checklist->request->user_ident));
  1607.     } else {
  1608. xstrncpy(checklist->ident, "-", sizeof(checklist->ident));
  1609.     }
  1610.     /*
  1611.      * Cache the ident result in the connection, to avoid redoing ident lookup
  1612.      * over and over on persistent connections
  1613.      */
  1614.     if (cbdataValid(checklist->conn) && !checklist->conn->ident[0])
  1615. xstrncpy(checklist->conn->ident, checklist->ident, sizeof(checklist->conn->ident));
  1616.     aclCheck(checklist);
  1617. }
  1618. #endif
  1620. static void
  1621. aclLookupDstIPDone(const ipcache_addrs * ia, void *data)
  1622. {
  1623.     aclCheck_t *checklist = data;
  1624.     checklist->state[ACL_DST_IP] = ACL_LOOKUP_DONE;
  1625.     aclCheck(checklist);
  1626. }
  1628. static void
  1629. aclLookupDstIPforASNDone(const ipcache_addrs * ia, void *data)
  1630. {
  1631.     aclCheck_t *checklist = data;
  1632.     checklist->state[ACL_DST_ASN] = ACL_LOOKUP_DONE;
  1633.     aclCheck(checklist);
  1634. }
  1636. static void
  1637. aclLookupSrcFQDNDone(const char *fqdn, void *data)
  1638. {
  1639.     aclCheck_t *checklist = data;
  1640.     checklist->state[ACL_SRC_DOMAIN] = ACL_LOOKUP_DONE;
  1641.     aclCheck(checklist);
  1642. }
  1644. static void
  1645. aclLookupDstFQDNDone(const char *fqdn, void *data)
  1646. {
  1647.     aclCheck_t *checklist = data;
  1648.     checklist->state[ACL_DST_DOMAIN] = ACL_LOOKUP_DONE;
  1649.     aclCheck(checklist);
  1650. }
  1652. static void
  1653. aclLookupProxyAuthDone(void *data, char *result)
  1654. {
  1655.     aclCheck_t *checklist = data;
  1656.     checklist->state[ACL_PROXY_AUTH] = ACL_LOOKUP_DONE;
  1657.     debug(28, 4) ("aclLookupProxyAuthDone: result = %sn",
  1658. result ? result : "NULL");
  1659.     if (result && (strncasecmp(result, "OK", 2) == 0))
  1660. checklist->auth_user->passwd_ok = 1;
  1661.     else
  1662. checklist->auth_user->passwd_ok = 0;
  1663.     aclCheck(checklist);
  1664. }
  1666. aclCheck_t *
  1667. aclChecklistCreate(const acl_access * A,
  1668.     request_t * request,
  1669.     struct in_addr src_addr,
  1670.     struct in_addr my_addr,
  1671.     const char *user_agent,
  1672.     const char *ident)
  1673. {
  1674.     int i;
  1675.     aclCheck_t *checklist = memAllocate(MEM_ACLCHECK_T);
  1676.     cbdataAdd(checklist, memFree, MEM_ACLCHECK_T);
  1677.     checklist->access_list = A;
  1678.     /*
  1679.      * aclCheck() makes sure checklist->access_list is a valid
  1680.      * pointer, so lock it.
  1681.      */
  1682.     cbdataLock(A);
  1683.     if (request != NULL)
  1684. checklist->request = requestLink(request);
  1685.     checklist->src_addr = src_addr;
  1686.     checklist->my_addr = my_addr;
  1687.     for (i = 0; i < ACL_ENUM_MAX; i++)
  1688. checklist->state[i] = ACL_LOOKUP_NONE;
  1689.     if (user_agent)
  1690. xstrncpy(checklist->browser, user_agent, BROWSERNAMELEN);
  1691. #if USE_IDENT
  1692.     if (ident)
  1693. xstrncpy(checklist->ident, ident, USER_IDENT_SZ);
  1694. #endif
  1695.     checklist->auth_user = NULL; /* init to NULL */
  1696.     return checklist;
  1697. }
  1699. void
  1700. aclNBCheck(aclCheck_t * checklist, PF callback, void *callback_data)
  1701. {
  1702.     checklist->callback = callback;
  1703.     checklist->callback_data = callback_data;
  1704.     cbdataLock(callback_data);
  1705.     aclCheck(checklist);
  1706. }
  1714. /*********************/
  1715. /* Destroy functions */
  1716. /*********************/
  1718. static void
  1719. aclDestroyTimeList(acl_time_data * data)
  1720. {
  1721.     acl_time_data *next = NULL;
  1722.     for (; data; data = next) {
  1723. next = data->next;
  1724. memFree(data, MEM_ACL_TIME_DATA);
  1725.     }
  1726. }
  1728. void
  1729. aclDestroyRegexList(relist * data)
  1730. {
  1731.     relist *next = NULL;
  1732.     for (; data; data = next) {
  1733. next = data->next;
  1734. regfree(&data->regex);
  1735. safe_free(data->pattern);
  1736. memFree(data, MEM_RELIST);
  1737.     }
  1738. }
  1740. static void
  1741. aclFreeProxyAuthUser(void *data)
  1742. {
  1743.     acl_proxy_auth_user *u = data;
  1744.     xfree(u->user);
  1745.     xfree(u->passwd);
  1746.     memFree(u, MEM_ACL_PROXY_AUTH_USER);
  1747. }
  1749. static void
  1750. aclFreeIpData(void *p)
  1751. {
  1752.     memFree(p, MEM_ACL_IP_DATA);
  1753. }
  1755. void
  1756. aclDestroyAcls(acl ** head)
  1757. {
  1758.     acl *a = NULL;
  1759.     acl *next = NULL;
  1760.     for (a = *head; a; a = next) {
  1761. next = a->next;
  1762. debug(28, 3) ("aclDestroyAcls: '%s'n", a->cfgline);
  1763. switch (a->type) {
  1764. case ACL_SRC_IP:
  1765. case ACL_DST_IP:
  1766. case ACL_MY_IP:
  1767.     splay_destroy(a->data, aclFreeIpData);
  1768.     break;
  1769. case ACL_SRC_ARP:
  1770. case ACL_DST_DOMAIN:
  1771. case ACL_SRC_DOMAIN:
  1772.     splay_destroy(a->data, xfree);
  1773.     break;
  1774. #if SQUID_SNMP
  1775. case ACL_SNMP_COMMUNITY:
  1776. #endif
  1777. #if USE_IDENT
  1778. case ACL_IDENT:
  1779. #endif
  1780. case ACL_PROXY_AUTH:
  1781.     wordlistDestroy((wordlist **) & a->data);
  1782.     break;
  1783. case ACL_TIME:
  1784.     aclDestroyTimeList(a->data);
  1785.     break;
  1786. case ACL_URL_REGEX:
  1787. case ACL_URLPATH_REGEX:
  1788. case ACL_BROWSER:
  1789.     aclDestroyRegexList(a->data);
  1790.     break;
  1791. case ACL_PROTO:
  1792. case ACL_METHOD:
  1793. case ACL_SRC_ASN:
  1794. case ACL_DST_ASN:
  1795.     intlistDestroy((intlist **) & a->data);
  1796.     break;
  1797. case ACL_URL_PORT:
  1798.     aclDestroyIntRange(a->data);
  1799.     break;
  1800. case ACL_NONE:
  1801. default:
  1802.     assert(0);
  1803.     break;
  1804. }
  1805. safe_free(a->cfgline);
  1806. memFree(a, MEM_ACL);
  1807.     }
  1808.     *head = NULL;
  1809. }
  1811. static void
  1812. aclDestroyAclList(acl_list * list)
  1813. {
  1814.     acl_list *next = NULL;
  1815.     for (; list; list = next) {
  1816. next = list->next;
  1817. memFree(list, MEM_ACL_LIST);
  1818.     }
  1819. }
  1821. void
  1822. aclDestroyAccessList(acl_access ** list)
  1823. {
  1824.     acl_access *l = NULL;
  1825.     acl_access *next = NULL;
  1826.     for (l = *list; l; l = next) {
  1827. debug(28, 3) ("aclDestroyAccessList: '%s'n", l->cfgline);
  1828. next = l->next;
  1829. aclDestroyAclList(l->acl_list);
  1830. l->acl_list = NULL;
  1831. safe_free(l->cfgline);
  1832. cbdataFree(l);
  1833.     }
  1834.     *list = NULL;
  1835. }
  1837. /* maex@space.net (06.09.1996)
  1838.  *    destroy an _acl_deny_info_list */
  1840. void
  1841. aclDestroyDenyInfoList(acl_deny_info_list ** list)
  1842. {
  1843.     acl_deny_info_list *a = NULL;
  1844.     acl_deny_info_list *a_next = NULL;
  1845.     acl_name_list *l = NULL;
  1846.     acl_name_list *l_next = NULL;
  1848.     for (a = *list; a; a = a_next) {
  1849. for (l = a->acl_list; l; l = l_next) {
  1850.     l_next = l->next;
  1851.     safe_free(l);
  1852. }
  1853. a_next = a->next;
  1854. xfree(a->err_page_name);
  1855. safe_free(a);
  1856.     }
  1857.     *list = NULL;
  1858. }
  1860. static void
  1861. aclDestroyIntRange(intrange * list)
  1862. {
  1863.     intrange *w = NULL;
  1864.     intrange *n = NULL;
  1865.     for (w = list; w; w = n) {
  1866. n = w->next;
  1867. safe_free(w);
  1868.     }
  1869. }
  1871. /* general compare functions, these are used for tree search algorithms
  1872.  * so they return <0, 0 or >0 */
  1874. /* compare two domains */
  1876. static int
  1877. aclDomainCompare(const void *data, splayNode * n)
  1878. {
  1879.     const char *d1 = data;
  1880.     const char *d2 = n->data;
  1881.     int l1 = strlen(d1);
  1882.     int l2 = strlen(d2);
  1883.     while (d1[l1] == d2[l2]) {
  1884. if ((l1 == 0) && (l2 == 0))
  1885.     return 0; /* d1 == d2 */
  1886. if (l1-- == 0)
  1887.     return -1; /* d1 < d2 */
  1888. if (l2-- == 0)
  1889.     return 1; /* d1 > d2 */
  1890.     }
  1891.     return (d1[l1] - d2[l2]);
  1892. }
  1894. /* compare a host and a domain */
  1896. static int
  1897. aclHostDomainCompare(const void *data, splayNode * n)
  1898. {
  1899.     const char *h = data;
  1900.     char *d = n->data;
  1901.     int l1;
  1902.     int l2;
  1903.     if (matchDomainName(d, h))
  1904. return 0;
  1905.     l1 = strlen(h);
  1906.     l2 = strlen(d);
  1907.     /* h != d */
  1908.     while (xtolower(h[l1]) == xtolower(d[l2])) {
  1909. if (l1 == 0)
  1910.     break;
  1911. if (l2 == 0)
  1912.     break;
  1913. l1--;
  1914. l2--;
  1915.     }
  1916.     /* a '.' is a special case */
  1917.     if ((h[l1] == '.') || (l1 == 0))
  1918. return -1; /* domain(h) < d */
  1919.     if ((d[l2] == '.') || (l2 == 0))
  1920. return 1; /* domain(h) > d */
  1921.     return (xtolower(h[l1]) - xtolower(d[l2]));
  1922. }
  1924. /* compare two network specs
  1925.  * 
  1926.  * NOTE: this is very similar to aclIpNetworkCompare and it's not yet
  1927.  * clear whether this OK. The problem could be with when a network
  1928.  * is a subset of the other networks:
  1929.  * 
  1930.  * 128.1.2.0/255.255.255.128 == 128.1.2.0/255.255.255.0 ?
  1931.  * 
  1932.  * Currently only the first address of the first network is used.
  1933.  */
  1935. /* compare an address and a network spec */
  1937. static int
  1938. aclIpNetworkCompare(const void *a, splayNode * n)
  1939. {
  1940.     struct in_addr A = *(struct in_addr *) a;
  1941.     acl_ip_data *q = n->data;
  1942.     struct in_addr B = q->addr1;
  1943.     struct in_addr C = q->addr2;
  1944.     int rc = 0;
  1945.     A.s_addr &= q->mask.s_addr; /* apply netmask */
  1946.     if (C.s_addr == 0) { /* single address check */
  1947. if (ntohl(A.s_addr) > ntohl(B.s_addr))
  1948.     rc = 1;
  1949. else if (ntohl(A.s_addr) < ntohl(B.s_addr))
  1950.     rc = -1;
  1951. else
  1952.     rc = 0;
  1953.     } else { /* range address check */
  1954. if (ntohl(A.s_addr) > ntohl(C.s_addr))
  1955.     rc = 1;
  1956. else if (ntohl(A.s_addr) < ntohl(B.s_addr))
  1957.     rc = -1;
  1958. else
  1959.     rc = 0;
  1960.     }
  1961.     return rc;
  1962. }
  1964. static void
  1965. aclDumpIpListWalkee(void *node, void *state)
  1966. {
  1967.     acl_ip_data *ip = node;
  1968.     MemBuf mb;
  1969.     wordlist **W = state;
  1970.     memBufDefInit(&mb);
  1971.     memBufPrintf(&mb, "%s", inet_ntoa(ip->addr1));
  1972.     if (ip->addr2.s_addr != any_addr.s_addr)
  1973. memBufPrintf(&mb, "-%s", inet_ntoa(ip->addr2));
  1974.     if (ip->mask.s_addr != no_addr.s_addr)
  1975. memBufPrintf(&mb, "/%s", inet_ntoa(ip->mask));
  1976.     wordlistAdd(W, mb.buf);
  1977.     memBufClean(&mb);
  1978. }
  1980. static wordlist *
  1981. aclDumpIpList(void *data)
  1982. {
  1983.     wordlist *w = NULL;
  1984.     splay_walk(data, aclDumpIpListWalkee, &w);
  1985.     return w;
  1986. }
  1988. static void
  1989. aclDumpDomainListWalkee(void *node, void *state)
  1990. {
  1991.     char *domain = node;
  1992.     wordlistAdd(state, domain);
  1993. }
  1995. static wordlist *
  1996. aclDumpDomainList(void *data)
  1997. {
  1998.     wordlist *w = NULL;
  1999.     splay_walk(data, aclDumpDomainListWalkee, &w);
  2000.     return w;
  2001. }
  2003. static wordlist *
  2004. aclDumpTimeSpecList(acl_time_data * t)
  2005. {
  2006.     wordlist *W = NULL;
  2007.     char buf[128];
  2008.     while (t != NULL) {
  2009. snprintf(buf, sizeof(buf), "%c%c%c%c%c%c%c %02d:%02d-%02d:%02d",
  2010.     t->weekbits & ACL_SUNDAY ? 'S' : '-',
  2011.     t->weekbits & ACL_MONDAY ? 'M' : '-',
  2012.     t->weekbits & ACL_TUESDAY ? 'T' : '-',
  2013.     t->weekbits & ACL_WEDNESDAY ? 'W' : '-',
  2014.     t->weekbits & ACL_THURSDAY ? 'H' : '-',
  2015.     t->weekbits & ACL_FRIDAY ? 'F' : '-',
  2016.     t->weekbits & ACL_SATURDAY ? 'A' : '-',
  2017.     t->start / 60,
  2018.     t->start % 60,
  2019.     t->stop / 60,
  2020.     t->stop % 60);
  2021. wordlistAdd(&W, buf);
  2022. t = t->next;
  2023.     }
  2024.     return W;
  2025. }
  2027. static wordlist *
  2028. aclDumpRegexList(relist * data)
  2029. {
  2030.     wordlist *W = NULL;
  2031.     while (data != NULL) {
  2032. wordlistAdd(&W, data->pattern);
  2033. data = data->next;
  2034.     }
  2035.     return W;
  2036. }
  2038. static wordlist *
  2039. aclDumpIntlistList(intlist * data)
  2040. {
  2041.     wordlist *W = NULL;
  2042.     char buf[32];
  2043.     while (data != NULL) {
  2044. snprintf(buf, sizeof(buf), "%d", data->i);
  2045. wordlistAdd(&W, buf);
  2046. data = data->next;
  2047.     }
  2048.     return W;
  2049. }
  2051. static wordlist *
  2052. aclDumpIntRangeList(intrange * data)
  2053. {
  2054.     wordlist *W = NULL;
  2055.     char buf[32];
  2056.     while (data != NULL) {
  2057. if (data->i == data->j)
  2058.     snprintf(buf, sizeof(buf), "%d", data->i);
  2059. else
  2060.     snprintf(buf, sizeof(buf), "%d-%d", data->i, data->j);
  2061. wordlistAdd(&W, buf);
  2062. data = data->next;
  2063.     }
  2064.     return W;
  2065. }
  2067. static wordlist *
  2068. aclDumpProtoList(intlist * data)
  2069. {
  2070.     wordlist *W = NULL;
  2071.     while (data != NULL) {
  2072. wordlistAdd(&W, ProtocolStr[data->i]);
  2073. data = data->next;
  2074.     }
  2075.     return W;
  2076. }
  2078. static wordlist *
  2079. aclDumpMethodList(intlist * data)
  2080. {
  2081.     wordlist *W = NULL;
  2082.     while (data != NULL) {
  2083. wordlistAdd(&W, RequestMethodStr[data->i]);
  2084. data = data->next;
  2085.     }
  2086.     return W;
  2087. }
  2089. wordlist *
  2090. aclDumpGeneric(const acl * a)
  2091. {
  2092.     debug(28, 3) ("aclDumpGeneric: %s type %dn", a->name, a->type);
  2093.     switch (a->type) {
  2094.     case ACL_SRC_IP:
  2095.     case ACL_DST_IP:
  2096.     case ACL_MY_IP:
  2097. return aclDumpIpList(a->data);
  2098. break;
  2099.     case ACL_SRC_DOMAIN:
  2100.     case ACL_DST_DOMAIN:
  2101. #if SQUID_SNMP
  2102.     case ACL_SNMP_COMMUNITY:
  2103. #endif
  2104. #if USE_IDENT
  2105.     case ACL_IDENT:
  2106. #endif
  2107.     case ACL_PROXY_AUTH:
  2108. return aclDumpDomainList(a->data);
  2109. break;
  2110.     case ACL_TIME:
  2111. return aclDumpTimeSpecList(a->data);
  2112. break;
  2113.     case ACL_URL_REGEX:
  2114.     case ACL_URLPATH_REGEX:
  2115.     case ACL_BROWSER:
  2116. return aclDumpRegexList(a->data);
  2117. break;
  2118.     case ACL_SRC_ASN:
  2119.     case ACL_DST_ASN:
  2120. return aclDumpIntlistList(a->data);
  2121. break;
  2122.     case ACL_URL_PORT:
  2123. return aclDumpIntRangeList(a->data);
  2124. break;
  2125.     case ACL_PROTO:
  2126. return aclDumpProtoList(a->data);
  2127. break;
  2128.     case ACL_METHOD:
  2129. return aclDumpMethodList(a->data);
  2130. break;
  2131. #if USE_ARP_ACL
  2132.     case ACL_SRC_ARP:
  2133. return aclDumpArpList(a->data);
  2134. break;
  2135. #endif
  2136.     case ACL_NONE:
  2137.     default:
  2138. break;
  2139.     }
  2140.     return NULL;
  2141. }
  2146. #if USE_ARP_ACL
  2147. /* ==== BEGIN ARP ACL SUPPORT ============================================= */
  2149. /*
  2150.  * From:    dale@server.ctam.bitmcnit.bryansk.su (Dale)
  2151.  * To:      wessels@nlanr.net
  2152.  * Subject: Another Squid patch... :)
  2153.  * Date:    Thu, 04 Dec 1997 19:55:01 +0300
  2154.  * ============================================================================
  2155.  * 
  2156.  * Working on setting up a proper firewall for a network containing some
  2157.  * Win'95 computers at our Univ, I've discovered that some smart students
  2158.  * avoid the restrictions easily just changing their IP addresses in Win'95
  2159.  * Contol Panel... It has been getting boring, so I took Squid-1.1.18
  2160.  * sources and added a new acl type for hard-wired access control:
  2161.  * 
  2162.  * acl <name> arp <Ethernet address> ...
  2163.  * 
  2164.  * For example,
  2165.  * 
  2166.  * acl students arp 00:00:21:55:ed:22 00:00:21:ff:55:38
  2167.  *
  2168.  * NOTE: Linux code by David Luyer <luyer@ucs.uwa.edu.au>.
  2169.  *       Original (BSD-specific) code no longer works.
  2170.  */
  2172. #include <sys/sysctl.h>
  2173. #ifdef _SQUID_LINUX_
  2174. #include <net/if_arp.h>
  2175. #include <sys/ioctl.h>
  2176. #else
  2177. #include <net/if_dl.h>
  2178. #endif
  2179. #include <net/route.h>
  2180. #include <net/if.h>
  2181. #include <netinet/if_ether.h>
  2183. /*
  2184.  * Decode an ascii representation (asc) of an ethernet adress, and place
  2185.  * it in eth[6].
  2186.  */
  2187. static int
  2188. decode_eth(const char *asc, char *eth)
  2189. {
  2190.     int a1 = 0, a2 = 0, a3 = 0, a4 = 0, a5 = 0, a6 = 0;
  2191.     if (sscanf(asc, "%x:%x:%x:%x:%x:%x", &a1, &a2, &a3, &a4, &a5, &a6) != 6) {
  2192. debug(28, 0) ("decode_eth: Invalid ethernet address '%s'n", asc);
  2193. return 0; /* This is not valid address */
  2194.     }
  2195.     eth[0] = (u_char) a1;
  2196.     eth[1] = (u_char) a2;
  2197.     eth[2] = (u_char) a3;
  2198.     eth[3] = (u_char) a4;
  2199.     eth[4] = (u_char) a5;
  2200.     eth[5] = (u_char) a6;
  2201.     return 1;
  2202. }
  2204. static acl_arp_data *
  2205. aclParseArpData(const char *t)
  2206. {
  2207.     LOCAL_ARRAY(char, eth, 256);
  2208.     acl_arp_data *q = xcalloc(1, sizeof(acl_arp_data));
  2209.     debug(28, 5) ("aclParseArpData: %sn", t);
  2210.     if (sscanf(t, "%[0-9a-fA-F:]", eth) != 1) {
  2211. debug(28, 0) ("aclParseArpData: Bad ethernet address: '%s'n", t);
  2212. safe_free(q);
  2213. return NULL;
  2214.     }
  2215.     if (!decode_eth(eth, q->eth)) {
  2216. debug(28, 0) ("%s line %d: %sn",
  2217.     cfg_filename, config_lineno, config_input_line);
  2218. debug(28, 0) ("aclParseArpData: Ignoring invalid ARP acl entry: can't parse '%s'n", eth);
  2219. safe_free(q);
  2220. return NULL;
  2221.     }
  2222.     return q;
  2223. }
  2226. /*******************/
  2227. /* aclParseArpList */
  2228. /*******************/
  2229. static void
  2230. aclParseArpList(void *curlist)
  2231. {
  2232.     char *t = NULL;
  2233.     splayNode **Top = curlist;
  2234.     acl_arp_data *q = NULL;
  2235.     while ((t = strtokFile())) {
  2236. if ((q = aclParseArpData(t)) == NULL)
  2237.     continue;
  2238. *Top = splay_insert(q, *Top, aclArpCompare);
  2239.     }
  2240. }
  2242. /***************/
  2243. /* aclMatchArp */
  2244. /***************/
  2245. #ifdef _SQUID_LINUX_
  2246. static int
  2247. aclMatchArp(void *dataptr, struct in_addr c)
  2248. {
  2249.     struct arpreq arpReq;
  2250.     struct sockaddr_in ipAddr;
  2251.     splayNode **Top = dataptr;
  2252.     ipAddr.sin_family = AF_INET;
  2253.     ipAddr.sin_port = 0;
  2254.     ipAddr.sin_addr = c;
  2255.     memcpy(&arpReq.arp_pa, &ipAddr, sizeof(struct sockaddr_in));
  2256.     arpReq.arp_dev[0] = '';
  2257.     arpReq.arp_flags = 0;
  2258.     /* any AF_INET socket will do... gives back hardware type, device, etc */
  2259.     if (ioctl(HttpSockets[0], SIOCGARP, &arpReq) == -1) {
  2260. debug(28, 1) ("ARP query failed - %d", errno);
  2261. return 0;
  2262.     } else if (arpReq.arp_ha.sa_family != ARPHRD_ETHER) {
  2263. debug(28, 1) ("Non-ethernet interface returned from ARP query - %d",
  2264.     arpReq.arp_ha.sa_family);
  2265. /* update here and MAC address parsing to handle non-ethernet */
  2266. return 0;
  2267.     } else
  2268. *Top = splay_splay(&arpReq.arp_ha.sa_data, *Top, aclArpCompare);
  2269.     debug(28, 3) ("aclMatchArp: '%s' %sn",
  2270. inet_ntoa(c), splayLastResult ? "NOT found" : "found");
  2271.     return !splayLastResult;
  2272. }
  2274. static int
  2275. aclArpCompare(const void *data, splayNode * n)
  2276. {
  2277.     const unsigned short *d1 = data;
  2278.     const unsigned short *d2 = n->data;
  2279.     if (d1[0] != d2[0])
  2280. return (d1[0] > d2[0]) ? 1 : -1;
  2281.     if (d1[1] != d2[1])
  2282. return (d1[1] > d2[1]) ? 1 : -1;
  2283.     if (d1[2] != d2[2])
  2284. return (d1[2] > d2[2]) ? 1 : -1;
  2285.     return 0;
  2286. }
  2287. #else
  2289. static int
  2290. aclMatchArp(void *dataptr, struct in_addr c)
  2291. {
  2292.     WRITE ME;
  2293. }
  2295. static int
  2296. aclArpCompare(const void *data, splayNode * n)
  2297. {
  2298.     WRITE ME;
  2299. }
  2301. /**********************************************************************
  2302. * This is from the pre-splay-tree code for BSD
  2303. * I suspect the Linux approach will work on most O/S and be much
  2304. * better - <luyer@ucs.uwa.edu.au>
  2305. ***********************************************************************
  2306. static int
  2307. checkARP(u_long ip, char *eth)
  2308. {
  2309.     int mib[6] =
  2310.     {CTL_NET, PF_ROUTE, 0, AF_INET, NET_RT_FLAGS, RTF_LLINFO};
  2311.     size_t needed;
  2312.     char *buf, *next, *lim;
  2313.     struct rt_msghdr *rtm;
  2314.     struct sockaddr_inarp *sin;
  2315.     struct sockaddr_dl *sdl;
  2316.     if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0) {
  2317. debug(28, 0) ("Can't estimate ARP table size!n");
  2318. return 0;
  2319.     }
  2320.     if ((buf = xmalloc(needed)) == NULL) {
  2321. debug(28, 0) ("Can't allocate temporary ARP table!n");
  2322. return 0;
  2323.     }
  2324.     if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0) {
  2325. debug(28, 0) ("Can't retrieve ARP table!n");
  2326. xfree(buf);
  2327. return 0;
  2328.     }
  2329.     lim = buf + needed;
  2330.     for (next = buf; next < lim; next += rtm->rtm_msglen) {
  2331. rtm = (struct rt_msghdr *) next;
  2332. sin = (struct sockaddr_inarp *) (rtm + 1);
  2333. sdl = (struct sockaddr_dl *) (sin + 1);
  2334. if (sin->sin_addr.s_addr == ip) {
  2335.     if (sdl->sdl_alen)
  2336. if (!memcmp(LLADDR(sdl), eth, 6)) {
  2337.     xfree(buf);
  2338.     return 1;
  2339. }
  2340.     break;
  2341. }
  2342.     }
  2343.     xfree(buf);
  2344.     return 0;
  2345. }
  2346. **********************************************************************/
  2347. #endif
  2349. static void
  2350. aclDumpArpListWalkee(void *node, void *state)
  2351. {
  2352.     acl_arp_data *arp = node;
  2353.     wordlist **W = state;
  2354.     static char buf[24];
  2355.     while (*W != NULL)
  2356. W = &(*W)->next;
  2357.     snprintf(buf, sizeof(buf), "%02x:%02x:02x:02x:02x:02x",
  2358. arp->eth[0], arp->eth[1], arp->eth[2], arp->eth[3],
  2359. arp->eth[4], arp->eth[5]);
  2360.     wordlistAdd(state, buf);
  2361. }
  2363. static wordlist *
  2364. aclDumpArpList(void *data)
  2365. {
  2366.     wordlist *w = NULL;
  2367.     splay_walk(data, aclDumpArpListWalkee, &w);
  2368.     return w;
  2369. }
  2371. /* ==== END ARP ACL SUPPORT =============================================== */
  2372. #endif /* USE_ARP_ACL */