开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
nanohttp.c
资源名称：rtsp-1.0.1.tar.gz　[点击查看]
上传用户：sy_wanhua
上传日期：2013-07-25
资源大小：3048k
文件大小：30k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

C/C++

nanohttp.c：源码内容
  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@w3.org
  12.  */
  13.  
  14. /* TODO add compression support, Send the Accept- , and decompress on the
  15.         fly with ZLIB if found at compile-time */
  17. #ifdef WIN32
  18. #define INCLUDE_WINSOCK
  19. #include "win32config.h"
  20. #else
  21. #include "config.h"
  22. #endif
  24. #include "xmlversion.h"
  26. #ifdef LIBXML_HTTP_ENABLED
  27. #include <stdio.h>
  28. #include <string.h>
  30. #ifdef HAVE_STDLIB_H
  31. #include <stdlib.h>
  32. #endif
  33. #ifdef HAVE_UNISTD_H
  34. #include <unistd.h>
  35. #endif
  36. #ifdef HAVE_SYS_SOCKET_H
  37. #include <sys/socket.h>
  38. #endif
  39. #ifdef HAVE_NETINET_IN_H
  40. #include <netinet/in.h>
  41. #endif
  42. #ifdef HAVE_ARPA_INET_H
  43. #include <arpa/inet.h>
  44. #endif
  45. #ifdef HAVE_NETDB_H
  46. #include <netdb.h>
  47. #endif
  48. #ifdef HAVE_FCNTL_H
  49. #include <fcntl.h> 
  50. #endif
  51. #ifdef HAVE_ERRNO_H
  52. #include <errno.h>
  53. #endif
  54. #ifdef HAVE_SYS_TIME_H
  55. #include <sys/time.h>
  56. #endif
  57. #ifdef HAVE_SYS_SELECT_H
  58. #include <sys/select.h>
  59. #endif
  60. #ifdef HAVE_STRINGS_H
  61. #include <strings.h>
  62. #endif
  64. #include <libxml/xmlmemory.h>
  65. #include <libxml/nanohttp.h>
  67. #ifdef STANDALONE
  68. #define DEBUG_HTTP
  69. #endif
  71. #define XML_NANO_HTTP_MAX_REDIR 10
  73. #define XML_NANO_HTTP_CHUNK 4096
  75. #define XML_NANO_HTTP_CLOSED 0
  76. #define XML_NANO_HTTP_WRITE 1
  77. #define XML_NANO_HTTP_READ 2
  78. #define XML_NANO_HTTP_NONE 4
  80. typedef struct xmlNanoHTTPCtxt {
  81.     char *protocol; /* the protocol name */
  82.     char *hostname; /* the host name */
  83.     int port; /* the port */
  84.     char *path; /* the path within the URL */
  85.     int fd; /* the file descriptor for the socket */
  86.     int state; /* WRITE / READ / CLOSED */
  87.     char *out; /* buffer sent (zero terminated) */
  88.     char *outptr; /* index within the buffer sent */
  89.     char *in; /* the receiving buffer */
  90.     char *content; /* the start of the content */
  91.     char *inptr; /* the next byte to read from network */
  92.     char *inrptr; /* the next byte to give back to the client */
  93.     int inlen; /* len of the input buffer */
  94.     int last; /* return code for last operation */
  95.     int returnValue; /* the protocol return value */
  96.     char *contentType; /* the MIME type for the input */
  97.     char *location; /* the new URL in case of redirect */
  98. } xmlNanoHTTPCtxt, *xmlNanoHTTPCtxtPtr;
  100. static int initialized = 0;
  101. static char *proxy = NULL; /* the proxy name if any */
  102. static int proxyPort; /* the proxy port if any */
  104. /**
  105.  * xmlNanoHTTPInit:
  106.  *
  107.  * Initialize the HTTP protocol layer.
  108.  * Currently it just checks for proxy informations
  109.  */
  111. void
  112. xmlNanoHTTPInit(void) {
  113.     const char *env;
  115.     if (initialized)
  116. return;
  118.     if (proxy == NULL) {
  119. proxyPort = 80;
  120. env = getenv("no_proxy");
  121. if (env != NULL)
  122.     goto done;
  123. env = getenv("http_proxy");
  124. if (env != NULL) {
  125.     xmlNanoHTTPScanProxy(env);
  126.     goto done;
  127. }
  128. env = getenv("HTTP_PROXY");
  129. if (env != NULL) {
  130.     xmlNanoHTTPScanProxy(env);
  131.     goto done;
  132. }
  133.     }
  134. done:
  135.     initialized = 1;
  136. }
  138. /**
  139.  * xmlNanoHTTPClenup:
  140.  *
  141.  * Cleanup the HTTP protocol layer.
  142.  */
  144. void
  145. xmlNanoHTTPCleanup(void) {
  146.     if (proxy != NULL)
  147. xmlFree(proxy);
  148.     initialized = 0;
  149.     return;
  150. }
  152. /**
  153.  * xmlNanoHTTPScanURL:
  154.  * @ctxt:  an HTTP context
  155.  * @URL:  The URL used to initialize the context
  156.  *
  157.  * (Re)Initialize an HTTP context by parsing the URL and finding
  158.  * the protocol host port and path it indicates.
  159.  */
  161. static void
  162. xmlNanoHTTPScanURL(xmlNanoHTTPCtxtPtr ctxt, const char *URL) {
  163.     const char *cur = URL;
  164.     char buf[4096];
  165.     int index = 0;
  166.     int port = 0;
  168.     if (ctxt->protocol != NULL) { 
  169.         xmlFree(ctxt->protocol);
  170. ctxt->protocol = NULL;
  171.     }
  172.     if (ctxt->hostname != NULL) { 
  173.         xmlFree(ctxt->hostname);
  174. ctxt->hostname = NULL;
  175.     }
  176.     if (ctxt->path != NULL) { 
  177.         xmlFree(ctxt->path);
  178. ctxt->path = NULL;
  179.     }
  180.     if (URL == NULL) return;
  181.     buf[index] = 0;
  182.     while (*cur != 0) {
  183.         if ((cur[0] == ':') && (cur[1] == '/') && (cur[2] == '/')) {
  184.     buf[index] = 0;
  185.     ctxt->protocol = xmlMemStrdup(buf);
  186.     index = 0;
  187.             cur += 3;
  188.     break;
  189. }
  190. buf[index++] = *cur++;
  191.     }
  192.     if (*cur == 0) return;
  194.     buf[index] = 0;
  195.     while (1) {
  196.         if (cur[0] == ':') {
  197.     buf[index] = 0;
  198.     ctxt->hostname = xmlMemStrdup(buf);
  199.     index = 0;
  200.     cur += 1;
  201.     while ((*cur >= '0') && (*cur <= '9')) {
  202.         port *= 10;
  203. port += *cur - '0';
  204. cur++;
  205.     }
  206.     if (port != 0) ctxt->port = port;
  207.     while ((cur[0] != '/') && (*cur != 0)) 
  208.         cur++;
  209.     break;
  210. }
  211.         if ((*cur == '/') || (*cur == 0)) {
  212.     buf[index] = 0;
  213.     ctxt->hostname = xmlMemStrdup(buf);
  214.     index = 0;
  215.     break;
  216. }
  217. buf[index++] = *cur++;
  218.     }
  219.     if (*cur == 0) 
  220.         ctxt->path = xmlMemStrdup("/");
  221.     else {
  222.         index = 0;
  223.         buf[index] = 0;
  224. while (*cur != 0)
  225.     buf[index++] = *cur++;
  226. buf[index] = 0;
  227. ctxt->path = xmlMemStrdup(buf);
  228.     }
  229. }
  231. /**
  232.  * xmlNanoHTTPScanProxy:
  233.  * @URL:  The proxy URL used to initialize the proxy context
  234.  *
  235.  * (Re)Initialize the HTTP Proxy context by parsing the URL and finding
  236.  * the protocol host port it indicates.
  237.  * Should be like http://myproxy/ or http://myproxy:3128/
  238.  * A NULL URL cleans up proxy informations.
  239.  */
  241. void
  242. xmlNanoHTTPScanProxy(const char *URL) {
  243.     const char *cur = URL;
  244.     char buf[4096];
  245.     int index = 0;
  246.     int port = 0;
  248.     if (proxy != NULL) { 
  249.         xmlFree(proxy);
  250. proxy = NULL;
  251.     }
  252.     if (proxyPort != 0) { 
  253. proxyPort = 0;
  254.     }
  255. #ifdef DEBUG_HTTP
  256.     if (URL == NULL)
  257. printf("Removing HTTP proxy infon");
  258.     else
  259. printf("Using HTTP proxy %sn", URL);
  260. #endif
  261.     if (URL == NULL) return;
  262.     buf[index] = 0;
  263.     while (*cur != 0) {
  264.         if ((cur[0] == ':') && (cur[1] == '/') && (cur[2] == '/')) {
  265.     buf[index] = 0;
  266.     index = 0;
  267.             cur += 3;
  268.     break;
  269. }
  270. buf[index++] = *cur++;
  271.     }
  272.     if (*cur == 0) return;
  274.     buf[index] = 0;
  275.     while (1) {
  276.         if (cur[0] == ':') {
  277.     buf[index] = 0;
  278.     proxy = xmlMemStrdup(buf);
  279.     index = 0;
  280.     cur += 1;
  281.     while ((*cur >= '0') && (*cur <= '9')) {
  282.         port *= 10;
  283. port += *cur - '0';
  284. cur++;
  285.     }
  286.     if (port != 0) proxyPort = port;
  287.     while ((cur[0] != '/') && (*cur != 0)) 
  288.         cur++;
  289.     break;
  290. }
  291.         if ((*cur == '/') || (*cur == 0)) {
  292.     buf[index] = 0;
  293.     proxy = xmlMemStrdup(buf);
  294.     index = 0;
  295.     break;
  296. }
  297. buf[index++] = *cur++;
  298.     }
  299. }
  301. /**
  302.  * xmlNanoHTTPNewCtxt:
  303.  * @URL:  The URL used to initialize the context
  304.  *
  305.  * Allocate and initialize a new HTTP context.
  306.  *
  307.  * Returns an HTTP context or NULL in case of error.
  308.  */
  310. static xmlNanoHTTPCtxtPtr
  311. xmlNanoHTTPNewCtxt(const char *URL) {
  312.     xmlNanoHTTPCtxtPtr ret;
  314.     ret = (xmlNanoHTTPCtxtPtr) xmlMalloc(sizeof(xmlNanoHTTPCtxt));
  315.     if (ret == NULL) return(NULL);
  317.     memset(ret, 0, sizeof(xmlNanoHTTPCtxt));
  318.     ret->port = 80;
  319.     ret->returnValue = 0;
  321.     xmlNanoHTTPScanURL(ret, URL);
  323.     return(ret);
  324. }
  326. /**
  327.  * xmlNanoHTTPFreeCtxt:
  328.  * @ctxt:  an HTTP context
  329.  *
  330.  * Frees the context after closing the connection.
  331.  */
  333. static void
  334. xmlNanoHTTPFreeCtxt(xmlNanoHTTPCtxtPtr ctxt) {
  335.     if (ctxt == NULL) return;
  336.     if (ctxt->hostname != NULL) xmlFree(ctxt->hostname);
  337.     if (ctxt->protocol != NULL) xmlFree(ctxt->protocol);
  338.     if (ctxt->path != NULL) xmlFree(ctxt->path);
  339.     if (ctxt->out != NULL) xmlFree(ctxt->out);
  340.     if (ctxt->in != NULL) xmlFree(ctxt->in);
  341.     if (ctxt->contentType != NULL) xmlFree(ctxt->contentType);
  342.     if (ctxt->location != NULL) xmlFree(ctxt->location);
  343.     ctxt->state = XML_NANO_HTTP_NONE;
  344.     if (ctxt->fd >= 0) close(ctxt->fd);
  345.     ctxt->fd = -1;
  346.     xmlFree(ctxt);
  347. }
  349. /**
  350.  * xmlNanoHTTPSend:
  351.  * @ctxt:  an HTTP context
  352.  *
  353.  * Send the input needed to initiate the processing on the server side
  354.  */
  356. static void
  357. xmlNanoHTTPSend(xmlNanoHTTPCtxtPtr ctxt) {
  358.     if (ctxt->state & XML_NANO_HTTP_WRITE)
  359. ctxt->last = write(ctxt->fd, ctxt->outptr, strlen(ctxt->outptr));
  360. }
  362. /**
  363.  * xmlNanoHTTPRecv:
  364.  * @ctxt:  an HTTP context
  365.  *
  366.  * Read information coming from the HTTP connection.
  367.  * This is a blocking call (but it blocks in select(), not read()).
  368.  *
  369.  * Returns the number of byte read or -1 in case of error.
  370.  */
  372. static int
  373. xmlNanoHTTPRecv(xmlNanoHTTPCtxtPtr ctxt) {
  374.     fd_set rfd;
  375.     struct timeval tv;
  378.     while (ctxt->state & XML_NANO_HTTP_READ) {
  379. if (ctxt->in == NULL) {
  380.     ctxt->in = (char *) xmlMalloc(65000 * sizeof(char));
  381.     if (ctxt->in == NULL) {
  382.         ctxt->last = -1;
  383. return(-1);
  384.     }
  385.     ctxt->inlen = 65000;
  386.     ctxt->inptr = ctxt->content = ctxt->inrptr = ctxt->in;
  387. }
  388. if (ctxt->inrptr > ctxt->in + XML_NANO_HTTP_CHUNK) {
  389.     int delta = ctxt->inrptr - ctxt->in;
  390.     int len = ctxt->inptr - ctxt->inrptr;
  391.     
  392.     memmove(ctxt->in, ctxt->inrptr, len);
  393.     ctxt->inrptr -= delta;
  394.     ctxt->content -= delta;
  395.     ctxt->inptr -= delta;
  396. }
  397.         if ((ctxt->in + ctxt->inlen) < (ctxt->inptr + XML_NANO_HTTP_CHUNK)) {
  398.     int d_inptr = ctxt->inptr - ctxt->in;
  399.     int d_content = ctxt->content - ctxt->in;
  400.     int d_inrptr = ctxt->inrptr - ctxt->in;
  402.     ctxt->inlen *= 2;
  403.             ctxt->in = (char *) xmlRealloc(ctxt->in, ctxt->inlen);
  404.     if (ctxt->in == NULL) {
  405.         ctxt->last = -1;
  406. return(-1);
  407.     }
  408.             ctxt->inptr = ctxt->in + d_inptr;
  409.             ctxt->content = ctxt->in + d_content;
  410.             ctxt->inrptr = ctxt->in + d_inrptr;
  411. }
  412. ctxt->last = read(ctxt->fd, ctxt->inptr, XML_NANO_HTTP_CHUNK);
  413. if (ctxt->last > 0) {
  414.     ctxt->inptr += ctxt->last;
  415.     return(ctxt->last);
  416. }
  417. if (ctxt->last == 0) {
  418.     return(0);
  419. }
  420. #ifdef EWOULDBLOCK
  421. if ((ctxt->last == -1) && (errno != EWOULDBLOCK)) {
  422.     return(0);
  423. }
  424. #endif
  425. tv.tv_sec=10;
  426. tv.tv_usec=0;
  427. FD_ZERO(&rfd);
  428. FD_SET(ctxt->fd, &rfd);
  430. if(select(ctxt->fd+1, &rfd, NULL, NULL, &tv)<1)
  431. return(0);
  432.     }
  433.     return(0);
  434. }
  436. /**
  437.  * xmlNanoHTTPReadLine:
  438.  * @ctxt:  an HTTP context
  439.  *
  440.  * Read one line in the HTTP server output, usually for extracting
  441.  * the HTTP protocol informations from the answer header.
  442.  *
  443.  * Returns a newly allocated string with a copy of the line, or NULL
  444.  *         which indicate the end of the input.
  445.  */
  447. static char *
  448. xmlNanoHTTPReadLine(xmlNanoHTTPCtxtPtr ctxt) {
  449.     char buf[4096];
  450.     char *bp=buf;
  451.     
  452.     while(bp - buf < 4095) {
  453. if(ctxt->inrptr == ctxt->inptr) {
  454.     if (xmlNanoHTTPRecv(ctxt) == 0) {
  455. if (bp == buf)
  456.     return(NULL);
  457. else
  458.     *bp = 0;
  459. return(xmlMemStrdup(buf));
  460.     }
  461. }
  462. *bp = *ctxt->inrptr++;
  463. if(*bp == 'n') {
  464.     *bp = 0;
  465.     return(xmlMemStrdup(buf));
  466. }
  467. if(*bp != 'r')
  468.     bp++;
  469.     }
  470.     buf[4095] = 0;
  471.     return(xmlMemStrdup(buf));
  472. }
  475. /**
  476.  * xmlNanoHTTPScanAnswer:
  477.  * @ctxt:  an HTTP context
  478.  * @line:  an HTTP header line
  479.  *
  480.  * Try to extract useful informations from the server answer.
  481.  * We currently parse and process:
  482.  *  - The HTTP revision/ return code
  483.  *  - The Content-Type
  484.  *  - The Location for redirrect processing.
  485.  *
  486.  * Returns -1 in case of failure, the file descriptor number otherwise
  487.  */
  489. static void
  490. xmlNanoHTTPScanAnswer(xmlNanoHTTPCtxtPtr ctxt, const char *line) {
  491.     const char *cur = line;
  493.     if (line == NULL) return;
  495.     if (!strncmp(line, "HTTP/", 5)) {
  496.         int version = 0;
  497. int ret = 0;
  499. cur += 5;
  500. while ((*cur >= '0') && (*cur <= '9')) {
  501.     version *= 10;
  502.     version += *cur - '0';
  503.     cur++;
  504. }
  505. if (*cur == '.') {
  506.     cur++;
  507.     if ((*cur >= '0') && (*cur <= '9')) {
  508. version *= 10;
  509. version += *cur - '0';
  510. cur++;
  511.     }
  512.     while ((*cur >= '0') && (*cur <= '9'))
  513. cur++;
  514. } else
  515.     version *= 10;
  516. if ((*cur != ' ') && (*cur != 't')) return;
  517. while ((*cur == ' ') || (*cur == 't')) cur++;
  518. if ((*cur < '0') || (*cur > '9')) return;
  519. while ((*cur >= '0') && (*cur <= '9')) {
  520.     ret *= 10;
  521.     ret += *cur - '0';
  522.     cur++;
  523. }
  524. if ((*cur != 0) && (*cur != ' ') && (*cur != 't')) return;
  525. ctxt->returnValue = ret;
  526.     } else if (!strncmp(line, "Content-Type:", 13)) {
  527.         cur += 13;
  528. while ((*cur == ' ') || (*cur == 't')) cur++;
  529. if (ctxt->contentType != NULL)
  530.     xmlFree(ctxt->contentType);
  531. ctxt->contentType = xmlMemStrdup(cur);
  532.     } else if (!strncmp(line, "ContentType:", 12)) {
  533.         cur += 12;
  534. if (ctxt->contentType != NULL) return;
  535. while ((*cur == ' ') || (*cur == 't')) cur++;
  536. ctxt->contentType = xmlMemStrdup(cur);
  537.     } else if (!strncmp(line, "content-type:", 13)) {
  538.         cur += 13;
  539. if (ctxt->contentType != NULL) return;
  540. while ((*cur == ' ') || (*cur == 't')) cur++;
  541. ctxt->contentType = xmlMemStrdup(cur);
  542.     } else if (!strncmp(line, "contenttype:", 12)) {
  543.         cur += 12;
  544. if (ctxt->contentType != NULL) return;
  545. while ((*cur == ' ') || (*cur == 't')) cur++;
  546. ctxt->contentType = xmlMemStrdup(cur);
  547.     } else if (!strncmp(line, "Location:", 9)) {
  548.         cur += 9;
  549. while ((*cur == ' ') || (*cur == 't')) cur++;
  550. if (ctxt->location != NULL)
  551.     xmlFree(ctxt->location);
  552. ctxt->location = xmlMemStrdup(cur);
  553.     } else if (!strncmp(line, "location:", 9)) {
  554.         cur += 9;
  555. if (ctxt->location != NULL) return;
  556. while ((*cur == ' ') || (*cur == 't')) cur++;
  557. ctxt->location = xmlMemStrdup(cur);
  558.     }
  559. }
  561. /**
  562.  * xmlNanoHTTPConnectAttempt:
  563.  * @ia:  an internet adress structure
  564.  * @port:  the port number
  565.  *
  566.  * Attempt a connection to the given IP:port endpoint. It forces
  567.  * non-blocking semantic on the socket, and allow 60 seconds for
  568.  * the host to answer.
  569.  *
  570.  * Returns -1 in case of failure, the file descriptor number otherwise
  571.  */
  573. static int
  574. xmlNanoHTTPConnectAttempt(struct in_addr ia, int port)
  575. {
  576.     int s=socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
  577.     struct sockaddr_in sin;
  578.     fd_set wfd;
  579.     struct timeval tv;
  580.     int status;
  581.     
  582.     if(s==-1) {
  583. #ifdef DEBUG_HTTP
  584. perror("socket");
  585. #endif
  586. return(-1);
  587.     }
  588.     
  589. #ifdef _WINSOCKAPI_
  590.     {
  591. long levents = FD_READ | FD_WRITE | FD_ACCEPT |
  592.        FD_CONNECT | FD_CLOSE ;
  593. int rv = 0 ;
  594. u_long one = 1;
  596. status = ioctlsocket(s, FIONBIO, &one) == SOCKET_ERROR ? -1 : 0;
  597.     }
  598. #else /* _WINSOCKAPI_ */
  599. #if defined(VMS)
  600.     {
  601. int enable = 1;
  602. status = IOCTL(s, FIONBIO, &enable);
  603.     }
  604. #else /* VMS */
  605.     if((status = fcntl(s, F_GETFL, 0)) != -1) {
  606. #ifdef O_NONBLOCK
  607. status |= O_NONBLOCK;
  608. #else /* O_NONBLOCK */
  609. #ifdef F_NDELAY
  610. status |= F_NDELAY;
  611. #endif /* F_NDELAY */
  612. #endif /* !O_NONBLOCK */
  613. status = fcntl(s, F_SETFL, status);
  614.     }
  615.     if(status < 0) {
  616. #ifdef DEBUG_HTTP
  617. perror("nonblocking");
  618. #endif
  619. close(s);
  620. return(-1);
  621.     }
  622. #endif /* !VMS */
  623. #endif /* !_WINSOCKAPI_ */
  626.     sin.sin_family = AF_INET;
  627.     sin.sin_addr   = ia;
  628.     sin.sin_port   = htons(port);
  629.     
  630.     if((connect(s, (struct sockaddr *)&sin, sizeof(sin))==-1) &&
  631.        (errno != EINPROGRESS)) {
  632. perror("connect");
  633. close(s);
  634. return(-1);
  635.     }
  636.     
  637.     tv.tv_sec = 60; /* We use 60 second timeouts for now */
  638.     tv.tv_usec = 0;
  639.     
  640.     FD_ZERO(&wfd);
  641.     FD_SET(s, &wfd);
  642.     
  643.     switch(select(s+1, NULL, &wfd, NULL, &tv))
  644.     {
  645. case 0:
  646.     /* Time out */
  647.     close(s);
  648.     return(-1);
  649. case -1:
  650.     /* Ermm.. ?? */
  651. #ifdef DEBUG_HTTP
  652.     perror("select");
  653. #endif
  654.     close(s);
  655.     return(-1);
  656.     }
  657.     
  658.     return(s);
  659. }
  660.  
  661. /**
  662.  * xmlNanoHTTPConnectHost:
  663.  * @host:  the host name
  664.  * @port:  the port number
  665.  *
  666.  * Attempt a connection to the given host:port endpoint. It tries
  667.  * the multiple IP provided by the DNS if available.
  668.  *
  669.  * Returns -1 in case of failure, the file descriptor number otherwise
  670.  */
  672. static int
  673. xmlNanoHTTPConnectHost(const char *host, int port)
  674. {
  675.     struct hostent *h;
  676.     int i;
  677.     int s;
  678.     
  679.     h=gethostbyname(host);
  680.     if(h==NULL)
  681.     {
  682. #ifdef DEBUG_HTTP
  683. fprintf(stderr,"unable to resolve '%s'.n", host);
  684. #endif
  685. return(-1);
  686.     }
  687.     
  688.     for(i=0; h->h_addr_list[i]; i++)
  689.     {
  690. struct in_addr ia;
  691. memcpy(&ia, h->h_addr_list[i],4);
  692. s = xmlNanoHTTPConnectAttempt(ia, port);
  693. if(s != -1)
  694.     return(s);
  695.     }
  697. #ifdef DEBUG_HTTP
  698.     fprintf(stderr, "unable to connect to '%s'.n", host);
  699. #endif
  700.     return(-1);
  701. }
  704. /**
  705.  * xmlNanoHTTPOpen:
  706.  * @URL:  The URL to load
  707.  * @contentType:  if available the Content-Type information will be
  708.  *                returned at that location
  709.  *
  710.  * This function try to open a connection to the indicated resource
  711.  * via HTTP GET.
  712.  *
  713.  * Returns NULL in case of failure, otherwise a request handler.
  714.  *     The contentType, if provided must be freed by the caller
  715.  */
  717. void *
  718. xmlNanoHTTPOpen(const char *URL, char **contentType) {
  719.     xmlNanoHTTPCtxtPtr ctxt;
  720.     char buf[4096];
  721.     int ret;
  722.     char *p;
  723.     int head;
  724.     int nbRedirects = 0;
  725.     char *redirURL = NULL;
  726.     
  727.     xmlNanoHTTPInit();
  728.     if (contentType != NULL) *contentType = NULL;
  730. retry:
  731.     if (redirURL == NULL)
  732. ctxt = xmlNanoHTTPNewCtxt(URL);
  733.     else {
  734. ctxt = xmlNanoHTTPNewCtxt(redirURL);
  735. xmlFree(redirURL);
  736. redirURL = NULL;
  737.     }
  739.     if ((ctxt->protocol == NULL) || (strcmp(ctxt->protocol, "http"))) {
  740.         xmlNanoHTTPFreeCtxt(ctxt);
  741. if (redirURL != NULL) xmlFree(redirURL);
  742.         return(NULL);
  743.     }
  744.     if (ctxt->hostname == NULL) {
  745.         xmlNanoHTTPFreeCtxt(ctxt);
  746.         return(NULL);
  747.     }
  748.     if (proxy)
  749. ret = xmlNanoHTTPConnectHost(proxy, proxyPort);
  750.     else
  751. ret = xmlNanoHTTPConnectHost(ctxt->hostname, ctxt->port);
  752.     if (ret < 0) {
  753.         xmlNanoHTTPFreeCtxt(ctxt);
  754.         return(NULL);
  755.     }
  756.     ctxt->fd = ret;
  757.     if (proxy) {
  758. #ifdef HAVE_SNPRINTF
  759. if (ctxt->port != 80)
  760.     snprintf(buf, sizeof(buf),
  761.      "GET http://%s:%d%s HTTP/1.0rnHost: %srnrn",
  762.  ctxt->hostname, ctxt->port, ctxt->path, ctxt->hostname);
  763. else 
  764.     snprintf(buf, sizeof(buf),"GET http://%s%s HTTP/1.0rnHost: %srnrn",
  765.  ctxt->hostname, ctxt->path, ctxt->hostname);
  766. #else
  767. if (ctxt->port != 80)
  768.     sprintf(buf, 
  769.      "GET http://%s:%d%s HTTP/1.0rnHost: %srnrn",
  770.  ctxt->hostname, ctxt->port, ctxt->path, ctxt->hostname);
  771. else 
  772.     sprintf(buf, "GET http://%s%s HTTP/1.0rnHost: %srnrn",
  773.  ctxt->hostname, ctxt->path, ctxt->hostname);
  774. #endif
  775. #ifdef DEBUG_HTTP
  776. if (ctxt->port != 80)
  777.     printf("-> Proxy GET http://%s:%d%s HTTP/1.0n-> Host: %snn",
  778.            ctxt->hostname, ctxt->port, ctxt->path, ctxt->hostname);
  779. else
  780.     printf("-> Proxy GET http://%s%s HTTP/1.0n-> Host: %snn",
  781.            ctxt->hostname, ctxt->path, ctxt->hostname);
  782. #endif
  783.     } else {
  784. #ifdef HAVE_SNPRINTF
  785. snprintf(buf, sizeof(buf),"GET %s HTTP/1.0rnHost: %srnrn",
  786.  ctxt->path, ctxt->hostname);
  787. #else
  788. sprintf(buf, "GET %s HTTP/1.0rnHost: %srnrn",
  789.  ctxt->path, ctxt->hostname);
  790. #endif
  791. #ifdef DEBUG_HTTP
  792. printf("-> GET %s HTTP/1.0n-> Host: %snn",
  793.        ctxt->path, ctxt->hostname);
  794. #endif
  795.     }
  796.     ctxt->outptr = ctxt->out = xmlMemStrdup(buf);
  797.     ctxt->state = XML_NANO_HTTP_WRITE;
  798.     xmlNanoHTTPSend(ctxt);
  799.     ctxt->state = XML_NANO_HTTP_READ;
  800.     head = 1;
  802.     while ((p = xmlNanoHTTPReadLine(ctxt)) != NULL) {
  803.         if (head && (*p == 0)) {
  804.     head = 0;
  805.     ctxt->content = ctxt->inrptr;
  806.     xmlFree(p);
  807.     break;
  808. }
  809. xmlNanoHTTPScanAnswer(ctxt, p);
  811. #ifdef DEBUG_HTTP
  812. if (p != NULL) printf("<- %sn", p);
  813. #endif
  814.         if (p != NULL) xmlFree(p);
  815.     }
  817.     if ((ctxt->location != NULL) && (ctxt->returnValue >= 300) &&
  818.         (ctxt->returnValue < 400)) {
  819. #ifdef DEBUG_HTTP
  820. printf("nRedirect to: %sn", ctxt->location);
  821. #endif
  822. while (xmlNanoHTTPRecv(ctxt)) ;
  823.         if (nbRedirects < XML_NANO_HTTP_MAX_REDIR) {
  824.     nbRedirects++;
  825.     redirURL = xmlMemStrdup(ctxt->location);
  826.     xmlNanoHTTPFreeCtxt(ctxt);
  827.     goto retry;
  828. }
  829. xmlNanoHTTPFreeCtxt(ctxt);
  830. #ifdef DEBUG_HTTP
  831. printf("Too many redirrects, aborting ...n");
  832. #endif
  833. return(NULL);
  835.     }
  837.     if ((contentType != NULL) && (ctxt->contentType != NULL))
  838.         *contentType = xmlMemStrdup(ctxt->contentType);
  840. #ifdef DEBUG_HTTP
  841.     if (ctxt->contentType != NULL)
  842. printf("nCode %d, content-type '%s'nn",
  843.        ctxt->returnValue, ctxt->contentType);
  844.     else
  845. printf("nCode %d, no content-typenn",
  846.        ctxt->returnValue);
  847. #endif
  849.     return((void *) ctxt);
  850. }
  852. /**
  853.  * xmlNanoHTTPRead:
  854.  * @ctx:  the HTTP context
  855.  * @dest:  a buffer
  856.  * @len:  the buffer length
  857.  *
  858.  * This function tries to read @len bytes from the existing HTTP connection
  859.  * and saves them in @dest. This is a blocking call.
  860.  *
  861.  * Returns the number of byte read. 0 is an indication of an end of connection.
  862.  *         -1 indicates a parameter error.
  863.  */
  864. int
  865. xmlNanoHTTPRead(void *ctx, void *dest, int len) {
  866.     xmlNanoHTTPCtxtPtr ctxt = (xmlNanoHTTPCtxtPtr) ctx;
  868.     if (ctx == NULL) return(-1);
  869.     if (dest == NULL) return(-1);
  870.     if (len <= 0) return(0);
  872.     while (ctxt->inptr - ctxt->inrptr < len) {
  873.         if (xmlNanoHTTPRecv(ctxt) == 0) break;
  874.     }
  875.     if (ctxt->inptr - ctxt->inrptr < len)
  876.         len = ctxt->inptr - ctxt->inrptr;
  877.     memcpy(dest, ctxt->inrptr, len);
  878.     ctxt->inrptr += len;
  879.     return(len);
  880. }
  882. /**
  883.  * xmlNanoHTTPClose:
  884.  * @ctx:  the HTTP context
  885.  *
  886.  * This function closes an HTTP context, it ends up the connection and
  887.  * free all data related to it.
  888.  */
  889. void
  890. xmlNanoHTTPClose(void *ctx) {
  891.     xmlNanoHTTPCtxtPtr ctxt = (xmlNanoHTTPCtxtPtr) ctx;
  893.     if (ctx == NULL) return;
  895.     xmlNanoHTTPFreeCtxt(ctxt);
  896. }
  898. #ifndef DEBUG_HTTP
  899. #define DEBUG_HTTP
  900. #endif
  901. /**
  902.  * xmlNanoHTTPMethod:
  903.  * @URL:  The URL to load
  904.  * @method:  the HTTP method to use
  905.  * @input:  the input string if any
  906.  * @contentType:  the Content-Type information IN and OUT
  907.  * @headers:  the extra headers
  908.  *
  909.  * This function try to open a connection to the indicated resource
  910.  * via HTTP using the given @method, adding the given extra headers
  911.  * and the input buffer for the request content.
  912.  *
  913.  * Returns NULL in case of failure, otherwise a request handler.
  914.  *     The contentType, if provided must be freed by the caller
  915.  */
  917. void *
  918. xmlNanoHTTPMethod(const char *URL, const char *method, const char *input,
  919.                   char **contentType, const char *headers) {
  920.     xmlNanoHTTPCtxtPtr ctxt;
  921.     char buf[20000];
  922.     int ret;
  923.     char *p;
  924.     int head;
  925.     int nbRedirects = 0;
  926.     char *redirURL = NULL;
  927.     
  928.     if (URL == NULL) return(NULL);
  929.     if (method == NULL) method = "GET";
  930.     if (contentType != NULL) *contentType = NULL;
  932. retry:
  933.     if (redirURL == NULL)
  934. ctxt = xmlNanoHTTPNewCtxt(URL);
  935.     else {
  936. ctxt = xmlNanoHTTPNewCtxt(redirURL);
  937. xmlFree(redirURL);
  938. redirURL = NULL;
  939.     }
  941.     if ((ctxt->protocol == NULL) || (strcmp(ctxt->protocol, "http"))) {
  942.         xmlNanoHTTPFreeCtxt(ctxt);
  943. if (redirURL != NULL) xmlFree(redirURL);
  944.         return(NULL);
  945.     }
  946.     if (ctxt->hostname == NULL) {
  947.         xmlNanoHTTPFreeCtxt(ctxt);
  948.         return(NULL);
  949.     }
  950.     ret = xmlNanoHTTPConnectHost(ctxt->hostname, ctxt->port);
  951.     if (ret < 0) {
  952.         xmlNanoHTTPFreeCtxt(ctxt);
  953.         return(NULL);
  954.     }
  955.     ctxt->fd = ret;
  957.     if (input == NULL) {
  958.         if (headers == NULL) {
  959.     if ((contentType == NULL) || (*contentType == NULL)) {
  960. #ifdef HAVE_SNPRINTF
  961. snprintf(buf, sizeof(buf),
  962.          "%s %s HTTP/1.0rnHost: %srnrn",
  963.  method, ctxt->path, ctxt->hostname);
  964. #else
  965. sprintf(buf,
  966.          "%s %s HTTP/1.0rnHost: %srnrn",
  967.  method, ctxt->path, ctxt->hostname);
  968. #endif
  969.     } else {
  970. #ifdef HAVE_SNPRINTF
  971. snprintf(buf, sizeof(buf),
  972.      "%s %s HTTP/1.0rnHost: %srnContent-Type: %srnrn",
  973.  method, ctxt->path, ctxt->hostname, *contentType);
  974. #else
  975. sprintf(buf,
  976.      "%s %s HTTP/1.0rnHost: %srnContent-Type: %srnrn",
  977.  method, ctxt->path, ctxt->hostname, *contentType);
  978. #endif
  979.     }
  980. } else {
  981.     if ((contentType == NULL) || (*contentType == NULL)) {
  982. #ifdef HAVE_SNPRINTF
  983. snprintf(buf, sizeof(buf),
  984.          "%s %s HTTP/1.0rnHost: %srn%srn",
  985.  method, ctxt->path, ctxt->hostname, headers);
  986. #else
  987. sprintf(buf,
  988.          "%s %s HTTP/1.0rnHost: %srn%srn",
  989.  method, ctxt->path, ctxt->hostname, headers);
  990. #endif
  991.     } else {
  992. #ifdef HAVE_SNPRINTF
  993. snprintf(buf, sizeof(buf),
  994.  "%s %s HTTP/1.0rnHost: %srnContent-Type: %srn%srn",
  995.  method, ctxt->path, ctxt->hostname, *contentType,
  996.  headers);
  997. #else
  998. sprintf(buf,
  999.  "%s %s HTTP/1.0rnHost: %srnContent-Type: %srn%srn",
  1000.  method, ctxt->path, ctxt->hostname, *contentType,
  1001.  headers);
  1002. #endif
  1003.     }
  1004. }
  1005.     } else {
  1006.         int len = strlen(input);
  1007.         if (headers == NULL) {
  1008.     if ((contentType == NULL) || (*contentType == NULL)) {
  1009. #ifdef HAVE_SNPRINTF
  1010. snprintf(buf, sizeof(buf),
  1011.  "%s %s HTTP/1.0rnHost: %srnContent-Length: %drnrn%s",
  1012.  method, ctxt->path, ctxt->hostname, len, input);
  1013. #else
  1014. sprintf(buf,
  1015.  "%s %s HTTP/1.0rnHost: %srnContent-Length: %drnrn%s",
  1016.  method, ctxt->path, ctxt->hostname, len, input);
  1017. #endif
  1018.     } else {
  1019. #ifdef HAVE_SNPRINTF
  1020. snprintf(buf, sizeof(buf),
  1021. "%s %s HTTP/1.0rnHost: %srnContent-Type: %srnContent-Length: %drnrn%s",
  1022.  method, ctxt->path, ctxt->hostname, *contentType, len,
  1023.  input);
  1024. #else
  1025. sprintf(buf,
  1026. "%s %s HTTP/1.0rnHost: %srnContent-Type: %srnContent-Length: %drnrn%s",
  1027.  method, ctxt->path, ctxt->hostname, *contentType, len,
  1028.  input);
  1029. #endif
  1030.     }
  1031. } else {
  1032.     if ((contentType == NULL) || (*contentType == NULL)) {
  1033. #ifdef HAVE_SNPRINTF
  1034. snprintf(buf, sizeof(buf),
  1035.      "%s %s HTTP/1.0rnHost: %srnContent-Length: %drn%srn%s",
  1036.  method, ctxt->path, ctxt->hostname, len,
  1037.  headers, input);
  1038. #else
  1039. sprintf(buf,
  1040.      "%s %s HTTP/1.0rnHost: %srnContent-Length: %drn%srn%s",
  1041.  method, ctxt->path, ctxt->hostname, len,
  1042.  headers, input);
  1043. #endif
  1044.     } else {
  1045. #ifdef HAVE_SNPRINTF
  1046. snprintf(buf, sizeof(buf),
  1047. "%s %s HTTP/1.0rnHost: %srnContent-Type: %srnContent-Length: %drn%srn%s",
  1048.  method, ctxt->path, ctxt->hostname, *contentType,
  1049.  len, headers, input);
  1050. #else
  1051. sprintf(buf,
  1052. "%s %s HTTP/1.0rnHost: %srnContent-Type: %srnContent-Length: %drn%srn%s",
  1053.  method, ctxt->path, ctxt->hostname, *contentType,
  1054.  len, headers, input);
  1055. #endif
  1056.     }
  1057. }
  1058.     }
  1059. #ifdef DEBUG_HTTP
  1060.     printf("-> %s", buf);
  1061. #endif
  1062.     ctxt->outptr = ctxt->out = xmlMemStrdup(buf);
  1063.     ctxt->state = XML_NANO_HTTP_WRITE;
  1064.     xmlNanoHTTPSend(ctxt);
  1065.     ctxt->state = XML_NANO_HTTP_READ;
  1066.     head = 1;
  1068.     while ((p = xmlNanoHTTPReadLine(ctxt)) != NULL) {
  1069.         if (head && (*p == 0)) {
  1070.     head = 0;
  1071.     ctxt->content = ctxt->inrptr;
  1072.     if (p != NULL) xmlFree(p);
  1073.     break;
  1074. }
  1075. xmlNanoHTTPScanAnswer(ctxt, p);
  1077. #ifdef DEBUG_HTTP
  1078. if (p != NULL) printf("<- %sn", p);
  1079. #endif
  1080.         if (p != NULL) xmlFree(p);
  1081.     }
  1083.     if ((ctxt->location != NULL) && (ctxt->returnValue >= 300) &&
  1084.         (ctxt->returnValue < 400)) {
  1085. #ifdef DEBUG_HTTP
  1086. printf("nRedirect to: %sn", ctxt->location);
  1087. #endif
  1088. while (xmlNanoHTTPRecv(ctxt)) ;
  1089.         if (nbRedirects < XML_NANO_HTTP_MAX_REDIR) {
  1090.     nbRedirects++;
  1091.     redirURL = xmlMemStrdup(ctxt->location);
  1092.     xmlNanoHTTPFreeCtxt(ctxt);
  1093.     goto retry;
  1094. }
  1095. xmlNanoHTTPFreeCtxt(ctxt);
  1096. #ifdef DEBUG_HTTP
  1097. printf("Too many redirrects, aborting ...n");
  1098. #endif
  1099. return(NULL);
  1101.     }
  1103.     if ((contentType != NULL) && (ctxt->contentType != NULL))
  1104.         *contentType = xmlMemStrdup(ctxt->contentType);
  1105.     else if (contentType != NULL)
  1106.         *contentType = NULL;
  1108. #ifdef DEBUG_HTTP
  1109.     if (ctxt->contentType != NULL)
  1110. printf("nCode %d, content-type '%s'nn",
  1111.        ctxt->returnValue, ctxt->contentType);
  1112.     else
  1113. printf("nCode %d, no content-typenn",
  1114.        ctxt->returnValue);
  1115. #endif
  1117.     return((void *) ctxt);
  1118. }
  1120. /**
  1121.  * xmlNanoHTTPFetch:
  1122.  * @URL:  The URL to load
  1123.  * @filename:  the filename where the content should be saved
  1124.  * @contentType:  if available the Content-Type information will be
  1125.  *                returned at that location
  1126.  *
  1127.  * This function try to fetch the indicated resource via HTTP GET
  1128.  * and save it's content in the file.
  1129.  *
  1130.  * Returns -1 in case of failure, 0 incase of success. The contentType,
  1131.  *     if provided must be freed by the caller
  1132.  */
  1133. int
  1134. xmlNanoHTTPFetch(const char *URL, const char *filename, char **contentType) {
  1135.     void *ctxt;
  1136.     char buf[4096];
  1137.     int fd;
  1138.     int len;
  1139.     
  1140.     ctxt = xmlNanoHTTPOpen(URL, contentType);
  1141.     if (ctxt == NULL) return(-1);
  1143.     if (!strcmp(filename, "-")) 
  1144.         fd = 0;
  1145.     else {
  1146.         fd = open(filename, O_CREAT | O_WRONLY, 00644);
  1147. if (fd < 0) {
  1148.     xmlNanoHTTPClose(ctxt);
  1149.     if ((contentType != NULL) && (*contentType != NULL)) {
  1150.         xmlFree(*contentType);
  1151. *contentType = NULL;
  1152.     }
  1153.     return(-1);
  1154. }
  1155.     }
  1157.     while ((len = xmlNanoHTTPRead(ctxt, buf, sizeof(buf))) > 0) {
  1158. write(fd, buf, len);
  1159.     }
  1161.     xmlNanoHTTPClose(ctxt);
  1162.     close(fd);
  1163.     return(0);
  1164. }
  1166. /**
  1167.  * xmlNanoHTTPSave:
  1168.  * @ctxt:  the HTTP context
  1169.  * @filename:  the filename where the content should be saved
  1170.  *
  1171.  * This function saves the output of the HTTP transaction to a file
  1172.  * It closes and free the context at the end
  1173.  *
  1174.  * Returns -1 in case of failure, 0 incase of success.
  1175.  */
  1176. int
  1177. xmlNanoHTTPSave(void *ctxt, const char *filename) {
  1178.     char buf[4096];
  1179.     int fd;
  1180.     int len;
  1181.     
  1182.     if (ctxt == NULL) return(-1);
  1184.     if (!strcmp(filename, "-")) 
  1185.         fd = 0;
  1186.     else {
  1187.         fd = open(filename, O_CREAT | O_WRONLY);
  1188. if (fd < 0) {
  1189.     xmlNanoHTTPClose(ctxt);
  1190.     return(-1);
  1191. }
  1192.     }
  1194.     while ((len = xmlNanoHTTPRead(ctxt, buf, sizeof(buf))) > 0) {
  1195. write(fd, buf, len);
  1196.     }
  1198.     xmlNanoHTTPClose(ctxt);
  1199.     return(0);
  1200. }
  1202. /**
  1203.  * xmlNanoHTTPReturnCode:
  1204.  * @ctx:  the HTTP context
  1205.  *
  1206.  * Returns the HTTP return code for the request.
  1207.  */
  1208. int
  1209. xmlNanoHTTPReturnCode(void *ctx) {
  1210.     xmlNanoHTTPCtxtPtr ctxt = (xmlNanoHTTPCtxtPtr) ctx;
  1212.     if (ctxt == NULL) return(-1);
  1214.     return(ctxt->returnValue);
  1215. }
  1217. #ifdef STANDALONE
  1218. int main(int argc, char **argv) {
  1219.     char *contentType = NULL;
  1221.     if (argv[1] != NULL) {
  1222. if (argv[2] != NULL) 
  1223.     xmlNanoHTTPFetch(argv[1], argv[2], &contentType);
  1224.         else
  1225.     xmlNanoHTTPFetch(argv[1], "-", &contentType);
  1226. if (contentType != NULL) xmlFree(contentType);
  1227.     } else {
  1228.         printf("%s: minimal HTTP GET implementationn", argv[0]);
  1229.         printf("tusage %s [ URL [ filename ] ]n", argv[0]);
  1230.     }
  1231.     xmlNanoHTTPCleanup();
  1232.     xmlMemoryDump();
  1233.     return(0);
  1234. }
  1235. #endif /* STANDALONE */
  1236. #else /* !LIBXML_HTTP_ENABLED */
  1237. #ifdef STANDALONE
  1238. #include <stdio.h>
  1239. int main(int argc, char **argv) {
  1240.     printf("%s : HTTP support not compiled inn", argv[0]);
  1241.     return(0);
  1242. }
  1243. #endif /* STANDALONE */
  1244. #endif /* LIBXML_HTTP_ENABLED */