1/*
2 * nanoftp.c: basic FTP client support
3 *
4 *  Reference: RFC 959
5 */
6
7#ifdef TESTING
8#define STANDALONE
9#define HAVE_STDLIB_H
10#define HAVE_UNISTD_H
11#define HAVE_SYS_SOCKET_H
12#define HAVE_NETINET_IN_H
13#define HAVE_NETDB_H
14#define HAVE_SYS_TIME_H
15#else /* TESTING */
16#define NEED_SOCKETS
17#endif /* TESTING */
18
19#define IN_LIBXML
20#include "libxml.h"
21
22#ifdef LIBXML_FTP_ENABLED
23#include <string.h>
24
25#ifdef HAVE_STDLIB_H
26#include <stdlib.h>
27#endif
28#ifdef HAVE_UNISTD_H
29#include <unistd.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_SYS_SOCKET_H
56#include <sys/socket.h>
57#endif
58#ifdef HAVE_SYS_TYPES_H
59#include <sys/types.h>
60#endif
61#ifdef HAVE_STRINGS_H
62#include <strings.h>
63#endif
64
65#include <libxml/xmlmemory.h>
66#include <libxml/parser.h>
67#include <libxml/xmlerror.h>
68#include <libxml/uri.h>
69#include <libxml/nanoftp.h>
70#include <libxml/globals.h>
71
72/* #define DEBUG_FTP 1  */
73#ifdef STANDALONE
74#ifndef DEBUG_FTP
75#define DEBUG_FTP 1
76#endif
77#endif
78
79
80#if defined(__MINGW32__) || defined(_WIN32_WCE)
81#define _WINSOCKAPI_
82#include <wsockcompat.h>
83#include <winsock2.h>
84#undef XML_SOCKLEN_T
85#define XML_SOCKLEN_T unsigned int
86#endif
87
88/**
89 * A couple portability macros
90 */
91#ifndef _WINSOCKAPI_
92#if !defined(__BEOS__) || defined(__HAIKU__)
93#define closesocket(s) close(s)
94#endif
95#define SOCKET int
96#endif
97
98#ifdef __BEOS__
99#ifndef PF_INET
100#define PF_INET AF_INET
101#endif
102#endif
103
104#ifdef _AIX
105#ifdef HAVE_BROKEN_SS_FAMILY
106#define ss_family __ss_family
107#endif
108#endif
109
110#ifndef XML_SOCKLEN_T
111#define XML_SOCKLEN_T unsigned int
112#endif
113
114#define FTP_COMMAND_OK		200
115#define FTP_SYNTAX_ERROR	500
116#define FTP_GET_PASSWD		331
117#define FTP_BUF_SIZE		1024
118
119#define XML_NANO_MAX_URLBUF	4096
120
121typedef struct xmlNanoFTPCtxt {
122    char *protocol;	/* the protocol name */
123    char *hostname;	/* the host name */
124    int port;		/* the port */
125    char *path;		/* the path within the URL */
126    char *user;		/* user string */
127    char *passwd;	/* passwd string */
128#ifdef SUPPORT_IP6
129    struct sockaddr_storage ftpAddr; /* this is large enough to hold IPv6 address*/
130#else
131    struct sockaddr_in ftpAddr; /* the socket address struct */
132#endif
133    int passive;	/* currently we support only passive !!! */
134    SOCKET controlFd;	/* the file descriptor for the control socket */
135    SOCKET dataFd;	/* the file descriptor for the data socket */
136    int state;		/* WRITE / READ / CLOSED */
137    int returnValue;	/* the protocol return value */
138    /* buffer for data received from the control connection */
139    char controlBuf[FTP_BUF_SIZE + 1];
140    int controlBufIndex;
141    int controlBufUsed;
142    int controlBufAnswer;
143} xmlNanoFTPCtxt, *xmlNanoFTPCtxtPtr;
144
145static int initialized = 0;
146static char *proxy = NULL;	/* the proxy name if any */
147static int proxyPort = 0;	/* the proxy port if any */
148static char *proxyUser = NULL;	/* user for proxy authentication */
149static char *proxyPasswd = NULL;/* passwd for proxy authentication */
150static int proxyType = 0;	/* uses TYPE or a@b ? */
151
152#ifdef SUPPORT_IP6
153static
154int have_ipv6(void) {
155    int s;
156
157    s = socket (AF_INET6, SOCK_STREAM, 0);
158    if (s != -1) {
159	close (s);
160	return (1);
161    }
162    return (0);
163}
164#endif
165
166/**
167 * xmlFTPErrMemory:
168 * @extra:  extra informations
169 *
170 * Handle an out of memory condition
171 */
172static void
173xmlFTPErrMemory(const char *extra)
174{
175    __xmlSimpleError(XML_FROM_FTP, XML_ERR_NO_MEMORY, NULL, NULL, extra);
176}
177
178/**
179 * xmlNanoFTPInit:
180 *
181 * Initialize the FTP protocol layer.
182 * Currently it just checks for proxy informations,
183 * and get the hostname
184 */
185
186void
187xmlNanoFTPInit(void) {
188    const char *env;
189#ifdef _WINSOCKAPI_
190    WSADATA wsaData;
191#endif
192
193    if (initialized)
194	return;
195
196#ifdef _WINSOCKAPI_
197    if (WSAStartup(MAKEWORD(1, 1), &wsaData) != 0)
198	return;
199#endif
200
201    proxyPort = 21;
202    env = getenv("no_proxy");
203    if (env && ((env[0] == '*' ) && (env[1] == 0)))
204	return;
205    env = getenv("ftp_proxy");
206    if (env != NULL) {
207	xmlNanoFTPScanProxy(env);
208    } else {
209	env = getenv("FTP_PROXY");
210	if (env != NULL) {
211	    xmlNanoFTPScanProxy(env);
212	}
213    }
214    env = getenv("ftp_proxy_user");
215    if (env != NULL) {
216	proxyUser = xmlMemStrdup(env);
217    }
218    env = getenv("ftp_proxy_password");
219    if (env != NULL) {
220	proxyPasswd = xmlMemStrdup(env);
221    }
222    initialized = 1;
223}
224
225/**
226 * xmlNanoFTPCleanup:
227 *
228 * Cleanup the FTP protocol layer. This cleanup proxy informations.
229 */
230
231void
232xmlNanoFTPCleanup(void) {
233    if (proxy != NULL) {
234	xmlFree(proxy);
235	proxy = NULL;
236    }
237    if (proxyUser != NULL) {
238	xmlFree(proxyUser);
239	proxyUser = NULL;
240    }
241    if (proxyPasswd != NULL) {
242	xmlFree(proxyPasswd);
243	proxyPasswd = NULL;
244    }
245#ifdef _WINSOCKAPI_
246    if (initialized)
247	WSACleanup();
248#endif
249    initialized = 0;
250}
251
252/**
253 * xmlNanoFTPProxy:
254 * @host:  the proxy host name
255 * @port:  the proxy port
256 * @user:  the proxy user name
257 * @passwd:  the proxy password
258 * @type:  the type of proxy 1 for using SITE, 2 for USER a@b
259 *
260 * Setup the FTP proxy informations.
261 * This can also be done by using ftp_proxy ftp_proxy_user and
262 * ftp_proxy_password environment variables.
263 */
264
265void
266xmlNanoFTPProxy(const char *host, int port, const char *user,
267	        const char *passwd, int type) {
268    if (proxy != NULL) {
269	xmlFree(proxy);
270	proxy = NULL;
271    }
272    if (proxyUser != NULL) {
273	xmlFree(proxyUser);
274	proxyUser = NULL;
275    }
276    if (proxyPasswd != NULL) {
277	xmlFree(proxyPasswd);
278	proxyPasswd = NULL;
279    }
280    if (host)
281	proxy = xmlMemStrdup(host);
282    if (user)
283	proxyUser = xmlMemStrdup(user);
284    if (passwd)
285	proxyPasswd = xmlMemStrdup(passwd);
286    proxyPort = port;
287    proxyType = type;
288}
289
290/**
291 * xmlNanoFTPScanURL:
292 * @ctx:  an FTP context
293 * @URL:  The URL used to initialize the context
294 *
295 * (Re)Initialize an FTP context by parsing the URL and finding
296 * the protocol host port and path it indicates.
297 */
298
299static void
300xmlNanoFTPScanURL(void *ctx, const char *URL) {
301    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
302    xmlURIPtr uri;
303
304    /*
305     * Clear any existing data from the context
306     */
307    if (ctxt->protocol != NULL) {
308        xmlFree(ctxt->protocol);
309	ctxt->protocol = NULL;
310    }
311    if (ctxt->hostname != NULL) {
312        xmlFree(ctxt->hostname);
313	ctxt->hostname = NULL;
314    }
315    if (ctxt->path != NULL) {
316        xmlFree(ctxt->path);
317	ctxt->path = NULL;
318    }
319    if (URL == NULL) return;
320
321    uri = xmlParseURIRaw(URL, 1);
322    if (uri == NULL)
323	return;
324
325    if ((uri->scheme == NULL) || (uri->server == NULL)) {
326	xmlFreeURI(uri);
327	return;
328    }
329
330    ctxt->protocol = xmlMemStrdup(uri->scheme);
331    ctxt->hostname = xmlMemStrdup(uri->server);
332    if (uri->path != NULL)
333	ctxt->path = xmlMemStrdup(uri->path);
334    else
335	ctxt->path = xmlMemStrdup("/");
336    if (uri->port != 0)
337	ctxt->port = uri->port;
338
339    if (uri->user != NULL) {
340	char *cptr;
341	if ((cptr=strchr(uri->user, ':')) == NULL)
342	    ctxt->user = xmlMemStrdup(uri->user);
343	else {
344	    ctxt->user = (char *)xmlStrndup((xmlChar *)uri->user,
345			    (cptr - uri->user));
346	    ctxt->passwd = xmlMemStrdup(cptr+1);
347	}
348    }
349
350    xmlFreeURI(uri);
351
352}
353
354/**
355 * xmlNanoFTPUpdateURL:
356 * @ctx:  an FTP context
357 * @URL:  The URL used to update the context
358 *
359 * Update an FTP context by parsing the URL and finding
360 * new path it indicates. If there is an error in the
361 * protocol, hostname, port or other information, the
362 * error is raised. It indicates a new connection has to
363 * be established.
364 *
365 * Returns 0 if Ok, -1 in case of error (other host).
366 */
367
368int
369xmlNanoFTPUpdateURL(void *ctx, const char *URL) {
370    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
371    xmlURIPtr uri;
372
373    if (URL == NULL)
374	return(-1);
375    if (ctxt == NULL)
376	return(-1);
377    if (ctxt->protocol == NULL)
378	return(-1);
379    if (ctxt->hostname == NULL)
380	return(-1);
381
382    uri = xmlParseURIRaw(URL, 1);
383    if (uri == NULL)
384	return(-1);
385
386    if ((uri->scheme == NULL) || (uri->server == NULL)) {
387	xmlFreeURI(uri);
388	return(-1);
389    }
390    if ((strcmp(ctxt->protocol, uri->scheme)) ||
391	(strcmp(ctxt->hostname, uri->server)) ||
392	((uri->port != 0) && (ctxt->port != uri->port))) {
393	xmlFreeURI(uri);
394	return(-1);
395    }
396
397    if (uri->port != 0)
398	ctxt->port = uri->port;
399
400    if (ctxt->path != NULL) {
401	xmlFree(ctxt->path);
402	ctxt->path = NULL;
403    }
404
405    if (uri->path == NULL)
406        ctxt->path = xmlMemStrdup("/");
407    else
408	ctxt->path = xmlMemStrdup(uri->path);
409
410    xmlFreeURI(uri);
411
412    return(0);
413}
414
415/**
416 * xmlNanoFTPScanProxy:
417 * @URL:  The proxy URL used to initialize the proxy context
418 *
419 * (Re)Initialize the FTP Proxy context by parsing the URL and finding
420 * the protocol host port it indicates.
421 * Should be like ftp://myproxy/ or ftp://myproxy:3128/
422 * A NULL URL cleans up proxy informations.
423 */
424
425void
426xmlNanoFTPScanProxy(const char *URL) {
427    xmlURIPtr uri;
428
429    if (proxy != NULL) {
430        xmlFree(proxy);
431	proxy = NULL;
432    }
433    proxyPort = 0;
434
435#ifdef DEBUG_FTP
436    if (URL == NULL)
437	xmlGenericError(xmlGenericErrorContext,
438		"Removing FTP proxy info\n");
439    else
440	xmlGenericError(xmlGenericErrorContext,
441		"Using FTP proxy %s\n", URL);
442#endif
443    if (URL == NULL) return;
444
445    uri = xmlParseURIRaw(URL, 1);
446    if ((uri == NULL) || (uri->scheme == NULL) ||
447	(strcmp(uri->scheme, "ftp")) || (uri->server == NULL)) {
448	__xmlIOErr(XML_FROM_FTP, XML_FTP_URL_SYNTAX, "Syntax Error\n");
449	if (uri != NULL)
450	    xmlFreeURI(uri);
451	return;
452    }
453
454    proxy = xmlMemStrdup(uri->server);
455    if (uri->port != 0)
456	proxyPort = uri->port;
457
458    xmlFreeURI(uri);
459}
460
461/**
462 * xmlNanoFTPNewCtxt:
463 * @URL:  The URL used to initialize the context
464 *
465 * Allocate and initialize a new FTP context.
466 *
467 * Returns an FTP context or NULL in case of error.
468 */
469
470void*
471xmlNanoFTPNewCtxt(const char *URL) {
472    xmlNanoFTPCtxtPtr ret;
473    char *unescaped;
474
475    ret = (xmlNanoFTPCtxtPtr) xmlMalloc(sizeof(xmlNanoFTPCtxt));
476    if (ret == NULL) {
477        xmlFTPErrMemory("allocating FTP context");
478        return(NULL);
479    }
480
481    memset(ret, 0, sizeof(xmlNanoFTPCtxt));
482    ret->port = 21;
483    ret->passive = 1;
484    ret->returnValue = 0;
485    ret->controlBufIndex = 0;
486    ret->controlBufUsed = 0;
487    ret->controlFd = -1;
488
489    unescaped = xmlURIUnescapeString(URL, 0, NULL);
490    if (unescaped != NULL) {
491	xmlNanoFTPScanURL(ret, unescaped);
492	xmlFree(unescaped);
493    } else if (URL != NULL)
494	xmlNanoFTPScanURL(ret, URL);
495
496    return(ret);
497}
498
499/**
500 * xmlNanoFTPFreeCtxt:
501 * @ctx:  an FTP context
502 *
503 * Frees the context after closing the connection.
504 */
505
506void
507xmlNanoFTPFreeCtxt(void * ctx) {
508    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
509    if (ctxt == NULL) return;
510    if (ctxt->hostname != NULL) xmlFree(ctxt->hostname);
511    if (ctxt->protocol != NULL) xmlFree(ctxt->protocol);
512    if (ctxt->path != NULL) xmlFree(ctxt->path);
513    ctxt->passive = 1;
514    if (ctxt->controlFd >= 0) closesocket(ctxt->controlFd);
515    ctxt->controlFd = -1;
516    ctxt->controlBufIndex = -1;
517    ctxt->controlBufUsed = -1;
518    xmlFree(ctxt);
519}
520
521/**
522 * xmlNanoFTPParseResponse:
523 * @buf:  the buffer containing the response
524 * @len:  the buffer length
525 *
526 * Parsing of the server answer, we just extract the code.
527 *
528 * returns 0 for errors
529 *     +XXX for last line of response
530 *     -XXX for response to be continued
531 */
532static int
533xmlNanoFTPParseResponse(char *buf, int len) {
534    int val = 0;
535
536    if (len < 3) return(-1);
537    if ((*buf >= '0') && (*buf <= '9'))
538        val = val * 10 + (*buf - '0');
539    else
540        return(0);
541    buf++;
542    if ((*buf >= '0') && (*buf <= '9'))
543        val = val * 10 + (*buf - '0');
544    else
545        return(0);
546    buf++;
547    if ((*buf >= '0') && (*buf <= '9'))
548        val = val * 10 + (*buf - '0');
549    else
550        return(0);
551    buf++;
552    if (*buf == '-')
553        return(-val);
554    return(val);
555}
556
557/**
558 * xmlNanoFTPGetMore:
559 * @ctx:  an FTP context
560 *
561 * Read more information from the FTP control connection
562 * Returns the number of bytes read, < 0 indicates an error
563 */
564static int
565xmlNanoFTPGetMore(void *ctx) {
566    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
567    int len;
568    int size;
569
570    if ((ctxt == NULL) || (ctxt->controlFd < 0)) return(-1);
571
572    if ((ctxt->controlBufIndex < 0) || (ctxt->controlBufIndex > FTP_BUF_SIZE)) {
573#ifdef DEBUG_FTP
574        xmlGenericError(xmlGenericErrorContext,
575		"xmlNanoFTPGetMore : controlBufIndex = %d\n",
576		ctxt->controlBufIndex);
577#endif
578	return(-1);
579    }
580
581    if ((ctxt->controlBufUsed < 0) || (ctxt->controlBufUsed > FTP_BUF_SIZE)) {
582#ifdef DEBUG_FTP
583        xmlGenericError(xmlGenericErrorContext,
584		"xmlNanoFTPGetMore : controlBufUsed = %d\n",
585		ctxt->controlBufUsed);
586#endif
587	return(-1);
588    }
589    if (ctxt->controlBufIndex > ctxt->controlBufUsed) {
590#ifdef DEBUG_FTP
591        xmlGenericError(xmlGenericErrorContext,
592		"xmlNanoFTPGetMore : controlBufIndex > controlBufUsed %d > %d\n",
593	       ctxt->controlBufIndex, ctxt->controlBufUsed);
594#endif
595	return(-1);
596    }
597
598    /*
599     * First pack the control buffer
600     */
601    if (ctxt->controlBufIndex > 0) {
602	memmove(&ctxt->controlBuf[0], &ctxt->controlBuf[ctxt->controlBufIndex],
603		ctxt->controlBufUsed - ctxt->controlBufIndex);
604	ctxt->controlBufUsed -= ctxt->controlBufIndex;
605	ctxt->controlBufIndex = 0;
606    }
607    size = FTP_BUF_SIZE - ctxt->controlBufUsed;
608    if (size == 0) {
609#ifdef DEBUG_FTP
610        xmlGenericError(xmlGenericErrorContext,
611		"xmlNanoFTPGetMore : buffer full %d \n", ctxt->controlBufUsed);
612#endif
613	return(0);
614    }
615
616    /*
617     * Read the amount left on the control connection
618     */
619    if ((len = recv(ctxt->controlFd, &ctxt->controlBuf[ctxt->controlBufIndex],
620		    size, 0)) < 0) {
621	__xmlIOErr(XML_FROM_FTP, 0, "recv failed");
622	closesocket(ctxt->controlFd); ctxt->controlFd = -1;
623        ctxt->controlFd = -1;
624        return(-1);
625    }
626#ifdef DEBUG_FTP
627    xmlGenericError(xmlGenericErrorContext,
628	    "xmlNanoFTPGetMore : read %d [%d - %d]\n", len,
629	   ctxt->controlBufUsed, ctxt->controlBufUsed + len);
630#endif
631    ctxt->controlBufUsed += len;
632    ctxt->controlBuf[ctxt->controlBufUsed] = 0;
633
634    return(len);
635}
636
637/**
638 * xmlNanoFTPReadResponse:
639 * @ctx:  an FTP context
640 *
641 * Read the response from the FTP server after a command.
642 * Returns the code number
643 */
644static int
645xmlNanoFTPReadResponse(void *ctx) {
646    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
647    char *ptr, *end;
648    int len;
649    int res = -1, cur = -1;
650
651    if ((ctxt == NULL) || (ctxt->controlFd < 0)) return(-1);
652
653get_more:
654    /*
655     * Assumes everything up to controlBuf[controlBufIndex] has been read
656     * and analyzed.
657     */
658    len = xmlNanoFTPGetMore(ctx);
659    if (len < 0) {
660        return(-1);
661    }
662    if ((ctxt->controlBufUsed == 0) && (len == 0)) {
663        return(-1);
664    }
665    ptr = &ctxt->controlBuf[ctxt->controlBufIndex];
666    end = &ctxt->controlBuf[ctxt->controlBufUsed];
667
668#ifdef DEBUG_FTP
669    xmlGenericError(xmlGenericErrorContext,
670	    "\n<<<\n%s\n--\n", ptr);
671#endif
672    while (ptr < end) {
673        cur = xmlNanoFTPParseResponse(ptr, end - ptr);
674	if (cur > 0) {
675	    /*
676	     * Successfully scanned the control code, scratch
677	     * till the end of the line, but keep the index to be
678	     * able to analyze the result if needed.
679	     */
680	    res = cur;
681	    ptr += 3;
682	    ctxt->controlBufAnswer = ptr - ctxt->controlBuf;
683	    while ((ptr < end) && (*ptr != '\n')) ptr++;
684	    if (*ptr == '\n') ptr++;
685	    if (*ptr == '\r') ptr++;
686	    break;
687	}
688	while ((ptr < end) && (*ptr != '\n')) ptr++;
689	if (ptr >= end) {
690	    ctxt->controlBufIndex = ctxt->controlBufUsed;
691	    goto get_more;
692	}
693	if (*ptr != '\r') ptr++;
694    }
695
696    if (res < 0) goto get_more;
697    ctxt->controlBufIndex = ptr - ctxt->controlBuf;
698#ifdef DEBUG_FTP
699    ptr = &ctxt->controlBuf[ctxt->controlBufIndex];
700    xmlGenericError(xmlGenericErrorContext, "\n---\n%s\n--\n", ptr);
701#endif
702
703#ifdef DEBUG_FTP
704    xmlGenericError(xmlGenericErrorContext, "Got %d\n", res);
705#endif
706    return(res / 100);
707}
708
709/**
710 * xmlNanoFTPGetResponse:
711 * @ctx:  an FTP context
712 *
713 * Get the response from the FTP server after a command.
714 * Returns the code number
715 */
716
717int
718xmlNanoFTPGetResponse(void *ctx) {
719    int res;
720
721    res = xmlNanoFTPReadResponse(ctx);
722
723    return(res);
724}
725
726/**
727 * xmlNanoFTPCheckResponse:
728 * @ctx:  an FTP context
729 *
730 * Check if there is a response from the FTP server after a command.
731 * Returns the code number, or 0
732 */
733
734int
735xmlNanoFTPCheckResponse(void *ctx) {
736    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
737    fd_set rfd;
738    struct timeval tv;
739
740    if ((ctxt == NULL) || (ctxt->controlFd < 0)) return(-1);
741    tv.tv_sec = 0;
742    tv.tv_usec = 0;
743    FD_ZERO(&rfd);
744    FD_SET(ctxt->controlFd, &rfd);
745    switch(select(ctxt->controlFd + 1, &rfd, NULL, NULL, &tv)) {
746	case 0:
747	    return(0);
748	case -1:
749	    __xmlIOErr(XML_FROM_FTP, 0, "select");
750	    return(-1);
751
752    }
753
754    return(xmlNanoFTPReadResponse(ctx));
755}
756
757/**
758 * Send the user authentication
759 */
760
761static int
762xmlNanoFTPSendUser(void *ctx) {
763    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
764    char buf[200];
765    int len;
766    int res;
767
768    if (ctxt->user == NULL)
769	snprintf(buf, sizeof(buf), "USER anonymous\r\n");
770    else
771	snprintf(buf, sizeof(buf), "USER %s\r\n", ctxt->user);
772    buf[sizeof(buf) - 1] = 0;
773    len = strlen(buf);
774#ifdef DEBUG_FTP
775    xmlGenericError(xmlGenericErrorContext, "%s", buf);
776#endif
777    res = send(ctxt->controlFd, buf, len, 0);
778    if (res < 0) {
779	__xmlIOErr(XML_FROM_FTP, 0, "send failed");
780	return(res);
781    }
782    return(0);
783}
784
785/**
786 * Send the password authentication
787 */
788
789static int
790xmlNanoFTPSendPasswd(void *ctx) {
791    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
792    char buf[200];
793    int len;
794    int res;
795
796    if (ctxt->passwd == NULL)
797	snprintf(buf, sizeof(buf), "PASS anonymous@\r\n");
798    else
799	snprintf(buf, sizeof(buf), "PASS %s\r\n", ctxt->passwd);
800    buf[sizeof(buf) - 1] = 0;
801    len = strlen(buf);
802#ifdef DEBUG_FTP
803    xmlGenericError(xmlGenericErrorContext, "%s", buf);
804#endif
805    res = send(ctxt->controlFd, buf, len, 0);
806    if (res < 0) {
807	__xmlIOErr(XML_FROM_FTP, 0, "send failed");
808	return(res);
809    }
810    return(0);
811}
812
813/**
814 * xmlNanoFTPQuit:
815 * @ctx:  an FTP context
816 *
817 * Send a QUIT command to the server
818 *
819 * Returns -1 in case of error, 0 otherwise
820 */
821
822
823int
824xmlNanoFTPQuit(void *ctx) {
825    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
826    char buf[200];
827    int len, res;
828
829    if ((ctxt == NULL) || (ctxt->controlFd < 0)) return(-1);
830
831    snprintf(buf, sizeof(buf), "QUIT\r\n");
832    len = strlen(buf);
833#ifdef DEBUG_FTP
834    xmlGenericError(xmlGenericErrorContext, "%s", buf); /* Just to be consistent, even though we know it can't have a % in it */
835#endif
836    res = send(ctxt->controlFd, buf, len, 0);
837    if (res < 0) {
838	__xmlIOErr(XML_FROM_FTP, 0, "send failed");
839	return(res);
840    }
841    return(0);
842}
843
844/**
845 * xmlNanoFTPConnect:
846 * @ctx:  an FTP context
847 *
848 * Tries to open a control connection
849 *
850 * Returns -1 in case of error, 0 otherwise
851 */
852
853int
854xmlNanoFTPConnect(void *ctx) {
855    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
856    struct hostent *hp;
857    int port;
858    int res;
859    int addrlen = sizeof (struct sockaddr_in);
860
861    if (ctxt == NULL)
862	return(-1);
863    if (ctxt->hostname == NULL)
864	return(-1);
865
866    /*
867     * do the blocking DNS query.
868     */
869    if (proxy) {
870        port = proxyPort;
871    } else {
872	port = ctxt->port;
873    }
874    if (port == 0)
875	port = 21;
876
877    memset (&ctxt->ftpAddr, 0, sizeof(ctxt->ftpAddr));
878
879#ifdef SUPPORT_IP6
880    if (have_ipv6 ()) {
881	struct addrinfo hints, *tmp, *result;
882
883	result = NULL;
884	memset (&hints, 0, sizeof(hints));
885	hints.ai_socktype = SOCK_STREAM;
886
887	if (proxy) {
888	    if (getaddrinfo (proxy, NULL, &hints, &result) != 0) {
889		__xmlIOErr(XML_FROM_FTP, 0, "getaddrinfo failed");
890		return (-1);
891	    }
892	}
893	else
894	    if (getaddrinfo (ctxt->hostname, NULL, &hints, &result) != 0) {
895		__xmlIOErr(XML_FROM_FTP, 0, "getaddrinfo failed");
896		return (-1);
897	    }
898
899	for (tmp = result; tmp; tmp = tmp->ai_next)
900	    if (tmp->ai_family == AF_INET || tmp->ai_family == AF_INET6)
901		break;
902
903	if (!tmp) {
904	    if (result)
905		freeaddrinfo (result);
906	    __xmlIOErr(XML_FROM_FTP, 0, "getaddrinfo failed");
907	    return (-1);
908	}
909	if (tmp->ai_addrlen > sizeof(ctxt->ftpAddr)) {
910	    __xmlIOErr(XML_FROM_FTP, 0, "gethostbyname address mismatch");
911	    return (-1);
912	}
913	if (tmp->ai_family == AF_INET6) {
914	    memcpy (&ctxt->ftpAddr, tmp->ai_addr, tmp->ai_addrlen);
915	    ((struct sockaddr_in6 *) &ctxt->ftpAddr)->sin6_port = htons (port);
916	    ctxt->controlFd = socket (AF_INET6, SOCK_STREAM, 0);
917	}
918	else {
919	    memcpy (&ctxt->ftpAddr, tmp->ai_addr, tmp->ai_addrlen);
920	    ((struct sockaddr_in *) &ctxt->ftpAddr)->sin_port = htons (port);
921	    ctxt->controlFd = socket (AF_INET, SOCK_STREAM, 0);
922	}
923	addrlen = tmp->ai_addrlen;
924	freeaddrinfo (result);
925    }
926    else
927#endif
928    {
929	if (proxy)
930	    hp = gethostbyname (proxy);
931	else
932	    hp = gethostbyname (ctxt->hostname);
933	if (hp == NULL) {
934	    __xmlIOErr(XML_FROM_FTP, 0, "gethostbyname failed");
935	    return (-1);
936	}
937	if ((unsigned int) hp->h_length >
938	    sizeof(((struct sockaddr_in *)&ctxt->ftpAddr)->sin_addr)) {
939	    __xmlIOErr(XML_FROM_FTP, 0, "gethostbyname address mismatch");
940	    return (-1);
941	}
942
943	/*
944	 * Prepare the socket
945	 */
946	((struct sockaddr_in *)&ctxt->ftpAddr)->sin_family = AF_INET;
947	memcpy (&((struct sockaddr_in *)&ctxt->ftpAddr)->sin_addr,
948		hp->h_addr_list[0], hp->h_length);
949	((struct sockaddr_in *)&ctxt->ftpAddr)->sin_port = (u_short)htons ((unsigned short)port);
950	ctxt->controlFd = socket (AF_INET, SOCK_STREAM, 0);
951	addrlen = sizeof (struct sockaddr_in);
952    }
953
954    if (ctxt->controlFd < 0) {
955	__xmlIOErr(XML_FROM_FTP, 0, "socket failed");
956        return(-1);
957    }
958
959    /*
960     * Do the connect.
961     */
962    if (connect(ctxt->controlFd, (struct sockaddr *) &ctxt->ftpAddr,
963	    addrlen) < 0) {
964	__xmlIOErr(XML_FROM_FTP, 0, "Failed to create a connection");
965        closesocket(ctxt->controlFd); ctxt->controlFd = -1;
966        ctxt->controlFd = -1;
967	return(-1);
968    }
969
970    /*
971     * Wait for the HELLO from the server.
972     */
973    res = xmlNanoFTPGetResponse(ctxt);
974    if (res != 2) {
975        closesocket(ctxt->controlFd); ctxt->controlFd = -1;
976        ctxt->controlFd = -1;
977	return(-1);
978    }
979
980    /*
981     * State diagram for the login operation on the FTP server
982     *
983     * Reference: RFC 959
984     *
985     *                       1
986     * +---+   USER    +---+------------->+---+
987     * | B |---------->| W | 2       ---->| E |
988     * +---+           +---+------  |  -->+---+
989     *                  | |       | | |
990     *                3 | | 4,5   | | |
991     *    --------------   -----  | | |
992     *   |                      | | | |
993     *   |                      | | | |
994     *   |                 ---------  |
995     *   |               1|     | |   |
996     *   V                |     | |   |
997     * +---+   PASS    +---+ 2  |  ------>+---+
998     * |   |---------->| W |------------->| S |
999     * +---+           +---+   ---------->+---+
1000     *                  | |   | |     |
1001     *                3 | |4,5| |     |
1002     *    --------------   --------   |
1003     *   |                    | |  |  |
1004     *   |                    | |  |  |
1005     *   |                 -----------
1006     *   |             1,3|   | |  |
1007     *   V                |  2| |  |
1008     * +---+   ACCT    +---+--  |   ----->+---+
1009     * |   |---------->| W | 4,5 -------->| F |
1010     * +---+           +---+------------->+---+
1011     *
1012     * Of course in case of using a proxy this get really nasty and is not
1013     * standardized at all :-(
1014     */
1015    if (proxy) {
1016        int len;
1017	char buf[400];
1018
1019        if (proxyUser != NULL) {
1020	    /*
1021	     * We need proxy auth
1022	     */
1023	    snprintf(buf, sizeof(buf), "USER %s\r\n", proxyUser);
1024            buf[sizeof(buf) - 1] = 0;
1025            len = strlen(buf);
1026#ifdef DEBUG_FTP
1027	    xmlGenericError(xmlGenericErrorContext, "%s", buf);
1028#endif
1029	    res = send(ctxt->controlFd, buf, len, 0);
1030	    if (res < 0) {
1031		__xmlIOErr(XML_FROM_FTP, 0, "send failed");
1032		closesocket(ctxt->controlFd);
1033		ctxt->controlFd = -1;
1034	        return(res);
1035	    }
1036	    res = xmlNanoFTPGetResponse(ctxt);
1037	    switch (res) {
1038		case 2:
1039		    if (proxyPasswd == NULL)
1040			break;
1041		case 3:
1042		    if (proxyPasswd != NULL)
1043			snprintf(buf, sizeof(buf), "PASS %s\r\n", proxyPasswd);
1044		    else
1045			snprintf(buf, sizeof(buf), "PASS anonymous@\r\n");
1046                    buf[sizeof(buf) - 1] = 0;
1047                    len = strlen(buf);
1048#ifdef DEBUG_FTP
1049		    xmlGenericError(xmlGenericErrorContext, "%s", buf);
1050#endif
1051		    res = send(ctxt->controlFd, buf, len, 0);
1052		    if (res < 0) {
1053			__xmlIOErr(XML_FROM_FTP, 0, "send failed");
1054			closesocket(ctxt->controlFd);
1055			ctxt->controlFd = -1;
1056			return(res);
1057		    }
1058		    res = xmlNanoFTPGetResponse(ctxt);
1059		    if (res > 3) {
1060			closesocket(ctxt->controlFd);
1061			ctxt->controlFd = -1;
1062			return(-1);
1063		    }
1064		    break;
1065		case 1:
1066		    break;
1067		case 4:
1068		case 5:
1069		case -1:
1070		default:
1071		    closesocket(ctxt->controlFd);
1072		    ctxt->controlFd = -1;
1073		    return(-1);
1074	    }
1075	}
1076
1077	/*
1078	 * We assume we don't need more authentication to the proxy
1079	 * and that it succeeded :-\
1080	 */
1081	switch (proxyType) {
1082	    case 0:
1083		/* we will try in sequence */
1084	    case 1:
1085		/* Using SITE command */
1086		snprintf(buf, sizeof(buf), "SITE %s\r\n", ctxt->hostname);
1087                buf[sizeof(buf) - 1] = 0;
1088                len = strlen(buf);
1089#ifdef DEBUG_FTP
1090		xmlGenericError(xmlGenericErrorContext, "%s", buf);
1091#endif
1092		res = send(ctxt->controlFd, buf, len, 0);
1093		if (res < 0) {
1094		    __xmlIOErr(XML_FROM_FTP, 0, "send failed");
1095		    closesocket(ctxt->controlFd); ctxt->controlFd = -1;
1096		    ctxt->controlFd = -1;
1097		    return(res);
1098		}
1099		res = xmlNanoFTPGetResponse(ctxt);
1100		if (res == 2) {
1101		    /* we assume it worked :-\ 1 is error for SITE command */
1102		    proxyType = 1;
1103		    break;
1104		}
1105		if (proxyType == 1) {
1106		    closesocket(ctxt->controlFd); ctxt->controlFd = -1;
1107		    ctxt->controlFd = -1;
1108		    return(-1);
1109		}
1110	    case 2:
1111		/* USER user@host command */
1112		if (ctxt->user == NULL)
1113		    snprintf(buf, sizeof(buf), "USER anonymous@%s\r\n",
1114			           ctxt->hostname);
1115		else
1116		    snprintf(buf, sizeof(buf), "USER %s@%s\r\n",
1117			           ctxt->user, ctxt->hostname);
1118                buf[sizeof(buf) - 1] = 0;
1119                len = strlen(buf);
1120#ifdef DEBUG_FTP
1121		xmlGenericError(xmlGenericErrorContext, "%s", buf);
1122#endif
1123		res = send(ctxt->controlFd, buf, len, 0);
1124		if (res < 0) {
1125		    __xmlIOErr(XML_FROM_FTP, 0, "send failed");
1126		    closesocket(ctxt->controlFd); ctxt->controlFd = -1;
1127		    ctxt->controlFd = -1;
1128		    return(res);
1129		}
1130		res = xmlNanoFTPGetResponse(ctxt);
1131		if ((res == 1) || (res == 2)) {
1132		    /* we assume it worked :-\ */
1133		    proxyType = 2;
1134		    return(0);
1135		}
1136		if (ctxt->passwd == NULL)
1137		    snprintf(buf, sizeof(buf), "PASS anonymous@\r\n");
1138		else
1139		    snprintf(buf, sizeof(buf), "PASS %s\r\n", ctxt->passwd);
1140                buf[sizeof(buf) - 1] = 0;
1141                len = strlen(buf);
1142#ifdef DEBUG_FTP
1143		xmlGenericError(xmlGenericErrorContext, "%s", buf);
1144#endif
1145		res = send(ctxt->controlFd, buf, len, 0);
1146		if (res < 0) {
1147		    __xmlIOErr(XML_FROM_FTP, 0, "send failed");
1148		    closesocket(ctxt->controlFd); ctxt->controlFd = -1;
1149		    ctxt->controlFd = -1;
1150		    return(res);
1151		}
1152		res = xmlNanoFTPGetResponse(ctxt);
1153		if ((res == 1) || (res == 2)) {
1154		    /* we assume it worked :-\ */
1155		    proxyType = 2;
1156		    return(0);
1157		}
1158		if (proxyType == 2) {
1159		    closesocket(ctxt->controlFd); ctxt->controlFd = -1;
1160		    ctxt->controlFd = -1;
1161		    return(-1);
1162		}
1163	    case 3:
1164		/*
1165		 * If you need support for other Proxy authentication scheme
1166		 * send the code or at least the sequence in use.
1167		 */
1168	    default:
1169		closesocket(ctxt->controlFd); ctxt->controlFd = -1;
1170		ctxt->controlFd = -1;
1171		return(-1);
1172	}
1173    }
1174    /*
1175     * Non-proxy handling.
1176     */
1177    res = xmlNanoFTPSendUser(ctxt);
1178    if (res < 0) {
1179        closesocket(ctxt->controlFd); ctxt->controlFd = -1;
1180        ctxt->controlFd = -1;
1181	return(-1);
1182    }
1183    res = xmlNanoFTPGetResponse(ctxt);
1184    switch (res) {
1185	case 2:
1186	    return(0);
1187	case 3:
1188	    break;
1189	case 1:
1190	case 4:
1191	case 5:
1192        case -1:
1193	default:
1194	    closesocket(ctxt->controlFd); ctxt->controlFd = -1;
1195	    ctxt->controlFd = -1;
1196	    return(-1);
1197    }
1198    res = xmlNanoFTPSendPasswd(ctxt);
1199    if (res < 0) {
1200        closesocket(ctxt->controlFd); ctxt->controlFd = -1;
1201        ctxt->controlFd = -1;
1202	return(-1);
1203    }
1204    res = xmlNanoFTPGetResponse(ctxt);
1205    switch (res) {
1206	case 2:
1207	    break;
1208	case 3:
1209	    __xmlIOErr(XML_FROM_FTP, XML_FTP_ACCNT,
1210		       "FTP server asking for ACCNT on anonymous\n");
1211	case 1:
1212	case 4:
1213	case 5:
1214        case -1:
1215	default:
1216	    closesocket(ctxt->controlFd); ctxt->controlFd = -1;
1217	    ctxt->controlFd = -1;
1218	    return(-1);
1219    }
1220
1221    return(0);
1222}
1223
1224/**
1225 * xmlNanoFTPConnectTo:
1226 * @server:  an FTP server name
1227 * @port:  the port (use 21 if 0)
1228 *
1229 * Tries to open a control connection to the given server/port
1230 *
1231 * Returns an fTP context or NULL if it failed
1232 */
1233
1234void*
1235xmlNanoFTPConnectTo(const char *server, int port) {
1236    xmlNanoFTPCtxtPtr ctxt;
1237    int res;
1238
1239    xmlNanoFTPInit();
1240    if (server == NULL)
1241	return(NULL);
1242    if (port <= 0)
1243	return(NULL);
1244    ctxt = (xmlNanoFTPCtxtPtr) xmlNanoFTPNewCtxt(NULL);
1245    ctxt->hostname = xmlMemStrdup(server);
1246    if (port != 0)
1247	ctxt->port = port;
1248    res = xmlNanoFTPConnect(ctxt);
1249    if (res < 0) {
1250	xmlNanoFTPFreeCtxt(ctxt);
1251	return(NULL);
1252    }
1253    return(ctxt);
1254}
1255
1256/**
1257 * xmlNanoFTPCwd:
1258 * @ctx:  an FTP context
1259 * @directory:  a directory on the server
1260 *
1261 * Tries to change the remote directory
1262 *
1263 * Returns -1 incase of error, 1 if CWD worked, 0 if it failed
1264 */
1265
1266int
1267xmlNanoFTPCwd(void *ctx, const char *directory) {
1268    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
1269    char buf[400];
1270    int len;
1271    int res;
1272
1273    if ((ctxt == NULL) || (ctxt->controlFd < 0)) return(-1);
1274    if (directory == NULL) return 0;
1275
1276    /*
1277     * Expected response code for CWD:
1278     *
1279     * CWD
1280     *     250
1281     *     500, 501, 502, 421, 530, 550
1282     */
1283    snprintf(buf, sizeof(buf), "CWD %s\r\n", directory);
1284    buf[sizeof(buf) - 1] = 0;
1285    len = strlen(buf);
1286#ifdef DEBUG_FTP
1287    xmlGenericError(xmlGenericErrorContext, "%s", buf);
1288#endif
1289    res = send(ctxt->controlFd, buf, len, 0);
1290    if (res < 0) {
1291	__xmlIOErr(XML_FROM_FTP, 0, "send failed");
1292	return(res);
1293    }
1294    res = xmlNanoFTPGetResponse(ctxt);
1295    if (res == 4) {
1296	return(-1);
1297    }
1298    if (res == 2) return(1);
1299    if (res == 5) {
1300	return(0);
1301    }
1302    return(0);
1303}
1304
1305/**
1306 * xmlNanoFTPDele:
1307 * @ctx:  an FTP context
1308 * @file:  a file or directory on the server
1309 *
1310 * Tries to delete an item (file or directory) from server
1311 *
1312 * Returns -1 incase of error, 1 if DELE worked, 0 if it failed
1313 */
1314
1315int
1316xmlNanoFTPDele(void *ctx, const char *file) {
1317    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
1318    char buf[400];
1319    int len;
1320    int res;
1321
1322    if ((ctxt == NULL) || (ctxt->controlFd < 0) || (file == NULL)) return(-1);
1323    if (file == NULL) return (0);
1324
1325    /*
1326     * Expected response code for DELE:
1327     *
1328     * DELE
1329     *       250
1330     *       450, 550
1331     *       500, 501, 502, 421, 530
1332     */
1333
1334    snprintf(buf, sizeof(buf), "DELE %s\r\n", file);
1335    buf[sizeof(buf) - 1] = 0;
1336    len = strlen(buf);
1337#ifdef DEBUG_FTP
1338    xmlGenericError(xmlGenericErrorContext, "%s", buf);
1339#endif
1340    res = send(ctxt->controlFd, buf, len, 0);
1341    if (res < 0) {
1342	__xmlIOErr(XML_FROM_FTP, 0, "send failed");
1343	return(res);
1344    }
1345    res = xmlNanoFTPGetResponse(ctxt);
1346    if (res == 4) {
1347	return(-1);
1348    }
1349    if (res == 2) return(1);
1350    if (res == 5) {
1351	return(0);
1352    }
1353    return(0);
1354}
1355/**
1356 * xmlNanoFTPGetConnection:
1357 * @ctx:  an FTP context
1358 *
1359 * Try to open a data connection to the server. Currently only
1360 * passive mode is supported.
1361 *
1362 * Returns -1 incase of error, 0 otherwise
1363 */
1364
1365int
1366xmlNanoFTPGetConnection(void *ctx) {
1367    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
1368    char buf[200], *cur;
1369    int len, i;
1370    int res;
1371    unsigned char ad[6], *adp, *portp;
1372    unsigned int temp[6];
1373#ifdef SUPPORT_IP6
1374    struct sockaddr_storage dataAddr;
1375#else
1376    struct sockaddr_in dataAddr;
1377#endif
1378    XML_SOCKLEN_T dataAddrLen;
1379
1380    if (ctxt == NULL) return(-1);
1381
1382    memset (&dataAddr, 0, sizeof(dataAddr));
1383#ifdef SUPPORT_IP6
1384    if ((ctxt->ftpAddr).ss_family == AF_INET6) {
1385	ctxt->dataFd = socket (AF_INET6, SOCK_STREAM, IPPROTO_TCP);
1386	((struct sockaddr_in6 *)&dataAddr)->sin6_family = AF_INET6;
1387	dataAddrLen = sizeof(struct sockaddr_in6);
1388    } else
1389#endif
1390    {
1391	ctxt->dataFd = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
1392	((struct sockaddr_in *)&dataAddr)->sin_family = AF_INET;
1393	dataAddrLen = sizeof (struct sockaddr_in);
1394    }
1395
1396    if (ctxt->dataFd < 0) {
1397	__xmlIOErr(XML_FROM_FTP, 0, "socket failed");
1398	return (-1);
1399    }
1400
1401    if (ctxt->passive) {
1402#ifdef SUPPORT_IP6
1403	if ((ctxt->ftpAddr).ss_family == AF_INET6)
1404	    snprintf (buf, sizeof(buf), "EPSV\r\n");
1405	else
1406#endif
1407	    snprintf (buf, sizeof(buf), "PASV\r\n");
1408        len = strlen (buf);
1409#ifdef DEBUG_FTP
1410	xmlGenericError(xmlGenericErrorContext, "%s", buf);
1411#endif
1412	res = send(ctxt->controlFd, buf, len, 0);
1413	if (res < 0) {
1414	    __xmlIOErr(XML_FROM_FTP, 0, "send failed");
1415	    closesocket(ctxt->dataFd); ctxt->dataFd = -1;
1416	    return(res);
1417	}
1418        res = xmlNanoFTPReadResponse(ctx);
1419	if (res != 2) {
1420	    if (res == 5) {
1421	        closesocket(ctxt->dataFd); ctxt->dataFd = -1;
1422		return(-1);
1423	    } else {
1424		/*
1425		 * retry with an active connection
1426		 */
1427	        closesocket(ctxt->dataFd); ctxt->dataFd = -1;
1428	        ctxt->passive = 0;
1429	    }
1430	}
1431	cur = &ctxt->controlBuf[ctxt->controlBufAnswer];
1432	while (((*cur < '0') || (*cur > '9')) && *cur != '\0') cur++;
1433#ifdef SUPPORT_IP6
1434	if ((ctxt->ftpAddr).ss_family == AF_INET6) {
1435	    if (sscanf (cur, "%u", &temp[0]) != 1) {
1436		__xmlIOErr(XML_FROM_FTP, XML_FTP_EPSV_ANSWER,
1437			"Invalid answer to EPSV\n");
1438		if (ctxt->dataFd != -1) {
1439		    closesocket (ctxt->dataFd); ctxt->dataFd = -1;
1440		}
1441		return (-1);
1442	    }
1443	    memcpy (&((struct sockaddr_in6 *)&dataAddr)->sin6_addr, &((struct sockaddr_in6 *)&ctxt->ftpAddr)->sin6_addr, sizeof(struct in6_addr));
1444	    ((struct sockaddr_in6 *)&dataAddr)->sin6_port = htons (temp[0]);
1445	}
1446	else
1447#endif
1448	{
1449	    if (sscanf (cur, "%u,%u,%u,%u,%u,%u", &temp[0], &temp[1], &temp[2],
1450		&temp[3], &temp[4], &temp[5]) != 6) {
1451		__xmlIOErr(XML_FROM_FTP, XML_FTP_PASV_ANSWER,
1452			"Invalid answer to PASV\n");
1453		if (ctxt->dataFd != -1) {
1454		    closesocket (ctxt->dataFd); ctxt->dataFd = -1;
1455		}
1456		return (-1);
1457	    }
1458	    for (i=0; i<6; i++) ad[i] = (unsigned char) (temp[i] & 0xff);
1459	    memcpy (&((struct sockaddr_in *)&dataAddr)->sin_addr, &ad[0], 4);
1460	    memcpy (&((struct sockaddr_in *)&dataAddr)->sin_port, &ad[4], 2);
1461	}
1462
1463	if (connect(ctxt->dataFd, (struct sockaddr *) &dataAddr, dataAddrLen) < 0) {
1464	    __xmlIOErr(XML_FROM_FTP, 0, "Failed to create a data connection");
1465	    closesocket(ctxt->dataFd); ctxt->dataFd = -1;
1466	    return (-1);
1467	}
1468    } else {
1469        getsockname(ctxt->dataFd, (struct sockaddr *) &dataAddr, &dataAddrLen);
1470#ifdef SUPPORT_IP6
1471	if ((ctxt->ftpAddr).ss_family == AF_INET6)
1472	    ((struct sockaddr_in6 *)&dataAddr)->sin6_port = 0;
1473	else
1474#endif
1475	    ((struct sockaddr_in *)&dataAddr)->sin_port = 0;
1476
1477	if (bind(ctxt->dataFd, (struct sockaddr *) &dataAddr, dataAddrLen) < 0) {
1478	    __xmlIOErr(XML_FROM_FTP, 0, "bind failed");
1479	    closesocket(ctxt->dataFd); ctxt->dataFd = -1;
1480	    return (-1);
1481	}
1482        getsockname(ctxt->dataFd, (struct sockaddr *) &dataAddr, &dataAddrLen);
1483
1484	if (listen(ctxt->dataFd, 1) < 0) {
1485	    __xmlIOErr(XML_FROM_FTP, 0, "listen failed");
1486	    closesocket(ctxt->dataFd); ctxt->dataFd = -1;
1487	    return (-1);
1488	}
1489#ifdef SUPPORT_IP6
1490	if ((ctxt->ftpAddr).ss_family == AF_INET6) {
1491	    char buf6[INET6_ADDRSTRLEN];
1492	    inet_ntop (AF_INET6, &((struct sockaddr_in6 *)&dataAddr)->sin6_addr,
1493		    buf6, INET6_ADDRSTRLEN);
1494	    adp = (unsigned char *) buf6;
1495	    portp = (unsigned char *) &((struct sockaddr_in6 *)&dataAddr)->sin6_port;
1496	    snprintf (buf, sizeof(buf), "EPRT |2|%s|%s|\r\n", adp, portp);
1497        } else
1498#endif
1499	{
1500	    adp = (unsigned char *) &((struct sockaddr_in *)&dataAddr)->sin_addr;
1501	    portp = (unsigned char *) &((struct sockaddr_in *)&dataAddr)->sin_port;
1502	    snprintf (buf, sizeof(buf), "PORT %d,%d,%d,%d,%d,%d\r\n",
1503	    adp[0] & 0xff, adp[1] & 0xff, adp[2] & 0xff, adp[3] & 0xff,
1504	    portp[0] & 0xff, portp[1] & 0xff);
1505	}
1506
1507        buf[sizeof(buf) - 1] = 0;
1508        len = strlen(buf);
1509#ifdef DEBUG_FTP
1510	xmlGenericError(xmlGenericErrorContext, "%s", buf);
1511#endif
1512
1513	res = send(ctxt->controlFd, buf, len, 0);
1514	if (res < 0) {
1515	    __xmlIOErr(XML_FROM_FTP, 0, "send failed");
1516	    closesocket(ctxt->dataFd); ctxt->dataFd = -1;
1517	    return(res);
1518	}
1519        res = xmlNanoFTPGetResponse(ctxt);
1520	if (res != 2) {
1521	    closesocket(ctxt->dataFd); ctxt->dataFd = -1;
1522	    return(-1);
1523        }
1524    }
1525    return(ctxt->dataFd);
1526
1527}
1528
1529/**
1530 * xmlNanoFTPCloseConnection:
1531 * @ctx:  an FTP context
1532 *
1533 * Close the data connection from the server
1534 *
1535 * Returns -1 incase of error, 0 otherwise
1536 */
1537
1538int
1539xmlNanoFTPCloseConnection(void *ctx) {
1540    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
1541    int res;
1542    fd_set rfd, efd;
1543    struct timeval tv;
1544
1545    if ((ctxt == NULL) || (ctxt->controlFd < 0)) return(-1);
1546
1547    closesocket(ctxt->dataFd); ctxt->dataFd = -1;
1548    tv.tv_sec = 15;
1549    tv.tv_usec = 0;
1550    FD_ZERO(&rfd);
1551    FD_SET(ctxt->controlFd, &rfd);
1552    FD_ZERO(&efd);
1553    FD_SET(ctxt->controlFd, &efd);
1554    res = select(ctxt->controlFd + 1, &rfd, NULL, &efd, &tv);
1555    if (res < 0) {
1556#ifdef DEBUG_FTP
1557	perror("select");
1558#endif
1559	closesocket(ctxt->controlFd); ctxt->controlFd = -1;
1560	return(-1);
1561    }
1562    if (res == 0) {
1563#ifdef DEBUG_FTP
1564	xmlGenericError(xmlGenericErrorContext,
1565		"xmlNanoFTPCloseConnection: timeout\n");
1566#endif
1567	closesocket(ctxt->controlFd); ctxt->controlFd = -1;
1568    } else {
1569	res = xmlNanoFTPGetResponse(ctxt);
1570	if (res != 2) {
1571	    closesocket(ctxt->controlFd); ctxt->controlFd = -1;
1572	    return(-1);
1573	}
1574    }
1575    return(0);
1576}
1577
1578/**
1579 * xmlNanoFTPParseList:
1580 * @list:  some data listing received from the server
1581 * @callback:  the user callback
1582 * @userData:  the user callback data
1583 *
1584 * Parse at most one entry from the listing.
1585 *
1586 * Returns -1 incase of error, the length of data parsed otherwise
1587 */
1588
1589static int
1590xmlNanoFTPParseList(const char *list, ftpListCallback callback, void *userData) {
1591    const char *cur = list;
1592    char filename[151];
1593    char attrib[11];
1594    char owner[11];
1595    char group[11];
1596    char month[4];
1597    int year = 0;
1598    int minute = 0;
1599    int hour = 0;
1600    int day = 0;
1601    unsigned long size = 0;
1602    int links = 0;
1603    int i;
1604
1605    if (!strncmp(cur, "total", 5)) {
1606        cur += 5;
1607	while (*cur == ' ') cur++;
1608	while ((*cur >= '0') && (*cur <= '9'))
1609	    links = (links * 10) + (*cur++ - '0');
1610	while ((*cur == ' ') || (*cur == '\n')  || (*cur == '\r'))
1611	    cur++;
1612	return(cur - list);
1613    } else if (*list == '+') {
1614	return(0);
1615    } else {
1616	while ((*cur == ' ') || (*cur == '\n')  || (*cur == '\r'))
1617	    cur++;
1618	if (*cur == 0) return(0);
1619	i = 0;
1620	while (*cur != ' ') {
1621	    if (i < 10)
1622		attrib[i++] = *cur;
1623	    cur++;
1624	    if (*cur == 0) return(0);
1625	}
1626	attrib[10] = 0;
1627	while (*cur == ' ') cur++;
1628	if (*cur == 0) return(0);
1629	while ((*cur >= '0') && (*cur <= '9'))
1630	    links = (links * 10) + (*cur++ - '0');
1631	while (*cur == ' ') cur++;
1632	if (*cur == 0) return(0);
1633	i = 0;
1634	while (*cur != ' ') {
1635	    if (i < 10)
1636		owner[i++] = *cur;
1637	    cur++;
1638	    if (*cur == 0) return(0);
1639	}
1640	owner[i] = 0;
1641	while (*cur == ' ') cur++;
1642	if (*cur == 0) return(0);
1643	i = 0;
1644	while (*cur != ' ') {
1645	    if (i < 10)
1646		group[i++] = *cur;
1647	    cur++;
1648	    if (*cur == 0) return(0);
1649	}
1650	group[i] = 0;
1651	while (*cur == ' ') cur++;
1652	if (*cur == 0) return(0);
1653	while ((*cur >= '0') && (*cur <= '9'))
1654	    size = (size * 10) + (*cur++ - '0');
1655	while (*cur == ' ') cur++;
1656	if (*cur == 0) return(0);
1657	i = 0;
1658	while (*cur != ' ') {
1659	    if (i < 3)
1660		month[i++] = *cur;
1661	    cur++;
1662	    if (*cur == 0) return(0);
1663	}
1664	month[i] = 0;
1665	while (*cur == ' ') cur++;
1666	if (*cur == 0) return(0);
1667        while ((*cur >= '0') && (*cur <= '9'))
1668	    day = (day * 10) + (*cur++ - '0');
1669	while (*cur == ' ') cur++;
1670	if (*cur == 0) return(0);
1671	if ((cur[1] == 0) || (cur[2] == 0)) return(0);
1672	if ((cur[1] == ':') || (cur[2] == ':')) {
1673	    while ((*cur >= '0') && (*cur <= '9'))
1674		hour = (hour * 10) + (*cur++ - '0');
1675	    if (*cur == ':') cur++;
1676	    while ((*cur >= '0') && (*cur <= '9'))
1677		minute = (minute * 10) + (*cur++ - '0');
1678	} else {
1679	    while ((*cur >= '0') && (*cur <= '9'))
1680		year = (year * 10) + (*cur++ - '0');
1681	}
1682	while (*cur == ' ') cur++;
1683	if (*cur == 0) return(0);
1684	i = 0;
1685	while ((*cur != '\n')  && (*cur != '\r')) {
1686	    if (i < 150)
1687		filename[i++] = *cur;
1688	    cur++;
1689	    if (*cur == 0) return(0);
1690	}
1691	filename[i] = 0;
1692	if ((*cur != '\n') && (*cur != '\r'))
1693	    return(0);
1694	while ((*cur == '\n')  || (*cur == '\r'))
1695	    cur++;
1696    }
1697    if (callback != NULL) {
1698        callback(userData, filename, attrib, owner, group, size, links,
1699		 year, month, day, hour, minute);
1700    }
1701    return(cur - list);
1702}
1703
1704/**
1705 * xmlNanoFTPList:
1706 * @ctx:  an FTP context
1707 * @callback:  the user callback
1708 * @userData:  the user callback data
1709 * @filename:  optional files to list
1710 *
1711 * Do a listing on the server. All files info are passed back
1712 * in the callbacks.
1713 *
1714 * Returns -1 incase of error, 0 otherwise
1715 */
1716
1717int
1718xmlNanoFTPList(void *ctx, ftpListCallback callback, void *userData,
1719	       const char *filename) {
1720    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
1721    char buf[4096 + 1];
1722    int len, res;
1723    int indx = 0, base;
1724    fd_set rfd, efd;
1725    struct timeval tv;
1726
1727    if (ctxt == NULL) return (-1);
1728    if (filename == NULL) {
1729        if (xmlNanoFTPCwd(ctxt, ctxt->path) < 1)
1730	    return(-1);
1731	ctxt->dataFd = xmlNanoFTPGetConnection(ctxt);
1732	if (ctxt->dataFd == -1)
1733	    return(-1);
1734	snprintf(buf, sizeof(buf), "LIST -L\r\n");
1735    } else {
1736	if (filename[0] != '/') {
1737	    if (xmlNanoFTPCwd(ctxt, ctxt->path) < 1)
1738		return(-1);
1739	}
1740	ctxt->dataFd = xmlNanoFTPGetConnection(ctxt);
1741	if (ctxt->dataFd == -1)
1742	    return(-1);
1743	snprintf(buf, sizeof(buf), "LIST -L %s\r\n", filename);
1744    }
1745    buf[sizeof(buf) - 1] = 0;
1746    len = strlen(buf);
1747#ifdef DEBUG_FTP
1748    xmlGenericError(xmlGenericErrorContext, "%s", buf);
1749#endif
1750    res = send(ctxt->controlFd, buf, len, 0);
1751    if (res < 0) {
1752	__xmlIOErr(XML_FROM_FTP, 0, "send failed");
1753	closesocket(ctxt->dataFd); ctxt->dataFd = -1;
1754	return(res);
1755    }
1756    res = xmlNanoFTPReadResponse(ctxt);
1757    if (res != 1) {
1758	closesocket(ctxt->dataFd); ctxt->dataFd = -1;
1759	return(-res);
1760    }
1761
1762    do {
1763	tv.tv_sec = 1;
1764	tv.tv_usec = 0;
1765	FD_ZERO(&rfd);
1766	FD_SET(ctxt->dataFd, &rfd);
1767	FD_ZERO(&efd);
1768	FD_SET(ctxt->dataFd, &efd);
1769	res = select(ctxt->dataFd + 1, &rfd, NULL, &efd, &tv);
1770	if (res < 0) {
1771#ifdef DEBUG_FTP
1772	    perror("select");
1773#endif
1774	    closesocket(ctxt->dataFd); ctxt->dataFd = -1;
1775	    return(-1);
1776	}
1777	if (res == 0) {
1778	    res = xmlNanoFTPCheckResponse(ctxt);
1779	    if (res < 0) {
1780		closesocket(ctxt->dataFd); ctxt->dataFd = -1;
1781		ctxt->dataFd = -1;
1782		return(-1);
1783	    }
1784	    if (res == 2) {
1785		closesocket(ctxt->dataFd); ctxt->dataFd = -1;
1786		return(0);
1787	    }
1788
1789	    continue;
1790	}
1791
1792	if ((len = recv(ctxt->dataFd, &buf[indx], sizeof(buf) - (indx + 1), 0)) < 0) {
1793	    __xmlIOErr(XML_FROM_FTP, 0, "recv");
1794	    closesocket(ctxt->dataFd); ctxt->dataFd = -1;
1795	    ctxt->dataFd = -1;
1796	    return(-1);
1797	}
1798#ifdef DEBUG_FTP
1799        write(1, &buf[indx], len);
1800#endif
1801	indx += len;
1802	buf[indx] = 0;
1803	base = 0;
1804	do {
1805	    res = xmlNanoFTPParseList(&buf[base], callback, userData);
1806	    base += res;
1807	} while (res > 0);
1808
1809	memmove(&buf[0], &buf[base], indx - base);
1810	indx -= base;
1811    } while (len != 0);
1812    xmlNanoFTPCloseConnection(ctxt);
1813    return(0);
1814}
1815
1816/**
1817 * xmlNanoFTPGetSocket:
1818 * @ctx:  an FTP context
1819 * @filename:  the file to retrieve (or NULL if path is in context).
1820 *
1821 * Initiate fetch of the given file from the server.
1822 *
1823 * Returns the socket for the data connection, or <0 in case of error
1824 */
1825
1826
1827int
1828xmlNanoFTPGetSocket(void *ctx, const char *filename) {
1829    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
1830    char buf[300];
1831    int res, len;
1832    if (ctx == NULL)
1833	return(-1);
1834    if ((filename == NULL) && (ctxt->path == NULL))
1835	return(-1);
1836    ctxt->dataFd = xmlNanoFTPGetConnection(ctxt);
1837    if (ctxt->dataFd == -1)
1838	return(-1);
1839
1840    snprintf(buf, sizeof(buf), "TYPE I\r\n");
1841    len = strlen(buf);
1842#ifdef DEBUG_FTP
1843    xmlGenericError(xmlGenericErrorContext, "%s", buf);
1844#endif
1845    res = send(ctxt->controlFd, buf, len, 0);
1846    if (res < 0) {
1847	__xmlIOErr(XML_FROM_FTP, 0, "send failed");
1848	closesocket(ctxt->dataFd); ctxt->dataFd = -1;
1849	return(res);
1850    }
1851    res = xmlNanoFTPReadResponse(ctxt);
1852    if (res != 2) {
1853	closesocket(ctxt->dataFd); ctxt->dataFd = -1;
1854	return(-res);
1855    }
1856    if (filename == NULL)
1857	snprintf(buf, sizeof(buf), "RETR %s\r\n", ctxt->path);
1858    else
1859	snprintf(buf, sizeof(buf), "RETR %s\r\n", filename);
1860    buf[sizeof(buf) - 1] = 0;
1861    len = strlen(buf);
1862#ifdef DEBUG_FTP
1863    xmlGenericError(xmlGenericErrorContext, "%s", buf);
1864#endif
1865    res = send(ctxt->controlFd, buf, len, 0);
1866    if (res < 0) {
1867	__xmlIOErr(XML_FROM_FTP, 0, "send failed");
1868	closesocket(ctxt->dataFd); ctxt->dataFd = -1;
1869	return(res);
1870    }
1871    res = xmlNanoFTPReadResponse(ctxt);
1872    if (res != 1) {
1873	closesocket(ctxt->dataFd); ctxt->dataFd = -1;
1874	return(-res);
1875    }
1876    return(ctxt->dataFd);
1877}
1878
1879/**
1880 * xmlNanoFTPGet:
1881 * @ctx:  an FTP context
1882 * @callback:  the user callback
1883 * @userData:  the user callback data
1884 * @filename:  the file to retrieve
1885 *
1886 * Fetch the given file from the server. All data are passed back
1887 * in the callbacks. The last callback has a size of 0 block.
1888 *
1889 * Returns -1 incase of error, 0 otherwise
1890 */
1891
1892int
1893xmlNanoFTPGet(void *ctx, ftpDataCallback callback, void *userData,
1894	      const char *filename) {
1895    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
1896    char buf[4096];
1897    int len = 0, res;
1898    fd_set rfd;
1899    struct timeval tv;
1900
1901    if (ctxt == NULL) return(-1);
1902    if ((filename == NULL) && (ctxt->path == NULL))
1903	return(-1);
1904    if (callback == NULL)
1905	return(-1);
1906    if (xmlNanoFTPGetSocket(ctxt, filename) < 0)
1907	return(-1);
1908
1909    do {
1910	tv.tv_sec = 1;
1911	tv.tv_usec = 0;
1912	FD_ZERO(&rfd);
1913	FD_SET(ctxt->dataFd, &rfd);
1914	res = select(ctxt->dataFd + 1, &rfd, NULL, NULL, &tv);
1915	if (res < 0) {
1916#ifdef DEBUG_FTP
1917	    perror("select");
1918#endif
1919	    closesocket(ctxt->dataFd); ctxt->dataFd = -1;
1920	    return(-1);
1921	}
1922	if (res == 0) {
1923	    res = xmlNanoFTPCheckResponse(ctxt);
1924	    if (res < 0) {
1925		closesocket(ctxt->dataFd); ctxt->dataFd = -1;
1926		ctxt->dataFd = -1;
1927		return(-1);
1928	    }
1929	    if (res == 2) {
1930		closesocket(ctxt->dataFd); ctxt->dataFd = -1;
1931		return(0);
1932	    }
1933
1934	    continue;
1935	}
1936	if ((len = recv(ctxt->dataFd, buf, sizeof(buf), 0)) < 0) {
1937	    __xmlIOErr(XML_FROM_FTP, 0, "recv failed");
1938	    callback(userData, buf, len);
1939	    closesocket(ctxt->dataFd); ctxt->dataFd = -1;
1940	    return(-1);
1941	}
1942	callback(userData, buf, len);
1943    } while (len != 0);
1944
1945    return(xmlNanoFTPCloseConnection(ctxt));
1946}
1947
1948/**
1949 * xmlNanoFTPRead:
1950 * @ctx:  the FTP context
1951 * @dest:  a buffer
1952 * @len:  the buffer length
1953 *
1954 * This function tries to read @len bytes from the existing FTP connection
1955 * and saves them in @dest. This is a blocking call.
1956 *
1957 * Returns the number of byte read. 0 is an indication of an end of connection.
1958 *         -1 indicates a parameter error.
1959 */
1960int
1961xmlNanoFTPRead(void *ctx, void *dest, int len) {
1962    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
1963
1964    if (ctx == NULL) return(-1);
1965    if (ctxt->dataFd < 0) return(0);
1966    if (dest == NULL) return(-1);
1967    if (len <= 0) return(0);
1968
1969    len = recv(ctxt->dataFd, dest, len, 0);
1970    if (len <= 0) {
1971	if (len < 0)
1972	    __xmlIOErr(XML_FROM_FTP, 0, "recv failed");
1973	xmlNanoFTPCloseConnection(ctxt);
1974    }
1975#ifdef DEBUG_FTP
1976    xmlGenericError(xmlGenericErrorContext, "Recvd %d bytes\n", len);
1977#endif
1978    return(len);
1979}
1980
1981/**
1982 * xmlNanoFTPOpen:
1983 * @URL: the URL to the resource
1984 *
1985 * Start to fetch the given ftp:// resource
1986 *
1987 * Returns an FTP context, or NULL
1988 */
1989
1990void*
1991xmlNanoFTPOpen(const char *URL) {
1992    xmlNanoFTPCtxtPtr ctxt;
1993    int sock;
1994
1995    xmlNanoFTPInit();
1996    if (URL == NULL) return(NULL);
1997    if (strncmp("ftp://", URL, 6)) return(NULL);
1998
1999    ctxt = (xmlNanoFTPCtxtPtr) xmlNanoFTPNewCtxt(URL);
2000    if (ctxt == NULL) return(NULL);
2001    if (xmlNanoFTPConnect(ctxt) < 0) {
2002	xmlNanoFTPFreeCtxt(ctxt);
2003	return(NULL);
2004    }
2005    sock = xmlNanoFTPGetSocket(ctxt, ctxt->path);
2006    if (sock < 0) {
2007	xmlNanoFTPFreeCtxt(ctxt);
2008	return(NULL);
2009    }
2010    return(ctxt);
2011}
2012
2013/**
2014 * xmlNanoFTPClose:
2015 * @ctx: an FTP context
2016 *
2017 * Close the connection and both control and transport
2018 *
2019 * Returns -1 incase of error, 0 otherwise
2020 */
2021
2022int
2023xmlNanoFTPClose(void *ctx) {
2024    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
2025
2026    if (ctxt == NULL)
2027	return(-1);
2028
2029    if (ctxt->dataFd >= 0) {
2030	closesocket(ctxt->dataFd);
2031	ctxt->dataFd = -1;
2032    }
2033    if (ctxt->controlFd >= 0) {
2034	xmlNanoFTPQuit(ctxt);
2035	closesocket(ctxt->controlFd);
2036	ctxt->controlFd = -1;
2037    }
2038    xmlNanoFTPFreeCtxt(ctxt);
2039    return(0);
2040}
2041
2042#ifdef STANDALONE
2043/************************************************************************
2044 * 									*
2045 * 			Basic test in Standalone mode			*
2046 * 									*
2047 ************************************************************************/
2048static
2049void ftpList(void *userData, const char *filename, const char* attrib,
2050	     const char *owner, const char *group, unsigned long size, int links,
2051	     int year, const char *month, int day, int hour, int minute) {
2052    xmlGenericError(xmlGenericErrorContext,
2053	    "%s %s %s %ld %s\n", attrib, owner, group, size, filename);
2054}
2055static
2056void ftpData(void *userData, const char *data, int len) {
2057    if (userData == NULL) return;
2058    if (len <= 0) {
2059	fclose((FILE*)userData);
2060	return;
2061    }
2062    fwrite(data, len, 1, (FILE*)userData);
2063}
2064
2065int main(int argc, char **argv) {
2066    void *ctxt;
2067    FILE *output;
2068    char *tstfile = NULL;
2069
2070    xmlNanoFTPInit();
2071    if (argc > 1) {
2072	ctxt = xmlNanoFTPNewCtxt(argv[1]);
2073	if (xmlNanoFTPConnect(ctxt) < 0) {
2074	    xmlGenericError(xmlGenericErrorContext,
2075		    "Couldn't connect to %s\n", argv[1]);
2076	    exit(1);
2077	}
2078	if (argc > 2)
2079	    tstfile = argv[2];
2080    } else
2081	ctxt = xmlNanoFTPConnectTo("localhost", 0);
2082    if (ctxt == NULL) {
2083        xmlGenericError(xmlGenericErrorContext,
2084		"Couldn't connect to localhost\n");
2085        exit(1);
2086    }
2087    xmlNanoFTPList(ctxt, ftpList, NULL, tstfile);
2088    output = fopen("/tmp/tstdata", "w");
2089    if (output != NULL) {
2090	if (xmlNanoFTPGet(ctxt, ftpData, (void *) output, tstfile) < 0)
2091	    xmlGenericError(xmlGenericErrorContext,
2092		    "Failed to get file\n");
2093
2094    }
2095    xmlNanoFTPClose(ctxt);
2096    xmlMemoryDump();
2097    exit(0);
2098}
2099#endif /* STANDALONE */
2100#else /* !LIBXML_FTP_ENABLED */
2101#ifdef STANDALONE
2102#include <stdio.h>
2103int main(int argc, char **argv) {
2104    xmlGenericError(xmlGenericErrorContext,
2105	    "%s : FTP support not compiled in\n", argv[0]);
2106    return(0);
2107}
2108#endif /* STANDALONE */
2109#endif /* LIBXML_FTP_ENABLED */
2110#define bottom_nanoftp
2111#include "elfgcchack.h"
2112