Coverage Report

Created: 2023-09-24 16:02

/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
264k
#define MAX_URI_LENGTH 1024 * 1024
37
38
4.75M
#define PORT_EMPTY           0
39
38.0k
#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
102M
#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
102M
#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
35.3M
#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
28.5M
#define IS_DIGIT(x) (((x) >= '0') && ((x) <= '9'))
89
90
/*
91
 * alphanum = alpha | digit
92
 */
93
94
102M
#define IS_ALPHANUM(x) (IS_ALPHA(x) || IS_DIGIT(x))
95
96
/*
97
 * mark = "-" | "_" | "." | "!" | "~" | "*" | "'" | "(" | ")"
98
 */
99
100
23.2M
#define IS_MARK(x) (((x) == '-') || ((x) == '_') || ((x) == '.') ||     \
101
23.2M
    ((x) == '!') || ((x) == '~') || ((x) == '*') || ((x) == '\'') ||    \
102
23.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
311k
#define IS_RESERVED(x) (((x) == ';') || ((x) == '/') || ((x) == '?') || \
118
311k
        ((x) == ':') || ((x) == '@') || ((x) == '&') || ((x) == '=') || \
119
311k
        ((x) == '+') || ((x) == '$') || ((x) == ',') || ((x) == '[') || \
120
311k
        ((x) == ']'))
121
122
/*
123
 * unreserved = alphanum | mark
124
 */
125
126
51.3M
#define IS_UNRESERVED(x) (IS_ALPHANUM(x) || IS_MARK(x))
127
128
/*
129
 * Skip to next pointer char, handle escaped sequences
130
 */
131
132
72.5M
#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
2.79M
#define STRNDUP(s, n) (char *) xmlStrndup((const xmlChar *)(s), (n))
145
146
/************************************************************************
147
 *                  *
148
 *                         RFC 3986 parser        *
149
 *                  *
150
 ************************************************************************/
151
152
82.7M
#define ISA_DIGIT(p) ((*(p) >= '0') && (*(p) <= '9'))
153
109M
#define ISA_ALPHA(p) (((*(p) >= 'a') && (*(p) <= 'z')) ||   \
154
109M
                      ((*(p) >= 'A') && (*(p) <= 'Z')))
155
#define ISA_HEXDIG(p)             \
156
15.2M
       (ISA_DIGIT(p) || ((*(p) >= 'a') && (*(p) <= 'f')) ||   \
157
15.2M
        ((*(p) >= 'A') && (*(p) <= 'F')))
158
159
/*
160
 *    sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
161
 *                     / "*" / "+" / "," / ";" / "="
162
 */
163
#define ISA_SUB_DELIM(p)            \
164
88.0M
      (((*(p) == '!')) || ((*(p) == '$')) || ((*(p) == '&')) ||   \
165
15.6M
       ((*(p) == '(')) || ((*(p) == ')')) || ((*(p) == '*')) ||   \
166
15.6M
       ((*(p) == '+')) || ((*(p) == ',')) || ((*(p) == ';')) ||   \
167
15.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
165M
      ((ISA_ALPHA(p)) || (ISA_DIGIT(p)) || ((*(p) == '-')) ||   \
187
82.7M
       ((*(p) == '.')) || ((*(p) == '_')) || ((*(p) == '~')))
188
189
/*
190
 *    pct-encoded   = "%" HEXDIG HEXDIG
191
 */
192
#define ISA_PCT_ENCODED(p)            \
193
105M
     ((*(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
99.6M
     (ISA_UNRESERVED(p) || ISA_PCT_ENCODED(p) || ISA_SUB_DELIM(p) ||  \
200
59.0M
      ((*(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
3.71M
xmlParse3986Scheme(xmlURIPtr uri, const char **str) {
215
3.71M
    const char *cur;
216
217
3.71M
    if (str == NULL)
218
0
  return(-1);
219
220
3.71M
    cur = *str;
221
3.71M
    if (!ISA_ALPHA(cur))
222
1.02M
  return(2);
223
2.68M
    cur++;
224
11.3M
    while (ISA_ALPHA(cur) || ISA_DIGIT(cur) ||
225
11.3M
           (*cur == '+') || (*cur == '-') || (*cur == '.')) cur++;
226
2.68M
    if (uri != NULL) {
227
2.68M
  if (uri->scheme != NULL) xmlFree(uri->scheme);
228
2.68M
  uri->scheme = STRNDUP(*str, cur - *str);
229
2.68M
    }
230
2.68M
    *str = cur;
231
2.68M
    return(0);
232
3.71M
}
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
170k
{
252
170k
    const char *cur;
253
254
170k
    if (str == NULL)
255
0
        return (-1);
256
257
170k
    cur = *str;
258
259
5.50M
    while ((ISA_PCHAR(cur)) || (*cur == '/') || (*cur == '?') ||
260
5.50M
           (*cur == '[') || (*cur == ']') ||
261
5.50M
           ((uri != NULL) && (uri->cleanup & 1) && (IS_UNWISE(cur))))
262
5.33M
        NEXT(cur);
263
170k
    if (uri != NULL) {
264
170k
        if (uri->fragment != NULL)
265
0
            xmlFree(uri->fragment);
266
170k
  if (uri->cleanup & 2)
267
0
      uri->fragment = STRNDUP(*str, cur - *str);
268
170k
  else
269
170k
      uri->fragment = xmlURIUnescapeString(*str, cur - *str, NULL);
270
170k
    }
271
170k
    *str = cur;
272
170k
    return (0);
273
170k
}
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
117k
{
289
117k
    const char *cur;
290
291
117k
    if (str == NULL)
292
0
        return (-1);
293
294
117k
    cur = *str;
295
296
3.64M
    while ((ISA_PCHAR(cur)) || (*cur == '/') || (*cur == '?') ||
297
3.64M
           ((uri != NULL) && (uri->cleanup & 1) && (IS_UNWISE(cur))))
298
3.53M
        NEXT(cur);
299
117k
    if (uri != NULL) {
300
117k
        if (uri->query != NULL)
301
0
            xmlFree(uri->query);
302
117k
  if (uri->cleanup & 2)
303
0
      uri->query = STRNDUP(*str, cur - *str);
304
117k
  else
305
117k
      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
117k
  if (uri->query_raw != NULL)
311
0
      xmlFree (uri->query_raw);
312
117k
  uri->query_raw = STRNDUP (*str, cur - *str);
313
117k
    }
314
117k
    *str = cur;
315
117k
    return (0);
316
117k
}
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
30.1k
{
333
30.1k
    const char *cur = *str;
334
30.1k
    int port = 0;
335
336
30.1k
    if (ISA_DIGIT(cur)) {
337
23.9k
  while (ISA_DIGIT(cur)) {
338
19.5k
            int digit = *cur - '0';
339
340
19.5k
            if (port > INT_MAX / 10)
341
588
                return(1);
342
18.9k
            port *= 10;
343
18.9k
            if (port > INT_MAX - digit)
344
0
                return(1);
345
18.9k
      port += digit;
346
347
18.9k
      cur++;
348
18.9k
  }
349
4.46k
  if (uri != NULL)
350
4.46k
      uri->port = port;
351
4.46k
  *str = cur;
352
4.46k
  return(0);
353
5.05k
    }
354
25.0k
    return(1);
355
30.1k
}
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
769k
{
372
769k
    const char *cur;
373
374
769k
    cur = *str;
375
13.3M
    while (ISA_UNRESERVED(cur) || ISA_PCT_ENCODED(cur) ||
376
13.3M
           ISA_SUB_DELIM(cur) || (*cur == ':'))
377
12.5M
  NEXT(cur);
378
769k
    if (*cur == '@') {
379
37.7k
  if (uri != NULL) {
380
37.7k
      if (uri->user != NULL) xmlFree(uri->user);
381
37.7k
      if (uri->cleanup & 2)
382
0
    uri->user = STRNDUP(*str, cur - *str);
383
37.7k
      else
384
37.7k
    uri->user = xmlURIUnescapeString(*str, cur - *str, NULL);
385
37.7k
  }
386
37.7k
  *str = cur;
387
37.7k
  return(0);
388
37.7k
    }
389
731k
    return(1);
390
769k
}
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
3.43k
xmlParse3986DecOctet(const char **str) {
408
3.43k
    const char *cur = *str;
409
410
3.43k
    if (!(ISA_DIGIT(cur)))
411
161
        return(1);
412
3.27k
    if (!ISA_DIGIT(cur+1))
413
2.17k
  cur++;
414
1.10k
    else if ((*cur != '0') && (ISA_DIGIT(cur + 1)) && (!ISA_DIGIT(cur+2)))
415
183
  cur += 2;
416
920
    else if ((*cur == '1') && (ISA_DIGIT(cur + 1)) && (ISA_DIGIT(cur + 2)))
417
193
  cur += 3;
418
727
    else if ((*cur == '2') && (*(cur + 1) >= '0') &&
419
727
       (*(cur + 1) <= '4') && (ISA_DIGIT(cur + 2)))
420
33
  cur += 3;
421
694
    else if ((*cur == '2') && (*(cur + 1) == '5') &&
422
694
       (*(cur + 2) >= '0') && (*(cur + 1) <= '5'))
423
0
  cur += 3;
424
694
    else
425
694
        return(1);
426
2.58k
    *str = cur;
427
2.58k
    return(0);
428
3.27k
}
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
769k
{
447
769k
    const char *cur = *str;
448
769k
    const char *host;
449
450
769k
    host = cur;
451
    /*
452
     * IPv6 and future addressing scheme are enclosed between brackets
453
     */
454
769k
    if (*cur == '[') {
455
5.67k
        cur++;
456
1.14M
  while ((*cur != ']') && (*cur != 0))
457
1.14M
      cur++;
458
5.67k
  if (*cur != ']')
459
4.50k
      return(1);
460
1.16k
  cur++;
461
1.16k
  goto found;
462
5.67k
    }
463
    /*
464
     * try to parse an IPv4
465
     */
466
763k
    if (ISA_DIGIT(cur)) {
467
3.26k
        if (xmlParse3986DecOctet(&cur) != 0)
468
694
      goto not_ipv4;
469
2.57k
  if (*cur != '.')
470
2.40k
      goto not_ipv4;
471
171
  cur++;
472
171
        if (xmlParse3986DecOctet(&cur) != 0)
473
161
      goto not_ipv4;
474
10
  if (*cur != '.')
475
10
      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
3.26k
not_ipv4:
484
3.26k
        cur = *str;
485
3.26k
    }
486
    /*
487
     * then this should be a hostname which can be empty
488
     */
489
10.3M
    while (ISA_UNRESERVED(cur) || ISA_PCT_ENCODED(cur) || ISA_SUB_DELIM(cur))
490
9.58M
        NEXT(cur);
491
764k
found:
492
764k
    if (uri != NULL) {
493
764k
  if (uri->authority != NULL) xmlFree(uri->authority);
494
764k
  uri->authority = NULL;
495
764k
  if (uri->server != NULL) xmlFree(uri->server);
496
764k
  if (cur != host) {
497
714k
      if (uri->cleanup & 2)
498
0
    uri->server = STRNDUP(host, cur - host);
499
714k
      else
500
714k
    uri->server = xmlURIUnescapeString(host, cur - host, NULL);
501
714k
  } else
502
50.1k
      uri->server = NULL;
503
764k
    }
504
764k
    *str = cur;
505
764k
    return(0);
506
763k
}
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
769k
{
523
769k
    const char *cur;
524
769k
    int ret;
525
526
769k
    cur = *str;
527
    /*
528
     * try to parse an userinfo and check for the trailing @
529
     */
530
769k
    ret = xmlParse3986Userinfo(uri, &cur);
531
769k
    if ((ret != 0) || (*cur != '@'))
532
731k
        cur = *str;
533
37.7k
    else
534
37.7k
        cur++;
535
769k
    ret = xmlParse3986Host(uri, &cur);
536
769k
    if (ret != 0) return(ret);
537
764k
    if (*cur == ':') {
538
30.1k
        cur++;
539
30.1k
        ret = xmlParse3986Port(uri, &cur);
540
30.1k
  if (ret != 0) return(ret);
541
30.1k
    }
542
739k
    *str = cur;
543
739k
    return(0);
544
764k
}
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
6.14M
{
565
6.14M
    const char *cur;
566
567
6.14M
    cur = *str;
568
6.14M
    if (!ISA_PCHAR(cur)) {
569
1.37M
        if (empty)
570
1.34M
      return(0);
571
23.7k
  return(1);
572
1.37M
    }
573
40.5M
    while (ISA_PCHAR(cur) && (*cur != forbid))
574
35.7M
        NEXT(cur);
575
4.77M
    *str = cur;
576
4.77M
    return (0);
577
6.14M
}
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
739k
{
594
739k
    const char *cur;
595
739k
    int ret;
596
597
739k
    cur = *str;
598
599
3.17M
    while (*cur == '/') {
600
2.43M
        cur++;
601
2.43M
  ret = xmlParse3986Segment(&cur, 0, 1);
602
2.43M
  if (ret != 0) return(ret);
603
2.43M
    }
604
739k
    if (uri != NULL) {
605
739k
  if (uri->path != NULL) xmlFree(uri->path);
606
739k
        if (*str != cur) {
607
459k
            if (uri->cleanup & 2)
608
0
                uri->path = STRNDUP(*str, cur - *str);
609
459k
            else
610
459k
                uri->path = xmlURIUnescapeString(*str, cur - *str, NULL);
611
459k
        } else {
612
280k
            uri->path = NULL;
613
280k
        }
614
739k
    }
615
739k
    *str = cur;
616
739k
    return (0);
617
739k
}
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
82.9k
{
634
82.9k
    const char *cur;
635
82.9k
    int ret;
636
637
82.9k
    cur = *str;
638
639
82.9k
    if (*cur != '/')
640
0
        return(1);
641
82.9k
    cur++;
642
82.9k
    ret = xmlParse3986Segment(&cur, 0, 0);
643
82.9k
    if (ret == 0) {
644
144k
  while (*cur == '/') {
645
85.1k
      cur++;
646
85.1k
      ret = xmlParse3986Segment(&cur, 0, 1);
647
85.1k
      if (ret != 0) return(ret);
648
85.1k
  }
649
59.1k
    }
650
82.9k
    if (uri != NULL) {
651
82.9k
  if (uri->path != NULL) xmlFree(uri->path);
652
82.9k
        if (cur != *str) {
653
82.9k
            if (uri->cleanup & 2)
654
0
                uri->path = STRNDUP(*str, cur - *str);
655
82.9k
            else
656
82.9k
                uri->path = xmlURIUnescapeString(*str, cur - *str, NULL);
657
82.9k
        } else {
658
0
            uri->path = NULL;
659
0
        }
660
82.9k
    }
661
82.9k
    *str = cur;
662
82.9k
    return (0);
663
82.9k
}
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
158k
{
680
158k
    const char *cur;
681
158k
    int ret;
682
683
158k
    cur = *str;
684
685
158k
    ret = xmlParse3986Segment(&cur, 0, 0);
686
158k
    if (ret != 0) return(ret);
687
299k
    while (*cur == '/') {
688
141k
        cur++;
689
141k
  ret = xmlParse3986Segment(&cur, 0, 1);
690
141k
  if (ret != 0) return(ret);
691
141k
    }
692
158k
    if (uri != NULL) {
693
158k
  if (uri->path != NULL) xmlFree(uri->path);
694
158k
        if (cur != *str) {
695
158k
            if (uri->cleanup & 2)
696
0
                uri->path = STRNDUP(*str, cur - *str);
697
158k
            else
698
158k
                uri->path = xmlURIUnescapeString(*str, cur - *str, NULL);
699
158k
        } else {
700
0
            uri->path = NULL;
701
0
        }
702
158k
    }
703
158k
    *str = cur;
704
158k
    return (0);
705
158k
}
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
2.46M
{
722
2.46M
    const char *cur;
723
2.46M
    int ret;
724
725
2.46M
    cur = *str;
726
727
2.46M
    ret = xmlParse3986Segment(&cur, ':', 0);
728
2.46M
    if (ret != 0) return(ret);
729
3.23M
    while (*cur == '/') {
730
772k
        cur++;
731
772k
  ret = xmlParse3986Segment(&cur, 0, 1);
732
772k
  if (ret != 0) return(ret);
733
772k
    }
734
2.46M
    if (uri != NULL) {
735
2.46M
  if (uri->path != NULL) xmlFree(uri->path);
736
2.46M
        if (cur != *str) {
737
2.44M
            if (uri->cleanup & 2)
738
0
                uri->path = STRNDUP(*str, cur - *str);
739
2.44M
            else
740
2.44M
                uri->path = xmlURIUnescapeString(*str, cur - *str, NULL);
741
2.44M
        } else {
742
23.0k
            uri->path = NULL;
743
23.0k
        }
744
2.46M
    }
745
2.46M
    *str = cur;
746
2.46M
    return (0);
747
2.46M
}
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
984k
{
767
984k
    const char *cur;
768
984k
    int ret;
769
770
984k
    cur = *str;
771
772
984k
    if ((*cur == '/') && (*(cur + 1) == '/')) {
773
753k
        cur += 2;
774
753k
  ret = xmlParse3986Authority(uri, &cur);
775
753k
  if (ret != 0) return(ret);
776
        /*
777
         * An empty server is marked with a special URI value.
778
         */
779
726k
  if ((uri->server == NULL) && (uri->port == PORT_EMPTY))
780
38.0k
      uri->port = PORT_EMPTY_SERVER;
781
726k
  ret = xmlParse3986PathAbEmpty(uri, &cur);
782
726k
  if (ret != 0) return(ret);
783
726k
  *str = cur;
784
726k
  return(0);
785
726k
    } else if (*cur == '/') {
786
41.9k
        ret = xmlParse3986PathAbsolute(uri, &cur);
787
41.9k
  if (ret != 0) return(ret);
788
189k
    } else if (ISA_PCHAR(cur)) {
789
158k
        ret = xmlParse3986PathRootless(uri, &cur);
790
158k
  if (ret != 0) return(ret);
791
158k
    } else {
792
  /* path-empty is effectively empty */
793
31.2k
  if (uri != NULL) {
794
31.2k
      if (uri->path != NULL) xmlFree(uri->path);
795
31.2k
      uri->path = NULL;
796
31.2k
  }
797
31.2k
    }
798
231k
    *str = cur;
799
231k
    return (0);
800
984k
}
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
3.12M
xmlParse3986RelativeRef(xmlURIPtr uri, const char *str) {
820
3.12M
    int ret;
821
822
3.12M
    if ((*str == '/') && (*(str + 1) == '/')) {
823
16.4k
        str += 2;
824
16.4k
  ret = xmlParse3986Authority(uri, &str);
825
16.4k
  if (ret != 0) return(ret);
826
13.0k
  ret = xmlParse3986PathAbEmpty(uri, &str);
827
13.0k
  if (ret != 0) return(ret);
828
3.11M
    } else if (*str == '/') {
829
40.9k
  ret = xmlParse3986PathAbsolute(uri, &str);
830
40.9k
  if (ret != 0) return(ret);
831
3.07M
    } else if (ISA_PCHAR(str)) {
832
2.46M
        ret = xmlParse3986PathNoScheme(uri, &str);
833
2.46M
  if (ret != 0) return(ret);
834
2.46M
    } else {
835
  /* path-empty is effectively empty */
836
606k
  if (uri != NULL) {
837
606k
      if (uri->path != NULL) xmlFree(uri->path);
838
606k
      uri->path = NULL;
839
606k
  }
840
606k
    }
841
842
3.12M
    if (*str == '?') {
843
75.1k
  str++;
844
75.1k
  ret = xmlParse3986Query(uri, &str);
845
75.1k
  if (ret != 0) return(ret);
846
75.1k
    }
847
3.12M
    if (*str == '#') {
848
94.2k
  str++;
849
94.2k
  ret = xmlParse3986Fragment(uri, &str);
850
94.2k
  if (ret != 0) return(ret);
851
94.2k
    }
852
3.12M
    if (*str != 0) {
853
1.46M
  xmlCleanURI(uri);
854
1.46M
  return(1);
855
1.46M
    }
856
1.66M
    return(0);
857
3.12M
}
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
3.71M
xmlParse3986URI(xmlURIPtr uri, const char *str) {
874
3.71M
    int ret;
875
876
3.71M
    ret = xmlParse3986Scheme(uri, &str);
877
3.71M
    if (ret != 0) return(ret);
878
2.68M
    if (*str != ':') {
879
1.69M
  return(1);
880
1.69M
    }
881
984k
    str++;
882
984k
    ret = xmlParse3986HierPart(uri, &str);
883
984k
    if (ret != 0) return(ret);
884
957k
    if (*str == '?') {
885
42.4k
  str++;
886
42.4k
  ret = xmlParse3986Query(uri, &str);
887
42.4k
  if (ret != 0) return(ret);
888
42.4k
    }
889
957k
    if (*str == '#') {
890
76.5k
  str++;
891
76.5k
  ret = xmlParse3986Fragment(uri, &str);
892
76.5k
  if (ret != 0) return(ret);
893
76.5k
    }
894
957k
    if (*str != 0) {
895
375k
  xmlCleanURI(uri);
896
375k
  return(1);
897
375k
    }
898
582k
    return(0);
899
957k
}
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
3.71M
xmlParse3986URIReference(xmlURIPtr uri, const char *str) {
915
3.71M
    int ret;
916
917
3.71M
    if (str == NULL)
918
0
  return(-1);
919
3.71M
    xmlCleanURI(uri);
920
921
    /*
922
     * Try first to parse absolute refs, then fallback to relative if
923
     * it fails.
924
     */
925
3.71M
    ret = xmlParse3986URI(uri, str);
926
3.71M
    if (ret != 0) {
927
3.12M
  xmlCleanURI(uri);
928
3.12M
        ret = xmlParse3986RelativeRef(uri, str);
929
3.12M
  if (ret != 0) {
930
1.46M
      xmlCleanURI(uri);
931
1.46M
      return(ret);
932
1.46M
  }
933
3.12M
    }
934
2.24M
    return(0);
935
3.71M
}
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
3.10M
xmlParseURI(const char *str) {
949
3.10M
    xmlURIPtr uri;
950
3.10M
    int ret;
951
952
3.10M
    if (str == NULL)
953
0
  return(NULL);
954
3.10M
    uri = xmlCreateURI();
955
3.10M
    if (uri != NULL) {
956
3.10M
  ret = xmlParse3986URIReference(uri, str);
957
3.10M
        if (ret) {
958
1.37M
      xmlFreeURI(uri);
959
1.37M
      return(NULL);
960
1.37M
  }
961
3.10M
    }
962
1.73M
    return(uri);
963
3.10M
}
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
603k
xmlParseURIReference(xmlURIPtr uri, const char *str) {
979
603k
    return(xmlParse3986URIReference(uri, str));
980
603k
}
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
3.78M
xmlCreateURI(void) {
1029
3.78M
    xmlURIPtr ret;
1030
1031
3.78M
    ret = (xmlURIPtr) xmlMalloc(sizeof(xmlURI));
1032
3.78M
    if (ret == NULL) {
1033
0
        xmlURIErrMemory("creating URI structure\n");
1034
0
  return(NULL);
1035
0
    }
1036
3.78M
    memset(ret, 0, sizeof(xmlURI));
1037
3.78M
    ret->port = PORT_EMPTY;
1038
3.78M
    return(ret);
1039
3.78M
}
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
264k
xmlSaveUriRealloc(xmlChar *ret, int *max) {
1049
264k
    xmlChar *temp;
1050
264k
    int tmp;
1051
1052
264k
    if (*max > MAX_URI_LENGTH) {
1053
0
        xmlURIErrMemory("reaching arbitrary MAX_URI_LENGTH limit\n");
1054
0
        return(NULL);
1055
0
    }
1056
264k
    tmp = *max * 2;
1057
264k
    temp = (xmlChar *) xmlRealloc(ret, (tmp + 1));
1058
264k
    if (temp == NULL) {
1059
0
        xmlURIErrMemory("saving URI\n");
1060
0
        return(NULL);
1061
0
    }
1062
264k
    *max = tmp;
1063
264k
    return(temp);
1064
264k
}
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
776k
xmlSaveUri(xmlURIPtr uri) {
1076
776k
    xmlChar *ret = NULL;
1077
776k
    xmlChar *temp;
1078
776k
    const char *p;
1079
776k
    int len;
1080
776k
    int max;
1081
1082
776k
    if (uri == NULL) return(NULL);
1083
1084
1085
776k
    max = 80;
1086
776k
    ret = (xmlChar *) xmlMallocAtomic(max + 1);
1087
776k
    if (ret == NULL) {
1088
0
        xmlURIErrMemory("saving URI\n");
1089
0
  return(NULL);
1090
0
    }
1091
776k
    len = 0;
1092
1093
776k
    if (uri->scheme != NULL) {
1094
35.8k
  p = uri->scheme;
1095
223k
  while (*p != 0) {
1096
187k
      if (len >= max) {
1097
470
                temp = xmlSaveUriRealloc(ret, &max);
1098
470
                if (temp == NULL) goto mem_error;
1099
470
    ret = temp;
1100
470
      }
1101
187k
      ret[len++] = *p++;
1102
187k
  }
1103
35.8k
  if (len >= max) {
1104
123
            temp = xmlSaveUriRealloc(ret, &max);
1105
123
            if (temp == NULL) goto mem_error;
1106
123
            ret = temp;
1107
123
  }
1108
35.8k
  ret[len++] = ':';
1109
35.8k
    }
1110
776k
    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
776k
    } else {
1129
776k
  if ((uri->server != NULL) || (uri->port != PORT_EMPTY)) {
1130
27.6k
      if (len + 3 >= max) {
1131
90
                temp = xmlSaveUriRealloc(ret, &max);
1132
90
                if (temp == NULL) goto mem_error;
1133
90
                ret = temp;
1134
90
      }
1135
27.6k
      ret[len++] = '/';
1136
27.6k
      ret[len++] = '/';
1137
27.6k
      if (uri->user != NULL) {
1138
5.94k
    p = uri->user;
1139
1.06M
    while (*p != 0) {
1140
1.05M
        if (len + 3 >= max) {
1141
7.68k
                        temp = xmlSaveUriRealloc(ret, &max);
1142
7.68k
                        if (temp == NULL) goto mem_error;
1143
7.68k
                        ret = temp;
1144
7.68k
        }
1145
1.05M
        if ((IS_UNRESERVED(*(p))) ||
1146
1.05M
      ((*(p) == ';')) || ((*(p) == ':')) ||
1147
1.05M
      ((*(p) == '&')) || ((*(p) == '=')) ||
1148
1.05M
      ((*(p) == '+')) || ((*(p) == '$')) ||
1149
1.05M
      ((*(p) == ',')))
1150
693k
      ret[len++] = *p++;
1151
364k
        else {
1152
364k
      int val = *(unsigned char *)p++;
1153
364k
      int hi = val / 0x10, lo = val % 0x10;
1154
364k
      ret[len++] = '%';
1155
364k
      ret[len++] = hi + (hi > 9? 'A'-10 : '0');
1156
364k
      ret[len++] = lo + (lo > 9? 'A'-10 : '0');
1157
364k
        }
1158
1.05M
    }
1159
5.94k
    if (len + 3 >= max) {
1160
196
                    temp = xmlSaveUriRealloc(ret, &max);
1161
196
                    if (temp == NULL) goto mem_error;
1162
196
                    ret = temp;
1163
196
    }
1164
5.94k
    ret[len++] = '@';
1165
5.94k
      }
1166
27.6k
      if (uri->server != NULL) {
1167
25.0k
    p = uri->server;
1168
682k
    while (*p != 0) {
1169
657k
        if (len >= max) {
1170
2.04k
      temp = xmlSaveUriRealloc(ret, &max);
1171
2.04k
      if (temp == NULL) goto mem_error;
1172
2.04k
      ret = temp;
1173
2.04k
        }
1174
                    /* TODO: escaping? */
1175
657k
        ret[len++] = (xmlChar) *p++;
1176
657k
    }
1177
25.0k
      }
1178
27.6k
            if (uri->port > 0) {
1179
373
                if (len + 10 >= max) {
1180
77
                    temp = xmlSaveUriRealloc(ret, &max);
1181
77
                    if (temp == NULL) goto mem_error;
1182
77
                    ret = temp;
1183
77
                }
1184
373
                len += snprintf((char *) &ret[len], max - len, ":%d", uri->port);
1185
373
            }
1186
749k
  } 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
749k
  } else if (uri->scheme != NULL) {
1215
10.3k
      if (len + 3 >= max) {
1216
147
                temp = xmlSaveUriRealloc(ret, &max);
1217
147
                if (temp == NULL) goto mem_error;
1218
147
                ret = temp;
1219
147
      }
1220
10.3k
  }
1221
776k
  if (uri->path != NULL) {
1222
770k
      p = uri->path;
1223
      /*
1224
       * the colon in file:///d: should not be escaped or
1225
       * Windows accesses fail later.
1226
       */
1227
770k
      if ((uri->scheme != NULL) &&
1228
770k
    (p[0] == '/') &&
1229
770k
    (((p[1] >= 'a') && (p[1] <= 'z')) ||
1230
26.8k
     ((p[1] >= 'A') && (p[1] <= 'Z'))) &&
1231
770k
    (p[2] == ':') &&
1232
770k
          (xmlStrEqual(BAD_CAST uri->scheme, BAD_CAST "file"))) {
1233
12
    if (len + 3 >= max) {
1234
1
                    temp = xmlSaveUriRealloc(ret, &max);
1235
1
                    if (temp == NULL) goto mem_error;
1236
1
                    ret = temp;
1237
1
    }
1238
12
    ret[len++] = *p++;
1239
12
    ret[len++] = *p++;
1240
12
    ret[len++] = *p++;
1241
12
      }
1242
35.5M
      while (*p != 0) {
1243
34.8M
    if (len + 3 >= max) {
1244
202k
                    temp = xmlSaveUriRealloc(ret, &max);
1245
202k
                    if (temp == NULL) goto mem_error;
1246
202k
                    ret = temp;
1247
202k
    }
1248
34.8M
    if ((IS_UNRESERVED(*(p))) || ((*(p) == '/')) ||
1249
34.8M
                    ((*(p) == ';')) || ((*(p) == '@')) || ((*(p) == '&')) ||
1250
34.8M
              ((*(p) == '=')) || ((*(p) == '+')) || ((*(p) == '$')) ||
1251
34.8M
              ((*(p) == ',')))
1252
25.1M
        ret[len++] = *p++;
1253
9.66M
    else {
1254
9.66M
        int val = *(unsigned char *)p++;
1255
9.66M
        int hi = val / 0x10, lo = val % 0x10;
1256
9.66M
        ret[len++] = '%';
1257
9.66M
        ret[len++] = hi + (hi > 9? 'A'-10 : '0');
1258
9.66M
        ret[len++] = lo + (lo > 9? 'A'-10 : '0');
1259
9.66M
    }
1260
34.8M
      }
1261
770k
  }
1262
776k
  if (uri->query_raw != NULL) {
1263
11.4k
      if (len + 1 >= max) {
1264
57
                temp = xmlSaveUriRealloc(ret, &max);
1265
57
                if (temp == NULL) goto mem_error;
1266
57
                ret = temp;
1267
57
      }
1268
11.4k
      ret[len++] = '?';
1269
11.4k
      p = uri->query_raw;
1270
342k
      while (*p != 0) {
1271
330k
    if (len + 1 >= max) {
1272
1.29k
                    temp = xmlSaveUriRealloc(ret, &max);
1273
1.29k
                    if (temp == NULL) goto mem_error;
1274
1.29k
                    ret = temp;
1275
1.29k
    }
1276
330k
    ret[len++] = *p++;
1277
330k
      }
1278
765k
  } 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
776k
    }
1304
776k
    if (uri->fragment != NULL) {
1305
14.1k
  if (len + 3 >= max) {
1306
171
            temp = xmlSaveUriRealloc(ret, &max);
1307
171
            if (temp == NULL) goto mem_error;
1308
171
            ret = temp;
1309
171
  }
1310
14.1k
  ret[len++] = '#';
1311
14.1k
  p = uri->fragment;
1312
1.19M
  while (*p != 0) {
1313
1.18M
      if (len + 3 >= max) {
1314
7.85k
                temp = xmlSaveUriRealloc(ret, &max);
1315
7.85k
                if (temp == NULL) goto mem_error;
1316
7.85k
                ret = temp;
1317
7.85k
      }
1318
1.18M
      if ((IS_UNRESERVED(*(p))) || (IS_RESERVED(*(p))))
1319
1.18M
    ret[len++] = *p++;
1320
4.78k
      else {
1321
4.78k
    int val = *(unsigned char *)p++;
1322
4.78k
    int hi = val / 0x10, lo = val % 0x10;
1323
4.78k
    ret[len++] = '%';
1324
4.78k
    ret[len++] = hi + (hi > 9? 'A'-10 : '0');
1325
4.78k
    ret[len++] = lo + (lo > 9? 'A'-10 : '0');
1326
4.78k
      }
1327
1.18M
  }
1328
14.1k
    }
1329
776k
    if (len >= max) {
1330
35
        temp = xmlSaveUriRealloc(ret, &max);
1331
35
        if (temp == NULL) goto mem_error;
1332
35
        ret = temp;
1333
35
    }
1334
776k
    ret[len] = 0;
1335
776k
    return(ret);
1336
1337
0
mem_error:
1338
0
    xmlFree(ret);
1339
0
    return(NULL);
1340
776k
}
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
10.1M
xmlCleanURI(xmlURIPtr uri) {
1368
10.1M
    if (uri == NULL) return;
1369
1370
10.1M
    if (uri->scheme != NULL) xmlFree(uri->scheme);
1371
10.1M
    uri->scheme = NULL;
1372
10.1M
    if (uri->server != NULL) xmlFree(uri->server);
1373
10.1M
    uri->server = NULL;
1374
10.1M
    if (uri->user != NULL) xmlFree(uri->user);
1375
10.1M
    uri->user = NULL;
1376
10.1M
    if (uri->path != NULL) xmlFree(uri->path);
1377
10.1M
    uri->path = NULL;
1378
10.1M
    if (uri->fragment != NULL) xmlFree(uri->fragment);
1379
10.1M
    uri->fragment = NULL;
1380
10.1M
    if (uri->opaque != NULL) xmlFree(uri->opaque);
1381
10.1M
    uri->opaque = NULL;
1382
10.1M
    if (uri->authority != NULL) xmlFree(uri->authority);
1383
10.1M
    uri->authority = NULL;
1384
10.1M
    if (uri->query != NULL) xmlFree(uri->query);
1385
10.1M
    uri->query = NULL;
1386
10.1M
    if (uri->query_raw != NULL) xmlFree(uri->query_raw);
1387
10.1M
    uri->query_raw = NULL;
1388
10.1M
}
1389
1390
/**
1391
 * xmlFreeURI:
1392
 * @uri:  pointer to an xmlURI
1393
 *
1394
 * Free up the xmlURI struct
1395
 */
1396
void
1397
3.78M
xmlFreeURI(xmlURIPtr uri) {
1398
3.78M
    if (uri == NULL) return;
1399
1400
3.78M
    if (uri->scheme != NULL) xmlFree(uri->scheme);
1401
3.78M
    if (uri->server != NULL) xmlFree(uri->server);
1402
3.78M
    if (uri->user != NULL) xmlFree(uri->user);
1403
3.78M
    if (uri->path != NULL) xmlFree(uri->path);
1404
3.78M
    if (uri->fragment != NULL) xmlFree(uri->fragment);
1405
3.78M
    if (uri->opaque != NULL) xmlFree(uri->opaque);
1406
3.78M
    if (uri->authority != NULL) xmlFree(uri->authority);
1407
3.78M
    if (uri->query != NULL) xmlFree(uri->query);
1408
3.78M
    if (uri->query_raw != NULL) xmlFree(uri->query_raw);
1409
3.78M
    xmlFree(uri);
1410
3.78M
}
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
76.6k
xmlNormalizeURIPath(char *path) {
1431
76.6k
    char *cur, *out;
1432
1433
76.6k
    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
76.6k
    cur = path;
1440
125k
    while (cur[0] == '/')
1441
48.9k
      ++cur;
1442
76.6k
    if (cur[0] == '\0')
1443
38
      return(0);
1444
1445
    /* Keep everything we've seen so far.  */
1446
76.5k
    out = cur;
1447
1448
    /*
1449
     * Analyze each segment in sequence for cases (c) and (d).
1450
     */
1451
249k
    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
249k
  if ((cur[0] == '.') && (cur[1] == '/')) {
1457
3.48k
      cur += 2;
1458
      /* '//' normalization should be done at this point too */
1459
26.9k
      while (cur[0] == '/')
1460
23.4k
    cur++;
1461
3.48k
      continue;
1462
3.48k
  }
1463
1464
  /*
1465
   * d) If the buffer string ends with "." as a complete path segment,
1466
   *    that "." is removed.
1467
   */
1468
245k
  if ((cur[0] == '.') && (cur[1] == '\0'))
1469
241
      break;
1470
1471
  /* Otherwise keep the segment.  */
1472
2.65M
  while (cur[0] != '/') {
1473
2.48M
            if (cur[0] == '\0')
1474
75.7k
              goto done_cd;
1475
2.40M
      (out++)[0] = (cur++)[0];
1476
2.40M
  }
1477
  /* normalize // */
1478
361k
  while ((cur[0] == '/') && (cur[1] == '/'))
1479
191k
      cur++;
1480
1481
169k
        (out++)[0] = (cur++)[0];
1482
169k
    }
1483
76.5k
 done_cd:
1484
76.5k
    out[0] = '\0';
1485
1486
    /* Reset to the beginning of the first segment for the next sequence.  */
1487
76.5k
    cur = path;
1488
125k
    while (cur[0] == '/')
1489
48.9k
      ++cur;
1490
76.5k
    if (cur[0] == '\0')
1491
166
  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
245k
    while (1) {
1512
245k
        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
245k
        segp = cur;
1520
2.72M
        while ((segp[0] != '/') && (segp[0] != '\0'))
1521
2.47M
          ++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
245k
        if (segp[0] == '\0')
1527
76.3k
          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
169k
        ++segp;
1533
169k
        if (((cur[0] == '.') && (cur[1] == '.') && (segp == cur+3))
1534
169k
            || ((segp[0] != '.') || (segp[1] != '.')
1535
167k
                || ((segp[2] != '/') && (segp[2] != '\0')))) {
1536
160k
          cur = segp;
1537
160k
          continue;
1538
160k
        }
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
8.46k
        if (segp[2] == '\0') {
1549
46
          cur[0] = '\0';
1550
46
          break;
1551
46
        }
1552
        /* Valgrind complained, strcpy(cur, segp + 3); */
1553
        /* string will overlap, do not use strcpy */
1554
8.41k
        tmp = cur;
1555
8.41k
        segp += 3;
1556
13.1M
        while ((*tmp++ = *segp++) != 0)
1557
13.1M
          ;
1558
1559
        /* If there are no previous segments, then keep going from here.  */
1560
8.41k
        segp = cur;
1561
19.6k
        while ((segp > path) && ((--segp)[0] == '/'))
1562
11.2k
          ;
1563
8.41k
        if (segp == path)
1564
795
          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
7.61k
        cur = segp;
1574
89.0k
        while ((cur > path) && (cur[-1] != '/'))
1575
81.4k
          --cur;
1576
7.61k
    }
1577
76.4k
    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
76.4k
    if (path[0] == '/') {
1591
29.7k
      cur = path;
1592
31.0k
      while ((cur[0] == '/') && (cur[1] == '.') && (cur[2] == '.')
1593
31.0k
             && ((cur[3] == '/') || (cur[3] == '\0')))
1594
1.27k
  cur += 3;
1595
1596
29.7k
      if (cur != path) {
1597
543
  out = path;
1598
89.8k
  while (cur[0] != '\0')
1599
89.3k
          (out++)[0] = (cur++)[0];
1600
543
  out[0] = 0;
1601
543
      }
1602
29.7k
    }
1603
1604
76.4k
    return(0);
1605
76.5k
}
1606
1607
14.5M
static int is_hex(char c) {
1608
14.5M
    if (((c >= '0') && (c <= '9')) ||
1609
14.5M
        ((c >= 'a') && (c <= 'f')) ||
1610
14.5M
        ((c >= 'A') && (c <= 'F')))
1611
14.3M
  return(1);
1612
164k
    return(0);
1613
14.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
4.18M
xmlURIUnescapeString(const char *str, int len, char *target) {
1631
4.18M
    char *ret, *out;
1632
4.18M
    const char *in;
1633
1634
4.18M
    if (str == NULL)
1635
0
  return(NULL);
1636
4.18M
    if (len <= 0) len = strlen(str);
1637
4.18M
    if (len < 0) return(NULL);
1638
1639
4.18M
    if (target == NULL) {
1640
4.18M
  ret = (char *) xmlMallocAtomic(len + 1);
1641
4.18M
  if (ret == NULL) {
1642
0
            xmlURIErrMemory("unescaping URI value\n");
1643
0
      return(NULL);
1644
0
  }
1645
4.18M
    } else
1646
0
  ret = target;
1647
4.18M
    in = str;
1648
4.18M
    out = ret;
1649
75.4M
    while(len > 0) {
1650
71.2M
  if ((len > 2) && (*in == '%') && (is_hex(in[1])) && (is_hex(in[2]))) {
1651
7.17M
            int c = 0;
1652
7.17M
      in++;
1653
7.17M
      if ((*in >= '0') && (*in <= '9'))
1654
4.59M
          c = (*in - '0');
1655
2.57M
      else if ((*in >= 'a') && (*in <= 'f'))
1656
31.7k
          c = (*in - 'a') + 10;
1657
2.54M
      else if ((*in >= 'A') && (*in <= 'F'))
1658
2.54M
          c = (*in - 'A') + 10;
1659
7.17M
      in++;
1660
7.17M
      if ((*in >= '0') && (*in <= '9'))
1661
3.42M
          c = c * 16 + (*in - '0');
1662
3.74M
      else if ((*in >= 'a') && (*in <= 'f'))
1663
32.6k
          c = c * 16 + (*in - 'a') + 10;
1664
3.71M
      else if ((*in >= 'A') && (*in <= 'F'))
1665
3.71M
          c = c * 16 + (*in - 'A') + 10;
1666
7.17M
      in++;
1667
7.17M
      len -= 3;
1668
            /* Explicit sign change */
1669
7.17M
      *out++ = (char) c;
1670
64.1M
  } else {
1671
64.1M
      *out++ = *in++;
1672
64.1M
      len--;
1673
64.1M
  }
1674
71.2M
    }
1675
4.18M
    *out = 0;
1676
4.18M
    return(ret);
1677
4.18M
}
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
67.9k
xmlURIEscapeStr(const xmlChar *str, const xmlChar *list) {
1691
67.9k
    xmlChar *ret, ch;
1692
67.9k
    xmlChar *temp;
1693
67.9k
    const xmlChar *in;
1694
67.9k
    int len, out;
1695
1696
67.9k
    if (str == NULL)
1697
0
  return(NULL);
1698
67.9k
    if (str[0] == 0)
1699
0
  return(xmlStrdup(str));
1700
67.9k
    len = xmlStrlen(str);
1701
67.9k
    if (!(len > 0)) return(NULL);
1702
1703
67.9k
    len += 20;
1704
67.9k
    ret = (xmlChar *) xmlMallocAtomic(len);
1705
67.9k
    if (ret == NULL) {
1706
0
        xmlURIErrMemory("escaping URI value\n");
1707
0
  return(NULL);
1708
0
    }
1709
67.9k
    in = (const xmlChar *) str;
1710
67.9k
    out = 0;
1711
14.4M
    while(*in != 0) {
1712
14.3M
  if (len - out <= 3) {
1713
41.6k
            temp = xmlSaveUriRealloc(ret, &len);
1714
41.6k
      if (temp == NULL) {
1715
0
                xmlURIErrMemory("escaping URI value\n");
1716
0
    xmlFree(ret);
1717
0
    return(NULL);
1718
0
      }
1719
41.6k
      ret = temp;
1720
41.6k
  }
1721
1722
14.3M
  ch = *in;
1723
1724
14.3M
  if ((ch != '@') && (!IS_UNRESERVED(ch)) && (!xmlStrchr(list, ch))) {
1725
4.23M
      unsigned char val;
1726
4.23M
      ret[out++] = '%';
1727
4.23M
      val = ch >> 4;
1728
4.23M
      if (val <= 9)
1729
2.83M
    ret[out++] = '0' + val;
1730
1.40M
      else
1731
1.40M
    ret[out++] = 'A' + val - 0xA;
1732
4.23M
      val = ch & 0xF;
1733
4.23M
      if (val <= 9)
1734
2.12M
    ret[out++] = '0' + val;
1735
2.11M
      else
1736
2.11M
    ret[out++] = 'A' + val - 0xA;
1737
4.23M
      in++;
1738
10.1M
  } else {
1739
10.1M
      ret[out++] = *in++;
1740
10.1M
  }
1741
1742
14.3M
    }
1743
67.9k
    ret[out] = 0;
1744
67.9k
    return(ret);
1745
67.9k
}
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
446k
xmlBuildURI(const xmlChar *URI, const xmlChar *base) {
1904
446k
    xmlChar *val = NULL;
1905
446k
    int ret, len, indx, cur, out;
1906
446k
    xmlURIPtr ref = NULL;
1907
446k
    xmlURIPtr bas = NULL;
1908
446k
    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
446k
    if (URI == NULL)
1919
1.10k
  ret = -1;
1920
445k
    else {
1921
445k
  if (*URI) {
1922
442k
      ref = xmlCreateURI();
1923
442k
      if (ref == NULL)
1924
0
    goto done;
1925
442k
      ret = xmlParseURIReference(ref, (const char *) URI);
1926
442k
  }
1927
2.52k
  else
1928
2.52k
      ret = 0;
1929
445k
    }
1930
446k
    if (ret != 0)
1931
15.1k
  goto done;
1932
431k
    if ((ref != NULL) && (ref->scheme != NULL)) {
1933
  /*
1934
   * The URI is absolute don't modify.
1935
   */
1936
33.3k
  val = xmlStrdup(URI);
1937
33.3k
  goto done;
1938
33.3k
    }
1939
397k
    if (base == NULL)
1940
237k
  ret = -1;
1941
160k
    else {
1942
160k
  bas = xmlCreateURI();
1943
160k
  if (bas == NULL)
1944
0
      goto done;
1945
160k
  ret = xmlParseURIReference(bas, (const char *) base);
1946
160k
    }
1947
397k
    if (ret != 0) {
1948
317k
  if (ref)
1949
316k
      val = xmlSaveUri(ref);
1950
317k
  goto done;
1951
317k
    }
1952
80.0k
    if (ref == NULL) {
1953
  /*
1954
   * the base fragment must be ignored
1955
   */
1956
1.24k
  if (bas->fragment != NULL) {
1957
114
      xmlFree(bas->fragment);
1958
114
      bas->fragment = NULL;
1959
114
  }
1960
1.24k
  val = xmlSaveUri(bas);
1961
1.24k
  goto done;
1962
1.24k
    }
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
78.7k
    res = xmlCreateURI();
1977
78.7k
    if (res == NULL)
1978
0
  goto done;
1979
78.7k
    if ((ref->scheme == NULL) && (ref->path == NULL) &&
1980
78.7k
  ((ref->authority == NULL) && (ref->server == NULL) &&
1981
1.27k
         (ref->port == PORT_EMPTY))) {
1982
1.10k
  if (bas->scheme != NULL)
1983
425
      res->scheme = xmlMemStrdup(bas->scheme);
1984
1.10k
  if (bas->authority != NULL)
1985
0
      res->authority = xmlMemStrdup(bas->authority);
1986
1.10k
  else {
1987
1.10k
      if (bas->server != NULL)
1988
315
    res->server = xmlMemStrdup(bas->server);
1989
1.10k
      if (bas->user != NULL)
1990
120
    res->user = xmlMemStrdup(bas->user);
1991
1.10k
      res->port = bas->port;
1992
1.10k
  }
1993
1.10k
  if (bas->path != NULL)
1994
570
      res->path = xmlMemStrdup(bas->path);
1995
1.10k
  if (ref->query_raw != NULL)
1996
547
      res->query_raw = xmlMemStrdup (ref->query_raw);
1997
560
  else if (ref->query != NULL)
1998
0
      res->query = xmlMemStrdup(ref->query);
1999
560
  else if (bas->query_raw != NULL)
2000
112
      res->query_raw = xmlMemStrdup(bas->query_raw);
2001
448
  else if (bas->query != NULL)
2002
0
      res->query = xmlMemStrdup(bas->query);
2003
1.10k
  if (ref->fragment != NULL)
2004
596
      res->fragment = xmlMemStrdup(ref->fragment);
2005
1.10k
  goto step_7;
2006
1.10k
    }
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
77.6k
    if (ref->scheme != NULL) {
2015
0
  val = xmlSaveUri(ref);
2016
0
  goto done;
2017
0
    }
2018
77.6k
    if (bas->scheme != NULL)
2019
35.1k
  res->scheme = xmlMemStrdup(bas->scheme);
2020
2021
77.6k
    if (ref->query_raw != NULL)
2022
1.51k
  res->query_raw = xmlMemStrdup(ref->query_raw);
2023
76.1k
    else if (ref->query != NULL)
2024
0
  res->query = xmlMemStrdup(ref->query);
2025
77.6k
    if (ref->fragment != NULL)
2026
4.28k
  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
77.6k
    if ((ref->authority != NULL) || (ref->server != NULL) ||
2036
77.6k
         (ref->port != PORT_EMPTY)) {
2037
279
  if (ref->authority != NULL)
2038
0
      res->authority = xmlMemStrdup(ref->authority);
2039
279
  else {
2040
279
            if (ref->server != NULL)
2041
276
                res->server = xmlMemStrdup(ref->server);
2042
279
      if (ref->user != NULL)
2043
71
    res->user = xmlMemStrdup(ref->user);
2044
279
            res->port = ref->port;
2045
279
  }
2046
279
  if (ref->path != NULL)
2047
108
      res->path = xmlMemStrdup(ref->path);
2048
279
  goto step_7;
2049
279
    }
2050
77.4k
    if (bas->authority != NULL)
2051
0
  res->authority = xmlMemStrdup(bas->authority);
2052
77.4k
    else if ((bas->server != NULL) || (bas->port != PORT_EMPTY)) {
2053
25.3k
  if (bas->server != NULL)
2054
22.8k
      res->server = xmlMemStrdup(bas->server);
2055
25.3k
  if (bas->user != NULL)
2056
5.54k
      res->user = xmlMemStrdup(bas->user);
2057
25.3k
  res->port = bas->port;
2058
25.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
77.4k
    if ((ref->path != NULL) && (ref->path[0] == '/')) {
2065
769
  res->path = xmlMemStrdup(ref->path);
2066
769
  goto step_7;
2067
769
    }
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
76.6k
    len = 2; /* extra / and 0 */
2079
76.6k
    if (ref->path != NULL)
2080
76.6k
  len += strlen(ref->path);
2081
76.6k
    if (bas->path != NULL)
2082
44.8k
  len += strlen(bas->path);
2083
76.6k
    res->path = (char *) xmlMallocAtomic(len);
2084
76.6k
    if (res->path == NULL) {
2085
0
        xmlURIErrMemory("resolving URI against base\n");
2086
0
  goto done;
2087
0
    }
2088
76.6k
    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
76.6k
    cur = 0;
2096
76.6k
    out = 0;
2097
76.6k
    if (bas->path != NULL) {
2098
398k
  while (bas->path[cur] != 0) {
2099
2.42M
      while ((bas->path[cur] != 0) && (bas->path[cur] != '/'))
2100
2.03M
    cur++;
2101
393k
      if (bas->path[cur] == 0)
2102
40.3k
    break;
2103
2104
353k
      cur++;
2105
2.25M
      while (out < cur) {
2106
1.90M
    res->path[out] = bas->path[out];
2107
1.90M
    out++;
2108
1.90M
      }
2109
353k
  }
2110
44.8k
    }
2111
76.6k
    res->path[out] = 0;
2112
2113
    /*
2114
     * b) The reference's path component is appended to the buffer
2115
     *    string.
2116
     */
2117
76.6k
    if (ref->path != NULL && ref->path[0] != 0) {
2118
76.5k
  indx = 0;
2119
  /*
2120
   * Ensure the path includes a '/'
2121
   */
2122
76.5k
  if ((out == 0) && ((bas->server != NULL) || bas->port != PORT_EMPTY))
2123
13.9k
      res->path[out++] = '/';
2124
1.00M
  while (ref->path[indx] != 0) {
2125
929k
      res->path[out++] = ref->path[indx++];
2126
929k
  }
2127
76.5k
    }
2128
76.6k
    res->path[out] = 0;
2129
2130
    /*
2131
     * Steps c) to h) are really path normalization steps
2132
     */
2133
76.6k
    xmlNormalizeURIPath(res->path);
2134
2135
78.7k
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
78.7k
    val = xmlSaveUri(res);
2143
2144
446k
done:
2145
446k
    if (ref != NULL)
2146
442k
  xmlFreeURI(ref);
2147
446k
    if (bas != NULL)
2148
160k
  xmlFreeURI(bas);
2149
446k
    if (res != NULL)
2150
78.7k
  xmlFreeURI(res);
2151
446k
    return(val);
2152
78.7k
}
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.14M
{
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.14M
    xmlURIPtr uri;
2406
1.14M
    xmlChar *ret;
2407
1.14M
    const xmlChar *absuri;
2408
2409
1.14M
    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.14M
    if ((path[0] == '/') && (path[1] == '/') && (path[2] != '/'))
2427
6.59k
        path++;
2428
2429
1.14M
    if ((uri = xmlParseURI((const char *) path)) != NULL) {
2430
537k
  xmlFreeURI(uri);
2431
537k
  return xmlStrdup(path);
2432
537k
    }
2433
2434
    /* Check if this is an "absolute uri" */
2435
608k
    absuri = xmlStrstr(path, BAD_CAST "://");
2436
608k
    if (absuri != NULL) {
2437
109k
        int l, j;
2438
109k
  unsigned char c;
2439
109k
  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
109k
  l = absuri - path;
2447
  /* Bypass if first part (part before the '://') is > 20 chars */
2448
109k
  if ((l <= 0) || (l > 20))
2449
20.4k
      goto path_processing;
2450
  /* Bypass if any non-alpha characters are present in first part */
2451
276k
  for (j = 0;j < l;j++) {
2452
208k
      c = path[j];
2453
208k
      if (!(((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z'))))
2454
20.8k
          goto path_processing;
2455
208k
  }
2456
2457
  /* Escape all except the characters specified in the supplied path */
2458
67.9k
        escURI = xmlURIEscapeStr(path, BAD_CAST ":/?_.#&;=");
2459
67.9k
  if (escURI != NULL) {
2460
      /* Try parsing the escaped path */
2461
67.9k
      uri = xmlParseURI((const char *) escURI);
2462
      /* If successful, return the escaped string */
2463
67.9k
      if (uri != NULL) {
2464
55.6k
          xmlFreeURI(uri);
2465
55.6k
    return escURI;
2466
55.6k
      }
2467
12.3k
            xmlFree(escURI);
2468
12.3k
  }
2469
67.9k
    }
2470
2471
552k
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
552k
    ret = xmlStrdup((const xmlChar *) path);
2520
552k
#endif
2521
552k
    return(ret);
2522
608k
}
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
676k
{
2538
676k
    xmlURIPtr uri;
2539
676k
    xmlURI temp;
2540
676k
    xmlChar *ret, *cal;
2541
2542
676k
    if (path == NULL)
2543
0
        return(NULL);
2544
2545
676k
    if ((uri = xmlParseURI((const char *) path)) != NULL) {
2546
296k
  xmlFreeURI(uri);
2547
296k
  return xmlStrdup(path);
2548
296k
    }
2549
380k
    cal = xmlCanonicPath(path);
2550
380k
    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
380k
    memset(&temp, 0, sizeof(temp));
2571
380k
    temp.path = (char *) cal;
2572
380k
    ret = xmlSaveUri(&temp);
2573
380k
    xmlFree(cal);
2574
380k
    return(ret);
2575
380k
}