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) || (bas->port == -1)) { 1965 if (bas->server != NULL) 1966 res->server = xmlMemStrdup(bas->server); 1967 if (bas->user != NULL) 1968 res->user = xmlMemStrdup(bas->user); 1969 res->port = bas->port; 1970 } 1971 if (bas->path != NULL) 1972 res->path = xmlMemStrdup(bas->path); 1973 if (ref->query_raw != NULL) 1974 res->query_raw = xmlMemStrdup (ref->query_raw); 1975 else if (ref->query != NULL) 1976 res->query = xmlMemStrdup(ref->query); 1977 else if (bas->query_raw != NULL) 1978 res->query_raw = xmlMemStrdup(bas->query_raw); 1979 else if (bas->query != NULL) 1980 res->query = xmlMemStrdup(bas->query); 1981 if (ref->fragment != NULL) 1982 res->fragment = xmlMemStrdup(ref->fragment); 1983 goto step_7; 1984 } 1985 1986 /* 1987 * 3) If the scheme component is defined, indicating that the reference 1988 * starts with a scheme name, then the reference is interpreted as an 1989 * absolute URI and we are done. Otherwise, the reference URI's 1990 * scheme is inherited from the base URI's scheme component. 1991 */ 1992 if (ref->scheme != NULL) { 1993 val = xmlSaveUri(ref); 1994 goto done; 1995 } 1996 if (bas->scheme != NULL) 1997 res->scheme = xmlMemStrdup(bas->scheme); 1998 1999 if (ref->query_raw != NULL) 2000 res->query_raw = xmlMemStrdup(ref->query_raw); 2001 else if (ref->query != NULL) 2002 res->query = xmlMemStrdup(ref->query); 2003 if (ref->fragment != NULL) 2004 res->fragment = xmlMemStrdup(ref->fragment); 2005 2006 /* 2007 * 4) If the authority component is defined, then the reference is a 2008 * network-path and we skip to step 7. Otherwise, the reference 2009 * URI's authority is inherited from the base URI's authority 2010 * component, which will also be undefined if the URI scheme does not 2011 * use an authority component. 2012 */ 2013 if ((ref->authority != NULL) || (ref->server != NULL)) { 2014 if (ref->authority != NULL) 2015 res->authority = xmlMemStrdup(ref->authority); 2016 else { 2017 res->server = xmlMemStrdup(ref->server); 2018 if (ref->user != NULL) 2019 res->user = xmlMemStrdup(ref->user); 2020 res->port = ref->port; 2021 } 2022 if (ref->path != NULL) 2023 res->path = xmlMemStrdup(ref->path); 2024 goto step_7; 2025 } 2026 if (bas->authority != NULL) 2027 res->authority = xmlMemStrdup(bas->authority); 2028 else if ((bas->server != NULL) || (bas->port == -1)) { 2029 if (bas->server != NULL) 2030 res->server = xmlMemStrdup(bas->server); 2031 if (bas->user != NULL) 2032 res->user = xmlMemStrdup(bas->user); 2033 res->port = bas->port; 2034 } 2035 2036 /* 2037 * 5) If the path component begins with a slash character ("/"), then 2038 * the reference is an absolute-path and we skip to step 7. 2039 */ 2040 if ((ref->path != NULL) && (ref->path[0] == '/')) { 2041 res->path = xmlMemStrdup(ref->path); 2042 goto step_7; 2043 } 2044 2045 2046 /* 2047 * 6) If this step is reached, then we are resolving a relative-path 2048 * reference. The relative path needs to be merged with the base 2049 * URI's path. Although there are many ways to do this, we will 2050 * describe a simple method using a separate string buffer. 2051 * 2052 * Allocate a buffer large enough for the result string. 2053 */ 2054 len = 2; /* extra / and 0 */ 2055 if (ref->path != NULL) 2056 len += strlen(ref->path); 2057 if (bas->path != NULL) 2058 len += strlen(bas->path); 2059 res->path = (char *) xmlMallocAtomic(len); 2060 if (res->path == NULL) { 2061 xmlURIErrMemory("resolving URI against base\n"); 2062 goto done; 2063 } 2064 res->path[0] = 0; 2065 2066 /* 2067 * a) All but the last segment of the base URI's path component is 2068 * copied to the buffer. In other words, any characters after the 2069 * last (right-most) slash character, if any, are excluded. 2070 */ 2071 cur = 0; 2072 out = 0; 2073 if (bas->path != NULL) { 2074 while (bas->path[cur] != 0) { 2075 while ((bas->path[cur] != 0) && (bas->path[cur] != '/')) 2076 cur++; 2077 if (bas->path[cur] == 0) 2078 break; 2079 2080 cur++; 2081 while (out < cur) { 2082 res->path[out] = bas->path[out]; 2083 out++; 2084 } 2085 } 2086 } 2087 res->path[out] = 0; 2088 2089 /* 2090 * b) The reference's path component is appended to the buffer 2091 * string. 2092 */ 2093 if (ref->path != NULL && ref->path[0] != 0) { 2094 indx = 0; 2095 /* 2096 * Ensure the path includes a '/' 2097 */ 2098 if ((out == 0) && (bas->server != NULL)) 2099 res->path[out++] = '/'; 2100 while (ref->path[indx] != 0) { 2101 res->path[out++] = ref->path[indx++]; 2102 } 2103 } 2104 res->path[out] = 0; 2105 2106 /* 2107 * Steps c) to h) are really path normalization steps 2108 */ 2109 xmlNormalizeURIPath(res->path); 2110 2111 step_7: 2112 2113 /* 2114 * 7) The resulting URI components, including any inherited from the 2115 * base URI, are recombined to give the absolute form of the URI 2116 * reference. 2117 */ 2118 val = xmlSaveUri(res); 2119 2120 done: 2121 if (ref != NULL) 2122 xmlFreeURI(ref); 2123 if (bas != NULL) 2124 xmlFreeURI(bas); 2125 if (res != NULL) 2126 xmlFreeURI(res); 2127 return(val); 2128 } 2129 2130 /** 2131 * xmlBuildRelativeURI: 2132 * @URI: the URI reference under consideration 2133 * @base: the base value 2134 * 2135 * Expresses the URI of the reference in terms relative to the 2136 * base. Some examples of this operation include: 2137 * base = "http://site1.com/docs/book1.html" 2138 * URI input URI returned 2139 * docs/pic1.gif pic1.gif 2140 * docs/img/pic1.gif img/pic1.gif 2141 * img/pic1.gif ../img/pic1.gif 2142 * http://site1.com/docs/pic1.gif pic1.gif 2143 * http://site2.com/docs/pic1.gif http://site2.com/docs/pic1.gif 2144 * 2145 * base = "docs/book1.html" 2146 * URI input URI returned 2147 * docs/pic1.gif pic1.gif 2148 * docs/img/pic1.gif img/pic1.gif 2149 * img/pic1.gif ../img/pic1.gif 2150 * http://site1.com/docs/pic1.gif http://site1.com/docs/pic1.gif 2151 * 2152 * 2153 * Note: if the URI reference is really wierd or complicated, it may be 2154 * worthwhile to first convert it into a "nice" one by calling 2155 * xmlBuildURI (using 'base') before calling this routine, 2156 * since this routine (for reasonable efficiency) assumes URI has 2157 * already been through some validation. 2158 * 2159 * Returns a new URI string (to be freed by the caller) or NULL in case 2160 * error. 2161 */ 2162 xmlChar * 2163 xmlBuildRelativeURI (const xmlChar * URI, const xmlChar * base) 2164 { 2165 xmlChar *val = NULL; 2166 int ret; 2167 int ix; 2168 int nbslash = 0; 2169 int len; 2170 xmlURIPtr ref = NULL; 2171 xmlURIPtr bas = NULL; 2172 xmlChar *bptr, *uptr, *vptr; 2173 int remove_path = 0; 2174 2175 if ((URI == NULL) || (*URI == 0)) 2176 return NULL; 2177 2178 /* 2179 * First parse URI into a standard form 2180 */ 2181 ref = xmlCreateURI (); 2182 if (ref == NULL) 2183 return NULL; 2184 /* If URI not already in "relative" form */ 2185 if (URI[0] != '.') { 2186 ret = xmlParseURIReference (ref, (const char *) URI); 2187 if (ret != 0) 2188 goto done; /* Error in URI, return NULL */ 2189 } else 2190 ref->path = (char *)xmlStrdup(URI); 2191 2192 /* 2193 * Next parse base into the same standard form 2194 */ 2195 if ((base == NULL) || (*base == 0)) { 2196 val = xmlStrdup (URI); 2197 goto done; 2198 } 2199 bas = xmlCreateURI (); 2200 if (bas == NULL) 2201 goto done; 2202 if (base[0] != '.') { 2203 ret = xmlParseURIReference (bas, (const char *) base); 2204 if (ret != 0) 2205 goto done; /* Error in base, return NULL */ 2206 } else 2207 bas->path = (char *)xmlStrdup(base); 2208 2209 /* 2210 * If the scheme / server on the URI differs from the base, 2211 * just return the URI 2212 */ 2213 if ((ref->scheme != NULL) && 2214 ((bas->scheme == NULL) || 2215 (xmlStrcmp ((xmlChar *)bas->scheme, (xmlChar *)ref->scheme)) || 2216 (xmlStrcmp ((xmlChar *)bas->server, (xmlChar *)ref->server)))) { 2217 val = xmlStrdup (URI); 2218 goto done; 2219 } 2220 if (xmlStrEqual((xmlChar *)bas->path, (xmlChar *)ref->path)) { 2221 val = xmlStrdup(BAD_CAST ""); 2222 goto done; 2223 } 2224 if (bas->path == NULL) { 2225 val = xmlStrdup((xmlChar *)ref->path); 2226 goto done; 2227 } 2228 if (ref->path == NULL) { 2229 ref->path = (char *) "/"; 2230 remove_path = 1; 2231 } 2232 2233 /* 2234 * At this point (at last!) we can compare the two paths 2235 * 2236 * First we take care of the special case where either of the 2237 * two path components may be missing (bug 316224) 2238 */ 2239 if (bas->path == NULL) { 2240 if (ref->path != NULL) { 2241 uptr = (xmlChar *) ref->path; 2242 if (*uptr == '/') 2243 uptr++; 2244 /* exception characters from xmlSaveUri */ 2245 val = xmlURIEscapeStr(uptr, BAD_CAST "/;&=+$,"); 2246 } 2247 goto done; 2248 } 2249 bptr = (xmlChar *)bas->path; 2250 if (ref->path == NULL) { 2251 for (ix = 0; bptr[ix] != 0; ix++) { 2252 if (bptr[ix] == '/') 2253 nbslash++; 2254 } 2255 uptr = NULL; 2256 len = 1; /* this is for a string terminator only */ 2257 } else { 2258 xmlChar *rptr = (xmlChar *) ref->path; 2259 int pos = 0; 2260 2261 /* 2262 * Next we compare the two strings and find where they first differ 2263 */ 2264 if ((*rptr == '.') && (rptr[1] == '/')) 2265 rptr += 2; 2266 if ((*bptr == '.') && (bptr[1] == '/')) 2267 bptr += 2; 2268 else if ((*bptr == '/') && (*rptr != '/')) 2269 bptr++; 2270 while ((bptr[pos] == rptr[pos]) && (bptr[pos] != 0)) 2271 pos++; 2272 2273 if (bptr[pos] == rptr[pos]) { 2274 val = xmlStrdup(BAD_CAST ""); 2275 goto done; /* (I can't imagine why anyone would do this) */ 2276 } 2277 2278 /* 2279 * In URI, "back up" to the last '/' encountered. This will be the 2280 * beginning of the "unique" suffix of URI 2281 */ 2282 ix = pos; 2283 if ((rptr[ix] == '/') && (ix > 0)) 2284 ix--; 2285 else if ((rptr[ix] == 0) && (ix > 1) && (rptr[ix - 1] == '/')) 2286 ix -= 2; 2287 for (; ix > 0; ix--) { 2288 if (rptr[ix] == '/') 2289 break; 2290 } 2291 if (ix == 0) { 2292 uptr = (xmlChar *)rptr; 2293 } else { 2294 ix++; 2295 uptr = (xmlChar *)&rptr[ix]; 2296 } 2297 2298 /* 2299 * In base, count the number of '/' from the differing point 2300 */ 2301 if (bptr[pos] != rptr[pos]) {/* check for trivial URI == base */ 2302 for (; bptr[ix] != 0; ix++) { 2303 if (bptr[ix] == '/') 2304 nbslash++; 2305 } 2306 } 2307 len = xmlStrlen (uptr) + 1; 2308 } 2309 2310 if (nbslash == 0) { 2311 if (uptr != NULL) 2312 /* exception characters from xmlSaveUri */ 2313 val = xmlURIEscapeStr(uptr, BAD_CAST "/;&=+$,"); 2314 goto done; 2315 } 2316 2317 /* 2318 * Allocate just enough space for the returned string - 2319 * length of the remainder of the URI, plus enough space 2320 * for the "../" groups, plus one for the terminator 2321 */ 2322 val = (xmlChar *) xmlMalloc (len + 3 * nbslash); 2323 if (val == NULL) { 2324 xmlURIErrMemory("building relative URI\n"); 2325 goto done; 2326 } 2327 vptr = val; 2328 /* 2329 * Put in as many "../" as needed 2330 */ 2331 for (; nbslash>0; nbslash--) { 2332 *vptr++ = '.'; 2333 *vptr++ = '.'; 2334 *vptr++ = '/'; 2335 } 2336 /* 2337 * Finish up with the end of the URI 2338 */ 2339 if (uptr != NULL) { 2340 if ((vptr > val) && (len > 0) && 2341 (uptr[0] == '/') && (vptr[-1] == '/')) { 2342 memcpy (vptr, uptr + 1, len - 1); 2343 vptr[len - 2] = 0; 2344 } else { 2345 memcpy (vptr, uptr, len); 2346 vptr[len - 1] = 0; 2347 } 2348 } else { 2349 vptr[len - 1] = 0; 2350 } 2351 2352 /* escape the freshly-built path */ 2353 vptr = val; 2354 /* exception characters from xmlSaveUri */ 2355 val = xmlURIEscapeStr(vptr, BAD_CAST "/;&=+$,"); 2356 xmlFree(vptr); 2357 2358 done: 2359 /* 2360 * Free the working variables 2361 */ 2362 if (remove_path != 0) 2363 ref->path = NULL; 2364 if (ref != NULL) 2365 xmlFreeURI (ref); 2366 if (bas != NULL) 2367 xmlFreeURI (bas); 2368 2369 return val; 2370 } 2371 2372 /** 2373 * xmlCanonicPath: 2374 * @path: the resource locator in a filesystem notation 2375 * 2376 * Constructs a canonic path from the specified path. 2377 * 2378 * Returns a new canonic path, or a duplicate of the path parameter if the 2379 * construction fails. The caller is responsible for freeing the memory occupied 2380 * by the returned string. If there is insufficient memory available, or the 2381 * argument is NULL, the function returns NULL. 2382 */ 2383 #define IS_WINDOWS_PATH(p) \ 2384 ((p != NULL) && \ 2385 (((p[0] >= 'a') && (p[0] <= 'z')) || \ 2386 ((p[0] >= 'A') && (p[0] <= 'Z'))) && \ 2387 (p[1] == ':') && ((p[2] == '/') || (p[2] == '\\'))) 2388 xmlChar * 2389 xmlCanonicPath(const xmlChar *path) 2390 { 2391 /* 2392 * For Windows implementations, additional work needs to be done to 2393 * replace backslashes in pathnames with "forward slashes" 2394 */ 2395 #if defined(_WIN32) && !defined(__CYGWIN__) 2396 int len = 0; 2397 char *p = NULL; 2398 #endif 2399 xmlURIPtr uri; 2400 xmlChar *ret; 2401 const xmlChar *absuri; 2402 2403 if (path == NULL) 2404 return(NULL); 2405 2406 #if defined(_WIN32) 2407 /* 2408 * We must not change the backslashes to slashes if the the path 2409 * starts with \\?\ 2410 * Those paths can be up to 32k characters long. 2411 * Was added specifically for OpenOffice, those paths can't be converted 2412 * to URIs anyway. 2413 */ 2414 if ((path[0] == '\\') && (path[1] == '\\') && (path[2] == '?') && 2415 (path[3] == '\\') ) 2416 return xmlStrdup((const xmlChar *) path); 2417 #endif 2418 2419 /* sanitize filename starting with // so it can be used as URI */ 2420 if ((path[0] == '/') && (path[1] == '/') && (path[2] != '/')) 2421 path++; 2422 2423 if ((uri = xmlParseURI((const char *) path)) != NULL) { 2424 xmlFreeURI(uri); 2425 return xmlStrdup(path); 2426 } 2427 2428 /* Check if this is an "absolute uri" */ 2429 absuri = xmlStrstr(path, BAD_CAST "://"); 2430 if (absuri != NULL) { 2431 int l, j; 2432 unsigned char c; 2433 xmlChar *escURI; 2434 2435 /* 2436 * this looks like an URI where some parts have not been 2437 * escaped leading to a parsing problem. Check that the first 2438 * part matches a protocol. 2439 */ 2440 l = absuri - path; 2441 /* Bypass if first part (part before the '://') is > 20 chars */ 2442 if ((l <= 0) || (l > 20)) 2443 goto path_processing; 2444 /* Bypass if any non-alpha characters are present in first part */ 2445 for (j = 0;j < l;j++) { 2446 c = path[j]; 2447 if (!(((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z')))) 2448 goto path_processing; 2449 } 2450 2451 /* Escape all except the characters specified in the supplied path */ 2452 escURI = xmlURIEscapeStr(path, BAD_CAST ":/?_.#&;="); 2453 if (escURI != NULL) { 2454 /* Try parsing the escaped path */ 2455 uri = xmlParseURI((const char *) escURI); 2456 /* If successful, return the escaped string */ 2457 if (uri != NULL) { 2458 xmlFreeURI(uri); 2459 return escURI; 2460 } 2461 xmlFree(escURI); 2462 } 2463 } 2464 2465 path_processing: 2466 /* For Windows implementations, replace backslashes with 'forward slashes' */ 2467 #if defined(_WIN32) && !defined(__CYGWIN__) 2468 /* 2469 * Create a URI structure 2470 */ 2471 uri = xmlCreateURI(); 2472 if (uri == NULL) { /* Guard against 'out of memory' */ 2473 return(NULL); 2474 } 2475 2476 len = xmlStrlen(path); 2477 if ((len > 2) && IS_WINDOWS_PATH(path)) { 2478 /* make the scheme 'file' */ 2479 uri->scheme = (char *) xmlStrdup(BAD_CAST "file"); 2480 /* allocate space for leading '/' + path + string terminator */ 2481 uri->path = xmlMallocAtomic(len + 2); 2482 if (uri->path == NULL) { 2483 xmlFreeURI(uri); /* Guard agains 'out of memory' */ 2484 return(NULL); 2485 } 2486 /* Put in leading '/' plus path */ 2487 uri->path[0] = '/'; 2488 p = uri->path + 1; 2489 strncpy(p, (char *) path, len + 1); 2490 } else { 2491 uri->path = (char *) xmlStrdup(path); 2492 if (uri->path == NULL) { 2493 xmlFreeURI(uri); 2494 return(NULL); 2495 } 2496 p = uri->path; 2497 } 2498 /* Now change all occurences of '\' to '/' */ 2499 while (*p != '\0') { 2500 if (*p == '\\') 2501 *p = '/'; 2502 p++; 2503 } 2504 2505 if (uri->scheme == NULL) { 2506 ret = xmlStrdup((const xmlChar *) uri->path); 2507 } else { 2508 ret = xmlSaveUri(uri); 2509 } 2510 2511 xmlFreeURI(uri); 2512 #else 2513 ret = xmlStrdup((const xmlChar *) path); 2514 #endif 2515 return(ret); 2516 } 2517 2518 /** 2519 * xmlPathToURI: 2520 * @path: the resource locator in a filesystem notation 2521 * 2522 * Constructs an URI expressing the existing path 2523 * 2524 * Returns a new URI, or a duplicate of the path parameter if the 2525 * construction fails. The caller is responsible for freeing the memory 2526 * occupied by the returned string. If there is insufficient memory available, 2527 * or the argument is NULL, the function returns NULL. 2528 */ 2529 xmlChar * 2530 xmlPathToURI(const xmlChar *path) 2531 { 2532 xmlURIPtr uri; 2533 xmlURI temp; 2534 xmlChar *ret, *cal; 2535 2536 if (path == NULL) 2537 return(NULL); 2538 2539 if ((uri = xmlParseURI((const char *) path)) != NULL) { 2540 xmlFreeURI(uri); 2541 return xmlStrdup(path); 2542 } 2543 cal = xmlCanonicPath(path); 2544 if (cal == NULL) 2545 return(NULL); 2546 #if defined(_WIN32) && !defined(__CYGWIN__) 2547 /* xmlCanonicPath can return an URI on Windows (is that the intended behaviour?) 2548 If 'cal' is a valid URI allready then we are done here, as continuing would make 2549 it invalid. */ 2550 if ((uri = xmlParseURI((const char *) cal)) != NULL) { 2551 xmlFreeURI(uri); 2552 return cal; 2553 } 2554 /* 'cal' can contain a relative path with backslashes. If that is processed 2555 by xmlSaveURI, they will be escaped and the external entity loader machinery 2556 will fail. So convert them to slashes. Misuse 'ret' for walking. */ 2557 ret = cal; 2558 while (*ret != '\0') { 2559 if (*ret == '\\') 2560 *ret = '/'; 2561 ret++; 2562 } 2563 #endif 2564 memset(&temp, 0, sizeof(temp)); 2565 temp.path = (char *) cal; 2566 ret = xmlSaveUri(&temp); 2567 xmlFree(cal); 2568 return(ret); 2569 } 2570 #define bottom_uri 2571 #include "elfgcchack.h" 2572
