2 * Copyright (c) 2022, 2024 Omar Polo <op@omarpolo.com>
4 * Permission to use, copy, modify, and distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
29 /* TODO: URI -> IRI. accept IRI but emit always URI */
32 cpstr(const char *start, const char *till, char *buf, size_t len)
34 size_t slen = till - start;
38 memcpy(buf, start, slen);
46 return (isalnum((unsigned char)c) ||
58 return (t[0] == '%' &&
59 isxdigit((unsigned char)t[1]) &&
60 isxdigit((unsigned char)t[2]));
66 return (c == '!' || c == '$' || c == '&' || c == '\'' ||
67 c == '(' || c == ')' || c == '*' || c == '+' || c == ',' ||
68 c == ';' || c == '=');
71 static inline const char *
72 advance_pchar(const char *s)
74 if (unreserved(*s) || sub_delims(*s) || *s == ':' || *s == '@')
81 static inline const char *
82 advance_segment(const char *s)
86 while ((t = advance_pchar(s)) != NULL)
91 static inline const char *
92 advance_segment_nz(const char *s)
96 if ((t = advance_pchar(s)) == NULL)
98 return (advance_segment(t));
101 static inline const char *
102 advance_segment_nz_nc(const char *s)
107 if (unreserved(*t) || sub_delims(*t) || *t == '@')
115 return (t != s ? t : NULL);
119 parse_scheme(const char *s, struct iri *iri)
123 if (!isalpha((unsigned char)*t))
126 while (isalnum((unsigned char)*t) ||
132 if (cpstr(s, t, iri->iri_scheme, sizeof(iri->iri_scheme)) == -1)
135 iri->iri_flags |= IH_SCHEME;
139 /* userinfo is always optional */
141 parse_uinfo(const char *s, struct iri *iri)
146 if (unreserved(*t) || sub_delims(*t) || *t == ':')
157 if (cpstr(s, t, iri->iri_uinfo, sizeof(iri->iri_uinfo)) == -1)
159 iri->iri_flags |= IH_UINFO;
164 parse_host(const char *s, struct iri *iri)
169 * cheating a bit by relaxing and merging the rule for
170 * IPv6address and IPvFuture and by merging IPv4address and
175 while (*t && *t != ']')
180 if (cpstr(s, t, iri->iri_host, sizeof(iri->iri_host)) == -1)
182 iri->iri_flags |= IH_HOST;
187 if (unreserved(*t) || sub_delims(*t))
195 if (cpstr(s, t, iri->iri_host, sizeof(iri->iri_host)) == -1)
197 iri->iri_flags |= IH_HOST;
202 parse_port(const char *s, struct iri *iri)
207 while (isdigit((unsigned char)*t))
209 if (cpstr(s, t, iri->iri_portstr, sizeof(iri->iri_portstr)) == -1)
211 iri->iri_port = strtonum(iri->iri_portstr, 1, UINT16_MAX, &errstr);
214 iri->iri_flags |= IH_PORT;
219 parse_authority(const char *s, struct iri *iri)
223 if ((t = parse_uinfo(s, iri)) == NULL)
226 if ((t = parse_host(t, iri)) == NULL)
230 return (parse_port(t + 1, iri));
236 parse_path_abempty(const char *s, struct iri *iri)
241 t = advance_segment(t + 1);
243 if (cpstr(s, t, iri->iri_path, sizeof(iri->iri_path)) == -1)
245 iri->iri_flags |= IH_PATH;
250 parse_path_absolute(const char *s, struct iri *iri)
257 if ((t = advance_segment_nz(s + 1)) == NULL)
261 t = advance_segment(t + 1);
264 if (cpstr(s, t, iri->iri_path, sizeof(iri->iri_path)) == -1)
266 iri->iri_flags |= IH_PATH;
271 parse_path_rootless(const char *s, struct iri *iri)
275 if ((t = advance_segment_nz(s)) == NULL)
279 t = advance_segment(t + 1);
281 if (cpstr(s, t, iri->iri_path, sizeof(iri->iri_path)) == -1)
283 iri->iri_flags |= IH_PATH;
288 parse_path_noscheme(const char *s, struct iri *iri)
292 if ((t = advance_segment_nz_nc(s)) == NULL)
296 t = advance_segment(t + 1);
298 if (cpstr(s, t, iri->iri_path, sizeof(iri->iri_path)) == -1)
300 iri->iri_flags |= IH_PATH;
305 parse_path_empty(const char *s, struct iri *iri)
307 iri->iri_path[0] = '\0';
308 iri->iri_flags |= IH_PATH;
313 parse_hier(const char *s, struct iri *iri)
317 if (!strncmp(s, "//", 2)) {
318 if ((t = parse_authority(s + 2, iri)) == NULL)
320 return (parse_path_abempty(t, iri));
323 if ((t = parse_path_absolute(s, iri)) != NULL)
326 if ((t = parse_path_rootless(s, iri)) != NULL)
329 return (parse_path_empty(s, iri));
333 parse_relative(const char *s, struct iri *iri)
337 if (!strncmp(s, "//", 2)) {
338 if ((t = parse_authority(s + 2, iri)) == NULL)
340 return (parse_path_abempty(t, iri));
343 if ((t = parse_path_absolute(s, iri)) != NULL)
346 if ((t = parse_path_noscheme(s, iri)) != NULL)
349 return (parse_path_empty(s, iri));
353 parse_qf(const char *s, int flag, struct iri *iri, char *buf, size_t bufsize)
355 const char *n, *t = s;
358 if ((n = advance_pchar(t)) != NULL)
360 else if (*t == '/' || *t == '?')
366 if (cpstr(s, t, buf, bufsize) == -1)
368 iri->iri_flags |= flag;
373 parse_uri(const char *s, struct iri *iri)
377 if ((s = parse_scheme(s, iri)) == NULL)
383 if ((s = parse_hier(s + 1, iri)) == NULL)
387 s = parse_qf(s + 1, IH_QUERY, iri, iri->iri_query,
388 sizeof(iri->iri_query));
394 s = parse_qf(s + 1, IH_FRAGMENT, iri, iri->iri_fragment,
395 sizeof(iri->iri_fragment));
407 parse_relative_ref(const char *s, struct iri *iri)
409 if ((s = parse_relative(s, iri)) == NULL)
413 s = parse_qf(s + 1, IH_QUERY, iri, iri->iri_query,
414 sizeof(iri->iri_query));
420 s = parse_qf(s + 1, IH_FRAGMENT, iri, iri->iri_fragment,
421 sizeof(iri->iri_fragment));
433 parse(const char *s, struct iri *iri)
440 if (parse_uri(s, iri) == -1) {
442 if (parse_relative_ref(s, iri) == -1)
453 *s = tolower((unsigned char)*s);
457 cpfields(struct iri *dest, const struct iri *src, int flags)
459 if (flags & IH_SCHEME) {
460 dest->iri_flags |= IH_SCHEME;
461 if (src->iri_flags & IH_SCHEME)
462 memcpy(dest->iri_scheme, src->iri_scheme,
463 sizeof(dest->iri_scheme));
464 lowerify(dest->iri_scheme);
466 if (flags & IH_UINFO) {
467 if (src->iri_flags & IH_UINFO) {
468 memcpy(dest->iri_uinfo, src->iri_uinfo,
469 sizeof(dest->iri_uinfo));
470 dest->iri_flags |= IH_UINFO;
473 if (flags & IH_HOST) {
474 dest->iri_flags |= IH_HOST;
475 if (src->iri_flags & IH_HOST)
476 memcpy(dest->iri_host, src->iri_host,
477 sizeof(dest->iri_host));
478 lowerify(dest->iri_host);
480 if (flags & IH_PORT) {
481 if (src->iri_flags & IH_PORT) {
482 dest->iri_port = src->iri_port;
483 memcpy(dest->iri_portstr, src->iri_portstr,
484 sizeof(dest->iri_portstr));
485 dest->iri_flags |= IH_PORT;
488 if (flags & IH_PATH) {
489 dest->iri_flags |= IH_PATH;
490 if (src->iri_flags & IH_PATH)
491 memcpy(dest->iri_path, src->iri_path,
492 sizeof(dest->iri_path));
494 if (flags & IH_QUERY) {
495 if (src->iri_flags & IH_QUERY) {
496 dest->iri_flags |= IH_QUERY;
497 memcpy(dest->iri_query, src->iri_query,
498 sizeof(dest->iri_query));
501 if (flags & IH_FRAGMENT) {
502 if (src->iri_flags & IH_FRAGMENT) {
503 dest->iri_flags |= IH_FRAGMENT;
504 memcpy(dest->iri_fragment, src->iri_fragment,
505 sizeof(dest->iri_fragment));
511 remove_dot_segments(char *buf, ptrdiff_t bufsize)
516 while (*p && (q - buf < bufsize)) {
517 if (p[0] == '/' && p[1] == '.' &&
518 (p[2] == '/' || p[2] == '\0')) {
522 } else if (p[0] == '/' && p[1] == '.' && p[2] == '.' &&
523 (p[3] == '/' || p[3] == '\0')) {
525 while (q > buf && *--q != '/')
527 if (*p != '/' && (q > buf && q[-1] != '/'))
532 if ((*p == '\0') && (q - buf < bufsize)) {
537 errno = ENAMETOOLONG;
542 mergepath(char *buf, size_t bufsize, int abs, const char *base, const char *r)
546 if (base == NULL || *base == '\0')
548 if (r == NULL || *r == '\0')
555 if (abs && (*base == '\0' || !strcmp(base, "/"))) {
558 strlcpy(buf, "/", bufsize);
559 strlcat(buf, r, bufsize);
563 if ((s = strrchr(base, '/')) != NULL) {
564 cpstr(base, s + 1, buf, bufsize);
568 if (strlcat(buf, r, bufsize) >= bufsize) {
569 errno = ENAMETOOLONG;
577 iri_parse(const char *base, const char *str, struct iri *iri)
579 static struct iri ibase, iparsed;
581 memset(iri, 0, sizeof(*iri));
585 if (parse_uri(str, &iparsed) == -1) {
590 if (parse_uri(base, &ibase) == -1 ||
591 parse(str, &iparsed) == -1) {
597 cpfields(iri, &iparsed, IH_FRAGMENT);
599 if (iparsed.iri_flags & IH_SCHEME) {
600 cpfields(iri, &iparsed, iparsed.iri_flags);
601 remove_dot_segments(iri->iri_path, sizeof(iri->iri_path));
605 cpfields(iri, &ibase, IH_SCHEME);
607 if (iparsed.iri_flags & IH_HOST) {
608 cpfields(iri, &iparsed, IH_AUTHORITY|IH_PATH|IH_QUERY);
609 remove_dot_segments(iri->iri_path, sizeof(iri->iri_path));
613 cpfields(iri, &ibase, IH_AUTHORITY);
615 if ((iparsed.iri_flags & IH_PATH) && *iparsed.iri_path == '\0') {
616 cpfields(iri, &ibase, IH_PATH);
617 if (iparsed.iri_flags & IH_QUERY)
618 cpfields(iri, &iparsed, IH_QUERY);
620 cpfields(iri, &ibase, IH_QUERY);
624 cpfields(iri, &iparsed, IH_QUERY);
625 if ((iparsed.iri_flags & IH_PATH) && *iparsed.iri_path == '/')
626 cpfields(iri, &iparsed, IH_PATH);
628 if (!(ibase.iri_flags & IH_PATH))
629 ibase.iri_path[0] = '\0';
630 if (!(iparsed.iri_flags & IH_PATH))
631 iparsed.iri_path[0] = '\0';
632 if (mergepath(iri->iri_path, sizeof(iri->iri_path),
633 ibase.iri_flags & IH_AUTHORITY, ibase.iri_path,
634 iparsed.iri_path) == -1)
636 iri->iri_flags |= IH_PATH;
638 if (remove_dot_segments(iri->iri_path, sizeof(iri->iri_path)) == -1)
644 iri_unparse(const struct iri *i, char *buf, size_t buflen)
646 int need_ss, have_path, need_s;
649 /* file is a quirky scheme */
650 need_ss = (i->iri_flags & IH_AUTHORITY) ||
651 !strcmp(i->iri_scheme, "file");
652 have_path = i->iri_flags & IH_PATH;
653 need_s = have_path && (i->iri_flags & IH_AUTHORITY) &&
654 i->iri_path[0] != '/';
656 r = snprintf(buf, buflen, "%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
657 (i->iri_flags & IH_SCHEME) ? i->iri_scheme : "",
658 (i->iri_flags & IH_SCHEME) ? ":" : "",
660 (i->iri_flags & IH_UINFO) ? i->iri_uinfo : "",
661 (i->iri_flags & IH_UINFO) ? "@" : "",
662 (i->iri_flags & IH_HOST) ? i->iri_host : "",
663 (i->iri_flags & IH_PORT) ? ":" : "",
664 (i->iri_flags & IH_PORT) ? i->iri_portstr : "",
666 have_path ? i->iri_path : "",
667 (i->iri_flags & IH_QUERY) ? "?" : "",
668 (i->iri_flags & IH_QUERY) ? i->iri_query : "",
669 (i->iri_flags & IH_FRAGMENT) ? "#" : "",
670 (i->iri_flags & IH_FRAGMENT) ? i->iri_fragment : "");
671 if (r < 0 || (size_t)r >= buflen) {
680 iri_human(const struct iri *iri, char *buf, size_t buflen)
682 memset(buf, 0, buflen);
687 iri_setport(struct iri *iri, const char *portstr)
692 port = strtonum(portstr, 1, UINT16_MAX, &errstr);
696 snprintf(iri->iri_portstr, sizeof(iri->iri_portstr), "%d", port);
697 iri->iri_port = port;
702 iri_setquery(struct iri *iri, const char *p)
706 char *buf, *q, tmp[4];
708 buf = q = iri->iri_query;
709 bufsize = sizeof(iri->iri_query);
710 while (*p && (q - buf < bufsize)) {
711 if (unreserved(*p) || sub_delims(*p) || *p == ':' ||
712 *p == '@' || *p == '/' || *p == '?') {
717 if (q - buf >= bufsize - 3)
719 r = snprintf(tmp, sizeof(tmp), "%%%02X", (int)*p);
720 if (r < 0 || (size_t)r > sizeof(tmp))
727 if ((*p == '\0') && (q - buf < bufsize)) {
728 iri->iri_flags |= IH_QUERY;
739 iri_urlescape(const char *path, char *buf, size_t len)
741 const char *hex = "0123456789abcdef";
742 const uint8_t *p = path;
748 if (unreserved(*p) || sub_delims(*p) ||
749 *p == ':' || *p == '@' ||
759 *buf++ = hex[*p >> 4];
760 *buf++ = hex[*p & 0xf];
773 iri_urlunescape(const char *str, char *buf, size_t len)
790 if (!isxdigit((unsigned char)str[1]) ||
791 !isxdigit((unsigned char)str[2]))
797 /* we know it's a proper number and will fit a char */
798 l = strtol(t, NULL, 16);
799 *buf++ = (unsigned char)l;