1: /**
2: * uri.c: set of generic URI related routines
3: *
4: * Reference: RFCs 3986, 2732 and 2373
5: *
6: * See Copyright for the status of this software.
7: *
8: * daniel@veillard.com
9: */
10:
11: #define IN_LIBXML
12: #include "libxml.h"
13:
14: #include <string.h>
15:
16: #include <libxml/xmlmemory.h>
17: #include <libxml/uri.h>
18: #include <libxml/globals.h>
19: #include <libxml/xmlerror.h>
20:
21: static void xmlCleanURI(xmlURIPtr uri);
22:
23: /*
24: * Old rule from 2396 used in legacy handling code
25: * alpha = lowalpha | upalpha
26: */
27: #define IS_ALPHA(x) (IS_LOWALPHA(x) || IS_UPALPHA(x))
28:
29:
30: /*
31: * lowalpha = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" |
32: * "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" |
33: * "u" | "v" | "w" | "x" | "y" | "z"
34: */
35:
36: #define IS_LOWALPHA(x) (((x) >= 'a') && ((x) <= 'z'))
37:
38: /*
39: * upalpha = "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" |
40: * "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" |
41: * "U" | "V" | "W" | "X" | "Y" | "Z"
42: */
43: #define IS_UPALPHA(x) (((x) >= 'A') && ((x) <= 'Z'))
44:
45: #ifdef IS_DIGIT
46: #undef IS_DIGIT
47: #endif
48: /*
49: * digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"
50: */
51: #define IS_DIGIT(x) (((x) >= '0') && ((x) <= '9'))
52:
53: /*
54: * alphanum = alpha | digit
55: */
56:
57: #define IS_ALPHANUM(x) (IS_ALPHA(x) || IS_DIGIT(x))
58:
59: /*
60: * mark = "-" | "_" | "." | "!" | "~" | "*" | "'" | "(" | ")"
61: */
62:
63: #define IS_MARK(x) (((x) == '-') || ((x) == '_') || ((x) == '.') || \
64: ((x) == '!') || ((x) == '~') || ((x) == '*') || ((x) == '\'') || \
65: ((x) == '(') || ((x) == ')'))
66:
67: /*
68: * unwise = "{" | "}" | "|" | "\" | "^" | "`"
69: */
70:
71: #define IS_UNWISE(p) \
72: (((*(p) == '{')) || ((*(p) == '}')) || ((*(p) == '|')) || \
73: ((*(p) == '\\')) || ((*(p) == '^')) || ((*(p) == '[')) || \
74: ((*(p) == ']')) || ((*(p) == '`')))
75: /*
76: * reserved = ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" | "$" | "," |
77: * "[" | "]"
78: */
79:
80: #define IS_RESERVED(x) (((x) == ';') || ((x) == '/') || ((x) == '?') || \
81: ((x) == ':') || ((x) == '@') || ((x) == '&') || ((x) == '=') || \
82: ((x) == '+') || ((x) == '$') || ((x) == ',') || ((x) == '[') || \
83: ((x) == ']'))
84:
85: /*
86: * unreserved = alphanum | mark
87: */
88:
89: #define IS_UNRESERVED(x) (IS_ALPHANUM(x) || IS_MARK(x))
90:
91: /*
92: * Skip to next pointer char, handle escaped sequences
93: */
94:
95: #define NEXT(p) ((*p == '%')? p += 3 : p++)
96:
97: /*
98: * Productions from the spec.
99: *
100: * authority = server | reg_name
101: * reg_name = 1*( unreserved | escaped | "$" | "," |
102: * ";" | ":" | "@" | "&" | "=" | "+" )
103: *
104: * path = [ abs_path | opaque_part ]
105: */
106:
107: #define STRNDUP(s, n) (char *) xmlStrndup((const xmlChar *)(s), (n))
108:
109: /************************************************************************
110: * *
111: * RFC 3986 parser *
112: * *
113: ************************************************************************/
114:
115: #define ISA_DIGIT(p) ((*(p) >= '0') && (*(p) <= '9'))
116: #define ISA_ALPHA(p) (((*(p) >= 'a') && (*(p) <= 'z')) || \
117: ((*(p) >= 'A') && (*(p) <= 'Z')))
118: #define ISA_HEXDIG(p) \
119: (ISA_DIGIT(p) || ((*(p) >= 'a') && (*(p) <= 'f')) || \
120: ((*(p) >= 'A') && (*(p) <= 'F')))
121:
122: /*
123: * sub-delims = "!" / "$" / "&" / "'" / "(" / ")"
124: * / "*" / "+" / "," / ";" / "="
125: */
126: #define ISA_SUB_DELIM(p) \
127: (((*(p) == '!')) || ((*(p) == '$')) || ((*(p) == '&')) || \
128: ((*(p) == '(')) || ((*(p) == ')')) || ((*(p) == '*')) || \
129: ((*(p) == '+')) || ((*(p) == ',')) || ((*(p) == ';')) || \
130: ((*(p) == '=')) || ((*(p) == '\'')))
131:
132: /*
133: * gen-delims = ":" / "/" / "?" / "#" / "[" / "]" / "@"
134: */
135: #define ISA_GEN_DELIM(p) \
136: (((*(p) == ':')) || ((*(p) == '/')) || ((*(p) == '?')) || \
137: ((*(p) == '#')) || ((*(p) == '[')) || ((*(p) == ']')) || \
138: ((*(p) == '@')))
139:
140: /*
141: * reserved = gen-delims / sub-delims
142: */
143: #define ISA_RESERVED(p) (ISA_GEN_DELIM(p) || (ISA_SUB_DELIM(p)))
144:
145: /*
146: * unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
147: */
148: #define ISA_UNRESERVED(p) \
149: ((ISA_ALPHA(p)) || (ISA_DIGIT(p)) || ((*(p) == '-')) || \
150: ((*(p) == '.')) || ((*(p) == '_')) || ((*(p) == '~')))
151:
152: /*
153: * pct-encoded = "%" HEXDIG HEXDIG
154: */
155: #define ISA_PCT_ENCODED(p) \
156: ((*(p) == '%') && (ISA_HEXDIG(p + 1)) && (ISA_HEXDIG(p + 2)))
157:
158: /*
159: * pchar = unreserved / pct-encoded / sub-delims / ":" / "@"
160: */
161: #define ISA_PCHAR(p) \
162: (ISA_UNRESERVED(p) || ISA_PCT_ENCODED(p) || ISA_SUB_DELIM(p) || \
163: ((*(p) == ':')) || ((*(p) == '@')))
164:
165: /**
166: * xmlParse3986Scheme:
167: * @uri: pointer to an URI structure
168: * @str: pointer to the string to analyze
169: *
170: * Parse an URI scheme
171: *
172: * ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
173: *
174: * Returns 0 or the error code
175: */
176: static int
177: xmlParse3986Scheme(xmlURIPtr uri, const char **str) {
178: const char *cur;
179:
180: if (str == NULL)
181: return(-1);
182:
183: cur = *str;
184: if (!ISA_ALPHA(cur))
185: return(2);
186: cur++;
187: while (ISA_ALPHA(cur) || ISA_DIGIT(cur) ||
188: (*cur == '+') || (*cur == '-') || (*cur == '.')) cur++;
189: if (uri != NULL) {
190: if (uri->scheme != NULL) xmlFree(uri->scheme);
191: uri->scheme = STRNDUP(*str, cur - *str);
192: }
193: *str = cur;
194: return(0);
195: }
196:
197: /**
198: * xmlParse3986Fragment:
199: * @uri: pointer to an URI structure
200: * @str: pointer to the string to analyze
201: *
202: * Parse the query part of an URI
203: *
204: * fragment = *( pchar / "/" / "?" )
205: * NOTE: the strict syntax as defined by 3986 does not allow '[' and ']'
206: * in the fragment identifier but this is used very broadly for
207: * xpointer scheme selection, so we are allowing it here to not break
208: * for example all the DocBook processing chains.
209: *
210: * Returns 0 or the error code
211: */
212: static int
213: xmlParse3986Fragment(xmlURIPtr uri, const char **str)
214: {
215: const char *cur;
216:
217: if (str == NULL)
218: return (-1);
219:
220: cur = *str;
221:
222: while ((ISA_PCHAR(cur)) || (*cur == '/') || (*cur == '?') ||
223: (*cur == '[') || (*cur == ']') ||
224: ((uri != NULL) && (uri->cleanup & 1) && (IS_UNWISE(cur))))
225: NEXT(cur);
226: if (uri != NULL) {
227: if (uri->fragment != NULL)
228: xmlFree(uri->fragment);
229: if (uri->cleanup & 2)
230: uri->fragment = STRNDUP(*str, cur - *str);
231: else
232: uri->fragment = xmlURIUnescapeString(*str, cur - *str, NULL);
233: }
234: *str = cur;
235: return (0);
236: }
237:
238: /**
239: * xmlParse3986Query:
240: * @uri: pointer to an URI structure
241: * @str: pointer to the string to analyze
242: *
243: * Parse the query part of an URI
244: *
245: * query = *uric
246: *
247: * Returns 0 or the error code
248: */
249: static int
250: xmlParse3986Query(xmlURIPtr uri, const char **str)
251: {
252: const char *cur;
253:
254: if (str == NULL)
255: return (-1);
256:
257: cur = *str;
258:
259: while ((ISA_PCHAR(cur)) || (*cur == '/') || (*cur == '?') ||
260: ((uri != NULL) && (uri->cleanup & 1) && (IS_UNWISE(cur))))
261: NEXT(cur);
262: if (uri != NULL) {
263: if (uri->query != NULL)
264: xmlFree(uri->query);
265: if (uri->cleanup & 2)
266: uri->query = STRNDUP(*str, cur - *str);
267: else
268: uri->query = xmlURIUnescapeString(*str, cur - *str, NULL);
269:
270: /* Save the raw bytes of the query as well.
271: * See: http://mail.gnome.org/archives/xml/2007-April/thread.html#00114
272: */
273: if (uri->query_raw != NULL)
274: xmlFree (uri->query_raw);
275: uri->query_raw = STRNDUP (*str, cur - *str);
276: }
277: *str = cur;
278: return (0);
279: }
280:
281: /**
282: * xmlParse3986Port:
283: * @uri: pointer to an URI structure
284: * @str: the string to analyze
285: *
286: * Parse a port part and fills in the appropriate fields
287: * of the @uri structure
288: *
289: * port = *DIGIT
290: *
291: * Returns 0 or the error code
292: */
293: static int
294: xmlParse3986Port(xmlURIPtr uri, const char **str)
295: {
296: const char *cur = *str;
297:
298: if (ISA_DIGIT(cur)) {
299: if (uri != NULL)
300: uri->port = 0;
301: while (ISA_DIGIT(cur)) {
302: if (uri != NULL)
303: uri->port = uri->port * 10 + (*cur - '0');
304: cur++;
305: }
306: *str = cur;
307: return(0);
308: }
309: return(1);
310: }
311:
312: /**
313: * xmlParse3986Userinfo:
314: * @uri: pointer to an URI structure
315: * @str: the string to analyze
316: *
317: * Parse an user informations part and fills in the appropriate fields
318: * of the @uri structure
319: *
320: * userinfo = *( unreserved / pct-encoded / sub-delims / ":" )
321: *
322: * Returns 0 or the error code
323: */
324: static int
325: xmlParse3986Userinfo(xmlURIPtr uri, const char **str)
326: {
327: const char *cur;
328:
329: cur = *str;
330: while (ISA_UNRESERVED(cur) || ISA_PCT_ENCODED(cur) ||
331: ISA_SUB_DELIM(cur) || (*cur == ':'))
332: NEXT(cur);
333: if (*cur == '@') {
334: if (uri != NULL) {
335: if (uri->user != NULL) xmlFree(uri->user);
336: if (uri->cleanup & 2)
337: uri->user = STRNDUP(*str, cur - *str);
338: else
339: uri->user = xmlURIUnescapeString(*str, cur - *str, NULL);
340: }
341: *str = cur;
342: return(0);
343: }
344: return(1);
345: }
346:
347: /**
348: * xmlParse3986DecOctet:
349: * @str: the string to analyze
350: *
351: * dec-octet = DIGIT ; 0-9
352: * / %x31-39 DIGIT ; 10-99
353: * / "1" 2DIGIT ; 100-199
354: * / "2" %x30-34 DIGIT ; 200-249
355: * / "25" %x30-35 ; 250-255
356: *
357: * Skip a dec-octet.
358: *
359: * Returns 0 if found and skipped, 1 otherwise
360: */
361: static int
362: xmlParse3986DecOctet(const char **str) {
363: const char *cur = *str;
364:
365: if (!(ISA_DIGIT(cur)))
366: return(1);
367: if (!ISA_DIGIT(cur+1))
368: cur++;
369: else if ((*cur != '0') && (ISA_DIGIT(cur + 1)) && (!ISA_DIGIT(cur+2)))
370: cur += 2;
371: else if ((*cur == '1') && (ISA_DIGIT(cur + 1)) && (ISA_DIGIT(cur + 2)))
372: cur += 3;
373: else if ((*cur == '2') && (*(cur + 1) >= '0') &&
374: (*(cur + 1) <= '4') && (ISA_DIGIT(cur + 2)))
375: cur += 3;
376: else if ((*cur == '2') && (*(cur + 1) == '5') &&
377: (*(cur + 2) >= '0') && (*(cur + 1) <= '5'))
378: cur += 3;
379: else
380: return(1);
381: *str = cur;
382: return(0);
383: }
384: /**
385: * xmlParse3986Host:
386: * @uri: pointer to an URI structure
387: * @str: the string to analyze
388: *
389: * Parse an host part and fills in the appropriate fields
390: * of the @uri structure
391: *
392: * host = IP-literal / IPv4address / reg-name
393: * IP-literal = "[" ( IPv6address / IPvFuture ) "]"
394: * IPv4address = dec-octet "." dec-octet "." dec-octet "." dec-octet
395: * reg-name = *( unreserved / pct-encoded / sub-delims )
396: *
397: * Returns 0 or the error code
398: */
399: static int
400: xmlParse3986Host(xmlURIPtr uri, const char **str)
401: {
402: const char *cur = *str;
403: const char *host;
404:
405: host = cur;
406: /*
407: * IPv6 and future adressing scheme are enclosed between brackets
408: */
409: if (*cur == '[') {
410: cur++;
411: while ((*cur != ']') && (*cur != 0))
412: cur++;
413: if (*cur != ']')
414: return(1);
415: cur++;
416: goto found;
417: }
418: /*
419: * try to parse an IPv4
420: */
421: if (ISA_DIGIT(cur)) {
422: if (xmlParse3986DecOctet(&cur) != 0)
423: goto not_ipv4;
424: if (*cur != '.')
425: goto not_ipv4;
426: cur++;
427: if (xmlParse3986DecOctet(&cur) != 0)
428: goto not_ipv4;
429: if (*cur != '.')
430: goto not_ipv4;
431: if (xmlParse3986DecOctet(&cur) != 0)
432: goto not_ipv4;
433: if (*cur != '.')
434: goto not_ipv4;
435: if (xmlParse3986DecOctet(&cur) != 0)
436: goto not_ipv4;
437: goto found;
438: not_ipv4:
439: cur = *str;
440: }
441: /*
442: * then this should be a hostname which can be empty
443: */
444: while (ISA_UNRESERVED(cur) || ISA_PCT_ENCODED(cur) || ISA_SUB_DELIM(cur))
445: NEXT(cur);
446: found:
447: if (uri != NULL) {
448: if (uri->authority != NULL) xmlFree(uri->authority);
449: uri->authority = NULL;
450: if (uri->server != NULL) xmlFree(uri->server);
451: if (cur != host) {
452: if (uri->cleanup & 2)
453: uri->server = STRNDUP(host, cur - host);
454: else
455: uri->server = xmlURIUnescapeString(host, cur - host, NULL);
456: } else
457: uri->server = NULL;
458: }
459: *str = cur;
460: return(0);
461: }
462:
463: /**
464: * xmlParse3986Authority:
465: * @uri: pointer to an URI structure
466: * @str: the string to analyze
467: *
468: * Parse an authority part and fills in the appropriate fields
469: * of the @uri structure
470: *
471: * authority = [ userinfo "@" ] host [ ":" port ]
472: *
473: * Returns 0 or the error code
474: */
475: static int
476: xmlParse3986Authority(xmlURIPtr uri, const char **str)
477: {
478: const char *cur;
479: int ret;
480:
481: cur = *str;
482: /*
483: * try to parse an userinfo and check for the trailing @
484: */
485: ret = xmlParse3986Userinfo(uri, &cur);
486: if ((ret != 0) || (*cur != '@'))
487: cur = *str;
488: else
489: cur++;
490: ret = xmlParse3986Host(uri, &cur);
491: if (ret != 0) return(ret);
492: if (*cur == ':') {
493: cur++;
494: ret = xmlParse3986Port(uri, &cur);
495: if (ret != 0) return(ret);
496: }
497: *str = cur;
498: return(0);
499: }
500:
501: /**
502: * xmlParse3986Segment:
503: * @str: the string to analyze
504: * @forbid: an optional forbidden character
505: * @empty: allow an empty segment
506: *
507: * Parse a segment and fills in the appropriate fields
508: * of the @uri structure
509: *
510: * segment = *pchar
511: * segment-nz = 1*pchar
512: * segment-nz-nc = 1*( unreserved / pct-encoded / sub-delims / "@" )
513: * ; non-zero-length segment without any colon ":"
514: *
515: * Returns 0 or the error code
516: */
517: static int
518: xmlParse3986Segment(const char **str, char forbid, int empty)
519: {
520: const char *cur;
521:
522: cur = *str;
523: if (!ISA_PCHAR(cur)) {
524: if (empty)
525: return(0);
526: return(1);
527: }
528: while (ISA_PCHAR(cur) && (*cur != forbid))
529: NEXT(cur);
530: *str = cur;
531: return (0);
532: }
533:
534: /**
535: * xmlParse3986PathAbEmpty:
536: * @uri: pointer to an URI structure
537: * @str: the string to analyze
538: *
539: * Parse an path absolute or empty and fills in the appropriate fields
540: * of the @uri structure
541: *
542: * path-abempty = *( "/" segment )
543: *
544: * Returns 0 or the error code
545: */
546: static int
547: xmlParse3986PathAbEmpty(xmlURIPtr uri, const char **str)
548: {
549: const char *cur;
550: int ret;
551:
552: cur = *str;
553:
554: while (*cur == '/') {
555: cur++;
556: ret = xmlParse3986Segment(&cur, 0, 1);
557: if (ret != 0) return(ret);
558: }
559: if (uri != NULL) {
560: if (uri->path != NULL) xmlFree(uri->path);
561: if (*str != cur) {
562: if (uri->cleanup & 2)
563: uri->path = STRNDUP(*str, cur - *str);
564: else
565: uri->path = xmlURIUnescapeString(*str, cur - *str, NULL);
566: } else {
567: uri->path = NULL;
568: }
569: }
570: *str = cur;
571: return (0);
572: }
573:
574: /**
575: * xmlParse3986PathAbsolute:
576: * @uri: pointer to an URI structure
577: * @str: the string to analyze
578: *
579: * Parse an path absolute and fills in the appropriate fields
580: * of the @uri structure
581: *
582: * path-absolute = "/" [ segment-nz *( "/" segment ) ]
583: *
584: * Returns 0 or the error code
585: */
586: static int
587: xmlParse3986PathAbsolute(xmlURIPtr uri, const char **str)
588: {
589: const char *cur;
590: int ret;
591:
592: cur = *str;
593:
594: if (*cur != '/')
595: return(1);
596: cur++;
597: ret = xmlParse3986Segment(&cur, 0, 0);
598: if (ret == 0) {
599: while (*cur == '/') {
600: cur++;
601: ret = xmlParse3986Segment(&cur, 0, 1);
602: if (ret != 0) return(ret);
603: }
604: }
605: if (uri != NULL) {
606: if (uri->path != NULL) xmlFree(uri->path);
607: if (cur != *str) {
608: if (uri->cleanup & 2)
609: uri->path = STRNDUP(*str, cur - *str);
610: else
611: uri->path = xmlURIUnescapeString(*str, cur - *str, NULL);
612: } else {
613: uri->path = NULL;
614: }
615: }
616: *str = cur;
617: return (0);
618: }
619:
620: /**
621: * xmlParse3986PathRootless:
622: * @uri: pointer to an URI structure
623: * @str: the string to analyze
624: *
625: * Parse an path without root and fills in the appropriate fields
626: * of the @uri structure
627: *
628: * path-rootless = segment-nz *( "/" segment )
629: *
630: * Returns 0 or the error code
631: */
632: static int
633: xmlParse3986PathRootless(xmlURIPtr uri, const char **str)
634: {
635: const char *cur;
636: int ret;
637:
638: cur = *str;
639:
640: ret = xmlParse3986Segment(&cur, 0, 0);
641: if (ret != 0) return(ret);
642: while (*cur == '/') {
643: cur++;
644: ret = xmlParse3986Segment(&cur, 0, 1);
645: if (ret != 0) return(ret);
646: }
647: if (uri != NULL) {
648: if (uri->path != NULL) xmlFree(uri->path);
649: if (cur != *str) {
650: if (uri->cleanup & 2)
651: uri->path = STRNDUP(*str, cur - *str);
652: else
653: uri->path = xmlURIUnescapeString(*str, cur - *str, NULL);
654: } else {
655: uri->path = NULL;
656: }
657: }
658: *str = cur;
659: return (0);
660: }
661:
662: /**
663: * xmlParse3986PathNoScheme:
664: * @uri: pointer to an URI structure
665: * @str: the string to analyze
666: *
667: * Parse an path which is not a scheme and fills in the appropriate fields
668: * of the @uri structure
669: *
670: * path-noscheme = segment-nz-nc *( "/" segment )
671: *
672: * Returns 0 or the error code
673: */
674: static int
675: xmlParse3986PathNoScheme(xmlURIPtr uri, const char **str)
676: {
677: const char *cur;
678: int ret;
679:
680: cur = *str;
681:
682: ret = xmlParse3986Segment(&cur, ':', 0);
683: if (ret != 0) return(ret);
684: while (*cur == '/') {
685: cur++;
686: ret = xmlParse3986Segment(&cur, 0, 1);
687: if (ret != 0) return(ret);
688: }
689: if (uri != NULL) {
690: if (uri->path != NULL) xmlFree(uri->path);
691: if (cur != *str) {
692: if (uri->cleanup & 2)
693: uri->path = STRNDUP(*str, cur - *str);
694: else
695: uri->path = xmlURIUnescapeString(*str, cur - *str, NULL);
696: } else {
697: uri->path = NULL;
698: }
699: }
700: *str = cur;
701: return (0);
702: }
703:
704: /**
705: * xmlParse3986HierPart:
706: * @uri: pointer to an URI structure
707: * @str: the string to analyze
708: *
709: * Parse an hierarchical part and fills in the appropriate fields
710: * of the @uri structure
711: *
712: * hier-part = "//" authority path-abempty
713: * / path-absolute
714: * / path-rootless
715: * / path-empty
716: *
717: * Returns 0 or the error code
718: */
719: static int
720: xmlParse3986HierPart(xmlURIPtr uri, const char **str)
721: {
722: const char *cur;
723: int ret;
724:
725: cur = *str;
726:
727: if ((*cur == '/') && (*(cur + 1) == '/')) {
728: cur += 2;
729: ret = xmlParse3986Authority(uri, &cur);
730: if (ret != 0) return(ret);
731: ret = xmlParse3986PathAbEmpty(uri, &cur);
732: if (ret != 0) return(ret);
733: *str = cur;
734: return(0);
735: } else if (*cur == '/') {
736: ret = xmlParse3986PathAbsolute(uri, &cur);
737: if (ret != 0) return(ret);
738: } else if (ISA_PCHAR(cur)) {
739: ret = xmlParse3986PathRootless(uri, &cur);
740: if (ret != 0) return(ret);
741: } else {
742: /* path-empty is effectively empty */
743: if (uri != NULL) {
744: if (uri->path != NULL) xmlFree(uri->path);
745: uri->path = NULL;
746: }
747: }
748: *str = cur;
749: return (0);
750: }
751:
752: /**
753: * xmlParse3986RelativeRef:
754: * @uri: pointer to an URI structure
755: * @str: the string to analyze
756: *
757: * Parse an URI string and fills in the appropriate fields
758: * of the @uri structure
759: *
760: * relative-ref = relative-part [ "?" query ] [ "#" fragment ]
761: * relative-part = "//" authority path-abempty
762: * / path-absolute
763: * / path-noscheme
764: * / path-empty
765: *
766: * Returns 0 or the error code
767: */
768: static int
769: xmlParse3986RelativeRef(xmlURIPtr uri, const char *str) {
770: int ret;
771:
772: if ((*str == '/') && (*(str + 1) == '/')) {
773: str += 2;
774: ret = xmlParse3986Authority(uri, &str);
775: if (ret != 0) return(ret);
776: ret = xmlParse3986PathAbEmpty(uri, &str);
777: if (ret != 0) return(ret);
778: } else if (*str == '/') {
779: ret = xmlParse3986PathAbsolute(uri, &str);
780: if (ret != 0) return(ret);
781: } else if (ISA_PCHAR(str)) {
782: ret = xmlParse3986PathNoScheme(uri, &str);
783: if (ret != 0) return(ret);
784: } else {
785: /* path-empty is effectively empty */
786: if (uri != NULL) {
787: if (uri->path != NULL) xmlFree(uri->path);
788: uri->path = NULL;
789: }
790: }
791:
792: if (*str == '?') {
793: str++;
794: ret = xmlParse3986Query(uri, &str);
795: if (ret != 0) return(ret);
796: }
797: if (*str == '#') {
798: str++;
799: ret = xmlParse3986Fragment(uri, &str);
800: if (ret != 0) return(ret);
801: }
802: if (*str != 0) {
803: xmlCleanURI(uri);
804: return(1);
805: }
806: return(0);
807: }
808:
809:
810: /**
811: * xmlParse3986URI:
812: * @uri: pointer to an URI structure
813: * @str: the string to analyze
814: *
815: * Parse an URI string and fills in the appropriate fields
816: * of the @uri structure
817: *
818: * scheme ":" hier-part [ "?" query ] [ "#" fragment ]
819: *
820: * Returns 0 or the error code
821: */
822: static int
823: xmlParse3986URI(xmlURIPtr uri, const char *str) {
824: int ret;
825:
826: ret = xmlParse3986Scheme(uri, &str);
827: if (ret != 0) return(ret);
828: if (*str != ':') {
829: return(1);
830: }
831: str++;
832: ret = xmlParse3986HierPart(uri, &str);
833: if (ret != 0) return(ret);
834: if (*str == '?') {
835: str++;
836: ret = xmlParse3986Query(uri, &str);
837: if (ret != 0) return(ret);
838: }
839: if (*str == '#') {
840: str++;
841: ret = xmlParse3986Fragment(uri, &str);
842: if (ret != 0) return(ret);
843: }
844: if (*str != 0) {
845: xmlCleanURI(uri);
846: return(1);
847: }
848: return(0);
849: }
850:
851: /**
852: * xmlParse3986URIReference:
853: * @uri: pointer to an URI structure
854: * @str: the string to analyze
855: *
856: * Parse an URI reference string and fills in the appropriate fields
857: * of the @uri structure
858: *
859: * URI-reference = URI / relative-ref
860: *
861: * Returns 0 or the error code
862: */
863: static int
864: xmlParse3986URIReference(xmlURIPtr uri, const char *str) {
865: int ret;
866:
867: if (str == NULL)
868: return(-1);
869: xmlCleanURI(uri);
870:
871: /*
872: * Try first to parse absolute refs, then fallback to relative if
873: * it fails.
874: */
875: ret = xmlParse3986URI(uri, str);
876: if (ret != 0) {
877: xmlCleanURI(uri);
878: ret = xmlParse3986RelativeRef(uri, str);
879: if (ret != 0) {
880: xmlCleanURI(uri);
881: return(ret);
882: }
883: }
884: return(0);
885: }
886:
887: /**
888: * xmlParseURI:
889: * @str: the URI string to analyze
890: *
891: * Parse an URI based on RFC 3986
892: *
893: * URI-reference = [ absoluteURI | relativeURI ] [ "#" fragment ]
894: *
895: * Returns a newly built xmlURIPtr or NULL in case of error
896: */
897: xmlURIPtr
898: xmlParseURI(const char *str) {
899: xmlURIPtr uri;
900: int ret;
901:
902: if (str == NULL)
903: return(NULL);
904: uri = xmlCreateURI();
905: if (uri != NULL) {
906: ret = xmlParse3986URIReference(uri, str);
907: if (ret) {
908: xmlFreeURI(uri);
909: return(NULL);
910: }
911: }
912: return(uri);
913: }
914:
915: /**
916: * xmlParseURIReference:
917: * @uri: pointer to an URI structure
918: * @str: the string to analyze
919: *
920: * Parse an URI reference string based on RFC 3986 and fills in the
921: * appropriate fields of the @uri structure
922: *
923: * URI-reference = URI / relative-ref
924: *
925: * Returns 0 or the error code
926: */
927: int
928: xmlParseURIReference(xmlURIPtr uri, const char *str) {
929: return(xmlParse3986URIReference(uri, str));
930: }
931:
932: /**
933: * xmlParseURIRaw:
934: * @str: the URI string to analyze
935: * @raw: if 1 unescaping of URI pieces are disabled
936: *
937: * Parse an URI but allows to keep intact the original fragments.
938: *
939: * URI-reference = URI / relative-ref
940: *
941: * Returns a newly built xmlURIPtr or NULL in case of error
942: */
943: xmlURIPtr
944: xmlParseURIRaw(const char *str, int raw) {
945: xmlURIPtr uri;
946: int ret;
947:
948: if (str == NULL)
949: return(NULL);
950: uri = xmlCreateURI();
951: if (uri != NULL) {
952: if (raw) {
953: uri->cleanup |= 2;
954: }
955: ret = xmlParseURIReference(uri, str);
956: if (ret) {
957: xmlFreeURI(uri);
958: return(NULL);
959: }
960: }
961: return(uri);
962: }
963:
964: /************************************************************************
965: * *
966: * Generic URI structure functions *
967: * *
968: ************************************************************************/
969:
970: /**
971: * xmlCreateURI:
972: *
973: * Simply creates an empty xmlURI
974: *
975: * Returns the new structure or NULL in case of error
976: */
977: xmlURIPtr
978: xmlCreateURI(void) {
979: xmlURIPtr ret;
980:
981: ret = (xmlURIPtr) xmlMalloc(sizeof(xmlURI));
982: if (ret == NULL) {
983: xmlGenericError(xmlGenericErrorContext,
984: "xmlCreateURI: out of memory\n");
985: return(NULL);
986: }
987: memset(ret, 0, sizeof(xmlURI));
988: return(ret);
989: }
990:
991: /**
992: * xmlSaveUri:
993: * @uri: pointer to an xmlURI
994: *
995: * Save the URI as an escaped string
996: *
997: * Returns a new string (to be deallocated by caller)
998: */
999: xmlChar *
1000: xmlSaveUri(xmlURIPtr uri) {
1001: xmlChar *ret = NULL;
1002: xmlChar *temp;
1003: const char *p;
1004: int len;
1005: int max;
1006:
1007: if (uri == NULL) return(NULL);
1008:
1009:
1010: max = 80;
1011: ret = (xmlChar *) xmlMallocAtomic((max + 1) * sizeof(xmlChar));
1012: if (ret == NULL) {
1013: xmlGenericError(xmlGenericErrorContext,
1014: "xmlSaveUri: out of memory\n");
1015: return(NULL);
1016: }
1017: len = 0;
1018:
1019: if (uri->scheme != NULL) {
1020: p = uri->scheme;
1021: while (*p != 0) {
1022: if (len >= max) {
1023: max *= 2;
1024: temp = (xmlChar *) xmlRealloc(ret, (max + 1) * sizeof(xmlChar));
1025: if (temp == NULL) {
1026: xmlGenericError(xmlGenericErrorContext,
1027: "xmlSaveUri: out of memory\n");
1028: xmlFree(ret);
1029: return(NULL);
1030: }
1031: ret = temp;
1032: }
1033: ret[len++] = *p++;
1034: }
1035: if (len >= max) {
1036: max *= 2;
1037: temp = (xmlChar *) xmlRealloc(ret, (max + 1) * sizeof(xmlChar));
1038: if (temp == NULL) {
1039: xmlGenericError(xmlGenericErrorContext,
1040: "xmlSaveUri: out of memory\n");
1041: xmlFree(ret);
1042: return(NULL);
1043: }
1044: ret = temp;
1045: }
1046: ret[len++] = ':';
1047: }
1048: if (uri->opaque != NULL) {
1049: p = uri->opaque;
1050: while (*p != 0) {
1051: if (len + 3 >= max) {
1052: max *= 2;
1053: temp = (xmlChar *) xmlRealloc(ret, (max + 1) * sizeof(xmlChar));
1054: if (temp == NULL) {
1055: xmlGenericError(xmlGenericErrorContext,
1056: "xmlSaveUri: out of memory\n");
1057: xmlFree(ret);
1058: return(NULL);
1059: }
1060: ret = temp;
1061: }
1062: if (IS_RESERVED(*(p)) || IS_UNRESERVED(*(p)))
1063: ret[len++] = *p++;
1064: else {
1065: int val = *(unsigned char *)p++;
1066: int hi = val / 0x10, lo = val % 0x10;
1067: ret[len++] = '%';
1068: ret[len++] = hi + (hi > 9? 'A'-10 : '0');
1069: ret[len++] = lo + (lo > 9? 'A'-10 : '0');
1070: }
1071: }
1072: } else {
1073: if (uri->server != NULL) {
1074: if (len + 3 >= max) {
1075: max *= 2;
1076: temp = (xmlChar *) xmlRealloc(ret, (max + 1) * sizeof(xmlChar));
1077: if (temp == NULL) {
1078: xmlGenericError(xmlGenericErrorContext,
1079: "xmlSaveUri: out of memory\n");
1080: xmlFree(ret);
1081: return(NULL);
1082: }
1083: ret = temp;
1084: }
1085: ret[len++] = '/';
1086: ret[len++] = '/';
1087: if (uri->user != NULL) {
1088: p = uri->user;
1089: while (*p != 0) {
1090: if (len + 3 >= max) {
1091: max *= 2;
1092: temp = (xmlChar *) xmlRealloc(ret,
1093: (max + 1) * sizeof(xmlChar));
1094: if (temp == NULL) {
1095: xmlGenericError(xmlGenericErrorContext,
1096: "xmlSaveUri: out of memory\n");
1097: xmlFree(ret);
1098: return(NULL);
1099: }
1100: ret = temp;
1101: }
1102: if ((IS_UNRESERVED(*(p))) ||
1103: ((*(p) == ';')) || ((*(p) == ':')) ||
1104: ((*(p) == '&')) || ((*(p) == '=')) ||
1105: ((*(p) == '+')) || ((*(p) == '$')) ||
1106: ((*(p) == ',')))
1107: ret[len++] = *p++;
1108: else {
1109: int val = *(unsigned char *)p++;
1110: int hi = val / 0x10, lo = val % 0x10;
1111: ret[len++] = '%';
1112: ret[len++] = hi + (hi > 9? 'A'-10 : '0');
1113: ret[len++] = lo + (lo > 9? 'A'-10 : '0');
1114: }
1115: }
1116: if (len + 3 >= max) {
1117: max *= 2;
1118: temp = (xmlChar *) xmlRealloc(ret,
1119: (max + 1) * sizeof(xmlChar));
1120: if (temp == NULL) {
1121: xmlGenericError(xmlGenericErrorContext,
1122: "xmlSaveUri: out of memory\n");
1123: xmlFree(ret);
1124: return(NULL);
1125: }
1126: ret = temp;
1127: }
1128: ret[len++] = '@';
1129: }
1130: p = uri->server;
1131: while (*p != 0) {
1132: if (len >= max) {
1133: max *= 2;
1134: temp = (xmlChar *) xmlRealloc(ret,
1135: (max + 1) * sizeof(xmlChar));
1136: if (temp == NULL) {
1137: xmlGenericError(xmlGenericErrorContext,
1138: "xmlSaveUri: out of memory\n");
1139: xmlFree(ret);
1140: return(NULL);
1141: }
1142: ret = temp;
1143: }
1144: ret[len++] = *p++;
1145: }
1146: if (uri->port > 0) {
1147: if (len + 10 >= max) {
1148: max *= 2;
1149: temp = (xmlChar *) xmlRealloc(ret,
1150: (max + 1) * sizeof(xmlChar));
1151: if (temp == NULL) {
1152: xmlGenericError(xmlGenericErrorContext,
1153: "xmlSaveUri: out of memory\n");
1154: xmlFree(ret);
1155: return(NULL);
1156: }
1157: ret = temp;
1158: }
1159: len += snprintf((char *) &ret[len], max - len, ":%d", uri->port);
1160: }
1161: } else if (uri->authority != NULL) {
1162: if (len + 3 >= max) {
1163: max *= 2;
1164: temp = (xmlChar *) xmlRealloc(ret,
1165: (max + 1) * sizeof(xmlChar));
1166: if (temp == NULL) {
1167: xmlGenericError(xmlGenericErrorContext,
1168: "xmlSaveUri: out of memory\n");
1169: xmlFree(ret);
1170: return(NULL);
1171: }
1172: ret = temp;
1173: }
1174: ret[len++] = '/';
1175: ret[len++] = '/';
1176: p = uri->authority;
1177: while (*p != 0) {
1178: if (len + 3 >= max) {
1179: max *= 2;
1180: temp = (xmlChar *) xmlRealloc(ret,
1181: (max + 1) * sizeof(xmlChar));
1182: if (temp == NULL) {
1183: xmlGenericError(xmlGenericErrorContext,
1184: "xmlSaveUri: out of memory\n");
1185: xmlFree(ret);
1186: return(NULL);
1187: }
1188: ret = temp;
1189: }
1190: if ((IS_UNRESERVED(*(p))) ||
1191: ((*(p) == '$')) || ((*(p) == ',')) || ((*(p) == ';')) ||
1192: ((*(p) == ':')) || ((*(p) == '@')) || ((*(p) == '&')) ||
1193: ((*(p) == '=')) || ((*(p) == '+')))
1194: ret[len++] = *p++;
1195: else {
1196: int val = *(unsigned char *)p++;
1197: int hi = val / 0x10, lo = val % 0x10;
1198: ret[len++] = '%';
1199: ret[len++] = hi + (hi > 9? 'A'-10 : '0');
1200: ret[len++] = lo + (lo > 9? 'A'-10 : '0');
1201: }
1202: }
1203: } else if (uri->scheme != NULL) {
1204: if (len + 3 >= max) {
1205: max *= 2;
1206: temp = (xmlChar *) xmlRealloc(ret,
1207: (max + 1) * sizeof(xmlChar));
1208: if (temp == NULL) {
1209: xmlGenericError(xmlGenericErrorContext,
1210: "xmlSaveUri: out of memory\n");
1211: xmlFree(ret);
1212: return(NULL);
1213: }
1214: ret = temp;
1215: }
1216: ret[len++] = '/';
1217: ret[len++] = '/';
1218: }
1219: if (uri->path != NULL) {
1220: p = uri->path;
1221: /*
1222: * the colon in file:///d: should not be escaped or
1223: * Windows accesses fail later.
1224: */
1225: if ((uri->scheme != NULL) &&
1226: (p[0] == '/') &&
1227: (((p[1] >= 'a') && (p[1] <= 'z')) ||
1228: ((p[1] >= 'A') && (p[1] <= 'Z'))) &&
1229: (p[2] == ':') &&
1230: (xmlStrEqual(BAD_CAST uri->scheme, BAD_CAST "file"))) {
1231: if (len + 3 >= max) {
1232: max *= 2;
1233: ret = (xmlChar *) xmlRealloc(ret,
1234: (max + 1) * sizeof(xmlChar));
1235: if (ret == NULL) {
1236: xmlGenericError(xmlGenericErrorContext,
1237: "xmlSaveUri: out of memory\n");
1238: return(NULL);
1239: }
1240: }
1241: ret[len++] = *p++;
1242: ret[len++] = *p++;
1243: ret[len++] = *p++;
1244: }
1245: while (*p != 0) {
1246: if (len + 3 >= max) {
1247: max *= 2;
1248: temp = (xmlChar *) xmlRealloc(ret,
1249: (max + 1) * sizeof(xmlChar));
1250: if (temp == NULL) {
1251: xmlGenericError(xmlGenericErrorContext,
1252: "xmlSaveUri: out of memory\n");
1253: xmlFree(ret);
1254: return(NULL);
1255: }
1256: ret = temp;
1257: }
1258: if ((IS_UNRESERVED(*(p))) || ((*(p) == '/')) ||
1259: ((*(p) == ';')) || ((*(p) == '@')) || ((*(p) == '&')) ||
1260: ((*(p) == '=')) || ((*(p) == '+')) || ((*(p) == '$')) ||
1261: ((*(p) == ',')))
1262: ret[len++] = *p++;
1263: else {
1264: int val = *(unsigned char *)p++;
1265: int hi = val / 0x10, lo = val % 0x10;
1266: ret[len++] = '%';
1267: ret[len++] = hi + (hi > 9? 'A'-10 : '0');
1268: ret[len++] = lo + (lo > 9? 'A'-10 : '0');
1269: }
1270: }
1271: }
1272: if (uri->query_raw != NULL) {
1273: if (len + 1 >= max) {
1274: max *= 2;
1275: temp = (xmlChar *) xmlRealloc(ret,
1276: (max + 1) * sizeof(xmlChar));
1277: if (temp == NULL) {
1278: xmlGenericError(xmlGenericErrorContext,
1279: "xmlSaveUri: out of memory\n");
1280: xmlFree(ret);
1281: return(NULL);
1282: }
1283: ret = temp;
1284: }
1285: ret[len++] = '?';
1286: p = uri->query_raw;
1287: while (*p != 0) {
1288: if (len + 1 >= max) {
1289: max *= 2;
1290: temp = (xmlChar *) xmlRealloc(ret,
1291: (max + 1) * sizeof(xmlChar));
1292: if (temp == NULL) {
1293: xmlGenericError(xmlGenericErrorContext,
1294: "xmlSaveUri: out of memory\n");
1295: xmlFree(ret);
1296: return(NULL);
1297: }
1298: ret = temp;
1299: }
1300: ret[len++] = *p++;
1301: }
1302: } else if (uri->query != NULL) {
1303: if (len + 3 >= max) {
1304: max *= 2;
1305: temp = (xmlChar *) xmlRealloc(ret,
1306: (max + 1) * sizeof(xmlChar));
1307: if (temp == NULL) {
1308: xmlGenericError(xmlGenericErrorContext,
1309: "xmlSaveUri: out of memory\n");
1310: xmlFree(ret);
1311: return(NULL);
1312: }
1313: ret = temp;
1314: }
1315: ret[len++] = '?';
1316: p = uri->query;
1317: while (*p != 0) {
1318: if (len + 3 >= max) {
1319: max *= 2;
1320: temp = (xmlChar *) xmlRealloc(ret,
1321: (max + 1) * sizeof(xmlChar));
1322: if (temp == NULL) {
1323: xmlGenericError(xmlGenericErrorContext,
1324: "xmlSaveUri: out of memory\n");
1325: xmlFree(ret);
1326: return(NULL);
1327: }
1328: ret = temp;
1329: }
1330: if ((IS_UNRESERVED(*(p))) || (IS_RESERVED(*(p))))
1331: ret[len++] = *p++;
1332: else {
1333: int val = *(unsigned char *)p++;
1334: int hi = val / 0x10, lo = val % 0x10;
1335: ret[len++] = '%';
1336: ret[len++] = hi + (hi > 9? 'A'-10 : '0');
1337: ret[len++] = lo + (lo > 9? 'A'-10 : '0');
1338: }
1339: }
1340: }
1341: }
1342: if (uri->fragment != NULL) {
1343: if (len + 3 >= max) {
1344: max *= 2;
1345: temp = (xmlChar *) xmlRealloc(ret,
1346: (max + 1) * sizeof(xmlChar));
1347: if (temp == NULL) {
1348: xmlGenericError(xmlGenericErrorContext,
1349: "xmlSaveUri: out of memory\n");
1350: xmlFree(ret);
1351: return(NULL);
1352: }
1353: ret = temp;
1354: }
1355: ret[len++] = '#';
1356: p = uri->fragment;
1357: while (*p != 0) {
1358: if (len + 3 >= max) {
1359: max *= 2;
1360: temp = (xmlChar *) xmlRealloc(ret,
1361: (max + 1) * sizeof(xmlChar));
1362: if (temp == NULL) {
1363: xmlGenericError(xmlGenericErrorContext,
1364: "xmlSaveUri: out of memory\n");
1365: xmlFree(ret);
1366: return(NULL);
1367: }
1368: ret = temp;
1369: }
1370: if ((IS_UNRESERVED(*(p))) || (IS_RESERVED(*(p))))
1371: ret[len++] = *p++;
1372: else {
1373: int val = *(unsigned char *)p++;
1374: int hi = val / 0x10, lo = val % 0x10;
1375: ret[len++] = '%';
1376: ret[len++] = hi + (hi > 9? 'A'-10 : '0');
1377: ret[len++] = lo + (lo > 9? 'A'-10 : '0');
1378: }
1379: }
1380: }
1381: if (len >= max) {
1382: max *= 2;
1383: temp = (xmlChar *) xmlRealloc(ret, (max + 1) * sizeof(xmlChar));
1384: if (temp == NULL) {
1385: xmlGenericError(xmlGenericErrorContext,
1386: "xmlSaveUri: out of memory\n");
1387: xmlFree(ret);
1388: return(NULL);
1389: }
1390: ret = temp;
1391: }
1392: ret[len] = 0;
1393: return(ret);
1394: }
1395:
1396: /**
1397: * xmlPrintURI:
1398: * @stream: a FILE* for the output
1399: * @uri: pointer to an xmlURI
1400: *
1401: * Prints the URI in the stream @stream.
1402: */
1403: void
1404: xmlPrintURI(FILE *stream, xmlURIPtr uri) {
1405: xmlChar *out;
1406:
1407: out = xmlSaveUri(uri);
1408: if (out != NULL) {
1409: fprintf(stream, "%s", (char *) out);
1410: xmlFree(out);
1411: }
1412: }
1413:
1414: /**
1415: * xmlCleanURI:
1416: * @uri: pointer to an xmlURI
1417: *
1418: * Make sure the xmlURI struct is free of content
1419: */
1420: static void
1421: xmlCleanURI(xmlURIPtr uri) {
1422: if (uri == NULL) return;
1423:
1424: if (uri->scheme != NULL) xmlFree(uri->scheme);
1425: uri->scheme = NULL;
1426: if (uri->server != NULL) xmlFree(uri->server);
1427: uri->server = NULL;
1428: if (uri->user != NULL) xmlFree(uri->user);
1429: uri->user = NULL;
1430: if (uri->path != NULL) xmlFree(uri->path);
1431: uri->path = NULL;
1432: if (uri->fragment != NULL) xmlFree(uri->fragment);
1433: uri->fragment = NULL;
1434: if (uri->opaque != NULL) xmlFree(uri->opaque);
1435: uri->opaque = NULL;
1436: if (uri->authority != NULL) xmlFree(uri->authority);
1437: uri->authority = NULL;
1438: if (uri->query != NULL) xmlFree(uri->query);
1439: uri->query = NULL;
1440: if (uri->query_raw != NULL) xmlFree(uri->query_raw);
1441: uri->query_raw = NULL;
1442: }
1443:
1444: /**
1445: * xmlFreeURI:
1446: * @uri: pointer to an xmlURI
1447: *
1448: * Free up the xmlURI struct
1449: */
1450: void
1451: xmlFreeURI(xmlURIPtr uri) {
1452: if (uri == NULL) return;
1453:
1454: if (uri->scheme != NULL) xmlFree(uri->scheme);
1455: if (uri->server != NULL) xmlFree(uri->server);
1456: if (uri->user != NULL) xmlFree(uri->user);
1457: if (uri->path != NULL) xmlFree(uri->path);
1458: if (uri->fragment != NULL) xmlFree(uri->fragment);
1459: if (uri->opaque != NULL) xmlFree(uri->opaque);
1460: if (uri->authority != NULL) xmlFree(uri->authority);
1461: if (uri->query != NULL) xmlFree(uri->query);
1462: if (uri->query_raw != NULL) xmlFree(uri->query_raw);
1463: xmlFree(uri);
1464: }
1465:
1466: /************************************************************************
1467: * *
1468: * Helper functions *
1469: * *
1470: ************************************************************************/
1471:
1472: /**
1473: * xmlNormalizeURIPath:
1474: * @path: pointer to the path string
1475: *
1476: * Applies the 5 normalization steps to a path string--that is, RFC 2396
1477: * Section 5.2, steps 6.c through 6.g.
1478: *
1479: * Normalization occurs directly on the string, no new allocation is done
1480: *
1481: * Returns 0 or an error code
1482: */
1483: int
1484: xmlNormalizeURIPath(char *path) {
1485: char *cur, *out;
1486:
1487: if (path == NULL)
1488: return(-1);
1489:
1490: /* Skip all initial "/" chars. We want to get to the beginning of the
1491: * first non-empty segment.
1492: */
1493: cur = path;
1494: while (cur[0] == '/')
1495: ++cur;
1496: if (cur[0] == '\0')
1497: return(0);
1498:
1499: /* Keep everything we've seen so far. */
1500: out = cur;
1501:
1502: /*
1503: * Analyze each segment in sequence for cases (c) and (d).
1504: */
1505: while (cur[0] != '\0') {
1506: /*
1507: * c) All occurrences of "./", where "." is a complete path segment,
1508: * are removed from the buffer string.
1509: */
1510: if ((cur[0] == '.') && (cur[1] == '/')) {
1511: cur += 2;
1512: /* '//' normalization should be done at this point too */
1513: while (cur[0] == '/')
1514: cur++;
1515: continue;
1516: }
1517:
1518: /*
1519: * d) If the buffer string ends with "." as a complete path segment,
1520: * that "." is removed.
1521: */
1522: if ((cur[0] == '.') && (cur[1] == '\0'))
1523: break;
1524:
1525: /* Otherwise keep the segment. */
1526: while (cur[0] != '/') {
1527: if (cur[0] == '\0')
1528: goto done_cd;
1529: (out++)[0] = (cur++)[0];
1530: }
1531: /* nomalize // */
1532: while ((cur[0] == '/') && (cur[1] == '/'))
1533: cur++;
1534:
1535: (out++)[0] = (cur++)[0];
1536: }
1537: done_cd:
1538: out[0] = '\0';
1539:
1540: /* Reset to the beginning of the first segment for the next sequence. */
1541: cur = path;
1542: while (cur[0] == '/')
1543: ++cur;
1544: if (cur[0] == '\0')
1545: return(0);
1546:
1547: /*
1548: * Analyze each segment in sequence for cases (e) and (f).
1549: *
1550: * e) All occurrences of "<segment>/../", where <segment> is a
1551: * complete path segment not equal to "..", are removed from the
1552: * buffer string. Removal of these path segments is performed
1553: * iteratively, removing the leftmost matching pattern on each
1554: * iteration, until no matching pattern remains.
1555: *
1556: * f) If the buffer string ends with "<segment>/..", where <segment>
1557: * is a complete path segment not equal to "..", that
1558: * "<segment>/.." is removed.
1559: *
1560: * To satisfy the "iterative" clause in (e), we need to collapse the
1561: * string every time we find something that needs to be removed. Thus,
1562: * we don't need to keep two pointers into the string: we only need a
1563: * "current position" pointer.
1564: */
1565: while (1) {
1566: char *segp, *tmp;
1567:
1568: /* At the beginning of each iteration of this loop, "cur" points to
1569: * the first character of the segment we want to examine.
1570: */
1571:
1572: /* Find the end of the current segment. */
1573: segp = cur;
1574: while ((segp[0] != '/') && (segp[0] != '\0'))
1575: ++segp;
1576:
1577: /* If this is the last segment, we're done (we need at least two
1578: * segments to meet the criteria for the (e) and (f) cases).
1579: */
1580: if (segp[0] == '\0')
1581: break;
1582:
1583: /* If the first segment is "..", or if the next segment _isn't_ "..",
1584: * keep this segment and try the next one.
1585: */
1586: ++segp;
1587: if (((cur[0] == '.') && (cur[1] == '.') && (segp == cur+3))
1588: || ((segp[0] != '.') || (segp[1] != '.')
1589: || ((segp[2] != '/') && (segp[2] != '\0')))) {
1590: cur = segp;
1591: continue;
1592: }
1593:
1594: /* If we get here, remove this segment and the next one and back up
1595: * to the previous segment (if there is one), to implement the
1596: * "iteratively" clause. It's pretty much impossible to back up
1597: * while maintaining two pointers into the buffer, so just compact
1598: * the whole buffer now.
1599: */
1600:
1601: /* If this is the end of the buffer, we're done. */
1602: if (segp[2] == '\0') {
1603: cur[0] = '\0';
1604: break;
1605: }
1606: /* Valgrind complained, strcpy(cur, segp + 3); */
1607: /* string will overlap, do not use strcpy */
1608: tmp = cur;
1609: segp += 3;
1610: while ((*tmp++ = *segp++) != 0);
1611:
1612: /* If there are no previous segments, then keep going from here. */
1613: segp = cur;
1614: while ((segp > path) && ((--segp)[0] == '/'))
1615: ;
1616: if (segp == path)
1617: continue;
1618:
1619: /* "segp" is pointing to the end of a previous segment; find it's
1620: * start. We need to back up to the previous segment and start
1621: * over with that to handle things like "foo/bar/../..". If we
1622: * don't do this, then on the first pass we'll remove the "bar/..",
1623: * but be pointing at the second ".." so we won't realize we can also
1624: * remove the "foo/..".
1625: */
1626: cur = segp;
1627: while ((cur > path) && (cur[-1] != '/'))
1628: --cur;
1629: }
1630: out[0] = '\0';
1631:
1632: /*
1633: * g) If the resulting buffer string still begins with one or more
1634: * complete path segments of "..", then the reference is
1635: * considered to be in error. Implementations may handle this
1636: * error by retaining these components in the resolved path (i.e.,
1637: * treating them as part of the final URI), by removing them from
1638: * the resolved path (i.e., discarding relative levels above the
1639: * root), or by avoiding traversal of the reference.
1640: *
1641: * We discard them from the final path.
1642: */
1643: if (path[0] == '/') {
1644: cur = path;
1645: while ((cur[0] == '/') && (cur[1] == '.') && (cur[2] == '.')
1646: && ((cur[3] == '/') || (cur[3] == '\0')))
1647: cur += 3;
1648:
1649: if (cur != path) {
1650: out = path;
1651: while (cur[0] != '\0')
1652: (out++)[0] = (cur++)[0];
1653: out[0] = 0;
1654: }
1655: }
1656:
1657: return(0);
1658: }
1659:
1660: static int is_hex(char c) {
1661: if (((c >= '0') && (c <= '9')) ||
1662: ((c >= 'a') && (c <= 'f')) ||
1663: ((c >= 'A') && (c <= 'F')))
1664: return(1);
1665: return(0);
1666: }
1667:
1668: /**
1669: * xmlURIUnescapeString:
1670: * @str: the string to unescape
1671: * @len: the length in bytes to unescape (or <= 0 to indicate full string)
1672: * @target: optional destination buffer
1673: *
1674: * Unescaping routine, but does not check that the string is an URI. The
1675: * output is a direct unsigned char translation of %XX values (no encoding)
1676: * Note that the length of the result can only be smaller or same size as
1677: * the input string.
1678: *
1679: * Returns a copy of the string, but unescaped, will return NULL only in case
1680: * of error
1681: */
1682: char *
1683: xmlURIUnescapeString(const char *str, int len, char *target) {
1684: char *ret, *out;
1685: const char *in;
1686:
1687: if (str == NULL)
1688: return(NULL);
1689: if (len <= 0) len = strlen(str);
1690: if (len < 0) return(NULL);
1691:
1692: if (target == NULL) {
1693: ret = (char *) xmlMallocAtomic(len + 1);
1694: if (ret == NULL) {
1695: xmlGenericError(xmlGenericErrorContext,
1696: "xmlURIUnescapeString: out of memory\n");
1697: return(NULL);
1698: }
1699: } else
1700: ret = target;
1701: in = str;
1702: out = ret;
1703: while(len > 0) {
1704: if ((len > 2) && (*in == '%') && (is_hex(in[1])) && (is_hex(in[2]))) {
1705: in++;
1706: if ((*in >= '0') && (*in <= '9'))
1707: *out = (*in - '0');
1708: else if ((*in >= 'a') && (*in <= 'f'))
1709: *out = (*in - 'a') + 10;
1710: else if ((*in >= 'A') && (*in <= 'F'))
1711: *out = (*in - 'A') + 10;
1712: in++;
1713: if ((*in >= '0') && (*in <= '9'))
1714: *out = *out * 16 + (*in - '0');
1715: else if ((*in >= 'a') && (*in <= 'f'))
1716: *out = *out * 16 + (*in - 'a') + 10;
1717: else if ((*in >= 'A') && (*in <= 'F'))
1718: *out = *out * 16 + (*in - 'A') + 10;
1719: in++;
1720: len -= 3;
1721: out++;
1722: } else {
1723: *out++ = *in++;
1724: len--;
1725: }
1726: }
1727: *out = 0;
1728: return(ret);
1729: }
1730:
1731: /**
1732: * xmlURIEscapeStr:
1733: * @str: string to escape
1734: * @list: exception list string of chars not to escape
1735: *
1736: * This routine escapes a string to hex, ignoring reserved characters (a-z)
1737: * and the characters in the exception list.
1738: *
1739: * Returns a new escaped string or NULL in case of error.
1740: */
1741: xmlChar *
1742: xmlURIEscapeStr(const xmlChar *str, const xmlChar *list) {
1743: xmlChar *ret, ch;
1744: xmlChar *temp;
1745: const xmlChar *in;
1746:
1747: unsigned int len, out;
1748:
1749: if (str == NULL)
1750: return(NULL);
1751: if (str[0] == 0)
1752: return(xmlStrdup(str));
1753: len = xmlStrlen(str);
1754: if (!(len > 0)) return(NULL);
1755:
1756: len += 20;
1757: ret = (xmlChar *) xmlMallocAtomic(len);
1758: if (ret == NULL) {
1759: xmlGenericError(xmlGenericErrorContext,
1760: "xmlURIEscapeStr: out of memory\n");
1761: return(NULL);
1762: }
1763: in = (const xmlChar *) str;
1764: out = 0;
1765: while(*in != 0) {
1766: if (len - out <= 3) {
1767: len += 20;
1768: temp = (xmlChar *) xmlRealloc(ret, len);
1769: if (temp == NULL) {
1770: xmlGenericError(xmlGenericErrorContext,
1771: "xmlURIEscapeStr: out of memory\n");
1772: xmlFree(ret);
1773: return(NULL);
1774: }
1775: ret = temp;
1776: }
1777:
1778: ch = *in;
1779:
1780: if ((ch != '@') && (!IS_UNRESERVED(ch)) && (!xmlStrchr(list, ch))) {
1781: unsigned char val;
1782: ret[out++] = '%';
1783: val = ch >> 4;
1784: if (val <= 9)
1785: ret[out++] = '0' + val;
1786: else
1787: ret[out++] = 'A' + val - 0xA;
1788: val = ch & 0xF;
1789: if (val <= 9)
1790: ret[out++] = '0' + val;
1791: else
1792: ret[out++] = 'A' + val - 0xA;
1793: in++;
1794: } else {
1795: ret[out++] = *in++;
1796: }
1797:
1798: }
1799: ret[out] = 0;
1800: return(ret);
1801: }
1802:
1803: /**
1804: * xmlURIEscape:
1805: * @str: the string of the URI to escape
1806: *
1807: * Escaping routine, does not do validity checks !
1808: * It will try to escape the chars needing this, but this is heuristic
1809: * based it's impossible to be sure.
1810: *
1811: * Returns an copy of the string, but escaped
1812: *
1813: * 25 May 2001
1814: * Uses xmlParseURI and xmlURIEscapeStr to try to escape correctly
1815: * according to RFC2396.
1816: * - Carl Douglas
1817: */
1818: xmlChar *
1819: xmlURIEscape(const xmlChar * str)
1820: {
1821: xmlChar *ret, *segment = NULL;
1822: xmlURIPtr uri;
1823: int ret2;
1824:
1825: #define NULLCHK(p) if(!p) { \
1826: xmlGenericError(xmlGenericErrorContext, \
1827: "xmlURIEscape: out of memory\n"); \
1828: xmlFreeURI(uri); \
1829: return NULL; } \
1830:
1831: if (str == NULL)
1832: return (NULL);
1833:
1834: uri = xmlCreateURI();
1835: if (uri != NULL) {
1836: /*
1837: * Allow escaping errors in the unescaped form
1838: */
1839: uri->cleanup = 1;
1840: ret2 = xmlParseURIReference(uri, (const char *)str);
1841: if (ret2) {
1842: xmlFreeURI(uri);
1843: return (NULL);
1844: }
1845: }
1846:
1847: if (!uri)
1848: return NULL;
1849:
1850: ret = NULL;
1851:
1852: if (uri->scheme) {
1853: segment = xmlURIEscapeStr(BAD_CAST uri->scheme, BAD_CAST "+-.");
1854: NULLCHK(segment)
1855: ret = xmlStrcat(ret, segment);
1856: ret = xmlStrcat(ret, BAD_CAST ":");
1857: xmlFree(segment);
1858: }
1859:
1860: if (uri->authority) {
1861: segment =
1862: xmlURIEscapeStr(BAD_CAST uri->authority, BAD_CAST "/?;:@");
1863: NULLCHK(segment)
1864: ret = xmlStrcat(ret, BAD_CAST "//");
1865: ret = xmlStrcat(ret, segment);
1866: xmlFree(segment);
1867: }
1868:
1869: if (uri->user) {
1870: segment = xmlURIEscapeStr(BAD_CAST uri->user, BAD_CAST ";:&=+$,");
1871: NULLCHK(segment)
1872: ret = xmlStrcat(ret,BAD_CAST "//");
1873: ret = xmlStrcat(ret, segment);
1874: ret = xmlStrcat(ret, BAD_CAST "@");
1875: xmlFree(segment);
1876: }
1877:
1878: if (uri->server) {
1879: segment = xmlURIEscapeStr(BAD_CAST uri->server, BAD_CAST "/?;:@");
1880: NULLCHK(segment)
1881: if (uri->user == NULL)
1882: ret = xmlStrcat(ret, BAD_CAST "//");
1883: ret = xmlStrcat(ret, segment);
1884: xmlFree(segment);
1885: }
1886:
1887: if (uri->port) {
1888: xmlChar port[10];
1889:
1890: snprintf((char *) port, 10, "%d", uri->port);
1891: ret = xmlStrcat(ret, BAD_CAST ":");
1892: ret = xmlStrcat(ret, port);
1893: }
1894:
1895: if (uri->path) {
1896: segment =
1897: xmlURIEscapeStr(BAD_CAST uri->path, BAD_CAST ":@&=+$,/?;");
1898: NULLCHK(segment)
1899: ret = xmlStrcat(ret, segment);
1900: xmlFree(segment);
1901: }
1902:
1903: if (uri->query_raw) {
1904: ret = xmlStrcat(ret, BAD_CAST "?");
1905: ret = xmlStrcat(ret, BAD_CAST uri->query_raw);
1906: }
1907: else if (uri->query) {
1908: segment =
1909: xmlURIEscapeStr(BAD_CAST uri->query, BAD_CAST ";/?:@&=+,$");
1910: NULLCHK(segment)
1911: ret = xmlStrcat(ret, BAD_CAST "?");
1912: ret = xmlStrcat(ret, segment);
1913: xmlFree(segment);
1914: }
1915:
1916: if (uri->opaque) {
1917: segment = xmlURIEscapeStr(BAD_CAST uri->opaque, BAD_CAST "");
1918: NULLCHK(segment)
1919: ret = xmlStrcat(ret, segment);
1920: xmlFree(segment);
1921: }
1922:
1923: if (uri->fragment) {
1924: segment = xmlURIEscapeStr(BAD_CAST uri->fragment, BAD_CAST "#");
1925: NULLCHK(segment)
1926: ret = xmlStrcat(ret, BAD_CAST "#");
1927: ret = xmlStrcat(ret, segment);
1928: xmlFree(segment);
1929: }
1930:
1931: xmlFreeURI(uri);
1932: #undef NULLCHK
1933:
1934: return (ret);
1935: }
1936:
1937: /************************************************************************
1938: * *
1939: * Public functions *
1940: * *
1941: ************************************************************************/
1942:
1943: /**
1944: * xmlBuildURI:
1945: * @URI: the URI instance found in the document
1946: * @base: the base value
1947: *
1948: * Computes he final URI of the reference done by checking that
1949: * the given URI is valid, and building the final URI using the
1950: * base URI. This is processed according to section 5.2 of the
1951: * RFC 2396
1952: *
1953: * 5.2. Resolving Relative References to Absolute Form
1954: *
1955: * Returns a new URI string (to be freed by the caller) or NULL in case
1956: * of error.
1957: */
1958: xmlChar *
1959: xmlBuildURI(const xmlChar *URI, const xmlChar *base) {
1960: xmlChar *val = NULL;
1961: int ret, len, indx, cur, out;
1962: xmlURIPtr ref = NULL;
1963: xmlURIPtr bas = NULL;
1964: xmlURIPtr res = NULL;
1965:
1966: /*
1967: * 1) The URI reference is parsed into the potential four components and
1968: * fragment identifier, as described in Section 4.3.
1969: *
1970: * NOTE that a completely empty URI is treated by modern browsers
1971: * as a reference to "." rather than as a synonym for the current
1972: * URI. Should we do that here?
1973: */
1974: if (URI == NULL)
1975: ret = -1;
1976: else {
1977: if (*URI) {
1978: ref = xmlCreateURI();
1979: if (ref == NULL)
1980: goto done;
1981: ret = xmlParseURIReference(ref, (const char *) URI);
1982: }
1983: else
1984: ret = 0;
1985: }
1986: if (ret != 0)
1987: goto done;
1988: if ((ref != NULL) && (ref->scheme != NULL)) {
1989: /*
1990: * The URI is absolute don't modify.
1991: */
1992: val = xmlStrdup(URI);
1993: goto done;
1994: }
1995: if (base == NULL)
1996: ret = -1;
1997: else {
1998: bas = xmlCreateURI();
1999: if (bas == NULL)
2000: goto done;
2001: ret = xmlParseURIReference(bas, (const char *) base);
2002: }
2003: if (ret != 0) {
2004: if (ref)
2005: val = xmlSaveUri(ref);
2006: goto done;
2007: }
2008: if (ref == NULL) {
2009: /*
2010: * the base fragment must be ignored
2011: */
2012: if (bas->fragment != NULL) {
2013: xmlFree(bas->fragment);
2014: bas->fragment = NULL;
2015: }
2016: val = xmlSaveUri(bas);
2017: goto done;
2018: }
2019:
2020: /*
2021: * 2) If the path component is empty and the scheme, authority, and
2022: * query components are undefined, then it is a reference to the
2023: * current document and we are done. Otherwise, the reference URI's
2024: * query and fragment components are defined as found (or not found)
2025: * within the URI reference and not inherited from the base URI.
2026: *
2027: * NOTE that in modern browsers, the parsing differs from the above
2028: * in the following aspect: the query component is allowed to be
2029: * defined while still treating this as a reference to the current
2030: * document.
2031: */
2032: res = xmlCreateURI();
2033: if (res == NULL)
2034: goto done;
2035: if ((ref->scheme == NULL) && (ref->path == NULL) &&
2036: ((ref->authority == NULL) && (ref->server == NULL))) {
2037: if (bas->scheme != NULL)
2038: res->scheme = xmlMemStrdup(bas->scheme);
2039: if (bas->authority != NULL)
2040: res->authority = xmlMemStrdup(bas->authority);
2041: else if (bas->server != NULL) {
2042: res->server = xmlMemStrdup(bas->server);
2043: if (bas->user != NULL)
2044: res->user = xmlMemStrdup(bas->user);
2045: res->port = bas->port;
2046: }
2047: if (bas->path != NULL)
2048: res->path = xmlMemStrdup(bas->path);
2049: if (ref->query_raw != NULL)
2050: res->query_raw = xmlMemStrdup (ref->query_raw);
2051: else if (ref->query != NULL)
2052: res->query = xmlMemStrdup(ref->query);
2053: else if (bas->query_raw != NULL)
2054: res->query_raw = xmlMemStrdup(bas->query_raw);
2055: else if (bas->query != NULL)
2056: res->query = xmlMemStrdup(bas->query);
2057: if (ref->fragment != NULL)
2058: res->fragment = xmlMemStrdup(ref->fragment);
2059: goto step_7;
2060: }
2061:
2062: /*
2063: * 3) If the scheme component is defined, indicating that the reference
2064: * starts with a scheme name, then the reference is interpreted as an
2065: * absolute URI and we are done. Otherwise, the reference URI's
2066: * scheme is inherited from the base URI's scheme component.
2067: */
2068: if (ref->scheme != NULL) {
2069: val = xmlSaveUri(ref);
2070: goto done;
2071: }
2072: if (bas->scheme != NULL)
2073: res->scheme = xmlMemStrdup(bas->scheme);
2074:
2075: if (ref->query_raw != NULL)
2076: res->query_raw = xmlMemStrdup(ref->query_raw);
2077: else if (ref->query != NULL)
2078: res->query = xmlMemStrdup(ref->query);
2079: if (ref->fragment != NULL)
2080: res->fragment = xmlMemStrdup(ref->fragment);
2081:
2082: /*
2083: * 4) If the authority component is defined, then the reference is a
2084: * network-path and we skip to step 7. Otherwise, the reference
2085: * URI's authority is inherited from the base URI's authority
2086: * component, which will also be undefined if the URI scheme does not
2087: * use an authority component.
2088: */
2089: if ((ref->authority != NULL) || (ref->server != NULL)) {
2090: if (ref->authority != NULL)
2091: res->authority = xmlMemStrdup(ref->authority);
2092: else {
2093: res->server = xmlMemStrdup(ref->server);
2094: if (ref->user != NULL)
2095: res->user = xmlMemStrdup(ref->user);
2096: res->port = ref->port;
2097: }
2098: if (ref->path != NULL)
2099: res->path = xmlMemStrdup(ref->path);
2100: goto step_7;
2101: }
2102: if (bas->authority != NULL)
2103: res->authority = xmlMemStrdup(bas->authority);
2104: else if (bas->server != NULL) {
2105: res->server = xmlMemStrdup(bas->server);
2106: if (bas->user != NULL)
2107: res->user = xmlMemStrdup(bas->user);
2108: res->port = bas->port;
2109: }
2110:
2111: /*
2112: * 5) If the path component begins with a slash character ("/"), then
2113: * the reference is an absolute-path and we skip to step 7.
2114: */
2115: if ((ref->path != NULL) && (ref->path[0] == '/')) {
2116: res->path = xmlMemStrdup(ref->path);
2117: goto step_7;
2118: }
2119:
2120:
2121: /*
2122: * 6) If this step is reached, then we are resolving a relative-path
2123: * reference. The relative path needs to be merged with the base
2124: * URI's path. Although there are many ways to do this, we will
2125: * describe a simple method using a separate string buffer.
2126: *
2127: * Allocate a buffer large enough for the result string.
2128: */
2129: len = 2; /* extra / and 0 */
2130: if (ref->path != NULL)
2131: len += strlen(ref->path);
2132: if (bas->path != NULL)
2133: len += strlen(bas->path);
2134: res->path = (char *) xmlMallocAtomic(len);
2135: if (res->path == NULL) {
2136: xmlGenericError(xmlGenericErrorContext,
2137: "xmlBuildURI: out of memory\n");
2138: goto done;
2139: }
2140: res->path[0] = 0;
2141:
2142: /*
2143: * a) All but the last segment of the base URI's path component is
2144: * copied to the buffer. In other words, any characters after the
2145: * last (right-most) slash character, if any, are excluded.
2146: */
2147: cur = 0;
2148: out = 0;
2149: if (bas->path != NULL) {
2150: while (bas->path[cur] != 0) {
2151: while ((bas->path[cur] != 0) && (bas->path[cur] != '/'))
2152: cur++;
2153: if (bas->path[cur] == 0)
2154: break;
2155:
2156: cur++;
2157: while (out < cur) {
2158: res->path[out] = bas->path[out];
2159: out++;
2160: }
2161: }
2162: }
2163: res->path[out] = 0;
2164:
2165: /*
2166: * b) The reference's path component is appended to the buffer
2167: * string.
2168: */
2169: if (ref->path != NULL && ref->path[0] != 0) {
2170: indx = 0;
2171: /*
2172: * Ensure the path includes a '/'
2173: */
2174: if ((out == 0) && (bas->server != NULL))
2175: res->path[out++] = '/';
2176: while (ref->path[indx] != 0) {
2177: res->path[out++] = ref->path[indx++];
2178: }
2179: }
2180: res->path[out] = 0;
2181:
2182: /*
2183: * Steps c) to h) are really path normalization steps
2184: */
2185: xmlNormalizeURIPath(res->path);
2186:
2187: step_7:
2188:
2189: /*
2190: * 7) The resulting URI components, including any inherited from the
2191: * base URI, are recombined to give the absolute form of the URI
2192: * reference.
2193: */
2194: val = xmlSaveUri(res);
2195:
2196: done:
2197: if (ref != NULL)
2198: xmlFreeURI(ref);
2199: if (bas != NULL)
2200: xmlFreeURI(bas);
2201: if (res != NULL)
2202: xmlFreeURI(res);
2203: return(val);
2204: }
2205:
2206: /**
2207: * xmlBuildRelativeURI:
2208: * @URI: the URI reference under consideration
2209: * @base: the base value
2210: *
2211: * Expresses the URI of the reference in terms relative to the
2212: * base. Some examples of this operation include:
2213: * base = "http://site1.com/docs/book1.html"
2214: * URI input URI returned
2215: * docs/pic1.gif pic1.gif
2216: * docs/img/pic1.gif img/pic1.gif
2217: * img/pic1.gif ../img/pic1.gif
2218: * http://site1.com/docs/pic1.gif pic1.gif
2219: * http://site2.com/docs/pic1.gif http://site2.com/docs/pic1.gif
2220: *
2221: * base = "docs/book1.html"
2222: * URI input URI returned
2223: * docs/pic1.gif pic1.gif
2224: * docs/img/pic1.gif img/pic1.gif
2225: * img/pic1.gif ../img/pic1.gif
2226: * http://site1.com/docs/pic1.gif http://site1.com/docs/pic1.gif
2227: *
2228: *
2229: * Note: if the URI reference is really wierd or complicated, it may be
2230: * worthwhile to first convert it into a "nice" one by calling
2231: * xmlBuildURI (using 'base') before calling this routine,
2232: * since this routine (for reasonable efficiency) assumes URI has
2233: * already been through some validation.
2234: *
2235: * Returns a new URI string (to be freed by the caller) or NULL in case
2236: * error.
2237: */
2238: xmlChar *
2239: xmlBuildRelativeURI (const xmlChar * URI, const xmlChar * base)
2240: {
2241: xmlChar *val = NULL;
2242: int ret;
2243: int ix;
2244: int pos = 0;
2245: int nbslash = 0;
2246: int len;
2247: xmlURIPtr ref = NULL;
2248: xmlURIPtr bas = NULL;
2249: xmlChar *bptr, *uptr, *vptr;
2250: int remove_path = 0;
2251:
2252: if ((URI == NULL) || (*URI == 0))
2253: return NULL;
2254:
2255: /*
2256: * First parse URI into a standard form
2257: */
2258: ref = xmlCreateURI ();
2259: if (ref == NULL)
2260: return NULL;
2261: /* If URI not already in "relative" form */
2262: if (URI[0] != '.') {
2263: ret = xmlParseURIReference (ref, (const char *) URI);
2264: if (ret != 0)
2265: goto done; /* Error in URI, return NULL */
2266: } else
2267: ref->path = (char *)xmlStrdup(URI);
2268:
2269: /*
2270: * Next parse base into the same standard form
2271: */
2272: if ((base == NULL) || (*base == 0)) {
2273: val = xmlStrdup (URI);
2274: goto done;
2275: }
2276: bas = xmlCreateURI ();
2277: if (bas == NULL)
2278: goto done;
2279: if (base[0] != '.') {
2280: ret = xmlParseURIReference (bas, (const char *) base);
2281: if (ret != 0)
2282: goto done; /* Error in base, return NULL */
2283: } else
2284: bas->path = (char *)xmlStrdup(base);
2285:
2286: /*
2287: * If the scheme / server on the URI differs from the base,
2288: * just return the URI
2289: */
2290: if ((ref->scheme != NULL) &&
2291: ((bas->scheme == NULL) ||
2292: (xmlStrcmp ((xmlChar *)bas->scheme, (xmlChar *)ref->scheme)) ||
2293: (xmlStrcmp ((xmlChar *)bas->server, (xmlChar *)ref->server)))) {
2294: val = xmlStrdup (URI);
2295: goto done;
2296: }
2297: if (xmlStrEqual((xmlChar *)bas->path, (xmlChar *)ref->path)) {
2298: val = xmlStrdup(BAD_CAST "");
2299: goto done;
2300: }
2301: if (bas->path == NULL) {
2302: val = xmlStrdup((xmlChar *)ref->path);
2303: goto done;
2304: }
2305: if (ref->path == NULL) {
2306: ref->path = (char *) "/";
2307: remove_path = 1;
2308: }
2309:
2310: /*
2311: * At this point (at last!) we can compare the two paths
2312: *
2313: * First we take care of the special case where either of the
2314: * two path components may be missing (bug 316224)
2315: */
2316: if (bas->path == NULL) {
2317: if (ref->path != NULL) {
2318: uptr = (xmlChar *) ref->path;
2319: if (*uptr == '/')
2320: uptr++;
2321: /* exception characters from xmlSaveUri */
2322: val = xmlURIEscapeStr(uptr, BAD_CAST "/;&=+$,");
2323: }
2324: goto done;
2325: }
2326: bptr = (xmlChar *)bas->path;
2327: if (ref->path == NULL) {
2328: for (ix = 0; bptr[ix] != 0; ix++) {
2329: if (bptr[ix] == '/')
2330: nbslash++;
2331: }
2332: uptr = NULL;
2333: len = 1; /* this is for a string terminator only */
2334: } else {
2335: /*
2336: * Next we compare the two strings and find where they first differ
2337: */
2338: if ((ref->path[pos] == '.') && (ref->path[pos+1] == '/'))
2339: pos += 2;
2340: if ((*bptr == '.') && (bptr[1] == '/'))
2341: bptr += 2;
2342: else if ((*bptr == '/') && (ref->path[pos] != '/'))
2343: bptr++;
2344: while ((bptr[pos] == ref->path[pos]) && (bptr[pos] != 0))
2345: pos++;
2346:
2347: if (bptr[pos] == ref->path[pos]) {
2348: val = xmlStrdup(BAD_CAST "");
2349: goto done; /* (I can't imagine why anyone would do this) */
2350: }
2351:
2352: /*
2353: * In URI, "back up" to the last '/' encountered. This will be the
2354: * beginning of the "unique" suffix of URI
2355: */
2356: ix = pos;
2357: if ((ref->path[ix] == '/') && (ix > 0))
2358: ix--;
2359: else if ((ref->path[ix] == 0) && (ix > 1) && (ref->path[ix - 1] == '/'))
2360: ix -= 2;
2361: for (; ix > 0; ix--) {
2362: if (ref->path[ix] == '/')
2363: break;
2364: }
2365: if (ix == 0) {
2366: uptr = (xmlChar *)ref->path;
2367: } else {
2368: ix++;
2369: uptr = (xmlChar *)&ref->path[ix];
2370: }
2371:
2372: /*
2373: * In base, count the number of '/' from the differing point
2374: */
2375: if (bptr[pos] != ref->path[pos]) {/* check for trivial URI == base */
2376: for (; bptr[ix] != 0; ix++) {
2377: if (bptr[ix] == '/')
2378: nbslash++;
2379: }
2380: }
2381: len = xmlStrlen (uptr) + 1;
2382: }
2383:
2384: if (nbslash == 0) {
2385: if (uptr != NULL)
2386: /* exception characters from xmlSaveUri */
2387: val = xmlURIEscapeStr(uptr, BAD_CAST "/;&=+$,");
2388: goto done;
2389: }
2390:
2391: /*
2392: * Allocate just enough space for the returned string -
2393: * length of the remainder of the URI, plus enough space
2394: * for the "../" groups, plus one for the terminator
2395: */
2396: val = (xmlChar *) xmlMalloc (len + 3 * nbslash);
2397: if (val == NULL) {
2398: xmlGenericError(xmlGenericErrorContext,
2399: "xmlBuildRelativeURI: out of memory\n");
2400: goto done;
2401: }
2402: vptr = val;
2403: /*
2404: * Put in as many "../" as needed
2405: */
2406: for (; nbslash>0; nbslash--) {
2407: *vptr++ = '.';
2408: *vptr++ = '.';
2409: *vptr++ = '/';
2410: }
2411: /*
2412: * Finish up with the end of the URI
2413: */
2414: if (uptr != NULL) {
2415: if ((vptr > val) && (len > 0) &&
2416: (uptr[0] == '/') && (vptr[-1] == '/')) {
2417: memcpy (vptr, uptr + 1, len - 1);
2418: vptr[len - 2] = 0;
2419: } else {
2420: memcpy (vptr, uptr, len);
2421: vptr[len - 1] = 0;
2422: }
2423: } else {
2424: vptr[len - 1] = 0;
2425: }
2426:
2427: /* escape the freshly-built path */
2428: vptr = val;
2429: /* exception characters from xmlSaveUri */
2430: val = xmlURIEscapeStr(vptr, BAD_CAST "/;&=+$,");
2431: xmlFree(vptr);
2432:
2433: done:
2434: /*
2435: * Free the working variables
2436: */
2437: if (remove_path != 0)
2438: ref->path = NULL;
2439: if (ref != NULL)
2440: xmlFreeURI (ref);
2441: if (bas != NULL)
2442: xmlFreeURI (bas);
2443:
2444: return val;
2445: }
2446:
2447: /**
2448: * xmlCanonicPath:
2449: * @path: the resource locator in a filesystem notation
2450: *
2451: * Constructs a canonic path from the specified path.
2452: *
2453: * Returns a new canonic path, or a duplicate of the path parameter if the
2454: * construction fails. The caller is responsible for freeing the memory occupied
2455: * by the returned string. If there is insufficient memory available, or the
2456: * argument is NULL, the function returns NULL.
2457: */
2458: #define IS_WINDOWS_PATH(p) \
2459: ((p != NULL) && \
2460: (((p[0] >= 'a') && (p[0] <= 'z')) || \
2461: ((p[0] >= 'A') && (p[0] <= 'Z'))) && \
2462: (p[1] == ':') && ((p[2] == '/') || (p[2] == '\\')))
2463: xmlChar *
2464: xmlCanonicPath(const xmlChar *path)
2465: {
2466: /*
2467: * For Windows implementations, additional work needs to be done to
2468: * replace backslashes in pathnames with "forward slashes"
2469: */
2470: #if defined(_WIN32) && !defined(__CYGWIN__)
2471: int len = 0;
2472: int i = 0;
2473: xmlChar *p = NULL;
2474: #endif
2475: xmlURIPtr uri;
2476: xmlChar *ret;
2477: const xmlChar *absuri;
2478:
2479: if (path == NULL)
2480: return(NULL);
2481:
2482: /* sanitize filename starting with // so it can be used as URI */
2483: if ((path[0] == '/') && (path[1] == '/') && (path[2] != '/'))
2484: path++;
2485:
2486: if ((uri = xmlParseURI((const char *) path)) != NULL) {
2487: xmlFreeURI(uri);
2488: return xmlStrdup(path);
2489: }
2490:
2491: /* Check if this is an "absolute uri" */
2492: absuri = xmlStrstr(path, BAD_CAST "://");
2493: if (absuri != NULL) {
2494: int l, j;
2495: unsigned char c;
2496: xmlChar *escURI;
2497:
2498: /*
2499: * this looks like an URI where some parts have not been
2500: * escaped leading to a parsing problem. Check that the first
2501: * part matches a protocol.
2502: */
2503: l = absuri - path;
2504: /* Bypass if first part (part before the '://') is > 20 chars */
2505: if ((l <= 0) || (l > 20))
2506: goto path_processing;
2507: /* Bypass if any non-alpha characters are present in first part */
2508: for (j = 0;j < l;j++) {
2509: c = path[j];
2510: if (!(((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z'))))
2511: goto path_processing;
2512: }
2513:
2514: /* Escape all except the characters specified in the supplied path */
2515: escURI = xmlURIEscapeStr(path, BAD_CAST ":/?_.#&;=");
2516: if (escURI != NULL) {
2517: /* Try parsing the escaped path */
2518: uri = xmlParseURI((const char *) escURI);
2519: /* If successful, return the escaped string */
2520: if (uri != NULL) {
2521: xmlFreeURI(uri);
2522: return escURI;
2523: }
2524: }
2525: }
2526:
2527: path_processing:
2528: /* For Windows implementations, replace backslashes with 'forward slashes' */
2529: #if defined(_WIN32) && !defined(__CYGWIN__)
2530: /*
2531: * Create a URI structure
2532: */
2533: uri = xmlCreateURI();
2534: if (uri == NULL) { /* Guard against 'out of memory' */
2535: return(NULL);
2536: }
2537:
2538: len = xmlStrlen(path);
2539: if ((len > 2) && IS_WINDOWS_PATH(path)) {
2540: /* make the scheme 'file' */
2541: uri->scheme = xmlStrdup(BAD_CAST "file");
2542: /* allocate space for leading '/' + path + string terminator */
2543: uri->path = xmlMallocAtomic(len + 2);
2544: if (uri->path == NULL) {
2545: xmlFreeURI(uri); /* Guard agains 'out of memory' */
2546: return(NULL);
2547: }
2548: /* Put in leading '/' plus path */
2549: uri->path[0] = '/';
2550: p = uri->path + 1;
2551: strncpy(p, path, len + 1);
2552: } else {
2553: uri->path = xmlStrdup(path);
2554: if (uri->path == NULL) {
2555: xmlFreeURI(uri);
2556: return(NULL);
2557: }
2558: p = uri->path;
2559: }
2560: /* Now change all occurences of '\' to '/' */
2561: while (*p != '\0') {
2562: if (*p == '\\')
2563: *p = '/';
2564: p++;
2565: }
2566:
2567: if (uri->scheme == NULL) {
2568: ret = xmlStrdup((const xmlChar *) uri->path);
2569: } else {
2570: ret = xmlSaveUri(uri);
2571: }
2572:
2573: xmlFreeURI(uri);
2574: #else
2575: ret = xmlStrdup((const xmlChar *) path);
2576: #endif
2577: return(ret);
2578: }
2579:
2580: /**
2581: * xmlPathToURI:
2582: * @path: the resource locator in a filesystem notation
2583: *
2584: * Constructs an URI expressing the existing path
2585: *
2586: * Returns a new URI, or a duplicate of the path parameter if the
2587: * construction fails. The caller is responsible for freeing the memory
2588: * occupied by the returned string. If there is insufficient memory available,
2589: * or the argument is NULL, the function returns NULL.
2590: */
2591: xmlChar *
2592: xmlPathToURI(const xmlChar *path)
2593: {
2594: xmlURIPtr uri;
2595: xmlURI temp;
2596: xmlChar *ret, *cal;
2597:
2598: if (path == NULL)
2599: return(NULL);
2600:
2601: if ((uri = xmlParseURI((const char *) path)) != NULL) {
2602: xmlFreeURI(uri);
2603: return xmlStrdup(path);
2604: }
2605: cal = xmlCanonicPath(path);
2606: if (cal == NULL)
2607: return(NULL);
2608: #if defined(_WIN32) && !defined(__CYGWIN__)
2609: /* xmlCanonicPath can return an URI on Windows (is that the intended behaviour?)
2610: If 'cal' is a valid URI allready then we are done here, as continuing would make
2611: it invalid. */
2612: if ((uri = xmlParseURI((const char *) cal)) != NULL) {
2613: xmlFreeURI(uri);
2614: return cal;
2615: }
2616: /* 'cal' can contain a relative path with backslashes. If that is processed
2617: by xmlSaveURI, they will be escaped and the external entity loader machinery
2618: will fail. So convert them to slashes. Misuse 'ret' for walking. */
2619: ret = cal;
2620: while (*ret != '\0') {
2621: if (*ret == '\\')
2622: *ret = '/';
2623: ret++;
2624: }
2625: #endif
2626: memset(&temp, 0, sizeof(temp));
2627: temp.path = (char *) cal;
2628: ret = xmlSaveUri(&temp);
2629: xmlFree(cal);
2630: return(ret);
2631: }
2632: #define bottom_uri
2633: #include "elfgcchack.h"
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to uri.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2