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