?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Try to work around that clang/win bug in another file.
[chromium-blink-merge.git] / third_party / libxml / src / uri.c
blobff47abbecb1d0fc0f4161d3596e2840a6970ffaa
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 if (uri->server == NULL)
763 uri->port = -1;
764 ret = xmlParse3986PathAbEmpty(uri, &cur);
765 if (ret != 0) return(ret);
766 *str = cur;
767 return(0);
768 } else if (*cur == '/') {
769 ret = xmlParse3986PathAbsolute(uri, &cur);
770 if (ret != 0) return(ret);
771 } else if (ISA_PCHAR(cur)) {
772 ret = xmlParse3986PathRootless(uri, &cur);
773 if (ret != 0) return(ret);
774 } else {
775 /* path-empty is effectively empty */
776 if (uri != NULL) {
777 if (uri->path != NULL) xmlFree(uri->path);
778 uri->path = NULL;
779 }
780 }
781 *str = cur;
782 return (0);
783 }
784
785 /**
786 * xmlParse3986RelativeRef:
787 * @uri: pointer to an URI structure
788 * @str: the string to analyze
789 *
790 * Parse an URI string and fills in the appropriate fields
791 * of the @uri structure
792 *
793 * relative-ref = relative-part [ "?" query ] [ "#" fragment ]
794 * relative-part = "//" authority path-abempty
795 * / path-absolute
796 * / path-noscheme
797 * / path-empty
798 *
799 * Returns 0 or the error code
800 */
801 static int
802 xmlParse3986RelativeRef(xmlURIPtr uri, const char *str) {
803 int ret;
804
805 if ((*str == '/') && (*(str + 1) == '/')) {
806 str += 2;
807 ret = xmlParse3986Authority(uri, &str);
808 if (ret != 0) return(ret);
809 ret = xmlParse3986PathAbEmpty(uri, &str);
810 if (ret != 0) return(ret);
811 } else if (*str == '/') {
812 ret = xmlParse3986PathAbsolute(uri, &str);
813 if (ret != 0) return(ret);
814 } else if (ISA_PCHAR(str)) {
815 ret = xmlParse3986PathNoScheme(uri, &str);
816 if (ret != 0) return(ret);
817 } else {
818 /* path-empty is effectively empty */
819 if (uri != NULL) {
820 if (uri->path != NULL) xmlFree(uri->path);
821 uri->path = NULL;
822 }
823 }
824
825 if (*str == '?') {
826 str++;
827 ret = xmlParse3986Query(uri, &str);
828 if (ret != 0) return(ret);
829 }
830 if (*str == '#') {
831 str++;
832 ret = xmlParse3986Fragment(uri, &str);
833 if (ret != 0) return(ret);
834 }
835 if (*str != 0) {
836 xmlCleanURI(uri);
837 return(1);
838 }
839 return(0);
840 }
841
842
843 /**
844 * xmlParse3986URI:
845 * @uri: pointer to an URI structure
846 * @str: the string to analyze
847 *
848 * Parse an URI string and fills in the appropriate fields
849 * of the @uri structure
850 *
851 * scheme ":" hier-part [ "?" query ] [ "#" fragment ]
852 *
853 * Returns 0 or the error code
854 */
855 static int
856 xmlParse3986URI(xmlURIPtr uri, const char *str) {
857 int ret;
858
859 ret = xmlParse3986Scheme(uri, &str);
860 if (ret != 0) return(ret);
861 if (*str != ':') {
862 return(1);
863 }
864 str++;
865 ret = xmlParse3986HierPart(uri, &str);
866 if (ret != 0) return(ret);
867 if (*str == '?') {
868 str++;
869 ret = xmlParse3986Query(uri, &str);
870 if (ret != 0) return(ret);
871 }
872 if (*str == '#') {
873 str++;
874 ret = xmlParse3986Fragment(uri, &str);
875 if (ret != 0) return(ret);
876 }
877 if (*str != 0) {
878 xmlCleanURI(uri);
879 return(1);
880 }
881 return(0);
882 }
883
884 /**
885 * xmlParse3986URIReference:
886 * @uri: pointer to an URI structure
887 * @str: the string to analyze
888 *
889 * Parse an URI reference string and fills in the appropriate fields
890 * of the @uri structure
891 *
892 * URI-reference = URI / relative-ref
893 *
894 * Returns 0 or the error code
895 */
896 static int
897 xmlParse3986URIReference(xmlURIPtr uri, const char *str) {
898 int ret;
899
900 if (str == NULL)
901 return(-1);
902 xmlCleanURI(uri);
903
904 /*
905 * Try first to parse absolute refs, then fallback to relative if
906 * it fails.
907 */
908 ret = xmlParse3986URI(uri, str);
909 if (ret != 0) {
910 xmlCleanURI(uri);
911 ret = xmlParse3986RelativeRef(uri, str);
912 if (ret != 0) {
913 xmlCleanURI(uri);
914 return(ret);
915 }
916 }
917 return(0);
918 }
919
920 /**
921 * xmlParseURI:
922 * @str: the URI string to analyze
923 *
924 * Parse an URI based on RFC 3986
925 *
926 * URI-reference = [ absoluteURI | relativeURI ] [ "#" fragment ]
927 *
928 * Returns a newly built xmlURIPtr or NULL in case of error
929 */
930 xmlURIPtr
931 xmlParseURI(const char *str) {
932 xmlURIPtr uri;
933 int ret;
934
935 if (str == NULL)
936 return(NULL);
937 uri = xmlCreateURI();
938 if (uri != NULL) {
939 ret = xmlParse3986URIReference(uri, str);
940 if (ret) {
941 xmlFreeURI(uri);
942 return(NULL);
943 }
944 }
945 return(uri);
946 }
947
948 /**
949 * xmlParseURIReference:
950 * @uri: pointer to an URI structure
951 * @str: the string to analyze
952 *
953 * Parse an URI reference string based on RFC 3986 and fills in the
954 * appropriate fields of the @uri structure
955 *
956 * URI-reference = URI / relative-ref
957 *
958 * Returns 0 or the error code
959 */
960 int
961 xmlParseURIReference(xmlURIPtr uri, const char *str) {
962 return(xmlParse3986URIReference(uri, str));
963 }
964
965 /**
966 * xmlParseURIRaw:
967 * @str: the URI string to analyze
968 * @raw: if 1 unescaping of URI pieces are disabled
969 *
970 * Parse an URI but allows to keep intact the original fragments.
971 *
972 * URI-reference = URI / relative-ref
973 *
974 * Returns a newly built xmlURIPtr or NULL in case of error
975 */
976 xmlURIPtr
977 xmlParseURIRaw(const char *str, int raw) {
978 xmlURIPtr uri;
979 int ret;
980
981 if (str == NULL)
982 return(NULL);
983 uri = xmlCreateURI();
984 if (uri != NULL) {
985 if (raw) {
986 uri->cleanup |= 2;
987 }
988 ret = xmlParseURIReference(uri, str);
989 if (ret) {
990 xmlFreeURI(uri);
991 return(NULL);
992 }
993 }
994 return(uri);
995 }
996
997 /************************************************************************
998 * *
999 * Generic URI structure functions *
1000 * *
1001 ************************************************************************/
1002
1003 /**
1004 * xmlCreateURI:
1005 *
1006 * Simply creates an empty xmlURI
1007 *
1008 * Returns the new structure or NULL in case of error
1009 */
1010 xmlURIPtr
1011 xmlCreateURI(void) {
1012 xmlURIPtr ret;
1013
1014 ret = (xmlURIPtr) xmlMalloc(sizeof(xmlURI));
1015 if (ret == NULL) {
1016 xmlURIErrMemory("creating URI structure\n");
1017 return(NULL);
1018 }
1019 memset(ret, 0, sizeof(xmlURI));
1020 return(ret);
1021 }
1022
1023 /**
1024 * xmlSaveUriRealloc:
1025 *
1026 * Function to handle properly a reallocation when saving an URI
1027 * Also imposes some limit on the length of an URI string output
1028 */
1029 static xmlChar *
1030 xmlSaveUriRealloc(xmlChar *ret, int *max) {
1031 xmlChar *temp;
1032 int tmp;
1033
1034 if (*max > MAX_URI_LENGTH) {
1035 xmlURIErrMemory("reaching arbitrary MAX_URI_LENGTH limit\n");
1036 return(NULL);
1037 }
1038 tmp = *max * 2;
1039 temp = (xmlChar *) xmlRealloc(ret, (tmp + 1));
1040 if (temp == NULL) {
1041 xmlURIErrMemory("saving URI\n");
1042 return(NULL);
1043 }
1044 *max = tmp;
1045 return(temp);
1046 }
1047
1048 /**
1049 * xmlSaveUri:
1050 * @uri: pointer to an xmlURI
1051 *
1052 * Save the URI as an escaped string
1053 *
1054 * Returns a new string (to be deallocated by caller)
1055 */
1056 xmlChar *
1057 xmlSaveUri(xmlURIPtr uri) {
1058 xmlChar *ret = NULL;
1059 xmlChar *temp;
1060 const char *p;
1061 int len;
1062 int max;
1063
1064 if (uri == NULL) return(NULL);
1065
1066
1067 max = 80;
1068 ret = (xmlChar *) xmlMallocAtomic((max + 1) * sizeof(xmlChar));
1069 if (ret == NULL) {
1070 xmlURIErrMemory("saving URI\n");
1071 return(NULL);
1072 }
1073 len = 0;
1074
1075 if (uri->scheme != NULL) {
1076 p = uri->scheme;
1077 while (*p != 0) {
1078 if (len >= max) {
1079 temp = xmlSaveUriRealloc(ret, &max);
1080 if (temp == NULL) goto mem_error;
1081 ret = temp;
1082 }
1083 ret[len++] = *p++;
1084 }
1085 if (len >= max) {
1086 temp = xmlSaveUriRealloc(ret, &max);
1087 if (temp == NULL) goto mem_error;
1088 ret = temp;
1089 }
1090 ret[len++] = ':';
1091 }
1092 if (uri->opaque != NULL) {
1093 p = uri->opaque;
1094 while (*p != 0) {
1095 if (len + 3 >= max) {
1096 temp = xmlSaveUriRealloc(ret, &max);
1097 if (temp == NULL) goto mem_error;
1098 ret = temp;
1099 }
1100 if (IS_RESERVED(*(p)) || IS_UNRESERVED(*(p)))
1101 ret[len++] = *p++;
1102 else {
1103 int val = *(unsigned char *)p++;
1104 int hi = val / 0x10, lo = val % 0x10;
1105 ret[len++] = '%';
1106 ret[len++] = hi + (hi > 9? 'A'-10 : '0');
1107 ret[len++] = lo + (lo > 9? 'A'-10 : '0');
1108 }
1109 }
1110 } else {
1111 if ((uri->server != NULL) || (uri->port == -1)) {
1112 if (len + 3 >= max) {
1113 temp = xmlSaveUriRealloc(ret, &max);
1114 if (temp == NULL) goto mem_error;
1115 ret = temp;
1116 }
1117 ret[len++] = '/';
1118 ret[len++] = '/';
1119 if (uri->user != NULL) {
1120 p = uri->user;
1121 while (*p != 0) {
1122 if (len + 3 >= max) {
1123 temp = xmlSaveUriRealloc(ret, &max);
1124 if (temp == NULL) goto mem_error;
1125 ret = temp;
1126 }
1127 if ((IS_UNRESERVED(*(p))) ||
1128 ((*(p) == ';')) || ((*(p) == ':')) ||
1129 ((*(p) == '&')) || ((*(p) == '=')) ||
1130 ((*(p) == '+')) || ((*(p) == '$')) ||
1131 ((*(p) == ',')))
1132 ret[len++] = *p++;
1133 else {
1134 int val = *(unsigned char *)p++;
1135 int hi = val / 0x10, lo = val % 0x10;
1136 ret[len++] = '%';
1137 ret[len++] = hi + (hi > 9? 'A'-10 : '0');
1138 ret[len++] = lo + (lo > 9? 'A'-10 : '0');
1139 }
1140 }
1141 if (len + 3 >= max) {
1142 temp = xmlSaveUriRealloc(ret, &max);
1143 if (temp == NULL) goto mem_error;
1144 ret = temp;
1145 }
1146 ret[len++] = '@';
1147 }
1148 if (uri->server != NULL) {
1149 p = uri->server;
1150 while (*p != 0) {
1151 if (len >= max) {
1152 temp = xmlSaveUriRealloc(ret, &max);
1153 if (temp == NULL) goto mem_error;
1154 ret = temp;
1155 }
1156 ret[len++] = *p++;
1157 }
1158 if (uri->port > 0) {
1159 if (len + 10 >= max) {
1160 temp = xmlSaveUriRealloc(ret, &max);
1161 if (temp == NULL) goto mem_error;
1162 ret = temp;
1163 }
1164 len += snprintf((char *) &ret[len], max - len, ":%d", uri->port);
1165 }
1166 }
1167 } else if (uri->authority != NULL) {
1168 if (len + 3 >= max) {
1169 temp = xmlSaveUriRealloc(ret, &max);
1170 if (temp == NULL) goto mem_error;
1171 ret = temp;
1172 }
1173 ret[len++] = '/';
1174 ret[len++] = '/';
1175 p = uri->authority;
1176 while (*p != 0) {
1177 if (len + 3 >= max) {
1178 temp = xmlSaveUriRealloc(ret, &max);
1179 if (temp == NULL) goto mem_error;
1180 ret = temp;
1181 }
1182 if ((IS_UNRESERVED(*(p))) ||
1183 ((*(p) == '$')) || ((*(p) == ',')) || ((*(p) == ';')) ||
1184 ((*(p) == ':')) || ((*(p) == '@')) || ((*(p) == '&')) ||
1185 ((*(p) == '=')) || ((*(p) == '+')))
1186 ret[len++] = *p++;
1187 else {
1188 int val = *(unsigned char *)p++;
1189 int hi = val / 0x10, lo = val % 0x10;
1190 ret[len++] = '%';
1191 ret[len++] = hi + (hi > 9? 'A'-10 : '0');
1192 ret[len++] = lo + (lo > 9? 'A'-10 : '0');
1193 }
1194 }
1195 } else if (uri->scheme != NULL) {
1196 if (len + 3 >= max) {
1197 temp = xmlSaveUriRealloc(ret, &max);
1198 if (temp == NULL) goto mem_error;
1199 ret = temp;
1200 }
1201 }
1202 if (uri->path != NULL) {
1203 p = uri->path;
1204 /*
1205 * the colon in file:///d: should not be escaped or
1206 * Windows accesses fail later.
1207 */
1208 if ((uri->scheme != NULL) &&
1209 (p[0] == '/') &&
1210 (((p[1] >= 'a') && (p[1] <= 'z')) ||
1211 ((p[1] >= 'A') && (p[1] <= 'Z'))) &&
1212 (p[2] == ':') &&
1213 (xmlStrEqual(BAD_CAST uri->scheme, BAD_CAST "file"))) {
1214 if (len + 3 >= max) {
1215 temp = xmlSaveUriRealloc(ret, &max);
1216 if (temp == NULL) goto mem_error;
1217 ret = temp;
1218 }
1219 ret[len++] = *p++;
1220 ret[len++] = *p++;
1221 ret[len++] = *p++;
1222 }
1223 while (*p != 0) {
1224 if (len + 3 >= max) {
1225 temp = xmlSaveUriRealloc(ret, &max);
1226 if (temp == NULL) goto mem_error;
1227 ret = temp;
1228 }
1229 if ((IS_UNRESERVED(*(p))) || ((*(p) == '/')) ||
1230 ((*(p) == ';')) || ((*(p) == '@')) || ((*(p) == '&')) ||
1231 ((*(p) == '=')) || ((*(p) == '+')) || ((*(p) == '$')) ||
1232 ((*(p) == ',')))
1233 ret[len++] = *p++;
1234 else {
1235 int val = *(unsigned char *)p++;
1236 int hi = val / 0x10, lo = val % 0x10;
1237 ret[len++] = '%';
1238 ret[len++] = hi + (hi > 9? 'A'-10 : '0');
1239 ret[len++] = lo + (lo > 9? 'A'-10 : '0');
1240 }
1241 }
1242 }
1243 if (uri->query_raw != NULL) {
1244 if (len + 1 >= max) {
1245 temp = xmlSaveUriRealloc(ret, &max);
1246 if (temp == NULL) goto mem_error;
1247 ret = temp;
1248 }
1249 ret[len++] = '?';
1250 p = uri->query_raw;
1251 while (*p != 0) {
1252 if (len + 1 >= max) {
1253 temp = xmlSaveUriRealloc(ret, &max);
1254 if (temp == NULL) goto mem_error;
1255 ret = temp;
1256 }
1257 ret[len++] = *p++;
1258 }
1259 } else if (uri->query != NULL) {
1260 if (len + 3 >= max) {
1261 temp = xmlSaveUriRealloc(ret, &max);
1262 if (temp == NULL) goto mem_error;
1263 ret = temp;
1264 }
1265 ret[len++] = '?';
1266 p = uri->query;
1267 while (*p != 0) {
1268 if (len + 3 >= max) {
1269 temp = xmlSaveUriRealloc(ret, &max);
1270 if (temp == NULL) goto mem_error;
1271 ret = temp;
1272 }
1273 if ((IS_UNRESERVED(*(p))) || (IS_RESERVED(*(p))))
1274 ret[len++] = *p++;
1275 else {
1276 int val = *(unsigned char *)p++;
1277 int hi = val / 0x10, lo = val % 0x10;
1278 ret[len++] = '%';
1279 ret[len++] = hi + (hi > 9? 'A'-10 : '0');
1280 ret[len++] = lo + (lo > 9? 'A'-10 : '0');
1281 }
1282 }
1283 }
1284 }
1285 if (uri->fragment != NULL) {
1286 if (len + 3 >= max) {
1287 temp = xmlSaveUriRealloc(ret, &max);
1288 if (temp == NULL) goto mem_error;
1289 ret = temp;
1290 }
1291 ret[len++] = '#';
1292 p = uri->fragment;
1293 while (*p != 0) {
1294 if (len + 3 >= max) {
1295 temp = xmlSaveUriRealloc(ret, &max);
1296 if (temp == NULL) goto mem_error;
1297 ret = temp;
1298 }
1299 if ((IS_UNRESERVED(*(p))) || (IS_RESERVED(*(p))))
1300 ret[len++] = *p++;
1301 else {
1302 int val = *(unsigned char *)p++;
1303 int hi = val / 0x10, lo = val % 0x10;
1304 ret[len++] = '%';
1305 ret[len++] = hi + (hi > 9? 'A'-10 : '0');
1306 ret[len++] = lo + (lo > 9? 'A'-10 : '0');
1307 }
1308 }
1309 }
1310 if (len >= max) {
1311 temp = xmlSaveUriRealloc(ret, &max);
1312 if (temp == NULL) goto mem_error;
1313 ret = temp;
1314 }
1315 ret[len] = 0;
1316 return(ret);
1317
1318 mem_error:
1319 xmlFree(ret);
1320 return(NULL);
1321 }
1322
1323 /**
1324 * xmlPrintURI:
1325 * @stream: a FILE* for the output
1326 * @uri: pointer to an xmlURI
1327 *
1328 * Prints the URI in the stream @stream.
1329 */
1330 void
1331 xmlPrintURI(FILE *stream, xmlURIPtr uri) {
1332 xmlChar *out;
1333
1334 out = xmlSaveUri(uri);
1335 if (out != NULL) {
1336 fprintf(stream, "%s", (char *) out);
1337 xmlFree(out);
1338 }
1339 }
1340
1341 /**
1342 * xmlCleanURI:
1343 * @uri: pointer to an xmlURI
1344 *
1345 * Make sure the xmlURI struct is free of content
1346 */
1347 static void
1348 xmlCleanURI(xmlURIPtr uri) {
1349 if (uri == NULL) return;
1350
1351 if (uri->scheme != NULL) xmlFree(uri->scheme);
1352 uri->scheme = NULL;
1353 if (uri->server != NULL) xmlFree(uri->server);
1354 uri->server = NULL;
1355 if (uri->user != NULL) xmlFree(uri->user);
1356 uri->user = NULL;
1357 if (uri->path != NULL) xmlFree(uri->path);
1358 uri->path = NULL;
1359 if (uri->fragment != NULL) xmlFree(uri->fragment);
1360 uri->fragment = NULL;
1361 if (uri->opaque != NULL) xmlFree(uri->opaque);
1362 uri->opaque = NULL;
1363 if (uri->authority != NULL) xmlFree(uri->authority);
1364 uri->authority = NULL;
1365 if (uri->query != NULL) xmlFree(uri->query);
1366 uri->query = NULL;
1367 if (uri->query_raw != NULL) xmlFree(uri->query_raw);
1368 uri->query_raw = NULL;
1369 }
1370
1371 /**
1372 * xmlFreeURI:
1373 * @uri: pointer to an xmlURI
1374 *
1375 * Free up the xmlURI struct
1376 */
1377 void
1378 xmlFreeURI(xmlURIPtr uri) {
1379 if (uri == NULL) return;
1380
1381 if (uri->scheme != NULL) xmlFree(uri->scheme);
1382 if (uri->server != NULL) xmlFree(uri->server);
1383 if (uri->user != NULL) xmlFree(uri->user);
1384 if (uri->path != NULL) xmlFree(uri->path);
1385 if (uri->fragment != NULL) xmlFree(uri->fragment);
1386 if (uri->opaque != NULL) xmlFree(uri->opaque);
1387 if (uri->authority != NULL) xmlFree(uri->authority);
1388 if (uri->query != NULL) xmlFree(uri->query);
1389 if (uri->query_raw != NULL) xmlFree(uri->query_raw);
1390 xmlFree(uri);
1391 }
1392
1393 /************************************************************************
1394 * *
1395 * Helper functions *
1396 * *
1397 ************************************************************************/
1398
1399 /**
1400 * xmlNormalizeURIPath:
1401 * @path: pointer to the path string
1402 *
1403 * Applies the 5 normalization steps to a path string--that is, RFC 2396
1404 * Section 5.2, steps 6.c through 6.g.
1405 *
1406 * Normalization occurs directly on the string, no new allocation is done
1407 *
1408 * Returns 0 or an error code
1409 */
1410 int
1411 xmlNormalizeURIPath(char *path) {
1412 char *cur, *out;
1413
1414 if (path == NULL)
1415 return(-1);
1416
1417 /* Skip all initial "/" chars. We want to get to the beginning of the
1418 * first non-empty segment.
1419 */
1420 cur = path;
1421 while (cur[0] == '/')
1422 ++cur;
1423 if (cur[0] == '\0')
1424 return(0);
1425
1426 /* Keep everything we've seen so far. */
1427 out = cur;
1428
1429 /*
1430 * Analyze each segment in sequence for cases (c) and (d).
1431 */
1432 while (cur[0] != '\0') {
1433 /*
1434 * c) All occurrences of "./", where "." is a complete path segment,
1435 * are removed from the buffer string.
1436 */
1437 if ((cur[0] == '.') && (cur[1] == '/')) {
1438 cur += 2;
1439 /* '//' normalization should be done at this point too */
1440 while (cur[0] == '/')
1441 cur++;
1442 continue;
1443 }
1444
1445 /*
1446 * d) If the buffer string ends with "." as a complete path segment,
1447 * that "." is removed.
1448 */
1449 if ((cur[0] == '.') && (cur[1] == '\0'))
1450 break;
1451
1452 /* Otherwise keep the segment. */
1453 while (cur[0] != '/') {
1454 if (cur[0] == '\0')
1455 goto done_cd;
1456 (out++)[0] = (cur++)[0];
1457 }
1458 /* nomalize // */
1459 while ((cur[0] == '/') && (cur[1] == '/'))
1460 cur++;
1461
1462 (out++)[0] = (cur++)[0];
1463 }
1464 done_cd:
1465 out[0] = '\0';
1466
1467 /* Reset to the beginning of the first segment for the next sequence. */
1468 cur = path;
1469 while (cur[0] == '/')
1470 ++cur;
1471 if (cur[0] == '\0')
1472 return(0);
1473
1474 /*
1475 * Analyze each segment in sequence for cases (e) and (f).
1476 *
1477 * e) All occurrences of "<segment>/../", where <segment> is a
1478 * complete path segment not equal to "..", are removed from the
1479 * buffer string. Removal of these path segments is performed
1480 * iteratively, removing the leftmost matching pattern on each
1481 * iteration, until no matching pattern remains.
1482 *
1483 * f) If the buffer string ends with "<segment>/..", where <segment>
1484 * is a complete path segment not equal to "..", that
1485 * "<segment>/.." is removed.
1486 *
1487 * To satisfy the "iterative" clause in (e), we need to collapse the
1488 * string every time we find something that needs to be removed. Thus,
1489 * we don't need to keep two pointers into the string: we only need a
1490 * "current position" pointer.
1491 */
1492 while (1) {
1493 char *segp, *tmp;
1494
1495 /* At the beginning of each iteration of this loop, "cur" points to
1496 * the first character of the segment we want to examine.
1497 */
1498
1499 /* Find the end of the current segment. */
1500 segp = cur;
1501 while ((segp[0] != '/') && (segp[0] != '\0'))
1502 ++segp;
1503
1504 /* If this is the last segment, we're done (we need at least two
1505 * segments to meet the criteria for the (e) and (f) cases).
1506 */
1507 if (segp[0] == '\0')
1508 break;
1509
1510 /* If the first segment is "..", or if the next segment _isn't_ "..",
1511 * keep this segment and try the next one.
1512 */
1513 ++segp;
1514 if (((cur[0] == '.') && (cur[1] == '.') && (segp == cur+3))
1515 || ((segp[0] != '.') || (segp[1] != '.')
1516 || ((segp[2] != '/') && (segp[2] != '\0')))) {
1517 cur = segp;
1518 continue;
1519 }
1520
1521 /* If we get here, remove this segment and the next one and back up
1522 * to the previous segment (if there is one), to implement the
1523 * "iteratively" clause. It's pretty much impossible to back up
1524 * while maintaining two pointers into the buffer, so just compact
1525 * the whole buffer now.
1526 */
1527
1528 /* If this is the end of the buffer, we're done. */
1529 if (segp[2] == '\0') {
1530 cur[0] = '\0';
1531 break;
1532 }
1533 /* Valgrind complained, strcpy(cur, segp + 3); */
1534 /* string will overlap, do not use strcpy */
1535 tmp = cur;
1536 segp += 3;
1537 while ((*tmp++ = *segp++) != 0)
1538 ;
1539
1540 /* If there are no previous segments, then keep going from here. */
1541 segp = cur;
1542 while ((segp > path) && ((--segp)[0] == '/'))
1543 ;
1544 if (segp == path)
1545 continue;
1546
1547 /* "segp" is pointing to the end of a previous segment; find it's
1548 * start. We need to back up to the previous segment and start
1549 * over with that to handle things like "foo/bar/../..". If we
1550 * don't do this, then on the first pass we'll remove the "bar/..",
1551 * but be pointing at the second ".." so we won't realize we can also
1552 * remove the "foo/..".
1553 */
1554 cur = segp;
1555 while ((cur > path) && (cur[-1] != '/'))
1556 --cur;
1557 }
1558 out[0] = '\0';
1559
1560 /*
1561 * g) If the resulting buffer string still begins with one or more
1562 * complete path segments of "..", then the reference is
1563 * considered to be in error. Implementations may handle this
1564 * error by retaining these components in the resolved path (i.e.,
1565 * treating them as part of the final URI), by removing them from
1566 * the resolved path (i.e., discarding relative levels above the
1567 * root), or by avoiding traversal of the reference.
1568 *
1569 * We discard them from the final path.
1570 */
1571 if (path[0] == '/') {
1572 cur = path;
1573 while ((cur[0] == '/') && (cur[1] == '.') && (cur[2] == '.')
1574 && ((cur[3] == '/') || (cur[3] == '\0')))
1575 cur += 3;
1576
1577 if (cur != path) {
1578 out = path;
1579 while (cur[0] != '\0')
1580 (out++)[0] = (cur++)[0];
1581 out[0] = 0;
1582 }
1583 }
1584
1585 return(0);
1586 }
1587
1588 static int is_hex(char c) {
1589 if (((c >= '0') && (c <= '9')) ||
1590 ((c >= 'a') && (c <= 'f')) ||
1591 ((c >= 'A') && (c <= 'F')))
1592 return(1);
1593 return(0);
1594 }
1595
1596 /**
1597 * xmlURIUnescapeString:
1598 * @str: the string to unescape
1599 * @len: the length in bytes to unescape (or <= 0 to indicate full string)
1600 * @target: optional destination buffer
1601 *
1602 * Unescaping routine, but does not check that the string is an URI. The
1603 * output is a direct unsigned char translation of %XX values (no encoding)
1604 * Note that the length of the result can only be smaller or same size as
1605 * the input string.
1606 *
1607 * Returns a copy of the string, but unescaped, will return NULL only in case
1608 * of error
1609 */
1610 char *
1611 xmlURIUnescapeString(const char *str, int len, char *target) {
1612 char *ret, *out;
1613 const char *in;
1614
1615 if (str == NULL)
1616 return(NULL);
1617 if (len <= 0) len = strlen(str);
1618 if (len < 0) return(NULL);
1619
1620 if (target == NULL) {
1621 ret = (char *) xmlMallocAtomic(len + 1);
1622 if (ret == NULL) {
1623 xmlURIErrMemory("unescaping URI value\n");
1624 return(NULL);
1625 }
1626 } else
1627 ret = target;
1628 in = str;
1629 out = ret;
1630 while(len > 0) {
1631 if ((len > 2) && (*in == '%') && (is_hex(in[1])) && (is_hex(in[2]))) {
1632 in++;
1633 if ((*in >= '0') && (*in <= '9'))
1634 *out = (*in - '0');
1635 else if ((*in >= 'a') && (*in <= 'f'))
1636 *out = (*in - 'a') + 10;
1637 else if ((*in >= 'A') && (*in <= 'F'))
1638 *out = (*in - 'A') + 10;
1639 in++;
1640 if ((*in >= '0') && (*in <= '9'))
1641 *out = *out * 16 + (*in - '0');
1642 else if ((*in >= 'a') && (*in <= 'f'))
1643 *out = *out * 16 + (*in - 'a') + 10;
1644 else if ((*in >= 'A') && (*in <= 'F'))
1645 *out = *out * 16 + (*in - 'A') + 10;
1646 in++;
1647 len -= 3;
1648 out++;
1649 } else {
1650 *out++ = *in++;
1651 len--;
1652 }
1653 }
1654 *out = 0;
1655 return(ret);
1656 }
1657
1658 /**
1659 * xmlURIEscapeStr:
1660 * @str: string to escape
1661 * @list: exception list string of chars not to escape
1662 *
1663 * This routine escapes a string to hex, ignoring reserved characters (a-z)
1664 * and the characters in the exception list.
1665 *
1666 * Returns a new escaped string or NULL in case of error.
1667 */
1668 xmlChar *
1669 xmlURIEscapeStr(const xmlChar *str, const xmlChar *list) {
1670 xmlChar *ret, ch;
1671 xmlChar *temp;
1672 const xmlChar *in;
1673 int len, out;
1674
1675 if (str == NULL)
1676 return(NULL);
1677 if (str[0] == 0)
1678 return(xmlStrdup(str));
1679 len = xmlStrlen(str);
1680 if (!(len > 0)) return(NULL);
1681
1682 len += 20;
1683 ret = (xmlChar *) xmlMallocAtomic(len);
1684 if (ret == NULL) {
1685 xmlURIErrMemory("escaping URI value\n");
1686 return(NULL);
1687 }
1688 in = (const xmlChar *) str;
1689 out = 0;
1690 while(*in != 0) {
1691 if (len - out <= 3) {
1692 temp = xmlSaveUriRealloc(ret, &len);
1693 if (temp == NULL) {
1694 xmlURIErrMemory("escaping URI value\n");
1695 xmlFree(ret);
1696 return(NULL);
1697 }
1698 ret = temp;
1699 }
1700
1701 ch = *in;
1702
1703 if ((ch != '@') && (!IS_UNRESERVED(ch)) && (!xmlStrchr(list, ch))) {
1704 unsigned char val;
1705 ret[out++] = '%';
1706 val = ch >> 4;
1707 if (val <= 9)
1708 ret[out++] = '0' + val;
1709 else
1710 ret[out++] = 'A' + val - 0xA;
1711 val = ch & 0xF;
1712 if (val <= 9)
1713 ret[out++] = '0' + val;
1714 else
1715 ret[out++] = 'A' + val - 0xA;
1716 in++;
1717 } else {
1718 ret[out++] = *in++;
1719 }
1720
1721 }
1722 ret[out] = 0;
1723 return(ret);
1724 }
1725
1726 /**
1727 * xmlURIEscape:
1728 * @str: the string of the URI to escape
1729 *
1730 * Escaping routine, does not do validity checks !
1731 * It will try to escape the chars needing this, but this is heuristic
1732 * based it's impossible to be sure.
1733 *
1734 * Returns an copy of the string, but escaped
1735 *
1736 * 25 May 2001
1737 * Uses xmlParseURI and xmlURIEscapeStr to try to escape correctly
1738 * according to RFC2396.
1739 * - Carl Douglas
1740 */
1741 xmlChar *
1742 xmlURIEscape(const xmlChar * str)
1743 {
1744 xmlChar *ret, *segment = NULL;
1745 xmlURIPtr uri;
1746 int ret2;
1747
1748 #define NULLCHK(p) if(!p) { \
1749 xmlURIErrMemory("escaping URI value\n"); \
1750 xmlFreeURI(uri); \
1751 return NULL; } \
1752
1753 if (str == NULL)
1754 return (NULL);
1755
1756 uri = xmlCreateURI();
1757 if (uri != NULL) {
1758 /*
1759 * Allow escaping errors in the unescaped form
1760 */
1761 uri->cleanup = 1;
1762 ret2 = xmlParseURIReference(uri, (const char *)str);
1763 if (ret2) {
1764 xmlFreeURI(uri);
1765 return (NULL);
1766 }
1767 }
1768
1769 if (!uri)
1770 return NULL;
1771
1772 ret = NULL;
1773
1774 if (uri->scheme) {
1775 segment = xmlURIEscapeStr(BAD_CAST uri->scheme, BAD_CAST "+-.");
1776 NULLCHK(segment)
1777 ret = xmlStrcat(ret, segment);
1778 ret = xmlStrcat(ret, BAD_CAST ":");
1779 xmlFree(segment);
1780 }
1781
1782 if (uri->authority) {
1783 segment =
1784 xmlURIEscapeStr(BAD_CAST uri->authority, BAD_CAST "/?;:@");
1785 NULLCHK(segment)
1786 ret = xmlStrcat(ret, BAD_CAST "//");
1787 ret = xmlStrcat(ret, segment);
1788 xmlFree(segment);
1789 }
1790
1791 if (uri->user) {
1792 segment = xmlURIEscapeStr(BAD_CAST uri->user, BAD_CAST ";:&=+$,");
1793 NULLCHK(segment)
1794 ret = xmlStrcat(ret,BAD_CAST "//");
1795 ret = xmlStrcat(ret, segment);
1796 ret = xmlStrcat(ret, BAD_CAST "@");
1797 xmlFree(segment);
1798 }
1799
1800 if (uri->server) {
1801 segment = xmlURIEscapeStr(BAD_CAST uri->server, BAD_CAST "/?;:@");
1802 NULLCHK(segment)
1803 if (uri->user == NULL)
1804 ret = xmlStrcat(ret, BAD_CAST "//");
1805 ret = xmlStrcat(ret, segment);
1806 xmlFree(segment);
1807 }
1808
1809 if (uri->port) {
1810 xmlChar port[10];
1811
1812 snprintf((char *) port, 10, "%d", uri->port);
1813 ret = xmlStrcat(ret, BAD_CAST ":");
1814 ret = xmlStrcat(ret, port);
1815 }
1816
1817 if (uri->path) {
1818 segment =
1819 xmlURIEscapeStr(BAD_CAST uri->path, BAD_CAST ":@&=+$,/?;");
1820 NULLCHK(segment)
1821 ret = xmlStrcat(ret, segment);
1822 xmlFree(segment);
1823 }
1824
1825 if (uri->query_raw) {
1826 ret = xmlStrcat(ret, BAD_CAST "?");
1827 ret = xmlStrcat(ret, BAD_CAST uri->query_raw);
1828 }
1829 else if (uri->query) {
1830 segment =
1831 xmlURIEscapeStr(BAD_CAST uri->query, BAD_CAST ";/?:@&=+,$");
1832 NULLCHK(segment)
1833 ret = xmlStrcat(ret, BAD_CAST "?");
1834 ret = xmlStrcat(ret, segment);
1835 xmlFree(segment);
1836 }
1837
1838 if (uri->opaque) {
1839 segment = xmlURIEscapeStr(BAD_CAST uri->opaque, BAD_CAST "");
1840 NULLCHK(segment)
1841 ret = xmlStrcat(ret, segment);
1842 xmlFree(segment);
1843 }
1844
1845 if (uri->fragment) {
1846 segment = xmlURIEscapeStr(BAD_CAST uri->fragment, BAD_CAST "#");
1847 NULLCHK(segment)
1848 ret = xmlStrcat(ret, BAD_CAST "#");
1849 ret = xmlStrcat(ret, segment);
1850 xmlFree(segment);
1851 }
1852
1853 xmlFreeURI(uri);
1854 #undef NULLCHK
1855
1856 return (ret);
1857 }
1858
1859 /************************************************************************
1860 * *
1861 * Public functions *
1862 * *
1863 ************************************************************************/
1864
1865 /**
1866 * xmlBuildURI:
1867 * @URI: the URI instance found in the document
1868 * @base: the base value
1869 *
1870 * Computes he final URI of the reference done by checking that
1871 * the given URI is valid, and building the final URI using the
1872 * base URI. This is processed according to section 5.2 of the
1873 * RFC 2396
1874 *
1875 * 5.2. Resolving Relative References to Absolute Form
1876 *
1877 * Returns a new URI string (to be freed by the caller) or NULL in case
1878 * of error.
1879 */
1880 xmlChar *
1881 xmlBuildURI(const xmlChar *URI, const xmlChar *base) {
1882 xmlChar *val = NULL;
1883 int ret, len, indx, cur, out;
1884 xmlURIPtr ref = NULL;
1885 xmlURIPtr bas = NULL;
1886 xmlURIPtr res = NULL;
1887
1888 /*
1889 * 1) The URI reference is parsed into the potential four components and
1890 * fragment identifier, as described in Section 4.3.
1891 *
1892 * NOTE that a completely empty URI is treated by modern browsers
1893 * as a reference to "." rather than as a synonym for the current
1894 * URI. Should we do that here?
1895 */
1896 if (URI == NULL)
1897 ret = -1;
1898 else {
1899 if (*URI) {
1900 ref = xmlCreateURI();
1901 if (ref == NULL)
1902 goto done;
1903 ret = xmlParseURIReference(ref, (const char *) URI);
1904 }
1905 else
1906 ret = 0;
1907 }
1908 if (ret != 0)
1909 goto done;
1910 if ((ref != NULL) && (ref->scheme != NULL)) {
1911 /*
1912 * The URI is absolute don't modify.
1913 */
1914 val = xmlStrdup(URI);
1915 goto done;
1916 }
1917 if (base == NULL)
1918 ret = -1;
1919 else {
1920 bas = xmlCreateURI();
1921 if (bas == NULL)
1922 goto done;
1923 ret = xmlParseURIReference(bas, (const char *) base);
1924 }
1925 if (ret != 0) {
1926 if (ref)
1927 val = xmlSaveUri(ref);
1928 goto done;
1929 }
1930 if (ref == NULL) {
1931 /*
1932 * the base fragment must be ignored
1933 */
1934 if (bas->fragment != NULL) {
1935 xmlFree(bas->fragment);
1936 bas->fragment = NULL;
1937 }
1938 val = xmlSaveUri(bas);
1939 goto done;
1940 }
1941
1942 /*
1943 * 2) If the path component is empty and the scheme, authority, and
1944 * query components are undefined, then it is a reference to the
1945 * current document and we are done. Otherwise, the reference URI's
1946 * query and fragment components are defined as found (or not found)
1947 * within the URI reference and not inherited from the base URI.
1948 *
1949 * NOTE that in modern browsers, the parsing differs from the above
1950 * in the following aspect: the query component is allowed to be
1951 * defined while still treating this as a reference to the current
1952 * document.
1953 */
1954 res = xmlCreateURI();
1955 if (res == NULL)
1956 goto done;
1957 if ((ref->scheme == NULL) && (ref->path == NULL) &&
1958 ((ref->authority == NULL) && (ref->server == NULL))) {
1959 if (bas->scheme != NULL)
1960 res->scheme = xmlMemStrdup(bas->scheme);
1961 if (bas->authority != NULL)
1962 res->authority = xmlMemStrdup(bas->authority);
1963 else if (bas->server != NULL) {
1964 res->server = xmlMemStrdup(bas->server);
1965 if (bas->user != NULL)
1966 res->user = xmlMemStrdup(bas->user);
1967 res->port = bas->port;
1968 }
1969 if (bas->path != NULL)
1970 res->path = xmlMemStrdup(bas->path);
1971 if (ref->query_raw != NULL)
1972 res->query_raw = xmlMemStrdup (ref->query_raw);
1973 else if (ref->query != NULL)
1974 res->query = xmlMemStrdup(ref->query);
1975 else if (bas->query_raw != NULL)
1976 res->query_raw = xmlMemStrdup(bas->query_raw);
1977 else if (bas->query != NULL)
1978 res->query = xmlMemStrdup(bas->query);
1979 if (ref->fragment != NULL)
1980 res->fragment = xmlMemStrdup(ref->fragment);
1981 goto step_7;
1982 }
1983
1984 /*
1985 * 3) If the scheme component is defined, indicating that the reference
1986 * starts with a scheme name, then the reference is interpreted as an
1987 * absolute URI and we are done. Otherwise, the reference URI's
1988 * scheme is inherited from the base URI's scheme component.
1989 */
1990 if (ref->scheme != NULL) {
1991 val = xmlSaveUri(ref);
1992 goto done;
1993 }
1994 if (bas->scheme != NULL)
1995 res->scheme = xmlMemStrdup(bas->scheme);
1996
1997 if (ref->query_raw != NULL)
1998 res->query_raw = xmlMemStrdup(ref->query_raw);
1999 else if (ref->query != NULL)
2000 res->query = xmlMemStrdup(ref->query);
2001 if (ref->fragment != NULL)
2002 res->fragment = xmlMemStrdup(ref->fragment);
2003
2004 /*
2005 * 4) If the authority component is defined, then the reference is a
2006 * network-path and we skip to step 7. Otherwise, the reference
2007 * URI's authority is inherited from the base URI's authority
2008 * component, which will also be undefined if the URI scheme does not
2009 * use an authority component.
2010 */
2011 if ((ref->authority != NULL) || (ref->server != NULL)) {
2012 if (ref->authority != NULL)
2013 res->authority = xmlMemStrdup(ref->authority);
2014 else {
2015 res->server = xmlMemStrdup(ref->server);
2016 if (ref->user != NULL)
2017 res->user = xmlMemStrdup(ref->user);
2018 res->port = ref->port;
2019 }
2020 if (ref->path != NULL)
2021 res->path = xmlMemStrdup(ref->path);
2022 goto step_7;
2023 }
2024 if (bas->authority != NULL)
2025 res->authority = xmlMemStrdup(bas->authority);
2026 else if (bas->server != NULL) {
2027 res->server = xmlMemStrdup(bas->server);
2028 if (bas->user != NULL)
2029 res->user = xmlMemStrdup(bas->user);
2030 res->port = bas->port;
2031 }
2032
2033 /*
2034 * 5) If the path component begins with a slash character ("/"), then
2035 * the reference is an absolute-path and we skip to step 7.
2036 */
2037 if ((ref->path != NULL) && (ref->path[0] == '/')) {
2038 res->path = xmlMemStrdup(ref->path);
2039 goto step_7;
2040 }
2041
2042
2043 /*
2044 * 6) If this step is reached, then we are resolving a relative-path
2045 * reference. The relative path needs to be merged with the base
2046 * URI's path. Although there are many ways to do this, we will
2047 * describe a simple method using a separate string buffer.
2048 *
2049 * Allocate a buffer large enough for the result string.
2050 */
2051 len = 2; /* extra / and 0 */
2052 if (ref->path != NULL)
2053 len += strlen(ref->path);
2054 if (bas->path != NULL)
2055 len += strlen(bas->path);
2056 res->path = (char *) xmlMallocAtomic(len);
2057 if (res->path == NULL) {
2058 xmlURIErrMemory("resolving URI against base\n");
2059 goto done;
2060 }
2061 res->path[0] = 0;
2062
2063 /*
2064 * a) All but the last segment of the base URI's path component is
2065 * copied to the buffer. In other words, any characters after the
2066 * last (right-most) slash character, if any, are excluded.
2067 */
2068 cur = 0;
2069 out = 0;
2070 if (bas->path != NULL) {
2071 while (bas->path[cur] != 0) {
2072 while ((bas->path[cur] != 0) && (bas->path[cur] != '/'))
2073 cur++;
2074 if (bas->path[cur] == 0)
2075 break;
2076
2077 cur++;
2078 while (out < cur) {
2079 res->path[out] = bas->path[out];
2080 out++;
2081 }
2082 }
2083 }
2084 res->path[out] = 0;
2085
2086 /*
2087 * b) The reference's path component is appended to the buffer
2088 * string.
2089 */
2090 if (ref->path != NULL && ref->path[0] != 0) {
2091 indx = 0;
2092 /*
2093 * Ensure the path includes a '/'
2094 */
2095 if ((out == 0) && (bas->server != NULL))
2096 res->path[out++] = '/';
2097 while (ref->path[indx] != 0) {
2098 res->path[out++] = ref->path[indx++];
2099 }
2100 }
2101 res->path[out] = 0;
2102
2103 /*
2104 * Steps c) to h) are really path normalization steps
2105 */
2106 xmlNormalizeURIPath(res->path);
2107
2108 step_7:
2109
2110 /*
2111 * 7) The resulting URI components, including any inherited from the
2112 * base URI, are recombined to give the absolute form of the URI
2113 * reference.
2114 */
2115 val = xmlSaveUri(res);
2116
2117 done:
2118 if (ref != NULL)
2119 xmlFreeURI(ref);
2120 if (bas != NULL)
2121 xmlFreeURI(bas);
2122 if (res != NULL)
2123 xmlFreeURI(res);
2124 return(val);
2125 }
2126
2127 /**
2128 * xmlBuildRelativeURI:
2129 * @URI: the URI reference under consideration
2130 * @base: the base value
2131 *
2132 * Expresses the URI of the reference in terms relative to the
2133 * base. Some examples of this operation include:
2134 * base = "http://site1.com/docs/book1.html"
2135 * URI input URI returned
2136 * docs/pic1.gif pic1.gif
2137 * docs/img/pic1.gif img/pic1.gif
2138 * img/pic1.gif ../img/pic1.gif
2139 * http://site1.com/docs/pic1.gif pic1.gif
2140 * http://site2.com/docs/pic1.gif http://site2.com/docs/pic1.gif
2141 *
2142 * base = "docs/book1.html"
2143 * URI input URI returned
2144 * docs/pic1.gif pic1.gif
2145 * docs/img/pic1.gif img/pic1.gif
2146 * img/pic1.gif ../img/pic1.gif
2147 * http://site1.com/docs/pic1.gif http://site1.com/docs/pic1.gif
2148 *
2149 *
2150 * Note: if the URI reference is really wierd or complicated, it may be
2151 * worthwhile to first convert it into a "nice" one by calling
2152 * xmlBuildURI (using 'base') before calling this routine,
2153 * since this routine (for reasonable efficiency) assumes URI has
2154 * already been through some validation.
2155 *
2156 * Returns a new URI string (to be freed by the caller) or NULL in case
2157 * error.
2158 */
2159 xmlChar *
2160 xmlBuildRelativeURI (const xmlChar * URI, const xmlChar * base)
2161 {
2162 xmlChar *val = NULL;
2163 int ret;
2164 int ix;
2165 int pos = 0;
2166 int nbslash = 0;
2167 int len;
2168 xmlURIPtr ref = NULL;
2169 xmlURIPtr bas = NULL;
2170 xmlChar *bptr, *uptr, *vptr;
2171 int remove_path = 0;
2172
2173 if ((URI == NULL) || (*URI == 0))
2174 return NULL;
2175
2176 /*
2177 * First parse URI into a standard form
2178 */
2179 ref = xmlCreateURI ();
2180 if (ref == NULL)
2181 return NULL;
2182 /* If URI not already in "relative" form */
2183 if (URI[0] != '.') {
2184 ret = xmlParseURIReference (ref, (const char *) URI);
2185 if (ret != 0)
2186 goto done; /* Error in URI, return NULL */
2187 } else
2188 ref->path = (char *)xmlStrdup(URI);
2189
2190 /*
2191 * Next parse base into the same standard form
2192 */
2193 if ((base == NULL) || (*base == 0)) {
2194 val = xmlStrdup (URI);
2195 goto done;
2196 }
2197 bas = xmlCreateURI ();
2198 if (bas == NULL)
2199 goto done;
2200 if (base[0] != '.') {
2201 ret = xmlParseURIReference (bas, (const char *) base);
2202 if (ret != 0)
2203 goto done; /* Error in base, return NULL */
2204 } else
2205 bas->path = (char *)xmlStrdup(base);
2206
2207 /*
2208 * If the scheme / server on the URI differs from the base,
2209 * just return the URI
2210 */
2211 if ((ref->scheme != NULL) &&
2212 ((bas->scheme == NULL) ||
2213 (xmlStrcmp ((xmlChar *)bas->scheme, (xmlChar *)ref->scheme)) ||
2214 (xmlStrcmp ((xmlChar *)bas->server, (xmlChar *)ref->server)))) {
2215 val = xmlStrdup (URI);
2216 goto done;
2217 }
2218 if (xmlStrEqual((xmlChar *)bas->path, (xmlChar *)ref->path)) {
2219 val = xmlStrdup(BAD_CAST "");
2220 goto done;
2221 }
2222 if (bas->path == NULL) {
2223 val = xmlStrdup((xmlChar *)ref->path);
2224 goto done;
2225 }
2226 if (ref->path == NULL) {
2227 ref->path = (char *) "/";
2228 remove_path = 1;
2229 }
2230
2231 /*
2232 * At this point (at last!) we can compare the two paths
2233 *
2234 * First we take care of the special case where either of the
2235 * two path components may be missing (bug 316224)
2236 */
2237 if (bas->path == NULL) {
2238 if (ref->path != NULL) {
2239 uptr = (xmlChar *) ref->path;
2240 if (*uptr == '/')
2241 uptr++;
2242 /* exception characters from xmlSaveUri */
2243 val = xmlURIEscapeStr(uptr, BAD_CAST "/;&=+$,");
2244 }
2245 goto done;
2246 }
2247 bptr = (xmlChar *)bas->path;
2248 if (ref->path == NULL) {
2249 for (ix = 0; bptr[ix] != 0; ix++) {
2250 if (bptr[ix] == '/')
2251 nbslash++;
2252 }
2253 uptr = NULL;
2254 len = 1; /* this is for a string terminator only */
2255 } else {
2256 /*
2257 * Next we compare the two strings and find where they first differ
2258 */
2259 if ((ref->path[pos] == '.') && (ref->path[pos+1] == '/'))
2260 pos += 2;
2261 if ((*bptr == '.') && (bptr[1] == '/'))
2262 bptr += 2;
2263 else if ((*bptr == '/') && (ref->path[pos] != '/'))
2264 bptr++;
2265 while ((bptr[pos] == ref->path[pos]) && (bptr[pos] != 0))
2266 pos++;
2267
2268 if (bptr[pos] == ref->path[pos]) {
2269 val = xmlStrdup(BAD_CAST "");
2270 goto done; /* (I can't imagine why anyone would do this) */
2271 }
2272
2273 /*
2274 * In URI, "back up" to the last '/' encountered. This will be the
2275 * beginning of the "unique" suffix of URI
2276 */
2277 ix = pos;
2278 if ((ref->path[ix] == '/') && (ix > 0))
2279 ix--;
2280 else if ((ref->path[ix] == 0) && (ix > 1) && (ref->path[ix - 1] == '/'))
2281 ix -= 2;
2282 for (; ix > 0; ix--) {
2283 if (ref->path[ix] == '/')
2284 break;
2285 }
2286 if (ix == 0) {
2287 uptr = (xmlChar *)ref->path;
2288 } else {
2289 ix++;
2290 uptr = (xmlChar *)&ref->path[ix];
2291 }
2292
2293 /*
2294 * In base, count the number of '/' from the differing point
2295 */
2296 if (bptr[pos] != ref->path[pos]) {/* check for trivial URI == base */
2297 for (; bptr[ix] != 0; ix++) {
2298 if (bptr[ix] == '/')
2299 nbslash++;
2300 }
2301 }
2302 len = xmlStrlen (uptr) + 1;
2303 }
2304
2305 if (nbslash == 0) {
2306 if (uptr != NULL)
2307 /* exception characters from xmlSaveUri */
2308 val = xmlURIEscapeStr(uptr, BAD_CAST "/;&=+$,");
2309 goto done;
2310 }
2311
2312 /*
2313 * Allocate just enough space for the returned string -
2314 * length of the remainder of the URI, plus enough space
2315 * for the "../" groups, plus one for the terminator
2316 */
2317 val = (xmlChar *) xmlMalloc (len + 3 * nbslash);
2318 if (val == NULL) {
2319 xmlURIErrMemory("building relative URI\n");
2320 goto done;
2321 }
2322 vptr = val;
2323 /*
2324 * Put in as many "../" as needed
2325 */
2326 for (; nbslash>0; nbslash--) {
2327 *vptr++ = '.';
2328 *vptr++ = '.';
2329 *vptr++ = '/';
2330 }
2331 /*
2332 * Finish up with the end of the URI
2333 */
2334 if (uptr != NULL) {
2335 if ((vptr > val) && (len > 0) &&
2336 (uptr[0] == '/') && (vptr[-1] == '/')) {
2337 memcpy (vptr, uptr + 1, len - 1);
2338 vptr[len - 2] = 0;
2339 } else {
2340 memcpy (vptr, uptr, len);
2341 vptr[len - 1] = 0;
2342 }
2343 } else {
2344 vptr[len - 1] = 0;
2345 }
2346
2347 /* escape the freshly-built path */
2348 vptr = val;
2349 /* exception characters from xmlSaveUri */
2350 val = xmlURIEscapeStr(vptr, BAD_CAST "/;&=+$,");
2351 xmlFree(vptr);
2352
2353 done:
2354 /*
2355 * Free the working variables
2356 */
2357 if (remove_path != 0)
2358 ref->path = NULL;
2359 if (ref != NULL)
2360 xmlFreeURI (ref);
2361 if (bas != NULL)
2362 xmlFreeURI (bas);
2363
2364 return val;
2365 }
2366
2367 /**
2368 * xmlCanonicPath:
2369 * @path: the resource locator in a filesystem notation
2370 *
2371 * Constructs a canonic path from the specified path.
2372 *
2373 * Returns a new canonic path, or a duplicate of the path parameter if the
2374 * construction fails. The caller is responsible for freeing the memory occupied
2375 * by the returned string. If there is insufficient memory available, or the
2376 * argument is NULL, the function returns NULL.
2377 */
2378 #define IS_WINDOWS_PATH(p) \
2379 ((p != NULL) && \
2380 (((p[0] >= 'a') && (p[0] <= 'z')) || \
2381 ((p[0] >= 'A') && (p[0] <= 'Z'))) && \
2382 (p[1] == ':') && ((p[2] == '/') || (p[2] == '\\')))
2383 xmlChar *
2384 xmlCanonicPath(const xmlChar *path)
2385 {
2386 /*
2387 * For Windows implementations, additional work needs to be done to
2388 * replace backslashes in pathnames with "forward slashes"
2389 */
2390 #if defined(_WIN32) && !defined(__CYGWIN__)
2391 int len = 0;
2392 int i = 0;
2393 xmlChar *p = NULL;
2394 #endif
2395 xmlURIPtr uri;
2396 xmlChar *ret;
2397 const xmlChar *absuri;
2398
2399 if (path == NULL)
2400 return(NULL);
2401
2402 #if defined(_WIN32)
2403 /*
2404 * We must not change the backslashes to slashes if the the path
2405 * starts with \\?\
2406 * Those paths can be up to 32k characters long.
2407 * Was added specifically for OpenOffice, those paths can't be converted
2408 * to URIs anyway.
2409 */
2410 if ((path[0] == '\\') && (path[1] == '\\') && (path[2] == '?') &&
2411 (path[3] == '\\') )
2412 return xmlStrdup((const xmlChar *) path);
2413 #endif
2414
2415 /* sanitize filename starting with // so it can be used as URI */
2416 if ((path[0] == '/') && (path[1] == '/') && (path[2] != '/'))
2417 path++;
2418
2419 if ((uri = xmlParseURI((const char *) path)) != NULL) {
2420 xmlFreeURI(uri);
2421 return xmlStrdup(path);
2422 }
2423
2424 /* Check if this is an "absolute uri" */
2425 absuri = xmlStrstr(path, BAD_CAST "://");
2426 if (absuri != NULL) {
2427 int l, j;
2428 unsigned char c;
2429 xmlChar *escURI;
2430
2431 /*
2432 * this looks like an URI where some parts have not been
2433 * escaped leading to a parsing problem. Check that the first
2434 * part matches a protocol.
2435 */
2436 l = absuri - path;
2437 /* Bypass if first part (part before the '://') is > 20 chars */
2438 if ((l <= 0) || (l > 20))
2439 goto path_processing;
2440 /* Bypass if any non-alpha characters are present in first part */
2441 for (j = 0;j < l;j++) {
2442 c = path[j];
2443 if (!(((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z'))))
2444 goto path_processing;
2445 }
2446
2447 /* Escape all except the characters specified in the supplied path */
2448 escURI = xmlURIEscapeStr(path, BAD_CAST ":/?_.#&;=");
2449 if (escURI != NULL) {
2450 /* Try parsing the escaped path */
2451 uri = xmlParseURI((const char *) escURI);
2452 /* If successful, return the escaped string */
2453 if (uri != NULL) {
2454 xmlFreeURI(uri);
2455 return escURI;
2456 }
2457 }
2458 }
2459
2460 path_processing:
2461 /* For Windows implementations, replace backslashes with 'forward slashes' */
2462 #if defined(_WIN32) && !defined(__CYGWIN__)
2463 /*
2464 * Create a URI structure
2465 */
2466 uri = xmlCreateURI();
2467 if (uri == NULL) { /* Guard against 'out of memory' */
2468 return(NULL);
2469 }
2470
2471 len = xmlStrlen(path);
2472 if ((len > 2) && IS_WINDOWS_PATH(path)) {
2473 /* make the scheme 'file' */
2474 uri->scheme = xmlStrdup(BAD_CAST "file");
2475 /* allocate space for leading '/' + path + string terminator */
2476 uri->path = xmlMallocAtomic(len + 2);
2477 if (uri->path == NULL) {
2478 xmlFreeURI(uri); /* Guard agains 'out of memory' */
2479 return(NULL);
2480 }
2481 /* Put in leading '/' plus path */
2482 uri->path[0] = '/';
2483 p = uri->path + 1;
2484 strncpy(p, path, len + 1);
2485 } else {
2486 uri->path = xmlStrdup(path);
2487 if (uri->path == NULL) {
2488 xmlFreeURI(uri);
2489 return(NULL);
2490 }
2491 p = uri->path;
2492 }
2493 /* Now change all occurences of '\' to '/' */
2494 while (*p != '\0') {
2495 if (*p == '\\')
2496 *p = '/';
2497 p++;
2498 }
2499
2500 if (uri->scheme == NULL) {
2501 ret = xmlStrdup((const xmlChar *) uri->path);
2502 } else {
2503 ret = xmlSaveUri(uri);
2504 }
2505
2506 xmlFreeURI(uri);
2507 #else
2508 ret = xmlStrdup((const xmlChar *) path);
2509 #endif
2510 return(ret);
2511 }
2512
2513 /**
2514 * xmlPathToURI:
2515 * @path: the resource locator in a filesystem notation
2516 *
2517 * Constructs an URI expressing the existing path
2518 *
2519 * Returns a new URI, or a duplicate of the path parameter if the
2520 * construction fails. The caller is responsible for freeing the memory
2521 * occupied by the returned string. If there is insufficient memory available,
2522 * or the argument is NULL, the function returns NULL.
2523 */
2524 xmlChar *
2525 xmlPathToURI(const xmlChar *path)
2526 {
2527 xmlURIPtr uri;
2528 xmlURI temp;
2529 xmlChar *ret, *cal;
2530
2531 if (path == NULL)
2532 return(NULL);
2533
2534 if ((uri = xmlParseURI((const char *) path)) != NULL) {
2535 xmlFreeURI(uri);
2536 return xmlStrdup(path);
2537 }
2538 cal = xmlCanonicPath(path);
2539 if (cal == NULL)
2540 return(NULL);
2541 #if defined(_WIN32) && !defined(__CYGWIN__)
2542 /* xmlCanonicPath can return an URI on Windows (is that the intended behaviour?)
2543 If 'cal' is a valid URI allready then we are done here, as continuing would make
2544 it invalid. */
2545 if ((uri = xmlParseURI((const char *) cal)) != NULL) {
2546 xmlFreeURI(uri);
2547 return cal;
2548 }
2549 /* 'cal' can contain a relative path with backslashes. If that is processed
2550 by xmlSaveURI, they will be escaped and the external entity loader machinery
2551 will fail. So convert them to slashes. Misuse 'ret' for walking. */
2552 ret = cal;
2553 while (*ret != '\0') {
2554 if (*ret == '\\')
2555 *ret = '/';
2556 ret++;
2557 }
2558 #endif
2559 memset(&temp, 0, sizeof(temp));
2560 temp.path = (char *) cal;
2561 ret = xmlSaveUri(&temp);
2562 xmlFree(cal);
2563 return(ret);
2564 }
2565 #define bottom_uri
2566 #include "elfgcchack.h"