projects / reactos.git / blob
? search:


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