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

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

流媒体/Mpeg4/MP4

开发平台：

C/C++

nanoftp.c：源码内容
  1. /**
  2.  * ftp.c: basic handling of an FTP command connection to check for
  3.  *        directory availability. No transfer is needed.
  4.  *
  5.  *  Reference: RFC 959
  6.  */
  8. #ifdef WIN32
  9. #define INCLUDE_WINSOCK
  10. #include "win32config.h"
  11. #else
  12. #include "config.h"
  13. #endif
  14. #include "xmlversion.h"
  16. #ifdef LIBXML_FTP_ENABLED
  17. #include <stdio.h>
  18. #include <string.h>
  20. #ifdef HAVE_CTYPE_H
  21. #include <ctype.h>
  22. #endif
  23. #ifdef HAVE_UNISTD_H
  24. #include <unistd.h>
  25. #endif
  27. #include <sys/types.h>
  28. #ifdef HAVE_SYS_TIME_H
  29. #include <sys/time.h>
  30. #endif
  31. #ifdef HAVE_SYS_SOCKET_H
  32. #include <sys/socket.h>
  33. #endif
  34. #ifdef HAVE_NETINET_IN_H
  35. #include <netinet/in.h>
  36. #endif
  37. #ifdef HAVE_ARPA_INET_H
  38. #include <arpa/inet.h>
  39. #endif
  40. #ifdef HAVE_NETDB_H
  41. #include <netdb.h>
  42. #endif
  43. #ifdef HAVE_FCNTL_H
  44. #include <fcntl.h> 
  45. #endif
  46. #ifdef HAVE_ERRNO_H
  47. #include <errno.h>
  48. #endif
  49. #ifdef HAVE_SYS_TIME_H
  50. #include <sys/time.h>
  51. #endif
  52. #ifdef HAVE_SYS_SELECT_H
  53. #include <sys/select.h>
  54. #endif
  55. #ifdef HAVE_RESOLV_H
  56. #include <resolv.h>
  57. #endif
  58. #ifdef HAVE_STDLIB_H
  59. #include <stdlib.h>
  60. #endif
  61. #ifdef HAVE_STRINGS_H
  62. #include <strings.h>
  63. #endif
  65. #include <libxml/xmlmemory.h>
  66. #include <libxml/nanoftp.h>
  68. /* #define DEBUG_FTP 1  */
  69. #ifdef STANDALONE
  70. #ifndef DEBUG_FTP
  71. #define DEBUG_FTP 1
  72. #endif
  73. #endif
  75. static char hostname[100];
  77. #define FTP_COMMAND_OK 200
  78. #define FTP_SYNTAX_ERROR 500
  79. #define FTP_GET_PASSWD 331
  81. typedef struct xmlNanoFTPCtxt {
  82.     char *protocol; /* the protocol name */
  83.     char *hostname; /* the host name */
  84.     int port; /* the port */
  85.     char *path; /* the path within the URL */
  86.     char *user; /* user string */
  87.     char *passwd; /* passwd string */
  88.     struct sockaddr_in ftpAddr; /* the socket address struct */
  89.     int passive; /* currently we support only passive !!! */
  90.     int controlFd; /* the file descriptor for the control socket */
  91.     int dataFd; /* the file descriptor for the data socket */
  92.     int state; /* WRITE / READ / CLOSED */
  93.     int returnValue; /* the protocol return value */
  94. } xmlNanoFTPCtxt, *xmlNanoFTPCtxtPtr;
  96. static int initialized = 0;
  97. static char *proxy = NULL; /* the proxy name if any */
  98. static int proxyPort = 0; /* the proxy port if any */
  99. static char *proxyUser = NULL; /* user for proxy authentication */
  100. static char *proxyPasswd = NULL;/* passwd for proxy authentication */
  101. static int proxyType = 0; /* uses TYPE or a@b ? */
  103. /**
  104.  * xmlNanoFTPInit:
  105.  *
  106.  * Initialize the FTP protocol layer.
  107.  * Currently it just checks for proxy informations,
  108.  * and get the hostname
  109.  */
  111. void
  112. xmlNanoFTPInit(void) {
  113.     const char *env;
  115.     if (initialized)
  116. return;
  118.     gethostname(hostname, sizeof(hostname));
  120.     proxyPort = 21;
  121.     env = getenv("no_proxy");
  122.     if (env != NULL)
  123. return;
  124.     env = getenv("ftp_proxy");
  125.     if (env != NULL) {
  126. xmlNanoFTPScanProxy(env);
  127.     } else {
  128. env = getenv("FTP_PROXY");
  129. if (env != NULL) {
  130.     xmlNanoFTPScanProxy(env);
  131. }
  132.     }
  133.     env = getenv("ftp_proxy_user");
  134.     if (env != NULL) {
  135. proxyUser = xmlMemStrdup(env);
  136.     }
  137.     env = getenv("ftp_proxy_password");
  138.     if (env != NULL) {
  139. proxyPasswd = xmlMemStrdup(env);
  140.     }
  141.     initialized = 1;
  142. }
  144. /**
  145.  * xmlNanoFTPClenup:
  146.  *
  147.  * Cleanup the FTP protocol layer. This cleanup proxy informations.
  148.  */
  150. void
  151. xmlNanoFTPCleanup(void) {
  152.     if (proxy != NULL) {
  153. xmlFree(proxy);
  154. proxy = NULL;
  155.     }
  156.     if (proxyUser != NULL) {
  157. xmlFree(proxyUser);
  158. proxyUser = NULL;
  159.     }
  160.     if (proxyPasswd != NULL) {
  161. xmlFree(proxyPasswd);
  162. proxyPasswd = NULL;
  163.     }
  164.     hostname[0] = 0;
  165.     initialized = 0;
  166.     return;
  167. }
  169. /**
  170.  * xmlNanoFTPProxy:
  171.  * @host:  the proxy host name
  172.  * @port:  the proxy port
  173.  * @user:  the proxy user name
  174.  * @passwd:  the proxy password
  175.  * @type:  the type of proxy 1 for using SITE, 2 for USER a@b
  176.  *
  177.  * Setup the FTP proxy informations.
  178.  * This can also be done by using ftp_proxy ftp_proxy_user and
  179.  * ftp_proxy_password environment variables.
  180.  */
  182. void
  183. xmlNanoFTPProxy(const char *host, int port, const char *user,
  184.         const char *passwd, int type) {
  185.     if (proxy != NULL)
  186. xmlFree(proxy);
  187.     if (proxyUser != NULL)
  188. xmlFree(proxyUser);
  189.     if (proxyPasswd != NULL)
  190. xmlFree(proxyPasswd);
  191.     if (host)
  192. proxy = xmlMemStrdup(host);
  193.     if (user)
  194. proxyUser = xmlMemStrdup(user);
  195.     if (passwd)
  196. proxyPasswd = xmlMemStrdup(passwd);
  197.     proxyPort = port;
  198.     proxyType = type;
  199. }
  201. /**
  202.  * xmlNanoFTPScanURL:
  203.  * @ctx:  an FTP context
  204.  * @URL:  The URL used to initialize the context
  205.  *
  206.  * (Re)Initialize an FTP context by parsing the URL and finding
  207.  * the protocol host port and path it indicates.
  208.  */
  210. static void
  211. xmlNanoFTPScanURL(void *ctx, const char *URL) {
  212.     xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
  213.     const char *cur = URL;
  214.     char buf[4096];
  215.     int index = 0;
  216.     int port = 0;
  218.     if (ctxt->protocol != NULL) { 
  219.         xmlFree(ctxt->protocol);
  220. ctxt->protocol = NULL;
  221.     }
  222.     if (ctxt->hostname != NULL) { 
  223.         xmlFree(ctxt->hostname);
  224. ctxt->hostname = NULL;
  225.     }
  226.     if (ctxt->path != NULL) { 
  227.         xmlFree(ctxt->path);
  228. ctxt->path = NULL;
  229.     }
  230.     if (URL == NULL) return;
  231.     buf[index] = 0;
  232.     while (*cur != 0) {
  233.         if ((cur[0] == ':') && (cur[1] == '/') && (cur[2] == '/')) {
  234.     buf[index] = 0;
  235.     ctxt->protocol = xmlMemStrdup(buf);
  236.     index = 0;
  237.             cur += 3;
  238.     break;
  239. }
  240. buf[index++] = *cur++;
  241.     }
  242.     if (*cur == 0) return;
  244.     buf[index] = 0;
  245.     while (1) {
  246.         if (cur[0] == ':') {
  247.     buf[index] = 0;
  248.     ctxt->hostname = xmlMemStrdup(buf);
  249.     index = 0;
  250.     cur += 1;
  251.     while ((*cur >= '0') && (*cur <= '9')) {
  252.         port *= 10;
  253. port += *cur - '0';
  254. cur++;
  255.     }
  256.     if (port != 0) ctxt->port = port;
  257.     while ((cur[0] != '/') && (*cur != 0)) 
  258.         cur++;
  259.     break;
  260. }
  261.         if ((*cur == '/') || (*cur == 0)) {
  262.     buf[index] = 0;
  263.     ctxt->hostname = xmlMemStrdup(buf);
  264.     index = 0;
  265.     break;
  266. }
  267. buf[index++] = *cur++;
  268.     }
  269.     if (*cur == 0) 
  270.         ctxt->path = xmlMemStrdup("/");
  271.     else {
  272.         index = 0;
  273.         buf[index] = 0;
  274. while (*cur != 0)
  275.     buf[index++] = *cur++;
  276. buf[index] = 0;
  277. ctxt->path = xmlMemStrdup(buf);
  278.     }
  279. }
  281. /**
  282.  * xmlNanoFTPUpdateURL:
  283.  * @ctx:  an FTP context
  284.  * @URL:  The URL used to update the context
  285.  *
  286.  * Update an FTP context by parsing the URL and finding
  287.  * new path it indicates. If there is an error in the 
  288.  * protocol, hostname, port or other information, the
  289.  * error is raised. It indicates a new connection has to
  290.  * be established.
  291.  *
  292.  * Returns 0 if Ok, -1 in case of error (other host).
  293.  */
  295. int
  296. xmlNanoFTPUpdateURL(void *ctx, const char *URL) {
  297.     xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
  298.     const char *cur = URL;
  299.     char buf[4096];
  300.     int index = 0;
  301.     int port = 0;
  303.     if (URL == NULL)
  304. return(-1);
  305.     if (ctxt == NULL)
  306. return(-1);
  307.     if (ctxt->protocol == NULL)
  308. return(-1);
  309.     if (ctxt->hostname == NULL)
  310. return(-1);
  311.     buf[index] = 0;
  312.     while (*cur != 0) {
  313.         if ((cur[0] == ':') && (cur[1] == '/') && (cur[2] == '/')) {
  314.     buf[index] = 0;
  315.     if (strcmp(ctxt->protocol, buf))
  316. return(-1);
  317.     index = 0;
  318.             cur += 3;
  319.     break;
  320. }
  321. buf[index++] = *cur++;
  322.     }
  323.     if (*cur == 0)
  324. return(-1);
  326.     buf[index] = 0;
  327.     while (1) {
  328.         if (cur[0] == ':') {
  329.     buf[index] = 0;
  330.     if (strcmp(ctxt->hostname, buf))
  331. return(-1);
  332.     index = 0;
  333.     cur += 1;
  334.     while ((*cur >= '0') && (*cur <= '9')) {
  335.         port *= 10;
  336. port += *cur - '0';
  337. cur++;
  338.     }
  339.     if (port != ctxt->port)
  340. return(-1);
  341.     while ((cur[0] != '/') && (*cur != 0)) 
  342.         cur++;
  343.     break;
  344. }
  345.         if ((*cur == '/') || (*cur == 0)) {
  346.     buf[index] = 0;
  347.     if (strcmp(ctxt->hostname, buf))
  348. return(-1);
  349.     index = 0;
  350.     break;
  351. }
  352. buf[index++] = *cur++;
  353.     }
  354.     if (ctxt->path != NULL) {
  355. xmlFree(ctxt->path);
  356. ctxt->path = NULL;
  357.     }
  359.     if (*cur == 0) 
  360.         ctxt->path = xmlMemStrdup("/");
  361.     else {
  362.         index = 0;
  363.         buf[index] = 0;
  364. while (*cur != 0)
  365.     buf[index++] = *cur++;
  366. buf[index] = 0;
  367. ctxt->path = xmlMemStrdup(buf);
  368.     }
  369.     return(0);
  370. }
  372. /**
  373.  * xmlNanoFTPScanProxy:
  374.  * @URL:  The proxy URL used to initialize the proxy context
  375.  *
  376.  * (Re)Initialize the FTP Proxy context by parsing the URL and finding
  377.  * the protocol host port it indicates.
  378.  * Should be like ftp://myproxy/ or ftp://myproxy:3128/
  379.  * A NULL URL cleans up proxy informations.
  380.  */
  382. void
  383. xmlNanoFTPScanProxy(const char *URL) {
  384.     const char *cur = URL;
  385.     char buf[4096];
  386.     int index = 0;
  387.     int port = 0;
  389.     if (proxy != NULL) { 
  390.         xmlFree(proxy);
  391. proxy = NULL;
  392.     }
  393.     if (proxyPort != 0) { 
  394. proxyPort = 0;
  395.     }
  396. #ifdef DEBUG_FTP
  397.     if (URL == NULL)
  398. printf("Removing FTP proxy infon");
  399.     else
  400. printf("Using FTP proxy %sn", URL);
  401. #endif
  402.     if (URL == NULL) return;
  403.     buf[index] = 0;
  404.     while (*cur != 0) {
  405.         if ((cur[0] == ':') && (cur[1] == '/') && (cur[2] == '/')) {
  406.     buf[index] = 0;
  407.     index = 0;
  408.             cur += 3;
  409.     break;
  410. }
  411. buf[index++] = *cur++;
  412.     }
  413.     if (*cur == 0) return;
  415.     buf[index] = 0;
  416.     while (1) {
  417.         if (cur[0] == ':') {
  418.     buf[index] = 0;
  419.     proxy = xmlMemStrdup(buf);
  420.     index = 0;
  421.     cur += 1;
  422.     while ((*cur >= '0') && (*cur <= '9')) {
  423.         port *= 10;
  424. port += *cur - '0';
  425. cur++;
  426.     }
  427.     if (port != 0) proxyPort = port;
  428.     while ((cur[0] != '/') && (*cur != 0)) 
  429.         cur++;
  430.     break;
  431. }
  432.         if ((*cur == '/') || (*cur == 0)) {
  433.     buf[index] = 0;
  434.     proxy = xmlMemStrdup(buf);
  435.     index = 0;
  436.     break;
  437. }
  438. buf[index++] = *cur++;
  439.     }
  440. }
  442. /**
  443.  * xmlNanoFTPNewCtxt:
  444.  * @URL:  The URL used to initialize the context
  445.  *
  446.  * Allocate and initialize a new FTP context.
  447.  *
  448.  * Returns an FTP context or NULL in case of error.
  449.  */
  451. void *
  452. xmlNanoFTPNewCtxt(const char *URL) {
  453.     xmlNanoFTPCtxtPtr ret;
  455.     ret = (xmlNanoFTPCtxtPtr) xmlMalloc(sizeof(xmlNanoFTPCtxt));
  456.     if (ret == NULL) return(NULL);
  458.     memset(ret, 0, sizeof(xmlNanoFTPCtxt));
  459.     ret->port = 21;
  460.     ret->passive = 1;
  461.     ret->returnValue = 0;
  463.     if (URL != NULL)
  464. xmlNanoFTPScanURL(ret, URL);
  466.     return(ret);
  467. }
  469. /**
  470.  * xmlNanoFTPFreeCtxt:
  471.  * @ctx:  an FTP context
  472.  *
  473.  * Frees the context after closing the connection.
  474.  */
  476. void
  477. xmlNanoFTPFreeCtxt(void * ctx) {
  478.     xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
  479.     if (ctxt == NULL) return;
  480.     if (ctxt->hostname != NULL) xmlFree(ctxt->hostname);
  481.     if (ctxt->protocol != NULL) xmlFree(ctxt->protocol);
  482.     if (ctxt->path != NULL) xmlFree(ctxt->path);
  483.     ctxt->passive = 1;
  484.     if (ctxt->controlFd >= 0) close(ctxt->controlFd);
  485.     ctxt->controlFd = -1;
  486.     xmlFree(ctxt);
  487. }
  489. /**
  490.  * Parsing of the server answer, we just extract the code.
  491.  * return 0 for errors
  492.  *     +XXX for last line of response
  493.  *     -XXX for response to be continued
  494.  */
  495. static int
  496. xmlNanoFTPParseResponse(void *ctx, char *buf, int len) {
  497.     int val = 0;
  499.     if (len < 3) return(-1);
  500.     if ((*buf >= '0') && (*buf <= '9')) 
  501.         val = val * 10 + (*buf - '0');
  502.     else
  503.         return(0);
  504.     buf++;
  505.     if ((*buf >= '0') && (*buf <= '9')) 
  506.         val = val * 10 + (*buf - '0');
  507.     else
  508.         return(0);
  509.     buf++;
  510.     if ((*buf >= '0') && (*buf <= '9')) 
  511.         val = val * 10 + (*buf - '0');
  512.     else
  513.         return(0);
  514.     buf++;
  515.     if (*buf == '-') 
  516.         return(-val);
  517.     return(val);
  518. }
  520. /**
  521.  * xmlNanoFTPReadResponse:
  522.  * @ctx:  an FTP context
  523.  * @buf:  buffer to read in
  524.  * @size:  buffer length
  525.  *
  526.  * Read the response from the FTP server after a command.
  527.  * Returns the code number
  528.  */
  529. static int
  530. xmlNanoFTPReadResponse(void *ctx, char *buf, int size) {
  531.     xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
  532.     char *ptr, *end;
  533.     int len;
  534.     int res = -1;
  536.     if (size <= 0) return(-1);
  538. get_more:
  539.     if ((len = recv(ctxt->controlFd, buf, size - 1, 0)) < 0) {
  540. close(ctxt->controlFd); ctxt->controlFd = -1;
  541.         ctxt->controlFd = -1;
  542.         return(-1);
  543.     }
  544.     if (len == 0) {
  545.         return(-1);
  546.     }
  548.     end = &buf[len];
  549.     *end = 0;
  550. #ifdef DEBUG_FTP
  551.     printf(buf);
  552. #endif
  553.     ptr = buf;
  554.     while (ptr < end) {
  555.         res = xmlNanoFTPParseResponse(ctxt, ptr, end - ptr);
  556. if (res > 0) break;
  557. if (res == 0) {
  558. #ifdef DEBUG_FTP
  559.     fprintf(stderr, "xmlNanoFTPReadResponse failed: %sn", ptr);
  560. #endif
  561.     return(-1);
  562. }
  563. while ((ptr < end) && (*ptr != 'n')) ptr++;
  564. if (ptr >= end) {
  565. #ifdef DEBUG_FTP
  566.     fprintf(stderr, "xmlNanoFTPReadResponse: unexpected end %sn", buf);
  567. #endif
  568.     return((-res) / 100);
  569. }
  570. if (*ptr != 'r') ptr++;
  571.     }
  573.     if (res < 0) goto get_more;
  575. #ifdef DEBUG_FTP
  576.     printf("Got %dn", res);
  577. #endif
  578.     return(res / 100);
  579. }
  581. /**
  582.  * xmlNanoFTPGetResponse:
  583.  * @ctx:  an FTP context
  584.  *
  585.  * Get the response from the FTP server after a command.
  586.  * Returns the code number
  587.  */
  589. int
  590. xmlNanoFTPGetResponse(void *ctx) {
  591.     char buf[16 * 1024 + 1];
  593. /**************
  594.     fd_set rfd;
  595.     struct timeval tv;
  596.     int res;
  598.     tv.tv_sec = 10;
  599.     tv.tv_usec = 0;
  600.     FD_ZERO(&rfd);
  601.     FD_SET(ctxt->controlFd, &rfd);
  602.     res = select(ctxt->controlFd + 1, &rfd, NULL, NULL, &tv);
  603.     if (res <= 0) return(res);
  604.  **************/
  606.     return(xmlNanoFTPReadResponse(ctx, buf, 16 * 1024));
  607. }
  609. /**
  610.  * xmlNanoFTPCheckResponse:
  611.  * @ctx:  an FTP context
  612.  *
  613.  * Check if there is a response from the FTP server after a command.
  614.  * Returns the code number, or 0
  615.  */
  617. int
  618. xmlNanoFTPCheckResponse(void *ctx) {
  619.     xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
  620.     char buf[1024 + 1];
  621.     fd_set rfd;
  622.     struct timeval tv;
  624.     tv.tv_sec = 0;
  625.     tv.tv_usec = 0;
  626.     FD_ZERO(&rfd);
  627.     FD_SET(ctxt->controlFd, &rfd);
  628.     switch(select(ctxt->controlFd + 1, &rfd, NULL, NULL, &tv)) {
  629. case 0:
  630.     return(0);
  631. case -1:
  632. #ifdef DEBUG_FTP
  633.     perror("select");
  634. #endif
  635.     return(-1);
  637.     }
  639.     return(xmlNanoFTPReadResponse(ctx, buf, 1024));
  640. }
  642. /**
  643.  * Send the user authentification
  644.  */
  646. static int
  647. xmlNanoFTPSendUser(void *ctx) {
  648.     xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
  649.     char buf[200];
  650.     int len;
  651.     int res;
  653.     if (ctxt->user == NULL)
  654. #ifndef HAVE_SNPRINTF
  655. len = sprintf(buf, "USER anonymousrn");
  656. #else /* HAVE_SNPRINTF */
  657. len = snprintf(buf, sizeof(buf), "USER anonymousrn");
  658. #endif /* HAVE_SNPRINTF */
  659.     else
  660. #ifndef HAVE_SNPRINTF
  661. len = sprintf(buf, "USER %srn", ctxt->user);
  662. #else /* HAVE_SNPRINTF */
  663. len = snprintf(buf, sizeof(buf), "USER %srn", ctxt->user);
  664. #endif /* HAVE_SNPRINTF */
  665. #ifdef DEBUG_FTP
  666.     printf(buf);
  667. #endif
  668.     res = send(ctxt->controlFd, buf, len, 0);
  669.     if (res < 0) return(res);
  670.     return(0);
  671. }
  673. /**
  674.  * Send the password authentification
  675.  */
  677. static int
  678. xmlNanoFTPSendPasswd(void *ctx) {
  679.     xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
  680.     char buf[200];
  681.     int len;
  682.     int res;
  684.     if (ctxt->passwd == NULL)
  685. #ifndef HAVE_SNPRINTF
  686. len = sprintf(buf, "PASS libxml@%srn", hostname);
  687. #else /* HAVE_SNPRINTF */
  688. len = snprintf(buf, sizeof(buf), "PASS libxml@%srn", hostname);
  689. #endif /* HAVE_SNPRINTF */
  690.     else
  691. #ifndef HAVE_SNPRINTF
  692. len = sprintf(buf, "PASS %srn", ctxt->passwd);
  693. #else /* HAVE_SNPRINTF */
  694. len = snprintf(buf, sizeof(buf), "PASS %srn", ctxt->passwd);
  695. #endif /* HAVE_SNPRINTF */
  696. #ifdef DEBUG_FTP
  697.     printf(buf);
  698. #endif
  699.     res = send(ctxt->controlFd, buf, len, 0);
  700.     if (res < 0) return(res);
  701.     return(0);
  702. }
  704. /**
  705.  * xmlNanoFTPQuit:
  706.  * @ctx:  an FTP context
  707.  *
  708.  * Send a QUIT command to the server
  709.  *
  710.  * Returns -1 in case of error, 0 otherwise
  711.  */
  714. int
  715. xmlNanoFTPQuit(void *ctx) {
  716.     xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
  717.     char buf[200];
  718.     int len;
  719.     int res;
  721. #ifndef HAVE_SNPRINTF
  722.     len = sprintf(buf, "QUITrn");
  723. #else /* HAVE_SNPRINTF */
  724.     len = snprintf(buf, sizeof(buf), "QUITrn");
  725. #endif /* HAVE_SNPRINTF */
  726. #ifdef DEBUG_FTP
  727.     printf(buf);
  728. #endif
  729.     res = send(ctxt->controlFd, buf, len, 0);
  730.     return(0);
  731. }
  733. /**
  734.  * xmlNanoFTPConnect:
  735.  * @ctx:  an FTP context
  736.  *
  737.  * Tries to open a control connection
  738.  *
  739.  * Returns -1 in case of error, 0 otherwise
  740.  */
  742. int
  743. xmlNanoFTPConnect(void *ctx) {
  744.     xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
  745.     struct hostent *hp;
  746.     int port;
  747.     int res;
  749.     if (ctxt == NULL)
  750. return(-1);
  751.     if (ctxt->hostname == NULL)
  752. return(-1);
  754.     /*
  755.      * do the blocking DNS query.
  756.      */
  757.     if (proxy)
  758. hp = gethostbyname(proxy);
  759.     else
  760. hp = gethostbyname(ctxt->hostname);
  761.     if (hp == NULL)
  762.         return(-1);
  764.     /*
  765.      * Prepare the socket
  766.      */
  767.     memset(&ctxt->ftpAddr, 0, sizeof(ctxt->ftpAddr));
  768.     ctxt->ftpAddr.sin_family = AF_INET;
  769.     memcpy(&ctxt->ftpAddr.sin_addr, hp->h_addr_list[0], hp->h_length);
  770.     if (proxy) {
  771.         port = proxyPort;
  772.     } else {
  773. port = ctxt->port;
  774.     }
  775.     if (port == 0)
  776. port = 21;
  777.     ctxt->ftpAddr.sin_port = htons(port);
  778.     ctxt->controlFd = socket(AF_INET, SOCK_STREAM, 0);
  779.     if (ctxt->controlFd < 0)
  780.         return(-1);
  782.     /*
  783.      * Do the connect.
  784.      */
  785.     if (connect(ctxt->controlFd, (struct sockaddr *) &ctxt->ftpAddr,
  786.                 sizeof(struct sockaddr_in)) < 0) {
  787.         close(ctxt->controlFd); ctxt->controlFd = -1;
  788.         ctxt->controlFd = -1;
  789. return(-1);
  790.     }
  792.     /*
  793.      * Wait for the HELLO from the server.
  794.      */
  795.     res = xmlNanoFTPGetResponse(ctxt);
  796.     if (res != 2) {
  797.         close(ctxt->controlFd); ctxt->controlFd = -1;
  798.         ctxt->controlFd = -1;
  799. return(-1);
  800.     }
  802.     /*
  803.      * State diagram for the login operation on the FTP server
  804.      *
  805.      * Reference: RFC 959
  806.      *
  807.      *                       1
  808.      * +---+   USER    +---+------------->+---+
  809.      * | B |---------->| W | 2       ---->| E |
  810.      * +---+           +---+------  |  -->+---+
  811.      *                  | |       | | |
  812.      *                3 | | 4,5   | | |
  813.      *    --------------   -----  | | |
  814.      *   |                      | | | |
  815.      *   |                      | | | |
  816.      *   |                 ---------  |
  817.      *   |               1|     | |   |
  818.      *   V                |     | |   |
  819.      * +---+   PASS    +---+ 2  |  ------>+---+
  820.      * |   |---------->| W |------------->| S |
  821.      * +---+           +---+   ---------->+---+
  822.      *                  | |   | |     |
  823.      *                3 | |4,5| |     |
  824.      *    --------------   --------   |
  825.      *   |                    | |  |  |
  826.      *   |                    | |  |  |
  827.      *   |                 -----------
  828.      *   |             1,3|   | |  |
  829.      *   V                |  2| |  |
  830.      * +---+   ACCT    +---+--  |   ----->+---+
  831.      * |   |---------->| W | 4,5 -------->| F |
  832.      * +---+           +---+------------->+---+
  833.      *
  834.      * Of course in case of using a proxy this get really nasty and is not
  835.      * standardized at all :-(
  836.      */
  837.     if (proxy) {
  838.         int len;
  839. char buf[400];
  841.         if (proxyUser != NULL) {
  842.     /*
  843.      * We need proxy auth
  844.      */
  845. #ifndef HAVE_SNPRINTF
  846.     len = sprintf(buf, "USER %srn", proxyUser);
  847. #else /* HAVE_SNPRINTF */
  848.     len = snprintf(buf, sizeof(buf), "USER %srn", proxyUser);
  849. #endif /* HAVE_SNPRINTF */
  850. #ifdef DEBUG_FTP
  851.     printf(buf);
  852. #endif
  853.     res = send(ctxt->controlFd, buf, len, 0);
  854.     if (res < 0) {
  855. close(ctxt->controlFd);
  856. ctxt->controlFd = -1;
  857.         return(res);
  858.     }
  859.     res = xmlNanoFTPGetResponse(ctxt);
  860.     switch (res) {
  861. case 2:
  862.     if (proxyPasswd == NULL)
  863. break;
  864. case 3:
  865.     if (proxyPasswd != NULL)
  866. #ifndef HAVE_SNPRINTF
  867. len = sprintf(buf, "PASS %srn", proxyPasswd);
  868. #else /* HAVE_SNPRINTF */
  869. len = snprintf(buf, sizeof(buf), "PASS %srn", proxyPasswd);
  870. #endif /* HAVE_SNPRINTF */
  871.     else
  872. #ifndef HAVE_SNPRINTF
  873. len = sprintf(buf, "PASS libxml@%srn",
  874.                hostname);
  875. #else /* HAVE_SNPRINTF */
  876. len = snprintf(buf, sizeof(buf), "PASS libxml@%srn",
  877.                hostname);
  878. #endif /* HAVE_SNPRINTF */
  879. #ifdef DEBUG_FTP
  880.     printf(buf);
  881. #endif
  882.     res = send(ctxt->controlFd, buf, len, 0);
  883.     if (res < 0) {
  884. close(ctxt->controlFd);
  885. ctxt->controlFd = -1;
  886. return(res);
  887.     }
  888.     res = xmlNanoFTPGetResponse(ctxt);
  889.     if (res > 3) {
  890. close(ctxt->controlFd);
  891. ctxt->controlFd = -1;
  892. return(-1);
  893.     }
  894.     break;
  895. case 1:
  896.     break;
  897. case 4:
  898. case 5:
  899. case -1:
  900. default:
  901.     close(ctxt->controlFd);
  902.     ctxt->controlFd = -1;
  903.     return(-1);
  904.     }
  905. }
  907. /*
  908.  * We assume we don't need more authentication to the proxy
  909.  * and that it succeeded :-
  910.  */
  911. switch (proxyType) {
  912.     case 0:
  913. /* we will try in seqence */
  914.     case 1:
  915. /* Using SITE command */
  916. #ifndef HAVE_SNPRINTF
  917. len = sprintf(buf, "SITE %srn", ctxt->hostname);
  918. #else /* HAVE_SNPRINTF */
  919. len = snprintf(buf, sizeof(buf), "SITE %srn", ctxt->hostname);
  920. #endif /* HAVE_SNPRINTF */
  921. #ifdef DEBUG_FTP
  922. printf(buf);
  923. #endif
  924. res = send(ctxt->controlFd, buf, len, 0);
  925. if (res < 0) {
  926.     close(ctxt->controlFd); ctxt->controlFd = -1;
  927.     ctxt->controlFd = -1;
  928.     return(res);
  929. }
  930. res = xmlNanoFTPGetResponse(ctxt);
  931. if (res == 2) {
  932.     /* we assume it worked :- 1 is error for SITE command */
  933.     proxyType = 1;
  934.     break;
  935. }    
  936. if (proxyType == 1) {
  937.     close(ctxt->controlFd); ctxt->controlFd = -1;
  938.     ctxt->controlFd = -1;
  939.     return(-1);
  940. }
  941.     case 2:
  942. /* USER user@host command */
  943. if (ctxt->user == NULL)
  944. #ifndef HAVE_SNPRINTF
  945.     len = sprintf(buf, "USER anonymous@%srn",
  946. #else /* HAVE_SNPRINTF */
  947.     len = snprintf(buf, sizeof(buf), "USER anonymous@%srn",
  948. #endif /* HAVE_SNPRINTF */
  949.            ctxt->hostname);
  950. else
  951. #ifndef HAVE_SNPRINTF
  952.     len = sprintf(buf, "USER %s@%srn",
  953. #else /* HAVE_SNPRINTF */
  954.     len = snprintf(buf, sizeof(buf), "USER %s@%srn",
  955. #endif /* HAVE_SNPRINTF */
  956.            ctxt->user, ctxt->hostname);
  957. #ifdef DEBUG_FTP
  958. printf(buf);
  959. #endif
  960. res = send(ctxt->controlFd, buf, len, 0);
  961. if (res < 0) {
  962.     close(ctxt->controlFd); ctxt->controlFd = -1;
  963.     ctxt->controlFd = -1;
  964.     return(res);
  965. }
  966. res = xmlNanoFTPGetResponse(ctxt);
  967. if ((res == 1) || (res == 2)) {
  968.     /* we assume it worked :- */
  969.     proxyType = 2;
  970.     return(0);
  971. }    
  972. if (ctxt->passwd == NULL)
  973. #ifndef HAVE_SNPRINTF
  974.     len = sprintf(buf, "PASS libxml@%srn", hostname);
  975. #else /* HAVE_SNPRINTF */
  976.     len = snprintf(buf, sizeof(buf), "PASS libxml@%srn", hostname);
  977. #endif /* HAVE_SNPRINTF */
  978. else
  979. #ifndef HAVE_SNPRINTF
  980.     len = sprintf(buf, "PASS %srn", ctxt->passwd);
  981. #else /* HAVE_SNPRINTF */
  982.     len = snprintf(buf, sizeof(buf), "PASS %srn", ctxt->passwd);
  983. #endif /* HAVE_SNPRINTF */
  984. #ifdef DEBUG_FTP
  985. printf(buf);
  986. #endif
  987. res = send(ctxt->controlFd, buf, len, 0);
  988. if (res < 0) {
  989.     close(ctxt->controlFd); ctxt->controlFd = -1;
  990.     ctxt->controlFd = -1;
  991.     return(res);
  992. }
  993. res = xmlNanoFTPGetResponse(ctxt);
  994. if ((res == 1) || (res == 2)) {
  995.     /* we assume it worked :- */
  996.     proxyType = 2;
  997.     return(0);
  998. }
  999. if (proxyType == 2) {
  1000.     close(ctxt->controlFd); ctxt->controlFd = -1;
  1001.     ctxt->controlFd = -1;
  1002.     return(-1);
  1003. }
  1004.     case 3:
  1005. /*
  1006.  * If you need support for other Proxy authentication scheme
  1007.  * send the code or at least the sequence in use.
  1008.  */
  1009.     default:
  1010. close(ctxt->controlFd); ctxt->controlFd = -1;
  1011. ctxt->controlFd = -1;
  1012. return(-1);
  1013. }
  1014.     }
  1015.     /*
  1016.      * Non-proxy handling.
  1017.      */
  1018.     res = xmlNanoFTPSendUser(ctxt);
  1019.     if (res < 0) {
  1020.         close(ctxt->controlFd); ctxt->controlFd = -1;
  1021.         ctxt->controlFd = -1;
  1022. return(-1);
  1023.     }
  1024.     res = xmlNanoFTPGetResponse(ctxt);
  1025.     switch (res) {
  1026. case 2:
  1027.     return(0);
  1028. case 3:
  1029.     break;
  1030. case 1:
  1031. case 4:
  1032. case 5:
  1033.         case -1:
  1034. default:
  1035.     close(ctxt->controlFd); ctxt->controlFd = -1;
  1036.     ctxt->controlFd = -1;
  1037.     return(-1);
  1038.     }
  1039.     res = xmlNanoFTPSendPasswd(ctxt);
  1040.     if (res < 0) {
  1041.         close(ctxt->controlFd); ctxt->controlFd = -1;
  1042.         ctxt->controlFd = -1;
  1043. return(-1);
  1044.     }
  1045.     res = xmlNanoFTPGetResponse(ctxt);
  1046.     switch (res) {
  1047. case 2:
  1048.     break;
  1049. case 3:
  1050.     fprintf(stderr, "FTP server asking for ACCNT on anonymousn");
  1051. case 1:
  1052. case 4:
  1053. case 5:
  1054.         case -1:
  1055. default:
  1056.     close(ctxt->controlFd); ctxt->controlFd = -1;
  1057.     ctxt->controlFd = -1;
  1058.     return(-1);
  1059.     }
  1061.     return(0);
  1062. }
  1064. /**
  1065.  * xmlNanoFTPConnectTo:
  1066.  * @server:  an FTP server name
  1067.  * @directory:  the port (use 21 if 0)
  1068.  *
  1069.  * Tries to open a control connection to the given server/port
  1070.  *
  1071.  * Returns and fTP context or NULL if it failed
  1072.  */
  1075. void *
  1076. xmlNanoFTPConnectTo(const char *server, int port) {
  1077.     xmlNanoFTPCtxtPtr ctxt;
  1078.     int res;
  1080.     xmlNanoFTPInit();
  1081.     if (server == NULL) 
  1082. return(NULL);
  1083.     ctxt = xmlNanoFTPNewCtxt(NULL);
  1084.     ctxt->hostname = xmlMemStrdup(server);
  1085.     if (port != 0)
  1086. ctxt->port = port;
  1087.     res = xmlNanoFTPConnect(ctxt);
  1088.     if (res < 0) {
  1089. xmlNanoFTPFreeCtxt(ctxt);
  1090. return(NULL);
  1091.     }
  1092.     return(ctxt);
  1093. }
  1095. /**
  1096.  * xmlNanoFTPGetConnection:
  1097.  * @ctx:  an FTP context
  1098.  * @directory:  a directory on the server
  1099.  *
  1100.  * Tries to change the remote directory
  1101.  *
  1102.  * Returns -1 incase of error, 1 if CWD worked, 0 if it failed
  1103.  */
  1105. int
  1106. xmlNanoFTPCwd(void *ctx, char *directory) {
  1107.     xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
  1108.     char buf[400];
  1109.     int len;
  1110.     int res;
  1112.     /*
  1113.      * Expected response code for CWD:
  1114.      *
  1115.      * CWD
  1116.      *     250
  1117.      *     500, 501, 502, 421, 530, 550
  1118.      */
  1119. #ifndef HAVE_SNPRINTF
  1120.     len = sprintf(buf, "CWD %srn", directory);
  1121. #else /* HAVE_SNPRINTF */
  1122.     len = snprintf(buf, sizeof(buf), "CWD %srn", directory);
  1123. #endif /* HAVE_SNPRINTF */
  1124. #ifdef DEBUG_FTP
  1125.     printf(buf);
  1126. #endif
  1127.     res = send(ctxt->controlFd, buf, len, 0);
  1128.     if (res < 0) return(res);
  1129.     res = xmlNanoFTPGetResponse(ctxt);
  1130.     if (res == 4) {
  1131. return(-1);
  1132.     }
  1133.     if (res == 2) return(1);
  1134.     if (res == 5) {
  1135. return(0);
  1136.     }
  1137.     return(0);
  1138. }
  1140. /**
  1141.  * xmlNanoFTPGetConnection:
  1142.  * @ctx:  an FTP context
  1143.  *
  1144.  * Try to open a data connection to the server. Currently only
  1145.  * passive mode is supported.
  1146.  *
  1147.  * Returns -1 incase of error, 0 otherwise
  1148.  */
  1150. int
  1151. xmlNanoFTPGetConnection(void *ctx) {
  1152.     xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
  1153.     char buf[200], *cur;
  1154.     int len, i;
  1155.     int res;
  1156.     unsigned char ad[6], *adp, *portp;
  1157.     unsigned int temp[6];
  1158.     struct sockaddr_in dataAddr;
  1159.     size_t dataAddrLen;
  1161.     ctxt->dataFd = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
  1162.     if (ctxt->dataFd < 0) {
  1163.         fprintf(stderr, "xmlNanoFTPGetConnection: failed to create socketn");
  1164.     }
  1165.     dataAddrLen = sizeof(dataAddr);
  1166.     memset(&dataAddr, 0, dataAddrLen);
  1167.     dataAddr.sin_family = AF_INET;
  1169.     if (ctxt->passive) {
  1170. #ifndef HAVE_SNPRINTF
  1171. len = sprintf(buf, "PASVrn");
  1172. #else /* HAVE_SNPRINTF */
  1173. len = snprintf(buf, sizeof(buf), "PASVrn");
  1174. #endif /* HAVE_SNPRINTF */
  1175. #ifdef DEBUG_FTP
  1176. printf(buf);
  1177. #endif
  1178. res = send(ctxt->controlFd, buf, len, 0);
  1179. if (res < 0) {
  1180.     close(ctxt->dataFd); ctxt->dataFd = -1;
  1181.     return(res);
  1182. }
  1183.         res = xmlNanoFTPReadResponse(ctx, buf, sizeof(buf) -1);
  1184. if (res != 2) {
  1185.     if (res == 5) {
  1186.         close(ctxt->dataFd); ctxt->dataFd = -1;
  1187. return(-1);
  1188.     } else {
  1189. /*
  1190.  * retry with an active connection
  1191.  */
  1192.         close(ctxt->dataFd); ctxt->dataFd = -1;
  1193.         ctxt->passive = 0;
  1194.     }
  1195. }
  1196. cur = &buf[4];
  1197. while (((*cur < '0') || (*cur > '9')) && *cur != '') cur++;
  1198. if (sscanf(cur, "%d,%d,%d,%d,%d,%d", &temp[0], &temp[1], &temp[2],
  1199.             &temp[3], &temp[4], &temp[5]) != 6) {
  1200.     fprintf(stderr, "Invalid answer to PASVn");
  1201.     close(ctxt->dataFd); ctxt->dataFd = -1;
  1202.     return(-1);
  1203. }
  1204. for (i=0; i<6; i++) ad[i] = (unsigned char) (temp[i] & 0xff);
  1205. memcpy(&dataAddr.sin_addr, &ad[0], 4);
  1206. memcpy(&dataAddr.sin_port, &ad[4], 2);
  1207. if (connect(ctxt->dataFd, (struct sockaddr *) &dataAddr, dataAddrLen) < 0) {
  1208.     fprintf(stderr, "Failed to create a data connectionn");
  1209.     close(ctxt->dataFd); ctxt->dataFd = -1;
  1210.     return (-1);
  1211. }
  1212.     } else {
  1213.         getsockname(ctxt->dataFd, (struct sockaddr *) &dataAddr, &dataAddrLen);
  1214. dataAddr.sin_port = 0;
  1215. if (bind(ctxt->dataFd, (struct sockaddr *) &dataAddr, dataAddrLen) < 0) {
  1216.     fprintf(stderr, "Failed to bind a portn");
  1217.     close(ctxt->dataFd); ctxt->dataFd = -1;
  1218.     return (-1);
  1219. }
  1220.         getsockname(ctxt->dataFd, (struct sockaddr *) &dataAddr, &dataAddrLen);
  1222. if (listen(ctxt->dataFd, 1) < 0) {
  1223.     fprintf(stderr, "Could not listen on port %dn",
  1224.             ntohs(dataAddr.sin_port));
  1225.     close(ctxt->dataFd); ctxt->dataFd = -1;
  1226.     return (-1);
  1227. }
  1228. adp = (unsigned char *) &dataAddr.sin_addr;
  1229. portp = (unsigned char *) &dataAddr.sin_port;
  1230. #ifndef HAVE_SNPRINTF
  1231. len = sprintf(buf, "PORT %d,%d,%d,%d,%d,%drn",
  1232.        adp[0] & 0xff, adp[1] & 0xff, adp[2] & 0xff, adp[3] & 0xff,
  1233.        portp[0] & 0xff, portp[1] & 0xff);
  1234. #else /* HAVE_SNPRINTF */
  1235. len = snprintf(buf, sizeof(buf), "PORT %d,%d,%d,%d,%d,%drn",
  1236.        adp[0] & 0xff, adp[1] & 0xff, adp[2] & 0xff, adp[3] & 0xff,
  1237.        portp[0] & 0xff, portp[1] & 0xff);
  1238. #endif /* HAVE_SNPRINTF */
  1239.         buf[sizeof(buf) - 1] = 0;
  1240. #ifdef DEBUG_FTP
  1241. printf(buf);
  1242. #endif
  1244. res = send(ctxt->controlFd, buf, len, 0);
  1245. if (res < 0) {
  1246.     close(ctxt->dataFd); ctxt->dataFd = -1;
  1247.     return(res);
  1248. }
  1249.         res = xmlNanoFTPGetResponse(ctxt);
  1250. if (res != 2) {
  1251.     close(ctxt->dataFd); ctxt->dataFd = -1;
  1252.     return(-1);
  1253.         }
  1254.     }
  1255.     return(ctxt->dataFd);
  1256.     
  1257. }
  1259. /**
  1260.  * xmlNanoFTPCloseConnection:
  1261.  * @ctx:  an FTP context
  1262.  *
  1263.  * Close the data connection from the server
  1264.  *
  1265.  * Returns -1 incase of error, 0 otherwise
  1266.  */
  1268. int
  1269. xmlNanoFTPCloseConnection(void *ctx) {
  1270.     xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
  1271.     int res;
  1272.     fd_set rfd, efd;
  1273.     struct timeval tv;
  1275.     close(ctxt->dataFd); ctxt->dataFd = -1;
  1276.     tv.tv_sec = 15;
  1277.     tv.tv_usec = 0;
  1278.     FD_ZERO(&rfd);
  1279.     FD_SET(ctxt->controlFd, &rfd);
  1280.     FD_ZERO(&efd);
  1281.     FD_SET(ctxt->controlFd, &efd);
  1282.     res = select(ctxt->controlFd + 1, &rfd, NULL, &efd, &tv);
  1283.     if (res < 0) {
  1284. #ifdef DEBUG_FTP
  1285. perror("select");
  1286. #endif
  1287. close(ctxt->controlFd); ctxt->controlFd = -1;
  1288. return(-1);
  1289.     }
  1290.     if (res == 0) {
  1291. fprintf(stderr, "xmlNanoFTPCloseConnection: timeoutn");
  1292. close(ctxt->controlFd); ctxt->controlFd = -1;
  1293.     } else {
  1294. res = xmlNanoFTPGetResponse(ctxt);
  1295. if (res != 2) {
  1296.     close(ctxt->controlFd); ctxt->controlFd = -1;
  1297.     return(-1);
  1298. }
  1299.     }
  1300.     return(0);
  1301. }
  1303. /**
  1304.  * xmlNanoFTPParseList:
  1305.  * @list:  some data listing received from the server
  1306.  * @callback:  the user callback
  1307.  * @userData:  the user callback data
  1308.  *
  1309.  * Parse at most one entry from the listing. 
  1310.  *
  1311.  * Returns -1 incase of error, the lenght of data parsed otherwise
  1312.  */
  1314. static int
  1315. xmlNanoFTPParseList(const char *list, ftpListCallback callback, void *userData) {
  1316.     const char *cur = list;
  1317.     char filename[151];
  1318.     char attrib[11];
  1319.     char owner[11];
  1320.     char group[11];
  1321.     char month[4];
  1322.     int year = 0;
  1323.     int minute = 0;
  1324.     int hour = 0;
  1325.     int day = 0;
  1326.     unsigned long size = 0;
  1327.     int links = 0;
  1328.     int i;
  1330.     if (!strncmp(cur, "total", 5)) {
  1331.         cur += 5;
  1332. while (*cur == ' ') cur++;
  1333. while ((*cur >= '0') && (*cur <= '9'))
  1334.     links = (links * 10) + (*cur++ - '0');
  1335. while ((*cur == ' ') || (*cur == 'n')  || (*cur == 'r'))
  1336.     cur++;
  1337. return(cur - list);
  1338.     } else if (*list == '+') {
  1339. return(0);
  1340.     } else {
  1341. while ((*cur == ' ') || (*cur == 'n')  || (*cur == 'r'))
  1342.     cur++;
  1343. if (*cur == 0) return(0);
  1344. i = 0;
  1345. while (*cur != ' ') {
  1346.     if (i < 10) 
  1347. attrib[i++] = *cur;
  1348.     cur++;
  1349.     if (*cur == 0) return(0);
  1350. }
  1351. attrib[10] = 0;
  1352. while (*cur == ' ') cur++;
  1353. if (*cur == 0) return(0);
  1354. while ((*cur >= '0') && (*cur <= '9'))
  1355.     links = (links * 10) + (*cur++ - '0');
  1356. while (*cur == ' ') cur++;
  1357. if (*cur == 0) return(0);
  1358. i = 0;
  1359. while (*cur != ' ') {
  1360.     if (i < 10) 
  1361. owner[i++] = *cur;
  1362.     cur++;
  1363.     if (*cur == 0) return(0);
  1364. }
  1365. owner[i] = 0;
  1366. while (*cur == ' ') cur++;
  1367. if (*cur == 0) return(0);
  1368. i = 0;
  1369. while (*cur != ' ') {
  1370.     if (i < 10) 
  1371. group[i++] = *cur;
  1372.     cur++;
  1373.     if (*cur == 0) return(0);
  1374. }
  1375. group[i] = 0;
  1376. while (*cur == ' ') cur++;
  1377. if (*cur == 0) return(0);
  1378. while ((*cur >= '0') && (*cur <= '9'))
  1379.     size = (size * 10) + (*cur++ - '0');
  1380. while (*cur == ' ') cur++;
  1381. if (*cur == 0) return(0);
  1382. i = 0;
  1383. while (*cur != ' ') {
  1384.     if (i < 3)
  1385. month[i++] = *cur;
  1386.     cur++;
  1387.     if (*cur == 0) return(0);
  1388. }
  1389. month[i] = 0;
  1390. while (*cur == ' ') cur++;
  1391. if (*cur == 0) return(0);
  1392.         while ((*cur >= '0') && (*cur <= '9'))
  1393.     day = (day * 10) + (*cur++ - '0');
  1394. while (*cur == ' ') cur++;
  1395. if (*cur == 0) return(0);
  1396. if ((cur[1] == 0) || (cur[2] == 0)) return(0);
  1397. if ((cur[1] == ':') || (cur[2] == ':')) {
  1398.     while ((*cur >= '0') && (*cur <= '9'))
  1399. hour = (hour * 10) + (*cur++ - '0');
  1400.     if (*cur == ':') cur++;
  1401.     while ((*cur >= '0') && (*cur <= '9'))
  1402. minute = (minute * 10) + (*cur++ - '0');
  1403. } else {
  1404.     while ((*cur >= '0') && (*cur <= '9'))
  1405. year = (year * 10) + (*cur++ - '0');
  1406. }
  1407. while (*cur == ' ') cur++;
  1408. if (*cur == 0) return(0);
  1409. i = 0;
  1410. while ((*cur != 'n')  && (*cur != 'r')) {
  1411.     if (i < 150)
  1412. filename[i++] = *cur;
  1413.     cur++;
  1414.     if (*cur == 0) return(0);
  1415. }
  1416. filename[i] = 0;
  1417. if ((*cur != 'n') && (*cur != 'r'))
  1418.     return(0);
  1419. while ((*cur == 'n')  || (*cur == 'r'))
  1420.     cur++;
  1421.     }
  1422.     if (callback != NULL) {
  1423.         callback(userData, filename, attrib, owner, group, size, links,
  1424.  year, month, day, hour, minute);
  1425.     }
  1426.     return(cur - list);
  1427. }
  1429. /**
  1430.  * xmlNanoFTPList:
  1431.  * @ctx:  an FTP context
  1432.  * @callback:  the user callback
  1433.  * @userData:  the user callback data
  1434.  * @filename:  optional files to list
  1435.  *
  1436.  * Do a listing on the server. All files info are passed back
  1437.  * in the callbacks.
  1438.  *
  1439.  * Returns -1 incase of error, 0 otherwise
  1440.  */
  1442. int
  1443. xmlNanoFTPList(void *ctx, ftpListCallback callback, void *userData,
  1444.        char *filename) {
  1445.     xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
  1446.     char buf[4096 + 1];
  1447.     int len, res;
  1448.     int index = 0, base;
  1449.     fd_set rfd, efd;
  1450.     struct timeval tv;
  1452.     if (filename == NULL) {
  1453.         if (xmlNanoFTPCwd(ctxt, ctxt->path) < 1)
  1454.     return(-1);
  1455. ctxt->dataFd = xmlNanoFTPGetConnection(ctxt);
  1456. #ifndef HAVE_SNPRINTF
  1457. len = sprintf(buf, "LIST -Lrn");
  1458. #else /* HAVE_SNPRINTF */
  1459. len = snprintf(buf, sizeof(buf), "LIST -Lrn");
  1460. #endif /* HAVE_SNPRINTF */
  1461.     } else {
  1462. if (filename[0] != '/') {
  1463.     if (xmlNanoFTPCwd(ctxt, ctxt->path) < 1)
  1464. return(-1);
  1465. }
  1466. ctxt->dataFd = xmlNanoFTPGetConnection(ctxt);
  1467. #ifndef HAVE_SNPRINTF
  1468. len = sprintf(buf, "LIST -L %srn", filename);
  1469. #else /* HAVE_SNPRINTF */
  1470. len = snprintf(buf, sizeof(buf), "LIST -L %srn", filename);
  1471. #endif /* HAVE_SNPRINTF */
  1472.     }
  1473. #ifdef DEBUG_FTP
  1474.     printf(buf);
  1475. #endif
  1476.     res = send(ctxt->controlFd, buf, len, 0);
  1477.     if (res < 0) {
  1478. close(ctxt->dataFd); ctxt->dataFd = -1;
  1479. return(res);
  1480.     }
  1481.     res = xmlNanoFTPReadResponse(ctxt, buf, sizeof(buf) -1);
  1482.     if (res != 1) {
  1483. close(ctxt->dataFd); ctxt->dataFd = -1;
  1484. return(-res);
  1485.     }
  1487.     do {
  1488. tv.tv_sec = 1;
  1489. tv.tv_usec = 0;
  1490. FD_ZERO(&rfd);
  1491. FD_SET(ctxt->dataFd, &rfd);
  1492. FD_ZERO(&efd);
  1493. FD_SET(ctxt->dataFd, &efd);
  1494. res = select(ctxt->dataFd + 1, &rfd, NULL, &efd, &tv);
  1495. if (res < 0) {
  1496. #ifdef DEBUG_FTP
  1497.     perror("select");
  1498. #endif
  1499.     close(ctxt->dataFd); ctxt->dataFd = -1;
  1500.     return(-1);
  1501. }
  1502. if (res == 0) {
  1503.     res = xmlNanoFTPCheckResponse(ctxt);
  1504.     if (res < 0) {
  1505. close(ctxt->dataFd); ctxt->dataFd = -1;
  1506. ctxt->dataFd = -1;
  1507. return(-1);
  1508.     }
  1509.     if (res == 2) {
  1510. close(ctxt->dataFd); ctxt->dataFd = -1;
  1511. return(0);
  1512.     }
  1514.     continue;
  1515. }
  1517. if ((len = read(ctxt->dataFd, &buf[index], sizeof(buf) - (index + 1))) < 0) {
  1518. #ifdef DEBUG_FTP
  1519.     perror("read");
  1520. #endif
  1521.     close(ctxt->dataFd); ctxt->dataFd = -1;
  1522.     ctxt->dataFd = -1;
  1523.     return(-1);
  1524. }
  1525. #ifdef DEBUG_FTP
  1526.         write(1, &buf[index], len);
  1527. #endif
  1528. index += len;
  1529. buf[index] = 0;
  1530. base = 0;
  1531. do {
  1532.     res = xmlNanoFTPParseList(&buf[base], callback, userData);
  1533.     base += res;
  1534. } while (res > 0);
  1536. memmove(&buf[0], &buf[base], index - base);
  1537. index -= base;
  1538.     } while (len != 0);
  1539.     xmlNanoFTPCloseConnection(ctxt);
  1540.     return(0);
  1541. }
  1543. /**
  1544.  * xmlNanoFTPGetSocket:
  1545.  * @ctx:  an FTP context
  1546.  * @filename:  the file to retrieve (or NULL if path is in context).
  1547.  *
  1548.  * Initiate fetch of the given file from the server.
  1549.  *
  1550.  * Returns the socket for the data connection, or <0 in case of error
  1551.  */
  1554. int
  1555. xmlNanoFTPGetSocket(void *ctx, const char *filename) {
  1556.     xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
  1557.     char buf[300];
  1558.     int res, len;
  1559.     if ((filename == NULL) && (ctxt->path == NULL))
  1560. return(-1);
  1561.     ctxt->dataFd = xmlNanoFTPGetConnection(ctxt);
  1563. #ifndef HAVE_SNPRINTF
  1564.     len = sprintf(buf, "TYPE Irn");
  1565. #else /* HAVE_SNPRINTF */
  1566.     len = snprintf(buf, sizeof(buf), "TYPE Irn");
  1567. #endif /* HAVE_SNPRINTF */
  1568. #ifdef DEBUG_FTP
  1569.     printf(buf);
  1570. #endif
  1571.     res = send(ctxt->controlFd, buf, len, 0);
  1572.     if (res < 0) {
  1573. close(ctxt->dataFd); ctxt->dataFd = -1;
  1574. return(res);
  1575.     }
  1576.     res = xmlNanoFTPReadResponse(ctxt, buf, sizeof(buf) -1);
  1577.     if (res != 2) {
  1578. close(ctxt->dataFd); ctxt->dataFd = -1;
  1579. return(-res);
  1580.     }
  1581.     if (filename == NULL)
  1582. #ifndef HAVE_SNPRINTF
  1583. len = sprintf(buf, "RETR %srn", ctxt->path);
  1584. #else /* HAVE_SNPRINTF */
  1585. len = snprintf(buf, sizeof(buf), "RETR %srn", ctxt->path);
  1586. #endif /* HAVE_SNPRINTF */
  1587.     else
  1588. #ifndef HAVE_SNPRINTF
  1589. len = sprintf(buf, "RETR %srn", filename);
  1590. #else /* HAVE_SNPRINTF */
  1591. len = snprintf(buf, sizeof(buf), "RETR %srn", filename);
  1592. #endif /* HAVE_SNPRINTF */
  1593. #ifdef DEBUG_FTP
  1594.     printf(buf);
  1595. #endif
  1596.     res = send(ctxt->controlFd, buf, len, 0);
  1597.     if (res < 0) {
  1598. close(ctxt->dataFd); ctxt->dataFd = -1;
  1599. return(res);
  1600.     }
  1601.     res = xmlNanoFTPReadResponse(ctxt, buf, sizeof(buf) -1);
  1602.     if (res != 1) {
  1603. close(ctxt->dataFd); ctxt->dataFd = -1;
  1604. return(-res);
  1605.     }
  1606.     return(ctxt->dataFd);
  1607. }
  1609. /**
  1610.  * xmlNanoFTPGet:
  1611.  * @ctx:  an FTP context
  1612.  * @callback:  the user callback
  1613.  * @userData:  the user callback data
  1614.  * @filename:  the file to retrieve
  1615.  *
  1616.  * Fetch the given file from the server. All data are passed back
  1617.  * in the callbacks. The last callback has a size of 0 block.
  1618.  *
  1619.  * Returns -1 incase of error, 0 otherwise
  1620.  */
  1622. int
  1623. xmlNanoFTPGet(void *ctx, ftpDataCallback callback, void *userData,
  1624.       const char *filename) {
  1625.     xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
  1626.     char buf[4096];
  1627.     int len = 0, res;
  1628.     fd_set rfd;
  1629.     struct timeval tv;
  1631.     if ((filename == NULL) && (ctxt->path == NULL))
  1632. return(-1);
  1633.     if (callback == NULL)
  1634. return(-1);
  1635.     if (xmlNanoFTPGetSocket(ctxt, filename) < 0)
  1636. return(-1);
  1638.     do {
  1639. tv.tv_sec = 1;
  1640. tv.tv_usec = 0;
  1641. FD_ZERO(&rfd);
  1642. FD_SET(ctxt->dataFd, &rfd);
  1643. res = select(ctxt->dataFd + 1, &rfd, NULL, NULL, &tv);
  1644. if (res < 0) {
  1645. #ifdef DEBUG_FTP
  1646.     perror("select");
  1647. #endif
  1648.     close(ctxt->dataFd); ctxt->dataFd = -1;
  1649.     return(-1);
  1650. }
  1651. if (res == 0) {
  1652.     res = xmlNanoFTPCheckResponse(ctxt);
  1653.     if (res < 0) {
  1654. close(ctxt->dataFd); ctxt->dataFd = -1;
  1655. ctxt->dataFd = -1;
  1656. return(-1);
  1657.     }
  1658.     if (res == 2) {
  1659. close(ctxt->dataFd); ctxt->dataFd = -1;
  1660. return(0);
  1661.     }
  1663.     continue;
  1664. }
  1665. if ((len = read(ctxt->dataFd, &buf, sizeof(buf))) < 0) {
  1666.     callback(userData, buf, len);
  1667.     close(ctxt->dataFd); ctxt->dataFd = -1;
  1668.     return(-1);
  1669. }
  1670. callback(userData, buf, len);
  1671.     } while (len != 0);
  1673.     return(xmlNanoFTPCloseConnection(ctxt));
  1674. }
  1676. /**
  1677.  * xmlNanoFTPRead:
  1678.  * @ctx:  the FTP context
  1679.  * @dest:  a buffer
  1680.  * @len:  the buffer length
  1681.  *
  1682.  * This function tries to read @len bytes from the existing FTP connection
  1683.  * and saves them in @dest. This is a blocking call.
  1684.  *
  1685.  * Returns the number of byte read. 0 is an indication of an end of connection.
  1686.  *         -1 indicates a parameter error.
  1687.  */
  1688. int
  1689. xmlNanoFTPRead(void *ctx, void *dest, int len) {
  1690.     xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
  1692.     if (ctx == NULL) return(-1);
  1693.     if (ctxt->dataFd < 0) return(0);
  1694.     if (dest == NULL) return(-1);
  1695.     if (len <= 0) return(0);
  1697.     len = read(ctxt->dataFd, dest, len);
  1698. #ifdef DEBUG_FTP
  1699.     printf("Read %d bytesn", len);
  1700. #endif
  1701.     if (len <= 0) {
  1702. xmlNanoFTPCloseConnection(ctxt);
  1703.     }
  1704.     return(len);
  1705. }
  1707. /**
  1708.  * xmlNanoFTPOpen:
  1709.  * @URL: the URL to the resource
  1710.  *
  1711.  * Start to fetch the given ftp:// resource
  1712.  *
  1713.  * Returns an FTP context, or NULL 
  1714.  */
  1716. void *
  1717. xmlNanoFTPOpen(const char *URL) {
  1718.     xmlNanoFTPCtxtPtr ctxt;
  1719.     int sock;
  1721.     xmlNanoFTPInit();
  1722.     if (URL == NULL) return(NULL);
  1723.     if (strncmp("ftp://", URL, 6)) return(NULL);
  1725.     ctxt = xmlNanoFTPNewCtxt(URL);
  1726.     if (ctxt == NULL) return(NULL);
  1727.     if (xmlNanoFTPConnect(ctxt) < 0) {
  1728. xmlNanoFTPFreeCtxt(ctxt);
  1729. return(NULL);
  1730.     }
  1731.     sock = xmlNanoFTPGetSocket(ctxt, ctxt->path);
  1732.     if (sock < 0) {
  1733. xmlNanoFTPFreeCtxt(ctxt);
  1734. return(NULL);
  1735.     }
  1736.     return(ctxt);
  1737. }
  1739. /**
  1740.  * xmlNanoFTPClose:
  1741.  * @ctx: an FTP context
  1742.  *
  1743.  * Close the connection and both control and transport
  1744.  *
  1745.  * Returns -1 incase of error, 0 otherwise
  1746.  */
  1748. int
  1749. xmlNanoFTPClose(void *ctx) {
  1750.     xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
  1752.     if (ctxt == NULL)
  1753. return(-1);
  1755.     if (ctxt->dataFd >= 0) {
  1756. close(ctxt->dataFd);
  1757. ctxt->dataFd = -1;
  1758.     }
  1759.     if (ctxt->controlFd >= 0) {
  1760. xmlNanoFTPQuit(ctxt);
  1761. close(ctxt->controlFd);
  1762. ctxt->controlFd = -1;
  1763.     }
  1764.     xmlNanoFTPFreeCtxt(ctxt);
  1765.     return(0);
  1766. }
  1768. #ifdef STANDALONE
  1769. /************************************************************************
  1770.  *  *
  1771.  *  Basic test in Standalone mode *
  1772.  *  *
  1773.  ************************************************************************/
  1774. void ftpList(void *userData, const char *filename, const char* attrib,
  1775.      const char *owner, const char *group, unsigned long size, int links,
  1776.      int year, const char *month, int day, int hour, int minute) {
  1777.     printf("%s %s %s %ld %sn", attrib, owner, group, size, filename);
  1778. }
  1779. void ftpData(void *userData, const char *data, int len) {
  1780.     if (userData == NULL) return;
  1781.     if (len <= 0) {
  1782. fclose(userData);
  1783. return;
  1784.     }
  1785.     fwrite(data, len, 1, userData);
  1786. }
  1788. int main(int argc, char **argv) {
  1789.     void *ctxt;
  1790.     FILE *output;
  1791.     char *tstfile = NULL;
  1793.     xmlNanoFTPInit();
  1794.     if (argc > 1) {
  1795. ctxt = xmlNanoFTPNewCtxt(argv[1]);
  1796. if (xmlNanoFTPConnect(ctxt) < 0) {
  1797.     fprintf(stderr, "Couldn't connect to %sn", argv[1]);
  1798.     exit(1);
  1799. }
  1800. if (argc > 2)
  1801.     tstfile = argv[2];
  1802.     } else
  1803. ctxt = xmlNanoFTPConnectTo("localhost", 0);
  1804.     if (ctxt == NULL) {
  1805.         fprintf(stderr, "Couldn't connect to localhostn");
  1806.         exit(1);
  1807.     }
  1808.     xmlNanoFTPList(ctxt, ftpList, NULL, tstfile);
  1809.     output = fopen("/tmp/tstdata", "w");
  1810.     if (output != NULL) {
  1811. if (xmlNanoFTPGet(ctxt, ftpData, (void *) output, tstfile) < 0)
  1812.     fprintf(stderr, "Failed to get filen");
  1814.     }
  1815.     xmlNanoFTPClose(ctxt);
  1816.     xmlMemoryDump();
  1817.     exit(0);
  1818. }
  1819. #endif /* STANDALONE */
  1820. #else /* !LIBXML_FTP_ENABLED */
  1821. #ifdef STANDALONE
  1822. #include <stdio.h>
  1823. int main(int argc, char **argv) {
  1824.     printf("%s : FTP support not compiled inn", argv[0]);
  1825.     return(0);
  1826. }
  1827. #endif /* STANDALONE */
  1828. #endif /* LIBXML_FTP_ENABLED */