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