1 const char urlmatch_rcs[] = "$Id: urlmatch.c,v 1.86 2015/12/27 12:47:17 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-2014
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",
458 * The PATCH method is defined by RFC5789, the format of the
459 * actual patch in the body depends on the application, but from
460 * Privoxy's point of view it doesn't matter.
466 for (i = 0; i < SZ(known_http_methods); i++)
468 if (0 == strcmpic(method, known_http_methods[i]))
479 /*********************************************************************
481 * Function : normalize_http_version
483 * Description : Take a supported HTTP version string and remove
484 * leading zeroes etc., reject unsupported versions.
486 * This is an explicit RFC 2616 (3.1) MUST and
487 * RFC 7230 mandates that intermediaries send their
488 * own HTTP-version in forwarded messages.
491 * 1 : http_version = HTTP version string
493 * Returns : JB_ERR_OK on success
494 * JB_ERR_PARSE if the HTTP version is unsupported
496 *********************************************************************/
497 jb_err static normalize_http_version(char *http_version)
499 unsigned int major_version;
500 unsigned int minor_version;
502 if (2 != sscanf(http_version, "HTTP/%u.%u", &major_version, &minor_version))
504 log_error(LOG_LEVEL_ERROR, "Unsupported HTTP version: %s", http_version);
508 if (major_version != 1 || (minor_version != 0 && minor_version != 1))
510 log_error(LOG_LEVEL_ERROR, "The only supported HTTP "
511 "versions are 1.0 and 1.1. This rules out: %s", http_version);
515 assert(strlen(http_version) >= 8);
516 snprintf(http_version, 9, "HTTP/%u.%u", major_version, minor_version);
523 /*********************************************************************
525 * Function : parse_http_request
527 * Description : Parse out the host and port from the URL. Find the
528 * hostname & path, port (if ':'), and/or password (if '@')
531 * 1 : req = HTTP request line to break down
532 * 2 : http = pointer to the http structure to hold elements
534 * Returns : JB_ERR_OK on success
535 * JB_ERR_CGI_PARAMS on malformed command/URL
536 * or >100 domains deep.
538 *********************************************************************/
539 jb_err parse_http_request(const char *req, struct http_request *http)
546 memset(http, '\0', sizeof(*http));
548 buf = strdup_or_die(req);
550 n = ssplit(buf, " \r\n", v, SZ(v));
558 * Fail in case of unknown methods
559 * which we might not handle correctly.
561 * XXX: There should be a config option
562 * to forward requests with unknown methods
563 * anyway. Most of them don't need special
566 if (unknown_method(v[0]))
568 log_error(LOG_LEVEL_ERROR, "Unknown HTTP method detected: %s", v[0]);
573 if (JB_ERR_OK != normalize_http_version(v[2]))
579 http->ssl = !strcmpic(v[0], "CONNECT");
581 err = parse_http_url(v[1], http, !http->ssl);
589 * Copy the details into the structure
591 http->cmd = strdup_or_die(req);
592 http->gpc = strdup_or_die(v[0]);
593 http->ver = strdup_or_die(v[2]);
594 http->ocmd = strdup_or_die(http->cmd);
603 /*********************************************************************
605 * Function : compile_pattern
607 * Description : Compiles a host, domain or TAG pattern.
610 * 1 : pattern = The pattern to compile.
611 * 2 : anchoring = How the regex should be modified
612 * before compilation. Can be either
613 * one of NO_ANCHORING, LEFT_ANCHORED,
614 * RIGHT_ANCHORED or RIGHT_ANCHORED_HOST.
615 * 3 : url = In case of failures, the spec member is
616 * logged and the structure freed.
617 * 4 : regex = Where the compiled regex should be stored.
619 * Returns : JB_ERR_OK - Success
620 * JB_ERR_PARSE - Cannot parse regex
622 *********************************************************************/
623 static jb_err compile_pattern(const char *pattern, enum regex_anchoring anchoring,
624 struct pattern_spec *url, regex_t **regex)
627 char rebuf[BUFFER_SIZE];
628 const char *fmt = NULL;
631 assert(strlen(pattern) < sizeof(rebuf) - 2);
633 if (pattern[0] == '\0')
647 case RIGHT_ANCHORED_HOST:
654 log_error(LOG_LEVEL_FATAL,
655 "Invalid anchoring in compile_pattern %d", anchoring);
658 *regex = zalloc_or_die(sizeof(**regex));
660 snprintf(rebuf, sizeof(rebuf), fmt, pattern);
662 errcode = regcomp(*regex, rebuf, (REG_EXTENDED|REG_NOSUB|REG_ICASE));
666 size_t errlen = regerror(errcode, *regex, rebuf, sizeof(rebuf));
667 if (errlen > (sizeof(rebuf) - (size_t)1))
669 errlen = sizeof(rebuf) - (size_t)1;
671 rebuf[errlen] = '\0';
672 log_error(LOG_LEVEL_ERROR, "error compiling %s from %s: %s",
673 pattern, url->spec, rebuf);
674 free_pattern_spec(url);
684 /*********************************************************************
686 * Function : compile_url_pattern
688 * Description : Compiles the three parts of an URL pattern.
691 * 1 : url = Target pattern_spec to be filled in.
692 * 2 : buf = The url pattern to compile. Will be messed up.
694 * Returns : JB_ERR_OK - Success
695 * JB_ERR_MEMORY - Out of memory
696 * JB_ERR_PARSE - Cannot parse regex
698 *********************************************************************/
699 static jb_err compile_url_pattern(struct pattern_spec *url, char *buf)
703 p = strchr(buf, '/');
707 * Only compile the regex if it consists of more than
708 * a single slash, otherwise it wouldn't affect the result.
713 * XXX: does it make sense to compile the slash at the beginning?
715 jb_err err = compile_pattern(p, LEFT_ANCHORED, url, &url->pattern.url_spec.preg);
717 if (JB_ERR_OK != err)
726 * IPv6 numeric hostnames can contain colons, thus we need
727 * to delimit the hostname before the real port separator.
728 * As brackets are already used in the hostname pattern,
729 * we use angle brackets ('<', '>') instead.
731 if ((buf[0] == '<') && (NULL != (p = strchr(buf + 1, '>'))))
738 /* IPv6 address without port number */
743 /* Garbage after address delimiter */
749 p = strchr(buf, ':');
755 url->pattern.url_spec.port_list = strdup_or_die(p);
759 url->pattern.url_spec.port_list = NULL;
764 return compile_host_pattern(url, buf);
772 #ifdef FEATURE_EXTENDED_HOST_PATTERNS
773 /*********************************************************************
775 * Function : compile_host_pattern
777 * Description : Parses and compiles a host pattern.
780 * 1 : url = Target pattern_spec to be filled in.
781 * 2 : host_pattern = Host pattern to compile.
783 * Returns : JB_ERR_OK - Success
784 * JB_ERR_MEMORY - Out of memory
785 * JB_ERR_PARSE - Cannot parse regex
787 *********************************************************************/
788 static jb_err compile_host_pattern(struct pattern_spec *url, const char *host_pattern)
790 return compile_pattern(host_pattern, RIGHT_ANCHORED_HOST, url, &url->pattern.url_spec.host_regex);
795 /*********************************************************************
797 * Function : compile_host_pattern
799 * Description : Parses and "compiles" an old-school host pattern.
802 * 1 : url = Target pattern_spec to be filled in.
803 * 2 : host_pattern = Host pattern to parse.
805 * Returns : JB_ERR_OK - Success
806 * JB_ERR_PARSE - Cannot parse regex
808 *********************************************************************/
809 static jb_err compile_host_pattern(struct pattern_spec *url, const char *host_pattern)
818 if (host_pattern[strlen(host_pattern) - 1] == '.')
820 url->pattern.url_spec.unanchored |= ANCHOR_RIGHT;
822 if (host_pattern[0] == '.')
824 url->pattern.url_spec.unanchored |= ANCHOR_LEFT;
828 * Split domain into components
830 url->pattern.url_spec.dbuffer = strdup_or_die(host_pattern);
835 for (p = url->pattern.url_spec.dbuffer; *p ; p++)
837 *p = (char)privoxy_tolower(*p);
841 * Split the domain name into components
843 url->pattern.url_spec.dcount = ssplit(url->pattern.url_spec.dbuffer, ".", v, SZ(v));
845 if (url->pattern.url_spec.dcount < 0)
847 free_pattern_spec(url);
850 else if (url->pattern.url_spec.dcount != 0)
853 * Save a copy of the pointers in dvec
855 size = (size_t)url->pattern.url_spec.dcount * sizeof(*url->pattern.url_spec.dvec);
857 url->pattern.url_spec.dvec = malloc_or_die(size);
859 memcpy(url->pattern.url_spec.dvec, v, size);
862 * else dcount == 0 in which case we needn't do anything,
863 * since dvec will never be accessed and the pattern will
870 /*********************************************************************
872 * Function : simplematch
874 * Description : String matching, with a (greedy) '*' wildcard that
875 * stands for zero or more arbitrary characters and
876 * character classes in [], which take both enumerations
880 * 1 : pattern = pattern for matching
881 * 2 : text = text to be matched
883 * Returns : 0 if match, else nonzero
885 *********************************************************************/
886 static int simplematch(const char *pattern, const char *text)
888 const unsigned char *pat = (const unsigned char *)pattern;
889 const unsigned char *txt = (const unsigned char *)text;
890 const unsigned char *fallback = pat;
893 unsigned char lastchar = 'a';
895 unsigned char charmap[32];
900 /* EOF pattern but !EOF text? */
913 /* '*' in the pattern? */
917 /* The pattern ends afterwards? Speed up the return. */
923 /* Else, set wildcard mode and remember position after '*' */
928 /* Character range specification? */
931 memset(charmap, '\0', sizeof(charmap));
933 while (*++pat != ']')
939 else if (*pat == '-')
941 if ((*++pat == ']') || *pat == '\0')
945 for (i = lastchar; i <= *pat; i++)
947 charmap[i / 8] |= (unsigned char)(1 << (i % 8));
952 charmap[*pat / 8] |= (unsigned char)(1 << (*pat % 8));
956 } /* -END- if Character range specification */
960 * Char match, or char range match?
964 || ((*pat == ']') && (charmap[*txt / 8] & (1 << (*txt % 8)))))
974 * No match && no wildcard: No luck
978 else if (pat != fallback)
981 * Increment text pointer if in char range matching
988 * Wildcard mode && nonmatch beyond fallback: Rewind pattern
992 * Restart matching from current text pointer
999 /* Cut off extra '*'s */
1000 if (*pat == '*') pat++;
1002 /* If this is the pattern's end, fine! */
1008 /*********************************************************************
1010 * Function : simple_domaincmp
1012 * Description : Domain-wise Compare fqdn's. The comparison is
1013 * both left- and right-anchored. The individual
1014 * domain names are compared with simplematch().
1015 * This is only used by domain_match.
1018 * 1 : pv = array of patterns to compare
1019 * 2 : fv = array of domain components to compare
1020 * 3 : len = length of the arrays (both arrays are the
1021 * same length - if they weren't, it couldn't
1022 * possibly be a match).
1024 * Returns : 0 => domains are equivalent, else no match.
1026 *********************************************************************/
1027 static int simple_domaincmp(char **pv, char **fv, int len)
1031 for (n = 0; n < len; n++)
1033 if (simplematch(pv[n], fv[n]))
1044 /*********************************************************************
1046 * Function : domain_match
1048 * Description : Domain-wise Compare fqdn's. Governed by the bimap in
1049 * p.pattern->unachored, the comparison is un-, left-,
1050 * right-anchored, or both.
1051 * The individual domain names are compared with
1055 * 1 : p = a domain that may contain a '*' as a wildcard.
1056 * 2 : fqdn = domain name against which the patterns are compared.
1058 * Returns : 0 => domains are equivalent, else no match.
1060 *********************************************************************/
1061 static int domain_match(const struct pattern_spec *p, const struct http_request *fqdn)
1063 char **pv, **fv; /* vectors */
1065 int unanchored = p->pattern.url_spec.unanchored & (ANCHOR_RIGHT | ANCHOR_LEFT);
1067 plen = p->pattern.url_spec.dcount;
1068 flen = fqdn->dcount;
1072 /* fqdn is too short to match this pattern */
1076 pv = p->pattern.url_spec.dvec;
1079 if (unanchored == ANCHOR_LEFT)
1084 * Convert this into a fully anchored pattern with
1085 * the fqdn and pattern the same length
1087 fv += (flen - plen); /* flen - plen >= 0 due to check above */
1088 return simple_domaincmp(pv, fv, plen);
1090 else if (unanchored == 0)
1092 /* Fully anchored, check length */
1097 return simple_domaincmp(pv, fv, plen);
1099 else if (unanchored == ANCHOR_RIGHT)
1101 /* Left anchored, ignore all extra in fqdn */
1102 return simple_domaincmp(pv, fv, plen);
1108 int maxn = flen - plen;
1109 for (n = 0; n <= maxn; n++)
1111 if (!simple_domaincmp(pv, fv, plen))
1116 * Doesn't match from start of fqdn
1117 * Try skipping first part of fqdn
1125 #endif /* def FEATURE_EXTENDED_HOST_PATTERNS */
1128 /*********************************************************************
1130 * Function : create_pattern_spec
1132 * Description : Creates a "pattern_spec" structure from a string.
1133 * When finished, free with free_pattern_spec().
1136 * 1 : pattern = Target pattern_spec to be filled in.
1137 * Will be zeroed before use.
1138 * 2 : buf = Source pattern, null terminated. NOTE: The
1139 * contents of this buffer are destroyed by this
1140 * function. If this function succeeds, the
1141 * buffer is copied to pattern->spec. If this
1142 * function fails, the contents of the buffer
1145 * Returns : JB_ERR_OK - Success
1146 * JB_ERR_PARSE - Cannot parse regex (Detailed message
1147 * written to system log)
1149 *********************************************************************/
1150 jb_err create_pattern_spec(struct pattern_spec *pattern, char *buf)
1154 /** The tag pattern prefix to match */
1157 /** The length of the prefix to match */
1158 const size_t prefix_length;
1160 /** The pattern flag */
1161 const unsigned flag;
1163 { "TAG:", 4, PATTERN_SPEC_TAG_PATTERN},
1164 { "NO-REQUEST-TAG:", 15, PATTERN_SPEC_NO_REQUEST_TAG_PATTERN},
1165 { "NO-RESPONSE-TAG:", 16, PATTERN_SPEC_NO_RESPONSE_TAG_PATTERN}
1172 memset(pattern, '\0', sizeof(*pattern));
1174 /* Remember the original specification for the CGI pages. */
1175 pattern->spec = strdup_or_die(buf);
1177 /* Check if it's a tag pattern */
1178 for (i = 0; i < SZ(tag_pattern); i++)
1180 if (0 == strncmpic(pattern->spec, tag_pattern[i].prefix, tag_pattern[i].prefix_length))
1182 /* The regex starts after the prefix */
1183 const char *tag_regex = buf + tag_pattern[i].prefix_length;
1185 pattern->flags |= tag_pattern[i].flag;
1187 return compile_pattern(tag_regex, NO_ANCHORING, pattern,
1188 &pattern->pattern.tag_regex);
1192 /* If it isn't a tag pattern it must be an URL pattern. */
1193 pattern->flags |= PATTERN_SPEC_URL_PATTERN;
1195 return compile_url_pattern(pattern, buf);
1200 /*********************************************************************
1202 * Function : free_pattern_spec
1204 * Description : Called from the "unloaders". Freez the pattern
1205 * structure elements.
1208 * 1 : pattern = pointer to a pattern_spec structure.
1212 *********************************************************************/
1213 void free_pattern_spec(struct pattern_spec *pattern)
1215 if (pattern == NULL) return;
1217 freez(pattern->spec);
1218 #ifdef FEATURE_EXTENDED_HOST_PATTERNS
1219 if (pattern->pattern.url_spec.host_regex)
1221 regfree(pattern->pattern.url_spec.host_regex);
1222 freez(pattern->pattern.url_spec.host_regex);
1225 freez(pattern->pattern.url_spec.dbuffer);
1226 freez(pattern->pattern.url_spec.dvec);
1227 pattern->pattern.url_spec.dcount = 0;
1228 #endif /* ndef FEATURE_EXTENDED_HOST_PATTERNS */
1229 freez(pattern->pattern.url_spec.port_list);
1230 if (pattern->pattern.url_spec.preg)
1232 regfree(pattern->pattern.url_spec.preg);
1233 freez(pattern->pattern.url_spec.preg);
1235 if (pattern->pattern.tag_regex)
1237 regfree(pattern->pattern.tag_regex);
1238 freez(pattern->pattern.tag_regex);
1243 /*********************************************************************
1245 * Function : port_matches
1247 * Description : Compares a port against a port list.
1250 * 1 : port = The port to check.
1251 * 2 : port_list = The list of port to compare with.
1253 * Returns : TRUE for yes, FALSE otherwise.
1255 *********************************************************************/
1256 static int port_matches(const int port, const char *port_list)
1258 return ((NULL == port_list) || match_portlist(port_list, port));
1262 /*********************************************************************
1264 * Function : host_matches
1266 * Description : Compares a host against a host pattern.
1269 * 1 : url = The URL to match
1270 * 2 : pattern = The URL pattern
1272 * Returns : TRUE for yes, FALSE otherwise.
1274 *********************************************************************/
1275 static int host_matches(const struct http_request *http,
1276 const struct pattern_spec *pattern)
1278 assert(http->host != NULL);
1279 #ifdef FEATURE_EXTENDED_HOST_PATTERNS
1280 return ((NULL == pattern->pattern.url_spec.host_regex)
1281 || (0 == regexec(pattern->pattern.url_spec.host_regex, http->host, 0, NULL, 0)));
1283 return ((NULL == pattern->pattern.url_spec.dbuffer) || (0 == domain_match(pattern, http)));
1288 /*********************************************************************
1290 * Function : path_matches
1292 * Description : Compares a path against a path pattern.
1295 * 1 : path = The path to match
1296 * 2 : pattern = The URL pattern
1298 * Returns : TRUE for yes, FALSE otherwise.
1300 *********************************************************************/
1301 static int path_matches(const char *path, const struct pattern_spec *pattern)
1303 return ((NULL == pattern->pattern.url_spec.preg)
1304 || (0 == regexec(pattern->pattern.url_spec.preg, path, 0, NULL, 0)));
1308 /*********************************************************************
1310 * Function : url_match
1312 * Description : Compare a URL against a URL pattern.
1315 * 1 : pattern = a URL pattern
1316 * 2 : url = URL to match
1318 * Returns : Nonzero if the URL matches the pattern, else 0.
1320 *********************************************************************/
1321 int url_match(const struct pattern_spec *pattern,
1322 const struct http_request *http)
1324 if (!(pattern->flags & PATTERN_SPEC_URL_PATTERN))
1326 /* It's not an URL pattern and thus shouldn't be matched against URLs */
1330 return (port_matches(http->port, pattern->pattern.url_spec.port_list)
1331 && host_matches(http, pattern) && path_matches(http->path, pattern));
1336 /*********************************************************************
1338 * Function : match_portlist
1340 * Description : Check if a given number is covered by a comma
1341 * separated list of numbers and ranges (a,b-c,d,..)
1344 * 1 : portlist = String with list
1345 * 2 : port = port to check
1347 * Returns : 0 => no match
1350 *********************************************************************/
1351 int match_portlist(const char *portlist, int port)
1353 char *min, *max, *next, *portlist_copy;
1355 min = portlist_copy = strdup_or_die(portlist);
1358 * Zero-terminate first item and remember offset for next
1360 if (NULL != (next = strchr(portlist_copy, (int) ',')))
1366 * Loop through all items, checking for match
1370 if (NULL == (max = strchr(min, (int) '-')))
1373 * No dash, check for equality
1375 if (port == atoi(min))
1377 freez(portlist_copy);
1384 * This is a range, so check if between min and max,
1385 * or, if max was omitted, between min and 65K
1388 if (port >= atoi(min) && port <= (atoi(max) ? atoi(max) : 65535))
1390 freez(portlist_copy);
1402 * Zero-terminate next item and remember offset for n+1
1404 if ((NULL != next) && (NULL != (next = strchr(next, (int) ','))))
1410 freez(portlist_copy);
1416 /*********************************************************************
1418 * Function : parse_forwarder_address
1420 * Description : Parse out the host and port from a forwarder address.
1423 * 1 : address = The forwarder address to parse.
1424 * 2 : hostname = Used to return the hostname. NULL on error.
1425 * 3 : port = Used to return the port. Untouched if no port
1428 * Returns : JB_ERR_OK on success
1429 * JB_ERR_MEMORY on out of memory
1430 * JB_ERR_PARSE on malformed address.
1432 *********************************************************************/
1433 jb_err parse_forwarder_address(char *address, char **hostname, int *port)
1437 if ((*address == '[') && (NULL == strchr(address, ']')))
1439 /* XXX: Should do some more validity checks here. */
1440 return JB_ERR_PARSE;
1443 *hostname = strdup_or_die(address);
1445 if ((**hostname == '[') && (NULL != (p = strchr(*hostname, ']'))))
1448 memmove(*hostname, (*hostname + 1), (size_t)(p - *hostname));
1451 *port = (int)strtol(++p, NULL, 0);
1454 else if (NULL != (p = strchr(*hostname, ':')))
1457 *port = (int)strtol(p, NULL, 0);