op public repos

Blob

Date:: Mon Dec 26 18:10:15 2022 UTC
Message:: iri: copy portstr too
Actions:: History | Blame | Raw File
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  */
16 
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>
24 
25 #include "iri.h"
26 
27 /* TODO: URI -> IRI.  accept IRI but emit always URI */
28 
29 static inline int
30 cpstr(const char *start, const char *till, char *buf, size_t len)
31 {
32 	size_t		slen = till - start;
33 
34 	if (slen + 1 >= len)
35 		return (-1);
36 	memcpy(buf, start, slen);
37 	buf[slen] = '\0';
38 	return (0);
39 }
40 
41 static inline int
42 unreserved(int c)
43 {
44 	return (isalnum((unsigned char)c) ||
45 	    c == '-' ||
46 	    c == '.' ||
47 	    c == '_' ||
48 	    c == '~');
49 }
50 
51 static inline int
52 pctenc(const char *s)
53 {
54 	const char	*t = s;
55 
56 	return (t[0] == '%' &&
57 	    isxdigit((unsigned char)t[1]) &&
58 	    isxdigit((unsigned char)t[2]));
59 }
60 
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 }
68 
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 }
78 
79 static inline const char *
80 advance_segment(const char *s)
81 {
82 	const char	*t = s;
83 
84 	while ((t = advance_pchar(s)) != NULL)
85 		s = t;
86 	return (s);
87 }
88 
89 static inline const char *
90 advance_segment_nz(const char *s)
91 {
92 	const char	*t;
93 
94 	if ((t = advance_pchar(s)) == NULL)
95 		return (NULL);
96 	return (advance_segment(t));
97 }
98 
99 static inline const char *
100 advance_segment_nz_nc(const char *s)
101 {
102 	const char	*t = s;
103 
104 	for (;;) {
105 		if (unreserved(*t) || sub_delims(*t) || *t == '@')
106 			t++;
107 		else if (pctenc(t))
108 			t += 3;
109 		else
110 			break;
111 	}
112 
113 	return (t != s ? t : NULL);
114 }
115 
116 static const char *
117 parse_scheme(const char *s, struct iri *iri)
118 {
119 	const char	*t = s;
120 
121 	if (!isalpha((unsigned char)*t))
122 		return (NULL);
123 
124 	while (isalnum((unsigned char)*t) ||
125 	    *t == '+' ||
126 	    *t == '-' ||
127 	    *t == '.')
128 		t++;
129 
130 	if (cpstr(s, t, iri->iri_scheme, sizeof(iri->iri_scheme)) == -1)
131 		return (NULL);
132 
133 	iri->iri_flags |= IH_SCHEME;
134 	return (t);
135 }
136 
137 /* userinfo is always optional */
138 static const char *
139 parse_uinfo(const char *s, struct iri *iri)
140 {
141 	const char	*t = s;
142 
143 	for (;;) {
144 		if (unreserved(*t) || sub_delims(*t) || *t == ':')
145 			t++;
146 		else if (pctenc(t))
147 			t += 3;
148 		else
149 			break;
150 	}
151 
152 	if (*t != '@')
153 		return (s);
154 
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);
159 }
160 
161 static const char *
162 parse_host(const char *s, struct iri *iri)
163 {
164 	const char	*t = s;
165 
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 	 */
171 
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);
182 	}
183 
184 	for (;;) {
185 		if (unreserved(*t) || sub_delims(*t))
186 			t++;
187 		else if (pctenc(t))
188 			t += 3;
189 		else
190 			break;
191 	}
192 
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);
197 }
198 
199 static const char *
200 parse_port(const char *s, struct iri *iri)
201 {
202 	const char	*t = s;
203 	const char	*errstr;
204 
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);
214 }
215 
216 static const char *
217 parse_authority(const char *s, struct iri *iri)
218 {
219 	const char	*t;
220 
221 	if ((t = parse_uinfo(s, iri)) == NULL)
222 		return (NULL);
223 
224 	if ((t = parse_host(t, iri)) == NULL)
225 		return (NULL);
226 
227 	if (*t == ':')
228 		return (parse_port(t + 1, iri));
229 
230 	return (t);
231 }
232 
233 static const char *
234 parse_path_abempty(const char *s, struct iri *iri)
235 {
236 	const char	*t = s;
237 
238 	while (*t == '/')
239 		t = advance_segment(t + 1);
240 
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);
245 }
246 
247 static const char *
248 parse_path_absolute(const char *s, struct iri *iri)
249 {
250 	const char	*t;
251 
252 	if (*s != '/')
253 		return (NULL);
254 
255 	if ((t = advance_segment_nz(s + 1)) == NULL)
256 		return (s + 1);
257 
258 	while (*t == '/')
259 		t = advance_segment(t + 1);
260 
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);
265 }
266 
267 static const char *
268 parse_path_rootless(const char *s, struct iri *iri)
269 {
270 	const char	*t;
271 
272 	if ((t = advance_segment_nz(s)) == NULL)
273 		return (NULL);
274 
275 	while (*t == '/')
276 		t = advance_segment(t + 1);
277 
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);
282 }
283 
284 static const char *
285 parse_path_noscheme(const char *s, struct iri *iri)
286 {
287 	const char	*t;
288 
289 	if ((t = advance_segment_nz_nc(s)) == NULL)
290 		return (NULL);
291 
292 	while (*t == '/')
293 		t = advance_segment(t + 1);
294 
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);
299 }
300 
301 static const char *
302 parse_path_empty(const char *s, struct iri *iri)
303 {
304 	iri->iri_path[0] = '\0';
305 	iri->iri_flags |= IH_PATH;
306 	return (s);
307 }
308 
309 static const char *
310 parse_hier(const char *s, struct iri *iri)
311 {
312 	const char	*t;
313 
314 	if (!strncmp(s, "//", 2)) {
315 		if ((t = parse_authority(s + 2, iri)) == NULL)
316 			return (NULL);
317 		return (parse_path_abempty(t, iri));
318 	}
319 
320 	if ((t = parse_path_absolute(s, iri)) != NULL)
321 		return (t);
322 
323 	if ((t = parse_path_rootless(s, iri)) != NULL)
324 		return (t);
325 
326 	return (parse_path_empty(s, iri));
327 }
328 
329 static const char *
330 parse_relative(const char *s, struct iri *iri)
331 {
332 	const char	*t = s;
333 
334 	if (!strncmp(s, "//", 2)) {
335 		if ((t = parse_authority(s + 2, iri)) == NULL)
336 			return (NULL);
337 		return (parse_path_abempty(t, iri));
338 	}
339 
340 	if ((t = parse_path_absolute(s, iri)) != NULL)
341 		return (t);
342 
343 	if ((t = parse_path_noscheme(s, iri)) != NULL)
344 		return (t);
345 
346 	return (parse_path_empty(s, iri));
347 }
348 
349 static const char *
350 parse_query(const char *s, struct iri *iri)
351 {
352 	const char	*n, *t = s;
353 
354 	for (;;) {
355 		if ((n = advance_pchar(t)) != NULL)
356 			t = n;
357 		else if (*t == '/' || *t == '?')
358 			t++;
359 		else
360 			break;
361 	}
362 
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);
367 }
368 
369 static const char *
370 parse_fragment(const char *s, struct iri *iri)
371 {
372 	const char	*n, *t = s;
373 
374 	for (;;) {
375 		if ((n = advance_pchar(t)) != NULL)
376 			t = n;
377 		else if (*t == '/' || *t == '?')
378 			t++;
379 		else
380 			break;
381 	}
382 
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);
387 }
388 
389 static int
390 parse_uri(const char *s, struct iri *iri)
391 {
392 	iri->iri_flags = 0;
393 
394 	if ((s = parse_scheme(s, iri)) == NULL)
395 		return (-1);
396 
397 	if (*s != ':')
398 		return (-1);
399 
400 	if ((s = parse_hier(s + 1, iri)) == NULL)
401 		return (-1);
402 
403 	if (*s == '?' && (s = parse_query(s + 1, iri)) == NULL)
404 		return (-1);
405 
406 	if (*s == '#' && (s = parse_fragment(s + 1, iri)) == NULL)
407 		return (-1);
408 
409 	if (*s == '\0')
410 		return (0);
411 
412 	return (-1);
413 }
414 
415 static int
416 parse_relative_ref(const char *s, struct iri *iri)
417 {
418 	if ((s = parse_relative(s, iri)) == NULL)
419 		return (-1);
420 
421 	if (*s == '?' && (s = parse_query(s + 1, iri)) == NULL)
422 		return (-1);
423 
424 	if (*s == '#' && (s = parse_fragment(s + 1, iri)) == NULL)
425 		return (-1);
426 
427 	if (*s == '\0')
428 		return (0);
429 
430 	return (-1);
431 }
432 
433 static int
434 parse(const char *s, struct iri *iri)
435 {
436 	iri->iri_flags = 0;
437 
438 	if (s == NULL)
439 		return (0);
440 
441 	if (parse_uri(s, iri) == -1) {
442 		iri->iri_flags = 0;
443 		if (parse_relative_ref(s, iri) == -1)
444 			return (-1);
445 	}
446 
447 	return (0);
448 }
449 
450 static inline void
451 lowerify(char *s)
452 {
453 	for (; *s; ++s)
454 		*s = tolower((unsigned char)*s);
455 }
456 
457 static void
458 cpfields(struct iri *dest, const struct iri *src, int flags)
459 {
460 	if (flags & IH_SCHEME) {
461 		dest->iri_flags |= IH_SCHEME;
462 		if (src->iri_flags & IH_SCHEME)
463 			memcpy(dest->iri_scheme, src->iri_scheme,
464 			    sizeof(dest->iri_scheme));
465 		lowerify(dest->iri_scheme);
466 	}
467 	if (flags & IH_UINFO) {
468 		if (src->iri_flags & IH_UINFO) {
469 			memcpy(dest->iri_uinfo, src->iri_uinfo,
470 			    sizeof(dest->iri_uinfo));
471 			dest->iri_flags |= IH_UINFO;
472 		}
473 	}
474 	if (flags & IH_HOST) {
475 		dest->iri_flags |= IH_HOST;
476 		if (src->iri_flags & IH_HOST)
477 			memcpy(dest->iri_host, src->iri_host,
478 			    sizeof(dest->iri_host));
479 		lowerify(dest->iri_host);
480 	}
481 	if (flags & IH_PORT) {
482 		if (src->iri_flags & IH_PORT) {
483 			dest->iri_port = src->iri_port;
484 			memcpy(dest->iri_portstr, src->iri_portstr,
485 			    sizeof(dest->iri_portstr));
486 			dest->iri_flags |= IH_PORT;
487 		}
488 	}
489 	if (flags & IH_PATH) {
490 		dest->iri_flags |= IH_PATH;
491 		if (src->iri_flags & IH_PATH)
492 			memcpy(dest->iri_path, src->iri_path,
493 			    sizeof(dest->iri_path));
494 	}
495 	if (flags & IH_QUERY) {
496 		if (src->iri_flags & IH_QUERY) {
497 			dest->iri_flags |= IH_QUERY;
498 			memcpy(dest->iri_query, src->iri_query,
499 			    sizeof(dest->iri_query));
500 		}
501 	}
502 	if (flags & IH_FRAGMENT) {
503 		if (src->iri_flags & IH_FRAGMENT) {
504 			dest->iri_flags |= IH_FRAGMENT;
505 			memcpy(dest->iri_fragment, src->iri_fragment,
506 			    sizeof(dest->iri_fragment));
507 		}
508 	}
509 }
510 
511 static inline int
512 remove_dot_segments(char *buf, ptrdiff_t bufsize)
513 {
514 	char		*p, *q;
515 
516 	p = q = buf;
517 	while (*p && (q - buf < bufsize)) {
518 		if (p[0] == '/' && p[1] == '.' &&
519 		    (p[2] == '/' || p[2] == '\0')) {
520 			p += 2;
521 			if (*p != '/')
522 				*q++ = '/';
523 		} else if (p[0] == '/' && p[1] == '.' && p[2] == '.' &&
524 		    (p[3] == '/' || p[3] == '\0')) {
525 			p += 3;
526 			while (q > buf && *--q != '/')
527 				continue;
528 			if (*p != '/' && (q > buf && q[-1] != '/'))
529 				*q++ = '/';
530 		} else
531 			*q++ = *p++;
532 	}
533 	if ((*p == '\0') && (q - buf < bufsize)) {
534 		*q = '\0';
535 		return (0);
536 	}
537 
538 	errno = ENAMETOOLONG;
539 	return (-1);
540 }
541 
542 static inline int
543 mergepath(char *buf, size_t bufsize, int abs, const char *base, const char *r)
544 {
545 	const char	*s;
546 
547 	if (base == NULL || *base == '\0')
548 		base = "/";
549 	if (r == NULL || *r == '\0')
550 		r = "/";
551 
552 	if (bufsize == 0)
553 		return (-1);
554 	buf[0] = '\0';
555 
556 	if (abs && (*base == '\0' || !strcmp(base, "/"))) {
557 		if (*r == '/')
558 			r++;
559 		strlcpy(buf, "/", bufsize);
560 		strlcat(buf, r, bufsize);
561 		return (0);
562 	}
563 
564 	if ((s = strrchr(base, '/')) != NULL) {
565 		cpstr(base, s + 1, buf, bufsize);
566 		if (*r == '/')
567 			r++;
568 	}
569 	if (strlcat(buf, r, bufsize) >= bufsize) {
570 		errno = ENAMETOOLONG;
571 		return (-1);
572 	}
573 
574 	return (0);
575 }
576 
577 int
578 iri_parse(const char *base, const char *str, struct iri *iri)
579 {
580 	static struct iri	ibase, iparsed;
581 
582 	memset(iri, 0, sizeof(*iri));
583 
584 	if (base == NULL) {
585 		ibase.iri_flags = 0;
586 		if (parse_uri(str, &iparsed) == -1) {
587 			errno = EINVAL;
588 			return (-1);
589 		}
590 	} else {
591 		if (parse_uri(base, &ibase) == -1 ||
592 		    parse(str, &iparsed) == -1) {
593 			errno = EINVAL;
594 			return (-1);
595 		}
596 	}
597 
598 	cpfields(iri, &iparsed, IH_FRAGMENT);
599 
600 	if (iparsed.iri_flags & IH_SCHEME) {
601 		cpfields(iri, &iparsed, iparsed.iri_flags);
602 		remove_dot_segments(iri->iri_path, sizeof(iri->iri_path));
603 		return (0);
604 	}
605 
606 	cpfields(iri, &ibase, IH_SCHEME);
607 
608 	if (iparsed.iri_flags & IH_HOST) {
609 		cpfields(iri, &iparsed, IH_AUTHORITY|IH_PATH|IH_QUERY);
610 		remove_dot_segments(iri->iri_path, sizeof(iri->iri_path));
611 		return (0);
612 	}
613 
614 	cpfields(iri, &ibase, IH_AUTHORITY);
615 
616 	if ((iparsed.iri_flags & IH_PATH) && *iparsed.iri_path == '\0') {
617 		cpfields(iri, &ibase, IH_PATH);
618 		if (iparsed.iri_flags & IH_QUERY)
619 			cpfields(iri, &iparsed, IH_QUERY);
620 		else
621 			cpfields(iri, &ibase, IH_QUERY);
622 		return (0);
623 	}
624 
625 	cpfields(iri, &iparsed, IH_QUERY);
626 	if ((iparsed.iri_flags & IH_PATH) && *iparsed.iri_path == '/')
627 		cpfields(iri, &iparsed, IH_PATH);
628 	else {
629 		if (!(ibase.iri_flags & IH_PATH))
630 			ibase.iri_path[0] = '\0';
631 		if (!(iparsed.iri_flags & IH_PATH))
632 			iparsed.iri_path[0] = '\0';
633 		if (mergepath(iri->iri_path, sizeof(iri->iri_path),
634 		    ibase.iri_flags & IH_AUTHORITY, ibase.iri_path,
635 		    iparsed.iri_path) == -1)
636 			return (-1);
637 		iri->iri_flags |= IH_PATH;
638 	}
639 	if (remove_dot_segments(iri->iri_path, sizeof(iri->iri_path)) == -1)
640 		return (-1);
641 	return (0);
642 }
643 
644 int
645 iri_unparse(const struct iri *i, char *buf, size_t buflen)
646 {
647 	if (buflen == 0)
648 		goto err;
649 
650 	/* TODO: should %enc octets if needed */
651 
652 	buf[0] = '\0';
653 
654 	if (i->iri_flags & IH_SCHEME) {
655 		if (strlcat(buf, i->iri_scheme, buflen) >= buflen ||
656 		    strlcat(buf, ":", buflen) >= buflen)
657 			goto err;
658 	}
659 
660 	if (i->iri_flags & IH_AUTHORITY) {
661 		if (strlcat(buf, "//", buflen) >= buflen)
662 			goto err;
663 	}
664 
665 	if (i->iri_flags & IH_UINFO) {
666 		if (strlcat(buf, i->iri_uinfo, buflen) >= buflen ||
667 		    strlcat(buf, "@", buflen) >= buflen)
668 			goto err;
669 	}
670 	if (i->iri_flags & IH_HOST) {
671 		if (strlcat(buf, i->iri_host, buflen) >= buflen)
672 			goto err;
673 	}
674 	if (i->iri_flags & IH_PORT) {
675 		if (strlcat(buf, ":", buflen) >= buflen ||
676 		    strlcat(buf, i->iri_portstr, buflen) >= buflen)
677 			goto err;
678 	}
679 
680 	if (i->iri_flags & IH_PATH) {
681 		if (i->iri_flags & IH_AUTHORITY &&
682 		    i->iri_path[0] != '/' &&
683 		    strlcat(buf, "/", buflen) >= buflen)
684 			goto err;
685 		if (strlcat(buf, i->iri_path, buflen) >= buflen)
686 			goto err;
687 	}
688 
689 	if (i->iri_flags & IH_QUERY) {
690 		if (strlcat(buf, "?", buflen) >= buflen ||
691 		    strlcat(buf, i->iri_query, buflen) >= buflen)
692 			goto err;
693 	}
694 
695 	if (i->iri_flags & IH_FRAGMENT) {
696 		if (strlcat(buf, "#", buflen) >= buflen ||
697 		    strlcat(buf, i->iri_fragment, buflen) >= buflen)
698 			goto err;
699 	}
700 
701 	return (0);
702 
703  err:
704 	errno = ENOBUFS;
705 	return (-1);
706 }
707 
708 int
709 iri_human(const struct iri *iri, char *buf, size_t buflen)
710 {
711 	memset(buf, 0, buflen);
712 	return (-1);
713 }
714 
715 int
716 iri_setquery(struct iri *iri, const char *p)
717 {
718 	ptrdiff_t	 bufsize;
719 	int		 r;
720 	char		*buf, *q, tmp[4];
721 
722 	buf = q = iri->iri_query;
723 	bufsize = sizeof(iri->iri_query);
724 	while (*p && (q - buf < bufsize)) {
725 		if (unreserved(*p) || sub_delims(*p) || *p == ':' || *p == '@' ||
726 		    *p == '/' || *p == '?')
727 			*q++ = *p++;
728 		else {
729 			if (q - buf >= bufsize - 3)
730 				goto err;
731 			r = snprintf(tmp, sizeof(tmp), "%%%02X", (int)*p);
732 			if (r < 0 || (size_t)r > sizeof(tmp))
733 				return (-1);
734 			*q++ = tmp[0];
735 			*q++ = tmp[1];
736 			*q++ = tmp[2];
737 			p++;
738 		}
739 	}
740 	if ((*p == '\0') && (q - buf < bufsize)) {
741 		iri->iri_flags |= IH_QUERY;
742 		*q = '\0';
743 		return (0);
744 	}
745 
746  err:
747 	errno = ENOBUFS;
748 	return (-1);
749 }