1 /*********************************************************************
3 * File : $Source: /cvsroot/ijbswa/current/urlmatch.c,v $
5 * Purpose : Declares functions to match URLs against URL
8 * Copyright : Written by and Copyright (C) 2001-2020
9 * the Privoxy team. https://www.privoxy.org/
11 * Based on the Internet Junkbuster originally written
12 * by and Copyright (C) 1997 Anonymous Coders and
13 * Junkbusters Corporation. http://www.junkbusters.com
15 * This program is free software; you can redistribute it
16 * and/or modify it under the terms of the GNU General
17 * Public License as published by the Free Software
18 * Foundation; either version 2 of the License, or (at
19 * your option) any later version.
21 * This program is distributed in the hope that it will
22 * be useful, but WITHOUT ANY WARRANTY; without even the
23 * implied warranty of MERCHANTABILITY or FITNESS FOR A
24 * PARTICULAR PURPOSE. See the GNU General Public
25 * License for more details.
27 * The GNU General Public License should be included with
28 * this file. If not, you can view it at
29 * http://www.gnu.org/copyleft/gpl.html
30 * or write to the Free Software Foundation, Inc., 59
31 * Temple Place - Suite 330, Boston, MA 02111-1307, USA.
33 *********************************************************************/
40 #include <sys/types.h>
65 static jb_err compile_vanilla_host_pattern(struct pattern_spec *url, const char *host_pattern);
66 #ifdef FEATURE_PCRE_HOST_PATTERNS
67 static jb_err compile_pcre_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);
101 /*********************************************************************
103 * Function : init_domain_components
105 * Description : Splits the domain name so we can compare it
106 * against wildcards. It used to be part of
107 * parse_http_url, but was separated because the
108 * same code is required in chat in case of
109 * intercepted requests.
112 * 1 : http = pointer to the http structure to hold elements.
114 * Returns : JB_ERR_OK on success
115 * JB_ERR_PARSE on malformed command/URL
116 * or >100 domains deep.
118 *********************************************************************/
119 jb_err init_domain_components(struct http_request *http)
121 char *vec[BUFFER_SIZE];
125 http->dbuffer = strdup_or_die(http->host);
127 /* map to lower case */
128 for (p = http->dbuffer; *p ; p++)
130 *p = (char)privoxy_tolower(*p);
133 /* split the domain name into components */
134 http->dcount = ssplit(http->dbuffer, ".", vec, SZ(vec));
136 if (http->dcount <= 0)
139 * Error: More than SZ(vec) components in domain
140 * or: no components in domain
142 log_error(LOG_LEVEL_ERROR, "More than SZ(vec) components in domain or none at all.");
146 /* save a copy of the pointers in dvec */
147 size = (size_t)http->dcount * sizeof(*http->dvec);
149 http->dvec = malloc_or_die(size);
151 memcpy(http->dvec, vec, size);
157 /*********************************************************************
159 * Function : url_requires_percent_encoding
161 * Description : Checks if an URL contains invalid characters
162 * according to RFC 3986 that should be percent-encoded.
163 * Does not verify whether or not the passed string
164 * actually is a valid URL.
167 * 1 : url = URL to check
169 * Returns : True in case of valid URLs, false otherwise
171 *********************************************************************/
172 int url_requires_percent_encoding(const char *url)
174 static const char allowed_characters[128] = {
175 '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
176 '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
177 '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
178 '\0', '\0', '\0', '!', '\0', '#', '$', '%', '&', '\'',
179 '(', ')', '*', '+', ',', '-', '.', '/', '0', '1',
180 '2', '3', '4', '5', '6', '7', '8', '9', ':', ';',
181 '\0', '=', '\0', '?', '@', 'A', 'B', 'C', 'D', 'E',
182 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
183 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y',
184 'Z', '[', '\0', ']', '\0', '_', '\0', 'a', 'b', 'c',
185 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
186 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
187 'x', 'y', 'z', '\0', '\0', '\0', '~', '\0'
192 const unsigned int i = (unsigned char)*url++;
193 if (i >= sizeof(allowed_characters) || '\0' == allowed_characters[i])
204 /*********************************************************************
206 * Function : parse_http_url
208 * Description : Parse out the host and port from the URL. Find the
209 * hostname & path, port (if ':'), and/or password (if '@')
212 * 1 : url = URL (or is it URI?) to break down
213 * 2 : http = pointer to the http structure to hold elements.
214 * Must be initialized with valid values (like NULLs).
215 * 3 : require_protocol = Whether or not URLs without
216 * protocol are acceptable.
218 * Returns : JB_ERR_OK on success
219 * JB_ERR_PARSE on malformed command/URL
220 * or >100 domains deep.
222 *********************************************************************/
223 jb_err parse_http_url(const char *url, struct http_request *http, int require_protocol)
225 int host_available = 1; /* A proxy can dream. */
228 * Save our initial URL
230 http->url = strdup_or_die(url);
233 * Check for * URI. If found, we're done.
235 if (*http->url == '*')
237 http->path = strdup_or_die("*");
238 http->hostport = strdup_or_die("");
239 if (http->url[1] != '\0')
248 * Split URL into protocol,hostport,path.
255 buf = strdup_or_die(url);
257 /* Find the start of the URL in our scratch space */
259 if (strncmpic(url_noproto, "http://", 7) == 0)
263 else if (strncmpic(url_noproto, "https://", 8) == 0)
266 * Should only happen when called from cgi_show_url_info()
267 * or when the request was https-inspected and the request
268 * line got rewritten.
273 else if (*url_noproto == '/')
276 * Short request line without protocol and host.
277 * Most likely because the client's request
278 * was intercepted and redirected into Privoxy.
283 else if (require_protocol)
289 url_path = strchr(url_noproto, '/');
290 if (url_path != NULL)
295 * If FEATURE_HTTPS_INSPECTION isn't available, ignore the
296 * path for https URLs so that we get consistent behaviour
297 * if a https URL is parsed. When the URL is actually
298 * retrieved, https hides the path part.
300 http->path = strdup_or_die(
301 #ifndef FEATURE_HTTPS_INSPECTION
307 http->hostport = string_tolower(url_noproto);
312 * Repair broken HTTP requests that don't contain a path,
313 * or CONNECT requests
315 http->path = strdup_or_die("/");
316 http->hostport = string_tolower(url_noproto);
321 if (http->hostport == NULL)
329 /* Without host, there is nothing left to do here */
334 * Split hostport into user/password (ignored), host, port.
341 buf = strdup_or_die(http->hostport);
343 /* check if url contains username and/or password */
344 host = strchr(buf, '@');
347 /* Contains username/password, skip it and the @ sign. */
352 /* No username or password. */
356 /* Move after hostname before port number */
359 /* Numeric IPv6 address delimited by brackets */
361 port = strchr(host, ']');
365 /* Missing closing bracket */
376 else if (*port != ':')
378 /* Garbage after closing bracket */
385 /* Plain non-escaped hostname */
386 port = strchr(host, ':');
389 /* check if url contains port */
395 /* Terminate hostname and point to start of port string */
397 parsed_port = strtol(port, &endptr, 10);
398 if ((parsed_port <= 0) || (parsed_port > 65535) || (*endptr != '\0'))
400 log_error(LOG_LEVEL_ERROR, "Invalid port in URL: %s.", url);
404 http->port = (int)parsed_port;
408 /* No port specified. */
409 http->port = (http->ssl ? 443 : 80);
412 http->host = strdup_or_die(host);
417 /* Split domain name so we can compare it against wildcards */
418 return init_domain_components(http);
423 /*********************************************************************
425 * Function : unknown_method
427 * Description : Checks whether a method is unknown.
430 * 1 : method = points to a http method
432 * Returns : TRUE if it's unknown, FALSE otherwise.
434 *********************************************************************/
435 static int unknown_method(const char *method)
437 static const char * const known_http_methods[] = {
438 /* Basic HTTP request type */
439 "GET", "HEAD", "POST", "PUT", "DELETE", "OPTIONS", "TRACE", "CONNECT",
440 /* webDAV extensions (RFC2518) */
441 "PROPFIND", "PROPPATCH", "MOVE", "COPY", "MKCOL", "LOCK", "UNLOCK",
443 * Microsoft webDAV extension for Exchange 2000. See:
444 * http://lists.w3.org/Archives/Public/w3c-dist-auth/2002JanMar/0001.html
445 * http://msdn.microsoft.com/library/en-us/wss/wss/_webdav_methods.asp
447 "BCOPY", "BMOVE", "BDELETE", "BPROPFIND", "BPROPPATCH",
449 * Another Microsoft webDAV extension for Exchange 2000. See:
450 * http://systems.cs.colorado.edu/grunwald/MobileComputing/Papers/draft-cohen-gena-p-base-00.txt
451 * http://lists.w3.org/Archives/Public/w3c-dist-auth/2002JanMar/0001.html
452 * http://msdn.microsoft.com/library/en-us/wss/wss/_webdav_methods.asp
454 "SUBSCRIBE", "UNSUBSCRIBE", "NOTIFY", "POLL",
456 * Yet another WebDAV extension, this time for
457 * Web Distributed Authoring and Versioning (RFC3253)
459 "VERSION-CONTROL", "REPORT", "CHECKOUT", "CHECKIN", "UNCHECKOUT",
460 "MKWORKSPACE", "UPDATE", "LABEL", "MERGE", "BASELINE-CONTROL", "MKACTIVITY",
462 * The PATCH method is defined by RFC5789, the format of the
463 * actual patch in the body depends on the application, but from
464 * Privoxy's point of view it doesn't matter.
470 for (i = 0; i < SZ(known_http_methods); i++)
472 if (0 == strcmpic(method, known_http_methods[i]))
483 /*********************************************************************
485 * Function : normalize_http_version
487 * Description : Take a supported HTTP version string and remove
488 * leading zeroes etc., reject unsupported versions.
490 * This is an explicit RFC 2616 (3.1) MUST and
491 * RFC 7230 mandates that intermediaries send their
492 * own HTTP-version in forwarded messages.
495 * 1 : http_version = HTTP version string
497 * Returns : JB_ERR_OK on success
498 * JB_ERR_PARSE if the HTTP version is unsupported
500 *********************************************************************/
501 static jb_err normalize_http_version(char *http_version)
503 unsigned int major_version;
504 unsigned int minor_version;
506 if (2 != sscanf(http_version, "HTTP/%u.%u", &major_version, &minor_version))
508 log_error(LOG_LEVEL_ERROR, "Unsupported HTTP version: %s", http_version);
512 if (major_version != 1 || (minor_version != 0 && minor_version != 1))
514 log_error(LOG_LEVEL_ERROR, "The only supported HTTP "
515 "versions are 1.0 and 1.1. This rules out: %s", http_version);
519 assert(strlen(http_version) >= 8);
520 snprintf(http_version, 9, "HTTP/%u.%u", major_version, minor_version);
527 /*********************************************************************
529 * Function : parse_http_request
531 * Description : Parse out the host and port from the URL. Find the
532 * hostname & path, port (if ':'), and/or password (if '@')
535 * 1 : req = HTTP request line to break down
536 * 2 : http = pointer to the http structure to hold elements
538 * Returns : JB_ERR_OK on success
539 * JB_ERR_CGI_PARAMS on malformed command/URL
540 * or >100 domains deep.
542 *********************************************************************/
543 jb_err parse_http_request(const char *req, struct http_request *http)
550 memset(http, '\0', sizeof(*http));
552 buf = strdup_or_die(req);
554 n = ssplit(buf, " \r\n", v, SZ(v));
562 * Fail in case of unknown methods
563 * which we might not handle correctly.
565 * XXX: There should be a config option
566 * to forward requests with unknown methods
567 * anyway. Most of them don't need special
570 if (unknown_method(v[0]))
572 log_error(LOG_LEVEL_ERROR, "Unknown HTTP method detected: %s", v[0]);
577 if (JB_ERR_OK != normalize_http_version(v[2]))
583 http->ssl = !strcmpic(v[0], "CONNECT");
585 err = parse_http_url(v[1], http, !http->ssl);
593 * Copy the details into the structure
595 http->cmd = strdup_or_die(req);
596 http->gpc = strdup_or_die(v[0]);
597 http->version = strdup_or_die(v[2]);
598 http->ocmd = strdup_or_die(http->cmd);
607 /*********************************************************************
609 * Function : compile_pattern
611 * Description : Compiles a host, domain or TAG pattern.
614 * 1 : pattern = The pattern to compile.
615 * 2 : anchoring = How the regex should be modified
616 * before compilation. Can be either
617 * one of NO_ANCHORING, LEFT_ANCHORED,
618 * RIGHT_ANCHORED or RIGHT_ANCHORED_HOST.
619 * 3 : url = In case of failures, the spec member is
620 * logged and the structure freed.
621 * 4 : regex = Where the compiled regex should be stored.
623 * Returns : JB_ERR_OK - Success
624 * JB_ERR_PARSE - Cannot parse regex
626 *********************************************************************/
627 static jb_err compile_pattern(const char *pattern, enum regex_anchoring anchoring,
628 struct pattern_spec *url, regex_t **regex)
631 const char *fmt = NULL;
637 if (pattern[0] == '\0')
651 case RIGHT_ANCHORED_HOST:
658 log_error(LOG_LEVEL_FATAL,
659 "Invalid anchoring in compile_pattern %d", anchoring);
661 rebuf_size = strlen(pattern) + strlen(fmt);
662 rebuf = malloc_or_die(rebuf_size);
663 *regex = zalloc_or_die(sizeof(**regex));
665 snprintf(rebuf, rebuf_size, fmt, pattern);
667 errcode = regcomp(*regex, rebuf, (REG_EXTENDED|REG_NOSUB|REG_ICASE));
671 size_t errlen = regerror(errcode, *regex, rebuf, rebuf_size);
672 if (errlen > (rebuf_size - (size_t)1))
674 errlen = rebuf_size - (size_t)1;
676 rebuf[errlen] = '\0';
677 log_error(LOG_LEVEL_ERROR, "error compiling %s from %s: %s",
678 pattern, url->spec, rebuf);
679 free_pattern_spec(url);
691 /*********************************************************************
693 * Function : compile_url_pattern
695 * Description : Compiles the three parts of an URL pattern.
698 * 1 : url = Target pattern_spec to be filled in.
699 * 2 : buf = The url pattern to compile. Will be messed up.
701 * Returns : JB_ERR_OK - Success
702 * JB_ERR_MEMORY - Out of memory
703 * JB_ERR_PARSE - Cannot parse regex
705 *********************************************************************/
706 static jb_err compile_url_pattern(struct pattern_spec *url, char *buf)
709 const size_t prefix_length = 18;
711 #ifdef FEATURE_PCRE_HOST_PATTERNS
712 if (strncmpic(buf, "PCRE-HOST-PATTERN:", prefix_length) == 0)
714 url->pattern.url_spec.host_regex_type = PCRE_HOST_PATTERN;
715 /* Overwrite the "PCRE-HOST-PATTERN:" prefix */
716 memmove(buf, buf+prefix_length, strlen(buf+prefix_length)+1);
720 url->pattern.url_spec.host_regex_type = VANILLA_HOST_PATTERN;
723 if (strncmpic(buf, "PCRE-HOST-PATTERN:", prefix_length) == 0)
725 log_error(LOG_LEVEL_ERROR,
726 "PCRE-HOST-PATTERN detected while Privoxy has been compiled "
727 "without FEATURE_PCRE_HOST_PATTERNS: %s",
729 /* Overwrite the "PCRE-HOST-PATTERN:" prefix */
730 memmove(buf, buf+prefix_length, strlen(buf+prefix_length)+1);
732 * The pattern will probably not work as expected.
733 * We don't simply return JB_ERR_PARSE here so the
734 * regression tests can be loaded with and without
735 * FEATURE_PCRE_HOST_PATTERNS.
740 p = strchr(buf, '/');
744 * Only compile the regex if it consists of more than
745 * a single slash, otherwise it wouldn't affect the result.
750 * XXX: does it make sense to compile the slash at the beginning?
752 jb_err err = compile_pattern(p, LEFT_ANCHORED, url, &url->pattern.url_spec.preg);
754 if (JB_ERR_OK != err)
763 * IPv6 numeric hostnames can contain colons, thus we need
764 * to delimit the hostname before the real port separator.
765 * As brackets are already used in the hostname pattern,
766 * we use angle brackets ('<', '>') instead.
768 if ((buf[0] == '<') && (NULL != (p = strchr(buf + 1, '>'))))
775 /* IPv6 address without port number */
780 /* Garbage after address delimiter */
786 p = strchr(buf, ':');
792 url->pattern.url_spec.port_list = strdup_or_die(p);
796 url->pattern.url_spec.port_list = NULL;
801 #ifdef FEATURE_PCRE_HOST_PATTERNS
802 if (url->pattern.url_spec.host_regex_type == PCRE_HOST_PATTERN)
804 return compile_pcre_host_pattern(url, buf);
809 return compile_vanilla_host_pattern(url, buf);
818 #ifdef FEATURE_PCRE_HOST_PATTERNS
819 /*********************************************************************
821 * Function : compile_pcre_host_pattern
823 * Description : Parses and compiles a pcre host pattern.
826 * 1 : url = Target pattern_spec to be filled in.
827 * 2 : host_pattern = Host pattern to compile.
829 * Returns : JB_ERR_OK - Success
830 * JB_ERR_MEMORY - Out of memory
831 * JB_ERR_PARSE - Cannot parse regex
833 *********************************************************************/
834 static jb_err compile_pcre_host_pattern(struct pattern_spec *url, const char *host_pattern)
836 return compile_pattern(host_pattern, RIGHT_ANCHORED_HOST, url, &url->pattern.url_spec.host_regex);
838 #endif /* def FEATURE_PCRE_HOST_PATTERNS */
841 /*********************************************************************
843 * Function : compile_vanilla_host_pattern
845 * Description : Parses and "compiles" an old-school host pattern.
848 * 1 : url = Target pattern_spec to be filled in.
849 * 2 : host_pattern = Host pattern to parse.
851 * Returns : JB_ERR_OK - Success
852 * JB_ERR_PARSE - Cannot parse regex
854 *********************************************************************/
855 static jb_err compile_vanilla_host_pattern(struct pattern_spec *url, const char *host_pattern)
864 if (host_pattern[strlen(host_pattern) - 1] == '.')
866 url->pattern.url_spec.unanchored |= ANCHOR_RIGHT;
868 if (host_pattern[0] == '.')
870 url->pattern.url_spec.unanchored |= ANCHOR_LEFT;
874 * Split domain into components
876 url->pattern.url_spec.dbuffer = strdup_or_die(host_pattern);
881 for (p = url->pattern.url_spec.dbuffer; *p ; p++)
883 *p = (char)privoxy_tolower(*p);
887 * Split the domain name into components
889 url->pattern.url_spec.dcount = ssplit(url->pattern.url_spec.dbuffer, ".", v, SZ(v));
891 if (url->pattern.url_spec.dcount < 0)
893 free_pattern_spec(url);
896 else if (url->pattern.url_spec.dcount != 0)
899 * Save a copy of the pointers in dvec
901 size = (size_t)url->pattern.url_spec.dcount * sizeof(*url->pattern.url_spec.dvec);
903 url->pattern.url_spec.dvec = malloc_or_die(size);
905 memcpy(url->pattern.url_spec.dvec, v, size);
908 * else dcount == 0 in which case we needn't do anything,
909 * since dvec will never be accessed and the pattern will
916 /*********************************************************************
918 * Function : simplematch
920 * Description : String matching, with a (greedy) '*' wildcard that
921 * stands for zero or more arbitrary characters and
922 * character classes in [], which take both enumerations
926 * 1 : pattern = pattern for matching
927 * 2 : text = text to be matched
929 * Returns : 0 if match, else nonzero
931 *********************************************************************/
932 static int simplematch(const char *pattern, const char *text)
934 const unsigned char *pat = (const unsigned char *)pattern;
935 const unsigned char *txt = (const unsigned char *)text;
936 const unsigned char *fallback = pat;
939 unsigned char lastchar = 'a';
941 unsigned char charmap[32];
946 /* EOF pattern but !EOF text? */
959 /* '*' in the pattern? */
963 /* The pattern ends afterwards? Speed up the return. */
969 /* Else, set wildcard mode and remember position after '*' */
974 /* Character range specification? */
977 memset(charmap, '\0', sizeof(charmap));
979 while (*++pat != ']')
985 else if (*pat == '-')
987 if ((*++pat == ']') || *pat == '\0')
991 for (i = lastchar; i <= *pat; i++)
993 charmap[i / 8] |= (unsigned char)(1 << (i % 8));
998 charmap[*pat / 8] |= (unsigned char)(1 << (*pat % 8));
1002 } /* -END- if Character range specification */
1006 * Char match, or char range match?
1010 || ((*pat == ']') && (charmap[*txt / 8] & (1 << (*txt % 8)))))
1020 * No match && no wildcard: No luck
1024 else if (pat != fallback)
1027 * Increment text pointer if in char range matching
1034 * Wildcard mode && nonmatch beyond fallback: Rewind pattern
1038 * Restart matching from current text pointer
1045 /* Cut off extra '*'s */
1046 if (*pat == '*') pat++;
1048 /* If this is the pattern's end, fine! */
1054 /*********************************************************************
1056 * Function : simple_domaincmp
1058 * Description : Domain-wise Compare fqdn's. The comparison is
1059 * both left- and right-anchored. The individual
1060 * domain names are compared with simplematch().
1061 * This is only used by domain_match.
1064 * 1 : pv = array of patterns to compare
1065 * 2 : fv = array of domain components to compare
1066 * 3 : len = length of the arrays (both arrays are the
1067 * same length - if they weren't, it couldn't
1068 * possibly be a match).
1070 * Returns : 0 => domains are equivalent, else no match.
1072 *********************************************************************/
1073 static int simple_domaincmp(char **pv, char **fv, int len)
1077 for (n = 0; n < len; n++)
1079 if (simplematch(pv[n], fv[n]))
1090 /*********************************************************************
1092 * Function : domain_match
1094 * Description : Domain-wise Compare fqdn's. Governed by the bimap in
1095 * p.pattern->unachored, the comparison is un-, left-,
1096 * right-anchored, or both.
1097 * The individual domain names are compared with
1101 * 1 : p = a domain that may contain a '*' as a wildcard.
1102 * 2 : fqdn = domain name against which the patterns are compared.
1104 * Returns : 0 => domains are equivalent, else no match.
1106 *********************************************************************/
1107 static int domain_match(const struct pattern_spec *p, const struct http_request *fqdn)
1109 char **pv, **fv; /* vectors */
1111 int unanchored = p->pattern.url_spec.unanchored & (ANCHOR_RIGHT | ANCHOR_LEFT);
1113 plen = p->pattern.url_spec.dcount;
1114 flen = fqdn->dcount;
1118 /* fqdn is too short to match this pattern */
1122 pv = p->pattern.url_spec.dvec;
1125 if (unanchored == ANCHOR_LEFT)
1130 * Convert this into a fully anchored pattern with
1131 * the fqdn and pattern the same length
1133 fv += (flen - plen); /* flen - plen >= 0 due to check above */
1134 return simple_domaincmp(pv, fv, plen);
1136 else if (unanchored == 0)
1138 /* Fully anchored, check length */
1143 return simple_domaincmp(pv, fv, plen);
1145 else if (unanchored == ANCHOR_RIGHT)
1147 /* Left anchored, ignore all extra in fqdn */
1148 return simple_domaincmp(pv, fv, plen);
1154 int maxn = flen - plen;
1155 for (n = 0; n <= maxn; n++)
1157 if (!simple_domaincmp(pv, fv, plen))
1162 * Doesn't match from start of fqdn
1163 * Try skipping first part of fqdn
1173 /*********************************************************************
1175 * Function : create_pattern_spec
1177 * Description : Creates a "pattern_spec" structure from a string.
1178 * When finished, free with free_pattern_spec().
1181 * 1 : pattern = Target pattern_spec to be filled in.
1182 * Will be zeroed before use.
1183 * 2 : buf = Source pattern, null terminated. NOTE: The
1184 * contents of this buffer are destroyed by this
1185 * function. If this function succeeds, the
1186 * buffer is copied to pattern->spec. If this
1187 * function fails, the contents of the buffer
1190 * Returns : JB_ERR_OK - Success
1191 * JB_ERR_PARSE - Cannot parse regex (Detailed message
1192 * written to system log)
1194 *********************************************************************/
1195 jb_err create_pattern_spec(struct pattern_spec *pattern, char *buf)
1199 /** The tag pattern prefix to match */
1202 /** The length of the prefix to match */
1203 const size_t prefix_length;
1205 /** The pattern flag */
1206 const unsigned flag;
1208 { "TAG:", 4, PATTERN_SPEC_TAG_PATTERN},
1209 #ifdef FEATURE_CLIENT_TAGS
1210 { "CLIENT-TAG:", 11, PATTERN_SPEC_CLIENT_TAG_PATTERN},
1212 { "NO-REQUEST-TAG:", 15, PATTERN_SPEC_NO_REQUEST_TAG_PATTERN},
1213 { "NO-RESPONSE-TAG:", 16, PATTERN_SPEC_NO_RESPONSE_TAG_PATTERN}
1220 memset(pattern, '\0', sizeof(*pattern));
1222 /* Remember the original specification for the CGI pages. */
1223 pattern->spec = strdup_or_die(buf);
1225 /* Check if it's a tag pattern */
1226 for (i = 0; i < SZ(tag_pattern); i++)
1228 if (0 == strncmpic(pattern->spec, tag_pattern[i].prefix, tag_pattern[i].prefix_length))
1230 /* The regex starts after the prefix */
1231 const char *tag_regex = buf + tag_pattern[i].prefix_length;
1233 pattern->flags |= tag_pattern[i].flag;
1235 return compile_pattern(tag_regex, NO_ANCHORING, pattern,
1236 &pattern->pattern.tag_regex);
1240 /* If it isn't a tag pattern it must be an URL pattern. */
1241 pattern->flags |= PATTERN_SPEC_URL_PATTERN;
1243 return compile_url_pattern(pattern, buf);
1248 /*********************************************************************
1250 * Function : free_pattern_spec
1252 * Description : Called from the "unloaders". Freez the pattern
1253 * structure elements.
1256 * 1 : pattern = pointer to a pattern_spec structure.
1260 *********************************************************************/
1261 void free_pattern_spec(struct pattern_spec *pattern)
1263 if (pattern == NULL) return;
1265 freez(pattern->spec);
1266 #ifdef FEATURE_PCRE_HOST_PATTERNS
1267 if (pattern->pattern.url_spec.host_regex)
1269 regfree(pattern->pattern.url_spec.host_regex);
1270 freez(pattern->pattern.url_spec.host_regex);
1272 #endif /* def FEATURE_PCRE_HOST_PATTERNS */
1273 freez(pattern->pattern.url_spec.dbuffer);
1274 freez(pattern->pattern.url_spec.dvec);
1275 pattern->pattern.url_spec.dcount = 0;
1276 freez(pattern->pattern.url_spec.port_list);
1277 if (pattern->pattern.url_spec.preg)
1279 regfree(pattern->pattern.url_spec.preg);
1280 freez(pattern->pattern.url_spec.preg);
1282 if (pattern->pattern.tag_regex)
1284 regfree(pattern->pattern.tag_regex);
1285 freez(pattern->pattern.tag_regex);
1290 /*********************************************************************
1292 * Function : port_matches
1294 * Description : Compares a port against a port list.
1297 * 1 : port = The port to check.
1298 * 2 : port_list = The list of port to compare with.
1300 * Returns : TRUE for yes, FALSE otherwise.
1302 *********************************************************************/
1303 static int port_matches(const int port, const char *port_list)
1305 return ((NULL == port_list) || match_portlist(port_list, port));
1309 /*********************************************************************
1311 * Function : host_matches
1313 * Description : Compares a host against a host pattern.
1316 * 1 : url = The URL to match
1317 * 2 : pattern = The URL pattern
1319 * Returns : TRUE for yes, FALSE otherwise.
1321 *********************************************************************/
1322 static int host_matches(const struct http_request *http,
1323 const struct pattern_spec *pattern)
1325 assert(http->host != NULL);
1326 #ifdef FEATURE_PCRE_HOST_PATTERNS
1327 if (pattern->pattern.url_spec.host_regex_type == PCRE_HOST_PATTERN)
1329 return ((NULL == pattern->pattern.url_spec.host_regex)
1330 || (0 == regexec(pattern->pattern.url_spec.host_regex,
1331 http->host, 0, NULL, 0)));
1334 return ((NULL == pattern->pattern.url_spec.dbuffer) || (0 == domain_match(pattern, http)));
1338 /*********************************************************************
1340 * Function : path_matches
1342 * Description : Compares a path against a path pattern.
1345 * 1 : path = The path to match
1346 * 2 : pattern = The URL pattern
1348 * Returns : TRUE for yes, FALSE otherwise.
1350 *********************************************************************/
1351 static int path_matches(const char *path, const struct pattern_spec *pattern)
1353 return ((NULL == pattern->pattern.url_spec.preg)
1354 || (0 == regexec(pattern->pattern.url_spec.preg, path, 0, NULL, 0)));
1358 /*********************************************************************
1360 * Function : url_match
1362 * Description : Compare a URL against a URL pattern.
1365 * 1 : pattern = a URL pattern
1366 * 2 : url = URL to match
1368 * Returns : Nonzero if the URL matches the pattern, else 0.
1370 *********************************************************************/
1371 int url_match(const struct pattern_spec *pattern,
1372 const struct http_request *http)
1374 if (!(pattern->flags & PATTERN_SPEC_URL_PATTERN))
1376 /* It's not an URL pattern and thus shouldn't be matched against URLs */
1380 return (port_matches(http->port, pattern->pattern.url_spec.port_list)
1381 && host_matches(http, pattern) && path_matches(http->path, pattern));
1386 /*********************************************************************
1388 * Function : match_portlist
1390 * Description : Check if a given number is covered by a comma
1391 * separated list of numbers and ranges (a,b-c,d,..)
1394 * 1 : portlist = String with list
1395 * 2 : port = port to check
1397 * Returns : 0 => no match
1400 *********************************************************************/
1401 int match_portlist(const char *portlist, int port)
1403 char *min, *max, *next, *portlist_copy;
1405 min = portlist_copy = strdup_or_die(portlist);
1408 * Zero-terminate first item and remember offset for next
1410 if (NULL != (next = strchr(portlist_copy, (int) ',')))
1416 * Loop through all items, checking for match
1420 if (NULL == (max = strchr(min, (int) '-')))
1423 * No dash, check for equality
1425 if (port == atoi(min))
1427 freez(portlist_copy);
1434 * This is a range, so check if between min and max,
1435 * or, if max was omitted, between min and 65K
1438 if (port >= atoi(min) && port <= (atoi(max) ? atoi(max) : 65535))
1440 freez(portlist_copy);
1452 * Zero-terminate next item and remember offset for n+1
1454 if ((NULL != next) && (NULL != (next = strchr(next, (int) ','))))
1460 freez(portlist_copy);
1466 /*********************************************************************
1468 * Function : parse_forwarder_address
1470 * Description : Parse out the username, password, host and port from
1471 * a forwarder address.
1474 * 1 : address = The forwarder address to parse.
1475 * 2 : hostname = Used to return the hostname. NULL on error.
1476 * 3 : port = Used to return the port. Untouched if no port
1478 * 4 : username = Used to return the username if any.
1479 * 5 : password = Used to return the password if any.
1481 * Returns : JB_ERR_OK on success
1482 * JB_ERR_MEMORY on out of memory
1483 * JB_ERR_PARSE on malformed address.
1485 *********************************************************************/
1486 jb_err parse_forwarder_address(char *address, char **hostname, int *port,
1487 char **username, char **password)
1492 tmp = *hostname = strdup_or_die(address);
1494 /* Parse username and password */
1495 if (username && password && (NULL != (p = strchr(*hostname, '@'))))
1498 *username = strdup_or_die(*hostname);
1499 *hostname = strdup_or_die(p);
1501 if (NULL != (p = strchr(*username, ':')))
1504 *password = strdup_or_die(p);
1509 /* Parse hostname and port */
1511 if ((*p == '[') && (NULL == strchr(p, ']')))
1513 /* XXX: Should do some more validity checks here. */
1514 return JB_ERR_PARSE;
1517 if ((**hostname == '[') && (NULL != (p = strchr(*hostname, ']'))))
1520 memmove(*hostname, (*hostname + 1), (size_t)(p - *hostname));
1523 *port = (int)strtol(++p, NULL, 0);
1526 else if (NULL != (p = strchr(*hostname, ':')))
1529 *port = (int)strtol(p, NULL, 0);