freshlybakedca.ke
Git fork
1#define DISABLE_SIGN_COMPARE_WARNINGS
2
3#include "git-compat-util.h"
4#include "gettext.h"
5#include "hex-ll.h"
6#include "strbuf.h"
7#include "urlmatch.h"
8
9#define URL_ALPHA "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
10#define URL_DIGIT "0123456789"
11#define URL_ALPHADIGIT URL_ALPHA URL_DIGIT
12#define URL_SCHEME_CHARS URL_ALPHADIGIT "+.-"
13#define URL_HOST_CHARS URL_ALPHADIGIT ".-_[:]" /* IPv6 literals need [:] */
14#define URL_UNSAFE_CHARS " <>\"%{}|\\^`" /* plus 0x00-0x1F,0x7F-0xFF */
15#define URL_GEN_RESERVED ":/?#[]@"
16#define URL_SUB_RESERVED "!$&'()*+,;="
17#define URL_RESERVED URL_GEN_RESERVED URL_SUB_RESERVED /* only allowed delims */
18
19static int append_normalized_escapes(struct strbuf *buf,
20 const char *from,
21 size_t from_len,
22 const char *esc_extra,
23 const char *esc_ok)
24{
25 /*
26 * Append to strbuf 'buf' characters from string 'from' with length
27 * 'from_len' while unescaping characters that do not need to be escaped
28 * and escaping characters that do. The set of characters to escape
29 * (the complement of which is unescaped) starts out as the RFC 3986
30 * unsafe characters (0x00-0x1F,0x7F-0xFF," <>\"#%{}|\\^`"). If
31 * 'esc_extra' is not NULL, those additional characters will also always
32 * be escaped. If 'esc_ok' is not NULL, those characters will be left
33 * escaped if found that way, but will not be unescaped otherwise (used
34 * for delimiters). If a %-escape sequence is encountered that is not
35 * followed by 2 hexadecimal digits, the sequence is invalid and
36 * false (0) will be returned. Otherwise true (1) will be returned for
37 * success.
38 *
39 * Note that all %-escape sequences will be normalized to UPPERCASE
40 * as indicated in RFC 3986. Unless included in esc_extra or esc_ok
41 * alphanumerics and "-._~" will always be unescaped as per RFC 3986.
42 */
43
44 while (from_len) {
45 int ch = *from++;
46 int was_esc = 0;
47
48 from_len--;
49 if (ch == '%') {
50 if (from_len < 2)
51 return 0;
52 ch = hex2chr(from);
53 if (ch < 0)
54 return 0;
55 from += 2;
56 from_len -= 2;
57 was_esc = 1;
58 }
59 if ((unsigned char)ch <= 0x1F || (unsigned char)ch >= 0x7F ||
60 strchr(URL_UNSAFE_CHARS, ch) ||
61 (esc_extra && strchr(esc_extra, ch)) ||
62 (was_esc && strchr(esc_ok, ch)))
63 strbuf_addf(buf, "%%%02X", (unsigned char)ch);
64 else
65 strbuf_addch(buf, ch);
66 }
67
68 return 1;
69}
70
71static const char *end_of_token(const char *s, int c, size_t n)
72{
73 const char *next = memchr(s, c, n);
74 if (!next)
75 next = s + n;
76 return next;
77}
78
79static int match_host(const struct url_info *url_info,
80 const struct url_info *pattern_info)
81{
82 const char *url = url_info->url + url_info->host_off;
83 const char *pat = pattern_info->url + pattern_info->host_off;
84 int url_len = url_info->host_len;
85 int pat_len = pattern_info->host_len;
86
87 while (url_len && pat_len) {
88 const char *url_next = end_of_token(url, '.', url_len);
89 const char *pat_next = end_of_token(pat, '.', pat_len);
90
91 if (pat_next == pat + 1 && pat[0] == '*')
92 /* wildcard matches anything */
93 ;
94 else if ((pat_next - pat) == (url_next - url) &&
95 !memcmp(url, pat, url_next - url))
96 /* the components are the same */
97 ;
98 else
99 return 0; /* found an unmatch */
100
101 if (url_next < url + url_len)
102 url_next++;
103 url_len -= url_next - url;
104 url = url_next;
105 if (pat_next < pat + pat_len)
106 pat_next++;
107 pat_len -= pat_next - pat;
108 pat = pat_next;
109 }
110
111 return (!url_len && !pat_len);
112}
113
114static char *url_normalize_1(const char *url, struct url_info *out_info, char allow_globs)
115{
116 /*
117 * Normalize NUL-terminated url using the following rules:
118 *
119 * 1. Case-insensitive parts of url will be converted to lower case
120 * 2. %-encoded characters that do not need to be will be unencoded
121 * 3. Characters that are not %-encoded and must be will be encoded
122 * 4. All %-encodings will be converted to upper case hexadecimal
123 * 5. Leading 0s are removed from port numbers
124 * 6. If the default port for the scheme is given it will be removed
125 * 7. A path part (including empty) not starting with '/' has one added
126 * 8. Any dot segments (. or ..) in the path are resolved and removed
127 * 9. IPv6 host literals are allowed (but not normalized or validated)
128 *
129 * The rules are based on information in RFC 3986.
130 *
131 * Please note this function requires a full URL including a scheme
132 * and host part (except for file: URLs which may have an empty host).
133 *
134 * The return value is a newly allocated string that must be freed
135 * or NULL if the url is not valid.
136 *
137 * If out_info is non-NULL, the url and err fields therein will always
138 * be set. If a non-NULL value is returned, it will be stored in
139 * out_info->url as well, out_info->err will be set to NULL and the
140 * other fields of *out_info will also be filled in. If a NULL value
141 * is returned, NULL will be stored in out_info->url and out_info->err
142 * will be set to a brief, translated, error message, but no other
143 * fields will be filled in.
144 *
145 * This is NOT a URL validation function. Full URL validation is NOT
146 * performed. Some invalid host names are passed through this function
147 * undetected. However, most all other problems that make a URL invalid
148 * will be detected (including a missing host for non file: URLs).
149 */
150
151 size_t url_len = strlen(url);
152 struct strbuf norm;
153 size_t spanned;
154 size_t scheme_len, user_off=0, user_len=0, passwd_off=0, passwd_len=0;
155 size_t host_off=0, host_len=0, port_off=0, port_len=0, path_off, path_len, result_len;
156 const char *slash_ptr, *at_ptr, *colon_ptr, *path_start;
157 char *result;
158
159 /*
160 * Copy lowercased scheme and :// suffix, %-escapes are not allowed
161 * First character of scheme must be URL_ALPHA
162 */
163 spanned = strspn(url, URL_SCHEME_CHARS);
164 if (!spanned || !isalpha(url[0]) || spanned + 3 > url_len ||
165 url[spanned] != ':' || url[spanned+1] != '/' || url[spanned+2] != '/') {
166 if (out_info) {
167 out_info->url = NULL;
168 out_info->err = _("invalid URL scheme name or missing '://' suffix");
169 }
170 return NULL; /* Bad scheme and/or missing "://" part */
171 }
172 strbuf_init(&norm, url_len);
173 scheme_len = spanned;
174 spanned += 3;
175 url_len -= spanned;
176 while (spanned--)
177 strbuf_addch(&norm, tolower(*url++));
178
179
180 /*
181 * Copy any username:password if present normalizing %-escapes
182 */
183 at_ptr = strchr(url, '@');
184 slash_ptr = url + strcspn(url, "/?#");
185 if (at_ptr && at_ptr < slash_ptr) {
186 user_off = norm.len;
187 if (at_ptr > url) {
188 if (!append_normalized_escapes(&norm, url, at_ptr - url,
189 "", URL_RESERVED)) {
190 if (out_info) {
191 out_info->url = NULL;
192 out_info->err = _("invalid %XX escape sequence");
193 }
194 strbuf_release(&norm);
195 return NULL;
196 }
197 colon_ptr = strchr(norm.buf + scheme_len + 3, ':');
198 if (colon_ptr) {
199 passwd_off = (colon_ptr + 1) - norm.buf;
200 passwd_len = norm.len - passwd_off;
201 user_len = (passwd_off - 1) - (scheme_len + 3);
202 } else {
203 user_len = norm.len - (scheme_len + 3);
204 }
205 }
206 strbuf_addch(&norm, '@');
207 url_len -= (++at_ptr - url);
208 url = at_ptr;
209 }
210
211
212 /*
213 * Copy the host part excluding any port part, no %-escapes allowed
214 */
215 if (!url_len || strchr(":/?#", *url)) {
216 /* Missing host invalid for all URL schemes except file */
217 if (!starts_with(norm.buf, "file:")) {
218 if (out_info) {
219 out_info->url = NULL;
220 out_info->err = _("missing host and scheme is not 'file:'");
221 }
222 strbuf_release(&norm);
223 return NULL;
224 }
225 } else {
226 host_off = norm.len;
227 }
228 colon_ptr = slash_ptr - 1;
229 while (colon_ptr > url && *colon_ptr != ':' && *colon_ptr != ']')
230 colon_ptr--;
231 if (*colon_ptr != ':') {
232 colon_ptr = slash_ptr;
233 } else if (!host_off && colon_ptr < slash_ptr && colon_ptr + 1 != slash_ptr) {
234 /* file: URLs may not have a port number */
235 if (out_info) {
236 out_info->url = NULL;
237 out_info->err = _("a 'file:' URL may not have a port number");
238 }
239 strbuf_release(&norm);
240 return NULL;
241 }
242
243 if (allow_globs)
244 spanned = strspn(url, URL_HOST_CHARS "*");
245 else
246 spanned = strspn(url, URL_HOST_CHARS);
247
248 if (spanned < colon_ptr - url) {
249 /* Host name has invalid characters */
250 if (out_info) {
251 out_info->url = NULL;
252 out_info->err = _("invalid characters in host name");
253 }
254 strbuf_release(&norm);
255 return NULL;
256 }
257 while (url < colon_ptr) {
258 strbuf_addch(&norm, tolower(*url++));
259 url_len--;
260 }
261
262
263 /*
264 * Check the port part and copy if not the default (after removing any
265 * leading 0s); no %-escapes allowed
266 */
267 if (colon_ptr < slash_ptr) {
268 /* skip the ':' and leading 0s but not the last one if all 0s */
269 url++;
270 url += strspn(url, "0");
271 if (url == slash_ptr && url[-1] == '0')
272 url--;
273 if (url == slash_ptr) {
274 /* Skip ":" port with no number, it's same as default */
275 } else if (slash_ptr - url == 2 &&
276 starts_with(norm.buf, "http:") &&
277 !strncmp(url, "80", 2)) {
278 /* Skip http :80 as it's the default */
279 } else if (slash_ptr - url == 3 &&
280 starts_with(norm.buf, "https:") &&
281 !strncmp(url, "443", 3)) {
282 /* Skip https :443 as it's the default */
283 } else {
284 /*
285 * Port number must be all digits with leading 0s removed
286 * and since all the protocols we deal with have a 16-bit
287 * port number it must also be in the range 1..65535
288 * 0 is not allowed because that means "next available"
289 * on just about every system and therefore cannot be used
290 */
291 unsigned long pnum = 0;
292 spanned = strspn(url, URL_DIGIT);
293 if (spanned < slash_ptr - url) {
294 /* port number has invalid characters */
295 if (out_info) {
296 out_info->url = NULL;
297 out_info->err = _("invalid port number");
298 }
299 strbuf_release(&norm);
300 return NULL;
301 }
302 if (slash_ptr - url <= 5)
303 pnum = strtoul(url, NULL, 10);
304 if (pnum == 0 || pnum > 65535) {
305 /* port number not in range 1..65535 */
306 if (out_info) {
307 out_info->url = NULL;
308 out_info->err = _("invalid port number");
309 }
310 strbuf_release(&norm);
311 return NULL;
312 }
313 strbuf_addch(&norm, ':');
314 port_off = norm.len;
315 strbuf_add(&norm, url, slash_ptr - url);
316 port_len = slash_ptr - url;
317 }
318 url_len -= slash_ptr - colon_ptr;
319 url = slash_ptr;
320 }
321 if (host_off)
322 host_len = norm.len - host_off - (port_len ? port_len + 1 : 0);
323
324
325 /*
326 * Now copy the path resolving any . and .. segments being careful not
327 * to corrupt the URL by unescaping any delimiters, but do add an
328 * initial '/' if it's missing and do normalize any %-escape sequences.
329 */
330 path_off = norm.len;
331 path_start = norm.buf + path_off;
332 strbuf_addch(&norm, '/');
333 if (*url == '/') {
334 url++;
335 url_len--;
336 }
337 for (;;) {
338 const char *seg_start;
339 size_t seg_start_off = norm.len;
340 const char *next_slash = url + strcspn(url, "/?#");
341 int skip_add_slash = 0;
342
343 /*
344 * RFC 3689 indicates that any . or .. segments should be
345 * unescaped before being checked for.
346 */
347 if (!append_normalized_escapes(&norm, url, next_slash - url, "",
348 URL_RESERVED)) {
349 if (out_info) {
350 out_info->url = NULL;
351 out_info->err = _("invalid %XX escape sequence");
352 }
353 strbuf_release(&norm);
354 return NULL;
355 }
356
357 seg_start = norm.buf + seg_start_off;
358 if (!strcmp(seg_start, ".")) {
359 /* ignore a . segment; be careful not to remove initial '/' */
360 if (seg_start == path_start + 1) {
361 strbuf_setlen(&norm, norm.len - 1);
362 skip_add_slash = 1;
363 } else {
364 strbuf_setlen(&norm, norm.len - 2);
365 }
366 } else if (!strcmp(seg_start, "..")) {
367 /*
368 * ignore a .. segment and remove the previous segment;
369 * be careful not to remove initial '/' from path
370 */
371 const char *prev_slash = norm.buf + norm.len - 3;
372 if (prev_slash == path_start) {
373 /* invalid .. because no previous segment to remove */
374 if (out_info) {
375 out_info->url = NULL;
376 out_info->err = _("invalid '..' path segment");
377 }
378 strbuf_release(&norm);
379 return NULL;
380 }
381 while (*--prev_slash != '/') {}
382 if (prev_slash == path_start) {
383 strbuf_setlen(&norm, prev_slash - norm.buf + 1);
384 skip_add_slash = 1;
385 } else {
386 strbuf_setlen(&norm, prev_slash - norm.buf);
387 }
388 }
389 url_len -= next_slash - url;
390 url = next_slash;
391 /* if the next char is not '/' done with the path */
392 if (*url != '/')
393 break;
394 url++;
395 url_len--;
396 if (!skip_add_slash)
397 strbuf_addch(&norm, '/');
398 }
399 path_len = norm.len - path_off;
400
401
402 /*
403 * Now simply copy the rest, if any, only normalizing %-escapes and
404 * being careful not to corrupt the URL by unescaping any delimiters.
405 */
406 if (*url) {
407 if (!append_normalized_escapes(&norm, url, url_len, "", URL_RESERVED)) {
408 if (out_info) {
409 out_info->url = NULL;
410 out_info->err = _("invalid %XX escape sequence");
411 }
412 strbuf_release(&norm);
413 return NULL;
414 }
415 }
416
417
418 result = strbuf_detach(&norm, &result_len);
419 if (out_info) {
420 out_info->url = result;
421 out_info->err = NULL;
422 out_info->url_len = result_len;
423 out_info->scheme_len = scheme_len;
424 out_info->user_off = user_off;
425 out_info->user_len = user_len;
426 out_info->passwd_off = passwd_off;
427 out_info->passwd_len = passwd_len;
428 out_info->host_off = host_off;
429 out_info->host_len = host_len;
430 out_info->port_off = port_off;
431 out_info->port_len = port_len;
432 out_info->path_off = path_off;
433 out_info->path_len = path_len;
434 }
435 return result;
436}
437
438char *url_normalize(const char *url, struct url_info *out_info)
439{
440 return url_normalize_1(url, out_info, 0);
441}
442
443static size_t url_match_prefix(const char *url,
444 const char *url_prefix,
445 size_t url_prefix_len)
446{
447 /*
448 * url_prefix matches url if url_prefix is an exact match for url or it
449 * is a prefix of url and the match ends on a path component boundary.
450 * Both url and url_prefix are considered to have an implicit '/' on the
451 * end for matching purposes if they do not already.
452 *
453 * url must be NUL terminated. url_prefix_len is the length of
454 * url_prefix which need not be NUL terminated.
455 *
456 * The return value is the length of the match in characters (including
457 * the final '/' even if it's implicit) or 0 for no match.
458 *
459 * Passing NULL as url and/or url_prefix will always cause 0 to be
460 * returned without causing any faults.
461 */
462 if (!url || !url_prefix)
463 return 0;
464 if (!url_prefix_len || (url_prefix_len == 1 && *url_prefix == '/'))
465 return (!*url || *url == '/') ? 1 : 0;
466 if (url_prefix[url_prefix_len - 1] == '/')
467 url_prefix_len--;
468 if (strncmp(url, url_prefix, url_prefix_len))
469 return 0;
470 if ((strlen(url) == url_prefix_len) || (url[url_prefix_len] == '/'))
471 return url_prefix_len + 1;
472 return 0;
473}
474
475static int match_urls(const struct url_info *url,
476 const struct url_info *url_prefix,
477 struct urlmatch_item *match)
478{
479 /*
480 * url_prefix matches url if the scheme, host and port of url_prefix
481 * are the same as those of url and the path portion of url_prefix
482 * is the same as the path portion of url or it is a prefix that
483 * matches at a '/' boundary. If url_prefix contains a user name,
484 * that must also exactly match the user name in url.
485 *
486 * If the user, host, port and path match in this fashion, the returned
487 * value is the length of the path match including any implicit
488 * final '/'. For example, "http://me@example.com/path" is matched by
489 * "http://example.com" with a path length of 1.
490 *
491 * If there is a match and exactusermatch is not NULL, then
492 * *exactusermatch will be set to true if both url and url_prefix
493 * contained a user name or false if url_prefix did not have a
494 * user name. If there is no match *exactusermatch is left untouched.
495 */
496 char usermatched = 0;
497 size_t pathmatchlen;
498
499 if (!url || !url_prefix || !url->url || !url_prefix->url)
500 return 0;
501
502 /* check the scheme */
503 if (url_prefix->scheme_len != url->scheme_len ||
504 strncmp(url->url, url_prefix->url, url->scheme_len))
505 return 0; /* schemes do not match */
506
507 /* check the user name if url_prefix has one */
508 if (url_prefix->user_off) {
509 if (!url->user_off || url->user_len != url_prefix->user_len ||
510 strncmp(url->url + url->user_off,
511 url_prefix->url + url_prefix->user_off,
512 url->user_len))
513 return 0; /* url_prefix has a user but it's not a match */
514 usermatched = 1;
515 }
516
517 /* check the host */
518 if (!match_host(url, url_prefix))
519 return 0; /* host names do not match */
520
521 /* check the port */
522 if (url_prefix->port_len != url->port_len ||
523 strncmp(url->url + url->port_off,
524 url_prefix->url + url_prefix->port_off, url->port_len))
525 return 0; /* ports do not match */
526
527 /* check the path */
528 pathmatchlen = url_match_prefix(
529 url->url + url->path_off,
530 url_prefix->url + url_prefix->path_off,
531 url_prefix->url_len - url_prefix->path_off);
532 if (!pathmatchlen)
533 return 0; /* paths do not match */
534
535 if (match) {
536 match->hostmatch_len = url_prefix->host_len;
537 match->pathmatch_len = pathmatchlen;
538 match->user_matched = usermatched;
539 }
540
541 return 1;
542}
543
544static int cmp_matches(const struct urlmatch_item *a,
545 const struct urlmatch_item *b)
546{
547 if (a->hostmatch_len != b->hostmatch_len)
548 return a->hostmatch_len < b->hostmatch_len ? -1 : 1;
549 if (a->pathmatch_len != b->pathmatch_len)
550 return a->pathmatch_len < b->pathmatch_len ? -1 : 1;
551 if (a->user_matched != b->user_matched)
552 return b->user_matched ? -1 : 1;
553 return 0;
554}
555
556int urlmatch_config_entry(const char *var, const char *value,
557 const struct config_context *ctx, void *cb)
558{
559 struct string_list_item *item;
560 struct urlmatch_config *collect = cb;
561 struct urlmatch_item matched = {0};
562 struct url_info *url = &collect->url;
563 const char *key, *dot;
564 struct strbuf synthkey = STRBUF_INIT;
565 int retval;
566 int (*select_fn)(const struct urlmatch_item *a, const struct urlmatch_item *b) =
567 collect->select_fn ? collect->select_fn : cmp_matches;
568
569 if (!skip_prefix(var, collect->section, &key) || *(key++) != '.') {
570 if (collect->cascade_fn)
571 return collect->cascade_fn(var, value, ctx, cb);
572 return 0; /* not interested */
573 }
574 dot = strrchr(key, '.');
575 if (dot) {
576 char *config_url, *norm_url;
577 struct url_info norm_info;
578
579 config_url = xmemdupz(key, dot - key);
580 norm_url = url_normalize_1(config_url, &norm_info, 1);
581 if (norm_url)
582 retval = match_urls(url, &norm_info, &matched);
583 else if (collect->fallback_match_fn)
584 retval = collect->fallback_match_fn(config_url,
585 collect->cb);
586 else
587 retval = 0;
588 free(config_url);
589 free(norm_url);
590 if (!retval)
591 return 0;
592 key = dot + 1;
593 }
594
595 if (collect->key && strcmp(key, collect->key))
596 return 0;
597
598 item = string_list_insert(&collect->vars, key);
599 if (!item->util) {
600 item->util = xcalloc(1, sizeof(matched));
601 } else {
602 if (select_fn(&matched, item->util) < 0)
603 /*
604 * Our match is worse than the old one,
605 * we cannot use it.
606 */
607 return 0;
608 /* Otherwise, replace it with this one. */
609 }
610
611 memcpy(item->util, &matched, sizeof(matched));
612 strbuf_addstr(&synthkey, collect->section);
613 strbuf_addch(&synthkey, '.');
614 strbuf_addstr(&synthkey, key);
615 retval = collect->collect_fn(synthkey.buf, value, ctx, collect->cb);
616
617 strbuf_release(&synthkey);
618 return retval;
619}
620
621void urlmatch_config_release(struct urlmatch_config *config)
622{
623 string_list_clear(&config->vars, 1);
624}