Blob


1 /*
2 * Copyright (c) 2022 Omar Polo <op@omarpolo.com>
3 *
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.
7 *
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.
15 */
17 #include <ctype.h>
18 #include <errno.h>
19 #include <stddef.h>
20 #include <stdint.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
25 #include "iri.h"
27 /* TODO: URI -> IRI. accept IRI but emit always URI */
29 static inline int
30 cpstr(const char *start, const char *till, char *buf, size_t len)
31 {
32 size_t slen = till - start;
34 if (slen + 1 >= len)
35 return (-1);
36 memcpy(buf, start, slen);
37 buf[slen] = '\0';
38 return (0);
39 }
41 static inline int
42 unreserved(int c)
43 {
44 return (isalnum((unsigned char)c) ||
45 c == '-' ||
46 c == '.' ||
47 c == '_' ||
48 c == '~');
49 }
51 static inline int
52 pctenc(const char *s)
53 {
54 const char *t = s;
56 return (t[0] == '%' &&
57 isxdigit((unsigned char)t[1]) &&
58 isxdigit((unsigned char)t[2]));
59 }
61 static inline int
62 sub_delims(int c)
63 {
64 return (c == '!' || c == '$' || c == '&' || c == '\'' ||
65 c == '(' || c == ')' || c == '*' || c == '+' || c == ',' ||
66 c == ';' || c == '=');
67 }
69 static inline const char *
70 advance_pchar(const char *s)
71 {
72 if (unreserved(*s) || sub_delims(*s) || *s == ':' || *s == '@')
73 return (s + 1);
74 if (pctenc(s))
75 return (s + 3);
76 return (NULL);
77 }
79 static inline const char *
80 advance_segment(const char *s)
81 {
82 const char *t = s;
84 while ((t = advance_pchar(s)) != NULL)
85 s = t;
86 return (s);
87 }
89 static inline const char *
90 advance_segment_nz(const char *s)
91 {
92 const char *t;
94 if ((t = advance_pchar(s)) == NULL)
95 return (NULL);
96 return (advance_segment(t));
97 }
99 static inline const char *
100 advance_segment_nz_nc(const char *s)
102 const char *t = s;
104 for (;;) {
105 if (unreserved(*t) || sub_delims(*t) || *t == '@')
106 t++;
107 else if (pctenc(t))
108 t += 3;
109 else
110 break;
113 return (t != s ? t : NULL);
116 static const char *
117 parse_scheme(const char *s, struct iri *iri)
119 const char *t = s;
121 if (!isalpha((unsigned char)*t))
122 return (NULL);
124 while (isalnum((unsigned char)*t) ||
125 *t == '+' ||
126 *t == '-' ||
127 *t == '.')
128 t++;
130 if (cpstr(s, t, iri->iri_scheme, sizeof(iri->iri_scheme)) == -1)
131 return (NULL);
133 iri->iri_flags |= IH_SCHEME;
134 return (t);
137 /* userinfo is always optional */
138 static const char *
139 parse_uinfo(const char *s, struct iri *iri)
141 const char *t = s;
143 for (;;) {
144 if (unreserved(*t) || sub_delims(*t) || *t == ':')
145 t++;
146 else if (pctenc(t))
147 t += 3;
148 else
149 break;
152 if (*t != '@')
153 return (s);
155 if (cpstr(s, t, iri->iri_uinfo, sizeof(iri->iri_uinfo)) == -1)
156 return (NULL);
157 iri->iri_flags |= IH_UINFO;
158 return (t + 1);
161 static const char *
162 parse_host(const char *s, struct iri *iri)
164 const char *t = s;
166 /*
167 * cheating a bit by relaxing and merging the rule for
168 * IPv6address and IPvFuture and by merging IPv4address and
169 * reg-name.
170 */
172 if (*t == '[') {
173 while (*t && *t != ']')
174 ++t;
175 if (*t == '\0')
176 return (NULL);
177 t++;
178 if (cpstr(s, t, iri->iri_host, sizeof(iri->iri_host)) == -1)
179 return (NULL);
180 iri->iri_flags |= IH_HOST;
181 return (t);
184 for (;;) {
185 if (unreserved(*t) || sub_delims(*t))
186 t++;
187 else if (pctenc(t))
188 t += 3;
189 else
190 break;
193 if (cpstr(s, t, iri->iri_host, sizeof(iri->iri_host)) == -1)
194 return (NULL);
195 iri->iri_flags |= IH_HOST;
196 return (t);
199 static const char *
200 parse_port(const char *s, struct iri *iri)
202 const char *t = s;
203 const char *errstr;
205 while (isdigit((unsigned char)*t))
206 t++;
207 if (cpstr(s, t, iri->iri_portstr, sizeof(iri->iri_portstr)) == -1)
208 return (NULL);
209 iri->iri_port = strtonum(iri->iri_portstr, 1, UINT16_MAX, &errstr);
210 if (errstr)
211 return (NULL);
212 iri->iri_flags |= IH_PORT;
213 return (t);
216 static const char *
217 parse_authority(const char *s, struct iri *iri)
219 const char *t;
221 if ((t = parse_uinfo(s, iri)) == NULL)
222 return (NULL);
224 if ((t = parse_host(t, iri)) == NULL)
225 return (NULL);
227 if (*t == ':')
228 return (parse_port(t + 1, iri));
230 return (t);
233 static const char *
234 parse_path_abempty(const char *s, struct iri *iri)
236 const char *t = s;
238 while (*t == '/')
239 t = advance_segment(t + 1);
241 if (cpstr(s, t, iri->iri_path, sizeof(iri->iri_path)) == -1)
242 return (NULL);
243 iri->iri_flags |= IH_PATH;
244 return (t);
247 static const char *
248 parse_path_absolute(const char *s, struct iri *iri)
250 const char *t;
252 if (*s != '/')
253 return (NULL);
255 if ((t = advance_segment_nz(s + 1)) == NULL)
256 return (s + 1);
258 while (*t == '/')
259 t = advance_segment(t + 1);
261 if (cpstr(s, t, iri->iri_path, sizeof(iri->iri_path)) == -1)
262 return (NULL);
263 iri->iri_flags |= IH_PATH;
264 return (t);
267 static const char *
268 parse_path_rootless(const char *s, struct iri *iri)
270 const char *t;
272 if ((t = advance_segment_nz(s)) == NULL)
273 return (NULL);
275 while (*t == '/')
276 t = advance_segment(t + 1);
278 if (cpstr(s, t, iri->iri_path, sizeof(iri->iri_path)) == -1)
279 return (NULL);
280 iri->iri_flags |= IH_PATH;
281 return (t);
284 static const char *
285 parse_path_noscheme(const char *s, struct iri *iri)
287 const char *t;
289 if ((t = advance_segment_nz_nc(s)) == NULL)
290 return (NULL);
292 while (*t == '/')
293 t = advance_segment(t + 1);
295 if (cpstr(s, t, iri->iri_path, sizeof(iri->iri_path)) == -1)
296 return (NULL);
297 iri->iri_flags |= IH_PATH;
298 return (t);
301 static const char *
302 parse_path_empty(const char *s, struct iri *iri)
304 iri->iri_path[0] = '\0';
305 iri->iri_flags |= IH_PATH;
306 return (s);
309 static const char *
310 parse_hier(const char *s, struct iri *iri)
312 const char *t;
314 if (!strncmp(s, "//", 2)) {
315 if ((t = parse_authority(s + 2, iri)) == NULL)
316 return (NULL);
317 return (parse_path_abempty(t, iri));
320 if ((t = parse_path_absolute(s, iri)) != NULL)
321 return (t);
323 if ((t = parse_path_rootless(s, iri)) != NULL)
324 return (t);
326 return (parse_path_empty(s, iri));
329 static const char *
330 parse_relative(const char *s, struct iri *iri)
332 const char *t = s;
334 if (!strncmp(s, "//", 2)) {
335 if ((t = parse_authority(s + 2, iri)) == NULL)
336 return (NULL);
337 return (parse_path_abempty(t, iri));
340 if ((t = parse_path_absolute(s, iri)) != NULL)
341 return (t);
343 if ((t = parse_path_noscheme(s, iri)) != NULL)
344 return (t);
346 return (parse_path_empty(s, iri));
349 static const char *
350 parse_query(const char *s, struct iri *iri)
352 const char *n, *t = s;
354 for (;;) {
355 if ((n = advance_pchar(t)) != NULL)
356 t = n;
357 else if (*t == '/' || *t == '?')
358 t++;
359 else
360 break;
363 if (cpstr(s, t, iri->iri_query, sizeof(iri->iri_query)) == -1)
364 return (NULL);
365 iri->iri_flags |= IH_QUERY;
366 return (t);
369 static const char *
370 parse_fragment(const char *s, struct iri *iri)
372 const char *n, *t = s;
374 for (;;) {
375 if ((n = advance_pchar(t)) != NULL)
376 t = n;
377 else if (*t == '/' || *t == '?')
378 t++;
379 else
380 break;
383 if (cpstr(s, t, iri->iri_fragment, sizeof(iri->iri_fragment)) == -1)
384 return (NULL);
385 iri->iri_flags |= IH_FRAGMENT;
386 return (t);
389 static int
390 parse_uri(const char *s, struct iri *iri)
392 if ((s = parse_scheme(s, iri)) == NULL)
393 return (-1);
395 if (*s != ':')
396 return (-1);
398 if ((s = parse_hier(s + 1, iri)) == NULL)
399 return (-1);
401 if (*s == '?' && (s = parse_query(s + 1, iri)) == NULL)
402 return (-1);
404 if (*s == '#' && (s = parse_fragment(s + 1, iri)) == NULL)
405 return (-1);
407 if (*s == '\0')
408 return (0);
410 return (-1);
413 static int
414 parse_relative_ref(const char *s, struct iri *iri)
416 if ((s = parse_relative(s, iri)) == NULL)
417 return (-1);
419 if (*s == '?' && (s = parse_query(s + 1, iri)) == NULL)
420 return (-1);
422 if (*s == '#' && (s = parse_fragment(s + 1, iri)) == NULL)
423 return (-1);
425 if (*s == '\0')
426 return (0);
428 return (-1);
431 static int
432 parse(const char *s, struct iri *iri)
434 iri->iri_flags = 0;
436 if (s == NULL)
437 return (0);
439 if (parse_uri(s, iri) == -1) {
440 iri->iri_flags = 0;
441 if (parse_relative_ref(s, iri) == -1)
442 return (-1);
445 return (0);
448 static inline void
449 lowerify(char *s)
451 for (; *s; ++s)
452 *s = tolower((unsigned char)*s);
455 static void
456 cpfields(struct iri *dest, const struct iri *src, int flags)
458 if (flags & IH_SCHEME) {
459 dest->iri_flags |= IH_SCHEME;
460 if (src->iri_flags & IH_SCHEME)
461 memcpy(dest->iri_scheme, src->iri_scheme,
462 sizeof(dest->iri_scheme));
463 lowerify(dest->iri_scheme);
465 if (flags & IH_UINFO) {
466 if (src->iri_flags & IH_UINFO) {
467 memcpy(dest->iri_uinfo, src->iri_uinfo,
468 sizeof(dest->iri_uinfo));
469 dest->iri_flags |= IH_UINFO;
472 if (flags & IH_HOST) {
473 dest->iri_flags |= IH_HOST;
474 if (src->iri_flags & IH_HOST)
475 memcpy(dest->iri_host, src->iri_host,
476 sizeof(dest->iri_host));
477 lowerify(dest->iri_host);
479 if (flags & IH_PORT) {
480 if (src->iri_flags & IH_PORT) {
481 dest->iri_port = src->iri_port;
482 dest->iri_flags |= IH_PORT;
485 if (flags & IH_PATH) {
486 dest->iri_flags |= IH_PATH;
487 if (src->iri_flags & IH_PATH)
488 memcpy(dest->iri_path, src->iri_path,
489 sizeof(dest->iri_path));
491 if (flags & IH_QUERY) {
492 if (src->iri_flags & IH_QUERY) {
493 dest->iri_flags |= IH_QUERY;
494 memcpy(dest->iri_query, src->iri_query,
495 sizeof(dest->iri_query));
498 if (flags & IH_FRAGMENT) {
499 if (src->iri_flags & IH_FRAGMENT) {
500 dest->iri_flags |= IH_FRAGMENT;
501 memcpy(dest->iri_fragment, src->iri_fragment,
502 sizeof(dest->iri_fragment));
507 static inline int
508 remove_dot_segments(struct iri *i)
510 char *p, *q, *buf;
511 ptrdiff_t bufsize;
513 buf = p = q = i->iri_path;
514 bufsize = sizeof(i->iri_path);
515 while (*p && (q - buf < bufsize)) {
516 if (p[0] == '/' && p[1] == '.' &&
517 (p[2] == '/' || p[2] == '\0')) {
518 p += 2;
519 if (*p != '/')
520 *q++ = '/';
521 } else if (p[0] == '/' && p[1] == '.' && p[2] == '.' &&
522 (p[3] == '/' || p[3] == '\0')) {
523 p += 3;
524 while (q > buf && *--q != '/')
525 continue;
526 if (*p != '/' && (q > buf && q[-1] != '/'))
527 *q++ = '/';
528 } else
529 *q++ = *p++;
531 if ((*p == '\0') && (q - buf < bufsize)) {
532 *q = '\0';
533 return (0);
536 errno = ENAMETOOLONG;
537 return (-1);
540 static inline int
541 mergepath(struct iri *i, struct iri *base, struct iri *r)
543 const char *bpath, *rpath, *s;
545 bpath = (base->iri_flags & IH_PATH) ? base->iri_path : "/";
546 rpath = (r->iri_flags & IH_PATH) ? r->iri_path : "/";
548 i->iri_flags |= IH_PATH;
549 i->iri_path[0] = '\0';
551 if ((base->iri_flags & IH_AUTHORITY) &&
552 (*bpath == '\0' || !strcmp(bpath, "/"))) {
553 if (*rpath == '/')
554 rpath++;
555 strlcpy(i->iri_path, "/", sizeof(i->iri_path));
556 strlcat(i->iri_path, rpath, sizeof(i->iri_path));
557 return (0);
560 if ((s = strrchr(bpath, '/')) != NULL) {
561 cpstr(bpath, s + 1, i->iri_path, sizeof(i->iri_path));
562 if (*rpath == '/')
563 rpath++;
565 if (strlcat(i->iri_path, rpath, sizeof(i->iri_path)) >=
566 sizeof(i->iri_path)) {
567 errno = ENAMETOOLONG;
568 return (-1);
571 return (0);
574 int
575 iri_parse(const char *base, const char *str, struct iri *iri)
577 static struct iri ibase, iparsed;
579 memset(iri, 0, sizeof(*iri));
581 if (base == NULL) {
582 ibase.iri_flags = 0;
583 if (parse_uri(str, &iparsed) == -1) {
584 errno = EINVAL;
585 return (-1);
587 } else {
588 if (parse_uri(base, &ibase) == -1 ||
589 parse(str, &iparsed) == -1) {
590 errno = EINVAL;
591 return (-1);
595 cpfields(iri, &iparsed, IH_FRAGMENT);
597 if (iparsed.iri_flags & IH_SCHEME) {
598 cpfields(iri, &iparsed, iparsed.iri_flags);
599 remove_dot_segments(iri);
600 return (0);
603 cpfields(iri, &ibase, IH_SCHEME);
605 if (iparsed.iri_flags & IH_HOST) {
606 cpfields(iri, &iparsed, IH_AUTHORITY|IH_PATH|IH_QUERY);
607 remove_dot_segments(iri);
608 return (0);
611 cpfields(iri, &ibase, IH_AUTHORITY);
613 if ((iparsed.iri_flags & IH_PATH) && *iparsed.iri_path == '\0') {
614 cpfields(iri, &ibase, IH_PATH);
615 if (iparsed.iri_flags & IH_QUERY)
616 cpfields(iri, &iparsed, IH_QUERY);
617 else
618 cpfields(iri, &ibase, IH_QUERY);
619 return (0);
622 cpfields(iri, &iparsed, IH_QUERY);
623 if ((iparsed.iri_flags & IH_PATH) && *iparsed.iri_path == '/')
624 cpfields(iri, &iparsed, IH_PATH);
625 else {
626 if (!(ibase.iri_flags & IH_PATH))
627 ibase.iri_path[0] = '\0';
628 if (!(iparsed.iri_flags & IH_PATH))
629 iparsed.iri_path[0] = '\0';
630 if (mergepath(iri, &ibase, &iparsed) == -1)
631 return (-1);
633 if (remove_dot_segments(iri) == -1)
634 return (-1);
635 return (0);
638 int
639 iri_unparse(const struct iri *i, char *buf, size_t buflen)
641 if (buflen == 0)
642 goto err;
644 /* TODO: should %enc octets if needed */
646 buf[0] = '\0';
648 if (i->iri_flags & IH_SCHEME) {
649 if (strlcat(buf, i->iri_scheme, buflen) >= buflen ||
650 strlcat(buf, ":", buflen) >= buflen)
651 goto err;
654 if (i->iri_flags & IH_AUTHORITY) {
655 if (strlcat(buf, "//", buflen) >= buflen)
656 goto err;
659 if (i->iri_flags & IH_UINFO) {
660 if (strlcat(buf, i->iri_uinfo, buflen) >= buflen ||
661 strlcat(buf, "@", buflen) >= buflen)
662 goto err;
664 if (i->iri_flags & IH_HOST) {
665 if (strlcat(buf, i->iri_host, buflen) >= buflen)
666 goto err;
668 if (i->iri_flags & IH_PORT) {
669 if (strlcat(buf, ":", buflen) >= buflen ||
670 strlcat(buf, i->iri_portstr, buflen) >= buflen)
671 goto err;
674 if (i->iri_flags & IH_PATH) {
675 if (i->iri_flags & IH_AUTHORITY &&
676 i->iri_path[0] != '/' &&
677 strlcat(buf, "/", buflen) >= buflen)
678 goto err;
679 if (strlcat(buf, i->iri_path, buflen) >= buflen)
680 goto err;
683 if (i->iri_flags & IH_QUERY) {
684 if (strlcat(buf, "?", buflen) >= buflen ||
685 strlcat(buf, i->iri_query, buflen) >= buflen)
686 goto err;
689 if (i->iri_flags & IH_FRAGMENT) {
690 if (strlcat(buf, "#", buflen) >= buflen ||
691 strlcat(buf, i->iri_fragment, buflen) >= buflen)
692 goto err;
695 return (0);
697 err:
698 errno = ENOBUFS;
699 return (-1);
702 int
703 iri_human(const struct iri *iri, char *buf, size_t buflen)
705 memset(buf, 0, buflen);
706 return (-1);
709 int
710 iri_setquery(struct iri *iri, const char *p)
712 ptrdiff_t bufsize;
713 int r;
714 char *buf, *q;
716 buf = q = iri->iri_query;
717 bufsize = sizeof(iri->iri_query);
718 while (*p && (q - buf < bufsize)) {
719 if (unreserved(*p) || sub_delims(*p) || *p == ':' || *p == '@' ||
720 *p == '/' || *p == '?')
721 *q++ = *p++;
722 else {
723 if (q - buf >= bufsize - 4)
724 goto err;
725 r = snprintf(q, 4, "%%%02X", (int)*p);
726 if (r < 0 || r > 4)
727 return (-1);
728 p++, q += 3;
731 if ((*p == '\0') && (q - buf < bufsize)) {
732 iri->iri_flags |= IH_QUERY;
733 *q = '\0';
734 return (0);
737 err:
738 errno = ENOBUFS;
739 return (-1);