Coverage Report

Created: 2023-03-26 06:14

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