uri.c@ 64739

Last change on this file since 64739 was 58072, checked in by vboxsync, 9 years ago
libxml 2.9.2 unmodified
Property svn:eol-style set to `native`
File size: 65.4 KB

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

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/libxml2-2.9.2/uri.c@ 64739

Download in other formats: