op public repos

Blob

Date:: Fri Aug 13 08:46:51 2021 UTC
Message:: correctly serialize file: URIs file URIs have the two slashes after the protocol even when the hostname is not specified.
Actions:: History | Blame | Raw File
1 /*
2  * Copyright (c) 2021 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 /*
18  * TODOs:
19  * - distinguish between an empty component and a undefined one
20  * - ...
21  */
22 
23 #include <assert.h>
24 
25 #include "compat.h"
26 
27 #include "phos.h"
28 
29 #include <ctype.h>
30 #include <stdint.h>
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <string.h>
34 
35 static const char	*sub_ip_literal(const char*);
36 static const char	*sub_host_dummy(const char*);
37 static const char	*sub_pchar(const char*);
38 
39 static const char	*sub_segment(const char*);
40 static const char	*sub_segment_nz(const char*);
41 static const char	*sub_segment_nz_nc(const char*);
42 static const char	*sub_path_common(const char*);
43 
44 static const char	*parse_scheme(const char*, struct phos_uri*);
45 static const char	*parse_host(const char*, struct phos_uri*);
46 static const char	*parse_port(const char*, struct phos_uri*);
47 static const char	*parse_authority(const char*, struct phos_uri*);
48 static const char	*parse_path_abempty(const char*, struct phos_uri*);
49 static const char	*parse_path_absolute(const char*, struct phos_uri*);
50 static const char	*parse_path_noscheme(const char*, struct phos_uri*);
51 static const char	*parse_path_rootless(const char*, struct phos_uri*);
52 static const char	*parse_path_empty(const char*, struct phos_uri*);
53 static const char	*parse_hier_part(const char*, struct phos_uri*);
54 static const char	*parse_query(const char*, struct phos_uri*);
55 static const char	*parse_fragment(const char*, struct phos_uri*);
56 static const char	*parse_uri(const char*, struct phos_uri*);
57 static const char	*parse_relative_part(const char*, struct phos_uri*);
58 static const char	*parse_relative_ref(const char*, struct phos_uri*);
59 static const char	*parse_uri_reference(const char*, struct phos_uri*);
60 
61 static int		 hasprefix(const char*, const char*);
62 static char		*dotdot(char*, char*);
63 static void		 path_clean(struct phos_uri*);
64 static int		 merge_path(struct phos_uri*, const struct phos_uri*, const struct phos_uri*);
65 
66 static int		 phos_resolve_uri_from(const struct phos_uri*, const struct phos_uri*, struct phos_uri*);
67 
68 
69 /* common defs */
70 
71 static inline int
72 gen_delims(int c)
73 {
74 	return c == ':'
75 		|| c == '/'
76 		|| c == '?'
77 		|| c == '#'
78 		|| c == '['
79 		|| c == ']'
80 		|| c == '@';
81 }
82 
83 static inline int
84 sub_delims(int c)
85 {
86 	return c == '!'
87 		|| c == '$'
88 		|| c == '&'
89 		|| c == '\''
90 		|| c == '('
91 		|| c == ')'
92 		|| c == '*'
93 		|| c == '+'
94 		|| c == ','
95 		|| c == ';'
96 		|| c == '=';
97 }
98 
99 static inline int
100 reserved(int c)
101 {
102 	return gen_delims(c) || sub_delims(c);
103 }
104 
105 static inline int
106 unreserved(int c)
107 {
108 	return isalpha(c)
109 		|| isdigit(c)
110 		|| c == '-'
111 		|| c == '.'
112 		|| c == '_'
113 		|| c == '~';
114 }
115 
116 
117 /* subs */
118 
119 /*
120  * IP-literal = "[" ( IPv6address / IPvFuture ) "]"
121  *
122  * in reality, we parse [.*]
123  */
124 static const char *
125 sub_ip_literal(const char *s)
126 {
127 	if (*s != '[')
128 		return NULL;
129 
130 	while (*s != '\0' && *s != ']')
131 		s++;
132 
133 	if (*s == '\0')
134 		return NULL;
135 	return ++s;
136 }
137 
138 /*
139  * parse everything until : or / (or \0).
140  * NB: empty hosts are technically valid!
141  */
142 static const char *
143 sub_host_dummy(const char *s)
144 {
145 	while (*s != '\0' && *s != ':' && *s != '/')
146 		s++;
147 	return s;
148 }
149 
150 /*
151  * pchar = unreserved / pct-encoded / sub-delims / ":" / "@"
152  */
153 static const char *
154 sub_pchar(const char *s)
155 {
156 	if (*s == '\0')
157 		return NULL;
158 
159 	if (unreserved(*s))
160 		return ++s;
161 
162 	if (*s == '%') {
163 		if (isxdigit(s[1]) && isxdigit(s[2]))
164 			return s + 3;
165 	}
166 
167 	if (sub_delims(*s))
168 		return ++s;
169 
170 	if (*s == ':' || *s == '@')
171 		return ++s;
172 
173 	return NULL;
174 }
175 
176 /*
177  * segment = *pchar
178  */
179 static const char *
180 sub_segment(const char *s)
181 {
182 	const char *t;
183 
184 	while ((t = sub_pchar(s)) != NULL)
185 		s = t;
186 	return s;
187 }
188 
189 /* segment-nz = 1*pchar */
190 static const char *
191 sub_segment_nz(const char *s)
192 {
193 	if ((s = sub_pchar(s)) == NULL)
194 		return NULL;
195 	return sub_segment(s);
196 }
197 
198 /*
199  * segment-nz-nc = 1*( unreserved / pct-encoded / sub-delims / "@" )
200  *
201  * so, 1*pchar excluding ":"
202  */
203 static const char *
204 sub_segment_nz_nc(const char *s)
205 {
206 	const char *t;
207 
208 	if (*s == ':')
209 		return NULL;
210 
211         while (*s != ':' && (t = sub_pchar(s)) != NULL)
212 		s = t;
213 	return s;
214 }
215 
216 /* *( "/" segment ) */
217 static const char *
218 sub_path_common(const char *s)
219 {
220 	for (;;) {
221 		if (*s != '/')
222 			return s;
223 		s++;
224 		s = sub_segment(s);
225 	}
226 }
227 
228 
229 /* parse fns */
230 
231 /*
232  * scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
233  */
234 static const char *
235 parse_scheme(const char *s, struct phos_uri *parsed)
236 {
237 	const char	*start = s;
238 	size_t		 len;
239 
240 	if (!isalpha(*s))
241 		return NULL;
242 
243 	while (*s != '\0') {
244 		if (isalpha(*s) ||
245 		    isdigit(*s) ||
246 		    *s == '+' ||
247 		    *s == '-' ||
248 		    *s == '.')
249 			s++;
250 		else
251 			break;
252 	}
253 
254 	if (*s == '\0')
255                 return NULL;
256 
257 	len = s - start;
258 	if (len >= sizeof(parsed->scheme))
259 		return NULL;
260 
261 	memcpy(parsed->scheme, start, len);
262 	return s;
263 }
264 
265 /*
266  * host = IP-literal / IPv4address / reg-name
267  *
268  * rules IPv4address and reg-name are relaxed into parse_host_dummy.
269  */
270 static const char *
271 parse_host(const char *s, struct phos_uri *parsed)
272 {
273 	const char	*t;
274 	size_t		 len;
275 
276 	if ((t = sub_ip_literal(s)) != NULL ||
277 	    (t = sub_host_dummy(s)) != NULL) {
278 		len = t - s;
279 		if (len >= sizeof(parsed->scheme))
280 			return NULL;
281 		memcpy(parsed->host, s, len);
282 		return t;
283 	}
284 
285 	return NULL;
286 }
287 
288 /*
289  * port = *digit
290  */
291 static const char *
292 parse_port(const char *s, struct phos_uri *parsed)
293 {
294 	const char	*errstr, *start = s;
295 	size_t		 len;
296 
297 	while (isdigit(*s))
298 		s++;
299 
300 	if (s == start)
301 		return NULL;
302 
303 	len = s - start;
304 	if (len >= sizeof(parsed->port))
305 		return NULL;
306 
307 	memcpy(parsed->port, start, len);
308 
309         parsed->dec_port = strtonum(parsed->port, 0, 65535, &errstr);
310 	if (errstr != NULL)
311 		return NULL;
312 
313 	return s;
314 }
315 
316 /*
317  * authority = host [ ":" port ]
318  * (yep, blatantly ignore the userinfo stuff -- not relevant for Gemini)
319  */
320 static const char *
321 parse_authority(const char *s, struct phos_uri *parsed)
322 {
323 	if ((s = parse_host(s, parsed)) == NULL)
324 		return NULL;
325 
326 	if (*s == ':') {
327 		s++;
328 		return parse_port(s, parsed);
329 	}
330 
331 	return s;
332 }
333 
334 static inline const char *
335 set_path(const char *start, const char *end, struct phos_uri *parsed)
336 {
337 	size_t len;
338 
339 	if (end == NULL)
340 		return NULL;
341 
342 	len = end - start;
343 	if (len >= sizeof(parsed->path))
344 		return NULL;
345 	memcpy(parsed->path, start, len);
346 	return end;
347 }
348 
349 /*
350  * path-abempty = *( "/" segment )
351  */
352 static const char *
353 parse_path_abempty(const char *s, struct phos_uri *parsed)
354 {
355 	const char *t;
356 
357 	t = sub_path_common(s);
358 	return set_path(s, t, parsed);
359 }
360 
361 /*
362  * path-absolute = "/" [ segment-nz *( "/" segment ) ]
363  */
364 static const char *
365 parse_path_absolute(const char *s, struct phos_uri *parsed)
366 {
367 	const char *t, *start = s;
368 
369 	if (*s != '/')
370 		return NULL;
371 
372 	s++;
373 	if ((t = sub_segment_nz(s)) == NULL)
374 		return set_path(start, s, parsed);
375 
376 	s = sub_path_common(t);
377 	return set_path(start, s, parsed);
378 }
379 
380 /*
381  * path-noscheme = segment-nz-nc *( "/" segment )
382  */
383 static const char *
384 parse_path_noscheme(const char *s, struct phos_uri *parsed)
385 {
386 	const char *start = s;
387 
388 	if ((s = sub_segment_nz_nc(s)) == NULL)
389 		return NULL;
390 	s = sub_path_common(s);
391 	return set_path(start, s, parsed);
392 }
393 
394 /*
395  * path-rootless = segment-nz *( "/" segment )
396  */
397 static const char *
398 parse_path_rootless(const char *s, struct phos_uri *parsed)
399 {
400 	const char *start = s;
401 
402 	if ((s = sub_segment_nz(s)) == NULL)
403 		return NULL;
404 	s = sub_path_common(s);
405 	return set_path(start, s, parsed);
406 }
407 
408 /*
409  * path-empty = 0<pchar>
410  */
411 static const char *
412 parse_path_empty(const char *s, struct phos_uri *parsed)
413 {
414 	return s;
415 }
416 
417 /*
418  * hier-part = "//" authority path-abempty
419  *           / path-absolute
420  *           / path-rootless
421  *           / path-empty
422  */
423 static const char *
424 parse_hier_part(const char *s, struct phos_uri *parsed)
425 {
426 	const char *t;
427 
428 	if (s[0] == '/' && s[1] == '/') {
429 		s += 2;
430 		if ((s = parse_authority(s, parsed)) == NULL)
431 			return NULL;
432 		return parse_path_abempty(s, parsed);
433 	}
434 
435 	if ((t = parse_path_absolute(s, parsed)) != NULL)
436 		return t;
437 
438 	if ((t = parse_path_rootless(s, parsed)) != NULL)
439 		return t;
440 
441 	return parse_path_empty(s, parsed);
442 }
443 
444 /*
445  * query = *( pchar / "/" / "?" )
446  */
447 static const char *
448 parse_query(const char *s, struct phos_uri *parsed)
449 {
450 	const char	*t, *start = s;
451 	size_t		 len;
452 
453 	while (*s != '\0') {
454 		if (*s == '/' || *s == '?') {
455 			s++;
456 			continue;
457 		}
458 
459 		if ((t = sub_pchar(s)) == NULL)
460                         break;
461 		s = t;
462 	}
463 
464 	len = s - start;
465 	if (len >= sizeof(parsed->query))
466 		return NULL;
467 
468 	memcpy(parsed->query, start, len);
469 	return s;
470 }
471 
472 /*
473  * fragment = *( pchar / "/" / "?" )
474  */
475 static const char *
476 parse_fragment(const char *s, struct phos_uri *parsed)
477 {
478 	const char	*start = s;
479 	size_t		 len;
480 
481 	for (;;) {
482 		if (*s == '\0')
483 			break;
484 
485 		if (*s == '/' || *s == '?') {
486 			s++;
487 			continue;
488 		}
489 
490 		if ((s = sub_pchar(s)) == NULL)
491 			return NULL;
492 	}
493 
494 	len = s - start;
495 	if (len >= sizeof(parsed->fragment))
496 		return NULL;
497 
498 	memcpy(parsed->fragment, start, len);
499 	return s;
500 }
501 
502 /*
503  * URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
504  */
505 static const char *
506 parse_uri(const char *s, struct phos_uri *parsed)
507 {
508 	if ((s = parse_scheme(s, parsed)) == NULL)
509 		return NULL;
510 
511 	if (*s != ':')
512 		return NULL;
513 
514 	s++;
515 	if ((s = parse_hier_part(s, parsed)) == NULL)
516 		return NULL;
517 
518 	if (*s == '?') {
519 		s++;
520 		if ((s = parse_query(s, parsed)) == NULL)
521 			return NULL;
522 	}
523 
524 	if (*s == '#') {
525 		s++;
526 		if ((s = parse_fragment(s, parsed)) == NULL)
527 			return NULL;
528 	}
529 
530 	return s;
531 }
532 
533 /*
534  * relative-part = "//" authority path-abempty
535  *               / path-absolute
536  *               / path-noscheme
537  *               / path-empty
538  */
539 static const char *
540 parse_relative_part(const char *s, struct phos_uri *parsed)
541 {
542 	const char *t;
543 
544 	if (s[0] == '/' && s[1] == '/') {
545 		s += 2;
546 		if ((s = parse_authority(s, parsed)) == NULL)
547 			return NULL;
548 		return parse_path_abempty(s, parsed);
549 	}
550 
551 	if ((t = parse_path_absolute(s, parsed)) != NULL)
552 		return t;
553 
554 	if ((t = parse_path_noscheme(s, parsed)) != NULL)
555 		return t;
556 
557 	return parse_path_empty(s, parsed);
558 }
559 
560 /*
561  * relative-ref = relative-part [ "?" query ] [ "#" fragment ]
562  */
563 static const char *
564 parse_relative_ref(const char *s, struct phos_uri *parsed)
565 {
566 	if ((s = parse_relative_part(s, parsed)) == NULL)
567 		return NULL;
568 
569 	if (*s == '?') {
570 		s++;
571 		if ((s = parse_query(s, parsed)) == NULL)
572 			return NULL;
573 	}
574 
575 	if (*s == '#') {
576 		s++;
577 		if ((s = parse_fragment(s, parsed)) == NULL)
578 			return NULL;
579 	}
580 
581 	return s;
582 }
583 
584 /*
585  * URI-reference = URI / relative-ref
586  */
587 static const char *
588 parse_uri_reference(const char *s, struct phos_uri *parsed)
589 {
590 	const char *t;
591 
592 	if ((t = parse_uri(s, parsed)) != NULL)
593 		return t;
594 	memset(parsed, 0, sizeof(*parsed));
595 	return parse_relative_ref(s, parsed);
596 }
597 
598 
599 /*
600  * absolute-URI = scheme ":" hier-part [ "?" query ]
601  */
602 static const char *
603 parse_absolute_uri(const char *s, struct phos_uri *parsed)
604 {
605 	if ((s = parse_scheme(s, parsed)) == NULL)
606 		return NULL;
607 
608 	if (*s != ':')
609 		return NULL;
610 
611 	s++;
612 	if ((s = parse_hier_part(s, parsed)) == NULL)
613 		return NULL;
614 
615 	if (*s == '?') {
616 		s++;
617 		if ((s = parse_query(s, parsed)) == NULL)
618 			return NULL;
619 	}
620 
621 	return s;
622 }
623 
624 
625 /* normalizing fns */
626 
627 static int
628 hasprefix(const char *str, const char *prfx)
629 {
630 	for (; *str == *prfx && *prfx != '\0'; str++, prfx++)
631 		;
632 
633 	return *prfx == '\0';
634 }
635 
636 static char *
637 dotdot(char *point, char *start)
638 {
639 	char	*t;
640 
641 	for (t = point-1; t > start; --t) {
642 		if (*t == '/')
643 			break;
644 	}
645 	if (t < start)
646 		t = start;
647 
648 	memmove(t, point, strlen(point)+1);
649 	return t;
650 }
651 
652 /*
653  * This is the "Remove Dot Segments" straight outta RFC3986, section
654  * 5.2.4
655  */
656 static void
657 path_clean(struct phos_uri *uri)
658 {
659 	char	*in = uri->path;
660 
661 	while (in != NULL && *in != '\0') {
662 		assert(in >= uri->path);
663 
664 		/* A) drop leading ../ or ./ */
665 		if (hasprefix(in, "../"))
666 			memmove(in, &in[3], strlen(&in[3])+1);
667 		else if (hasprefix(in, "./"))
668 			memmove(in, &in[2], strlen(&in[2])+1);
669 
670 		/* B) replace /./ or /. with / */
671 		else if (hasprefix(in, "/./"))
672 			memmove(&in[1], &in[3], strlen(&in[3])+1);
673 		else if (!strcmp(in, "/."))
674                         in[1] = '\0';
675 
676 		/* C) resolve dot-dot */
677 		else if (hasprefix(in, "/../")) {
678 			in = dotdot(in, uri->path);
679 			memmove(&in[1], &in[4], strlen(&in[4])+1);
680 		} else if (!strcmp(in, "/..")) {
681 			in = dotdot(in, uri->path);
682 			in[1] = '\0';
683 			break;
684 		}
685 
686 		/* D */
687 		else if (!strcmp(in, "."))
688 			*in = '\0';
689 		else if (!strcmp(in, ".."))
690 			*in = '\0';
691 
692 		/* E */
693 		else
694 			in = strchr(in+1, '/');
695 	}
696 }
697 
698 /*
699  * see RFC3986 5.3.3 "Merge Paths".
700  */
701 static int
702 merge_path(struct phos_uri *ret, const struct phos_uri *base,
703     const struct phos_uri *ref)
704 {
705 	const char *s;
706 	size_t len;
707 
708 	len = sizeof(ret->path);
709 
710 	s = strrchr(base->path, '/');
711 	if ((*base->host != '\0' && *base->path == '\0') || s == NULL) {
712 		strlcpy(ret->path, "/", len);
713 	} else {
714 		/* copy the / too */
715                 memcpy(ret->path, base->path, s - base->path + 1);
716 	}
717 
718 	return strlcat(ret->path, ref->path, len) < len;
719 }
720 
721 
722 /* public interface */
723 
724 int
725 phos_parse_absolute_uri(const char *s, struct phos_uri *uri)
726 {
727 	memset(uri, 0, sizeof(*uri));
728 
729 	if ((s = parse_absolute_uri(s, uri)) == NULL)
730 		return 0;
731 	if (*s != '\0')
732 		return 0;
733 	path_clean(uri);
734 	return 1;
735 }
736 
737 int
738 phos_parse_uri_reference(const char *s, struct phos_uri *uri)
739 {
740 	memset(uri, 0, sizeof(*uri));
741 
742 	if ((s = parse_uri_reference(s, uri)) == NULL)
743 		return 0;
744 	if (*s != '\0')
745 		return 0;
746 	path_clean(uri);
747 	return 1;
748 }
749 
750 /*
751  * Implementation of the "transform references" algorithm from
752  * RFC3986, see 5.2.2.
753  *
754  * We expect base and ref to be URIs constructed by this library
755  * (because we emit only normalized URIs).
756  *
757  * ATM this is marked as private because:
758  * - let's say the URI is "."
759  * - one calls phos_parse_uri_references
760  * - it exists with success, but the path becomes ""
761  * - this routine does the right thing, but the outcome is not what expected.
762  *
763  * so users for now have to user resolve_uri_from_str, which parses
764  * the URI but not normalize it, and then call into us.
765  */
766 static int
767 phos_resolve_uri_from(const struct phos_uri *base, const struct phos_uri *ref,
768     struct phos_uri *ret)
769 {
770 	memset(ret, 0, sizeof(*ret));
771 
772 	if (*ref->scheme != '\0') {
773 		strlcpy(ret->scheme, ref->scheme, sizeof(ret->scheme));
774 		strlcpy(ret->host, ref->host, sizeof(ret->host));
775 		strlcpy(ret->port, ref->port, sizeof(ret->port));
776 		ret->dec_port = ret->dec_port;
777 		strlcpy(ret->path, ref->path, sizeof(ret->path));
778 		strlcpy(ret->query, ref->query, sizeof(ret->query));
779 	} else {
780 		if (*ref->host != '\0') {
781 			strlcpy(ret->host, ref->host, sizeof(ret->host));
782 			strlcpy(ret->port, ref->port, sizeof(ret->port));
783 			ret->dec_port = ret->dec_port;
784 			strlcpy(ret->path, ref->path, sizeof(ret->path));
785 			strlcpy(ret->query, ref->query, sizeof(ret->query));
786 		} else {
787 			if (*ref->path == '\0') {
788 				strlcpy(ret->path, base->path, sizeof(ret->path));
789 				if (*ref->query != '\0')
790 					strlcpy(ret->query, ref->query, sizeof(ret->query));
791 				else
792 					strlcpy(ret->query, base->query, sizeof(ret->query));
793 			} else {
794 				if (*ref->path == '/')
795 					strlcpy(ret->path, ref->path, sizeof(ret->path));
796 				else {
797 					if (!merge_path(ret, base, ref))
798 						return 0;
799 				}
800 				path_clean(ret);
801 
802 				strlcpy(ret->query, ref->query, sizeof(ret->query));
803 			}
804 
805 			strlcpy(ret->host, base->host, sizeof(ret->host));
806 			strlcpy(ret->port, base->port, sizeof(ret->port));
807 			ret->dec_port = base->dec_port;
808 		}
809 
810 		strlcpy(ret->scheme, base->scheme, sizeof(ret->scheme));
811 	}
812 
813 	strlcpy(ret->fragment, ref->fragment, sizeof(ret->fragment));
814 
815 	return 1;
816 }
817 
818 int
819 phos_resolve_uri_from_str(const struct phos_uri *base, const char *refstr,
820     struct phos_uri *ret)
821 {
822 	struct phos_uri ref;
823 
824 	memset(&ref, 0, sizeof(ref));
825 
826 	if ((refstr = parse_uri_reference(refstr, &ref)) == NULL)
827 		return 0;
828 
829 	if (*refstr != '\0')
830 		return 0;
831 
832 	return phos_resolve_uri_from(base, &ref, ret);
833 }
834 
835 void
836 phos_uri_drop_empty_segments(struct phos_uri *uri)
837 {
838 	char *i;
839 
840 	for (i = uri->path; *i; ++i) {
841 		if (*i == '/' && *(i+1) == '/') {
842 			memmove(i, i+1, strlen(i)); /* move also the \0 */
843 			i--;
844 		}
845 	}
846 }
847 
848 int
849 phos_uri_set_query(struct phos_uri *uri, const char *query)
850 {
851 	char		*out;
852 	int		 t;
853 	size_t		 len;
854 
855 	len = sizeof(uri->query);
856 	out = uri->query;
857 	memset(uri->query, 0, len);
858 
859 	for (; *query != '\0' && len > 0; ++query) {
860 		if (*query == '/' ||
861 		    *query == '?' ||
862 		    *query == ':' ||
863 		    *query == '@' ||
864 		    unreserved(*query) ||
865 		    sub_delims(*query)) {
866 			*out++ = *query;
867 			len--;
868 		} else {
869 			if (len <= 4)
870 				break;
871 			len -= 3;
872 			*out++ = '%';
873 			t = *query;
874 			sprintf(out, "%02X", t);
875 			out += 2;
876 		}
877 	}
878 
879 	return *query == '\0';
880 }
881 
882 int
883 phos_serialize_uri(const struct phos_uri *uri, char *buf, size_t len)
884 {
885 #define CAT(s)					\
886 	if (strlcat(buf, s, len) >= len)	\
887 		return 0;
888 
889 	strlcpy(buf, "", len);
890 
891 	if (*uri->scheme != '\0') {
892                 CAT(uri->scheme);
893 		CAT(":");
894 	}
895 
896 	if (*uri->host != '\0' || strcmp(uri->scheme, "file") == 0) {
897 		/*
898 		 * The file URI scheme has a quirk that even if a
899 		 * hostname is not present, we still have to append
900 		 * the two slashes.  This is why we have
901 		 * file:///etc/hosts and not file:/etc/hosts
902 		 */
903 		CAT("//");
904 		CAT(uri->host);
905 	}
906 
907 	if (*uri->port != '\0' && strcmp(uri->port, "1965")) {
908 		CAT(":");
909 		CAT(uri->port);
910 	}
911 
912 	CAT(uri->path);
913 
914 	if (*uri->query != '\0') {
915 		CAT("?");
916 		CAT(uri->query);
917 	}
918 
919 	if (*uri->fragment) {
920 		CAT("#");
921 		CAT(uri->fragment);
922 	}
923 
924 	return 1;
925 
926 #undef CAT
927 }