Coverage Report

Created: 2023-03-23 11:53

/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
145k
#define MAX_URI_LENGTH 1024 * 1024
37
38
9.48M
#define PORT_EMPTY           0
39
84.6k
#define PORT_EMPTY_SERVER   -1
40
41
static void
42
xmlURIErrMemory(const char *extra)
43
0
{
44
0
    if (extra)
45
0
        __xmlRaiseError(NULL, NULL, NULL,
46
0
                        NULL, NULL, XML_FROM_URI,
47
0
                        XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0,
48
0
                        extra, NULL, NULL, 0, 0,
49
0
                        "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
0
}
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
347M
#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
347M
#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
79.1M
#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
64.9M
#define IS_DIGIT(x) (((x) >= '0') && ((x) <= '9'))
89
90
/*
91
 * alphanum = alpha | digit
92
 */
93
94
347M
#define IS_ALPHANUM(x) (IS_ALPHA(x) || IS_DIGIT(x))
95
96
/*
97
 * mark = "-" | "_" | "." | "!" | "~" | "*" | "'" | "(" | ")"
98
 */
99
100
55.2M
#define IS_MARK(x) (((x) == '-') || ((x) == '_') || ((x) == '.') ||     \
101
55.2M
    ((x) == '!') || ((x) == '~') || ((x) == '*') || ((x) == '\'') ||    \
102
55.2M
    ((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
927k
#define IS_RESERVED(x) (((x) == ';') || ((x) == '/') || ((x) == '?') || \
118
927k
        ((x) == ':') || ((x) == '@') || ((x) == '&') || ((x) == '=') || \
119
927k
        ((x) == '+') || ((x) == '$') || ((x) == ',') || ((x) == '[') || \
120
927k
        ((x) == ']'))
121
122
/*
123
 * unreserved = alphanum | mark
124
 */
125
126
173M
#define IS_UNRESERVED(x) (IS_ALPHANUM(x) || IS_MARK(x))
127
128
/*
129
 * Skip to next pointer char, handle escaped sequences
130
 */
131
132
138M
#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
6.43M
#define STRNDUP(s, n) (char *) xmlStrndup((const xmlChar *)(s), (n))
145
146
/************************************************************************
147
 *                  *
148
 *                         RFC 3986 parser        *
149
 *                  *
150
 ************************************************************************/
151
152
176M
#define ISA_DIGIT(p) ((*(p) >= '0') && (*(p) <= '9'))
153
229M
#define ISA_ALPHA(p) (((*(p) >= 'a') && (*(p) <= 'z')) ||   \
154
229M
                      ((*(p) >= 'A') && (*(p) <= 'Z')))
155
#define ISA_HEXDIG(p)             \
156
31.3M
       (ISA_DIGIT(p) || ((*(p) >= 'a') && (*(p) <= 'f')) ||   \
157
31.3M
        ((*(p) >= 'A') && (*(p) <= 'F')))
158
159
/*
160
 *    sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
161
 *                     / "*" / "+" / "," / ";" / "="
162
 */
163
#define ISA_SUB_DELIM(p)            \
164
168M
      (((*(p) == '!')) || ((*(p) == '$')) || ((*(p) == '&')) ||   \
165
23.6M
       ((*(p) == '(')) || ((*(p) == ')')) || ((*(p) == '*')) ||   \
166
23.6M
       ((*(p) == '+')) || ((*(p) == ',')) || ((*(p) == ';')) ||   \
167
23.6M
       ((*(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
312M
      ((ISA_ALPHA(p)) || (ISA_DIGIT(p)) || ((*(p) == '-')) ||   \
187
156M
       ((*(p) == '.')) || ((*(p) == '_')) || ((*(p) == '~')))
188
189
/*
190
 *    pct-encoded   = "%" HEXDIG HEXDIG
191
 */
192
#define ISA_PCT_ENCODED(p)            \
193
195M
     ((*(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
197M
     (ISA_UNRESERVED(p) || ISA_PCT_ENCODED(p) || ISA_SUB_DELIM(p) ||  \
200
121M
      ((*(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
7.00M
xmlParse3986Scheme(xmlURIPtr uri, const char **str) {
215
7.00M
    const char *cur;
216
217
7.00M
    if (str == NULL)
218
0
  return(-1);
219
220
7.00M
    cur = *str;
221
7.00M
    if (!ISA_ALPHA(cur))
222
674k
  return(2);
223
6.32M
    cur++;
224
33.4M
    while (ISA_ALPHA(cur) || ISA_DIGIT(cur) ||
225
33.4M
           (*cur == '+') || (*cur == '-') || (*cur == '.')) cur++;
226
6.32M
    if (uri != NULL) {
227
6.32M
  if (uri->scheme != NULL) xmlFree(uri->scheme);
228
6.32M
  uri->scheme = STRNDUP(*str, cur - *str);
229
6.32M
    }
230
6.32M
    *str = cur;
231
6.32M
    return(0);
232
7.00M
}
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
110k
{
252
110k
    const char *cur;
253
254
110k
    if (str == NULL)
255
0
        return (-1);
256
257
110k
    cur = *str;
258
259
13.7M
    while ((ISA_PCHAR(cur)) || (*cur == '/') || (*cur == '?') ||
260
13.7M
           (*cur == '[') || (*cur == ']') ||
261
13.7M
           ((uri != NULL) && (uri->cleanup & 1) && (IS_UNWISE(cur))))
262
13.6M
        NEXT(cur);
263
110k
    if (uri != NULL) {
264
110k
        if (uri->fragment != NULL)
265
0
            xmlFree(uri->fragment);
266
110k
  if (uri->cleanup & 2)
267
0
      uri->fragment = STRNDUP(*str, cur - *str);
268
110k
  else
269
110k
      uri->fragment = xmlURIUnescapeString(*str, cur - *str, NULL);
270
110k
    }
271
110k
    *str = cur;
272
110k
    return (0);
273
110k
}
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
112k
{
289
112k
    const char *cur;
290
291
112k
    if (str == NULL)
292
0
        return (-1);
293
294
112k
    cur = *str;
295
296
13.8M
    while ((ISA_PCHAR(cur)) || (*cur == '/') || (*cur == '?') ||
297
13.8M
           ((uri != NULL) && (uri->cleanup & 1) && (IS_UNWISE(cur))))
298
13.7M
        NEXT(cur);
299
112k
    if (uri != NULL) {
300
112k
        if (uri->query != NULL)
301
0
            xmlFree(uri->query);
302
112k
  if (uri->cleanup & 2)
303
0
      uri->query = STRNDUP(*str, cur - *str);
304
112k
  else
305
112k
      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
112k
  if (uri->query_raw != NULL)
311
0
      xmlFree (uri->query_raw);
312
112k
  uri->query_raw = STRNDUP (*str, cur - *str);
313
112k
    }
314
112k
    *str = cur;
315
112k
    return (0);
316
112k
}
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
23.8k
{
333
23.8k
    const char *cur = *str;
334
23.8k
    int port = 0;
335
336
23.8k
    if (ISA_DIGIT(cur)) {
337
49.5k
  while (ISA_DIGIT(cur)) {
338
45.1k
            int digit = *cur - '0';
339
340
45.1k
            if (port > INT_MAX / 10)
341
565
                return(1);
342
44.5k
            port *= 10;
343
44.5k
            if (port > INT_MAX - digit)
344
0
                return(1);
345
44.5k
      port += digit;
346
347
44.5k
      cur++;
348
44.5k
  }
349
4.40k
  if (uri != NULL)
350
4.40k
      uri->port = port;
351
4.40k
  *str = cur;
352
4.40k
  return(0);
353
4.97k
    }
354
18.9k
    return(1);
355
23.8k
}
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
619k
{
372
619k
    const char *cur;
373
374
619k
    cur = *str;
375
24.0M
    while (ISA_UNRESERVED(cur) || ISA_PCT_ENCODED(cur) ||
376
24.0M
           ISA_SUB_DELIM(cur) || (*cur == ':'))
377
23.4M
  NEXT(cur);
378
619k
    if (*cur == '@') {
379
53.4k
  if (uri != NULL) {
380
53.4k
      if (uri->user != NULL) xmlFree(uri->user);
381
53.4k
      if (uri->cleanup & 2)
382
0
    uri->user = STRNDUP(*str, cur - *str);
383
53.4k
      else
384
53.4k
    uri->user = xmlURIUnescapeString(*str, cur - *str, NULL);
385
53.4k
  }
386
53.4k
  *str = cur;
387
53.4k
  return(0);
388
53.4k
    }
389
566k
    return(1);
390
619k
}
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
7.48k
xmlParse3986DecOctet(const char **str) {
408
7.48k
    const char *cur = *str;
409
410
7.48k
    if (!(ISA_DIGIT(cur)))
411
1.06k
        return(1);
412
6.42k
    if (!ISA_DIGIT(cur+1))
413
5.63k
  cur++;
414
793
    else if ((*cur != '0') && (ISA_DIGIT(cur + 1)) && (!ISA_DIGIT(cur+2)))
415
454
  cur += 2;
416
339
    else if ((*cur == '1') && (ISA_DIGIT(cur + 1)) && (ISA_DIGIT(cur + 2)))
417
41
  cur += 3;
418
298
    else if ((*cur == '2') && (*(cur + 1) >= '0') &&
419
298
       (*(cur + 1) <= '4') && (ISA_DIGIT(cur + 2)))
420
0
  cur += 3;
421
298
    else if ((*cur == '2') && (*(cur + 1) == '5') &&
422
298
       (*(cur + 2) >= '0') && (*(cur + 1) <= '5'))
423
0
  cur += 3;
424
298
    else
425
298
        return(1);
426
6.12k
    *str = cur;
427
6.12k
    return(0);
428
6.42k
}
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
619k
{
447
619k
    const char *cur = *str;
448
619k
    const char *host;
449
450
619k
    host = cur;
451
    /*
452
     * IPv6 and future addressing scheme are enclosed between brackets
453
     */
454
619k
    if (*cur == '[') {
455
6.03k
        cur++;
456
415k
  while ((*cur != ']') && (*cur != 0))
457
409k
      cur++;
458
6.03k
  if (*cur != ']')
459
4.42k
      return(1);
460
1.61k
  cur++;
461
1.61k
  goto found;
462
6.03k
    }
463
    /*
464
     * try to parse an IPv4
465
     */
466
613k
    if (ISA_DIGIT(cur)) {
467
6.40k
        if (xmlParse3986DecOctet(&cur) != 0)
468
298
      goto not_ipv4;
469
6.10k
  if (*cur != '.')
470
5.01k
      goto not_ipv4;
471
1.08k
  cur++;
472
1.08k
        if (xmlParse3986DecOctet(&cur) != 0)
473
1.06k
      goto not_ipv4;
474
25
  if (*cur != '.')
475
25
      goto not_ipv4;
476
0
        if (xmlParse3986DecOctet(&cur) != 0)
477
0
      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
6.40k
not_ipv4:
484
6.40k
        cur = *str;
485
6.40k
    }
486
    /*
487
     * then this should be a hostname which can be empty
488
     */
489
10.8M
    while (ISA_UNRESERVED(cur) || ISA_PCT_ENCODED(cur) || ISA_SUB_DELIM(cur))
490
10.2M
        NEXT(cur);
491
615k
found:
492
615k
    if (uri != NULL) {
493
615k
  if (uri->authority != NULL) xmlFree(uri->authority);
494
615k
  uri->authority = NULL;
495
615k
  if (uri->server != NULL) xmlFree(uri->server);
496
615k
  if (cur != host) {
497
515k
      if (uri->cleanup & 2)
498
0
    uri->server = STRNDUP(host, cur - host);
499
515k
      else
500
515k
    uri->server = xmlURIUnescapeString(host, cur - host, NULL);
501
515k
  } else
502
100k
      uri->server = NULL;
503
615k
    }
504
615k
    *str = cur;
505
615k
    return(0);
506
613k
}
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
619k
{
523
619k
    const char *cur;
524
619k
    int ret;
525
526
619k
    cur = *str;
527
    /*
528
     * try to parse an userinfo and check for the trailing @
529
     */
530
619k
    ret = xmlParse3986Userinfo(uri, &cur);
531
619k
    if ((ret != 0) || (*cur != '@'))
532
566k
        cur = *str;
533
53.4k
    else
534
53.4k
        cur++;
535
619k
    ret = xmlParse3986Host(uri, &cur);
536
619k
    if (ret != 0) return(ret);
537
615k
    if (*cur == ':') {
538
23.8k
        cur++;
539
23.8k
        ret = xmlParse3986Port(uri, &cur);
540
23.8k
  if (ret != 0) return(ret);
541
23.8k
    }
542
595k
    *str = cur;
543
595k
    return(0);
544
615k
}
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
10.2M
{
565
10.2M
    const char *cur;
566
567
10.2M
    cur = *str;
568
10.2M
    if (!ISA_PCHAR(cur)) {
569
1.87M
        if (empty)
570
1.82M
      return(0);
571
57.3k
  return(1);
572
1.87M
    }
573
76.7M
    while (ISA_PCHAR(cur) && (*cur != forbid))
574
68.4M
        NEXT(cur);
575
8.35M
    *str = cur;
576
8.35M
    return (0);
577
10.2M
}
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
595k
{
594
595k
    const char *cur;
595
595k
    int ret;
596
597
595k
    cur = *str;
598
599
2.91M
    while (*cur == '/') {
600
2.32M
        cur++;
601
2.32M
  ret = xmlParse3986Segment(&cur, 0, 1);
602
2.32M
  if (ret != 0) return(ret);
603
2.32M
    }
604
595k
    if (uri != NULL) {
605
595k
  if (uri->path != NULL) xmlFree(uri->path);
606
595k
        if (*str != cur) {
607
292k
            if (uri->cleanup & 2)
608
0
                uri->path = STRNDUP(*str, cur - *str);
609
292k
            else
610
292k
                uri->path = xmlURIUnescapeString(*str, cur - *str, NULL);
611
303k
        } else {
612
303k
            uri->path = NULL;
613
303k
        }
614
595k
    }
615
595k
    *str = cur;
616
595k
    return (0);
617
595k
}
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
220k
{
634
220k
    const char *cur;
635
220k
    int ret;
636
637
220k
    cur = *str;
638
639
220k
    if (*cur != '/')
640
0
        return(1);
641
220k
    cur++;
642
220k
    ret = xmlParse3986Segment(&cur, 0, 0);
643
220k
    if (ret == 0) {
644
298k
  while (*cur == '/') {
645
135k
      cur++;
646
135k
      ret = xmlParse3986Segment(&cur, 0, 1);
647
135k
      if (ret != 0) return(ret);
648
135k
  }
649
162k
    }
650
220k
    if (uri != NULL) {
651
220k
  if (uri->path != NULL) xmlFree(uri->path);
652
220k
        if (cur != *str) {
653
220k
            if (uri->cleanup & 2)
654
0
                uri->path = STRNDUP(*str, cur - *str);
655
220k
            else
656
220k
                uri->path = xmlURIUnescapeString(*str, cur - *str, NULL);
657
220k
        } else {
658
0
            uri->path = NULL;
659
0
        }
660
220k
    }
661
220k
    *str = cur;
662
220k
    return (0);
663
220k
}
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
396k
{
680
396k
    const char *cur;
681
396k
    int ret;
682
683
396k
    cur = *str;
684
685
396k
    ret = xmlParse3986Segment(&cur, 0, 0);
686
396k
    if (ret != 0) return(ret);
687
539k
    while (*cur == '/') {
688
143k
        cur++;
689
143k
  ret = xmlParse3986Segment(&cur, 0, 1);
690
143k
  if (ret != 0) return(ret);
691
143k
    }
692
396k
    if (uri != NULL) {
693
396k
  if (uri->path != NULL) xmlFree(uri->path);
694
396k
        if (cur != *str) {
695
396k
            if (uri->cleanup & 2)
696
0
                uri->path = STRNDUP(*str, cur - *str);
697
396k
            else
698
396k
                uri->path = xmlURIUnescapeString(*str, cur - *str, NULL);
699
396k
        } else {
700
0
            uri->path = NULL;
701
0
        }
702
396k
    }
703
396k
    *str = cur;
704
396k
    return (0);
705
396k
}
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
5.92M
{
722
5.92M
    const char *cur;
723
5.92M
    int ret;
724
725
5.92M
    cur = *str;
726
727
5.92M
    ret = xmlParse3986Segment(&cur, ':', 0);
728
5.92M
    if (ret != 0) return(ret);
729
7.01M
    while (*cur == '/') {
730
1.09M
        cur++;
731
1.09M
  ret = xmlParse3986Segment(&cur, 0, 1);
732
1.09M
  if (ret != 0) return(ret);
733
1.09M
    }
734
5.92M
    if (uri != NULL) {
735
5.92M
  if (uri->path != NULL) xmlFree(uri->path);
736
5.92M
        if (cur != *str) {
737
5.91M
            if (uri->cleanup & 2)
738
0
                uri->path = STRNDUP(*str, cur - *str);
739
5.91M
            else
740
5.91M
                uri->path = xmlURIUnescapeString(*str, cur - *str, NULL);
741
5.91M
        } else {
742
5.94k
            uri->path = NULL;
743
5.94k
        }
744
5.92M
    }
745
5.92M
    *str = cur;
746
5.92M
    return (0);
747
5.92M
}
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
1.16M
{
767
1.16M
    const char *cur;
768
1.16M
    int ret;
769
770
1.16M
    cur = *str;
771
772
1.16M
    if ((*cur == '/') && (*(cur + 1) == '/')) {
773
589k
        cur += 2;
774
589k
  ret = xmlParse3986Authority(uri, &cur);
775
589k
  if (ret != 0) return(ret);
776
        /*
777
         * An empty server is marked with a special URI value.
778
         */
779
566k
  if ((uri->server == NULL) && (uri->port == PORT_EMPTY))
780
84.6k
      uri->port = PORT_EMPTY_SERVER;
781
566k
  ret = xmlParse3986PathAbEmpty(uri, &cur);
782
566k
  if (ret != 0) return(ret);
783
566k
  *str = cur;
784
566k
  return(0);
785
579k
    } else if (*cur == '/') {
786
135k
        ret = xmlParse3986PathAbsolute(uri, &cur);
787
135k
  if (ret != 0) return(ret);
788
443k
    } else if (ISA_PCHAR(cur)) {
789
396k
        ret = xmlParse3986PathRootless(uri, &cur);
790
396k
  if (ret != 0) return(ret);
791
396k
    } else {
792
  /* path-empty is effectively empty */
793
47.8k
  if (uri != NULL) {
794
47.8k
      if (uri->path != NULL) xmlFree(uri->path);
795
47.8k
      uri->path = NULL;
796
47.8k
  }
797
47.8k
    }
798
579k
    *str = cur;
799
579k
    return (0);
800
1.16M
}
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
6.23M
xmlParse3986RelativeRef(xmlURIPtr uri, const char *str) {
820
6.23M
    int ret;
821
822
6.23M
    if ((*str == '/') && (*(str + 1) == '/')) {
823
30.6k
        str += 2;
824
30.6k
  ret = xmlParse3986Authority(uri, &str);
825
30.6k
  if (ret != 0) return(ret);
826
29.1k
  ret = xmlParse3986PathAbEmpty(uri, &str);
827
29.1k
  if (ret != 0) return(ret);
828
6.19M
    } else if (*str == '/') {
829
84.9k
  ret = xmlParse3986PathAbsolute(uri, &str);
830
84.9k
  if (ret != 0) return(ret);
831
6.11M
    } else if (ISA_PCHAR(str)) {
832
5.92M
        ret = xmlParse3986PathNoScheme(uri, &str);
833
5.92M
  if (ret != 0) return(ret);
834
5.92M
    } else {
835
  /* path-empty is effectively empty */
836
191k
  if (uri != NULL) {
837
191k
      if (uri->path != NULL) xmlFree(uri->path);
838
191k
      uri->path = NULL;
839
191k
  }
840
191k
    }
841
842
6.22M
    if (*str == '?') {
843
85.9k
  str++;
844
85.9k
  ret = xmlParse3986Query(uri, &str);
845
85.9k
  if (ret != 0) return(ret);
846
85.9k
    }
847
6.22M
    if (*str == '#') {
848
85.8k
  str++;
849
85.8k
  ret = xmlParse3986Fragment(uri, &str);
850
85.8k
  if (ret != 0) return(ret);
851
85.8k
    }
852
6.22M
    if (*str != 0) {
853
1.05M
  xmlCleanURI(uri);
854
1.05M
  return(1);
855
1.05M
    }
856
5.16M
    return(0);
857
6.22M
}
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
7.00M
xmlParse3986URI(xmlURIPtr uri, const char *str) {
874
7.00M
    int ret;
875
876
7.00M
    ret = xmlParse3986Scheme(uri, &str);
877
7.00M
    if (ret != 0) return(ret);
878
6.32M
    if (*str != ':') {
879
5.15M
  return(1);
880
5.15M
    }
881
1.16M
    str++;
882
1.16M
    ret = xmlParse3986HierPart(uri, &str);
883
1.16M
    if (ret != 0) return(ret);
884
1.14M
    if (*str == '?') {
885
26.4k
  str++;
886
26.4k
  ret = xmlParse3986Query(uri, &str);
887
26.4k
  if (ret != 0) return(ret);
888
26.4k
    }
889
1.14M
    if (*str == '#') {
890
24.4k
  str++;
891
24.4k
  ret = xmlParse3986Fragment(uri, &str);
892
24.4k
  if (ret != 0) return(ret);
893
24.4k
    }
894
1.14M
    if (*str != 0) {
895
374k
  xmlCleanURI(uri);
896
374k
  return(1);
897
374k
    }
898
771k
    return(0);
899
1.14M
}
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
7.00M
xmlParse3986URIReference(xmlURIPtr uri, const char *str) {
915
7.00M
    int ret;
916
917
7.00M
    if (str == NULL)
918
0
  return(-1);
919
7.00M
    xmlCleanURI(uri);
920
921
    /*
922
     * Try first to parse absolute refs, then fallback to relative if
923
     * it fails.
924
     */
925
7.00M
    ret = xmlParse3986URI(uri, str);
926
7.00M
    if (ret != 0) {
927
6.23M
  xmlCleanURI(uri);
928
6.23M
        ret = xmlParse3986RelativeRef(uri, str);
929
6.23M
  if (ret != 0) {
930
1.06M
      xmlCleanURI(uri);
931
1.06M
      return(ret);
932
1.06M
  }
933
6.23M
    }
934
5.94M
    return(0);
935
7.00M
}
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
5.24M
xmlParseURI(const char *str) {
949
5.24M
    xmlURIPtr uri;
950
5.24M
    int ret;
951
952
5.24M
    if (str == NULL)
953
0
  return(NULL);
954
5.24M
    uri = xmlCreateURI();
955
5.24M
    if (uri != NULL) {
956
5.24M
  ret = xmlParse3986URIReference(uri, str);
957
5.24M
        if (ret) {
958
963k
      xmlFreeURI(uri);
959
963k
      return(NULL);
960
963k
  }
961
5.24M
    }
962
4.27M
    return(uri);
963
5.24M
}
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.75M
xmlParseURIReference(xmlURIPtr uri, const char *str) {
979
1.75M
    return(xmlParse3986URIReference(uri, str));
980
1.75M
}
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
7.25M
xmlCreateURI(void) {
1029
7.25M
    xmlURIPtr ret;
1030
1031
7.25M
    ret = (xmlURIPtr) xmlMalloc(sizeof(xmlURI));
1032
7.25M
    if (ret == NULL) {
1033
0
        xmlURIErrMemory("creating URI structure\n");
1034
0
  return(NULL);
1035
0
    }
1036
7.25M
    memset(ret, 0, sizeof(xmlURI));
1037
7.25M
    ret->port = PORT_EMPTY;
1038
7.25M
    return(ret);
1039
7.25M
}
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
145k
xmlSaveUriRealloc(xmlChar *ret, int *max) {
1049
145k
    xmlChar *temp;
1050
145k
    int tmp;
1051
1052
145k
    if (*max > MAX_URI_LENGTH) {
1053
0
        xmlURIErrMemory("reaching arbitrary MAX_URI_LENGTH limit\n");
1054
0
        return(NULL);
1055
0
    }
1056
145k
    tmp = *max * 2;
1057
145k
    temp = (xmlChar *) xmlRealloc(ret, (tmp + 1));
1058
145k
    if (temp == NULL) {
1059
0
        xmlURIErrMemory("saving URI\n");
1060
0
        return(NULL);
1061
0
    }
1062
145k
    *max = tmp;
1063
145k
    return(temp);
1064
145k
}
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
1.52M
xmlSaveUri(xmlURIPtr uri) {
1076
1.52M
    xmlChar *ret = NULL;
1077
1.52M
    xmlChar *temp;
1078
1.52M
    const char *p;
1079
1.52M
    int len;
1080
1.52M
    int max;
1081
1082
1.52M
    if (uri == NULL) return(NULL);
1083
1084
1085
1.52M
    max = 80;
1086
1.52M
    ret = (xmlChar *) xmlMallocAtomic(max + 1);
1087
1.52M
    if (ret == NULL) {
1088
0
        xmlURIErrMemory("saving URI\n");
1089
0
  return(NULL);
1090
0
    }
1091
1.52M
    len = 0;
1092
1093
1.52M
    if (uri->scheme != NULL) {
1094
54.5k
  p = uri->scheme;
1095
1.31M
  while (*p != 0) {
1096
1.26M
      if (len >= max) {
1097
1.69k
                temp = xmlSaveUriRealloc(ret, &max);
1098
1.69k
                if (temp == NULL) goto mem_error;
1099
1.69k
    ret = temp;
1100
1.69k
      }
1101
1.26M
      ret[len++] = *p++;
1102
1.26M
  }
1103
54.5k
  if (len >= max) {
1104
99
            temp = xmlSaveUriRealloc(ret, &max);
1105
99
            if (temp == NULL) goto mem_error;
1106
99
            ret = temp;
1107
99
  }
1108
54.5k
  ret[len++] = ':';
1109
54.5k
    }
1110
1.52M
    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
1.52M
    } else {
1129
1.52M
  if ((uri->server != NULL) || (uri->port != PORT_EMPTY)) {
1130
44.5k
      if (len + 3 >= max) {
1131
54
                temp = xmlSaveUriRealloc(ret, &max);
1132
54
                if (temp == NULL) goto mem_error;
1133
54
                ret = temp;
1134
54
      }
1135
44.5k
      ret[len++] = '/';
1136
44.5k
      ret[len++] = '/';
1137
44.5k
      if (uri->user != NULL) {
1138
13.9k
    p = uri->user;
1139
3.84M
    while (*p != 0) {
1140
3.83M
        if (len + 3 >= max) {
1141
9.49k
                        temp = xmlSaveUriRealloc(ret, &max);
1142
9.49k
                        if (temp == NULL) goto mem_error;
1143
9.49k
                        ret = temp;
1144
9.49k
        }
1145
3.83M
        if ((IS_UNRESERVED(*(p))) ||
1146
3.83M
      ((*(p) == ';')) || ((*(p) == ':')) ||
1147
3.83M
      ((*(p) == '&')) || ((*(p) == '=')) ||
1148
3.83M
      ((*(p) == '+')) || ((*(p) == '$')) ||
1149
3.83M
      ((*(p) == ',')))
1150
2.61M
      ret[len++] = *p++;
1151
1.21M
        else {
1152
1.21M
      int val = *(unsigned char *)p++;
1153
1.21M
      int hi = val / 0x10, lo = val % 0x10;
1154
1.21M
      ret[len++] = '%';
1155
1.21M
      ret[len++] = hi + (hi > 9? 'A'-10 : '0');
1156
1.21M
      ret[len++] = lo + (lo > 9? 'A'-10 : '0');
1157
1.21M
        }
1158
3.83M
    }
1159
13.9k
    if (len + 3 >= max) {
1160
686
                    temp = xmlSaveUriRealloc(ret, &max);
1161
686
                    if (temp == NULL) goto mem_error;
1162
686
                    ret = temp;
1163
686
    }
1164
13.9k
    ret[len++] = '@';
1165
13.9k
      }
1166
44.5k
      if (uri->server != NULL) {
1167
40.8k
    p = uri->server;
1168
1.41M
    while (*p != 0) {
1169
1.36M
        if (len >= max) {
1170
4.02k
      temp = xmlSaveUriRealloc(ret, &max);
1171
4.02k
      if (temp == NULL) goto mem_error;
1172
4.02k
      ret = temp;
1173
4.02k
        }
1174
                    /* TODO: escaping? */
1175
1.36M
        ret[len++] = (xmlChar) *p++;
1176
1.36M
    }
1177
40.8k
      }
1178
44.5k
            if (uri->port > 0) {
1179
539
                if (len + 10 >= max) {
1180
20
                    temp = xmlSaveUriRealloc(ret, &max);
1181
20
                    if (temp == NULL) goto mem_error;
1182
20
                    ret = temp;
1183
20
                }
1184
539
                len += snprintf((char *) &ret[len], max - len, ":%d", uri->port);
1185
539
            }
1186
1.48M
  } 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
1.48M
  } else if (uri->scheme != NULL) {
1215
23.0k
      if (len + 3 >= max) {
1216
258
                temp = xmlSaveUriRealloc(ret, &max);
1217
258
                if (temp == NULL) goto mem_error;
1218
258
                ret = temp;
1219
258
      }
1220
23.0k
  }
1221
1.52M
  if (uri->path != NULL) {
1222
1.51M
      p = uri->path;
1223
      /*
1224
       * the colon in file:///d: should not be escaped or
1225
       * Windows accesses fail later.
1226
       */
1227
1.51M
      if ((uri->scheme != NULL) &&
1228
1.51M
    (p[0] == '/') &&
1229
1.51M
    (((p[1] >= 'a') && (p[1] <= 'z')) ||
1230
34.0k
     ((p[1] >= 'A') && (p[1] <= 'Z'))) &&
1231
1.51M
    (p[2] == ':') &&
1232
1.51M
          (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
95.0M
      while (*p != 0) {
1243
93.5M
    if (len + 3 >= max) {
1244
86.2k
                    temp = xmlSaveUriRealloc(ret, &max);
1245
86.2k
                    if (temp == NULL) goto mem_error;
1246
86.2k
                    ret = temp;
1247
86.2k
    }
1248
93.5M
    if ((IS_UNRESERVED(*(p))) || ((*(p) == '/')) ||
1249
93.5M
                    ((*(p) == ';')) || ((*(p) == '@')) || ((*(p) == '&')) ||
1250
93.5M
              ((*(p) == '=')) || ((*(p) == '+')) || ((*(p) == '$')) ||
1251
93.5M
              ((*(p) == ',')))
1252
76.5M
        ret[len++] = *p++;
1253
17.0M
    else {
1254
17.0M
        int val = *(unsigned char *)p++;
1255
17.0M
        int hi = val / 0x10, lo = val % 0x10;
1256
17.0M
        ret[len++] = '%';
1257
17.0M
        ret[len++] = hi + (hi > 9? 'A'-10 : '0');
1258
17.0M
        ret[len++] = lo + (lo > 9? 'A'-10 : '0');
1259
17.0M
    }
1260
93.5M
      }
1261
1.51M
  }
1262
1.52M
  if (uri->query_raw != NULL) {
1263
24.0k
      if (len + 1 >= max) {
1264
502
                temp = xmlSaveUriRealloc(ret, &max);
1265
502
                if (temp == NULL) goto mem_error;
1266
502
                ret = temp;
1267
502
      }
1268
24.0k
      ret[len++] = '?';
1269
24.0k
      p = uri->query_raw;
1270
2.21M
      while (*p != 0) {
1271
2.19M
    if (len + 1 >= max) {
1272
5.90k
                    temp = xmlSaveUriRealloc(ret, &max);
1273
5.90k
                    if (temp == NULL) goto mem_error;
1274
5.90k
                    ret = temp;
1275
5.90k
    }
1276
2.19M
    ret[len++] = *p++;
1277
2.19M
      }
1278
1.50M
  } 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
1.52M
    }
1304
1.52M
    if (uri->fragment != NULL) {
1305
10.9k
  if (len + 3 >= max) {
1306
152
            temp = xmlSaveUriRealloc(ret, &max);
1307
152
            if (temp == NULL) goto mem_error;
1308
152
            ret = temp;
1309
152
  }
1310
10.9k
  ret[len++] = '#';
1311
10.9k
  p = uri->fragment;
1312
3.34M
  while (*p != 0) {
1313
3.33M
      if (len + 3 >= max) {
1314
7.95k
                temp = xmlSaveUriRealloc(ret, &max);
1315
7.95k
                if (temp == NULL) goto mem_error;
1316
7.95k
                ret = temp;
1317
7.95k
      }
1318
3.33M
      if ((IS_UNRESERVED(*(p))) || (IS_RESERVED(*(p))))
1319
3.33M
    ret[len++] = *p++;
1320
833
      else {
1321
833
    int val = *(unsigned char *)p++;
1322
833
    int hi = val / 0x10, lo = val % 0x10;
1323
833
    ret[len++] = '%';
1324
833
    ret[len++] = hi + (hi > 9? 'A'-10 : '0');
1325
833
    ret[len++] = lo + (lo > 9? 'A'-10 : '0');
1326
833
      }
1327
3.33M
  }
1328
10.9k
    }
1329
1.52M
    if (len >= max) {
1330
316
        temp = xmlSaveUriRealloc(ret, &max);
1331
316
        if (temp == NULL) goto mem_error;
1332
316
        ret = temp;
1333
316
    }
1334
1.52M
    ret[len] = 0;
1335
1.52M
    return(ret);
1336
1337
0
mem_error:
1338
0
    xmlFree(ret);
1339
0
    return(NULL);
1340
1.52M
}
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
15.7M
xmlCleanURI(xmlURIPtr uri) {
1368
15.7M
    if (uri == NULL) return;
1369
1370
15.7M
    if (uri->scheme != NULL) xmlFree(uri->scheme);
1371
15.7M
    uri->scheme = NULL;
1372
15.7M
    if (uri->server != NULL) xmlFree(uri->server);
1373
15.7M
    uri->server = NULL;
1374
15.7M
    if (uri->user != NULL) xmlFree(uri->user);
1375
15.7M
    uri->user = NULL;
1376
15.7M
    if (uri->path != NULL) xmlFree(uri->path);
1377
15.7M
    uri->path = NULL;
1378
15.7M
    if (uri->fragment != NULL) xmlFree(uri->fragment);
1379
15.7M
    uri->fragment = NULL;
1380
15.7M
    if (uri->opaque != NULL) xmlFree(uri->opaque);
1381
15.7M
    uri->opaque = NULL;
1382
15.7M
    if (uri->authority != NULL) xmlFree(uri->authority);
1383
15.7M
    uri->authority = NULL;
1384
15.7M
    if (uri->query != NULL) xmlFree(uri->query);
1385
15.7M
    uri->query = NULL;
1386
15.7M
    if (uri->query_raw != NULL) xmlFree(uri->query_raw);
1387
15.7M
    uri->query_raw = NULL;
1388
15.7M
}
1389
1390
/**
1391
 * xmlFreeURI:
1392
 * @uri:  pointer to an xmlURI
1393
 *
1394
 * Free up the xmlURI struct
1395
 */
1396
void
1397
7.25M
xmlFreeURI(xmlURIPtr uri) {
1398
7.25M
    if (uri == NULL) return;
1399
1400
7.25M
    if (uri->scheme != NULL) xmlFree(uri->scheme);
1401
7.25M
    if (uri->server != NULL) xmlFree(uri->server);
1402
7.25M
    if (uri->user != NULL) xmlFree(uri->user);
1403
7.25M
    if (uri->path != NULL) xmlFree(uri->path);
1404
7.25M
    if (uri->fragment != NULL) xmlFree(uri->fragment);
1405
7.25M
    if (uri->opaque != NULL) xmlFree(uri->opaque);
1406
7.25M
    if (uri->authority != NULL) xmlFree(uri->authority);
1407
7.25M
    if (uri->query != NULL) xmlFree(uri->query);
1408
7.25M
    if (uri->query_raw != NULL) xmlFree(uri->query_raw);
1409
7.25M
    xmlFree(uri);
1410
7.25M
}
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
248k
xmlNormalizeURIPath(char *path) {
1431
248k
    char *cur, *out;
1432
1433
248k
    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
248k
    cur = path;
1440
327k
    while (cur[0] == '/')
1441
78.4k
      ++cur;
1442
248k
    if (cur[0] == '\0')
1443
0
      return(0);
1444
1445
    /* Keep everything we've seen so far.  */
1446
248k
    out = cur;
1447
1448
    /*
1449
     * Analyze each segment in sequence for cases (c) and (d).
1450
     */
1451
489k
    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
488k
  if ((cur[0] == '.') && (cur[1] == '/')) {
1457
1.86k
      cur += 2;
1458
      /* '//' normalization should be done at this point too */
1459
34.8k
      while (cur[0] == '/')
1460
33.0k
    cur++;
1461
1.86k
      continue;
1462
1.86k
  }
1463
1464
  /*
1465
   * d) If the buffer string ends with "." as a complete path segment,
1466
   *    that "." is removed.
1467
   */
1468
486k
  if ((cur[0] == '.') && (cur[1] == '\0'))
1469
138
      break;
1470
1471
  /* Otherwise keep the segment.  */
1472
5.19M
  while (cur[0] != '/') {
1473
4.95M
            if (cur[0] == '\0')
1474
247k
              goto done_cd;
1475
4.71M
      (out++)[0] = (cur++)[0];
1476
4.71M
  }
1477
  /* normalize // */
1478
539k
  while ((cur[0] == '/') && (cur[1] == '/'))
1479
300k
      cur++;
1480
1481
238k
        (out++)[0] = (cur++)[0];
1482
238k
    }
1483
248k
 done_cd:
1484
248k
    out[0] = '\0';
1485
1486
    /* Reset to the beginning of the first segment for the next sequence.  */
1487
248k
    cur = path;
1488
327k
    while (cur[0] == '/')
1489
78.4k
      ++cur;
1490
248k
    if (cur[0] == '\0')
1491
96
  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
486k
    while (1) {
1512
486k
        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
486k
        segp = cur;
1520
5.25M
        while ((segp[0] != '/') && (segp[0] != '\0'))
1521
4.76M
          ++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
486k
        if (segp[0] == '\0')
1527
248k
          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
237k
        ++segp;
1533
237k
        if (((cur[0] == '.') && (cur[1] == '.') && (segp == cur+3))
1534
237k
            || ((segp[0] != '.') || (segp[1] != '.')
1535
236k
                || ((segp[2] != '/') && (segp[2] != '\0')))) {
1536
227k
          cur = segp;
1537
227k
          continue;
1538
227k
        }
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
10.7k
        if (segp[2] == '\0') {
1549
42
          cur[0] = '\0';
1550
42
          break;
1551
42
        }
1552
        /* Valgrind complained, strcpy(cur, segp + 3); */
1553
        /* string will overlap, do not use strcpy */
1554
10.7k
        tmp = cur;
1555
10.7k
        segp += 3;
1556
73.4M
        while ((*tmp++ = *segp++) != 0)
1557
73.4M
          ;
1558
1559
        /* If there are no previous segments, then keep going from here.  */
1560
10.7k
        segp = cur;
1561
30.3k
        while ((segp > path) && ((--segp)[0] == '/'))
1562
19.6k
          ;
1563
10.7k
        if (segp == path)
1564
993
          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
9.71k
        cur = segp;
1574
78.8k
        while ((cur > path) && (cur[-1] != '/'))
1575
69.0k
          --cur;
1576
9.71k
    }
1577
248k
    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
248k
    if (path[0] == '/') {
1591
42.0k
      cur = path;
1592
43.0k
      while ((cur[0] == '/') && (cur[1] == '.') && (cur[2] == '.')
1593
43.0k
             && ((cur[3] == '/') || (cur[3] == '\0')))
1594
1.07k
  cur += 3;
1595
1596
42.0k
      if (cur != path) {
1597
957
  out = path;
1598
220k
  while (cur[0] != '\0')
1599
219k
          (out++)[0] = (cur++)[0];
1600
957
  out[0] = 0;
1601
957
      }
1602
42.0k
    }
1603
1604
248k
    return(0);
1605
248k
}
1606
1607
32.7M
static int is_hex(char c) {
1608
32.7M
    if (((c >= '0') && (c <= '9')) ||
1609
32.7M
        ((c >= 'a') && (c <= 'f')) ||
1610
32.7M
        ((c >= 'A') && (c <= 'F')))
1611
32.7M
  return(1);
1612
43.9k
    return(0);
1613
32.7M
}
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
7.61M
xmlURIUnescapeString(const char *str, int len, char *target) {
1631
7.61M
    char *ret, *out;
1632
7.61M
    const char *in;
1633
1634
7.61M
    if (str == NULL)
1635
0
  return(NULL);
1636
7.61M
    if (len <= 0) len = strlen(str);
1637
7.61M
    if (len < 0) return(NULL);
1638
1639
7.61M
    if (target == NULL) {
1640
7.61M
  ret = (char *) xmlMallocAtomic(len + 1);
1641
7.61M
  if (ret == NULL) {
1642
0
            xmlURIErrMemory("unescaping URI value\n");
1643
0
      return(NULL);
1644
0
  }
1645
7.61M
    } else
1646
0
  ret = target;
1647
7.61M
    in = str;
1648
7.61M
    out = ret;
1649
180M
    while(len > 0) {
1650
173M
  if ((len > 2) && (*in == '%') && (is_hex(in[1])) && (is_hex(in[2]))) {
1651
16.3M
            int c = 0;
1652
16.3M
      in++;
1653
16.3M
      if ((*in >= '0') && (*in <= '9'))
1654
9.38M
          c = (*in - '0');
1655
6.97M
      else if ((*in >= 'a') && (*in <= 'f'))
1656
98.9k
          c = (*in - 'a') + 10;
1657
6.87M
      else if ((*in >= 'A') && (*in <= 'F'))
1658
6.87M
          c = (*in - 'A') + 10;
1659
16.3M
      in++;
1660
16.3M
      if ((*in >= '0') && (*in <= '9'))
1661
11.7M
          c = c * 16 + (*in - '0');
1662
4.58M
      else if ((*in >= 'a') && (*in <= 'f'))
1663
95.1k
          c = c * 16 + (*in - 'a') + 10;
1664
4.49M
      else if ((*in >= 'A') && (*in <= 'F'))
1665
4.49M
          c = c * 16 + (*in - 'A') + 10;
1666
16.3M
      in++;
1667
16.3M
      len -= 3;
1668
            /* Explicit sign change */
1669
16.3M
      *out++ = (char) c;
1670
156M
  } else {
1671
156M
      *out++ = *in++;
1672
156M
      len--;
1673
156M
  }
1674
173M
    }
1675
7.61M
    *out = 0;
1676
7.61M
    return(ret);
1677
7.61M
}
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
64.8k
xmlURIEscapeStr(const xmlChar *str, const xmlChar *list) {
1691
64.8k
    xmlChar *ret, ch;
1692
64.8k
    xmlChar *temp;
1693
64.8k
    const xmlChar *in;
1694
64.8k
    int len, out;
1695
1696
64.8k
    if (str == NULL)
1697
0
  return(NULL);
1698
64.8k
    if (str[0] == 0)
1699
0
  return(xmlStrdup(str));
1700
64.8k
    len = xmlStrlen(str);
1701
64.8k
    if (!(len > 0)) return(NULL);
1702
1703
64.8k
    len += 20;
1704
64.8k
    ret = (xmlChar *) xmlMallocAtomic(len);
1705
64.8k
    if (ret == NULL) {
1706
0
        xmlURIErrMemory("escaping URI value\n");
1707
0
  return(NULL);
1708
0
    }
1709
64.8k
    in = (const xmlChar *) str;
1710
64.8k
    out = 0;
1711
73.1M
    while(*in != 0) {
1712
73.0M
  if (len - out <= 3) {
1713
27.7k
            temp = xmlSaveUriRealloc(ret, &len);
1714
27.7k
      if (temp == NULL) {
1715
0
                xmlURIErrMemory("escaping URI value\n");
1716
0
    xmlFree(ret);
1717
0
    return(NULL);
1718
0
      }
1719
27.7k
      ret = temp;
1720
27.7k
  }
1721
1722
73.0M
  ch = *in;
1723
1724
73.0M
  if ((ch != '@') && (!IS_UNRESERVED(ch)) && (!xmlStrchr(list, ch))) {
1725
17.7M
      unsigned char val;
1726
17.7M
      ret[out++] = '%';
1727
17.7M
      val = ch >> 4;
1728
17.7M
      if (val <= 9)
1729
15.1M
    ret[out++] = '0' + val;
1730
2.68M
      else
1731
2.68M
    ret[out++] = 'A' + val - 0xA;
1732
17.7M
      val = ch & 0xF;
1733
17.7M
      if (val <= 9)
1734
11.5M
    ret[out++] = '0' + val;
1735
6.19M
      else
1736
6.19M
    ret[out++] = 'A' + val - 0xA;
1737
17.7M
      in++;
1738
55.2M
  } else {
1739
55.2M
      ret[out++] = *in++;
1740
55.2M
  }
1741
1742
73.0M
    }
1743
64.8k
    ret[out] = 0;
1744
64.8k
    return(ret);
1745
64.8k
}
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
1.43M
xmlBuildURI(const xmlChar *URI, const xmlChar *base) {
1904
1.43M
    xmlChar *val = NULL;
1905
1.43M
    int ret, len, indx, cur, out;
1906
1.43M
    xmlURIPtr ref = NULL;
1907
1.43M
    xmlURIPtr bas = NULL;
1908
1.43M
    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
1.43M
    if (URI == NULL)
1919
1.11k
  ret = -1;
1920
1.43M
    else {
1921
1.43M
  if (*URI) {
1922
1.42M
      ref = xmlCreateURI();
1923
1.42M
      if (ref == NULL)
1924
0
    goto done;
1925
1.42M
      ret = xmlParseURIReference(ref, (const char *) URI);
1926
1.42M
  }
1927
5.03k
  else
1928
5.03k
      ret = 0;
1929
1.43M
    }
1930
1.43M
    if (ret != 0)
1931
20.8k
  goto done;
1932
1.41M
    if ((ref != NULL) && (ref->scheme != NULL)) {
1933
  /*
1934
   * The URI is absolute don't modify.
1935
   */
1936
69.0k
  val = xmlStrdup(URI);
1937
69.0k
  goto done;
1938
69.0k
    }
1939
1.34M
    if (base == NULL)
1940
1.01M
  ret = -1;
1941
331k
    else {
1942
331k
  bas = xmlCreateURI();
1943
331k
  if (bas == NULL)
1944
0
      goto done;
1945
331k
  ret = xmlParseURIReference(bas, (const char *) base);
1946
331k
    }
1947
1.34M
    if (ret != 0) {
1948
1.08M
  if (ref)
1949
1.08M
      val = xmlSaveUri(ref);
1950
1.08M
  goto done;
1951
1.08M
    }
1952
254k
    if (ref == NULL) {
1953
  /*
1954
   * the base fragment must be ignored
1955
   */
1956
2.75k
  if (bas->fragment != NULL) {
1957
297
      xmlFree(bas->fragment);
1958
297
      bas->fragment = NULL;
1959
297
  }
1960
2.75k
  val = xmlSaveUri(bas);
1961
2.75k
  goto done;
1962
2.75k
    }
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
251k
    res = xmlCreateURI();
1977
251k
    if (res == NULL)
1978
0
  goto done;
1979
251k
    if ((ref->scheme == NULL) && (ref->path == NULL) &&
1980
251k
  ((ref->authority == NULL) && (ref->server == NULL) &&
1981
2.25k
         (ref->port == PORT_EMPTY))) {
1982
1.70k
  if (bas->scheme != NULL)
1983
848
      res->scheme = xmlMemStrdup(bas->scheme);
1984
1.70k
  if (bas->authority != NULL)
1985
0
      res->authority = xmlMemStrdup(bas->authority);
1986
1.70k
  else {
1987
1.70k
      if (bas->server != NULL)
1988
383
    res->server = xmlMemStrdup(bas->server);
1989
1.70k
      if (bas->user != NULL)
1990
347
    res->user = xmlMemStrdup(bas->user);
1991
1.70k
      res->port = bas->port;
1992
1.70k
  }
1993
1.70k
  if (bas->path != NULL)
1994
1.00k
      res->path = xmlMemStrdup(bas->path);
1995
1.70k
  if (ref->query_raw != NULL)
1996
1.13k
      res->query_raw = xmlMemStrdup (ref->query_raw);
1997
572
  else if (ref->query != NULL)
1998
0
      res->query = xmlMemStrdup(ref->query);
1999
572
  else if (bas->query_raw != NULL)
2000
83
      res->query_raw = xmlMemStrdup(bas->query_raw);
2001
489
  else if (bas->query != NULL)
2002
0
      res->query = xmlMemStrdup(bas->query);
2003
1.70k
  if (ref->fragment != NULL)
2004
662
      res->fragment = xmlMemStrdup(ref->fragment);
2005
1.70k
  goto step_7;
2006
1.70k
    }
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
250k
    if (ref->scheme != NULL) {
2015
0
  val = xmlSaveUri(ref);
2016
0
  goto done;
2017
0
    }
2018
250k
    if (bas->scheme != NULL)
2019
53.3k
  res->scheme = xmlMemStrdup(bas->scheme);
2020
2021
250k
    if (ref->query_raw != NULL)
2022
2.18k
  res->query_raw = xmlMemStrdup(ref->query_raw);
2023
248k
    else if (ref->query != NULL)
2024
0
  res->query = xmlMemStrdup(ref->query);
2025
250k
    if (ref->fragment != NULL)
2026
4.69k
  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
250k
    if ((ref->authority != NULL) || (ref->server != NULL) ||
2036
250k
         (ref->port != PORT_EMPTY)) {
2037
664
  if (ref->authority != NULL)
2038
0
      res->authority = xmlMemStrdup(ref->authority);
2039
664
  else {
2040
664
            if (ref->server != NULL)
2041
664
                res->server = xmlMemStrdup(ref->server);
2042
664
      if (ref->user != NULL)
2043
321
    res->user = xmlMemStrdup(ref->user);
2044
664
            res->port = ref->port;
2045
664
  }
2046
664
  if (ref->path != NULL)
2047
115
      res->path = xmlMemStrdup(ref->path);
2048
664
  goto step_7;
2049
664
    }
2050
249k
    if (bas->authority != NULL)
2051
0
  res->authority = xmlMemStrdup(bas->authority);
2052
249k
    else if ((bas->server != NULL) || (bas->port != PORT_EMPTY)) {
2053
32.3k
  if (bas->server != NULL)
2054
28.8k
      res->server = xmlMemStrdup(bas->server);
2055
32.3k
  if (bas->user != NULL)
2056
7.46k
      res->user = xmlMemStrdup(bas->user);
2057
32.3k
  res->port = bas->port;
2058
32.3k
    }
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
249k
    if ((ref->path != NULL) && (ref->path[0] == '/')) {
2065
798
  res->path = xmlMemStrdup(ref->path);
2066
798
  goto step_7;
2067
798
    }
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
248k
    len = 2; /* extra / and 0 */
2079
248k
    if (ref->path != NULL)
2080
248k
  len += strlen(ref->path);
2081
248k
    if (bas->path != NULL)
2082
213k
  len += strlen(bas->path);
2083
248k
    res->path = (char *) xmlMallocAtomic(len);
2084
248k
    if (res->path == NULL) {
2085
0
        xmlURIErrMemory("resolving URI against base\n");
2086
0
  goto done;
2087
0
    }
2088
248k
    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
248k
    cur = 0;
2096
248k
    out = 0;
2097
248k
    if (bas->path != NULL) {
2098
668k
  while (bas->path[cur] != 0) {
2099
4.51M
      while ((bas->path[cur] != 0) && (bas->path[cur] != '/'))
2100
3.84M
    cur++;
2101
662k
      if (bas->path[cur] == 0)
2102
207k
    break;
2103
2104
454k
      cur++;
2105
2.39M
      while (out < cur) {
2106
1.94M
    res->path[out] = bas->path[out];
2107
1.94M
    out++;
2108
1.94M
      }
2109
454k
  }
2110
213k
    }
2111
248k
    res->path[out] = 0;
2112
2113
    /*
2114
     * b) The reference's path component is appended to the buffer
2115
     *    string.
2116
     */
2117
248k
    if (ref->path != NULL && ref->path[0] != 0) {
2118
248k
  indx = 0;
2119
  /*
2120
   * Ensure the path includes a '/'
2121
   */
2122
248k
  if ((out == 0) && ((bas->server != NULL) || bas->port != PORT_EMPTY))
2123
26.7k
      res->path[out++] = '/';
2124
3.64M
  while (ref->path[indx] != 0) {
2125
3.39M
      res->path[out++] = ref->path[indx++];
2126
3.39M
  }
2127
248k
    }
2128
248k
    res->path[out] = 0;
2129
2130
    /*
2131
     * Steps c) to h) are really path normalization steps
2132
     */
2133
248k
    xmlNormalizeURIPath(res->path);
2134
2135
251k
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
251k
    val = xmlSaveUri(res);
2143
2144
1.43M
done:
2145
1.43M
    if (ref != NULL)
2146
1.42M
  xmlFreeURI(ref);
2147
1.43M
    if (bas != NULL)
2148
331k
  xmlFreeURI(bas);
2149
1.43M
    if (res != NULL)
2150
251k
  xmlFreeURI(res);
2151
1.43M
    return(val);
2152
251k
}
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
1.89M
{
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
1.89M
    xmlURIPtr uri;
2406
1.89M
    xmlChar *ret;
2407
1.89M
    const xmlChar *absuri;
2408
2409
1.89M
    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
1.89M
    if ((path[0] == '/') && (path[1] == '/') && (path[2] != '/'))
2427
15.6k
        path++;
2428
2429
1.89M
    if ((uri = xmlParseURI((const char *) path)) != NULL) {
2430
1.57M
  xmlFreeURI(uri);
2431
1.57M
  return xmlStrdup(path);
2432
1.57M
    }
2433
2434
    /* Check if this is an "absolute uri" */
2435
317k
    absuri = xmlStrstr(path, BAD_CAST "://");
2436
317k
    if (absuri != NULL) {
2437
71.1k
        int l, j;
2438
71.1k
  unsigned char c;
2439
71.1k
  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
71.1k
  l = absuri - path;
2447
  /* Bypass if first part (part before the '://') is > 20 chars */
2448
71.1k
  if ((l <= 0) || (l > 20))
2449
2.85k
      goto path_processing;
2450
  /* Bypass if any non-alpha characters are present in first part */
2451
236k
  for (j = 0;j < l;j++) {
2452
171k
      c = path[j];
2453
171k
      if (!(((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z'))))
2454
3.42k
          goto path_processing;
2455
171k
  }
2456
2457
  /* Escape all except the characters specified in the supplied path */
2458
64.8k
        escURI = xmlURIEscapeStr(path, BAD_CAST ":/?_.#&;=");
2459
64.8k
  if (escURI != NULL) {
2460
      /* Try parsing the escaped path */
2461
64.8k
      uri = xmlParseURI((const char *) escURI);
2462
      /* If successful, return the escaped string */
2463
64.8k
      if (uri != NULL) {
2464
56.2k
          xmlFreeURI(uri);
2465
56.2k
    return escURI;
2466
56.2k
      }
2467
8.62k
            xmlFree(escURI);
2468
8.62k
  }
2469
64.8k
    }
2470
2471
261k
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
261k
    ret = xmlStrdup((const xmlChar *) path);
2520
261k
#endif
2521
261k
    return(ret);
2522
317k
}
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
625k
{
2538
625k
    xmlURIPtr uri;
2539
625k
    xmlURI temp;
2540
625k
    xmlChar *ret, *cal;
2541
2542
625k
    if (path == NULL)
2543
0
        return(NULL);
2544
2545
625k
    if ((uri = xmlParseURI((const char *) path)) != NULL) {
2546
441k
  xmlFreeURI(uri);
2547
441k
  return xmlStrdup(path);
2548
441k
    }
2549
184k
    cal = xmlCanonicPath(path);
2550
184k
    if (cal == NULL)
2551
0
        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
184k
    memset(&temp, 0, sizeof(temp));
2571
184k
    temp.path = (char *) cal;
2572
184k
    ret = xmlSaveUri(&temp);
2573
184k
    xmlFree(cal);
2574
184k
    return(ret);
2575
184k
}