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