nanohttp.c@ 102948

Last change on this file since 102948 was 95312, checked in by vboxsync, 2 years ago
libs/{curl,libxml2}: OSE export fixes, bugref:8515
Property svn:eol-style set to `native`
File size: 47.4 KB

Line
1	/*
2	* nanohttp.c: minimalist HTTP GET implementation to fetch external subsets.
3	* focuses on size, streamability, reentrancy and portability
4	*
5	* This is clearly not a general purpose HTTP implementation
6	* If you look for one, check:
7	* http://www.w3.org/Library/
8	*
9	* See Copyright for the status of this software.
10	*
11	* daniel@veillard.com
12	*/
13
14	#define IN_LIBXML
15	#include "libxml.h"
16
17	#ifdef LIBXML_HTTP_ENABLED
18	#include <string.h>
19
20	#ifdef HAVE_STDLIB_H
21	#include <stdlib.h>
22	#endif
23	#ifdef HAVE_UNISTD_H
24	#include <unistd.h>
25	#endif
26	#ifdef HAVE_SYS_TYPES_H
27	#include <sys/types.h>
28	#endif
29	#ifdef HAVE_SYS_SOCKET_H
30	#include <sys/socket.h>
31	#endif
32	#ifdef HAVE_NETINET_IN_H
33	#include <netinet/in.h>
34	#endif
35	#ifdef HAVE_ARPA_INET_H
36	#include <arpa/inet.h>
37	#endif
38	#ifdef HAVE_NETDB_H
39	#include <netdb.h>
40	#endif
41	#ifdef HAVE_RESOLV_H
42	#ifdef HAVE_ARPA_NAMESER_H
43	#include <arpa/nameser.h>
44	#endif
45	#include <resolv.h>
46	#endif
47	#ifdef HAVE_FCNTL_H
48	#include <fcntl.h>
49	#endif
50	#ifdef HAVE_ERRNO_H
51	#include <errno.h>
52	#endif
53	#ifdef HAVE_SYS_TIME_H
54	#include <sys/time.h>
55	#endif
56	#ifndef HAVE_POLL_H
57	#ifdef HAVE_SYS_SELECT_H
58	#include <sys/select.h>
59	#endif
60	#else
61	#include <poll.h>
62	#endif
63	#ifdef HAVE_STRINGS_H
64	#include <strings.h>
65	#endif
66	#ifdef LIBXML_ZLIB_ENABLED
67	#include <zlib.h>
68	#endif
69
70
71	#ifdef VMS
72	#include <stropts>
73	#define XML_SOCKLEN_T unsigned int
74	#endif
75
76	#if defined(_WIN32) && !defined(__CYGWIN__)
77	#include <wsockcompat.h>
78	#endif
79
80	#include <libxml/globals.h>
81	#include <libxml/xmlerror.h>
82	#include <libxml/xmlmemory.h>
83	#include <libxml/parser.h> /* for xmlStr(n)casecmp() */
84	#include <libxml/nanohttp.h>
85	#include <libxml/globals.h>
86	#include <libxml/uri.h>
87
88	/**
89	* A couple portability macros
90	*/
91	#ifndef _WINSOCKAPI_
92	#if !defined(__BEOS__) \|\| defined(__HAIKU__)
93	#define closesocket(s) close(s)
94	#endif
95	#define SOCKET int
96	#define INVALID_SOCKET (-1)
97	#endif
98
99	#ifdef __BEOS__
100	#ifndef PF_INET
101	#define PF_INET AF_INET
102	#endif
103	#endif
104
105	#ifndef XML_SOCKLEN_T
106	#define XML_SOCKLEN_T unsigned int
107	#endif
108
109	#ifdef STANDALONE
110	#define DEBUG_HTTP
111	#define xmlStrncasecmp(a, b, n) strncasecmp((char )a, (char )b, n)
112	#define xmlStrcasecmpi(a, b) strcasecmp((char )a, (char )b)
113	#endif
114
115	#define XML_NANO_HTTP_MAX_REDIR 10
116
117	#define XML_NANO_HTTP_CHUNK 4096
118
119	#define XML_NANO_HTTP_CLOSED 0
120	#define XML_NANO_HTTP_WRITE 1
121	#define XML_NANO_HTTP_READ 2
122	#define XML_NANO_HTTP_NONE 4
123
124	typedef struct xmlNanoHTTPCtxt {
125	char protocol; / the protocol name */
126	char hostname; / the host name */
127	int port; /* the port */
128	char path; / the path within the URL */
129	char query; / the query string */
130	SOCKET fd; /* the file descriptor for the socket */
131	int state; /* WRITE / READ / CLOSED */
132	char out; / buffer sent (zero terminated) */
133	char outptr; / index within the buffer sent */
134	char in; / the receiving buffer */
135	char content; / the start of the content */
136	char inptr; / the next byte to read from network */
137	char inrptr; / the next byte to give back to the client */
138	int inlen; /* len of the input buffer */
139	int last; /* return code for last operation */
140	int returnValue; /* the protocol return value */
141	int version; /* the protocol version */
142	int ContentLength; /* specified content length from HTTP header */
143	char contentType; / the MIME type for the input */
144	char location; / the new URL in case of redirect */
145	char authHeader; / contents of {WWW,Proxy}-Authenticate header */
146	char encoding; / encoding extracted from the contentType */
147	char mimeType; / Mime-Type extracted from the contentType */
148	#ifdef LIBXML_ZLIB_ENABLED
149	z_stream strm; / Zlib stream object */
150	int usesGzip; /* "Content-Encoding: gzip" was detected */
151	#endif
152	} xmlNanoHTTPCtxt, *xmlNanoHTTPCtxtPtr;
153
154	static int initialized = 0;
155	static char proxy = NULL; / the proxy name if any */
156	static int proxyPort; /* the proxy port if any */
157	static unsigned int timeout = 60;/* the select() timeout in seconds */
158
159	static int xmlNanoHTTPFetchContent( void * ctx, char ** ptr, int * len );
160
161	/**
162	* xmlHTTPErrMemory:
163	* @extra: extra information
164	*
165	* Handle an out of memory condition
166	*/
167	static void
168	xmlHTTPErrMemory(const char *extra)
169	{
170	__xmlSimpleError(XML_FROM_HTTP, XML_ERR_NO_MEMORY, NULL, NULL, extra);
171	}
172
173	/**
174	* A portability function
175	*/
176	static int socket_errno(void) {
177	#ifdef _WINSOCKAPI_
178	int err = WSAGetLastError();
179	switch(err) {
180	case WSAECONNRESET:
181	return(ECONNRESET);
182	case WSAEINPROGRESS:
183	return(EINPROGRESS);
184	case WSAEINTR:
185	return(EINTR);
186	case WSAESHUTDOWN:
187	return(ESHUTDOWN);
188	case WSAEWOULDBLOCK:
189	return(EWOULDBLOCK);
190	default:
191	return(err);
192	}
193	#else
194	return(errno);
195	#endif
196	}
197
198	#ifdef SUPPORT_IP6
199	static
200	int have_ipv6(void) {
201	SOCKET s;
202
203	s = socket (AF_INET6, SOCK_STREAM, 0);
204	if (s != INVALID_SOCKET) {
205	close (s);
206	return (1);
207	}
208	return (0);
209	}
210	#endif
211
212	/**
213	* xmlNanoHTTPInit:
214	*
215	* Initialize the HTTP protocol layer.
216	* Currently it just checks for proxy information
217	*/
218
219	void
220	xmlNanoHTTPInit(void) {
221	const char *env;
222	#ifdef _WINSOCKAPI_
223	WSADATA wsaData;
224	#endif
225
226	if (initialized)
227	return;
228
229	#ifdef _WINSOCKAPI_
230	if (WSAStartup(MAKEWORD(1, 1), &wsaData) != 0)
231	return;
232	#endif
233
234	if (proxy == NULL) {
235	proxyPort = 80;
236	env = getenv("no_proxy");
237	if (env && ((env[0] == '*') && (env[1] == 0)))
238	goto done;
239	env = getenv("http_proxy");
240	if (env != NULL) {
241	xmlNanoHTTPScanProxy(env);
242	goto done;
243	}
244	env = getenv("HTTP_PROXY");
245	if (env != NULL) {
246	xmlNanoHTTPScanProxy(env);
247	goto done;
248	}
249	}
250	done:
251	initialized = 1;
252	}
253
254	/**
255	* xmlNanoHTTPCleanup:
256	*
257	* Cleanup the HTTP protocol layer.
258	*/
259
260	void
261	xmlNanoHTTPCleanup(void) {
262	if (proxy != NULL) {
263	xmlFree(proxy);
264	proxy = NULL;
265	}
266	#ifdef _WINSOCKAPI_
267	if (initialized)
268	WSACleanup();
269	#endif
270	initialized = 0;
271	return;
272	}
273
274	/**
275	* xmlNanoHTTPScanURL:
276	* @ctxt: an HTTP context
277	* @URL: The URL used to initialize the context
278	*
279	* (Re)Initialize an HTTP context by parsing the URL and finding
280	* the protocol host port and path it indicates.
281	*/
282
283	static void
284	xmlNanoHTTPScanURL(xmlNanoHTTPCtxtPtr ctxt, const char *URL) {
285	xmlURIPtr uri;
286	int len;
287
288	/*
289	* Clear any existing data from the context
290	*/
291	if (ctxt->protocol != NULL) {
292	xmlFree(ctxt->protocol);
293	ctxt->protocol = NULL;
294	}
295	if (ctxt->hostname != NULL) {
296	xmlFree(ctxt->hostname);
297	ctxt->hostname = NULL;
298	}
299	if (ctxt->path != NULL) {
300	xmlFree(ctxt->path);
301	ctxt->path = NULL;
302	}
303	if (ctxt->query != NULL) {
304	xmlFree(ctxt->query);
305	ctxt->query = NULL;
306	}
307	if (URL == NULL) return;
308
309	uri = xmlParseURIRaw(URL, 1);
310	if (uri == NULL)
311	return;
312
313	if ((uri->scheme == NULL) \|\| (uri->server == NULL)) {
314	xmlFreeURI(uri);
315	return;
316	}
317
318	ctxt->protocol = xmlMemStrdup(uri->scheme);
319	/* special case of IPv6 addresses, the [] need to be removed */
320	if ((uri->server != NULL) && (*uri->server == '[')) {
321	len = strlen(uri->server);
322	if ((len > 2) && (uri->server[len - 1] == ']')) {
323	ctxt->hostname = (char *) xmlCharStrndup(uri->server + 1, len -2);
324	} else
325	ctxt->hostname = xmlMemStrdup(uri->server);
326	} else
327	ctxt->hostname = xmlMemStrdup(uri->server);
328	if (uri->path != NULL)
329	ctxt->path = xmlMemStrdup(uri->path);
330	else
331	ctxt->path = xmlMemStrdup("/");
332	if (uri->query != NULL)
333	ctxt->query = xmlMemStrdup(uri->query);
334	if (uri->port != 0)
335	ctxt->port = uri->port;
336
337	xmlFreeURI(uri);
338	}
339
340	/**
341	* xmlNanoHTTPScanProxy:
342	* @URL: The proxy URL used to initialize the proxy context
343	*
344	* (Re)Initialize the HTTP Proxy context by parsing the URL and finding
345	* the protocol host port it indicates.
346	* Should be like http://myproxy/ or http://myproxy:3128/
347	* A NULL URL cleans up proxy information.
348	*/
349
350	void
351	xmlNanoHTTPScanProxy(const char *URL) {
352	xmlURIPtr uri;
353
354	if (proxy != NULL) {
355	xmlFree(proxy);
356	proxy = NULL;
357	}
358	proxyPort = 0;
359
360	#ifdef DEBUG_HTTP
361	if (URL == NULL)
362	xmlGenericError(xmlGenericErrorContext,
363	"Removing HTTP proxy info\n");
364	else
365	xmlGenericError(xmlGenericErrorContext,
366	"Using HTTP proxy %s\n", URL);
367	#endif
368	if (URL == NULL) return;
369
370	uri = xmlParseURIRaw(URL, 1);
371	if ((uri == NULL) \|\| (uri->scheme == NULL) \|\|
372	(strcmp(uri->scheme, "http")) \|\| (uri->server == NULL)) {
373	__xmlIOErr(XML_FROM_HTTP, XML_HTTP_URL_SYNTAX, "Syntax Error\n");
374	if (uri != NULL)
375	xmlFreeURI(uri);
376	return;
377	}
378
379	proxy = xmlMemStrdup(uri->server);
380	if (uri->port != 0)
381	proxyPort = uri->port;
382
383	xmlFreeURI(uri);
384	}
385
386	/**
387	* xmlNanoHTTPNewCtxt:
388	* @URL: The URL used to initialize the context
389	*
390	* Allocate and initialize a new HTTP context.
391	*
392	* Returns an HTTP context or NULL in case of error.
393	*/
394
395	static xmlNanoHTTPCtxtPtr
396	xmlNanoHTTPNewCtxt(const char *URL) {
397	xmlNanoHTTPCtxtPtr ret;
398
399	ret = (xmlNanoHTTPCtxtPtr) xmlMalloc(sizeof(xmlNanoHTTPCtxt));
400	if (ret == NULL) {
401	xmlHTTPErrMemory("allocating context");
402	return(NULL);
403	}
404
405	memset(ret, 0, sizeof(xmlNanoHTTPCtxt));
406	ret->port = 80;
407	ret->returnValue = 0;
408	ret->fd = INVALID_SOCKET;
409	ret->ContentLength = -1;
410
411	xmlNanoHTTPScanURL(ret, URL);
412
413	return(ret);
414	}
415
416	/**
417	* xmlNanoHTTPFreeCtxt:
418	* @ctxt: an HTTP context
419	*
420	* Frees the context after closing the connection.
421	*/
422
423	static void
424	xmlNanoHTTPFreeCtxt(xmlNanoHTTPCtxtPtr ctxt) {
425	if (ctxt == NULL) return;
426	if (ctxt->hostname != NULL) xmlFree(ctxt->hostname);
427	if (ctxt->protocol != NULL) xmlFree(ctxt->protocol);
428	if (ctxt->path != NULL) xmlFree(ctxt->path);
429	if (ctxt->query != NULL) xmlFree(ctxt->query);
430	if (ctxt->out != NULL) xmlFree(ctxt->out);
431	if (ctxt->in != NULL) xmlFree(ctxt->in);
432	if (ctxt->contentType != NULL) xmlFree(ctxt->contentType);
433	if (ctxt->encoding != NULL) xmlFree(ctxt->encoding);
434	if (ctxt->mimeType != NULL) xmlFree(ctxt->mimeType);
435	if (ctxt->location != NULL) xmlFree(ctxt->location);
436	if (ctxt->authHeader != NULL) xmlFree(ctxt->authHeader);
437	#ifdef LIBXML_ZLIB_ENABLED
438	if (ctxt->strm != NULL) {
439	inflateEnd(ctxt->strm);
440	xmlFree(ctxt->strm);
441	}
442	#endif
443
444	ctxt->state = XML_NANO_HTTP_NONE;
445	if (ctxt->fd != INVALID_SOCKET) closesocket(ctxt->fd);
446	ctxt->fd = INVALID_SOCKET;
447	xmlFree(ctxt);
448	}
449
450	/**
451	* xmlNanoHTTPSend:
452	* @ctxt: an HTTP context
453	*
454	* Send the input needed to initiate the processing on the server side
455	* Returns number of bytes sent or -1 on error.
456	*/
457
458	static int
459	xmlNanoHTTPSend(xmlNanoHTTPCtxtPtr ctxt, const char *xmt_ptr, int outlen)
460	{
461	int total_sent = 0;
462	#ifdef HAVE_POLL_H
463	struct pollfd p;
464	#else
465	struct timeval tv;
466	fd_set wfd;
467	#endif
468
469	if ((ctxt->state & XML_NANO_HTTP_WRITE) && (xmt_ptr != NULL)) {
470	while (total_sent < outlen) {
471	int nsent = send(ctxt->fd, SEND_ARG2_CAST (xmt_ptr + total_sent),
472	outlen - total_sent, 0);
473
474	if (nsent > 0)
475	total_sent += nsent;
476	else if ((nsent == -1) &&
477	#if defined(EAGAIN) && EAGAIN != EWOULDBLOCK
478	(socket_errno() != EAGAIN) &&
479	#endif
480	(socket_errno() != EWOULDBLOCK)) {
481	__xmlIOErr(XML_FROM_HTTP, 0, "send failed\n");
482	if (total_sent == 0)
483	total_sent = -1;
484	break;
485	} else {
486	/*
487	* No data sent
488	* Since non-blocking sockets are used, wait for
489	* socket to be writable or default timeout prior
490	* to retrying.
491	*/
492	#ifndef HAVE_POLL_H
493	#ifndef _WINSOCKAPI_
494	if (ctxt->fd > FD_SETSIZE)
495	return -1;
496	#endif
497
498	tv.tv_sec = timeout;
499	tv.tv_usec = 0;
500	FD_ZERO(&wfd);
501	#ifdef _MSC_VER
502	#pragma warning(push)
503	#pragma warning(disable: 4018)
504	#endif
505	FD_SET(ctxt->fd, &wfd);
506	#ifdef _MSC_VER
507	#pragma warning(pop)
508	#endif
509	(void) select(ctxt->fd + 1, NULL, &wfd, NULL, &tv);
510	#else
511	p.fd = ctxt->fd;
512	p.events = POLLOUT;
513	(void) poll(&p, 1, timeout * 1000);
514	#endif /* !HAVE_POLL_H */
515	}
516	}
517	}
518
519	return total_sent;
520	}
521
522	/**
523	* xmlNanoHTTPRecv:
524	* @ctxt: an HTTP context
525	*
526	* Read information coming from the HTTP connection.
527	* This is a blocking call (but it blocks in select(), not read()).
528	*
529	* Returns the number of byte read or -1 in case of error.
530	*/
531
532	static int
533	xmlNanoHTTPRecv(xmlNanoHTTPCtxtPtr ctxt)
534	{
535	#ifdef HAVE_POLL_H
536	struct pollfd p;
537	#else
538	fd_set rfd;
539	struct timeval tv;
540	#endif
541
542
543	while (ctxt->state & XML_NANO_HTTP_READ) {
544	if (ctxt->in == NULL) {
545	ctxt->in = (char ) xmlMallocAtomic(65000 sizeof(char));
546	if (ctxt->in == NULL) {
547	xmlHTTPErrMemory("allocating input");
548	ctxt->last = -1;
549	return (-1);
550	}
551	ctxt->inlen = 65000;
552	ctxt->inptr = ctxt->content = ctxt->inrptr = ctxt->in;
553	}
554	if (ctxt->inrptr > ctxt->in + XML_NANO_HTTP_CHUNK) {
555	int delta = ctxt->inrptr - ctxt->in;
556	int len = ctxt->inptr - ctxt->inrptr;
557
558	memmove(ctxt->in, ctxt->inrptr, len);
559	ctxt->inrptr -= delta;
560	ctxt->content -= delta;
561	ctxt->inptr -= delta;
562	}
563	if ((ctxt->in + ctxt->inlen) < (ctxt->inptr + XML_NANO_HTTP_CHUNK)) {
564	int d_inptr = ctxt->inptr - ctxt->in;
565	int d_content = ctxt->content - ctxt->in;
566	int d_inrptr = ctxt->inrptr - ctxt->in;
567	char *tmp_ptr = ctxt->in;
568
569	ctxt->inlen *= 2;
570	ctxt->in = (char *) xmlRealloc(tmp_ptr, ctxt->inlen);
571	if (ctxt->in == NULL) {
572	xmlHTTPErrMemory("allocating input buffer");
573	xmlFree(tmp_ptr);
574	ctxt->last = -1;
575	return (-1);
576	}
577	ctxt->inptr = ctxt->in + d_inptr;
578	ctxt->content = ctxt->in + d_content;
579	ctxt->inrptr = ctxt->in + d_inrptr;
580	}
581	ctxt->last = recv(ctxt->fd, ctxt->inptr, XML_NANO_HTTP_CHUNK, 0);
582	if (ctxt->last > 0) {
583	ctxt->inptr += ctxt->last;
584	return (ctxt->last);
585	}
586	if (ctxt->last == 0) {
587	return (0);
588	}
589	if (ctxt->last == -1) {
590	switch (socket_errno()) {
591	case EINPROGRESS:
592	case EWOULDBLOCK:
593	#if defined(EAGAIN) && EAGAIN != EWOULDBLOCK
594	case EAGAIN:
595	#endif
596	break;
597
598	case ECONNRESET:
599	case ESHUTDOWN:
600	return (0);
601
602	default:
603	__xmlIOErr(XML_FROM_HTTP, 0, "recv failed\n");
604	return (-1);
605	}
606	}
607	#ifdef HAVE_POLL_H
608	p.fd = ctxt->fd;
609	p.events = POLLIN;
610	if ((poll(&p, 1, timeout * 1000) < 1)
611	#if defined(EINTR)
612	&& (errno != EINTR)
613	#endif
614	)
615	return (0);
616	#else /* !HAVE_POLL_H */
617	#ifndef _WINSOCKAPI_
618	if (ctxt->fd > FD_SETSIZE)
619	return 0;
620	#endif
621
622	tv.tv_sec = timeout;
623	tv.tv_usec = 0;
624	FD_ZERO(&rfd);
625
626	#ifdef _MSC_VER
627	#pragma warning(push)
628	#pragma warning(disable: 4018)
629	#endif
630
631	FD_SET(ctxt->fd, &rfd);
632
633	#ifdef _MSC_VER
634	#pragma warning(pop)
635	#endif
636
637	if ((select(ctxt->fd + 1, &rfd, NULL, NULL, &tv) < 1)
638	#if defined(EINTR)
639	&& (socket_errno() != EINTR)
640	#endif
641	)
642	return (0);
643	#endif /* !HAVE_POLL_H */
644	}
645	return (0);
646	}
647
648	/**
649	* xmlNanoHTTPReadLine:
650	* @ctxt: an HTTP context
651	*
652	* Read one line in the HTTP server output, usually for extracting
653	* the HTTP protocol information from the answer header.
654	*
655	* Returns a newly allocated string with a copy of the line, or NULL
656	* which indicate the end of the input.
657	*/
658
659	static char *
660	xmlNanoHTTPReadLine(xmlNanoHTTPCtxtPtr ctxt) {
661	char buf[4096];
662	char *bp = buf;
663	int rc;
664
665	while (bp - buf < 4095) {
666	if (ctxt->inrptr == ctxt->inptr) {
667	if ( (rc = xmlNanoHTTPRecv(ctxt)) == 0) {
668	if (bp == buf)
669	return(NULL);
670	else
671	*bp = 0;
672	return(xmlMemStrdup(buf));
673	}
674	else if ( rc == -1 ) {
675	return ( NULL );
676	}
677	}
678	bp = ctxt->inrptr++;
679	if (*bp == '\n') {
680	*bp = 0;
681	return(xmlMemStrdup(buf));
682	}
683	if (*bp != '\r')
684	bp++;
685	}
686	buf[4095] = 0;
687	return(xmlMemStrdup(buf));
688	}
689
690
691	/**
692	* xmlNanoHTTPScanAnswer:
693	* @ctxt: an HTTP context
694	* @line: an HTTP header line
695	*
696	* Try to extract useful information from the server answer.
697	* We currently parse and process:
698	* - The HTTP revision/ return code
699	* - The Content-Type, Mime-Type and charset used
700	* - The Location for redirect processing.
701	*
702	* Returns -1 in case of failure, the file descriptor number otherwise
703	*/
704
705	static void
706	xmlNanoHTTPScanAnswer(xmlNanoHTTPCtxtPtr ctxt, const char *line) {
707	const char *cur = line;
708
709	if (line == NULL) return;
710
711	if (!strncmp(line, "HTTP/", 5)) {
712	int version = 0;
713	int ret = 0;
714
715	cur += 5;
716	while ((cur >= '0') && (cur <= '9')) {
717	version *= 10;
718	version += *cur - '0';
719	cur++;
720	}
721	if (*cur == '.') {
722	cur++;
723	if ((cur >= '0') && (cur <= '9')) {
724	version *= 10;
725	version += *cur - '0';
726	cur++;
727	}
728	while ((cur >= '0') && (cur <= '9'))
729	cur++;
730	} else
731	version *= 10;
732	if ((cur != ' ') && (cur != '\t')) return;
733	while ((cur == ' ') \|\| (cur == '\t')) cur++;
734	if ((cur < '0') \|\| (cur > '9')) return;
735	while ((cur >= '0') && (cur <= '9')) {
736	ret *= 10;
737	ret += *cur - '0';
738	cur++;
739	}
740	if ((cur != 0) && (cur != ' ') && (*cur != '\t')) return;
741	ctxt->returnValue = ret;
742	ctxt->version = version;
743	} else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"Content-Type:", 13)) {
744	const xmlChar charset, last, *mime;
745	cur += 13;
746	while ((cur == ' ') \|\| (cur == '\t')) cur++;
747	if (ctxt->contentType != NULL)
748	xmlFree(ctxt->contentType);
749	ctxt->contentType = xmlMemStrdup(cur);
750	mime = (const xmlChar *) cur;
751	last = mime;
752	while ((last != 0) && (last != ' ') && (*last != '\t') &&
753	(last != ';') && (last != ','))
754	last++;
755	if (ctxt->mimeType != NULL)
756	xmlFree(ctxt->mimeType);
757	ctxt->mimeType = (char *) xmlStrndup(mime, last - mime);
758	charset = xmlStrstr(BAD_CAST ctxt->contentType, BAD_CAST "charset=");
759	if (charset != NULL) {
760	charset += 8;
761	last = charset;
762	while ((last != 0) && (last != ' ') && (*last != '\t') &&
763	(last != ';') && (last != ','))
764	last++;
765	if (ctxt->encoding != NULL)
766	xmlFree(ctxt->encoding);
767	ctxt->encoding = (char *) xmlStrndup(charset, last - charset);
768	}
769	} else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"ContentType:", 12)) {
770	const xmlChar charset, last, *mime;
771	cur += 12;
772	if (ctxt->contentType != NULL) return;
773	while ((cur == ' ') \|\| (cur == '\t')) cur++;
774	ctxt->contentType = xmlMemStrdup(cur);
775	mime = (const xmlChar *) cur;
776	last = mime;
777	while ((last != 0) && (last != ' ') && (*last != '\t') &&
778	(last != ';') && (last != ','))
779	last++;
780	if (ctxt->mimeType != NULL)
781	xmlFree(ctxt->mimeType);
782	ctxt->mimeType = (char *) xmlStrndup(mime, last - mime);
783	charset = xmlStrstr(BAD_CAST ctxt->contentType, BAD_CAST "charset=");
784	if (charset != NULL) {
785	charset += 8;
786	last = charset;
787	while ((last != 0) && (last != ' ') && (*last != '\t') &&
788	(last != ';') && (last != ','))
789	last++;
790	if (ctxt->encoding != NULL)
791	xmlFree(ctxt->encoding);
792	ctxt->encoding = (char *) xmlStrndup(charset, last - charset);
793	}
794	} else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"Location:", 9)) {
795	cur += 9;
796	while ((cur == ' ') \|\| (cur == '\t')) cur++;
797	if (ctxt->location != NULL)
798	xmlFree(ctxt->location);
799	if (*cur == '/') {
800	xmlChar *tmp_http = xmlStrdup(BAD_CAST "http://");
801	xmlChar *tmp_loc =
802	xmlStrcat(tmp_http, (const xmlChar *) ctxt->hostname);
803	ctxt->location =
804	(char ) xmlStrcat (tmp_loc, (const xmlChar ) cur);
805	} else {
806	ctxt->location = xmlMemStrdup(cur);
807	}
808	} else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"WWW-Authenticate:", 17)) {
809	cur += 17;
810	while ((cur == ' ') \|\| (cur == '\t')) cur++;
811	if (ctxt->authHeader != NULL)
812	xmlFree(ctxt->authHeader);
813	ctxt->authHeader = xmlMemStrdup(cur);
814	} else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"Proxy-Authenticate:", 19)) {
815	cur += 19;
816	while ((cur == ' ') \|\| (cur == '\t')) cur++;
817	if (ctxt->authHeader != NULL)
818	xmlFree(ctxt->authHeader);
819	ctxt->authHeader = xmlMemStrdup(cur);
820	#ifdef LIBXML_ZLIB_ENABLED
821	} else if ( !xmlStrncasecmp( BAD_CAST line, BAD_CAST"Content-Encoding:", 17) ) {
822	cur += 17;
823	while ((cur == ' ') \|\| (cur == '\t')) cur++;
824	if ( !xmlStrncasecmp( BAD_CAST cur, BAD_CAST"gzip", 4) ) {
825	ctxt->usesGzip = 1;
826
827	ctxt->strm = xmlMalloc(sizeof(z_stream));
828
829	if (ctxt->strm != NULL) {
830	ctxt->strm->zalloc = Z_NULL;
831	ctxt->strm->zfree = Z_NULL;
832	ctxt->strm->opaque = Z_NULL;
833	ctxt->strm->avail_in = 0;
834	ctxt->strm->next_in = Z_NULL;
835
836	inflateInit2( ctxt->strm, 31 );
837	}
838	}
839	#endif
840	} else if ( !xmlStrncasecmp( BAD_CAST line, BAD_CAST"Content-Length:", 15) ) {
841	cur += 15;
842	ctxt->ContentLength = strtol( cur, NULL, 10 );
843	}
844	}
845
846	/**
847	* xmlNanoHTTPConnectAttempt:
848	* @addr: a socket address structure
849	*
850	* Attempt a connection to the given IP:port endpoint. It forces
851	* non-blocking semantic on the socket, and allow 60 seconds for
852	* the host to answer.
853	*
854	* Returns -1 in case of failure, the file descriptor number otherwise
855	*/
856
857	static SOCKET
858	xmlNanoHTTPConnectAttempt(struct sockaddr *addr)
859	{
860	#ifndef HAVE_POLL_H
861	fd_set wfd;
862	#ifdef _WINSOCKAPI_
863	fd_set xfd;
864	#endif
865	struct timeval tv;
866	#else /* !HAVE_POLL_H */
867	struct pollfd p;
868	#endif /* !HAVE_POLL_H */
869	int status;
870
871	int addrlen;
872
873	SOCKET s;
874
875	#ifdef SUPPORT_IP6
876	if (addr->sa_family == AF_INET6) {
877	s = socket(PF_INET6, SOCK_STREAM, IPPROTO_TCP);
878	addrlen = sizeof(struct sockaddr_in6);
879	} else
880	#endif
881	{
882	s = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
883	addrlen = sizeof(struct sockaddr_in);
884	}
885	if (s == INVALID_SOCKET) {
886	#ifdef DEBUG_HTTP
887	perror("socket");
888	#endif
889	__xmlIOErr(XML_FROM_HTTP, 0, "socket failed\n");
890	return INVALID_SOCKET;
891	}
892	#ifdef _WINSOCKAPI_
893	{
894	u_long one = 1;
895
896	status = ioctlsocket(s, FIONBIO, &one) == SOCKET_ERROR ? -1 : 0;
897	}
898	#else /* _WINSOCKAPI_ */
899	#if defined(VMS)
900	{
901	int enable = 1;
902
903	status = ioctl(s, FIONBIO, &enable);
904	}
905	#else /* VMS */
906	#if defined(__BEOS__) && !defined(__HAIKU__)
907	{
908	bool noblock = true;
909
910	status =
911	setsockopt(s, SOL_SOCKET, SO_NONBLOCK, &noblock,
912	sizeof(noblock));
913	}
914	#else /* __BEOS__ */
915	if ((status = fcntl(s, F_GETFL, 0)) != -1) {
916	#ifdef O_NONBLOCK
917	status \|= O_NONBLOCK;
918	#else /* O_NONBLOCK */
919	#ifdef F_NDELAY
920	status \|= F_NDELAY;
921	#endif /* F_NDELAY */
922	#endif /* !O_NONBLOCK */
923	status = fcntl(s, F_SETFL, status);
924	}
925	if (status < 0) {
926	#ifdef DEBUG_HTTP
927	perror("nonblocking");
928	#endif
929	__xmlIOErr(XML_FROM_HTTP, 0, "error setting non-blocking IO\n");
930	closesocket(s);
931	return INVALID_SOCKET;
932	}
933	#endif /* !__BEOS__ */
934	#endif /* !VMS */
935	#endif /* !_WINSOCKAPI_ */
936
937	if (connect(s, addr, addrlen) == -1) {
938	switch (socket_errno()) {
939	case EINPROGRESS:
940	case EWOULDBLOCK:
941	break;
942	default:
943	__xmlIOErr(XML_FROM_HTTP, 0,
944	"error connecting to HTTP server");
945	closesocket(s);
946	return INVALID_SOCKET;
947	}
948	}
949	#ifndef HAVE_POLL_H
950	tv.tv_sec = timeout;
951	tv.tv_usec = 0;
952
953	#ifdef _MSC_VER
954	#pragma warning(push)
955	#pragma warning(disable: 4018)
956	#endif
957	#ifndef _WINSOCKAPI_
958	if (s > FD_SETSIZE)
959	return INVALID_SOCKET;
960	#endif
961	FD_ZERO(&wfd);
962	FD_SET(s, &wfd);
963
964	#ifdef _WINSOCKAPI_
965	FD_ZERO(&xfd);
966	FD_SET(s, &xfd);
967
968	switch (select(s + 1, NULL, &wfd, &xfd, &tv))
969	#else
970	switch (select(s + 1, NULL, &wfd, NULL, &tv))
971	#endif
972	#ifdef _MSC_VER
973	#pragma warning(pop)
974	#endif
975
976	#else /* !HAVE_POLL_H */
977	p.fd = s;
978	p.events = POLLOUT;
979	switch (poll(&p, 1, timeout * 1000))
980	#endif /* !HAVE_POLL_H */
981
982	{
983	case 0:
984	/* Time out */
985	__xmlIOErr(XML_FROM_HTTP, 0, "Connect attempt timed out");
986	closesocket(s);
987	return INVALID_SOCKET;
988	case -1:
989	/* Ermm.. ?? */
990	__xmlIOErr(XML_FROM_HTTP, 0, "Connect failed");
991	closesocket(s);
992	return INVALID_SOCKET;
993	}
994
995	#ifndef HAVE_POLL_H
996	if (FD_ISSET(s, &wfd)
997	#ifdef _WINSOCKAPI_
998	\|\| FD_ISSET(s, &xfd)
999	#endif
1000	)
1001	#else /* !HAVE_POLL_H */
1002	if (p.revents == POLLOUT)
1003	#endif /* !HAVE_POLL_H */
1004	{
1005	XML_SOCKLEN_T len;
1006
1007	len = sizeof(status);
1008	#ifdef SO_ERROR
1009	if (getsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &status, &len) <
1010	0) {
1011	/* Solaris error code */
1012	__xmlIOErr(XML_FROM_HTTP, 0, "getsockopt failed\n");
1013	closesocket(s);
1014	return INVALID_SOCKET;
1015	}
1016	#endif
1017	if (status) {
1018	__xmlIOErr(XML_FROM_HTTP, 0,
1019	"Error connecting to remote host");
1020	closesocket(s);
1021	errno = status;
1022	return INVALID_SOCKET;
1023	}
1024	} else {
1025	/* pbm */
1026	__xmlIOErr(XML_FROM_HTTP, 0, "select failed\n");
1027	closesocket(s);
1028	return INVALID_SOCKET;
1029	}
1030
1031	return (s);
1032	}
1033
1034	/**
1035	* xmlNanoHTTPConnectHost:
1036	* @host: the host name
1037	* @port: the port number
1038	*
1039	* Attempt a connection to the given host:port endpoint. It tries
1040	* the multiple IP provided by the DNS if available.
1041	*
1042	* Returns -1 in case of failure, the file descriptor number otherwise
1043	*/
1044
1045	static SOCKET
1046	xmlNanoHTTPConnectHost(const char *host, int port)
1047	{
1048	struct sockaddr *addr = NULL;
1049	struct sockaddr_in sockin;
1050
1051	#ifdef SUPPORT_IP6
1052	struct in6_addr ia6;
1053	struct sockaddr_in6 sockin6;
1054	#endif
1055	SOCKET s;
1056
1057	memset (&sockin, 0, sizeof(sockin));
1058	#ifdef SUPPORT_IP6
1059	memset (&sockin6, 0, sizeof(sockin6));
1060	#endif
1061
1062	#if !defined(HAVE_GETADDRINFO) && defined(SUPPORT_IP6) && defined(RES_USE_INET6)
1063	if (have_ipv6 ())
1064	{
1065	if (!(_res.options & RES_INIT))
1066	res_init();
1067	_res.options \|= RES_USE_INET6;
1068	}
1069	#endif
1070
1071	#if defined(HAVE_GETADDRINFO) && defined(SUPPORT_IP6) && !defined(_WIN32)
1072	if (have_ipv6 ())
1073	#endif
1074	#if defined(HAVE_GETADDRINFO) && (defined(SUPPORT_IP6) \|\| defined(_WIN32))
1075	{
1076	int status;
1077	struct addrinfo hints, res, result;
1078
1079	result = NULL;
1080	memset (&hints, 0,sizeof(hints));
1081	hints.ai_socktype = SOCK_STREAM;
1082
1083	status = getaddrinfo (host, NULL, &hints, &result);
1084	if (status) {
1085	__xmlIOErr(XML_FROM_HTTP, 0, "getaddrinfo failed\n");
1086	return INVALID_SOCKET;
1087	}
1088
1089	for (res = result; res; res = res->ai_next) {
1090	if (res->ai_family == AF_INET) {
1091	if ((size_t)res->ai_addrlen > sizeof(sockin)) {
1092	__xmlIOErr(XML_FROM_HTTP, 0, "address size mismatch\n");
1093	freeaddrinfo (result);
1094	return INVALID_SOCKET;
1095	}
1096	memcpy (&sockin, res->ai_addr, res->ai_addrlen);
1097	sockin.sin_port = htons (port);
1098	addr = (struct sockaddr *)&sockin;
1099	#ifdef SUPPORT_IP6
1100	} else if (have_ipv6 () && (res->ai_family == AF_INET6)) {
1101	if ((size_t)res->ai_addrlen > sizeof(sockin6)) {
1102	__xmlIOErr(XML_FROM_HTTP, 0, "address size mismatch\n");
1103	freeaddrinfo (result);
1104	return INVALID_SOCKET;
1105	}
1106	memcpy (&sockin6, res->ai_addr, res->ai_addrlen);
1107	sockin6.sin6_port = htons (port);
1108	addr = (struct sockaddr *)&sockin6;
1109	#endif
1110	} else
1111	continue; /* for */
1112
1113	s = xmlNanoHTTPConnectAttempt (addr);
1114	if (s != INVALID_SOCKET) {
1115	freeaddrinfo (result);
1116	return (s);
1117	}
1118	}
1119
1120	if (result)
1121	freeaddrinfo (result);
1122	}
1123	#endif
1124	#if defined(HAVE_GETADDRINFO) && defined(SUPPORT_IP6) && !defined(_WIN32)
1125	else
1126	#endif
1127	#if !defined(HAVE_GETADDRINFO) \|\| !defined(_WIN32)
1128	{
1129	struct hostent *h;
1130	struct in_addr ia;
1131	int i;
1132
1133	h = gethostbyname (GETHOSTBYNAME_ARG_CAST host);
1134	if (h == NULL) {
1135
1136	/*
1137	* Okay, I got fed up by the non-portability of this error message
1138	* extraction code. it work on Linux, if it work on your platform
1139	* and one want to enable it, send me the defined(foobar) needed
1140	*/
1141	#if defined(HAVE_NETDB_H) && defined(HOST_NOT_FOUND) && defined(__linux__)
1142	const char *h_err_txt = "";
1143
1144	switch (h_errno) {
1145	case HOST_NOT_FOUND:
1146	h_err_txt = "Authoritative host not found";
1147	break;
1148
1149	case TRY_AGAIN:
1150	h_err_txt =
1151	"Non-authoritative host not found or server failure.";
1152	break;
1153
1154	case NO_RECOVERY:
1155	h_err_txt =
1156	"Non-recoverable errors: FORMERR, REFUSED, or NOTIMP.";
1157	break;
1158
1159	#ifdef NO_ADDRESS
1160	case NO_ADDRESS:
1161	h_err_txt =
1162	"Valid name, no data record of requested type.";
1163	break;
1164	#endif
1165
1166	default:
1167	h_err_txt = "No error text defined.";
1168	break;
1169	}
1170	__xmlIOErr(XML_FROM_HTTP, 0, h_err_txt);
1171	#else
1172	__xmlIOErr(XML_FROM_HTTP, 0, "Failed to resolve host");
1173	#endif
1174	return INVALID_SOCKET;
1175	}
1176
1177	for (i = 0; h->h_addr_list[i]; i++) {
1178	if (h->h_addrtype == AF_INET) {
1179	/* A records (IPv4) */
1180	if ((unsigned int) h->h_length > sizeof(ia)) {
1181	__xmlIOErr(XML_FROM_HTTP, 0, "address size mismatch\n");
1182	return INVALID_SOCKET;
1183	}
1184	memcpy (&ia, h->h_addr_list[i], h->h_length);
1185	sockin.sin_family = h->h_addrtype;
1186	sockin.sin_addr = ia;
1187	sockin.sin_port = (unsigned short)htons ((unsigned short)port);
1188	addr = (struct sockaddr *) &sockin;
1189	#ifdef SUPPORT_IP6
1190	} else if (have_ipv6 () && (h->h_addrtype == AF_INET6)) {
1191	/* AAAA records (IPv6) */
1192	if ((unsigned int) h->h_length > sizeof(ia6)) {
1193	__xmlIOErr(XML_FROM_HTTP, 0, "address size mismatch\n");
1194	return INVALID_SOCKET;
1195	}
1196	memcpy (&ia6, h->h_addr_list[i], h->h_length);
1197	sockin6.sin6_family = h->h_addrtype;
1198	sockin6.sin6_addr = ia6;
1199	sockin6.sin6_port = htons (port);
1200	addr = (struct sockaddr *) &sockin6;
1201	#endif
1202	} else
1203	break; /* for */
1204
1205	s = xmlNanoHTTPConnectAttempt (addr);
1206	if (s != INVALID_SOCKET)
1207	return (s);
1208	}
1209	}
1210	#endif
1211
1212	#ifdef DEBUG_HTTP
1213	xmlGenericError(xmlGenericErrorContext,
1214	"xmlNanoHTTPConnectHost: unable to connect to '%s'.\n",
1215	host);
1216	#endif
1217	return INVALID_SOCKET;
1218	}
1219
1220
1221	/**
1222	* xmlNanoHTTPOpen:
1223	* @URL: The URL to load
1224	* @contentType: if available the Content-Type information will be
1225	* returned at that location
1226	*
1227	* This function try to open a connection to the indicated resource
1228	* via HTTP GET.
1229	*
1230	* Returns NULL in case of failure, otherwise a request handler.
1231	* The contentType, if provided must be freed by the caller
1232	*/
1233
1234	void*
1235	xmlNanoHTTPOpen(const char URL, char *contentType) {
1236	if (contentType != NULL) *contentType = NULL;
1237	return(xmlNanoHTTPMethod(URL, NULL, NULL, contentType, NULL, 0));
1238	}
1239
1240	/**
1241	* xmlNanoHTTPOpenRedir:
1242	* @URL: The URL to load
1243	* @contentType: if available the Content-Type information will be
1244	* returned at that location
1245	* @redir: if available the redirected URL will be returned
1246	*
1247	* This function try to open a connection to the indicated resource
1248	* via HTTP GET.
1249	*
1250	* Returns NULL in case of failure, otherwise a request handler.
1251	* The contentType, if provided must be freed by the caller
1252	*/
1253
1254	void*
1255	xmlNanoHTTPOpenRedir(const char URL, char contentType, char *redir) {
1256	if (contentType != NULL) *contentType = NULL;
1257	if (redir != NULL) *redir = NULL;
1258	return(xmlNanoHTTPMethodRedir(URL, NULL, NULL, contentType, redir, NULL,0));
1259	}
1260
1261	/**
1262	* xmlNanoHTTPRead:
1263	* @ctx: the HTTP context
1264	* @dest: a buffer
1265	* @len: the buffer length
1266	*
1267	* This function tries to read @len bytes from the existing HTTP connection
1268	* and saves them in @dest. This is a blocking call.
1269	*
1270	* Returns the number of byte read. 0 is an indication of an end of connection.
1271	* -1 indicates a parameter error.
1272	*/
1273	int
1274	xmlNanoHTTPRead(void ctx, void dest, int len) {
1275	xmlNanoHTTPCtxtPtr ctxt = (xmlNanoHTTPCtxtPtr) ctx;
1276	#ifdef LIBXML_ZLIB_ENABLED
1277	int bytes_read = 0;
1278	int orig_avail_in;
1279	int z_ret;
1280	#endif
1281
1282	if (ctx == NULL) return(-1);
1283	if (dest == NULL) return(-1);
1284	if (len <= 0) return(0);
1285
1286	#ifdef LIBXML_ZLIB_ENABLED
1287	if (ctxt->usesGzip == 1) {
1288	if (ctxt->strm == NULL) return(0);
1289
1290	ctxt->strm->next_out = dest;
1291	ctxt->strm->avail_out = len;
1292	ctxt->strm->avail_in = ctxt->inptr - ctxt->inrptr;
1293
1294	while (ctxt->strm->avail_out > 0 &&
1295	(ctxt->strm->avail_in > 0 \|\| xmlNanoHTTPRecv(ctxt) > 0)) {
1296	orig_avail_in = ctxt->strm->avail_in =
1297	ctxt->inptr - ctxt->inrptr - bytes_read;
1298	ctxt->strm->next_in = BAD_CAST (ctxt->inrptr + bytes_read);
1299
1300	z_ret = inflate(ctxt->strm, Z_NO_FLUSH);
1301	bytes_read += orig_avail_in - ctxt->strm->avail_in;
1302
1303	if (z_ret != Z_OK) break;
1304	}
1305
1306	ctxt->inrptr += bytes_read;
1307	return(len - ctxt->strm->avail_out);
1308	}
1309	#endif
1310
1311	while (ctxt->inptr - ctxt->inrptr < len) {
1312	if (xmlNanoHTTPRecv(ctxt) <= 0) break;
1313	}
1314	if (ctxt->inptr - ctxt->inrptr < len)
1315	len = ctxt->inptr - ctxt->inrptr;
1316	memcpy(dest, ctxt->inrptr, len);
1317	ctxt->inrptr += len;
1318	return(len);
1319	}
1320
1321	/**
1322	* xmlNanoHTTPClose:
1323	* @ctx: the HTTP context
1324	*
1325	* This function closes an HTTP context, it ends up the connection and
1326	* free all data related to it.
1327	*/
1328	void
1329	xmlNanoHTTPClose(void *ctx) {
1330	xmlNanoHTTPCtxtPtr ctxt = (xmlNanoHTTPCtxtPtr) ctx;
1331
1332	if (ctx == NULL) return;
1333
1334	xmlNanoHTTPFreeCtxt(ctxt);
1335	}
1336
1337	/**
1338	* xmlNanoHTTPMethodRedir:
1339	* @URL: The URL to load
1340	* @method: the HTTP method to use
1341	* @input: the input string if any
1342	* @contentType: the Content-Type information IN and OUT
1343	* @redir: the redirected URL OUT
1344	* @headers: the extra headers
1345	* @ilen: input length
1346	*
1347	* This function try to open a connection to the indicated resource
1348	* via HTTP using the given @method, adding the given extra headers
1349	* and the input buffer for the request content.
1350	*
1351	* Returns NULL in case of failure, otherwise a request handler.
1352	* The contentType, or redir, if provided must be freed by the caller
1353	*/
1354
1355	void*
1356	xmlNanoHTTPMethodRedir(const char URL, const char method, const char *input,
1357	char contentType, char redir,
1358	const char *headers, int ilen ) {
1359	xmlNanoHTTPCtxtPtr ctxt;
1360	char bp, p;
1361	int blen;
1362	SOCKET ret;
1363	int nbRedirects = 0;
1364	char *redirURL = NULL;
1365	#ifdef DEBUG_HTTP
1366	int xmt_bytes;
1367	#endif
1368
1369	if (URL == NULL) return(NULL);
1370	if (method == NULL) method = "GET";
1371	xmlNanoHTTPInit();
1372
1373	retry:
1374	if (redirURL == NULL) {
1375	ctxt = xmlNanoHTTPNewCtxt(URL);
1376	if (ctxt == NULL)
1377	return(NULL);
1378	} else {
1379	ctxt = xmlNanoHTTPNewCtxt(redirURL);
1380	if (ctxt == NULL)
1381	return(NULL);
1382	ctxt->location = xmlMemStrdup(redirURL);
1383	}
1384
1385	if ((ctxt->protocol == NULL) \|\| (strcmp(ctxt->protocol, "http"))) {
1386	__xmlIOErr(XML_FROM_HTTP, XML_HTTP_URL_SYNTAX, "Not a valid HTTP URI");
1387	xmlNanoHTTPFreeCtxt(ctxt);
1388	if (redirURL != NULL) xmlFree(redirURL);
1389	return(NULL);
1390	}
1391	if (ctxt->hostname == NULL) {
1392	__xmlIOErr(XML_FROM_HTTP, XML_HTTP_UNKNOWN_HOST,
1393	"Failed to identify host in URI");
1394	xmlNanoHTTPFreeCtxt(ctxt);
1395	if (redirURL != NULL) xmlFree(redirURL);
1396	return(NULL);
1397	}
1398	if (proxy) {
1399	blen = strlen(ctxt->hostname) * 2 + 16;
1400	ret = xmlNanoHTTPConnectHost(proxy, proxyPort);
1401	}
1402	else {
1403	blen = strlen(ctxt->hostname);
1404	ret = xmlNanoHTTPConnectHost(ctxt->hostname, ctxt->port);
1405	}
1406	if (ret == INVALID_SOCKET) {
1407	xmlNanoHTTPFreeCtxt(ctxt);
1408	if (redirURL != NULL) xmlFree(redirURL);
1409	return(NULL);
1410	}
1411	ctxt->fd = ret;
1412
1413	if (input == NULL)
1414	ilen = 0;
1415	else
1416	blen += 36;
1417
1418	if (headers != NULL)
1419	blen += strlen(headers) + 2;
1420	if (contentType && *contentType)
1421	/* reserve for string plus 'Content-Type: \r\n" */
1422	blen += strlen(*contentType) + 16;
1423	if (ctxt->query != NULL)
1424	/* 1 for '?' */
1425	blen += strlen(ctxt->query) + 1;
1426	blen += strlen(method) + strlen(ctxt->path) + 24;
1427	#ifdef LIBXML_ZLIB_ENABLED
1428	/* reserve for possible 'Accept-Encoding: gzip' string */
1429	blen += 23;
1430	#endif
1431	if (ctxt->port != 80) {
1432	/* reserve space for ':xxxxx', incl. potential proxy */
1433	if (proxy)
1434	blen += 17;
1435	else
1436	blen += 11;
1437	}
1438	bp = (char*)xmlMallocAtomic(blen);
1439	if ( bp == NULL ) {
1440	xmlNanoHTTPFreeCtxt( ctxt );
1441	xmlHTTPErrMemory("allocating header buffer");
1442	return ( NULL );
1443	}
1444
1445	p = bp;
1446
1447	if (proxy) {
1448	if (ctxt->port != 80) {
1449	p += snprintf( p, blen - (p - bp), "%s http://%s:%d%s",
1450	method, ctxt->hostname,
1451	ctxt->port, ctxt->path );
1452	}
1453	else
1454	p += snprintf( p, blen - (p - bp), "%s http://%s%s", method,
1455	ctxt->hostname, ctxt->path);
1456	}
1457	else
1458	p += snprintf( p, blen - (p - bp), "%s %s", method, ctxt->path);
1459
1460	if (ctxt->query != NULL)
1461	p += snprintf( p, blen - (p - bp), "?%s", ctxt->query);
1462
1463	if (ctxt->port == 80) {
1464	p += snprintf( p, blen - (p - bp), " HTTP/1.0\r\nHost: %s\r\n",
1465	ctxt->hostname);
1466	} else {
1467	p += snprintf( p, blen - (p - bp), " HTTP/1.0\r\nHost: %s:%d\r\n",
1468	ctxt->hostname, ctxt->port);
1469	}
1470
1471	#ifdef LIBXML_ZLIB_ENABLED
1472	p += snprintf(p, blen - (p - bp), "Accept-Encoding: gzip\r\n");
1473	#endif
1474
1475	if (contentType != NULL && *contentType)
1476	p += snprintf(p, blen - (p - bp), "Content-Type: %s\r\n", *contentType);
1477
1478	if (headers != NULL)
1479	p += snprintf( p, blen - (p - bp), "%s", headers );
1480
1481	if (input != NULL)
1482	snprintf(p, blen - (p - bp), "Content-Length: %d\r\n\r\n", ilen );
1483	else
1484	snprintf(p, blen - (p - bp), "\r\n");
1485
1486	#ifdef DEBUG_HTTP
1487	xmlGenericError(xmlGenericErrorContext,
1488	"-> %s%s", proxy? "(Proxy) " : "", bp);
1489	if ((blen -= strlen(bp)+1) < 0)
1490	xmlGenericError(xmlGenericErrorContext,
1491	"ERROR: overflowed buffer by %d bytes\n", -blen);
1492	#endif
1493	ctxt->outptr = ctxt->out = bp;
1494	ctxt->state = XML_NANO_HTTP_WRITE;
1495	blen = strlen( ctxt->out );
1496	#ifdef DEBUG_HTTP
1497	xmt_bytes = xmlNanoHTTPSend(ctxt, ctxt->out, blen );
1498	if ( xmt_bytes != blen )
1499	xmlGenericError( xmlGenericErrorContext,
1500	"xmlNanoHTTPMethodRedir: Only %d of %d %s %s\n",
1501	xmt_bytes, blen,
1502	"bytes of HTTP headers sent to host",
1503	ctxt->hostname );
1504	#else
1505	xmlNanoHTTPSend(ctxt, ctxt->out, blen );
1506	#endif
1507
1508	if ( input != NULL ) {
1509	#ifdef DEBUG_HTTP
1510	xmt_bytes = xmlNanoHTTPSend( ctxt, input, ilen );
1511
1512	if ( xmt_bytes != ilen )
1513	xmlGenericError( xmlGenericErrorContext,
1514	"xmlNanoHTTPMethodRedir: Only %d of %d %s %s\n",
1515	xmt_bytes, ilen,
1516	"bytes of HTTP content sent to host",
1517	ctxt->hostname );
1518	#else
1519	xmlNanoHTTPSend( ctxt, input, ilen );
1520	#endif
1521	}
1522
1523	ctxt->state = XML_NANO_HTTP_READ;
1524
1525	while ((p = xmlNanoHTTPReadLine(ctxt)) != NULL) {
1526	if (*p == 0) {
1527	ctxt->content = ctxt->inrptr;
1528	xmlFree(p);
1529	break;
1530	}
1531	xmlNanoHTTPScanAnswer(ctxt, p);
1532
1533	#ifdef DEBUG_HTTP
1534	xmlGenericError(xmlGenericErrorContext, "<- %s\n", p);
1535	#endif
1536	xmlFree(p);
1537	}
1538
1539	if ((ctxt->location != NULL) && (ctxt->returnValue >= 300) &&
1540	(ctxt->returnValue < 400)) {
1541	#ifdef DEBUG_HTTP
1542	xmlGenericError(xmlGenericErrorContext,
1543	"\nRedirect to: %s\n", ctxt->location);
1544	#endif
1545	while ( xmlNanoHTTPRecv(ctxt) > 0 )
1546	;
1547	if (nbRedirects < XML_NANO_HTTP_MAX_REDIR) {
1548	nbRedirects++;
1549	if (redirURL != NULL)
1550	xmlFree(redirURL);
1551	redirURL = xmlMemStrdup(ctxt->location);
1552	xmlNanoHTTPFreeCtxt(ctxt);
1553	goto retry;
1554	}
1555	xmlNanoHTTPFreeCtxt(ctxt);
1556	if (redirURL != NULL) xmlFree(redirURL);
1557	#ifdef DEBUG_HTTP
1558	xmlGenericError(xmlGenericErrorContext,
1559	"xmlNanoHTTPMethodRedir: Too many redirects, aborting ...\n");
1560	#endif
1561	return(NULL);
1562	}
1563
1564	if (contentType != NULL) {
1565	if (ctxt->contentType != NULL)
1566	*contentType = xmlMemStrdup(ctxt->contentType);
1567	else
1568	*contentType = NULL;
1569	}
1570
1571	if ((redir != NULL) && (redirURL != NULL)) {
1572	*redir = redirURL;
1573	} else {
1574	if (redirURL != NULL)
1575	xmlFree(redirURL);
1576	if (redir != NULL)
1577	*redir = NULL;
1578	}
1579
1580	#ifdef DEBUG_HTTP
1581	if (ctxt->contentType != NULL)
1582	xmlGenericError(xmlGenericErrorContext,
1583	"\nCode %d, content-type '%s'\n\n",
1584	ctxt->returnValue, ctxt->contentType);
1585	else
1586	xmlGenericError(xmlGenericErrorContext,
1587	"\nCode %d, no content-type\n\n",
1588	ctxt->returnValue);
1589	#endif
1590
1591	return((void *) ctxt);
1592	}
1593
1594	/**
1595	* xmlNanoHTTPMethod:
1596	* @URL: The URL to load
1597	* @method: the HTTP method to use
1598	* @input: the input string if any
1599	* @contentType: the Content-Type information IN and OUT
1600	* @headers: the extra headers
1601	* @ilen: input length
1602	*
1603	* This function try to open a connection to the indicated resource
1604	* via HTTP using the given @method, adding the given extra headers
1605	* and the input buffer for the request content.
1606	*
1607	* Returns NULL in case of failure, otherwise a request handler.
1608	* The contentType, if provided must be freed by the caller
1609	*/
1610
1611	void*
1612	xmlNanoHTTPMethod(const char URL, const char method, const char *input,
1613	char *contentType, const char headers, int ilen) {
1614	return(xmlNanoHTTPMethodRedir(URL, method, input, contentType,
1615	NULL, headers, ilen));
1616	}
1617
1618	/**
1619	* xmlNanoHTTPFetch:
1620	* @URL: The URL to load
1621	* @filename: the filename where the content should be saved
1622	* @contentType: if available the Content-Type information will be
1623	* returned at that location
1624	*
1625	* This function try to fetch the indicated resource via HTTP GET
1626	* and save it's content in the file.
1627	*
1628	* Returns -1 in case of failure, 0 in case of success. The contentType,
1629	* if provided must be freed by the caller
1630	*/
1631	int
1632	xmlNanoHTTPFetch(const char URL, const char filename, char **contentType) {
1633	void *ctxt = NULL;
1634	char *buf = NULL;
1635	int fd;
1636	int len;
1637	int ret = 0;
1638
1639	if (filename == NULL) return(-1);
1640	ctxt = xmlNanoHTTPOpen(URL, contentType);
1641	if (ctxt == NULL) return(-1);
1642
1643	if (!strcmp(filename, "-"))
1644	fd = 0;
1645	else {
1646	fd = open(filename, O_CREAT \| O_WRONLY, 00644);
1647	if (fd < 0) {
1648	xmlNanoHTTPClose(ctxt);
1649	if ((contentType != NULL) && (*contentType != NULL)) {
1650	xmlFree(*contentType);
1651	*contentType = NULL;
1652	}
1653	return(-1);
1654	}
1655	}
1656
1657	xmlNanoHTTPFetchContent( ctxt, &buf, &len );
1658	if ( len > 0 ) {
1659	if (write(fd, buf, len) == -1) {
1660	ret = -1;
1661	}
1662	}
1663
1664	xmlNanoHTTPClose(ctxt);
1665	close(fd);
1666	return(ret);
1667	}
1668
1669	#ifdef LIBXML_OUTPUT_ENABLED
1670	/**
1671	* xmlNanoHTTPSave:
1672	* @ctxt: the HTTP context
1673	* @filename: the filename where the content should be saved
1674	*
1675	* This function saves the output of the HTTP transaction to a file
1676	* It closes and free the context at the end
1677	*
1678	* Returns -1 in case of failure, 0 in case of success.
1679	*/
1680	int
1681	xmlNanoHTTPSave(void ctxt, const char filename) {
1682	char *buf = NULL;
1683	int fd;
1684	int len;
1685	int ret = 0;
1686
1687	if ((ctxt == NULL) \|\| (filename == NULL)) return(-1);
1688
1689	if (!strcmp(filename, "-"))
1690	fd = 0;
1691	else {
1692	fd = open(filename, O_CREAT \| O_WRONLY, 0666);
1693	if (fd < 0) {
1694	xmlNanoHTTPClose(ctxt);
1695	return(-1);
1696	}
1697	}
1698
1699	xmlNanoHTTPFetchContent( ctxt, &buf, &len );
1700	if ( len > 0 ) {
1701	if (write(fd, buf, len) == -1) {
1702	ret = -1;
1703	}
1704	}
1705
1706	xmlNanoHTTPClose(ctxt);
1707	close(fd);
1708	return(ret);
1709	}
1710	#endif /* LIBXML_OUTPUT_ENABLED */
1711
1712	/**
1713	* xmlNanoHTTPReturnCode:
1714	* @ctx: the HTTP context
1715	*
1716	* Get the latest HTTP return code received
1717	*
1718	* Returns the HTTP return code for the request.
1719	*/
1720	int
1721	xmlNanoHTTPReturnCode(void *ctx) {
1722	xmlNanoHTTPCtxtPtr ctxt = (xmlNanoHTTPCtxtPtr) ctx;
1723
1724	if (ctxt == NULL) return(-1);
1725
1726	return(ctxt->returnValue);
1727	}
1728
1729	/**
1730	* xmlNanoHTTPAuthHeader:
1731	* @ctx: the HTTP context
1732	*
1733	* Get the authentication header of an HTTP context
1734	*
1735	* Returns the stashed value of the WWW-Authenticate or Proxy-Authenticate
1736	* header.
1737	*/
1738	const char *
1739	xmlNanoHTTPAuthHeader(void *ctx) {
1740	xmlNanoHTTPCtxtPtr ctxt = (xmlNanoHTTPCtxtPtr) ctx;
1741
1742	if (ctxt == NULL) return(NULL);
1743
1744	return(ctxt->authHeader);
1745	}
1746
1747	/**
1748	* xmlNanoHTTPContentLength:
1749	* @ctx: the HTTP context
1750	*
1751	* Provides the specified content length from the HTTP header.
1752	*
1753	* Return the specified content length from the HTTP header. Note that
1754	* a value of -1 indicates that the content length element was not included in
1755	* the response header.
1756	*/
1757	int
1758	xmlNanoHTTPContentLength( void * ctx ) {
1759	xmlNanoHTTPCtxtPtr ctxt = (xmlNanoHTTPCtxtPtr)ctx;
1760
1761	return ( ( ctxt == NULL ) ? -1 : ctxt->ContentLength );
1762	}
1763
1764	/**
1765	* xmlNanoHTTPRedir:
1766	* @ctx: the HTTP context
1767	*
1768	* Provides the specified redirection URL if available from the HTTP header.
1769	*
1770	* Return the specified redirection URL or NULL if not redirected.
1771	*/
1772	const char *
1773	xmlNanoHTTPRedir( void * ctx ) {
1774	xmlNanoHTTPCtxtPtr ctxt = (xmlNanoHTTPCtxtPtr)ctx;
1775
1776	return ( ( ctxt == NULL ) ? NULL : ctxt->location );
1777	}
1778
1779	/**
1780	* xmlNanoHTTPEncoding:
1781	* @ctx: the HTTP context
1782	*
1783	* Provides the specified encoding if specified in the HTTP headers.
1784	*
1785	* Return the specified encoding or NULL if not available
1786	*/
1787	const char *
1788	xmlNanoHTTPEncoding( void * ctx ) {
1789	xmlNanoHTTPCtxtPtr ctxt = (xmlNanoHTTPCtxtPtr)ctx;
1790
1791	return ( ( ctxt == NULL ) ? NULL : ctxt->encoding );
1792	}
1793
1794	/**
1795	* xmlNanoHTTPMimeType:
1796	* @ctx: the HTTP context
1797	*
1798	* Provides the specified Mime-Type if specified in the HTTP headers.
1799	*
1800	* Return the specified Mime-Type or NULL if not available
1801	*/
1802	const char *
1803	xmlNanoHTTPMimeType( void * ctx ) {
1804	xmlNanoHTTPCtxtPtr ctxt = (xmlNanoHTTPCtxtPtr)ctx;
1805
1806	return ( ( ctxt == NULL ) ? NULL : ctxt->mimeType );
1807	}
1808
1809	/**
1810	* xmlNanoHTTPFetchContent:
1811	* @ctx: the HTTP context
1812	* @ptr: pointer to set to the content buffer.
1813	* @len: integer pointer to hold the length of the content
1814	*
1815	* Check if all the content was read
1816	*
1817	* Returns 0 if all the content was read and available, returns
1818	* -1 if received content length was less than specified or an error
1819	* occurred.
1820	*/
1821	static int
1822	xmlNanoHTTPFetchContent( void * ctx, char ** ptr, int * len ) {
1823	xmlNanoHTTPCtxtPtr ctxt = (xmlNanoHTTPCtxtPtr)ctx;
1824
1825	int rc = 0;
1826	int cur_lgth;
1827	int rcvd_lgth;
1828	int dummy_int;
1829	char * dummy_ptr = NULL;
1830
1831	/* Dummy up return input parameters if not provided */
1832
1833	if ( len == NULL )
1834	len = &dummy_int;
1835
1836	if ( ptr == NULL )
1837	ptr = &dummy_ptr;
1838
1839	/* But can't work without the context pointer */
1840
1841	if ( ( ctxt == NULL ) \|\| ( ctxt->content == NULL ) ) {
1842	*len = 0;
1843	*ptr = NULL;
1844	return ( -1 );
1845	}
1846
1847	rcvd_lgth = ctxt->inptr - ctxt->content;
1848
1849	while ( (cur_lgth = xmlNanoHTTPRecv( ctxt )) > 0 ) {
1850
1851	rcvd_lgth += cur_lgth;
1852	if ( (ctxt->ContentLength > 0) && (rcvd_lgth >= ctxt->ContentLength) )
1853	break;
1854	}
1855
1856	*ptr = ctxt->content;
1857	*len = rcvd_lgth;
1858
1859	if ( ( ctxt->ContentLength > 0 ) && ( rcvd_lgth < ctxt->ContentLength ) )
1860	rc = -1;
1861	else if ( rcvd_lgth == 0 )
1862	rc = -1;
1863
1864	return ( rc );
1865	}
1866
1867	#ifdef STANDALONE
1868	int main(int argc, char **argv) {
1869	char *contentType = NULL;
1870
1871	if (argv[1] != NULL) {
1872	if (argv[2] != NULL)
1873	xmlNanoHTTPFetch(argv[1], argv[2], &contentType);
1874	else
1875	xmlNanoHTTPFetch(argv[1], "-", &contentType);
1876	if (contentType != NULL) xmlFree(contentType);
1877	} else {
1878	xmlGenericError(xmlGenericErrorContext,
1879	"%s: minimal HTTP GET implementation\n", argv[0]);
1880	xmlGenericError(xmlGenericErrorContext,
1881	"\tusage %s [ URL [ filename ] ]\n", argv[0]);
1882	}
1883	xmlNanoHTTPCleanup();
1884	xmlMemoryDump();
1885	return(0);
1886	}
1887	#endif /* STANDALONE */
1888	#else /* !LIBXML_HTTP_ENABLED */
1889	#ifdef STANDALONE
1890	#include <stdio.h>
1891	int main(int argc, char **argv) {
1892	xmlGenericError(xmlGenericErrorContext,
1893	"%s : HTTP support not compiled in\n", argv[0]);
1894	return(0);
1895	}
1896	#endif /* STANDALONE */
1897	#endif /* LIBXML_HTTP_ENABLED */
1898	#define bottom_nanohttp
1899	#include "elfgcchack.h"

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

source: vbox/trunk/src/libs/libxml2-2.9.14/nanohttp.c@ 102948

Download in other formats: