Coverage Report

Created: 2023-09-25 06:03

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