op public repos

Blob

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