util/uri.c

   1 /**
   2  * uri.c: set of generic URI related routines
   3  *
   4  * Reference: RFCs 3986, 2732 and 2373
   5  *
   6  * Copyright (C) 1998-2003 Daniel Veillard.  All Rights Reserved.
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a copy
   9  * of this software and associated documentation files (the "Software"), to deal
  10  * in the Software without restriction, including without limitation the rights
  11  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  12  * copies of the Software, and to permit persons to whom the Software is
  13  * furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be included in
  16  * all copies or substantial portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  21  * DANIEL VEILLARD BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
  22  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  23  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24  *
  25  * Except as contained in this notice, the name of Daniel Veillard shall not
  26  * be used in advertising or otherwise to promote the sale, use or other
  27  * dealings in this Software without prior written authorization from him.
  28  *
  29  * daniel@veillard.com
  30  *
  31  **
  32  *
  33  * Copyright (C) 2007, 2009-2010 Red Hat, Inc.
  34  *
  35  * This library is free software; you can redistribute it and/or
  36  * modify it under the terms of the GNU Lesser General Public
  37  * License as published by the Free Software Foundation; either
  38  * version 2.1 of the License, or (at your option) any later version.
  39  *
  40  * This library is distributed in the hope that it will be useful,
  41  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  42  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  43  * Lesser General Public License for more details.
  44  *
  45  * You should have received a copy of the GNU Lesser General Public
  46  * License along with this library; if not, write to the Free Software
  47  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
  48  *
  49  * Authors:
  50  *    Richard W.M. Jones <rjones@redhat.com>
  51  *
  52  */
  53
  54 #include "qemu/osdep.h"
  55
  56 #include "qemu/uri.h"
  57
  58 static void uri_clean(URI *uri);
  59
  60 /*
  61  * Old rule from 2396 used in legacy handling code
  62  * alpha    = lowalpha | upalpha
  63  */
  64 #define IS_ALPHA(x) (IS_LOWALPHA(x) || IS_UPALPHA(x))
  65
  66
  67 /*
  68  * lowalpha = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" |
  69  *            "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" |
  70  *            "u" | "v" | "w" | "x" | "y" | "z"
  71  */
  72
  73 #define IS_LOWALPHA(x) (((x) >= 'a') && ((x) <= 'z'))
  74
  75 /*
  76  * upalpha = "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" |
  77  *           "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" |
  78  *           "U" | "V" | "W" | "X" | "Y" | "Z"
  79  */
  80 #define IS_UPALPHA(x) (((x) >= 'A') && ((x) <= 'Z'))
  81
  82 #ifdef IS_DIGIT
  83 #undef IS_DIGIT
  84 #endif
  85 /*
  86  * digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"
  87  */
  88 #define IS_DIGIT(x) (((x) >= '0') && ((x) <= '9'))
  89
  90 /*
  91  * alphanum = alpha | digit
  92  */
  93
  94 #define IS_ALPHANUM(x) (IS_ALPHA(x) || IS_DIGIT(x))
  95
  96 /*
  97  * mark = "-" | "_" | "." | "!" | "~" | "*" | "'" | "(" | ")"
  98  */
  99
 100 #define IS_MARK(x) (((x) == '-') || ((x) == '_') || ((x) == '.') ||     \
 101     ((x) == '!') || ((x) == '~') || ((x) == '*') || ((x) == '\'') ||    \
 102     ((x) == '(') || ((x) == ')'))
 103
 104 /*
 105  * unwise = "{" | "}" | "|" | "\" | "^" | "`"
 106  */
 107
 108 #define IS_UNWISE(p)                                                    \
 109       (((*(p) == '{')) || ((*(p) == '}')) || ((*(p) == '|')) ||         \
 110        ((*(p) == '\\')) || ((*(p) == '^')) || ((*(p) == '[')) ||        \
 111        ((*(p) == ']')) || ((*(p) == '`')))
 112 /*
 113  * reserved = ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" | "$" | "," |
 114  *            "[" | "]"
 115  */
 116
 117 #define IS_RESERVED(x) (((x) == ';') || ((x) == '/') || ((x) == '?') || \
 118         ((x) == ':') || ((x) == '@') || ((x) == '&') || ((x) == '=') || \
 119         ((x) == '+') || ((x) == '$') || ((x) == ',') || ((x) == '[') || \
 120         ((x) == ']'))
 121
 122 /*
 123  * unreserved = alphanum | mark
 124  */
 125
 126 #define IS_UNRESERVED(x) (IS_ALPHANUM(x) || IS_MARK(x))
 127
 128 /*
 129  * Skip to next pointer char, handle escaped sequences
 130  */
 131
 132 #define NEXT(p) ((*p == '%')? p += 3 : p++)
 133
 134 /*
 135  * Productions from the spec.
 136  *
 137  *    authority     = server | reg_name
 138  *    reg_name      = 1*( unreserved | escaped | "$" | "," |
 139  *                        ";" | ":" | "@" | "&" | "=" | "+" )
 140  *
 141  * path          = [ abs_path | opaque_part ]
 142  */
 143
 144
 145 /************************************************************************
 146  *                                                                      *
 147  *                         RFC 3986 parser                              *
 148  *                                                                      *
 149  ************************************************************************/
 150
 151 #define ISA_DIGIT(p) ((*(p) >= '0') && (*(p) <= '9'))
 152 #define ISA_ALPHA(p) (((*(p) >= 'a') && (*(p) <= 'z')) ||               \
 153                       ((*(p) >= 'A') && (*(p) <= 'Z')))
 154 #define ISA_HEXDIG(p)                                                   \
 155        (ISA_DIGIT(p) || ((*(p) >= 'a') && (*(p) <= 'f')) ||             \
 156         ((*(p) >= 'A') && (*(p) <= 'F')))
 157
 158 /*
 159  *    sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
 160  *                     / "*" / "+" / "," / ";" / "="
 161  */
 162 #define ISA_SUB_DELIM(p)                                                \
 163       (((*(p) == '!')) || ((*(p) == '$')) || ((*(p) == '&')) ||         \
 164        ((*(p) == '(')) || ((*(p) == ')')) || ((*(p) == '*')) ||         \
 165        ((*(p) == '+')) || ((*(p) == ',')) || ((*(p) == ';')) ||         \
 166        ((*(p) == '=')) || ((*(p) == '\'')))
 167
 168 /*
 169  *    gen-delims    = ":" / "/" / "?" / "#" / "[" / "]" / "@"
 170  */
 171 #define ISA_GEN_DELIM(p)                                                \
 172       (((*(p) == ':')) || ((*(p) == '/')) || ((*(p) == '?')) ||         \
 173        ((*(p) == '#')) || ((*(p) == '[')) || ((*(p) == ']')) ||         \
 174        ((*(p) == '@')))
 175
 176 /*
 177  *    reserved      = gen-delims / sub-delims
 178  */
 179 #define ISA_RESERVED(p) (ISA_GEN_DELIM(p) || (ISA_SUB_DELIM(p)))
 180
 181 /*
 182  *    unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
 183  */
 184 #define ISA_UNRESERVED(p)                                               \
 185       ((ISA_ALPHA(p)) || (ISA_DIGIT(p)) || ((*(p) == '-')) ||           \
 186        ((*(p) == '.')) || ((*(p) == '_')) || ((*(p) == '~')))
 187
 188 /*
 189  *    pct-encoded   = "%" HEXDIG HEXDIG
 190  */
 191 #define ISA_PCT_ENCODED(p)                                              \
 192      ((*(p) == '%') && (ISA_HEXDIG(p + 1)) && (ISA_HEXDIG(p + 2)))
 193
 194 /*
 195  *    pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
 196  */
 197 #define ISA_PCHAR(p)                                                    \
 198      (ISA_UNRESERVED(p) || ISA_PCT_ENCODED(p) || ISA_SUB_DELIM(p) ||    \
 199       ((*(p) == ':')) || ((*(p) == '@')))
 200
 201 /**
 202  * rfc3986_parse_scheme:
 203  * @uri:  pointer to an URI structure
 204  * @str:  pointer to the string to analyze
 205  *
 206  * Parse an URI scheme
 207  *
 208  * ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
 209  *
 210  * Returns 0 or the error code
 211  */
 212 static int
 213 rfc3986_parse_scheme(URI *uri, const char **str) {
 214     const char *cur;
 215
 216     if (str == NULL)
 217         return(-1);
 218
 219     cur = *str;
 220     if (!ISA_ALPHA(cur))
 221         return(2);
 222     cur++;
 223     while (ISA_ALPHA(cur) || ISA_DIGIT(cur) ||
 224            (*cur == '+') || (*cur == '-') || (*cur == '.')) cur++;
 225     if (uri != NULL) {
 226         g_free(uri->scheme);
 227         uri->scheme = g_strndup(*str, cur - *str);
 228     }
 229     *str = cur;
 230     return(0);
 231 }
 232
 233 /**
 234  * rfc3986_parse_fragment:
 235  * @uri:  pointer to an URI structure
 236  * @str:  pointer to the string to analyze
 237  *
 238  * Parse the query part of an URI
 239  *
 240  * fragment      = *( pchar / "/" / "?" )
 241  * NOTE: the strict syntax as defined by 3986 does not allow '[' and ']'
 242  *       in the fragment identifier but this is used very broadly for
 243  *       xpointer scheme selection, so we are allowing it here to not break
 244  *       for example all the DocBook processing chains.
 245  *
 246  * Returns 0 or the error code
 247  */
 248 static int
 249 rfc3986_parse_fragment(URI *uri, const char **str)
 250 {
 251     const char *cur;
 252
 253     if (str == NULL)
 254         return (-1);
 255
 256     cur = *str;
 257
 258     while ((ISA_PCHAR(cur)) || (*cur == '/') || (*cur == '?') ||
 259            (*cur == '[') || (*cur == ']') ||
 260            ((uri != NULL) && (uri->cleanup & 1) && (IS_UNWISE(cur))))
 261         NEXT(cur);
 262     if (uri != NULL) {
 263         g_free(uri->fragment);
 264         if (uri->cleanup & 2)
 265             uri->fragment = g_strndup(*str, cur - *str);
 266         else
 267             uri->fragment = uri_string_unescape(*str, cur - *str, NULL);
 268     }
 269     *str = cur;
 270     return (0);
 271 }
 272
 273 /**
 274  * rfc3986_parse_query:
 275  * @uri:  pointer to an URI structure
 276  * @str:  pointer to the string to analyze
 277  *
 278  * Parse the query part of an URI
 279  *
 280  * query = *uric
 281  *
 282  * Returns 0 or the error code
 283  */
 284 static int
 285 rfc3986_parse_query(URI *uri, const char **str)
 286 {
 287     const char *cur;
 288
 289     if (str == NULL)
 290         return (-1);
 291
 292     cur = *str;
 293
 294     while ((ISA_PCHAR(cur)) || (*cur == '/') || (*cur == '?') ||
 295            ((uri != NULL) && (uri->cleanup & 1) && (IS_UNWISE(cur))))
 296         NEXT(cur);
 297     if (uri != NULL) {
 298         g_free(uri->query);
 299         uri->query = g_strndup (*str, cur - *str);
 300     }
 301     *str = cur;
 302     return (0);
 303 }
 304
 305 /**
 306  * rfc3986_parse_port:
 307  * @uri:  pointer to an URI structure
 308  * @str:  the string to analyze
 309  *
 310  * Parse a port  part and fills in the appropriate fields
 311  * of the @uri structure
 312  *
 313  * port          = *DIGIT
 314  *
 315  * Returns 0 or the error code
 316  */
 317 static int
 318 rfc3986_parse_port(URI *uri, const char **str)
 319 {
 320     const char *cur = *str;
 321     int port = 0;
 322
 323     if (ISA_DIGIT(cur)) {
 324         while (ISA_DIGIT(cur)) {
 325             port = port * 10 + (*cur - '0');
 326             if (port > 65535) {
 327                 return 1;
 328             }
 329             cur++;
 330         }
 331         if (uri) {
 332             uri->port = port;
 333         }
 334         *str = cur;
 335         return 0;
 336     }
 337     return 1;
 338 }
 339
 340 /**
 341  * rfc3986_parse_user_info:
 342  * @uri:  pointer to an URI structure
 343  * @str:  the string to analyze
 344  *
 345  * Parse an user informations part and fills in the appropriate fields
 346  * of the @uri structure
 347  *
 348  * userinfo      = *( unreserved / pct-encoded / sub-delims / ":" )
 349  *
 350  * Returns 0 or the error code
 351  */
 352 static int
 353 rfc3986_parse_user_info(URI *uri, const char **str)
 354 {
 355     const char *cur;
 356
 357     cur = *str;
 358     while (ISA_UNRESERVED(cur) || ISA_PCT_ENCODED(cur) ||
 359            ISA_SUB_DELIM(cur) || (*cur == ':'))
 360         NEXT(cur);
 361     if (*cur == '@') {
 362         if (uri != NULL) {
 363             g_free(uri->user);
 364             if (uri->cleanup & 2)
 365                 uri->user = g_strndup(*str, cur - *str);
 366             else
 367                 uri->user = uri_string_unescape(*str, cur - *str, NULL);
 368         }
 369         *str = cur;
 370         return(0);
 371     }
 372     return(1);
 373 }
 374
 375 /**
 376  * rfc3986_parse_dec_octet:
 377  * @str:  the string to analyze
 378  *
 379  *    dec-octet     = DIGIT                 ; 0-9
 380  *                  / %x31-39 DIGIT         ; 10-99
 381  *                  / "1" 2DIGIT            ; 100-199
 382  *                  / "2" %x30-34 DIGIT     ; 200-249
 383  *                  / "25" %x30-35          ; 250-255
 384  *
 385  * Skip a dec-octet.
 386  *
 387  * Returns 0 if found and skipped, 1 otherwise
 388  */
 389 static int
 390 rfc3986_parse_dec_octet(const char **str) {
 391     const char *cur = *str;
 392
 393     if (!(ISA_DIGIT(cur)))
 394         return(1);
 395     if (!ISA_DIGIT(cur+1))
 396         cur++;
 397     else if ((*cur != '0') && (ISA_DIGIT(cur + 1)) && (!ISA_DIGIT(cur+2)))
 398         cur += 2;
 399     else if ((*cur == '1') && (ISA_DIGIT(cur + 1)) && (ISA_DIGIT(cur + 2)))
 400         cur += 3;
 401     else if ((*cur == '2') && (*(cur + 1) >= '0') &&
 402              (*(cur + 1) <= '4') && (ISA_DIGIT(cur + 2)))
 403         cur += 3;
 404     else if ((*cur == '2') && (*(cur + 1) == '5') &&
 405              (*(cur + 2) >= '0') && (*(cur + 1) <= '5'))
 406         cur += 3;
 407     else
 408         return(1);
 409     *str = cur;
 410     return(0);
 411 }
 412 /**
 413  * rfc3986_parse_host:
 414  * @uri:  pointer to an URI structure
 415  * @str:  the string to analyze
 416  *
 417  * Parse an host part and fills in the appropriate fields
 418  * of the @uri structure
 419  *
 420  * host          = IP-literal / IPv4address / reg-name
 421  * IP-literal    = "[" ( IPv6address / IPvFuture  ) "]"
 422  * IPv4address   = dec-octet "." dec-octet "." dec-octet "." dec-octet
 423  * reg-name      = *( unreserved / pct-encoded / sub-delims )
 424  *
 425  * Returns 0 or the error code
 426  */
 427 static int
 428 rfc3986_parse_host(URI *uri, const char **str)
 429 {
 430     const char *cur = *str;
 431     const char *host;
 432
 433     host = cur;
 434     /*
 435      * IPv6 and future addressing scheme are enclosed between brackets
 436      */
 437     if (*cur == '[') {
 438         cur++;
 439         while ((*cur != ']') && (*cur != 0))
 440             cur++;
 441         if (*cur != ']')
 442             return(1);
 443         cur++;
 444         goto found;
 445     }
 446     /*
 447      * try to parse an IPv4
 448      */
 449     if (ISA_DIGIT(cur)) {
 450         if (rfc3986_parse_dec_octet(&cur) != 0)
 451             goto not_ipv4;
 452         if (*cur != '.')
 453             goto not_ipv4;
 454         cur++;
 455         if (rfc3986_parse_dec_octet(&cur) != 0)
 456             goto not_ipv4;
 457         if (*cur != '.')
 458             goto not_ipv4;
 459         if (rfc3986_parse_dec_octet(&cur) != 0)
 460             goto not_ipv4;
 461         if (*cur != '.')
 462             goto not_ipv4;
 463         if (rfc3986_parse_dec_octet(&cur) != 0)
 464             goto not_ipv4;
 465         goto found;
 466 not_ipv4:
 467         cur = *str;
 468     }
 469     /*
 470      * then this should be a hostname which can be empty
 471      */
 472     while (ISA_UNRESERVED(cur) || ISA_PCT_ENCODED(cur) || ISA_SUB_DELIM(cur))
 473         NEXT(cur);
 474 found:
 475     if (uri != NULL) {
 476         g_free(uri->authority);
 477         uri->authority = NULL;
 478         g_free(uri->server);
 479         if (cur != host) {
 480             if (uri->cleanup & 2)
 481                 uri->server = g_strndup(host, cur - host);
 482             else
 483                 uri->server = uri_string_unescape(host, cur - host, NULL);
 484         } else
 485             uri->server = NULL;
 486     }
 487     *str = cur;
 488     return(0);
 489 }
 490
 491 /**
 492  * rfc3986_parse_authority:
 493  * @uri:  pointer to an URI structure
 494  * @str:  the string to analyze
 495  *
 496  * Parse an authority part and fills in the appropriate fields
 497  * of the @uri structure
 498  *
 499  * authority     = [ userinfo "@" ] host [ ":" port ]
 500  *
 501  * Returns 0 or the error code
 502  */
 503 static int
 504 rfc3986_parse_authority(URI *uri, const char **str)
 505 {
 506     const char *cur;
 507     int ret;
 508
 509     cur = *str;
 510     /*
 511      * try to parse an userinfo and check for the trailing @
 512      */
 513     ret = rfc3986_parse_user_info(uri, &cur);
 514     if ((ret != 0) || (*cur != '@'))
 515         cur = *str;
 516     else
 517         cur++;
 518     ret = rfc3986_parse_host(uri, &cur);
 519     if (ret != 0) return(ret);
 520     if (*cur == ':') {
 521         cur++;
 522         ret = rfc3986_parse_port(uri, &cur);
 523         if (ret != 0) return(ret);
 524     }
 525     *str = cur;
 526     return(0);
 527 }
 528
 529 /**
 530  * rfc3986_parse_segment:
 531  * @str:  the string to analyze
 532  * @forbid: an optional forbidden character
 533  * @empty: allow an empty segment
 534  *
 535  * Parse a segment and fills in the appropriate fields
 536  * of the @uri structure
 537  *
 538  * segment       = *pchar
 539  * segment-nz    = 1*pchar
 540  * segment-nz-nc = 1*( unreserved / pct-encoded / sub-delims / "@" )
 541  *               ; non-zero-length segment without any colon ":"
 542  *
 543  * Returns 0 or the error code
 544  */
 545 static int
 546 rfc3986_parse_segment(const char **str, char forbid, int empty)
 547 {
 548     const char *cur;
 549
 550     cur = *str;
 551     if (!ISA_PCHAR(cur)) {
 552         if (empty)
 553             return(0);
 554         return(1);
 555     }
 556     while (ISA_PCHAR(cur) && (*cur != forbid))
 557         NEXT(cur);
 558     *str = cur;
 559     return (0);
 560 }
 561
 562 /**
 563  * rfc3986_parse_path_ab_empty:
 564  * @uri:  pointer to an URI structure
 565  * @str:  the string to analyze
 566  *
 567  * Parse an path absolute or empty and fills in the appropriate fields
 568  * of the @uri structure
 569  *
 570  * path-abempty  = *( "/" segment )
 571  *
 572  * Returns 0 or the error code
 573  */
 574 static int
 575 rfc3986_parse_path_ab_empty(URI *uri, const char **str)
 576 {
 577     const char *cur;
 578     int ret;
 579
 580     cur = *str;
 581
 582     while (*cur == '/') {
 583         cur++;
 584         ret = rfc3986_parse_segment(&cur, 0, 1);
 585         if (ret != 0) return(ret);
 586     }
 587     if (uri != NULL) {
 588         g_free(uri->path);
 589         if (*str != cur) {
 590             if (uri->cleanup & 2)
 591                 uri->path = g_strndup(*str, cur - *str);
 592             else
 593                 uri->path = uri_string_unescape(*str, cur - *str, NULL);
 594         } else {
 595             uri->path = NULL;
 596         }
 597     }
 598     *str = cur;
 599     return (0);
 600 }
 601
 602 /**
 603  * rfc3986_parse_path_absolute:
 604  * @uri:  pointer to an URI structure
 605  * @str:  the string to analyze
 606  *
 607  * Parse an path absolute and fills in the appropriate fields
 608  * of the @uri structure
 609  *
 610  * path-absolute = "/" [ segment-nz *( "/" segment ) ]
 611  *
 612  * Returns 0 or the error code
 613  */
 614 static int
 615 rfc3986_parse_path_absolute(URI *uri, const char **str)
 616 {
 617     const char *cur;
 618     int ret;
 619
 620     cur = *str;
 621
 622     if (*cur != '/')
 623         return(1);
 624     cur++;
 625     ret = rfc3986_parse_segment(&cur, 0, 0);
 626     if (ret == 0) {
 627         while (*cur == '/') {
 628             cur++;
 629             ret = rfc3986_parse_segment(&cur, 0, 1);
 630             if (ret != 0) return(ret);
 631         }
 632     }
 633     if (uri != NULL) {
 634         g_free(uri->path);
 635         if (cur != *str) {
 636             if (uri->cleanup & 2)
 637                 uri->path = g_strndup(*str, cur - *str);
 638             else
 639                 uri->path = uri_string_unescape(*str, cur - *str, NULL);
 640         } else {
 641             uri->path = NULL;
 642         }
 643     }
 644     *str = cur;
 645     return (0);
 646 }
 647
 648 /**
 649  * rfc3986_parse_path_rootless:
 650  * @uri:  pointer to an URI structure
 651  * @str:  the string to analyze
 652  *
 653  * Parse an path without root and fills in the appropriate fields
 654  * of the @uri structure
 655  *
 656  * path-rootless = segment-nz *( "/" segment )
 657  *
 658  * Returns 0 or the error code
 659  */
 660 static int
 661 rfc3986_parse_path_rootless(URI *uri, const char **str)
 662 {
 663     const char *cur;
 664     int ret;
 665
 666     cur = *str;
 667
 668     ret = rfc3986_parse_segment(&cur, 0, 0);
 669     if (ret != 0) return(ret);
 670     while (*cur == '/') {
 671         cur++;
 672         ret = rfc3986_parse_segment(&cur, 0, 1);
 673         if (ret != 0) return(ret);
 674     }
 675     if (uri != NULL) {
 676         g_free(uri->path);
 677         if (cur != *str) {
 678             if (uri->cleanup & 2)
 679                 uri->path = g_strndup(*str, cur - *str);
 680             else
 681                 uri->path = uri_string_unescape(*str, cur - *str, NULL);
 682         } else {
 683             uri->path = NULL;
 684         }
 685     }
 686     *str = cur;
 687     return (0);
 688 }
 689
 690 /**
 691  * rfc3986_parse_path_no_scheme:
 692  * @uri:  pointer to an URI structure
 693  * @str:  the string to analyze
 694  *
 695  * Parse an path which is not a scheme and fills in the appropriate fields
 696  * of the @uri structure
 697  *
 698  * path-noscheme = segment-nz-nc *( "/" segment )
 699  *
 700  * Returns 0 or the error code
 701  */
 702 static int
 703 rfc3986_parse_path_no_scheme(URI *uri, const char **str)
 704 {
 705     const char *cur;
 706     int ret;
 707
 708     cur = *str;
 709
 710     ret = rfc3986_parse_segment(&cur, ':', 0);
 711     if (ret != 0) return(ret);
 712     while (*cur == '/') {
 713         cur++;
 714         ret = rfc3986_parse_segment(&cur, 0, 1);
 715         if (ret != 0) return(ret);
 716     }
 717     if (uri != NULL) {
 718         g_free(uri->path);
 719         if (cur != *str) {
 720             if (uri->cleanup & 2)
 721                 uri->path = g_strndup(*str, cur - *str);
 722             else
 723                 uri->path = uri_string_unescape(*str, cur - *str, NULL);
 724         } else {
 725             uri->path = NULL;
 726         }
 727     }
 728     *str = cur;
 729     return (0);
 730 }
 731
 732 /**
 733  * rfc3986_parse_hier_part:
 734  * @uri:  pointer to an URI structure
 735  * @str:  the string to analyze
 736  *
 737  * Parse an hierarchical part and fills in the appropriate fields
 738  * of the @uri structure
 739  *
 740  * hier-part     = "//" authority path-abempty
 741  *                / path-absolute
 742  *                / path-rootless
 743  *                / path-empty
 744  *
 745  * Returns 0 or the error code
 746  */
 747 static int
 748 rfc3986_parse_hier_part(URI *uri, const char **str)
 749 {
 750     const char *cur;
 751     int ret;
 752
 753     cur = *str;
 754
 755     if ((*cur == '/') && (*(cur + 1) == '/')) {
 756         cur += 2;
 757         ret = rfc3986_parse_authority(uri, &cur);
 758         if (ret != 0) return(ret);
 759         ret = rfc3986_parse_path_ab_empty(uri, &cur);
 760         if (ret != 0) return(ret);
 761         *str = cur;
 762         return(0);
 763     } else if (*cur == '/') {
 764         ret = rfc3986_parse_path_absolute(uri, &cur);
 765         if (ret != 0) return(ret);
 766     } else if (ISA_PCHAR(cur)) {
 767         ret = rfc3986_parse_path_rootless(uri, &cur);
 768         if (ret != 0) return(ret);
 769     } else {
 770         /* path-empty is effectively empty */
 771         if (uri != NULL) {
 772             g_free(uri->path);
 773             uri->path = NULL;
 774         }
 775     }
 776     *str = cur;
 777     return (0);
 778 }
 779
 780 /**
 781  * rfc3986_parse_relative_ref:
 782  * @uri:  pointer to an URI structure
 783  * @str:  the string to analyze
 784  *
 785  * Parse an URI string and fills in the appropriate fields
 786  * of the @uri structure
 787  *
 788  * relative-ref  = relative-part [ "?" query ] [ "#" fragment ]
 789  * relative-part = "//" authority path-abempty
 790  *               / path-absolute
 791  *               / path-noscheme
 792  *               / path-empty
 793  *
 794  * Returns 0 or the error code
 795  */
 796 static int
 797 rfc3986_parse_relative_ref(URI *uri, const char *str) {
 798     int ret;
 799
 800     if ((*str == '/') && (*(str + 1) == '/')) {
 801         str += 2;
 802         ret = rfc3986_parse_authority(uri, &str);
 803         if (ret != 0) return(ret);
 804         ret = rfc3986_parse_path_ab_empty(uri, &str);
 805         if (ret != 0) return(ret);
 806     } else if (*str == '/') {
 807         ret = rfc3986_parse_path_absolute(uri, &str);
 808         if (ret != 0) return(ret);
 809     } else if (ISA_PCHAR(str)) {
 810         ret = rfc3986_parse_path_no_scheme(uri, &str);
 811         if (ret != 0) return(ret);
 812     } else {
 813         /* path-empty is effectively empty */
 814         if (uri != NULL) {
 815             g_free(uri->path);
 816             uri->path = NULL;
 817         }
 818     }
 819
 820     if (*str == '?') {
 821         str++;
 822         ret = rfc3986_parse_query(uri, &str);
 823         if (ret != 0) return(ret);
 824     }
 825     if (*str == '#') {
 826         str++;
 827         ret = rfc3986_parse_fragment(uri, &str);
 828         if (ret != 0) return(ret);
 829     }
 830     if (*str != 0) {
 831         uri_clean(uri);
 832         return(1);
 833     }
 834     return(0);
 835 }
 836
 837
 838 /**
 839  * rfc3986_parse:
 840  * @uri:  pointer to an URI structure
 841  * @str:  the string to analyze
 842  *
 843  * Parse an URI string and fills in the appropriate fields
 844  * of the @uri structure
 845  *
 846  * scheme ":" hier-part [ "?" query ] [ "#" fragment ]
 847  *
 848  * Returns 0 or the error code
 849  */
 850 static int
 851 rfc3986_parse(URI *uri, const char *str) {
 852     int ret;
 853
 854     ret = rfc3986_parse_scheme(uri, &str);
 855     if (ret != 0) return(ret);
 856     if (*str != ':') {
 857         return(1);
 858     }
 859     str++;
 860     ret = rfc3986_parse_hier_part(uri, &str);
 861     if (ret != 0) return(ret);
 862     if (*str == '?') {
 863         str++;
 864         ret = rfc3986_parse_query(uri, &str);
 865         if (ret != 0) return(ret);
 866     }
 867     if (*str == '#') {
 868         str++;
 869         ret = rfc3986_parse_fragment(uri, &str);
 870         if (ret != 0) return(ret);
 871     }
 872     if (*str != 0) {
 873         uri_clean(uri);
 874         return(1);
 875     }
 876     return(0);
 877 }
 878
 879 /**
 880  * rfc3986_parse_uri_reference:
 881  * @uri:  pointer to an URI structure
 882  * @str:  the string to analyze
 883  *
 884  * Parse an URI reference string and fills in the appropriate fields
 885  * of the @uri structure
 886  *
 887  * URI-reference = URI / relative-ref
 888  *
 889  * Returns 0 or the error code
 890  */
 891 static int
 892 rfc3986_parse_uri_reference(URI *uri, const char *str) {
 893     int ret;
 894
 895     if (str == NULL)
 896         return(-1);
 897     uri_clean(uri);
 898
 899     /*
 900      * Try first to parse absolute refs, then fallback to relative if
 901      * it fails.
 902      */
 903     ret = rfc3986_parse(uri, str);
 904     if (ret != 0) {
 905         uri_clean(uri);
 906         ret = rfc3986_parse_relative_ref(uri, str);
 907         if (ret != 0) {
 908             uri_clean(uri);
 909             return(ret);
 910         }
 911     }
 912     return(0);
 913 }
 914
 915 /**
 916  * uri_parse:
 917  * @str:  the URI string to analyze
 918  *
 919  * Parse an URI based on RFC 3986
 920  *
 921  * URI-reference = [ absoluteURI | relativeURI ] [ "#" fragment ]
 922  *
 923  * Returns a newly built URI or NULL in case of error
 924  */
 925 URI *
 926 uri_parse(const char *str) {
 927     URI *uri;
 928     int ret;
 929
 930     if (str == NULL)
 931         return(NULL);
 932     uri = uri_new();
 933     ret = rfc3986_parse_uri_reference(uri, str);
 934     if (ret) {
 935         uri_free(uri);
 936         return(NULL);
 937     }
 938     return(uri);
 939 }
 940
 941 /**
 942  * uri_parse_into:
 943  * @uri:  pointer to an URI structure
 944  * @str:  the string to analyze
 945  *
 946  * Parse an URI reference string based on RFC 3986 and fills in the
 947  * appropriate fields of the @uri structure
 948  *
 949  * URI-reference = URI / relative-ref
 950  *
 951  * Returns 0 or the error code
 952  */
 953 int
 954 uri_parse_into(URI *uri, const char *str) {
 955     return(rfc3986_parse_uri_reference(uri, str));
 956 }
 957
 958 /**
 959  * uri_parse_raw:
 960  * @str:  the URI string to analyze
 961  * @raw:  if 1 unescaping of URI pieces are disabled
 962  *
 963  * Parse an URI but allows to keep intact the original fragments.
 964  *
 965  * URI-reference = URI / relative-ref
 966  *
 967  * Returns a newly built URI or NULL in case of error
 968  */
 969 URI *
 970 uri_parse_raw(const char *str, int raw) {
 971     URI *uri;
 972     int ret;
 973
 974     if (str == NULL)
 975         return(NULL);
 976     uri = uri_new();
 977     if (raw) {
 978         uri->cleanup |= 2;
 979     }
 980     ret = uri_parse_into(uri, str);
 981     if (ret) {
 982         uri_free(uri);
 983         return(NULL);
 984     }
 985     return(uri);
 986 }
 987
 988 /************************************************************************
 989  *                                                                      *
 990  *                      Generic URI structure functions                 *
 991  *                                                                      *
 992  ************************************************************************/
 993
 994 /**
 995  * uri_new:
 996  *
 997  * Simply creates an empty URI
 998  *
 999  * Returns the new structure or NULL in case of error
1000  */
1001 URI *
1002 uri_new(void) {
1003     URI *ret;
1004
1005     ret = g_new0(URI, 1);
1006     return(ret);
1007 }
1008
1009 /**
1010  * realloc2n:
1011  *
1012  * Function to handle properly a reallocation when saving an URI
1013  * Also imposes some limit on the length of an URI string output
1014  */
1015 static char *
1016 realloc2n(char *ret, int *max) {
1017     char *temp;
1018     int tmp;
1019
1020     tmp = *max * 2;
1021     temp = g_realloc(ret, (tmp + 1));
1022     *max = tmp;
1023     return(temp);
1024 }
1025
1026 /**
1027  * uri_to_string:
1028  * @uri:  pointer to an URI
1029  *
1030  * Save the URI as an escaped string
1031  *
1032  * Returns a new string (to be deallocated by caller)
1033  */
1034 char *
1035 uri_to_string(URI *uri) {
1036     char *ret = NULL;
1037     char *temp;
1038     const char *p;
1039     int len;
1040     int max;
1041
1042     if (uri == NULL) return(NULL);
1043
1044
1045     max = 80;
1046     ret = g_malloc(max + 1);
1047     len = 0;
1048
1049     if (uri->scheme != NULL) {
1050         p = uri->scheme;
1051         while (*p != 0) {
1052             if (len >= max) {
1053                 temp = realloc2n(ret, &max);
1054                 ret = temp;
1055             }
1056             ret[len++] = *p++;
1057         }
1058         if (len >= max) {
1059             temp = realloc2n(ret, &max);
1060             ret = temp;
1061         }
1062         ret[len++] = ':';
1063     }
1064     if (uri->opaque != NULL) {
1065         p = uri->opaque;
1066         while (*p != 0) {
1067             if (len + 3 >= max) {
1068                 temp = realloc2n(ret, &max);
1069                 ret = temp;
1070             }
1071             if (IS_RESERVED(*(p)) || IS_UNRESERVED(*(p)))
1072                 ret[len++] = *p++;
1073             else {
1074                 int val = *(unsigned char *)p++;
1075                 int hi = val / 0x10, lo = val % 0x10;
1076                 ret[len++] = '%';
1077                 ret[len++] = hi + (hi > 9? 'A'-10 : '0');
1078                 ret[len++] = lo + (lo > 9? 'A'-10 : '0');
1079             }
1080         }
1081     } else {
1082         if (uri->server != NULL) {
1083             if (len + 3 >= max) {
1084                 temp = realloc2n(ret, &max);
1085                 ret = temp;
1086             }
1087             ret[len++] = '/';
1088             ret[len++] = '/';
1089             if (uri->user != NULL) {
1090                 p = uri->user;
1091                 while (*p != 0) {
1092                     if (len + 3 >= max) {
1093                         temp = realloc2n(ret, &max);
1094                         ret = temp;
1095                     }
1096                     if ((IS_UNRESERVED(*(p))) ||
1097                         ((*(p) == ';')) || ((*(p) == ':')) ||
1098                         ((*(p) == '&')) || ((*(p) == '=')) ||
1099                         ((*(p) == '+')) || ((*(p) == '$')) ||
1100                         ((*(p) == ',')))
1101                         ret[len++] = *p++;
1102                     else {
1103                         int val = *(unsigned char *)p++;
1104                         int hi = val / 0x10, lo = val % 0x10;
1105                         ret[len++] = '%';
1106                         ret[len++] = hi + (hi > 9? 'A'-10 : '0');
1107                         ret[len++] = lo + (lo > 9? 'A'-10 : '0');
1108                     }
1109                 }
1110                 if (len + 3 >= max) {
1111                     temp = realloc2n(ret, &max);
1112                     ret = temp;
1113                 }
1114                 ret[len++] = '@';
1115             }
1116             p = uri->server;
1117             while (*p != 0) {
1118                 if (len >= max) {
1119                     temp = realloc2n(ret, &max);
1120                     ret = temp;
1121                 }
1122                 ret[len++] = *p++;
1123             }
1124             if (uri->port > 0) {
1125                 if (len + 10 >= max) {
1126                     temp = realloc2n(ret, &max);
1127                     ret = temp;
1128                 }
1129                 len += snprintf(&ret[len], max - len, ":%d", uri->port);
1130             }
1131         } else if (uri->authority != NULL) {
1132             if (len + 3 >= max) {
1133                 temp = realloc2n(ret, &max);
1134                 ret = temp;
1135             }
1136             ret[len++] = '/';
1137             ret[len++] = '/';
1138             p = uri->authority;
1139             while (*p != 0) {
1140                 if (len + 3 >= max) {
1141                     temp = realloc2n(ret, &max);
1142                     ret = temp;
1143                 }
1144                 if ((IS_UNRESERVED(*(p))) ||
1145                     ((*(p) == '$')) || ((*(p) == ',')) || ((*(p) == ';')) ||
1146                     ((*(p) == ':')) || ((*(p) == '@')) || ((*(p) == '&')) ||
1147                     ((*(p) == '=')) || ((*(p) == '+')))
1148                     ret[len++] = *p++;
1149                 else {
1150                     int val = *(unsigned char *)p++;
1151                     int hi = val / 0x10, lo = val % 0x10;
1152                     ret[len++] = '%';
1153                     ret[len++] = hi + (hi > 9? 'A'-10 : '0');
1154                     ret[len++] = lo + (lo > 9? 'A'-10 : '0');
1155                 }
1156             }
1157         } else if (uri->scheme != NULL) {
1158             if (len + 3 >= max) {
1159                 temp = realloc2n(ret, &max);
1160                 ret = temp;
1161             }
1162             ret[len++] = '/';
1163             ret[len++] = '/';
1164         }
1165         if (uri->path != NULL) {
1166             p = uri->path;
1167             /*
1168              * the colon in file:///d: should not be escaped or
1169              * Windows accesses fail later.
1170              */
1171             if ((uri->scheme != NULL) &&
1172                 (p[0] == '/') &&
1173                 (((p[1] >= 'a') && (p[1] <= 'z')) ||
1174                  ((p[1] >= 'A') && (p[1] <= 'Z'))) &&
1175                 (p[2] == ':') &&
1176                 (!strcmp(uri->scheme, "file"))) {
1177                 if (len + 3 >= max) {
1178                     temp = realloc2n(ret, &max);
1179                     ret = temp;
1180                 }
1181                 ret[len++] = *p++;
1182                 ret[len++] = *p++;
1183                 ret[len++] = *p++;
1184             }
1185             while (*p != 0) {
1186                 if (len + 3 >= max) {
1187                     temp = realloc2n(ret, &max);
1188                     ret = temp;
1189                 }
1190                 if ((IS_UNRESERVED(*(p))) || ((*(p) == '/')) ||
1191                     ((*(p) == ';')) || ((*(p) == '@')) || ((*(p) == '&')) ||
1192                     ((*(p) == '=')) || ((*(p) == '+')) || ((*(p) == '$')) ||
1193                     ((*(p) == ',')))
1194                     ret[len++] = *p++;
1195                 else {
1196                     int val = *(unsigned char *)p++;
1197                     int hi = val / 0x10, lo = val % 0x10;
1198                     ret[len++] = '%';
1199                     ret[len++] = hi + (hi > 9? 'A'-10 : '0');
1200                     ret[len++] = lo + (lo > 9? 'A'-10 : '0');
1201                 }
1202             }
1203         }
1204         if (uri->query != NULL) {
1205             if (len + 1 >= max) {
1206                 temp = realloc2n(ret, &max);
1207                 ret = temp;
1208             }
1209             ret[len++] = '?';
1210             p = uri->query;
1211             while (*p != 0) {
1212                 if (len + 1 >= max) {
1213                     temp = realloc2n(ret, &max);
1214                     ret = temp;
1215                 }
1216                 ret[len++] = *p++;
1217             }
1218         }
1219     }
1220     if (uri->fragment != NULL) {
1221         if (len + 3 >= max) {
1222             temp = realloc2n(ret, &max);
1223             ret = temp;
1224         }
1225         ret[len++] = '#';
1226         p = uri->fragment;
1227         while (*p != 0) {
1228             if (len + 3 >= max) {
1229                 temp = realloc2n(ret, &max);
1230                 ret = temp;
1231             }
1232             if ((IS_UNRESERVED(*(p))) || (IS_RESERVED(*(p))))
1233                 ret[len++] = *p++;
1234             else {
1235                 int val = *(unsigned char *)p++;
1236                 int hi = val / 0x10, lo = val % 0x10;
1237                 ret[len++] = '%';
1238                 ret[len++] = hi + (hi > 9? 'A'-10 : '0');
1239                 ret[len++] = lo + (lo > 9? 'A'-10 : '0');
1240             }
1241         }
1242     }
1243     if (len >= max) {
1244         temp = realloc2n(ret, &max);
1245         ret = temp;
1246     }
1247     ret[len] = 0;
1248     return(ret);
1249 }
1250
1251 /**
1252  * uri_clean:
1253  * @uri:  pointer to an URI
1254  *
1255  * Make sure the URI struct is free of content
1256  */
1257 static void
1258 uri_clean(URI *uri) {
1259     if (uri == NULL) return;
1260
1261     g_free(uri->scheme);
1262     uri->scheme = NULL;
1263     g_free(uri->server);
1264     uri->server = NULL;
1265     g_free(uri->user);
1266     uri->user = NULL;
1267     g_free(uri->path);
1268     uri->path = NULL;
1269     g_free(uri->fragment);
1270     uri->fragment = NULL;
1271     g_free(uri->opaque);
1272     uri->opaque = NULL;
1273     g_free(uri->authority);
1274     uri->authority = NULL;
1275     g_free(uri->query);
1276     uri->query = NULL;
1277 }
1278
1279 /**
1280  * uri_free:
1281  * @uri:  pointer to an URI
1282  *
1283  * Free up the URI struct
1284  */
1285 void
1286 uri_free(URI *uri) {
1287     uri_clean(uri);
1288     g_free(uri);
1289 }
1290
1291 /************************************************************************
1292  *                                                                      *
1293  *                      Helper functions                                *
1294  *                                                                      *
1295  ************************************************************************/
1296
1297 /**
1298  * normalize_uri_path:
1299  * @path:  pointer to the path string
1300  *
1301  * Applies the 5 normalization steps to a path string--that is, RFC 2396
1302  * Section 5.2, steps 6.c through 6.g.
1303  *
1304  * Normalization occurs directly on the string, no new allocation is done
1305  *
1306  * Returns 0 or an error code
1307  */
1308 static int
1309 normalize_uri_path(char *path) {
1310     char *cur, *out;
1311
1312     if (path == NULL)
1313         return(-1);
1314
1315     /* Skip all initial "/" chars.  We want to get to the beginning of the
1316      * first non-empty segment.
1317      */
1318     cur = path;
1319     while (cur[0] == '/')
1320       ++cur;
1321     if (cur[0] == '\0')
1322       return(0);
1323
1324     /* Keep everything we've seen so far.  */
1325     out = cur;
1326
1327     /*
1328      * Analyze each segment in sequence for cases (c) and (d).
1329      */
1330     while (cur[0] != '\0') {
1331         /*
1332          * c) All occurrences of "./", where "." is a complete path segment,
1333          *    are removed from the buffer string.
1334          */
1335         if ((cur[0] == '.') && (cur[1] == '/')) {
1336             cur += 2;
1337             /* '//' normalization should be done at this point too */
1338             while (cur[0] == '/')
1339                 cur++;
1340             continue;
1341         }
1342
1343         /*
1344          * d) If the buffer string ends with "." as a complete path segment,
1345          *    that "." is removed.
1346          */
1347         if ((cur[0] == '.') && (cur[1] == '\0'))
1348             break;
1349
1350         /* Otherwise keep the segment.  */
1351         while (cur[0] != '/') {
1352             if (cur[0] == '\0')
1353               goto done_cd;
1354             (out++)[0] = (cur++)[0];
1355         }
1356         /* nomalize // */
1357         while ((cur[0] == '/') && (cur[1] == '/'))
1358             cur++;
1359
1360         (out++)[0] = (cur++)[0];
1361     }
1362  done_cd:
1363     out[0] = '\0';
1364
1365     /* Reset to the beginning of the first segment for the next sequence.  */
1366     cur = path;
1367     while (cur[0] == '/')
1368       ++cur;
1369     if (cur[0] == '\0')
1370         return(0);
1371
1372     /*
1373      * Analyze each segment in sequence for cases (e) and (f).
1374      *
1375      * e) All occurrences of "<segment>/../", where <segment> is a
1376      *    complete path segment not equal to "..", are removed from the
1377      *    buffer string.  Removal of these path segments is performed
1378      *    iteratively, removing the leftmost matching pattern on each
1379      *    iteration, until no matching pattern remains.
1380      *
1381      * f) If the buffer string ends with "<segment>/..", where <segment>
1382      *    is a complete path segment not equal to "..", that
1383      *    "<segment>/.." is removed.
1384      *
1385      * To satisfy the "iterative" clause in (e), we need to collapse the
1386      * string every time we find something that needs to be removed.  Thus,
1387      * we don't need to keep two pointers into the string: we only need a
1388      * "current position" pointer.
1389      */
1390     while (1) {
1391         char *segp, *tmp;
1392
1393         /* At the beginning of each iteration of this loop, "cur" points to
1394          * the first character of the segment we want to examine.
1395          */
1396
1397         /* Find the end of the current segment.  */
1398         segp = cur;
1399         while ((segp[0] != '/') && (segp[0] != '\0'))
1400           ++segp;
1401
1402         /* If this is the last segment, we're done (we need at least two
1403          * segments to meet the criteria for the (e) and (f) cases).
1404          */
1405         if (segp[0] == '\0')
1406           break;
1407
1408         /* If the first segment is "..", or if the next segment _isn't_ "..",
1409          * keep this segment and try the next one.
1410          */
1411         ++segp;
1412         if (((cur[0] == '.') && (cur[1] == '.') && (segp == cur+3))
1413             || ((segp[0] != '.') || (segp[1] != '.')
1414                 || ((segp[2] != '/') && (segp[2] != '\0')))) {
1415           cur = segp;
1416           continue;
1417         }
1418
1419         /* If we get here, remove this segment and the next one and back up
1420          * to the previous segment (if there is one), to implement the
1421          * "iteratively" clause.  It's pretty much impossible to back up
1422          * while maintaining two pointers into the buffer, so just compact
1423          * the whole buffer now.
1424          */
1425
1426         /* If this is the end of the buffer, we're done.  */
1427         if (segp[2] == '\0') {
1428           cur[0] = '\0';
1429           break;
1430         }
1431         /* Valgrind complained, strcpy(cur, segp + 3); */
1432         /* string will overlap, do not use strcpy */
1433         tmp = cur;
1434         segp += 3;
1435         while ((*tmp++ = *segp++) != 0)
1436           ;
1437
1438         /* If there are no previous segments, then keep going from here.  */
1439         segp = cur;
1440         while ((segp > path) && ((--segp)[0] == '/'))
1441           ;
1442         if (segp == path)
1443           continue;
1444
1445         /* "segp" is pointing to the end of a previous segment; find it's
1446          * start.  We need to back up to the previous segment and start
1447          * over with that to handle things like "foo/bar/../..".  If we
1448          * don't do this, then on the first pass we'll remove the "bar/..",
1449          * but be pointing at the second ".." so we won't realize we can also
1450          * remove the "foo/..".
1451          */
1452         cur = segp;
1453         while ((cur > path) && (cur[-1] != '/'))
1454           --cur;
1455     }
1456     out[0] = '\0';
1457
1458     /*
1459      * g) If the resulting buffer string still begins with one or more
1460      *    complete path segments of "..", then the reference is
1461      *    considered to be in error. Implementations may handle this
1462      *    error by retaining these components in the resolved path (i.e.,
1463      *    treating them as part of the final URI), by removing them from
1464      *    the resolved path (i.e., discarding relative levels above the
1465      *    root), or by avoiding traversal of the reference.
1466      *
1467      * We discard them from the final path.
1468      */
1469     if (path[0] == '/') {
1470       cur = path;
1471       while ((cur[0] == '/') && (cur[1] == '.') && (cur[2] == '.')
1472              && ((cur[3] == '/') || (cur[3] == '\0')))
1473         cur += 3;
1474
1475       if (cur != path) {
1476         out = path;
1477         while (cur[0] != '\0')
1478           (out++)[0] = (cur++)[0];
1479         out[0] = 0;
1480       }
1481     }
1482
1483     return(0);
1484 }
1485
1486 static int is_hex(char c) {
1487     if (((c >= '0') && (c <= '9')) ||
1488         ((c >= 'a') && (c <= 'f')) ||
1489         ((c >= 'A') && (c <= 'F')))
1490         return(1);
1491     return(0);
1492 }
1493
1494
1495 /**
1496  * uri_string_unescape:
1497  * @str:  the string to unescape
1498  * @len:   the length in bytes to unescape (or <= 0 to indicate full string)
1499  * @target:  optional destination buffer
1500  *
1501  * Unescaping routine, but does not check that the string is an URI. The
1502  * output is a direct unsigned char translation of %XX values (no encoding)
1503  * Note that the length of the result can only be smaller or same size as
1504  * the input string.
1505  *
1506  * Returns a copy of the string, but unescaped, will return NULL only in case
1507  * of error
1508  */
1509 char *
1510 uri_string_unescape(const char *str, int len, char *target) {
1511     char *ret, *out;
1512     const char *in;
1513
1514     if (str == NULL)
1515         return(NULL);
1516     if (len <= 0) len = strlen(str);
1517     if (len < 0) return(NULL);
1518
1519     if (target == NULL) {
1520         ret = g_malloc(len + 1);
1521     } else
1522         ret = target;
1523     in = str;
1524     out = ret;
1525     while(len > 0) {
1526         if ((len > 2) && (*in == '%') && (is_hex(in[1])) && (is_hex(in[2]))) {
1527             in++;
1528             if ((*in >= '0') && (*in <= '9'))
1529                 *out = (*in - '0');
1530             else if ((*in >= 'a') && (*in <= 'f'))
1531                 *out = (*in - 'a') + 10;
1532             else if ((*in >= 'A') && (*in <= 'F'))
1533                 *out = (*in - 'A') + 10;
1534             in++;
1535             if ((*in >= '0') && (*in <= '9'))
1536                 *out = *out * 16 + (*in - '0');
1537             else if ((*in >= 'a') && (*in <= 'f'))
1538                 *out = *out * 16 + (*in - 'a') + 10;
1539             else if ((*in >= 'A') && (*in <= 'F'))
1540                 *out = *out * 16 + (*in - 'A') + 10;
1541             in++;
1542             len -= 3;
1543             out++;
1544         } else {
1545             *out++ = *in++;
1546             len--;
1547         }
1548     }
1549     *out = 0;
1550     return(ret);
1551 }
1552
1553 /**
1554  * uri_string_escape:
1555  * @str:  string to escape
1556  * @list: exception list string of chars not to escape
1557  *
1558  * This routine escapes a string to hex, ignoring reserved characters (a-z)
1559  * and the characters in the exception list.
1560  *
1561  * Returns a new escaped string or NULL in case of error.
1562  */
1563 char *
1564 uri_string_escape(const char *str, const char *list) {
1565     char *ret, ch;
1566     char *temp;
1567     const char *in;
1568     int len, out;
1569
1570     if (str == NULL)
1571         return(NULL);
1572     if (str[0] == 0)
1573         return(g_strdup(str));
1574     len = strlen(str);
1575     if (!(len > 0)) return(NULL);
1576
1577     len += 20;
1578     ret = g_malloc(len);
1579     in = str;
1580     out = 0;
1581     while(*in != 0) {
1582         if (len - out <= 3) {
1583             temp = realloc2n(ret, &len);
1584             ret = temp;
1585         }
1586
1587         ch = *in;
1588
1589         if ((ch != '@') && (!IS_UNRESERVED(ch)) && (!strchr(list, ch))) {
1590             unsigned char val;
1591             ret[out++] = '%';
1592             val = ch >> 4;
1593             if (val <= 9)
1594                 ret[out++] = '0' + val;
1595             else
1596                 ret[out++] = 'A' + val - 0xA;
1597             val = ch & 0xF;
1598             if (val <= 9)
1599                 ret[out++] = '0' + val;
1600             else
1601                 ret[out++] = 'A' + val - 0xA;
1602             in++;
1603         } else {
1604             ret[out++] = *in++;
1605         }
1606
1607     }
1608     ret[out] = 0;
1609     return(ret);
1610 }
1611
1612 /************************************************************************
1613  *                                                                      *
1614  *                      Public functions                                *
1615  *                                                                      *
1616  ************************************************************************/
1617
1618 /**
1619  * uri_resolve:
1620  * @URI:  the URI instance found in the document
1621  * @base:  the base value
1622  *
1623  * Computes he final URI of the reference done by checking that
1624  * the given URI is valid, and building the final URI using the
1625  * base URI. This is processed according to section 5.2 of the
1626  * RFC 2396
1627  *
1628  * 5.2. Resolving Relative References to Absolute Form
1629  *
1630  * Returns a new URI string (to be freed by the caller) or NULL in case
1631  *         of error.
1632  */
1633 char *
1634 uri_resolve(const char *uri, const char *base) {
1635     char *val = NULL;
1636     int ret, len, indx, cur, out;
1637     URI *ref = NULL;
1638     URI *bas = NULL;
1639     URI *res = NULL;
1640
1641     /*
1642      * 1) The URI reference is parsed into the potential four components and
1643      *    fragment identifier, as described in Section 4.3.
1644      *
1645      *    NOTE that a completely empty URI is treated by modern browsers
1646      *    as a reference to "." rather than as a synonym for the current
1647      *    URI.  Should we do that here?
1648      */
1649     if (uri == NULL)
1650         ret = -1;
1651     else {
1652         if (*uri) {
1653             ref = uri_new();
1654             ret = uri_parse_into(ref, uri);
1655         }
1656         else
1657             ret = 0;
1658     }
1659     if (ret != 0)
1660         goto done;
1661     if ((ref != NULL) && (ref->scheme != NULL)) {
1662         /*
1663          * The URI is absolute don't modify.
1664          */
1665         val = g_strdup(uri);
1666         goto done;
1667     }
1668     if (base == NULL)
1669         ret = -1;
1670     else {
1671         bas = uri_new();
1672         ret = uri_parse_into(bas, base);
1673     }
1674     if (ret != 0) {
1675         if (ref)
1676             val = uri_to_string(ref);
1677         goto done;
1678     }
1679     if (ref == NULL) {
1680         /*
1681          * the base fragment must be ignored
1682          */
1683         g_free(bas->fragment);
1684         bas->fragment = NULL;
1685         val = uri_to_string(bas);
1686         goto done;
1687     }
1688
1689     /*
1690      * 2) If the path component is empty and the scheme, authority, and
1691      *    query components are undefined, then it is a reference to the
1692      *    current document and we are done.  Otherwise, the reference URI's
1693      *    query and fragment components are defined as found (or not found)
1694      *    within the URI reference and not inherited from the base URI.
1695      *
1696      *    NOTE that in modern browsers, the parsing differs from the above
1697      *    in the following aspect:  the query component is allowed to be
1698      *    defined while still treating this as a reference to the current
1699      *    document.
1700      */
1701     res = uri_new();
1702     if ((ref->scheme == NULL) && (ref->path == NULL) &&
1703         ((ref->authority == NULL) && (ref->server == NULL))) {
1704         res->scheme = g_strdup(bas->scheme);
1705         if (bas->authority != NULL)
1706             res->authority = g_strdup(bas->authority);
1707         else if (bas->server != NULL) {
1708             res->server = g_strdup(bas->server);
1709             res->user = g_strdup(bas->user);
1710             res->port = bas->port;
1711         }
1712         res->path = g_strdup(bas->path);
1713         if (ref->query != NULL) {
1714             res->query = g_strdup (ref->query);
1715         } else {
1716             res->query = g_strdup(bas->query);
1717         }
1718         res->fragment = g_strdup(ref->fragment);
1719         goto step_7;
1720     }
1721
1722     /*
1723      * 3) If the scheme component is defined, indicating that the reference
1724      *    starts with a scheme name, then the reference is interpreted as an
1725      *    absolute URI and we are done.  Otherwise, the reference URI's
1726      *    scheme is inherited from the base URI's scheme component.
1727      */
1728     if (ref->scheme != NULL) {
1729         val = uri_to_string(ref);
1730         goto done;
1731     }
1732     res->scheme = g_strdup(bas->scheme);
1733
1734     res->query = g_strdup(ref->query);
1735     res->fragment = g_strdup(ref->fragment);
1736
1737     /*
1738      * 4) If the authority component is defined, then the reference is a
1739      *    network-path and we skip to step 7.  Otherwise, the reference
1740      *    URI's authority is inherited from the base URI's authority
1741      *    component, which will also be undefined if the URI scheme does not
1742      *    use an authority component.
1743      */
1744     if ((ref->authority != NULL) || (ref->server != NULL)) {
1745         if (ref->authority != NULL)
1746             res->authority = g_strdup(ref->authority);
1747         else {
1748             res->server = g_strdup(ref->server);
1749             res->user = g_strdup(ref->user);
1750             res->port = ref->port;
1751         }
1752         res->path = g_strdup(ref->path);
1753         goto step_7;
1754     }
1755     if (bas->authority != NULL)
1756         res->authority = g_strdup(bas->authority);
1757     else if (bas->server != NULL) {
1758         res->server = g_strdup(bas->server);
1759         res->user = g_strdup(bas->user);
1760         res->port = bas->port;
1761     }
1762
1763     /*
1764      * 5) If the path component begins with a slash character ("/"), then
1765      *    the reference is an absolute-path and we skip to step 7.
1766      */
1767     if ((ref->path != NULL) && (ref->path[0] == '/')) {
1768         res->path = g_strdup(ref->path);
1769         goto step_7;
1770     }
1771
1772
1773     /*
1774      * 6) If this step is reached, then we are resolving a relative-path
1775      *    reference.  The relative path needs to be merged with the base
1776      *    URI's path.  Although there are many ways to do this, we will
1777      *    describe a simple method using a separate string buffer.
1778      *
1779      * Allocate a buffer large enough for the result string.
1780      */
1781     len = 2; /* extra / and 0 */
1782     if (ref->path != NULL)
1783         len += strlen(ref->path);
1784     if (bas->path != NULL)
1785         len += strlen(bas->path);
1786     res->path = g_malloc(len);
1787     res->path[0] = 0;
1788
1789     /*
1790      * a) All but the last segment of the base URI's path component is
1791      *    copied to the buffer.  In other words, any characters after the
1792      *    last (right-most) slash character, if any, are excluded.
1793      */
1794     cur = 0;
1795     out = 0;
1796     if (bas->path != NULL) {
1797         while (bas->path[cur] != 0) {
1798             while ((bas->path[cur] != 0) && (bas->path[cur] != '/'))
1799                 cur++;
1800             if (bas->path[cur] == 0)
1801                 break;
1802
1803             cur++;
1804             while (out < cur) {
1805                 res->path[out] = bas->path[out];
1806                 out++;
1807             }
1808         }
1809     }
1810     res->path[out] = 0;
1811
1812     /*
1813      * b) The reference's path component is appended to the buffer
1814      *    string.
1815      */
1816     if (ref->path != NULL && ref->path[0] != 0) {
1817         indx = 0;
1818         /*
1819          * Ensure the path includes a '/'
1820          */
1821         if ((out == 0) && (bas->server != NULL))
1822             res->path[out++] = '/';
1823         while (ref->path[indx] != 0) {
1824             res->path[out++] = ref->path[indx++];
1825         }
1826     }
1827     res->path[out] = 0;
1828
1829     /*
1830      * Steps c) to h) are really path normalization steps
1831      */
1832     normalize_uri_path(res->path);
1833
1834 step_7:
1835
1836     /*
1837      * 7) The resulting URI components, including any inherited from the
1838      *    base URI, are recombined to give the absolute form of the URI
1839      *    reference.
1840      */
1841     val = uri_to_string(res);
1842
1843 done:
1844     if (ref != NULL)
1845         uri_free(ref);
1846     if (bas != NULL)
1847         uri_free(bas);
1848     if (res != NULL)
1849         uri_free(res);
1850     return(val);
1851 }
1852
1853 /**
1854  * uri_resolve_relative:
1855  * @URI:  the URI reference under consideration
1856  * @base:  the base value
1857  *
1858  * Expresses the URI of the reference in terms relative to the
1859  * base.  Some examples of this operation include:
1860  *     base = "http://site1.com/docs/book1.html"
1861  *        URI input                        URI returned
1862  *     docs/pic1.gif                    pic1.gif
1863  *     docs/img/pic1.gif                img/pic1.gif
1864  *     img/pic1.gif                     ../img/pic1.gif
1865  *     http://site1.com/docs/pic1.gif   pic1.gif
1866  *     http://site2.com/docs/pic1.gif   http://site2.com/docs/pic1.gif
1867  *
1868  *     base = "docs/book1.html"
1869  *        URI input                        URI returned
1870  *     docs/pic1.gif                    pic1.gif
1871  *     docs/img/pic1.gif                img/pic1.gif
1872  *     img/pic1.gif                     ../img/pic1.gif
1873  *     http://site1.com/docs/pic1.gif   http://site1.com/docs/pic1.gif
1874  *
1875  *
1876  * Note: if the URI reference is really weird or complicated, it may be
1877  *       worthwhile to first convert it into a "nice" one by calling
1878  *       uri_resolve (using 'base') before calling this routine,
1879  *       since this routine (for reasonable efficiency) assumes URI has
1880  *       already been through some validation.
1881  *
1882  * Returns a new URI string (to be freed by the caller) or NULL in case
1883  * error.
1884  */
1885 char *
1886 uri_resolve_relative (const char *uri, const char * base)
1887 {
1888     char *val = NULL;
1889     int ret;
1890     int ix;
1891     int pos = 0;
1892     int nbslash = 0;
1893     int len;
1894     URI *ref = NULL;
1895     URI *bas = NULL;
1896     char *bptr, *uptr, *vptr;
1897     int remove_path = 0;
1898
1899     if ((uri == NULL) || (*uri == 0))
1900         return NULL;
1901
1902     /*
1903      * First parse URI into a standard form
1904      */
1905     ref = uri_new ();
1906     /* If URI not already in "relative" form */
1907     if (uri[0] != '.') {
1908         ret = uri_parse_into (ref, uri);
1909         if (ret != 0)
1910             goto done;          /* Error in URI, return NULL */
1911     } else
1912         ref->path = g_strdup(uri);
1913
1914     /*
1915      * Next parse base into the same standard form
1916      */
1917     if ((base == NULL) || (*base == 0)) {
1918         val = g_strdup (uri);
1919         goto done;
1920     }
1921     bas = uri_new ();
1922     if (base[0] != '.') {
1923         ret = uri_parse_into (bas, base);
1924         if (ret != 0)
1925             goto done;          /* Error in base, return NULL */
1926     } else
1927         bas->path = g_strdup(base);
1928
1929     /*
1930      * If the scheme / server on the URI differs from the base,
1931      * just return the URI
1932      */
1933     if ((ref->scheme != NULL) &&
1934         ((bas->scheme == NULL) ||
1935          (strcmp (bas->scheme, ref->scheme)) ||
1936          (strcmp (bas->server, ref->server)))) {
1937         val = g_strdup (uri);
1938         goto done;
1939     }
1940     if (bas->path == ref->path ||
1941         (bas->path && ref->path && !strcmp(bas->path, ref->path))) {
1942         val = g_strdup("");
1943         goto done;
1944     }
1945     if (bas->path == NULL) {
1946         val = g_strdup(ref->path);
1947         goto done;
1948     }
1949     if (ref->path == NULL) {
1950         ref->path = (char *) "/";
1951         remove_path = 1;
1952     }
1953
1954     /*
1955      * At this point (at last!) we can compare the two paths
1956      *
1957      * First we take care of the special case where either of the
1958      * two path components may be missing (bug 316224)
1959      */
1960     if (bas->path == NULL) {
1961         if (ref->path != NULL) {
1962             uptr = ref->path;
1963             if (*uptr == '/')
1964                 uptr++;
1965             /* exception characters from uri_to_string */
1966             val = uri_string_escape(uptr, "/;&=+$,");
1967         }
1968         goto done;
1969     }
1970     bptr = bas->path;
1971     if (ref->path == NULL) {
1972         for (ix = 0; bptr[ix] != 0; ix++) {
1973             if (bptr[ix] == '/')
1974                 nbslash++;
1975         }
1976         uptr = NULL;
1977         len = 1;        /* this is for a string terminator only */
1978     } else {
1979     /*
1980      * Next we compare the two strings and find where they first differ
1981      */
1982         if ((ref->path[pos] == '.') && (ref->path[pos+1] == '/'))
1983             pos += 2;
1984         if ((*bptr == '.') && (bptr[1] == '/'))
1985             bptr += 2;
1986         else if ((*bptr == '/') && (ref->path[pos] != '/'))
1987             bptr++;
1988         while ((bptr[pos] == ref->path[pos]) && (bptr[pos] != 0))
1989             pos++;
1990
1991         if (bptr[pos] == ref->path[pos]) {
1992             val = g_strdup("");
1993             goto done;          /* (I can't imagine why anyone would do this) */
1994         }
1995
1996         /*
1997          * In URI, "back up" to the last '/' encountered.  This will be the
1998          * beginning of the "unique" suffix of URI
1999          */
2000         ix = pos;
2001         if ((ref->path[ix] == '/') && (ix > 0))
2002             ix--;
2003         else if ((ref->path[ix] == 0) && (ix > 1) && (ref->path[ix - 1] == '/'))
2004             ix -= 2;
2005         for (; ix > 0; ix--) {
2006             if (ref->path[ix] == '/')
2007                 break;
2008         }
2009         if (ix == 0) {
2010             uptr = ref->path;
2011         } else {
2012             ix++;
2013             uptr = &ref->path[ix];
2014         }
2015
2016         /*
2017          * In base, count the number of '/' from the differing point
2018          */
2019         if (bptr[pos] != ref->path[pos]) {/* check for trivial URI == base */
2020             for (; bptr[ix] != 0; ix++) {
2021                 if (bptr[ix] == '/')
2022                     nbslash++;
2023             }
2024         }
2025         len = strlen (uptr) + 1;
2026     }
2027
2028     if (nbslash == 0) {
2029         if (uptr != NULL)
2030             /* exception characters from uri_to_string */
2031             val = uri_string_escape(uptr, "/;&=+$,");
2032         goto done;
2033     }
2034
2035     /*
2036      * Allocate just enough space for the returned string -
2037      * length of the remainder of the URI, plus enough space
2038      * for the "../" groups, plus one for the terminator
2039      */
2040     val = g_malloc (len + 3 * nbslash);
2041     vptr = val;
2042     /*
2043      * Put in as many "../" as needed
2044      */
2045     for (; nbslash>0; nbslash--) {
2046         *vptr++ = '.';
2047         *vptr++ = '.';
2048         *vptr++ = '/';
2049     }
2050     /*
2051      * Finish up with the end of the URI
2052      */
2053     if (uptr != NULL) {
2054         if ((vptr > val) && (len > 0) &&
2055             (uptr[0] == '/') && (vptr[-1] == '/')) {
2056             memcpy (vptr, uptr + 1, len - 1);
2057             vptr[len - 2] = 0;
2058         } else {
2059             memcpy (vptr, uptr, len);
2060             vptr[len - 1] = 0;
2061         }
2062     } else {
2063         vptr[len - 1] = 0;
2064     }
2065
2066     /* escape the freshly-built path */
2067     vptr = val;
2068         /* exception characters from uri_to_string */
2069     val = uri_string_escape(vptr, "/;&=+$,");
2070     g_free(vptr);
2071
2072 done:
2073     /*
2074      * Free the working variables
2075      */
2076     if (remove_path != 0)
2077         ref->path = NULL;
2078     if (ref != NULL)
2079         uri_free (ref);
2080     if (bas != NULL)
2081         uri_free (bas);
2082
2083     return val;
2084 }
2085
2086 /*
2087  * Utility functions to help parse and assemble query strings.
2088  */
2089
2090 struct QueryParams *
2091 query_params_new (int init_alloc)
2092 {
2093     struct QueryParams *ps;
2094
2095     if (init_alloc <= 0) init_alloc = 1;
2096
2097     ps = g_new(QueryParams, 1);
2098     ps->n = 0;
2099     ps->alloc = init_alloc;
2100     ps->p = g_new(QueryParam, ps->alloc);
2101
2102     return ps;
2103 }
2104
2105 /* Ensure there is space to store at least one more parameter
2106  * at the end of the set.
2107  */
2108 static int
2109 query_params_append (struct QueryParams *ps,
2110                const char *name, const char *value)
2111 {
2112     if (ps->n >= ps->alloc) {
2113         ps->p = g_renew(QueryParam, ps->p, ps->alloc * 2);
2114         ps->alloc *= 2;
2115     }
2116
2117     ps->p[ps->n].name = g_strdup(name);
2118     ps->p[ps->n].value = g_strdup(value);
2119     ps->p[ps->n].ignore = 0;
2120     ps->n++;
2121
2122     return 0;
2123 }
2124
2125 void
2126 query_params_free (struct QueryParams *ps)
2127 {
2128     int i;
2129
2130     for (i = 0; i < ps->n; ++i) {
2131         g_free (ps->p[i].name);
2132         g_free (ps->p[i].value);
2133     }
2134     g_free (ps->p);
2135     g_free (ps);
2136 }
2137
2138 struct QueryParams *
2139 query_params_parse (const char *query)
2140 {
2141     struct QueryParams *ps;
2142     const char *end, *eq;
2143
2144     ps = query_params_new (0);
2145     if (!query || query[0] == '\0') return ps;
2146
2147     while (*query) {
2148         char *name = NULL, *value = NULL;
2149
2150         /* Find the next separator, or end of the string. */
2151         end = strchr (query, '&');
2152         if (!end)
2153             end = strchr (query, ';');
2154         if (!end)
2155             end = query + strlen (query);
2156
2157         /* Find the first '=' character between here and end. */
2158         eq = strchr (query, '=');
2159         if (eq && eq >= end) eq = NULL;
2160
2161         /* Empty section (eg. "&&"). */
2162         if (end == query)
2163             goto next;
2164
2165         /* If there is no '=' character, then we have just "name"
2166          * and consistent with CGI.pm we assume value is "".
2167          */
2168         else if (!eq) {
2169             name = uri_string_unescape (query, end - query, NULL);
2170             value = NULL;
2171         }
2172         /* Or if we have "name=" here (works around annoying
2173          * problem when calling uri_string_unescape with len = 0).
2174          */
2175         else if (eq+1 == end) {
2176             name = uri_string_unescape (query, eq - query, NULL);
2177             value = g_new0(char, 1);
2178         }
2179         /* If the '=' character is at the beginning then we have
2180          * "=value" and consistent with CGI.pm we _ignore_ this.
2181          */
2182         else if (query == eq)
2183             goto next;
2184
2185         /* Otherwise it's "name=value". */
2186         else {
2187             name = uri_string_unescape (query, eq - query, NULL);
2188             value = uri_string_unescape (eq+1, end - (eq+1), NULL);
2189         }
2190
2191         /* Append to the parameter set. */
2192         query_params_append (ps, name, value);
2193         g_free(name);
2194         g_free(value);
2195
2196     next:
2197         query = end;
2198         if (*query) query ++; /* skip '&' separator */
2199     }
2200
2201     return ps;
2202 }