1 const char urlmatch_rcs[] = "$Id: urlmatch.c,v 1.75 2012/12/07 12:49:47 fabiankeil Exp $";
2 /*********************************************************************
4 * File : $Source: /cvsroot/ijbswa/current/urlmatch.c,v $
6 * Purpose : Declares functions to match URLs against URL
9 * Copyright : Written by and Copyright (C) 2001-2011
10 * the Privoxy team. http://www.privoxy.org/
12 * Based on the Internet Junkbuster originally written
13 * by and Copyright (C) 1997 Anonymous Coders and
14 * Junkbusters Corporation. http://www.junkbusters.com
16 * This program is free software; you can redistribute it
17 * and/or modify it under the terms of the GNU General
18 * Public License as published by the Free Software
19 * Foundation; either version 2 of the License, or (at
20 * your option) any later version.
22 * This program is distributed in the hope that it will
23 * be useful, but WITHOUT ANY WARRANTY; without even the
24 * implied warranty of MERCHANTABILITY or FITNESS FOR A
25 * PARTICULAR PURPOSE. See the GNU General Public
26 * License for more details.
28 * The GNU General Public License should be included with
29 * this file. If not, you can view it at
30 * http://www.gnu.org/copyleft/gpl.html
31 * or write to the Free Software Foundation, Inc., 59
32 * Temple Place - Suite 330, Boston, MA 02111-1307, USA.
34 *********************************************************************/
41 #include <sys/types.h>
49 #if !defined(_WIN32) && !defined(__OS2__)
59 const char urlmatch_h_rcs[] = URLMATCH_H_VERSION;
68 static jb_err compile_host_pattern(struct pattern_spec *url, const char *host_pattern);
70 /*********************************************************************
72 * Function : free_http_request
74 * Description : Freez a http_request structure
77 * 1 : http = points to a http_request structure to free
81 *********************************************************************/
82 void free_http_request(struct http_request *http)
91 freez(http->hostport);
94 freez(http->host_ip_addr_str);
95 #ifndef FEATURE_EXTENDED_HOST_PATTERNS
103 #ifndef FEATURE_EXTENDED_HOST_PATTERNS
104 /*********************************************************************
106 * Function : init_domain_components
108 * Description : Splits the domain name so we can compare it
109 * against wildcards. It used to be part of
110 * parse_http_url, but was separated because the
111 * same code is required in chat in case of
112 * intercepted requests.
115 * 1 : http = pointer to the http structure to hold elements.
117 * Returns : JB_ERR_OK on success
118 * JB_ERR_PARSE on malformed command/URL
119 * or >100 domains deep.
121 *********************************************************************/
122 jb_err init_domain_components(struct http_request *http)
124 char *vec[BUFFER_SIZE];
128 http->dbuffer = strdup_or_die(http->host);
130 /* map to lower case */
131 for (p = http->dbuffer; *p ; p++)
133 *p = (char)privoxy_tolower(*p);
136 /* split the domain name into components */
137 http->dcount = ssplit(http->dbuffer, ".", vec, SZ(vec));
139 if (http->dcount <= 0)
142 * Error: More than SZ(vec) components in domain
143 * or: no components in domain
145 log_error(LOG_LEVEL_ERROR, "More than SZ(vec) components in domain or none at all.");
149 /* save a copy of the pointers in dvec */
150 size = (size_t)http->dcount * sizeof(*http->dvec);
152 http->dvec = malloc_or_die(size);
154 memcpy(http->dvec, vec, size);
158 #endif /* ndef FEATURE_EXTENDED_HOST_PATTERNS */
161 /*********************************************************************
163 * Function : url_requires_percent_encoding
165 * Description : Checks if an URL contains invalid characters
166 * according to RFC 3986 that should be percent-encoded.
167 * Does not verify whether or not the passed string
168 * actually is a valid URL.
171 * 1 : url = URL to check
173 * Returns : True in case of valid URLs, false otherwise
175 *********************************************************************/
176 int url_requires_percent_encoding(const char *url)
178 static const char allowed_characters[128] = {
179 '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
180 '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
181 '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
182 '\0', '\0', '\0', '!', '\0', '#', '$', '%', '&', '\'',
183 '(', ')', '*', '+', ',', '-', '.', '/', '0', '1',
184 '2', '3', '4', '5', '6', '7', '8', '9', ':', ';',
185 '\0', '=', '\0', '?', '@', 'A', 'B', 'C', 'D', 'E',
186 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
187 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y',
188 'Z', '[', '\0', ']', '\0', '_', '\0', 'a', 'b', 'c',
189 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
190 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
191 'x', 'y', 'z', '\0', '\0', '\0', '~', '\0'
196 const unsigned int i = (unsigned char)*url++;
197 if (i >= sizeof(allowed_characters) || '\0' == allowed_characters[i])
208 /*********************************************************************
210 * Function : parse_http_url
212 * Description : Parse out the host and port from the URL. Find the
213 * hostname & path, port (if ':'), and/or password (if '@')
216 * 1 : url = URL (or is it URI?) to break down
217 * 2 : http = pointer to the http structure to hold elements.
218 * Must be initialized with valid values (like NULLs).
219 * 3 : require_protocol = Whether or not URLs without
220 * protocol are acceptable.
222 * Returns : JB_ERR_OK on success
223 * JB_ERR_PARSE on malformed command/URL
224 * or >100 domains deep.
226 *********************************************************************/
227 jb_err parse_http_url(const char *url, struct http_request *http, int require_protocol)
229 int host_available = 1; /* A proxy can dream. */
232 * Save our initial URL
234 http->url = strdup_or_die(url);
237 * Check for * URI. If found, we're done.
239 if (*http->url == '*')
241 http->path = strdup_or_die("*");
242 http->hostport = strdup_or_die("");
243 if (http->url[1] != '\0')
252 * Split URL into protocol,hostport,path.
259 buf = strdup_or_die(url);
261 /* Find the start of the URL in our scratch space */
263 if (strncmpic(url_noproto, "http://", 7) == 0)
267 else if (strncmpic(url_noproto, "https://", 8) == 0)
270 * Should only happen when called from cgi_show_url_info().
275 else if (*url_noproto == '/')
278 * Short request line without protocol and host.
279 * Most likely because the client's request
280 * was intercepted and redirected into Privoxy.
285 else if (require_protocol)
291 url_path = strchr(url_noproto, '/');
292 if (url_path != NULL)
297 * NOTE: The following line ignores the path for HTTPS URLS.
298 * This means that you get consistent behaviour if you type a
299 * https URL in and it's parsed by the function. (When the
300 * URL is actually retrieved, SSL hides the path part).
302 http->path = strdup_or_die(http->ssl ? "/" : url_path);
304 http->hostport = strdup_or_die(url_noproto);
309 * Repair broken HTTP requests that don't contain a path,
310 * or CONNECT requests
312 http->path = strdup_or_die("/");
313 http->hostport = strdup_or_die(url_noproto);
321 /* Without host, there is nothing left to do here */
326 * Split hostport into user/password (ignored), host, port.
333 buf = strdup_or_die(http->hostport);
335 /* check if url contains username and/or password */
336 host = strchr(buf, '@');
339 /* Contains username/password, skip it and the @ sign. */
344 /* No username or password. */
348 /* Move after hostname before port number */
351 /* Numeric IPv6 address delimited by brackets */
353 port = strchr(host, ']');
357 /* Missing closing bracket */
368 else if (*port != ':')
370 /* Garbage after closing bracket */
377 /* Plain non-escaped hostname */
378 port = strchr(host, ':');
381 /* check if url contains port */
387 /* Terminate hostname and point to start of port string */
389 parsed_port = strtol(port, &endptr, 10);
390 if ((parsed_port <= 0) || (parsed_port > 65535) || (*endptr != '\0'))
392 log_error(LOG_LEVEL_ERROR, "Invalid port in URL: %s.", url);
396 http->port = (int)parsed_port;
400 /* No port specified. */
401 http->port = (http->ssl ? 443 : 80);
404 http->host = strdup_or_die(host);
409 #ifdef FEATURE_EXTENDED_HOST_PATTERNS
412 /* Split domain name so we can compare it against wildcards */
413 return init_domain_components(http);
414 #endif /* def FEATURE_EXTENDED_HOST_PATTERNS */
419 /*********************************************************************
421 * Function : unknown_method
423 * Description : Checks whether a method is unknown.
426 * 1 : method = points to a http method
428 * Returns : TRUE if it's unknown, FALSE otherwise.
430 *********************************************************************/
431 static int unknown_method(const char *method)
433 static const char * const known_http_methods[] = {
434 /* Basic HTTP request type */
435 "GET", "HEAD", "POST", "PUT", "DELETE", "OPTIONS", "TRACE", "CONNECT",
436 /* webDAV extensions (RFC2518) */
437 "PROPFIND", "PROPPATCH", "MOVE", "COPY", "MKCOL", "LOCK", "UNLOCK",
439 * Microsoft webDAV extension for Exchange 2000. See:
440 * http://lists.w3.org/Archives/Public/w3c-dist-auth/2002JanMar/0001.html
441 * http://msdn.microsoft.com/library/en-us/wss/wss/_webdav_methods.asp
443 "BCOPY", "BMOVE", "BDELETE", "BPROPFIND", "BPROPPATCH",
445 * Another Microsoft webDAV extension for Exchange 2000. See:
446 * http://systems.cs.colorado.edu/grunwald/MobileComputing/Papers/draft-cohen-gena-p-base-00.txt
447 * http://lists.w3.org/Archives/Public/w3c-dist-auth/2002JanMar/0001.html
448 * http://msdn.microsoft.com/library/en-us/wss/wss/_webdav_methods.asp
450 "SUBSCRIBE", "UNSUBSCRIBE", "NOTIFY", "POLL",
452 * Yet another WebDAV extension, this time for
453 * Web Distributed Authoring and Versioning (RFC3253)
455 "VERSION-CONTROL", "REPORT", "CHECKOUT", "CHECKIN", "UNCHECKOUT",
456 "MKWORKSPACE", "UPDATE", "LABEL", "MERGE", "BASELINE-CONTROL", "MKACTIVITY",
460 for (i = 0; i < SZ(known_http_methods); i++)
462 if (0 == strcmpic(method, known_http_methods[i]))
473 /*********************************************************************
475 * Function : parse_http_request
477 * Description : Parse out the host and port from the URL. Find the
478 * hostname & path, port (if ':'), and/or password (if '@')
481 * 1 : req = HTTP request line to break down
482 * 2 : http = pointer to the http structure to hold elements
484 * Returns : JB_ERR_OK on success
485 * JB_ERR_CGI_PARAMS on malformed command/URL
486 * or >100 domains deep.
488 *********************************************************************/
489 jb_err parse_http_request(const char *req, struct http_request *http)
492 char *v[10]; /* XXX: Why 10? We should only need three. */
496 memset(http, '\0', sizeof(*http));
498 buf = strdup_or_die(req);
500 n = ssplit(buf, " \r\n", v, SZ(v));
508 * Fail in case of unknown methods
509 * which we might not handle correctly.
511 * XXX: There should be a config option
512 * to forward requests with unknown methods
513 * anyway. Most of them don't need special
516 if (unknown_method(v[0]))
518 log_error(LOG_LEVEL_ERROR, "Unknown HTTP method detected: %s", v[0]);
523 if (strcmpic(v[2], "HTTP/1.1") && strcmpic(v[2], "HTTP/1.0"))
525 log_error(LOG_LEVEL_ERROR, "The only supported HTTP "
526 "versions are 1.0 and 1.1. This rules out: %s", v[2]);
531 http->ssl = !strcmpic(v[0], "CONNECT");
533 err = parse_http_url(v[1], http, !http->ssl);
541 * Copy the details into the structure
543 http->cmd = strdup_or_die(req);
544 http->gpc = strdup_or_die(v[0]);
545 http->ver = strdup_or_die(v[2]);
554 /*********************************************************************
556 * Function : compile_pattern
558 * Description : Compiles a host, domain or TAG pattern.
561 * 1 : pattern = The pattern to compile.
562 * 2 : anchoring = How the regex should be modified
563 * before compilation. Can be either
564 * one of NO_ANCHORING, LEFT_ANCHORED,
565 * RIGHT_ANCHORED or RIGHT_ANCHORED_HOST.
566 * 3 : url = In case of failures, the spec member is
567 * logged and the structure freed.
568 * 4 : regex = Where the compiled regex should be stored.
570 * Returns : JB_ERR_OK - Success
571 * JB_ERR_MEMORY - Out of memory
572 * JB_ERR_PARSE - Cannot parse regex
574 *********************************************************************/
575 static jb_err compile_pattern(const char *pattern, enum regex_anchoring anchoring,
576 struct pattern_spec *url, regex_t **regex)
579 char rebuf[BUFFER_SIZE];
580 const char *fmt = NULL;
583 assert(strlen(pattern) < sizeof(rebuf) - 2);
585 if (pattern[0] == '\0')
599 case RIGHT_ANCHORED_HOST:
606 log_error(LOG_LEVEL_FATAL,
607 "Invalid anchoring in compile_pattern %d", anchoring);
610 *regex = zalloc(sizeof(**regex));
614 return JB_ERR_MEMORY;
617 snprintf(rebuf, sizeof(rebuf), fmt, pattern);
619 errcode = regcomp(*regex, rebuf, (REG_EXTENDED|REG_NOSUB|REG_ICASE));
623 size_t errlen = regerror(errcode, *regex, rebuf, sizeof(rebuf));
624 if (errlen > (sizeof(rebuf) - (size_t)1))
626 errlen = sizeof(rebuf) - (size_t)1;
628 rebuf[errlen] = '\0';
629 log_error(LOG_LEVEL_ERROR, "error compiling %s from %s: %s",
630 pattern, url->spec, rebuf);
641 /*********************************************************************
643 * Function : compile_url_pattern
645 * Description : Compiles the three parts of an URL pattern.
648 * 1 : url = Target pattern_spec to be filled in.
649 * 2 : buf = The url pattern to compile. Will be messed up.
651 * Returns : JB_ERR_OK - Success
652 * JB_ERR_MEMORY - Out of memory
653 * JB_ERR_PARSE - Cannot parse regex
655 *********************************************************************/
656 static jb_err compile_url_pattern(struct pattern_spec *url, char *buf)
660 p = strchr(buf, '/');
664 * Only compile the regex if it consists of more than
665 * a single slash, otherwise it wouldn't affect the result.
670 * XXX: does it make sense to compile the slash at the beginning?
672 jb_err err = compile_pattern(p, LEFT_ANCHORED, url, &url->pattern.url_spec.preg);
674 if (JB_ERR_OK != err)
683 * IPv6 numeric hostnames can contain colons, thus we need
684 * to delimit the hostname before the real port separator.
685 * As brackets are already used in the hostname pattern,
686 * we use angle brackets ('<', '>') instead.
688 if ((buf[0] == '<') && (NULL != (p = strchr(buf + 1, '>'))))
695 /* IPv6 address without port number */
700 /* Garbage after address delimiter */
706 p = strchr(buf, ':');
712 url->pattern.url_spec.port_list = strdup_or_die(p);
716 url->pattern.url_spec.port_list = NULL;
721 return compile_host_pattern(url, buf);
729 #ifdef FEATURE_EXTENDED_HOST_PATTERNS
730 /*********************************************************************
732 * Function : compile_host_pattern
734 * Description : Parses and compiles a host pattern.
737 * 1 : url = Target pattern_spec to be filled in.
738 * 2 : host_pattern = Host pattern to compile.
740 * Returns : JB_ERR_OK - Success
741 * JB_ERR_MEMORY - Out of memory
742 * JB_ERR_PARSE - Cannot parse regex
744 *********************************************************************/
745 static jb_err compile_host_pattern(struct pattern_spec *url, const char *host_pattern)
747 return compile_pattern(host_pattern, RIGHT_ANCHORED_HOST, url, &url->pattern.url_spec.host_regex);
752 /*********************************************************************
754 * Function : compile_host_pattern
756 * Description : Parses and "compiles" an old-school host pattern.
759 * 1 : url = Target pattern_spec to be filled in.
760 * 2 : host_pattern = Host pattern to parse.
762 * Returns : JB_ERR_OK - Success
763 * JB_ERR_PARSE - Cannot parse regex
765 *********************************************************************/
766 static jb_err compile_host_pattern(struct pattern_spec *url, const char *host_pattern)
775 if (host_pattern[strlen(host_pattern) - 1] == '.')
777 url->unanchored |= ANCHOR_RIGHT;
779 if (host_pattern[0] == '.')
781 url->unanchored |= ANCHOR_LEFT;
785 * Split domain into components
787 url->dbuffer = strdup_or_die(host_pattern);
792 for (p = url->dbuffer; *p ; p++)
794 *p = (char)privoxy_tolower(*p);
798 * Split the domain name into components
800 url->dcount = ssplit(url->dbuffer, ".", v, SZ(v));
807 else if (url->dcount != 0)
810 * Save a copy of the pointers in dvec
812 size = (size_t)url->dcount * sizeof(*url->dvec);
814 url->dvec = malloc_or_die(size);
816 memcpy(url->dvec, v, size);
819 * else dcount == 0 in which case we needn't do anything,
820 * since dvec will never be accessed and the pattern will
827 /*********************************************************************
829 * Function : simplematch
831 * Description : String matching, with a (greedy) '*' wildcard that
832 * stands for zero or more arbitrary characters and
833 * character classes in [], which take both enumerations
837 * 1 : pattern = pattern for matching
838 * 2 : text = text to be matched
840 * Returns : 0 if match, else nonzero
842 *********************************************************************/
843 static int simplematch(const char *pattern, const char *text)
845 const unsigned char *pat = (const unsigned char *)pattern;
846 const unsigned char *txt = (const unsigned char *)text;
847 const unsigned char *fallback = pat;
850 unsigned char lastchar = 'a';
852 unsigned char charmap[32];
857 /* EOF pattern but !EOF text? */
870 /* '*' in the pattern? */
874 /* The pattern ends afterwards? Speed up the return. */
880 /* Else, set wildcard mode and remember position after '*' */
885 /* Character range specification? */
888 memset(charmap, '\0', sizeof(charmap));
890 while (*++pat != ']')
896 else if (*pat == '-')
898 if ((*++pat == ']') || *pat == '\0')
902 for (i = lastchar; i <= *pat; i++)
904 charmap[i / 8] |= (unsigned char)(1 << (i % 8));
909 charmap[*pat / 8] |= (unsigned char)(1 << (*pat % 8));
913 } /* -END- if Character range specification */
917 * Char match, or char range match?
921 || ((*pat == ']') && (charmap[*txt / 8] & (1 << (*txt % 8)))))
931 * No match && no wildcard: No luck
935 else if (pat != fallback)
938 * Increment text pointer if in char range matching
945 * Wildcard mode && nonmatch beyond fallback: Rewind pattern
949 * Restart matching from current text pointer
956 /* Cut off extra '*'s */
957 if (*pat == '*') pat++;
959 /* If this is the pattern's end, fine! */
965 /*********************************************************************
967 * Function : simple_domaincmp
969 * Description : Domain-wise Compare fqdn's. The comparison is
970 * both left- and right-anchored. The individual
971 * domain names are compared with simplematch().
972 * This is only used by domain_match.
975 * 1 : pv = array of patterns to compare
976 * 2 : fv = array of domain components to compare
977 * 3 : len = length of the arrays (both arrays are the
978 * same length - if they weren't, it couldn't
979 * possibly be a match).
981 * Returns : 0 => domains are equivalent, else no match.
983 *********************************************************************/
984 static int simple_domaincmp(char **pv, char **fv, int len)
988 for (n = 0; n < len; n++)
990 if (simplematch(pv[n], fv[n]))
1001 /*********************************************************************
1003 * Function : domain_match
1005 * Description : Domain-wise Compare fqdn's. Governed by the bimap in
1006 * pattern->unachored, the comparison is un-, left-,
1007 * right-anchored, or both.
1008 * The individual domain names are compared with
1012 * 1 : pattern = a domain that may contain a '*' as a wildcard.
1013 * 2 : fqdn = domain name against which the patterns are compared.
1015 * Returns : 0 => domains are equivalent, else no match.
1017 *********************************************************************/
1018 static int domain_match(const struct pattern_spec *pattern, const struct http_request *fqdn)
1020 char **pv, **fv; /* vectors */
1022 int unanchored = pattern->unanchored & (ANCHOR_RIGHT | ANCHOR_LEFT);
1024 plen = pattern->dcount;
1025 flen = fqdn->dcount;
1029 /* fqdn is too short to match this pattern */
1036 if (unanchored == ANCHOR_LEFT)
1041 * Convert this into a fully anchored pattern with
1042 * the fqdn and pattern the same length
1044 fv += (flen - plen); /* flen - plen >= 0 due to check above */
1045 return simple_domaincmp(pv, fv, plen);
1047 else if (unanchored == 0)
1049 /* Fully anchored, check length */
1054 return simple_domaincmp(pv, fv, plen);
1056 else if (unanchored == ANCHOR_RIGHT)
1058 /* Left anchored, ignore all extra in fqdn */
1059 return simple_domaincmp(pv, fv, plen);
1065 int maxn = flen - plen;
1066 for (n = 0; n <= maxn; n++)
1068 if (!simple_domaincmp(pv, fv, plen))
1073 * Doesn't match from start of fqdn
1074 * Try skipping first part of fqdn
1082 #endif /* def FEATURE_EXTENDED_HOST_PATTERNS */
1085 /*********************************************************************
1087 * Function : create_url_spec
1089 * Description : Creates a "url_spec" structure from a string.
1090 * When finished, free with free_url_spec().
1093 * 1 : url = Target url_spec to be filled in. Will be
1094 * zeroed before use.
1095 * 2 : buf = Source pattern, null terminated. NOTE: The
1096 * contents of this buffer are destroyed by this
1097 * function. If this function succeeds, the
1098 * buffer is copied to url->spec. If this
1099 * function fails, the contents of the buffer
1102 * Returns : JB_ERR_OK - Success
1103 * JB_ERR_PARSE - Cannot parse regex (Detailed message
1104 * written to system log)
1106 *********************************************************************/
1107 jb_err create_url_spec(struct pattern_spec *url, char *buf)
1112 memset(url, '\0', sizeof(*url));
1114 /* Remember the original specification for the CGI pages. */
1115 url->spec = strdup_or_die(buf);
1117 /* Is it a tag pattern? */
1118 if (0 == strncmpic(url->spec, "TAG:", 4))
1120 /* The pattern starts with the first character after "TAG:" */
1121 const char *tag_pattern = buf + 4;
1122 return compile_pattern(tag_pattern, NO_ANCHORING, url, &url->pattern.tag_regex);
1125 /* If it isn't a tag pattern it must be an URL pattern. */
1126 return compile_url_pattern(url, buf);
1130 /*********************************************************************
1132 * Function : free_url_spec
1134 * Description : Called from the "unloaders". Freez the url
1135 * structure elements.
1138 * 1 : url = pointer to a pattern_spec structure.
1142 *********************************************************************/
1143 void free_url_spec(struct pattern_spec *url)
1145 if (url == NULL) return;
1148 #ifdef FEATURE_EXTENDED_HOST_PATTERNS
1149 if (url->pattern.url_spec.host_regex)
1151 regfree(url->pattern.url_spec.host_regex);
1152 freez(url->pattern.url_spec.host_regex);
1155 freez(url->pattern.url_spec.dbuffer);
1156 freez(url->pattern.url_spec.dvec);
1157 url->pattern.url_spec.dcount = 0;
1158 #endif /* ndef FEATURE_EXTENDED_HOST_PATTERNS */
1159 freez(url->pattern.url_spec.port_list);
1160 if (url->pattern.url_spec.preg)
1162 regfree(url->pattern.url_spec.preg);
1163 freez(url->pattern.url_spec.preg);
1165 if (url->pattern.tag_regex)
1167 regfree(url->pattern.tag_regex);
1168 freez(url->pattern.tag_regex);
1173 /*********************************************************************
1175 * Function : port_matches
1177 * Description : Compares a port against a port list.
1180 * 1 : port = The port to check.
1181 * 2 : port_list = The list of port to compare with.
1183 * Returns : TRUE for yes, FALSE otherwise.
1185 *********************************************************************/
1186 static int port_matches(const int port, const char *port_list)
1188 return ((NULL == port_list) || match_portlist(port_list, port));
1192 /*********************************************************************
1194 * Function : host_matches
1196 * Description : Compares a host against a host pattern.
1199 * 1 : url = The URL to match
1200 * 2 : pattern = The URL pattern
1202 * Returns : TRUE for yes, FALSE otherwise.
1204 *********************************************************************/
1205 static int host_matches(const struct http_request *http,
1206 const struct pattern_spec *pattern)
1208 #ifdef FEATURE_EXTENDED_HOST_PATTERNS
1209 return ((NULL == pattern->pattern.url_spec.host_regex)
1210 || (0 == regexec(pattern->pattern.url_spec.host_regex, http->host, 0, NULL, 0)));
1212 return ((NULL == pattern->pattern.url_spec.dbuffer) || (0 == domain_match(pattern, http)));
1217 /*********************************************************************
1219 * Function : path_matches
1221 * Description : Compares a path against a path pattern.
1224 * 1 : path = The path to match
1225 * 2 : pattern = The URL pattern
1227 * Returns : TRUE for yes, FALSE otherwise.
1229 *********************************************************************/
1230 static int path_matches(const char *path, const struct pattern_spec *pattern)
1232 return ((NULL == pattern->pattern.url_spec.preg)
1233 || (0 == regexec(pattern->pattern.url_spec.preg, path, 0, NULL, 0)));
1237 /*********************************************************************
1239 * Function : url_match
1241 * Description : Compare a URL against a URL pattern.
1244 * 1 : pattern = a URL pattern
1245 * 2 : url = URL to match
1247 * Returns : Nonzero if the URL matches the pattern, else 0.
1249 *********************************************************************/
1250 int url_match(const struct pattern_spec *pattern,
1251 const struct http_request *http)
1253 if (pattern->pattern.tag_regex != NULL)
1255 /* It's a tag pattern and shouldn't be matched against URLs */
1259 return (port_matches(http->port, pattern->pattern.url_spec.port_list)
1260 && host_matches(http, pattern) && path_matches(http->path, pattern));
1265 /*********************************************************************
1267 * Function : match_portlist
1269 * Description : Check if a given number is covered by a comma
1270 * separated list of numbers and ranges (a,b-c,d,..)
1273 * 1 : portlist = String with list
1274 * 2 : port = port to check
1276 * Returns : 0 => no match
1279 *********************************************************************/
1280 int match_portlist(const char *portlist, int port)
1282 char *min, *max, *next, *portlist_copy;
1284 min = portlist_copy = strdup_or_die(portlist);
1287 * Zero-terminate first item and remember offset for next
1289 if (NULL != (next = strchr(portlist_copy, (int) ',')))
1295 * Loop through all items, checking for match
1299 if (NULL == (max = strchr(min, (int) '-')))
1302 * No dash, check for equality
1304 if (port == atoi(min))
1306 freez(portlist_copy);
1313 * This is a range, so check if between min and max,
1314 * or, if max was omitted, between min and 65K
1317 if (port >= atoi(min) && port <= (atoi(max) ? atoi(max) : 65535))
1319 freez(portlist_copy);
1331 * Zero-terminate next item and remember offset for n+1
1333 if ((NULL != next) && (NULL != (next = strchr(next, (int) ','))))
1339 freez(portlist_copy);
1345 /*********************************************************************
1347 * Function : parse_forwarder_address
1349 * Description : Parse out the host and port from a forwarder address.
1352 * 1 : address = The forwarder address to parse.
1353 * 2 : hostname = Used to return the hostname. NULL on error.
1354 * 3 : port = Used to return the port. Untouched if no port
1357 * Returns : JB_ERR_OK on success
1358 * JB_ERR_MEMORY on out of memory
1359 * JB_ERR_PARSE on malformed address.
1361 *********************************************************************/
1362 jb_err parse_forwarder_address(char *address, char **hostname, int *port)
1366 if ((*address == '[') && (NULL == strchr(address, ']')))
1368 /* XXX: Should do some more validity checks here. */
1369 return JB_ERR_PARSE;
1372 *hostname = strdup_or_die(address);
1374 if ((**hostname == '[') && (NULL != (p = strchr(*hostname, ']'))))
1377 memmove(*hostname, (*hostname + 1), (size_t)(p - *hostname));
1380 *port = (int)strtol(++p, NULL, 0);
1383 else if (NULL != (p = strchr(*hostname, ':')))
1386 *port = (int)strtol(p, NULL, 0);