/*

 * nanohttp.c: minimalist HTTP GET implementation to fetch external subsets.

 *             focuses on size, streamability, reentrancy and portability

 *

 * This is clearly not a general purpose HTTP implementation

 * If you look for one, check:

 *         http://www.w3.org/Library/

 *

 * See Copyright for the status of this software.

 *

 * daniel@veillard.com

 */

#define IN_LIBXML

#include "libxml.h"

#ifdef LIBXML_HTTP_ENABLED

#include <string.h>

#ifdef HAVE_STDLIB_H

#include <stdlib.h>

#endif

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#ifdef HAVE_SYS_TYPES_H

#include <sys/types.h>

#endif

#ifdef HAVE_SYS_SOCKET_H

#include <sys/socket.h>

#endif

#ifdef HAVE_NETINET_IN_H

#include <netinet/in.h>

#endif

#ifdef HAVE_ARPA_INET_H

#include <arpa/inet.h>

#endif

#ifdef HAVE_NETDB_H

#include <netdb.h>

#endif

#ifdef HAVE_RESOLV_H

#ifdef HAVE_ARPA_NAMESER_H

#include <arpa/nameser.h>

#endif

#include <resolv.h>

#endif

#ifdef HAVE_FCNTL_H

#include <fcntl.h>

#endif

#ifdef HAVE_ERRNO_H

#include <errno.h>

#endif

#ifdef HAVE_SYS_TIME_H

#include <sys/time.h>

#endif

#ifndef HAVE_POLL_H

#ifdef HAVE_SYS_SELECT_H

#include <sys/select.h>

#endif

#else

#include <poll.h>

#endif

#ifdef HAVE_STRINGS_H

#include <strings.h>

#endif

#ifdef HAVE_ZLIB_H

#include <zlib.h>

#endif

#ifdef VMS

#include <stropts>

#define XML_SOCKLEN_T unsigned int

#endif

#if defined(_WIN32) && !defined(__CYGWIN__)

#include <wsockcompat.h>

#endif

#include <libxml/globals.h>

#include <libxml/xmlerror.h>

#include <libxml/xmlmemory.h>

#include <libxml/parser.h> /* for xmlStr(n)casecmp() */

#include <libxml/nanohttp.h>

#include <libxml/globals.h>

#include <libxml/uri.h>

/**

 * A couple portability macros

 */

#ifndef _WINSOCKAPI_

#if !defined(__BEOS__) || defined(__HAIKU__)

#define closesocket(s) close(s)

#endif

#define SOCKET int

#define INVALID_SOCKET (-1)

#endif

#ifdef __BEOS__

#ifndef PF_INET

#define PF_INET AF_INET

#endif

#endif

#ifndef XML_SOCKLEN_T

#define XML_SOCKLEN_T unsigned int

#endif

#ifdef STANDALONE

#define DEBUG_HTTP

#define xmlStrncasecmp(a, b, n) strncasecmp((char *)a, (char *)b, n)

#define xmlStrcasecmpi(a, b) strcasecmp((char *)a, (char *)b)

#endif

#define XML_NANO_HTTP_MAX_REDIR	10

#define XML_NANO_HTTP_CHUNK	4096

#define XML_NANO_HTTP_CLOSED	0

#define XML_NANO_HTTP_WRITE	1

#define XML_NANO_HTTP_READ	2

#define XML_NANO_HTTP_NONE	4

typedef struct xmlNanoHTTPCtxt {

    char *protocol;	/* the protocol name */

    char *hostname;	/* the host name */

    int port;		/* the port */

    char *path;		/* the path within the URL */

    char *query;	/* the query string */

    SOCKET fd;		/* the file descriptor for the socket */

    int state;		/* WRITE / READ / CLOSED */

    char *out;		/* buffer sent (zero terminated) */

    char *outptr;	/* index within the buffer sent */

    char *in;		/* the receiving buffer */

    char *content;	/* the start of the content */

    char *inptr;	/* the next byte to read from network */

    char *inrptr;	/* the next byte to give back to the client */

    int inlen;		/* len of the input buffer */

    int last;		/* return code for last operation */

    int returnValue;	/* the protocol return value */

    int version;        /* the protocol version */

    int ContentLength;  /* specified content length from HTTP header */

    char *contentType;	/* the MIME type for the input */

    char *location;	/* the new URL in case of redirect */

    char *authHeader;	/* contents of {WWW,Proxy}-Authenticate header */

    char *encoding;	/* encoding extracted from the contentType */

    char *mimeType;	/* Mime-Type extracted from the contentType */

#ifdef HAVE_ZLIB_H

    z_stream *strm;	/* Zlib stream object */

    int usesGzip;	/* "Content-Encoding: gzip" was detected */

#endif

} xmlNanoHTTPCtxt, *xmlNanoHTTPCtxtPtr;

static int initialized = 0;

static char *proxy = NULL;	 /* the proxy name if any */

static int proxyPort;	/* the proxy port if any */

static unsigned int timeout = 60;/* the select() timeout in seconds */

static int xmlNanoHTTPFetchContent( void * ctx, char ** ptr, int * len );

/**

 * xmlHTTPErrMemory:

 * @extra:  extra informations

 *

 * Handle an out of memory condition

 */

static void

xmlHTTPErrMemory(const char *extra)

{

    __xmlSimpleError(XML_FROM_HTTP, XML_ERR_NO_MEMORY, NULL, NULL, extra);

}

/**

 * A portability function

 */

static int socket_errno(void) {

#ifdef _WINSOCKAPI_

    int err = WSAGetLastError();

    switch(err) {

        case WSAECONNRESET:

            return(ECONNRESET);

        case WSAEINPROGRESS:

            return(EINPROGRESS);

        case WSAEINTR:

            return(EINTR);

        case WSAESHUTDOWN:

            return(ESHUTDOWN);

        case WSAEWOULDBLOCK:

            return(EWOULDBLOCK);

        default:

            return(err);

    }

#else

    return(errno);

#endif

}

#ifdef SUPPORT_IP6

static

int have_ipv6(void) {

    SOCKET s;

    s = socket (AF_INET6, SOCK_STREAM, 0);

    if (s != INVALID_SOCKET) {

	close (s);

	return (1);

    }

    return (0);

}

#endif

/**

 * xmlNanoHTTPInit:

 *

 * Initialize the HTTP protocol layer.

 * Currently it just checks for proxy informations

 */

void

xmlNanoHTTPInit(void) {

    const char *env;

#ifdef _WINSOCKAPI_

    WSADATA wsaData;

#endif

    if (initialized)

	return;

#ifdef _WINSOCKAPI_

    if (WSAStartup(MAKEWORD(1, 1), &wsaData) != 0)

	return;

#endif

    if (proxy == NULL) {

	proxyPort = 80;

	env = getenv("no_proxy");

	if (env && ((env[0] == '*') && (env[1] == 0)))

	    goto done;

	env = getenv("http_proxy");

	if (env != NULL) {

	    xmlNanoHTTPScanProxy(env);

	    goto done;

	}

	env = getenv("HTTP_PROXY");

	if (env != NULL) {

	    xmlNanoHTTPScanProxy(env);

	    goto done;

	}

    }

done:

    initialized = 1;

}

/**

 * xmlNanoHTTPCleanup:

 *

 * Cleanup the HTTP protocol layer.

 */

void

xmlNanoHTTPCleanup(void) {

    if (proxy != NULL) {

	xmlFree(proxy);

	proxy = NULL;

    }

#ifdef _WINSOCKAPI_

    if (initialized)

	WSACleanup();

#endif

    initialized = 0;

    return;

}

/**

 * xmlNanoHTTPScanURL:

 * @ctxt:  an HTTP context

 * @URL:  The URL used to initialize the context

 *

 * (Re)Initialize an HTTP context by parsing the URL and finding

 * the protocol host port and path it indicates.

 */

static void

xmlNanoHTTPScanURL(xmlNanoHTTPCtxtPtr ctxt, const char *URL) {

    xmlURIPtr uri;

    int len;

    /*

     * Clear any existing data from the context

     */

    if (ctxt->protocol != NULL) {

        xmlFree(ctxt->protocol);

	ctxt->protocol = NULL;

    }

    if (ctxt->hostname != NULL) {

        xmlFree(ctxt->hostname);

	ctxt->hostname = NULL;

    }

    if (ctxt->path != NULL) {

        xmlFree(ctxt->path);

	ctxt->path = NULL;

    }

    if (ctxt->query != NULL) {

        xmlFree(ctxt->query);

	ctxt->query = NULL;

    }

    if (URL == NULL) return;

    uri = xmlParseURIRaw(URL, 1);

    if (uri == NULL)

	return;

    if ((uri->scheme == NULL) || (uri->server == NULL)) {

	xmlFreeURI(uri);

	return;

    }

    ctxt->protocol = xmlMemStrdup(uri->scheme);

    /* special case of IPv6 addresses, the [] need to be removed */

    if ((uri->server != NULL) && (*uri->server == '[')) {

        len = strlen(uri->server);

	if ((len > 2) && (uri->server[len - 1] == ']')) {

	    ctxt->hostname = (char *) xmlCharStrndup(uri->server + 1, len -2);

	} else

	    ctxt->hostname = xmlMemStrdup(uri->server);

    } else

	ctxt->hostname = xmlMemStrdup(uri->server);

    if (uri->path != NULL)

	ctxt->path = xmlMemStrdup(uri->path);

    else

	ctxt->path = xmlMemStrdup("/");

    if (uri->query != NULL)

	ctxt->query = xmlMemStrdup(uri->query);

    if (uri->port != 0)

	ctxt->port = uri->port;

    xmlFreeURI(uri);

}

/**

 * xmlNanoHTTPScanProxy:

 * @URL:  The proxy URL used to initialize the proxy context

 *

 * (Re)Initialize the HTTP Proxy context by parsing the URL and finding

 * the protocol host port it indicates.

 * Should be like http://myproxy/ or http://myproxy:3128/

 * A NULL URL cleans up proxy informations.

 */

void

xmlNanoHTTPScanProxy(const char *URL) {

    xmlURIPtr uri;

    if (proxy != NULL) {

        xmlFree(proxy);

	proxy = NULL;

    }

    proxyPort = 0;

#ifdef DEBUG_HTTP

    if (URL == NULL)

	xmlGenericError(xmlGenericErrorContext,

		"Removing HTTP proxy info\n");

    else

	xmlGenericError(xmlGenericErrorContext,

		"Using HTTP proxy %s\n", URL);

#endif

    if (URL == NULL) return;

    uri = xmlParseURIRaw(URL, 1);

    if ((uri == NULL) || (uri->scheme == NULL) ||

	(strcmp(uri->scheme, "http")) || (uri->server == NULL)) {

	__xmlIOErr(XML_FROM_HTTP, XML_HTTP_URL_SYNTAX, "Syntax Error\n");

	if (uri != NULL)

	    xmlFreeURI(uri);

	return;

    }

    proxy = xmlMemStrdup(uri->server);

    if (uri->port != 0)

	proxyPort = uri->port;

    xmlFreeURI(uri);

}

/**

 * xmlNanoHTTPNewCtxt:

 * @URL:  The URL used to initialize the context

 *

 * Allocate and initialize a new HTTP context.

 *

 * Returns an HTTP context or NULL in case of error.

 */

static xmlNanoHTTPCtxtPtr

xmlNanoHTTPNewCtxt(const char *URL) {

    xmlNanoHTTPCtxtPtr ret;

    ret = (xmlNanoHTTPCtxtPtr) xmlMalloc(sizeof(xmlNanoHTTPCtxt));

    if (ret == NULL) {

        xmlHTTPErrMemory("allocating context");

        return(NULL);

    }

    memset(ret, 0, sizeof(xmlNanoHTTPCtxt));

    ret->port = 80;

    ret->returnValue = 0;

    ret->fd = INVALID_SOCKET;

    ret->ContentLength = -1;

    xmlNanoHTTPScanURL(ret, URL);

    return(ret);

}

/**

 * xmlNanoHTTPFreeCtxt:

 * @ctxt:  an HTTP context

 *

 * Frees the context after closing the connection.

 */

static void

xmlNanoHTTPFreeCtxt(xmlNanoHTTPCtxtPtr ctxt) {

    if (ctxt == NULL) return;

    if (ctxt->hostname != NULL) xmlFree(ctxt->hostname);

    if (ctxt->protocol != NULL) xmlFree(ctxt->protocol);

    if (ctxt->path != NULL) xmlFree(ctxt->path);

    if (ctxt->query != NULL) xmlFree(ctxt->query);

    if (ctxt->out != NULL) xmlFree(ctxt->out);

    if (ctxt->in != NULL) xmlFree(ctxt->in);

    if (ctxt->contentType != NULL) xmlFree(ctxt->contentType);

    if (ctxt->encoding != NULL) xmlFree(ctxt->encoding);

    if (ctxt->mimeType != NULL) xmlFree(ctxt->mimeType);

    if (ctxt->location != NULL) xmlFree(ctxt->location);

    if (ctxt->authHeader != NULL) xmlFree(ctxt->authHeader);

#ifdef HAVE_ZLIB_H

    if (ctxt->strm != NULL) {

	inflateEnd(ctxt->strm);

	xmlFree(ctxt->strm);

    }

#endif

    ctxt->state = XML_NANO_HTTP_NONE;

    if (ctxt->fd != INVALID_SOCKET) closesocket(ctxt->fd);

    ctxt->fd = INVALID_SOCKET;

    xmlFree(ctxt);

}

/**

 * xmlNanoHTTPSend:

 * @ctxt:  an HTTP context

 *

 * Send the input needed to initiate the processing on the server side

 * Returns number of bytes sent or -1 on error.

 */

static int

xmlNanoHTTPSend(xmlNanoHTTPCtxtPtr ctxt, const char *xmt_ptr, int outlen)

{

    int total_sent = 0;

#ifdef HAVE_POLL_H

    struct pollfd p;

#else

    struct timeval tv;

    fd_set wfd;

#endif

    if ((ctxt->state & XML_NANO_HTTP_WRITE) && (xmt_ptr != NULL)) {

        while (total_sent < outlen) {

            int nsent = send(ctxt->fd, SEND_ARG2_CAST (xmt_ptr + total_sent),

                             outlen - total_sent, 0);

            if (nsent > 0)

                total_sent += nsent;

            else if ((nsent == -1) &&

#if defined(EAGAIN) && EAGAIN != EWOULDBLOCK

                     (socket_errno() != EAGAIN) &&

#endif

                     (socket_errno() != EWOULDBLOCK)) {

                __xmlIOErr(XML_FROM_HTTP, 0, "send failed\n");

                if (total_sent == 0)

                    total_sent = -1;

                break;

            } else {

                /*

                 * No data sent

                 * Since non-blocking sockets are used, wait for

                 * socket to be writable or default timeout prior

                 * to retrying.

                 */

#ifndef HAVE_POLL_H

#ifndef _WINSOCKAPI_

                if (ctxt->fd > FD_SETSIZE)

                    return -1;

#endif

                tv.tv_sec = timeout;

                tv.tv_usec = 0;

                FD_ZERO(&wfd;;

#ifdef _MSC_VER

#pragma warning(push)

#pragma warning(disable: 4018)

#endif

                FD_SET(ctxt->fd, &wfd;;

#ifdef _MSC_VER

#pragma warning(pop)

#endif

                (void) select(ctxt->fd + 1, NULL, &wfd, NULL, &tv;;

#else

                p.fd = ctxt->fd;

                p.events = POLLOUT;

                (void) poll(&p, 1, timeout * 1000);

#endif /* !HAVE_POLL_H */

            }

        }

    }

    return total_sent;

}

/**

 * xmlNanoHTTPRecv:

 * @ctxt:  an HTTP context

 *

 * Read information coming from the HTTP connection.

 * This is a blocking call (but it blocks in select(), not read()).

 *

 * Returns the number of byte read or -1 in case of error.

 */

static int

xmlNanoHTTPRecv(xmlNanoHTTPCtxtPtr ctxt)

{

#ifdef HAVE_POLL_H

    struct pollfd p;

#else

    fd_set rfd;

    struct timeval tv;

#endif

    while (ctxt->state & XML_NANO_HTTP_READ) {

        if (ctxt->in == NULL) {

            ctxt->in = (char *) xmlMallocAtomic(65000 * sizeof(char));

            if (ctxt->in == NULL) {

                xmlHTTPErrMemory("allocating input");

                ctxt->last = -1;

                return (-1);

            }

            ctxt->inlen = 65000;

            ctxt->inptr = ctxt->content = ctxt->inrptr = ctxt->in;

        }

        if (ctxt->inrptr > ctxt->in + XML_NANO_HTTP_CHUNK) {

            int delta = ctxt->inrptr - ctxt->in;

            int len = ctxt->inptr - ctxt->inrptr;

            memmove(ctxt->in, ctxt->inrptr, len);

            ctxt->inrptr -= delta;

            ctxt->content -= delta;

            ctxt->inptr -= delta;

        }

        if ((ctxt->in + ctxt->inlen) < (ctxt->inptr + XML_NANO_HTTP_CHUNK)) {

            int d_inptr = ctxt->inptr - ctxt->in;

            int d_content = ctxt->content - ctxt->in;

            int d_inrptr = ctxt->inrptr - ctxt->in;

            char *tmp_ptr = ctxt->in;

            ctxt->inlen *= 2;

            ctxt->in = (char *) xmlRealloc(tmp_ptr, ctxt->inlen);

            if (ctxt->in == NULL) {

                xmlHTTPErrMemory("allocating input buffer");

                xmlFree(tmp_ptr);

                ctxt->last = -1;

                return (-1);

            }

            ctxt->inptr = ctxt->in + d_inptr;

            ctxt->content = ctxt->in + d_content;

            ctxt->inrptr = ctxt->in + d_inrptr;

        }

        ctxt->last = recv(ctxt->fd, ctxt->inptr, XML_NANO_HTTP_CHUNK, 0);

        if (ctxt->last > 0) {

            ctxt->inptr += ctxt->last;

            return (ctxt->last);

        }

        if (ctxt->last == 0) {

            return (0);

        }

        if (ctxt->last == -1) {

            switch (socket_errno()) {

                case EINPROGRESS:

                case EWOULDBLOCK:

#if defined(EAGAIN) && EAGAIN != EWOULDBLOCK

                case EAGAIN:

#endif

                    break;

                case ECONNRESET:

                case ESHUTDOWN:

                    return (0);

                default:

                    __xmlIOErr(XML_FROM_HTTP, 0, "recv failed\n");

                    return (-1);

            }

        }

#ifdef HAVE_POLL_H

        p.fd = ctxt->fd;

        p.events = POLLIN;

        if ((poll(&p, 1, timeout * 1000) < 1)

#if defined(EINTR)

            && (errno != EINTR)

#endif

            )

            return (0);

#else /* !HAVE_POLL_H */

#ifndef _WINSOCKAPI_

        if (ctxt->fd > FD_SETSIZE)

            return 0;

#endif

        tv.tv_sec = timeout;

        tv.tv_usec = 0;

        FD_ZERO(&rfd;;

#ifdef _MSC_VER

#pragma warning(push)

#pragma warning(disable: 4018)

#endif

        FD_SET(ctxt->fd, &rfd;;

#ifdef _MSC_VER

#pragma warning(pop)

#endif

        if ((select(ctxt->fd + 1, &rfd, NULL, NULL, &tv) < 1)

#if defined(EINTR)

            && (socket_errno() != EINTR)

#endif

            )

            return (0);

#endif /* !HAVE_POLL_H */

    }

    return (0);

}

/**

 * xmlNanoHTTPReadLine:

 * @ctxt:  an HTTP context

 *

 * Read one line in the HTTP server output, usually for extracting

 * the HTTP protocol informations from the answer header.

 *

 * Returns a newly allocated string with a copy of the line, or NULL

 *         which indicate the end of the input.

 */

static char *

xmlNanoHTTPReadLine(xmlNanoHTTPCtxtPtr ctxt) {

    char buf[4096];

    char *bp = buf;

    int	rc;

    while (bp - buf < 4095) {

	if (ctxt->inrptr == ctxt->inptr) {

	    if ( (rc = xmlNanoHTTPRecv(ctxt)) == 0) {

		if (bp == buf)

		    return(NULL);

		else

		    *bp = 0;

		return(xmlMemStrdup(buf));

	    }

	    else if ( rc == -1 ) {

	        return ( NULL );

	    }

	}

	*bp = *ctxt->inrptr++;

	if (*bp == '\n') {

	    *bp = 0;

	    return(xmlMemStrdup(buf));

	}

	if (*bp != '\r')

	    bp++;

    }

    buf[4095] = 0;

    return(xmlMemStrdup(buf));

}

/**

 * xmlNanoHTTPScanAnswer:

 * @ctxt:  an HTTP context

 * @line:  an HTTP header line

 *

 * Try to extract useful informations from the server answer.

 * We currently parse and process:

 *  - The HTTP revision/ return code

 *  - The Content-Type, Mime-Type and charset used

 *  - The Location for redirect processing.

 *

 * Returns -1 in case of failure, the file descriptor number otherwise

 */

static void

xmlNanoHTTPScanAnswer(xmlNanoHTTPCtxtPtr ctxt, const char *line) {

    const char *cur = line;

    if (line == NULL) return;

    if (!strncmp(line, "HTTP/", 5)) {

        int version = 0;

	int ret = 0;

	cur += 5;

	while ((*cur >= '0') && (*cur <= '9')) {

	    version *= 10;

	    version += *cur - '0';

	    cur++;

	}

	if (*cur == '.') {

	    cur++;

	    if ((*cur >= '0') && (*cur <= '9')) {

		version *= 10;

		version += *cur - '0';

		cur++;

	    }

	    while ((*cur >= '0') && (*cur <= '9'))

		cur++;

	} else

	    version *= 10;

	if ((*cur != ' ') && (*cur != '\t')) return;

	while ((*cur == ' ') || (*cur == '\t')) cur++;

	if ((*cur < '0') || (*cur > '9')) return;

	while ((*cur >= '0') && (*cur <= '9')) {

	    ret *= 10;

	    ret += *cur - '0';

	    cur++;

	}

	if ((*cur != 0) && (*cur != ' ') && (*cur != '\t')) return;

	ctxt->returnValue = ret;

        ctxt->version = version;

    } else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"Content-Type:", 13)) {

        const xmlChar *charset, *last, *mime;

        cur += 13;

	while ((*cur == ' ') || (*cur == '\t')) cur++;

	if (ctxt->contentType != NULL)

	    xmlFree(ctxt->contentType);

	ctxt->contentType = xmlMemStrdup(cur);

	mime = (const xmlChar *) cur;

	last = mime;

	while ((*last != 0) && (*last != ' ') && (*last != '\t') &&

	       (*last != ';') && (*last != ','))

	    last++;

	if (ctxt->mimeType != NULL)

	    xmlFree(ctxt->mimeType);

	ctxt->mimeType = (char *) xmlStrndup(mime, last - mime);

	charset = xmlStrstr(BAD_CAST ctxt->contentType, BAD_CAST "charset=");

	if (charset != NULL) {

	    charset += 8;

	    last = charset;

	    while ((*last != 0) && (*last != ' ') && (*last != '\t') &&

	           (*last != ';') && (*last != ','))

		last++;

	    if (ctxt->encoding != NULL)

	        xmlFree(ctxt->encoding);

	    ctxt->encoding = (char *) xmlStrndup(charset, last - charset);

	}

    } else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"ContentType:", 12)) {

        const xmlChar *charset, *last, *mime;

        cur += 12;

	if (ctxt->contentType != NULL) return;

	while ((*cur == ' ') || (*cur == '\t')) cur++;

	ctxt->contentType = xmlMemStrdup(cur);

	mime = (const xmlChar *) cur;

	last = mime;

	while ((*last != 0) && (*last != ' ') && (*last != '\t') &&

	       (*last != ';') && (*last != ','))

	    last++;

	if (ctxt->mimeType != NULL)

	    xmlFree(ctxt->mimeType);

	ctxt->mimeType = (char *) xmlStrndup(mime, last - mime);

	charset = xmlStrstr(BAD_CAST ctxt->contentType, BAD_CAST "charset=");

	if (charset != NULL) {

	    charset += 8;

	    last = charset;

	    while ((*last != 0) && (*last != ' ') && (*last != '\t') &&

	           (*last != ';') && (*last != ','))

		last++;

	    if (ctxt->encoding != NULL)

	        xmlFree(ctxt->encoding);

	    ctxt->encoding = (char *) xmlStrndup(charset, last - charset);

	}

    } else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"Location:", 9)) {

        cur += 9;

	while ((*cur == ' ') || (*cur == '\t')) cur++;

	if (ctxt->location != NULL)

	    xmlFree(ctxt->location);

	if (*cur == '/') {

	    xmlChar *tmp_http = xmlStrdup(BAD_CAST "http://");

	    xmlChar *tmp_loc =

	        xmlStrcat(tmp_http, (const xmlChar *) ctxt->hostname);

	    ctxt->location =

	        (char *) xmlStrcat (tmp_loc, (const xmlChar *) cur);

	} else {

	    ctxt->location = xmlMemStrdup(cur);

	}

    } else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"WWW-Authenticate:", 17)) {

        cur += 17;

	while ((*cur == ' ') || (*cur == '\t')) cur++;

	if (ctxt->authHeader != NULL)

	    xmlFree(ctxt->authHeader);

	ctxt->authHeader = xmlMemStrdup(cur);

    } else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"Proxy-Authenticate:", 19)) {

        cur += 19;

	while ((*cur == ' ') || (*cur == '\t')) cur++;

	if (ctxt->authHeader != NULL)

	    xmlFree(ctxt->authHeader);

	ctxt->authHeader = xmlMemStrdup(cur);

#ifdef HAVE_ZLIB_H

    } else if ( !xmlStrncasecmp( BAD_CAST line, BAD_CAST"Content-Encoding:", 17) ) {

	cur += 17;

	while ((*cur == ' ') || (*cur == '\t')) cur++;

	if ( !xmlStrncasecmp( BAD_CAST cur, BAD_CAST"gzip", 4) ) {

	    ctxt->usesGzip = 1;

	    ctxt->strm = xmlMalloc(sizeof(z_stream));

	    if (ctxt->strm != NULL) {

		ctxt->strm->zalloc = Z_NULL;

		ctxt->strm->zfree = Z_NULL;

		ctxt->strm->opaque = Z_NULL;

		ctxt->strm->avail_in = 0;

		ctxt->strm->next_in = Z_NULL;

		inflateInit2( ctxt->strm, 31 );

	    }

	}

#endif

    } else if ( !xmlStrncasecmp( BAD_CAST line, BAD_CAST"Content-Length:", 15) ) {

	cur += 15;

	ctxt->ContentLength = strtol( cur, NULL, 10 );

    }

}

/**

 * xmlNanoHTTPConnectAttempt:

 * @addr:  a socket address structure

 *

 * Attempt a connection to the given IP:port endpoint. It forces

 * non-blocking semantic on the socket, and allow 60 seconds for

 * the host to answer.

 *

 * Returns -1 in case of failure, the file descriptor number otherwise

 */

static SOCKET

xmlNanoHTTPConnectAttempt(struct sockaddr *addr)

{

#ifndef HAVE_POLL_H

    fd_set wfd;

#ifdef _WINSOCKAPI_

    fd_set xfd;

#endif

    struct timeval tv;

#else /* !HAVE_POLL_H */

    struct pollfd p;

#endif /* !HAVE_POLL_H */

    int status;

    int addrlen;

    SOCKET s;

#ifdef SUPPORT_IP6

    if (addr->sa_family == AF_INET6) {

        s = socket(PF_INET6, SOCK_STREAM, IPPROTO_TCP);

        addrlen = sizeof(struct sockaddr_in6);

    } else

#endif