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 "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         if (uri->scheme != NULL) 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         if (uri->fragment != NULL)
 266             g_free(uri->fragment);
 267         if (uri->cleanup & 2)
 268             uri->fragment = g_strndup(*str, cur - *str);
 269         else
 270             uri->fragment = uri_string_unescape(*str, cur - *str, NULL);
 271     }
 272     *str = cur;
 273     return (0);
 274 }
 275
 276 /**
 277  * rfc3986_parse_query:
 278  * @uri:  pointer to an URI structure
 279  * @str:  pointer to the string to analyze
 280  *
 281  * Parse the query part of an URI
 282  *
 283  * query = *uric
 284  *
 285  * Returns 0 or the error code
 286  */
 287 static int
 288 rfc3986_parse_query(URI *uri, const char **str)
 289 {
 290     const char *cur;
 291
 292     if (str == NULL)
 293         return (-1);
 294
 295     cur = *str;
 296
 297     while ((ISA_PCHAR(cur)) || (*cur == '/') || (*cur == '?') ||
 298            ((uri != NULL) && (uri->cleanup & 1) && (IS_UNWISE(cur))))
 299         NEXT(cur);
 300     if (uri != NULL) {
 301         if (uri->query != NULL)
 302             g_free (uri->query);
 303         uri->query = g_strndup (*str, cur - *str);
 304     }
 305     *str = cur;
 306     return (0);
 307 }
 308
 309 /**
 310  * rfc3986_parse_port:
 311  * @uri:  pointer to an URI structure
 312  * @str:  the string to analyze
 313  *
 314  * Parse a port  part and fills in the appropriate fields
 315  * of the @uri structure
 316  *
 317  * port          = *DIGIT
 318  *
 319  * Returns 0 or the error code
 320  */
 321 static int
 322 rfc3986_parse_port(URI *uri, const char **str)
 323 {
 324     const char *cur = *str;
 325
 326     if (ISA_DIGIT(cur)) {
 327         if (uri != NULL)
 328             uri->port = 0;
 329         while (ISA_DIGIT(cur)) {
 330             if (uri != NULL)
 331                 uri->port = uri->port * 10 + (*cur - '0');
 332             cur++;
 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             if (uri->user != NULL) 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 adressing 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         if (uri->authority != NULL) g_free(uri->authority);
 477         uri->authority = NULL;
 478         if (uri->server != NULL) 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         if (uri->path != NULL) 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         if (uri->path != NULL) 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         if (uri->path != NULL) 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         if (uri->path != NULL) 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             if (uri->path != NULL) 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             if (uri->path != NULL) 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     if (uri != NULL) {
 934         ret = rfc3986_parse_uri_reference(uri, str);
 935         if (ret) {
 936             uri_free(uri);
 937             return(NULL);
 938         }
 939     }
 940     return(uri);
 941 }
 942
 943 /**
 944  * uri_parse_into:
 945  * @uri:  pointer to an URI structure
 946  * @str:  the string to analyze
 947  *
 948  * Parse an URI reference string based on RFC 3986 and fills in the
 949  * appropriate fields of the @uri structure
 950  *
 951  * URI-reference = URI / relative-ref
 952  *
 953  * Returns 0 or the error code
 954  */
 955 int
 956 uri_parse_into(URI *uri, const char *str) {
 957     return(rfc3986_parse_uri_reference(uri, str));
 958 }
 959
 960 /**
 961  * uri_parse_raw:
 962  * @str:  the URI string to analyze
 963  * @raw:  if 1 unescaping of URI pieces are disabled
 964  *
 965  * Parse an URI but allows to keep intact the original fragments.
 966  *
 967  * URI-reference = URI / relative-ref
 968  *
 969  * Returns a newly built URI or NULL in case of error
 970  */
 971 URI *
 972 uri_parse_raw(const char *str, int raw) {
 973     URI *uri;
 974     int ret;
 975
 976     if (str == NULL)
 977         return(NULL);
 978     uri = uri_new();
 979     if (uri != NULL) {
 980         if (raw) {
 981             uri->cleanup |= 2;
 982         }
 983         ret = uri_parse_into(uri, str);
 984         if (ret) {
 985             uri_free(uri);
 986             return(NULL);
 987         }
 988     }
 989     return(uri);
 990 }
 991
 992 /************************************************************************
 993  *                                                                      *
 994  *                      Generic URI structure functions                 *
 995  *                                                                      *
 996  ************************************************************************/
 997
 998 /**
 999  * uri_new:
1000  *
1001  * Simply creates an empty URI
1002  *
1003  * Returns the new structure or NULL in case of error
1004  */
1005 URI *
1006 uri_new(void) {
1007     URI *ret;
1008
1009     ret = (URI *) g_malloc(sizeof(URI));
1010     memset(ret, 0, sizeof(URI));
1011     return(ret);
1012 }
1013
1014 /**
1015  * realloc2n:
1016  *
1017  * Function to handle properly a reallocation when saving an URI
1018  * Also imposes some limit on the length of an URI string output
1019  */
1020 static char *
1021 realloc2n(char *ret, int *max) {
1022     char *temp;
1023     int tmp;
1024
1025     tmp = *max * 2;
1026     temp = g_realloc(ret, (tmp + 1));
1027     *max = tmp;
1028     return(temp);
1029 }
1030
1031 /**
1032  * uri_to_string:
1033  * @uri:  pointer to an URI
1034  *
1035  * Save the URI as an escaped string
1036  *
1037  * Returns a new string (to be deallocated by caller)
1038  */
1039 char *
1040 uri_to_string(URI *uri) {
1041     char *ret = NULL;
1042     char *temp;
1043     const char *p;
1044     int len;
1045     int max;
1046
1047     if (uri == NULL) return(NULL);
1048
1049
1050     max = 80;
1051     ret = g_malloc(max + 1);
1052     len = 0;
1053
1054     if (uri->scheme != NULL) {
1055         p = uri->scheme;
1056         while (*p != 0) {
1057             if (len >= max) {
1058                 temp = realloc2n(ret, &max);
1059                 if (temp == NULL) goto mem_error;
1060                 ret = temp;
1061             }
1062             ret[len++] = *p++;
1063         }
1064         if (len >= max) {
1065             temp = realloc2n(ret, &max);
1066             if (temp == NULL) goto mem_error;
1067             ret = temp;
1068         }
1069         ret[len++] = ':';
1070     }
1071     if (uri->opaque != NULL) {
1072         p = uri->opaque;
1073         while (*p != 0) {
1074             if (len + 3 >= max) {
1075                 temp = realloc2n(ret, &max);
1076                 if (temp == NULL) goto mem_error;
1077                 ret = temp;
1078             }
1079             if (IS_RESERVED(*(p)) || IS_UNRESERVED(*(p)))
1080                 ret[len++] = *p++;
1081             else {
1082                 int val = *(unsigned char *)p++;
1083                 int hi = val / 0x10, lo = val % 0x10;
1084                 ret[len++] = '%';
1085                 ret[len++] = hi + (hi > 9? 'A'-10 : '0');
1086                 ret[len++] = lo + (lo > 9? 'A'-10 : '0');
1087             }
1088         }
1089     } else {
1090         if (uri->server != NULL) {
1091             if (len + 3 >= max) {
1092                 temp = realloc2n(ret, &max);
1093                 if (temp == NULL) goto mem_error;
1094                 ret = temp;
1095             }
1096             ret[len++] = '/';
1097             ret[len++] = '/';
1098             if (uri->user != NULL) {
1099                 p = uri->user;
1100                 while (*p != 0) {
1101                     if (len + 3 >= max) {
1102                         temp = realloc2n(ret, &max);
1103                         if (temp == NULL) goto mem_error;
1104                         ret = temp;
1105                     }
1106                     if ((IS_UNRESERVED(*(p))) ||
1107                         ((*(p) == ';')) || ((*(p) == ':')) ||
1108                         ((*(p) == '&')) || ((*(p) == '=')) ||
1109                         ((*(p) == '+')) || ((*(p) == '$')) ||
1110                         ((*(p) == ',')))
1111                         ret[len++] = *p++;
1112                     else {
1113                         int val = *(unsigned char *)p++;
1114                         int hi = val / 0x10, lo = val % 0x10;
1115                         ret[len++] = '%';
1116                         ret[len++] = hi + (hi > 9? 'A'-10 : '0');
1117                         ret[len++] = lo + (lo > 9? 'A'-10 : '0');
1118                     }
1119                 }
1120                 if (len + 3 >= max) {
1121                     temp = realloc2n(ret, &max);
1122                     if (temp == NULL) goto mem_error;
1123                     ret = temp;
1124                 }
1125                 ret[len++] = '@';
1126             }
1127             p = uri->server;
1128             while (*p != 0) {
1129                 if (len >= max) {
1130                     temp = realloc2n(ret, &max);
1131                     if (temp == NULL) goto mem_error;
1132                     ret = temp;
1133                 }
1134                 ret[len++] = *p++;
1135             }
1136             if (uri->port > 0) {
1137                 if (len + 10 >= max) {
1138                     temp = realloc2n(ret, &max);
1139                     if (temp == NULL) goto mem_error;
1140                     ret = temp;
1141                 }
1142                 len += snprintf(&ret[len], max - len, ":%d", uri->port);
1143             }
1144         } else if (uri->authority != NULL) {
1145             if (len + 3 >= max) {
1146                 temp = realloc2n(ret, &max);
1147                 if (temp == NULL) goto mem_error;
1148                 ret = temp;
1149             }
1150             ret[len++] = '/';
1151             ret[len++] = '/';
1152             p = uri->authority;
1153             while (*p != 0) {
1154                 if (len + 3 >= max) {
1155                     temp = realloc2n(ret, &max);
1156                     if (temp == NULL) goto mem_error;
1157                     ret = temp;
1158                 }
1159                 if ((IS_UNRESERVED(*(p))) ||
1160                     ((*(p) == '$')) || ((*(p) == ',')) || ((*(p) == ';')) ||
1161                     ((*(p) == ':')) || ((*(p) == '@')) || ((*(p) == '&')) ||
1162                     ((*(p) == '=')) || ((*(p) == '+')))
1163                     ret[len++] = *p++;
1164                 else {
1165                     int val = *(unsigned char *)p++;
1166                     int hi = val / 0x10, lo = val % 0x10;
1167                     ret[len++] = '%';
1168                     ret[len++] = hi + (hi > 9? 'A'-10 : '0');
1169                     ret[len++] = lo + (lo > 9? 'A'-10 : '0');
1170                 }
1171             }
1172         } else if (uri->scheme != NULL) {
1173             if (len + 3 >= max) {
1174                 temp = realloc2n(ret, &max);
1175                 if (temp == NULL) goto mem_error;
1176                 ret = temp;
1177             }
1178             ret[len++] = '/';
1179             ret[len++] = '/';
1180         }
1181         if (uri->path != NULL) {
1182             p = uri->path;
1183             /*
1184              * the colon in file:///d: should not be escaped or
1185              * Windows accesses fail later.
1186              */
1187             if ((uri->scheme != NULL) &&
1188                 (p[0] == '/') &&
1189                 (((p[1] >= 'a') && (p[1] <= 'z')) ||
1190                  ((p[1] >= 'A') && (p[1] <= 'Z'))) &&
1191                 (p[2] == ':') &&
1192                 (!strcmp(uri->scheme, "file"))) {
1193                 if (len + 3 >= max) {
1194                     temp = realloc2n(ret, &max);
1195                     if (temp == NULL) goto mem_error;
1196                     ret = temp;
1197                 }
1198                 ret[len++] = *p++;
1199                 ret[len++] = *p++;
1200                 ret[len++] = *p++;
1201             }
1202             while (*p != 0) {
1203                 if (len + 3 >= max) {
1204                     temp = realloc2n(ret, &max);
1205                     if (temp == NULL) goto mem_error;
1206                     ret = temp;
1207                 }
1208                 if ((IS_UNRESERVED(*(p))) || ((*(p) == '/')) ||
1209                     ((*(p) == ';')) || ((*(p) == '@')) || ((*(p) == '&')) ||
1210                     ((*(p) == '=')) || ((*(p) == '+')) || ((*(p) == '$')) ||
1211                     ((*(p) == ',')))
1212                     ret[len++] = *p++;
1213                 else {
1214                     int val = *(unsigned char *)p++;
1215                     int hi = val / 0x10, lo = val % 0x10;
1216                     ret[len++] = '%';
1217                     ret[len++] = hi + (hi > 9? 'A'-10 : '0');
1218                     ret[len++] = lo + (lo > 9? 'A'-10 : '0');
1219                 }
1220             }
1221         }
1222         if (uri->query != NULL) {
1223             if (len + 1 >= max) {
1224                 temp = realloc2n(ret, &max);
1225                 if (temp == NULL) goto mem_error;
1226                 ret = temp;
1227             }
1228             ret[len++] = '?';
1229             p = uri->query;
1230             while (*p != 0) {
1231                 if (len + 1 >= max) {
1232                     temp = realloc2n(ret, &max);
1233                     if (temp == NULL) goto mem_error;
1234                     ret = temp;
1235                 }
1236                 ret[len++] = *p++;
1237             }
1238         }
1239     }
1240     if (uri->fragment != NULL) {
1241         if (len + 3 >= max) {
1242             temp = realloc2n(ret, &max);
1243             if (temp == NULL) goto mem_error;
1244             ret = temp;
1245         }
1246         ret[len++] = '#';
1247         p = uri->fragment;
1248         while (*p != 0) {
1249             if (len + 3 >= max) {
1250                 temp = realloc2n(ret, &max);
1251                 if (temp == NULL) goto mem_error;
1252                 ret = temp;
1253             }
1254             if ((IS_UNRESERVED(*(p))) || (IS_RESERVED(*(p))))
1255                 ret[len++] = *p++;
1256             else {
1257                 int val = *(unsigned char *)p++;
1258                 int hi = val / 0x10, lo = val % 0x10;
1259                 ret[len++] = '%';
1260                 ret[len++] = hi + (hi > 9? 'A'-10 : '0');
1261                 ret[len++] = lo + (lo > 9? 'A'-10 : '0');
1262             }
1263         }
1264     }
1265     if (len >= max) {
1266         temp = realloc2n(ret, &max);
1267         if (temp == NULL) goto mem_error;
1268         ret = temp;
1269     }
1270     ret[len] = 0;
1271     return(ret);
1272
1273 mem_error:
1274     g_free(ret);
1275     return(NULL);
1276 }
1277
1278 /**
1279  * uri_clean:
1280  * @uri:  pointer to an URI
1281  *
1282  * Make sure the URI struct is free of content
1283  */
1284 static void
1285 uri_clean(URI *uri) {
1286     if (uri == NULL) return;
1287
1288     if (uri->scheme != NULL) g_free(uri->scheme);
1289     uri->scheme = NULL;
1290     if (uri->server != NULL) g_free(uri->server);
1291     uri->server = NULL;
1292     if (uri->user != NULL) g_free(uri->user);
1293     uri->user = NULL;
1294     if (uri->path != NULL) g_free(uri->path);
1295     uri->path = NULL;
1296     if (uri->fragment != NULL) g_free(uri->fragment);
1297     uri->fragment = NULL;
1298     if (uri->opaque != NULL) g_free(uri->opaque);
1299     uri->opaque = NULL;
1300     if (uri->authority != NULL) g_free(uri->authority);
1301     uri->authority = NULL;
1302     if (uri->query != NULL) g_free(uri->query);
1303     uri->query = NULL;
1304 }
1305
1306 /**
1307  * uri_free:
1308  * @uri:  pointer to an URI
1309  *
1310  * Free up the URI struct
1311  */
1312 void
1313 uri_free(URI *uri) {
1314     uri_clean(uri);
1315     g_free(uri);
1316 }
1317
1318 /************************************************************************
1319  *                                                                      *
1320  *                      Helper functions                                *
1321  *                                                                      *
1322  ************************************************************************/
1323
1324 /**
1325  * normalize_uri_path:
1326  * @path:  pointer to the path string
1327  *
1328  * Applies the 5 normalization steps to a path string--that is, RFC 2396
1329  * Section 5.2, steps 6.c through 6.g.
1330  *
1331  * Normalization occurs directly on the string, no new allocation is done
1332  *
1333  * Returns 0 or an error code
1334  */
1335 static int
1336 normalize_uri_path(char *path) {
1337     char *cur, *out;
1338
1339     if (path == NULL)
1340         return(-1);
1341
1342     /* Skip all initial "/" chars.  We want to get to the beginning of the
1343      * first non-empty segment.
1344      */
1345     cur = path;
1346     while (cur[0] == '/')
1347       ++cur;
1348     if (cur[0] == '\0')
1349       return(0);
1350
1351     /* Keep everything we've seen so far.  */
1352     out = cur;
1353
1354     /*
1355      * Analyze each segment in sequence for cases (c) and (d).
1356      */
1357     while (cur[0] != '\0') {
1358         /*
1359          * c) All occurrences of "./", where "." is a complete path segment,
1360          *    are removed from the buffer string.
1361          */
1362         if ((cur[0] == '.') && (cur[1] == '/')) {
1363             cur += 2;
1364             /* '//' normalization should be done at this point too */
1365             while (cur[0] == '/')
1366                 cur++;
1367             continue;
1368         }
1369
1370         /*
1371          * d) If the buffer string ends with "." as a complete path segment,
1372          *    that "." is removed.
1373          */
1374         if ((cur[0] == '.') && (cur[1] == '\0'))
1375             break;
1376
1377         /* Otherwise keep the segment.  */
1378         while (cur[0] != '/') {
1379             if (cur[0] == '\0')
1380               goto done_cd;
1381             (out++)[0] = (cur++)[0];
1382         }
1383         /* nomalize // */
1384         while ((cur[0] == '/') && (cur[1] == '/'))
1385             cur++;
1386
1387         (out++)[0] = (cur++)[0];
1388     }
1389  done_cd:
1390     out[0] = '\0';
1391
1392     /* Reset to the beginning of the first segment for the next sequence.  */
1393     cur = path;
1394     while (cur[0] == '/')
1395       ++cur;
1396     if (cur[0] == '\0')
1397         return(0);
1398
1399     /*
1400      * Analyze each segment in sequence for cases (e) and (f).
1401      *
1402      * e) All occurrences of "<segment>/../", where <segment> is a
1403      *    complete path segment not equal to "..", are removed from the
1404      *    buffer string.  Removal of these path segments is performed
1405      *    iteratively, removing the leftmost matching pattern on each
1406      *    iteration, until no matching pattern remains.
1407      *
1408      * f) If the buffer string ends with "<segment>/..", where <segment>
1409      *    is a complete path segment not equal to "..", that
1410      *    "<segment>/.." is removed.
1411      *
1412      * To satisfy the "iterative" clause in (e), we need to collapse the
1413      * string every time we find something that needs to be removed.  Thus,
1414      * we don't need to keep two pointers into the string: we only need a
1415      * "current position" pointer.
1416      */
1417     while (1) {
1418         char *segp, *tmp;
1419
1420         /* At the beginning of each iteration of this loop, "cur" points to
1421          * the first character of the segment we want to examine.
1422          */
1423
1424         /* Find the end of the current segment.  */
1425         segp = cur;
1426         while ((segp[0] != '/') && (segp[0] != '\0'))
1427           ++segp;
1428
1429         /* If this is the last segment, we're done (we need at least two
1430          * segments to meet the criteria for the (e) and (f) cases).
1431          */
1432         if (segp[0] == '\0')
1433           break;
1434
1435         /* If the first segment is "..", or if the next segment _isn't_ "..",
1436          * keep this segment and try the next one.
1437          */
1438         ++segp;
1439         if (((cur[0] == '.') && (cur[1] == '.') && (segp == cur+3))
1440             || ((segp[0] != '.') || (segp[1] != '.')
1441                 || ((segp[2] != '/') && (segp[2] != '\0')))) {
1442           cur = segp;
1443           continue;
1444         }
1445
1446         /* If we get here, remove this segment and the next one and back up
1447          * to the previous segment (if there is one), to implement the
1448          * "iteratively" clause.  It's pretty much impossible to back up
1449          * while maintaining two pointers into the buffer, so just compact
1450          * the whole buffer now.
1451          */
1452
1453         /* If this is the end of the buffer, we're done.  */
1454         if (segp[2] == '\0') {
1455           cur[0] = '\0';
1456           break;
1457         }
1458         /* Valgrind complained, strcpy(cur, segp + 3); */
1459         /* string will overlap, do not use strcpy */
1460         tmp = cur;
1461         segp += 3;
1462         while ((*tmp++ = *segp++) != 0)
1463           ;
1464
1465         /* If there are no previous segments, then keep going from here.  */
1466         segp = cur;
1467         while ((segp > path) && ((--segp)[0] == '/'))
1468           ;
1469         if (segp == path)
1470           continue;
1471
1472         /* "segp" is pointing to the end of a previous segment; find it's
1473          * start.  We need to back up to the previous segment and start
1474          * over with that to handle things like "foo/bar/../..".  If we
1475          * don't do this, then on the first pass we'll remove the "bar/..",
1476          * but be pointing at the second ".." so we won't realize we can also
1477          * remove the "foo/..".
1478          */
1479         cur = segp;
1480         while ((cur > path) && (cur[-1] != '/'))
1481           --cur;
1482     }
1483     out[0] = '\0';
1484
1485     /*
1486      * g) If the resulting buffer string still begins with one or more
1487      *    complete path segments of "..", then the reference is
1488      *    considered to be in error. Implementations may handle this
1489      *    error by retaining these components in the resolved path (i.e.,
1490      *    treating them as part of the final URI), by removing them from
1491      *    the resolved path (i.e., discarding relative levels above the
1492      *    root), or by avoiding traversal of the reference.
1493      *
1494      * We discard them from the final path.
1495      */
1496     if (path[0] == '/') {
1497       cur = path;
1498       while ((cur[0] == '/') && (cur[1] == '.') && (cur[2] == '.')
1499              && ((cur[3] == '/') || (cur[3] == '\0')))
1500         cur += 3;
1501
1502       if (cur != path) {
1503         out = path;
1504         while (cur[0] != '\0')
1505           (out++)[0] = (cur++)[0];
1506         out[0] = 0;
1507       }
1508     }
1509
1510     return(0);
1511 }
1512
1513 static int is_hex(char c) {
1514     if (((c >= '0') && (c <= '9')) ||
1515         ((c >= 'a') && (c <= 'f')) ||
1516         ((c >= 'A') && (c <= 'F')))
1517         return(1);
1518     return(0);
1519 }
1520
1521
1522 /**
1523  * uri_string_unescape:
1524  * @str:  the string to unescape
1525  * @len:   the length in bytes to unescape (or <= 0 to indicate full string)
1526  * @target:  optional destination buffer
1527  *
1528  * Unescaping routine, but does not check that the string is an URI. The
1529  * output is a direct unsigned char translation of %XX values (no encoding)
1530  * Note that the length of the result can only be smaller or same size as
1531  * the input string.
1532  *
1533  * Returns a copy of the string, but unescaped, will return NULL only in case
1534  * of error
1535  */
1536 char *
1537 uri_string_unescape(const char *str, int len, char *target) {
1538     char *ret, *out;
1539     const char *in;
1540
1541     if (str == NULL)
1542         return(NULL);
1543     if (len <= 0) len = strlen(str);
1544     if (len < 0) return(NULL);
1545
1546     if (target == NULL) {
1547         ret = g_malloc(len + 1);
1548     } else
1549         ret = target;
1550     in = str;
1551     out = ret;
1552     while(len > 0) {
1553         if ((len > 2) && (*in == '%') && (is_hex(in[1])) && (is_hex(in[2]))) {
1554             in++;
1555             if ((*in >= '0') && (*in <= '9'))
1556                 *out = (*in - '0');
1557             else if ((*in >= 'a') && (*in <= 'f'))
1558                 *out = (*in - 'a') + 10;
1559             else if ((*in >= 'A') && (*in <= 'F'))
1560                 *out = (*in - 'A') + 10;
1561             in++;
1562             if ((*in >= '0') && (*in <= '9'))
1563                 *out = *out * 16 + (*in - '0');
1564             else if ((*in >= 'a') && (*in <= 'f'))
1565                 *out = *out * 16 + (*in - 'a') + 10;
1566             else if ((*in >= 'A') && (*in <= 'F'))
1567                 *out = *out * 16 + (*in - 'A') + 10;
1568             in++;
1569             len -= 3;
1570             out++;
1571         } else {
1572             *out++ = *in++;
1573             len--;
1574         }
1575     }
1576     *out = 0;
1577     return(ret);
1578 }
1579
1580 /**
1581  * uri_string_escape:
1582  * @str:  string to escape
1583  * @list: exception list string of chars not to escape
1584  *
1585  * This routine escapes a string to hex, ignoring reserved characters (a-z)
1586  * and the characters in the exception list.
1587  *
1588  * Returns a new escaped string or NULL in case of error.
1589  */
1590 char *
1591 uri_string_escape(const char *str, const char *list) {
1592     char *ret, ch;
1593     char *temp;
1594     const char *in;
1595     int len, out;
1596
1597     if (str == NULL)
1598         return(NULL);
1599     if (str[0] == 0)
1600         return(g_strdup(str));
1601     len = strlen(str);
1602     if (!(len > 0)) return(NULL);
1603
1604     len += 20;
1605     ret = g_malloc(len);
1606     in = str;
1607     out = 0;
1608     while(*in != 0) {
1609         if (len - out <= 3) {
1610             temp = realloc2n(ret, &len);
1611             ret = temp;
1612         }
1613
1614         ch = *in;
1615
1616         if ((ch != '@') && (!IS_UNRESERVED(ch)) && (!strchr(list, ch))) {
1617             unsigned char val;
1618             ret[out++] = '%';
1619             val = ch >> 4;
1620             if (val <= 9)
1621                 ret[out++] = '0' + val;
1622             else
1623                 ret[out++] = 'A' + val - 0xA;
1624             val = ch & 0xF;
1625             if (val <= 9)
1626                 ret[out++] = '0' + val;
1627             else
1628                 ret[out++] = 'A' + val - 0xA;
1629             in++;
1630         } else {
1631             ret[out++] = *in++;
1632         }
1633
1634     }
1635     ret[out] = 0;
1636     return(ret);
1637 }
1638
1639 /************************************************************************
1640  *                                                                      *
1641  *                      Public functions                                *
1642  *                                                                      *
1643  ************************************************************************/
1644
1645 /**
1646  * uri_resolve:
1647  * @URI:  the URI instance found in the document
1648  * @base:  the base value
1649  *
1650  * Computes he final URI of the reference done by checking that
1651  * the given URI is valid, and building the final URI using the
1652  * base URI. This is processed according to section 5.2 of the
1653  * RFC 2396
1654  *
1655  * 5.2. Resolving Relative References to Absolute Form
1656  *
1657  * Returns a new URI string (to be freed by the caller) or NULL in case
1658  *         of error.
1659  */
1660 char *
1661 uri_resolve(const char *uri, const char *base) {
1662     char *val = NULL;
1663     int ret, len, indx, cur, out;
1664     URI *ref = NULL;
1665     URI *bas = NULL;
1666     URI *res = NULL;
1667
1668     /*
1669      * 1) The URI reference is parsed into the potential four components and
1670      *    fragment identifier, as described in Section 4.3.
1671      *
1672      *    NOTE that a completely empty URI is treated by modern browsers
1673      *    as a reference to "." rather than as a synonym for the current
1674      *    URI.  Should we do that here?
1675      */
1676     if (uri == NULL)
1677         ret = -1;
1678     else {
1679         if (*uri) {
1680             ref = uri_new();
1681             if (ref == NULL)
1682                 goto done;
1683             ret = uri_parse_into(ref, uri);
1684         }
1685         else
1686             ret = 0;
1687     }
1688     if (ret != 0)
1689         goto done;
1690     if ((ref != NULL) && (ref->scheme != NULL)) {
1691         /*
1692          * The URI is absolute don't modify.
1693          */
1694         val = g_strdup(uri);
1695         goto done;
1696     }
1697     if (base == NULL)
1698         ret = -1;
1699     else {
1700         bas = uri_new();
1701         if (bas == NULL)
1702             goto done;
1703         ret = uri_parse_into(bas, base);
1704     }
1705     if (ret != 0) {
1706         if (ref)
1707             val = uri_to_string(ref);
1708         goto done;
1709     }
1710     if (ref == NULL) {
1711         /*
1712          * the base fragment must be ignored
1713          */
1714         if (bas->fragment != NULL) {
1715             g_free(bas->fragment);
1716             bas->fragment = NULL;
1717         }
1718         val = uri_to_string(bas);
1719         goto done;
1720     }
1721
1722     /*
1723      * 2) If the path component is empty and the scheme, authority, and
1724      *    query components are undefined, then it is a reference to the
1725      *    current document and we are done.  Otherwise, the reference URI's
1726      *    query and fragment components are defined as found (or not found)
1727      *    within the URI reference and not inherited from the base URI.
1728      *
1729      *    NOTE that in modern browsers, the parsing differs from the above
1730      *    in the following aspect:  the query component is allowed to be
1731      *    defined while still treating this as a reference to the current
1732      *    document.
1733      */
1734     res = uri_new();
1735     if (res == NULL)
1736         goto done;
1737     if ((ref->scheme == NULL) && (ref->path == NULL) &&
1738         ((ref->authority == NULL) && (ref->server == NULL))) {
1739         if (bas->scheme != NULL)
1740             res->scheme = g_strdup(bas->scheme);
1741         if (bas->authority != NULL)
1742             res->authority = g_strdup(bas->authority);
1743         else if (bas->server != NULL) {
1744             res->server = g_strdup(bas->server);
1745             if (bas->user != NULL)
1746                 res->user = g_strdup(bas->user);
1747             res->port = bas->port;
1748         }
1749         if (bas->path != NULL)
1750             res->path = g_strdup(bas->path);
1751         if (ref->query != NULL)
1752             res->query = g_strdup (ref->query);
1753         else if (bas->query != NULL)
1754             res->query = g_strdup(bas->query);
1755         if (ref->fragment != NULL)
1756             res->fragment = g_strdup(ref->fragment);
1757         goto step_7;
1758     }
1759
1760     /*
1761      * 3) If the scheme component is defined, indicating that the reference
1762      *    starts with a scheme name, then the reference is interpreted as an
1763      *    absolute URI and we are done.  Otherwise, the reference URI's
1764      *    scheme is inherited from the base URI's scheme component.
1765      */
1766     if (ref->scheme != NULL) {
1767         val = uri_to_string(ref);
1768         goto done;
1769     }
1770     if (bas->scheme != NULL)
1771         res->scheme = g_strdup(bas->scheme);
1772
1773     if (ref->query != NULL)
1774         res->query = g_strdup(ref->query);
1775     if (ref->fragment != NULL)
1776         res->fragment = g_strdup(ref->fragment);
1777
1778     /*
1779      * 4) If the authority component is defined, then the reference is a
1780      *    network-path and we skip to step 7.  Otherwise, the reference
1781      *    URI's authority is inherited from the base URI's authority
1782      *    component, which will also be undefined if the URI scheme does not
1783      *    use an authority component.
1784      */
1785     if ((ref->authority != NULL) || (ref->server != NULL)) {
1786         if (ref->authority != NULL)
1787             res->authority = g_strdup(ref->authority);
1788         else {
1789             res->server = g_strdup(ref->server);
1790             if (ref->user != NULL)
1791                 res->user = g_strdup(ref->user);
1792             res->port = ref->port;
1793         }
1794         if (ref->path != NULL)
1795             res->path = g_strdup(ref->path);
1796         goto step_7;
1797     }
1798     if (bas->authority != NULL)
1799         res->authority = g_strdup(bas->authority);
1800     else if (bas->server != NULL) {
1801         res->server = g_strdup(bas->server);
1802         if (bas->user != NULL)
1803             res->user = g_strdup(bas->user);
1804         res->port = bas->port;
1805     }
1806
1807     /*
1808      * 5) If the path component begins with a slash character ("/"), then
1809      *    the reference is an absolute-path and we skip to step 7.
1810      */
1811     if ((ref->path != NULL) && (ref->path[0] == '/')) {
1812         res->path = g_strdup(ref->path);
1813         goto step_7;
1814     }
1815
1816
1817     /*
1818      * 6) If this step is reached, then we are resolving a relative-path
1819      *    reference.  The relative path needs to be merged with the base
1820      *    URI's path.  Although there are many ways to do this, we will
1821      *    describe a simple method using a separate string buffer.
1822      *
1823      * Allocate a buffer large enough for the result string.
1824      */
1825     len = 2; /* extra / and 0 */
1826     if (ref->path != NULL)
1827         len += strlen(ref->path);
1828     if (bas->path != NULL)
1829         len += strlen(bas->path);
1830     res->path = g_malloc(len);
1831     res->path[0] = 0;
1832
1833     /*
1834      * a) All but the last segment of the base URI's path component is
1835      *    copied to the buffer.  In other words, any characters after the
1836      *    last (right-most) slash character, if any, are excluded.
1837      */
1838     cur = 0;
1839     out = 0;
1840     if (bas->path != NULL) {
1841         while (bas->path[cur] != 0) {
1842             while ((bas->path[cur] != 0) && (bas->path[cur] != '/'))
1843                 cur++;
1844             if (bas->path[cur] == 0)
1845                 break;
1846
1847             cur++;
1848             while (out < cur) {
1849                 res->path[out] = bas->path[out];
1850                 out++;
1851             }
1852         }
1853     }
1854     res->path[out] = 0;
1855
1856     /*
1857      * b) The reference's path component is appended to the buffer
1858      *    string.
1859      */
1860     if (ref->path != NULL && ref->path[0] != 0) {
1861         indx = 0;
1862         /*
1863          * Ensure the path includes a '/'
1864          */
1865         if ((out == 0) && (bas->server != NULL))
1866             res->path[out++] = '/';
1867         while (ref->path[indx] != 0) {
1868             res->path[out++] = ref->path[indx++];
1869         }
1870     }
1871     res->path[out] = 0;
1872
1873     /*
1874      * Steps c) to h) are really path normalization steps
1875      */
1876     normalize_uri_path(res->path);
1877
1878 step_7:
1879
1880     /*
1881      * 7) The resulting URI components, including any inherited from the
1882      *    base URI, are recombined to give the absolute form of the URI
1883      *    reference.
1884      */
1885     val = uri_to_string(res);
1886
1887 done:
1888     if (ref != NULL)
1889         uri_free(ref);
1890     if (bas != NULL)
1891         uri_free(bas);
1892     if (res != NULL)
1893         uri_free(res);
1894     return(val);
1895 }
1896
1897 /**
1898  * uri_resolve_relative:
1899  * @URI:  the URI reference under consideration
1900  * @base:  the base value
1901  *
1902  * Expresses the URI of the reference in terms relative to the
1903  * base.  Some examples of this operation include:
1904  *     base = "http://site1.com/docs/book1.html"
1905  *        URI input                        URI returned
1906  *     docs/pic1.gif                    pic1.gif
1907  *     docs/img/pic1.gif                img/pic1.gif
1908  *     img/pic1.gif                     ../img/pic1.gif
1909  *     http://site1.com/docs/pic1.gif   pic1.gif
1910  *     http://site2.com/docs/pic1.gif   http://site2.com/docs/pic1.gif
1911  *
1912  *     base = "docs/book1.html"
1913  *        URI input                        URI returned
1914  *     docs/pic1.gif                    pic1.gif
1915  *     docs/img/pic1.gif                img/pic1.gif
1916  *     img/pic1.gif                     ../img/pic1.gif
1917  *     http://site1.com/docs/pic1.gif   http://site1.com/docs/pic1.gif
1918  *
1919  *
1920  * Note: if the URI reference is really wierd or complicated, it may be
1921  *       worthwhile to first convert it into a "nice" one by calling
1922  *       uri_resolve (using 'base') before calling this routine,
1923  *       since this routine (for reasonable efficiency) assumes URI has
1924  *       already been through some validation.
1925  *
1926  * Returns a new URI string (to be freed by the caller) or NULL in case
1927  * error.
1928  */
1929 char *
1930 uri_resolve_relative (const char *uri, const char * base)
1931 {
1932     char *val = NULL;
1933     int ret;
1934     int ix;
1935     int pos = 0;
1936     int nbslash = 0;
1937     int len;
1938     URI *ref = NULL;
1939     URI *bas = NULL;
1940     char *bptr, *uptr, *vptr;
1941     int remove_path = 0;
1942
1943     if ((uri == NULL) || (*uri == 0))
1944         return NULL;
1945
1946     /*
1947      * First parse URI into a standard form
1948      */
1949     ref = uri_new ();
1950     if (ref == NULL)
1951         return NULL;
1952     /* If URI not already in "relative" form */
1953     if (uri[0] != '.') {
1954         ret = uri_parse_into (ref, uri);
1955         if (ret != 0)
1956             goto done;          /* Error in URI, return NULL */
1957     } else
1958         ref->path = g_strdup(uri);
1959
1960     /*
1961      * Next parse base into the same standard form
1962      */
1963     if ((base == NULL) || (*base == 0)) {
1964         val = g_strdup (uri);
1965         goto done;
1966     }
1967     bas = uri_new ();
1968     if (bas == NULL)
1969         goto done;
1970     if (base[0] != '.') {
1971         ret = uri_parse_into (bas, base);
1972         if (ret != 0)
1973             goto done;          /* Error in base, return NULL */
1974     } else
1975         bas->path = g_strdup(base);
1976
1977     /*
1978      * If the scheme / server on the URI differs from the base,
1979      * just return the URI
1980      */
1981     if ((ref->scheme != NULL) &&
1982         ((bas->scheme == NULL) ||
1983          (strcmp (bas->scheme, ref->scheme)) ||
1984          (strcmp (bas->server, ref->server)))) {
1985         val = g_strdup (uri);
1986         goto done;
1987     }
1988     if (!strcmp(bas->path, ref->path)) {
1989         val = g_strdup("");
1990         goto done;
1991     }
1992     if (bas->path == NULL) {
1993         val = g_strdup(ref->path);
1994         goto done;
1995     }
1996     if (ref->path == NULL) {
1997         ref->path = (char *) "/";
1998         remove_path = 1;
1999     }
2000
2001     /*
2002      * At this point (at last!) we can compare the two paths
2003      *
2004      * First we take care of the special case where either of the
2005      * two path components may be missing (bug 316224)
2006      */
2007     if (bas->path == NULL) {
2008         if (ref->path != NULL) {
2009             uptr = ref->path;
2010             if (*uptr == '/')
2011                 uptr++;
2012             /* exception characters from uri_to_string */
2013             val = uri_string_escape(uptr, "/;&=+$,");
2014         }
2015         goto done;
2016     }
2017     bptr = bas->path;
2018     if (ref->path == NULL) {
2019         for (ix = 0; bptr[ix] != 0; ix++) {
2020             if (bptr[ix] == '/')
2021                 nbslash++;
2022         }
2023         uptr = NULL;
2024         len = 1;        /* this is for a string terminator only */
2025     } else {
2026     /*
2027      * Next we compare the two strings and find where they first differ
2028      */
2029         if ((ref->path[pos] == '.') && (ref->path[pos+1] == '/'))
2030             pos += 2;
2031         if ((*bptr == '.') && (bptr[1] == '/'))
2032             bptr += 2;
2033         else if ((*bptr == '/') && (ref->path[pos] != '/'))
2034             bptr++;
2035         while ((bptr[pos] == ref->path[pos]) && (bptr[pos] != 0))
2036             pos++;
2037
2038         if (bptr[pos] == ref->path[pos]) {
2039             val = g_strdup("");
2040             goto done;          /* (I can't imagine why anyone would do this) */
2041         }
2042
2043         /*
2044          * In URI, "back up" to the last '/' encountered.  This will be the
2045          * beginning of the "unique" suffix of URI
2046          */
2047         ix = pos;
2048         if ((ref->path[ix] == '/') && (ix > 0))
2049             ix--;
2050         else if ((ref->path[ix] == 0) && (ix > 1) && (ref->path[ix - 1] == '/'))
2051             ix -= 2;
2052         for (; ix > 0; ix--) {
2053             if (ref->path[ix] == '/')
2054                 break;
2055         }
2056         if (ix == 0) {
2057             uptr = ref->path;
2058         } else {
2059             ix++;
2060             uptr = &ref->path[ix];
2061         }
2062
2063         /*
2064          * In base, count the number of '/' from the differing point
2065          */
2066         if (bptr[pos] != ref->path[pos]) {/* check for trivial URI == base */
2067             for (; bptr[ix] != 0; ix++) {
2068                 if (bptr[ix] == '/')
2069                     nbslash++;
2070             }
2071         }
2072         len = strlen (uptr) + 1;
2073     }
2074
2075     if (nbslash == 0) {
2076         if (uptr != NULL)
2077             /* exception characters from uri_to_string */
2078             val = uri_string_escape(uptr, "/;&=+$,");
2079         goto done;
2080     }
2081
2082     /*
2083      * Allocate just enough space for the returned string -
2084      * length of the remainder of the URI, plus enough space
2085      * for the "../" groups, plus one for the terminator
2086      */
2087     val = g_malloc (len + 3 * nbslash);
2088     vptr = val;
2089     /*
2090      * Put in as many "../" as needed
2091      */
2092     for (; nbslash>0; nbslash--) {
2093         *vptr++ = '.';
2094         *vptr++ = '.';
2095         *vptr++ = '/';
2096     }
2097     /*
2098      * Finish up with the end of the URI
2099      */
2100     if (uptr != NULL) {
2101         if ((vptr > val) && (len > 0) &&
2102             (uptr[0] == '/') && (vptr[-1] == '/')) {
2103             memcpy (vptr, uptr + 1, len - 1);
2104             vptr[len - 2] = 0;
2105         } else {
2106             memcpy (vptr, uptr, len);
2107             vptr[len - 1] = 0;
2108         }
2109     } else {
2110         vptr[len - 1] = 0;
2111     }
2112
2113     /* escape the freshly-built path */
2114     vptr = val;
2115         /* exception characters from uri_to_string */
2116     val = uri_string_escape(vptr, "/;&=+$,");
2117     g_free(vptr);
2118
2119 done:
2120     /*
2121      * Free the working variables
2122      */
2123     if (remove_path != 0)
2124         ref->path = NULL;
2125     if (ref != NULL)
2126         uri_free (ref);
2127     if (bas != NULL)
2128         uri_free (bas);
2129
2130     return val;
2131 }
2132
2133 /*
2134  * Utility functions to help parse and assemble query strings.
2135  */
2136
2137 struct QueryParams *
2138 query_params_new (int init_alloc)
2139 {
2140     struct QueryParams *ps;
2141
2142     if (init_alloc <= 0) init_alloc = 1;
2143
2144     ps = g_new(QueryParams, 1);
2145     ps->n = 0;
2146     ps->alloc = init_alloc;
2147     ps->p = g_new(QueryParam, ps->alloc);
2148
2149     return ps;
2150 }
2151
2152 /* Ensure there is space to store at least one more parameter
2153  * at the end of the set.
2154  */
2155 static int
2156 query_params_append (struct QueryParams *ps,
2157                const char *name, const char *value)
2158 {
2159     if (ps->n >= ps->alloc) {
2160         ps->p = g_renew(QueryParam, ps->p, ps->alloc * 2);
2161         ps->alloc *= 2;
2162     }
2163
2164     ps->p[ps->n].name = g_strdup(name);
2165     ps->p[ps->n].value = value ? g_strdup(value) : NULL;
2166     ps->p[ps->n].ignore = 0;
2167     ps->n++;
2168
2169     return 0;
2170 }
2171
2172 void
2173 query_params_free (struct QueryParams *ps)
2174 {
2175     int i;
2176
2177     for (i = 0; i < ps->n; ++i) {
2178         g_free (ps->p[i].name);
2179         g_free (ps->p[i].value);
2180     }
2181     g_free (ps->p);
2182     g_free (ps);
2183 }
2184
2185 struct QueryParams *
2186 query_params_parse (const char *query)
2187 {
2188     struct QueryParams *ps;
2189     const char *end, *eq;
2190
2191     ps = query_params_new (0);
2192     if (!query || query[0] == '\0') return ps;
2193
2194     while (*query) {
2195         char *name = NULL, *value = NULL;
2196
2197         /* Find the next separator, or end of the string. */
2198         end = strchr (query, '&');
2199         if (!end)
2200             end = strchr (query, ';');
2201         if (!end)
2202             end = query + strlen (query);
2203
2204         /* Find the first '=' character between here and end. */
2205         eq = strchr (query, '=');
2206         if (eq && eq >= end) eq = NULL;
2207
2208         /* Empty section (eg. "&&"). */
2209         if (end == query)
2210             goto next;
2211
2212         /* If there is no '=' character, then we have just "name"
2213          * and consistent with CGI.pm we assume value is "".
2214          */
2215         else if (!eq) {
2216             name = uri_string_unescape (query, end - query, NULL);
2217             value = NULL;
2218         }
2219         /* Or if we have "name=" here (works around annoying
2220          * problem when calling uri_string_unescape with len = 0).
2221          */
2222         else if (eq+1 == end) {
2223             name = uri_string_unescape (query, eq - query, NULL);
2224             value = g_new0(char, 1);
2225         }
2226         /* If the '=' character is at the beginning then we have
2227          * "=value" and consistent with CGI.pm we _ignore_ this.
2228          */
2229         else if (query == eq)
2230             goto next;
2231
2232         /* Otherwise it's "name=value". */
2233         else {
2234             name = uri_string_unescape (query, eq - query, NULL);
2235             value = uri_string_unescape (eq+1, end - (eq+1), NULL);
2236         }
2237
2238         /* Append to the parameter set. */
2239         query_params_append (ps, name, value);
2240         g_free(name);
2241         g_free(value);
2242
2243     next:
2244         query = end;
2245         if (*query) query ++; /* skip '&' separator */
2246     }
2247
2248     return ps;
2249 }