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