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, 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, 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, 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 __xmlIOErr(XML_FROM_FTP, 0, "gethostbyname address mismatch");
912 return (-1);
913 }
914 if (tmp->ai_family == AF_INET6) {
915 memcpy (&ctxt->ftpAddr, tmp->ai_addr, tmp->ai_addrlen);
916 ((struct sockaddr_in6 *) &ctxt->ftpAddr)->sin6_port = htons (port);
917 ctxt->controlFd = socket (AF_INET6, SOCK_STREAM, 0);
918 }
919 else {
920 memcpy (&ctxt->ftpAddr, tmp->ai_addr, tmp->ai_addrlen);
921 ((struct sockaddr_in *) &ctxt->ftpAddr)->sin_port = htons (port);
922 ctxt->controlFd = socket (AF_INET, SOCK_STREAM, 0);
923 }
924 addrlen = tmp->ai_addrlen;
925 freeaddrinfo (result);
926 }
927 else
928 #endif
929 {
930 if (proxy)
931 hp = gethostbyname (proxy);
932 else
933 hp = gethostbyname (ctxt->hostname);
934 if (hp == NULL) {
935 __xmlIOErr(XML_FROM_FTP, 0, "gethostbyname failed");
936 return (-1);
937 }
938 if ((unsigned int) hp->h_length >
939 sizeof(((struct sockaddr_in *)&ctxt->ftpAddr)->sin_addr)) {
940 __xmlIOErr(XML_FROM_FTP, 0, "gethostbyname address mismatch");
941 return (-1);
942 }
943
944 /*
945 * Prepare the socket
946 */
947 ((struct sockaddr_in *)&ctxt->ftpAddr)->sin_family = AF_INET;
948 memcpy (&((struct sockaddr_in *)&ctxt->ftpAddr)->sin_addr,
949 hp->h_addr_list[0], hp->h_length);
950 ((struct sockaddr_in *)&ctxt->ftpAddr)->sin_port = (u_short)htons ((unsigned short)port);
951 ctxt->controlFd = socket (AF_INET, SOCK_STREAM, 0);
952 addrlen = sizeof (struct sockaddr_in);
953 }
954
955 if (ctxt->controlFd == INVALID_SOCKET) {
956 __xmlIOErr(XML_FROM_FTP, 0, "socket failed");
957 return(-1);
958 }
959
960 /*
961 * Do the connect.
962 */
963 if (connect(ctxt->controlFd, (struct sockaddr *) &ctxt->ftpAddr,
964 addrlen) < 0) {
965 __xmlIOErr(XML_FROM_FTP, 0, "Failed to create a connection");
966 closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET;
967 ctxt->controlFd = INVALID_SOCKET;
968 return(-1);
969 }
970
971 /*
972 * Wait for the HELLO from the server.
973 */
974 res = xmlNanoFTPGetResponse(ctxt);
975 if (res != 2) {
976 closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET;
977 ctxt->controlFd = INVALID_SOCKET;
978 return(-1);
979 }
980
981 /*
982 * State diagram for the login operation on the FTP server
983 *
984 * Reference: RFC 959
985 *
986 * 1
987 * +---+ USER +---+------------->+---+
988 * | B |---------->| W | 2 ---->| E |
989 * +---+ +---+------ | -->+---+
990 * | | | | |
991 * 3 | | 4,5 | | |
992 * -------------- ----- | | |
993 * | | | | |
994 * | | | | |
995 * | --------- |
996 * | 1| | | |
997 * V | | | |
998 * +---+ PASS +---+ 2 | ------>+---+
999 * | |---------->| W |------------->| S |
1000 * +---+ +---+ ---------->+---+
1001 * | | | | |
1002 * 3 | |4,5| | |
1003 * -------------- -------- |
1004 * | | | | |
1005 * | | | | |
1006 * | -----------
1007 * | 1,3| | | |
1008 * V | 2| | |
1009 * +---+ ACCT +---+-- | ----->+---+
1010 * | |---------->| W | 4,5 -------->| F |
1011 * +---+ +---+------------->+---+
1012 *
1013 * Of course in case of using a proxy this get really nasty and is not
1014 * standardized at all :-(
1015 */
1016 if (proxy) {
1017 int len;
1018 char buf[400];
1019
1020 if (proxyUser != NULL) {
1021 /*
1022 * We need proxy auth
1023 */
1024 snprintf(buf, sizeof(buf), "USER %s\r\n", proxyUser);
1025 buf[sizeof(buf) - 1] = 0;
1026 len = strlen(buf);
1027 #ifdef DEBUG_FTP
1028 xmlGenericError(xmlGenericErrorContext, "%s", buf);
1029 #endif
1030 res = send(ctxt->controlFd, buf, len, 0);
1031 if (res < 0) {
1032 __xmlIOErr(XML_FROM_FTP, 0, "send failed");
1033 closesocket(ctxt->controlFd);
1034 ctxt->controlFd = INVALID_SOCKET;
1035 return(res);
1036 }
1037 res = xmlNanoFTPGetResponse(ctxt);
1038 switch (res) {
1039 case 2:
1040 if (proxyPasswd == NULL)
1041 break;
1042 case 3:
1043 if (proxyPasswd != NULL)
1044 snprintf(buf, sizeof(buf), "PASS %s\r\n", proxyPasswd);
1045 else
1046 snprintf(buf, sizeof(buf), "PASS anonymous@\r\n");
1047 buf[sizeof(buf) - 1] = 0;
1048 len = strlen(buf);
1049 #ifdef DEBUG_FTP
1050 xmlGenericError(xmlGenericErrorContext, "%s", buf);
1051 #endif
1052 res = send(ctxt->controlFd, buf, len, 0);
1053 if (res < 0) {
1054 __xmlIOErr(XML_FROM_FTP, 0, "send failed");
1055 closesocket(ctxt->controlFd);
1056 ctxt->controlFd = INVALID_SOCKET;
1057 return(res);
1058 }
1059 res = xmlNanoFTPGetResponse(ctxt);
1060 if (res > 3) {
1061 closesocket(ctxt->controlFd);
1062 ctxt->controlFd = INVALID_SOCKET;
1063 return(-1);
1064 }
1065 break;
1066 case 1:
1067 break;
1068 case 4:
1069 case 5:
1070 case -1:
1071 default:
1072 closesocket(ctxt->controlFd);
1073 ctxt->controlFd = INVALID_SOCKET;
1074 return(-1);
1075 }
1076 }
1077
1078 /*
1079 * We assume we don't need more authentication to the proxy
1080 * and that it succeeded :-\
1081 */
1082 switch (proxyType) {
1083 case 0:
1084 /* we will try in sequence */
1085 case 1:
1086 /* Using SITE command */
1087 snprintf(buf, sizeof(buf), "SITE %s\r\n", ctxt->hostname);
1088 buf[sizeof(buf) - 1] = 0;
1089 len = strlen(buf);
1090 #ifdef DEBUG_FTP
1091 xmlGenericError(xmlGenericErrorContext, "%s", buf);
1092 #endif
1093 res = send(ctxt->controlFd, buf, len, 0);
1094 if (res < 0) {
1095 __xmlIOErr(XML_FROM_FTP, 0, "send failed");
1096 closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET;
1097 ctxt->controlFd = INVALID_SOCKET;
1098 return(res);
1099 }
1100 res = xmlNanoFTPGetResponse(ctxt);
1101 if (res == 2) {
1102 /* we assume it worked :-\ 1 is error for SITE command */
1103 proxyType = 1;
1104 break;
1105 }
1106 if (proxyType == 1) {
1107 closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET;
1108 ctxt->controlFd = INVALID_SOCKET;
1109 return(-1);
1110 }
1111 case 2:
1112 /* USER user@host command */
1113 if (ctxt->user == NULL)
1114 snprintf(buf, sizeof(buf), "USER anonymous@%s\r\n",
1115 ctxt->hostname);
1116 else
1117 snprintf(buf, sizeof(buf), "USER %s@%s\r\n",
1118 ctxt->user, ctxt->hostname);
1119 buf[sizeof(buf) - 1] = 0;
1120 len = strlen(buf);
1121 #ifdef DEBUG_FTP
1122 xmlGenericError(xmlGenericErrorContext, "%s", buf);
1123 #endif
1124 res = send(ctxt->controlFd, buf, len, 0);
1125 if (res < 0) {
1126 __xmlIOErr(XML_FROM_FTP, 0, "send failed");
1127 closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET;
1128 ctxt->controlFd = INVALID_SOCKET;
1129 return(res);
1130 }
1131 res = xmlNanoFTPGetResponse(ctxt);
1132 if ((res == 1) || (res == 2)) {
1133 /* we assume it worked :-\ */
1134 proxyType = 2;
1135 return(0);
1136 }
1137 if (ctxt->passwd == NULL)
1138 snprintf(buf, sizeof(buf), "PASS anonymous@\r\n");
1139 else
1140 snprintf(buf, sizeof(buf), "PASS %s\r\n", ctxt->passwd);
1141 buf[sizeof(buf) - 1] = 0;
1142 len = strlen(buf);
1143 #ifdef DEBUG_FTP
1144 xmlGenericError(xmlGenericErrorContext, "%s", buf);
1145 #endif
1146 res = send(ctxt->controlFd, buf, len, 0);
1147 if (res < 0) {
1148 __xmlIOErr(XML_FROM_FTP, 0, "send failed");
1149 closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET;
1150 ctxt->controlFd = INVALID_SOCKET;
1151 return(res);
1152 }
1153 res = xmlNanoFTPGetResponse(ctxt);
1154 if ((res == 1) || (res == 2)) {
1155 /* we assume it worked :-\ */
1156 proxyType = 2;
1157 return(0);
1158 }
1159 if (proxyType == 2) {
1160 closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET;
1161 ctxt->controlFd = INVALID_SOCKET;
1162 return(-1);
1163 }
1164 case 3:
1165 /*
1166 * If you need support for other Proxy authentication scheme
1167 * send the code or at least the sequence in use.
1168 */
1169 default:
1170 closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET;
1171 ctxt->controlFd = INVALID_SOCKET;
1172 return(-1);
1173 }
1174 }
1175 /*
1176 * Non-proxy handling.
1177 */
1178 res = xmlNanoFTPSendUser(ctxt);
1179 if (res < 0) {
1180 closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET;
1181 ctxt->controlFd = INVALID_SOCKET;
1182 return(-1);
1183 }
1184 res = xmlNanoFTPGetResponse(ctxt);
1185 switch (res) {
1186 case 2:
1187 return(0);
1188 case 3:
1189 break;
1190 case 1:
1191 case 4:
1192 case 5:
1193 case -1:
1194 default:
1195 closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET;
1196 ctxt->controlFd = INVALID_SOCKET;
1197 return(-1);
1198 }
1199 res = xmlNanoFTPSendPasswd(ctxt);
1200 if (res < 0) {
1201 closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET;
1202 ctxt->controlFd = INVALID_SOCKET;
1203 return(-1);
1204 }
1205 res = xmlNanoFTPGetResponse(ctxt);
1206 switch (res) {
1207 case 2:
1208 break;
1209 case 3:
1210 __xmlIOErr(XML_FROM_FTP, XML_FTP_ACCNT,
1211 "FTP server asking for ACCNT on anonymous\n");
1212 case 1:
1213 case 4:
1214 case 5:
1215 case -1:
1216 default:
1217 closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET;
1218 ctxt->controlFd = INVALID_SOCKET;
1219 return(-1);
1220 }
1221
1222 return(0);
1223 }
1224
1225 /**
1226 * xmlNanoFTPConnectTo:
1227 * @server: an FTP server name
1228 * @port: the port (use 21 if 0)
1229 *
1230 * Tries to open a control connection to the given server/port
1231 *
1232 * Returns an fTP context or NULL if it failed
1233 */
1234
1235 void*
xmlNanoFTPConnectTo(const char * server,int port)1236 xmlNanoFTPConnectTo(const char *server, int port) {
1237 xmlNanoFTPCtxtPtr ctxt;
1238 int res;
1239
1240 xmlNanoFTPInit();
1241 if (server == NULL)
1242 return(NULL);
1243 if (port <= 0)
1244 return(NULL);
1245 ctxt = (xmlNanoFTPCtxtPtr) xmlNanoFTPNewCtxt(NULL);
1246 ctxt->hostname = xmlMemStrdup(server);
1247 if (port != 0)
1248 ctxt->port = port;
1249 res = xmlNanoFTPConnect(ctxt);
1250 if (res < 0) {
1251 xmlNanoFTPFreeCtxt(ctxt);
1252 return(NULL);
1253 }
1254 return(ctxt);
1255 }
1256
1257 /**
1258 * xmlNanoFTPCwd:
1259 * @ctx: an FTP context
1260 * @directory: a directory on the server
1261 *
1262 * Tries to change the remote directory
1263 *
1264 * Returns -1 incase of error, 1 if CWD worked, 0 if it failed
1265 */
1266
1267 int
xmlNanoFTPCwd(void * ctx,const char * directory)1268 xmlNanoFTPCwd(void *ctx, const char *directory) {
1269 xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
1270 char buf[400];
1271 int len;
1272 int res;
1273
1274 if ((ctxt == NULL) || (ctxt->controlFd == INVALID_SOCKET)) return(-1);
1275 if (directory == NULL) return 0;
1276
1277 /*
1278 * Expected response code for CWD:
1279 *
1280 * CWD
1281 * 250
1282 * 500, 501, 502, 421, 530, 550
1283 */
1284 snprintf(buf, sizeof(buf), "CWD %s\r\n", directory);
1285 buf[sizeof(buf) - 1] = 0;
1286 len = strlen(buf);
1287 #ifdef DEBUG_FTP
1288 xmlGenericError(xmlGenericErrorContext, "%s", buf);
1289 #endif
1290 res = send(ctxt->controlFd, buf, len, 0);
1291 if (res < 0) {
1292 __xmlIOErr(XML_FROM_FTP, 0, "send failed");
1293 return(res);
1294 }
1295 res = xmlNanoFTPGetResponse(ctxt);
1296 if (res == 4) {
1297 return(-1);
1298 }
1299 if (res == 2) return(1);
1300 if (res == 5) {
1301 return(0);
1302 }
1303 return(0);
1304 }
1305
1306 /**
1307 * xmlNanoFTPDele:
1308 * @ctx: an FTP context
1309 * @file: a file or directory on the server
1310 *
1311 * Tries to delete an item (file or directory) from server
1312 *
1313 * Returns -1 incase of error, 1 if DELE worked, 0 if it failed
1314 */
1315
1316 int
xmlNanoFTPDele(void * ctx,const char * file)1317 xmlNanoFTPDele(void *ctx, const char *file) {
1318 xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
1319 char buf[400];
1320 int len;
1321 int res;
1322
1323 if ((ctxt == NULL) || (ctxt->controlFd == INVALID_SOCKET) || (file == NULL)) return(-1);
1324 if (file == NULL) return (0);
1325
1326 /*
1327 * Expected response code for DELE:
1328 *
1329 * DELE
1330 * 250
1331 * 450, 550
1332 * 500, 501, 502, 421, 530
1333 */
1334
1335 snprintf(buf, sizeof(buf), "DELE %s\r\n", file);
1336 buf[sizeof(buf) - 1] = 0;
1337 len = strlen(buf);
1338 #ifdef DEBUG_FTP
1339 xmlGenericError(xmlGenericErrorContext, "%s", buf);
1340 #endif
1341 res = send(ctxt->controlFd, buf, len, 0);
1342 if (res < 0) {
1343 __xmlIOErr(XML_FROM_FTP, 0, "send failed");
1344 return(res);
1345 }
1346 res = xmlNanoFTPGetResponse(ctxt);
1347 if (res == 4) {
1348 return(-1);
1349 }
1350 if (res == 2) return(1);
1351 if (res == 5) {
1352 return(0);
1353 }
1354 return(0);
1355 }
1356 /**
1357 * xmlNanoFTPGetConnection:
1358 * @ctx: an FTP context
1359 *
1360 * Try to open a data connection to the server. Currently only
1361 * passive mode is supported.
1362 *
1363 * Returns -1 incase of error, 0 otherwise
1364 */
1365
1366 SOCKET
xmlNanoFTPGetConnection(void * ctx)1367 xmlNanoFTPGetConnection(void *ctx) {
1368 xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
1369 char buf[200], *cur;
1370 int len, i;
1371 int res;
1372 unsigned char ad[6], *adp, *portp;
1373 unsigned int temp[6];
1374 #ifdef SUPPORT_IP6
1375 struct sockaddr_storage dataAddr;
1376 #else
1377 struct sockaddr_in dataAddr;
1378 #endif
1379 XML_SOCKLEN_T dataAddrLen;
1380
1381 if (ctxt == NULL) return INVALID_SOCKET;
1382
1383 memset (&dataAddr, 0, sizeof(dataAddr));
1384 #ifdef SUPPORT_IP6
1385 if ((ctxt->ftpAddr).ss_family == AF_INET6) {
1386 ctxt->dataFd = socket (AF_INET6, SOCK_STREAM, IPPROTO_TCP);
1387 ((struct sockaddr_in6 *)&dataAddr)->sin6_family = AF_INET6;
1388 dataAddrLen = sizeof(struct sockaddr_in6);
1389 } else
1390 #endif
1391 {
1392 ctxt->dataFd = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
1393 ((struct sockaddr_in *)&dataAddr)->sin_family = AF_INET;
1394 dataAddrLen = sizeof (struct sockaddr_in);
1395 }
1396
1397 if (ctxt->dataFd == INVALID_SOCKET) {
1398 __xmlIOErr(XML_FROM_FTP, 0, "socket failed");
1399 return INVALID_SOCKET;
1400 }
1401
1402 if (ctxt->passive) {
1403 #ifdef SUPPORT_IP6
1404 if ((ctxt->ftpAddr).ss_family == AF_INET6)
1405 snprintf (buf, sizeof(buf), "EPSV\r\n");
1406 else
1407 #endif
1408 snprintf (buf, sizeof(buf), "PASV\r\n");
1409 len = strlen (buf);
1410 #ifdef DEBUG_FTP
1411 xmlGenericError(xmlGenericErrorContext, "%s", buf);
1412 #endif
1413 res = send(ctxt->controlFd, buf, len, 0);
1414 if (res < 0) {
1415 __xmlIOErr(XML_FROM_FTP, 0, "send failed");
1416 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
1417 return INVALID_SOCKET;
1418 }
1419 res = xmlNanoFTPReadResponse(ctx);
1420 if (res != 2) {
1421 if (res == 5) {
1422 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
1423 return INVALID_SOCKET;
1424 } else {
1425 /*
1426 * retry with an active connection
1427 */
1428 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
1429 ctxt->passive = 0;
1430 }
1431 }
1432 cur = &ctxt->controlBuf[ctxt->controlBufAnswer];
1433 while (((*cur < '0') || (*cur > '9')) && *cur != '\0') cur++;
1434 #ifdef SUPPORT_IP6
1435 if ((ctxt->ftpAddr).ss_family == AF_INET6) {
1436 if (sscanf (cur, "%u", &temp[0]) != 1) {
1437 __xmlIOErr(XML_FROM_FTP, XML_FTP_EPSV_ANSWER,
1438 "Invalid answer to EPSV\n");
1439 if (ctxt->dataFd != INVALID_SOCKET) {
1440 closesocket (ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
1441 }
1442 return INVALID_SOCKET;
1443 }
1444 memcpy (&((struct sockaddr_in6 *)&dataAddr)->sin6_addr, &((struct sockaddr_in6 *)&ctxt->ftpAddr)->sin6_addr, sizeof(struct in6_addr));
1445 ((struct sockaddr_in6 *)&dataAddr)->sin6_port = htons (temp[0]);
1446 }
1447 else
1448 #endif
1449 {
1450 if (sscanf (cur, "%u,%u,%u,%u,%u,%u", &temp[0], &temp[1], &temp[2],
1451 &temp[3], &temp[4], &temp[5]) != 6) {
1452 __xmlIOErr(XML_FROM_FTP, XML_FTP_PASV_ANSWER,
1453 "Invalid answer to PASV\n");
1454 if (ctxt->dataFd != INVALID_SOCKET) {
1455 closesocket (ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
1456 }
1457 return INVALID_SOCKET;
1458 }
1459 for (i=0; i<6; i++) ad[i] = (unsigned char) (temp[i] & 0xff);
1460 memcpy (&((struct sockaddr_in *)&dataAddr)->sin_addr, &ad[0], 4);
1461 memcpy (&((struct sockaddr_in *)&dataAddr)->sin_port, &ad[4], 2);
1462 }
1463
1464 if (connect(ctxt->dataFd, (struct sockaddr *) &dataAddr, dataAddrLen) < 0) {
1465 __xmlIOErr(XML_FROM_FTP, 0, "Failed to create a data connection");
1466 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
1467 return INVALID_SOCKET;
1468 }
1469 } else {
1470 getsockname(ctxt->dataFd, (struct sockaddr *) &dataAddr, &dataAddrLen);
1471 #ifdef SUPPORT_IP6
1472 if ((ctxt->ftpAddr).ss_family == AF_INET6)
1473 ((struct sockaddr_in6 *)&dataAddr)->sin6_port = 0;
1474 else
1475 #endif
1476 ((struct sockaddr_in *)&dataAddr)->sin_port = 0;
1477
1478 if (bind(ctxt->dataFd, (struct sockaddr *) &dataAddr, dataAddrLen) < 0) {
1479 __xmlIOErr(XML_FROM_FTP, 0, "bind failed");
1480 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
1481 return INVALID_SOCKET;
1482 }
1483 getsockname(ctxt->dataFd, (struct sockaddr *) &dataAddr, &dataAddrLen);
1484
1485 if (listen(ctxt->dataFd, 1) < 0) {
1486 __xmlIOErr(XML_FROM_FTP, 0, "listen failed");
1487 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
1488 return INVALID_SOCKET;
1489 }
1490 #ifdef SUPPORT_IP6
1491 if ((ctxt->ftpAddr).ss_family == AF_INET6) {
1492 char buf6[INET6_ADDRSTRLEN];
1493 inet_ntop (AF_INET6, &((struct sockaddr_in6 *)&dataAddr)->sin6_addr,
1494 buf6, INET6_ADDRSTRLEN);
1495 adp = (unsigned char *) buf6;
1496 portp = (unsigned char *) &((struct sockaddr_in6 *)&dataAddr)->sin6_port;
1497 snprintf (buf, sizeof(buf), "EPRT |2|%s|%s|\r\n", adp, portp);
1498 } else
1499 #endif
1500 {
1501 adp = (unsigned char *) &((struct sockaddr_in *)&dataAddr)->sin_addr;
1502 portp = (unsigned char *) &((struct sockaddr_in *)&dataAddr)->sin_port;
1503 snprintf (buf, sizeof(buf), "PORT %d,%d,%d,%d,%d,%d\r\n",
1504 adp[0] & 0xff, adp[1] & 0xff, adp[2] & 0xff, adp[3] & 0xff,
1505 portp[0] & 0xff, portp[1] & 0xff);
1506 }
1507
1508 buf[sizeof(buf) - 1] = 0;
1509 len = strlen(buf);
1510 #ifdef DEBUG_FTP
1511 xmlGenericError(xmlGenericErrorContext, "%s", buf);
1512 #endif
1513
1514 res = send(ctxt->controlFd, buf, len, 0);
1515 if (res < 0) {
1516 __xmlIOErr(XML_FROM_FTP, 0, "send failed");
1517 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
1518 return INVALID_SOCKET;
1519 }
1520 res = xmlNanoFTPGetResponse(ctxt);
1521 if (res != 2) {
1522 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
1523 return INVALID_SOCKET;
1524 }
1525 }
1526 return(ctxt->dataFd);
1527
1528 }
1529
1530 /**
1531 * xmlNanoFTPCloseConnection:
1532 * @ctx: an FTP context
1533 *
1534 * Close the data connection from the server
1535 *
1536 * Returns -1 incase of error, 0 otherwise
1537 */
1538
1539 int
xmlNanoFTPCloseConnection(void * ctx)1540 xmlNanoFTPCloseConnection(void *ctx) {
1541 xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
1542 int res;
1543 fd_set rfd, efd;
1544 struct timeval tv;
1545
1546 if ((ctxt == NULL) || (ctxt->controlFd == INVALID_SOCKET)) return(-1);
1547
1548 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
1549 tv.tv_sec = 15;
1550 tv.tv_usec = 0;
1551 FD_ZERO(&rfd);
1552 FD_SET(ctxt->controlFd, &rfd);
1553 FD_ZERO(&efd);
1554 FD_SET(ctxt->controlFd, &efd);
1555 res = select(ctxt->controlFd + 1, &rfd, NULL, &efd, &tv);
1556 if (res < 0) {
1557 #ifdef DEBUG_FTP
1558 perror("select");
1559 #endif
1560 closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET;
1561 return(-1);
1562 }
1563 if (res == 0) {
1564 #ifdef DEBUG_FTP
1565 xmlGenericError(xmlGenericErrorContext,
1566 "xmlNanoFTPCloseConnection: timeout\n");
1567 #endif
1568 closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET;
1569 } else {
1570 res = xmlNanoFTPGetResponse(ctxt);
1571 if (res != 2) {
1572 closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET;
1573 return(-1);
1574 }
1575 }
1576 return(0);
1577 }
1578
1579 /**
1580 * xmlNanoFTPParseList:
1581 * @list: some data listing received from the server
1582 * @callback: the user callback
1583 * @userData: the user callback data
1584 *
1585 * Parse at most one entry from the listing.
1586 *
1587 * Returns -1 incase of error, the length of data parsed otherwise
1588 */
1589
1590 static int
xmlNanoFTPParseList(const char * list,ftpListCallback callback,void * userData)1591 xmlNanoFTPParseList(const char *list, ftpListCallback callback, void *userData) {
1592 const char *cur = list;
1593 char filename[151];
1594 char attrib[11];
1595 char owner[11];
1596 char group[11];
1597 char month[4];
1598 int year = 0;
1599 int minute = 0;
1600 int hour = 0;
1601 int day = 0;
1602 unsigned long size = 0;
1603 int links = 0;
1604 int i;
1605
1606 if (!strncmp(cur, "total", 5)) {
1607 cur += 5;
1608 while (*cur == ' ') cur++;
1609 while ((*cur >= '0') && (*cur <= '9'))
1610 links = (links * 10) + (*cur++ - '0');
1611 while ((*cur == ' ') || (*cur == '\n') || (*cur == '\r'))
1612 cur++;
1613 return(cur - list);
1614 } else if (*list == '+') {
1615 return(0);
1616 } else {
1617 while ((*cur == ' ') || (*cur == '\n') || (*cur == '\r'))
1618 cur++;
1619 if (*cur == 0) return(0);
1620 i = 0;
1621 while (*cur != ' ') {
1622 if (i < 10)
1623 attrib[i++] = *cur;
1624 cur++;
1625 if (*cur == 0) return(0);
1626 }
1627 attrib[10] = 0;
1628 while (*cur == ' ') cur++;
1629 if (*cur == 0) return(0);
1630 while ((*cur >= '0') && (*cur <= '9'))
1631 links = (links * 10) + (*cur++ - '0');
1632 while (*cur == ' ') cur++;
1633 if (*cur == 0) return(0);
1634 i = 0;
1635 while (*cur != ' ') {
1636 if (i < 10)
1637 owner[i++] = *cur;
1638 cur++;
1639 if (*cur == 0) return(0);
1640 }
1641 owner[i] = 0;
1642 while (*cur == ' ') cur++;
1643 if (*cur == 0) return(0);
1644 i = 0;
1645 while (*cur != ' ') {
1646 if (i < 10)
1647 group[i++] = *cur;
1648 cur++;
1649 if (*cur == 0) return(0);
1650 }
1651 group[i] = 0;
1652 while (*cur == ' ') cur++;
1653 if (*cur == 0) return(0);
1654 while ((*cur >= '0') && (*cur <= '9'))
1655 size = (size * 10) + (*cur++ - '0');
1656 while (*cur == ' ') cur++;
1657 if (*cur == 0) return(0);
1658 i = 0;
1659 while (*cur != ' ') {
1660 if (i < 3)
1661 month[i++] = *cur;
1662 cur++;
1663 if (*cur == 0) return(0);
1664 }
1665 month[i] = 0;
1666 while (*cur == ' ') cur++;
1667 if (*cur == 0) return(0);
1668 while ((*cur >= '0') && (*cur <= '9'))
1669 day = (day * 10) + (*cur++ - '0');
1670 while (*cur == ' ') cur++;
1671 if (*cur == 0) return(0);
1672 if ((cur[1] == 0) || (cur[2] == 0)) return(0);
1673 if ((cur[1] == ':') || (cur[2] == ':')) {
1674 while ((*cur >= '0') && (*cur <= '9'))
1675 hour = (hour * 10) + (*cur++ - '0');
1676 if (*cur == ':') cur++;
1677 while ((*cur >= '0') && (*cur <= '9'))
1678 minute = (minute * 10) + (*cur++ - '0');
1679 } else {
1680 while ((*cur >= '0') && (*cur <= '9'))
1681 year = (year * 10) + (*cur++ - '0');
1682 }
1683 while (*cur == ' ') cur++;
1684 if (*cur == 0) return(0);
1685 i = 0;
1686 while ((*cur != '\n') && (*cur != '\r')) {
1687 if (i < 150)
1688 filename[i++] = *cur;
1689 cur++;
1690 if (*cur == 0) return(0);
1691 }
1692 filename[i] = 0;
1693 if ((*cur != '\n') && (*cur != '\r'))
1694 return(0);
1695 while ((*cur == '\n') || (*cur == '\r'))
1696 cur++;
1697 }
1698 if (callback != NULL) {
1699 callback(userData, filename, attrib, owner, group, size, links,
1700 year, month, day, hour, minute);
1701 }
1702 return(cur - list);
1703 }
1704
1705 /**
1706 * xmlNanoFTPList:
1707 * @ctx: an FTP context
1708 * @callback: the user callback
1709 * @userData: the user callback data
1710 * @filename: optional files to list
1711 *
1712 * Do a listing on the server. All files info are passed back
1713 * in the callbacks.
1714 *
1715 * Returns -1 incase of error, 0 otherwise
1716 */
1717
1718 int
xmlNanoFTPList(void * ctx,ftpListCallback callback,void * userData,const char * filename)1719 xmlNanoFTPList(void *ctx, ftpListCallback callback, void *userData,
1720 const char *filename) {
1721 xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
1722 char buf[4096 + 1];
1723 int len, res;
1724 int indx = 0, base;
1725 fd_set rfd, efd;
1726 struct timeval tv;
1727
1728 if (ctxt == NULL) return (-1);
1729 if (filename == NULL) {
1730 if (xmlNanoFTPCwd(ctxt, ctxt->path) < 1)
1731 return(-1);
1732 ctxt->dataFd = xmlNanoFTPGetConnection(ctxt);
1733 if (ctxt->dataFd == INVALID_SOCKET)
1734 return(-1);
1735 snprintf(buf, sizeof(buf), "LIST -L\r\n");
1736 } else {
1737 if (filename[0] != '/') {
1738 if (xmlNanoFTPCwd(ctxt, ctxt->path) < 1)
1739 return(-1);
1740 }
1741 ctxt->dataFd = xmlNanoFTPGetConnection(ctxt);
1742 if (ctxt->dataFd == INVALID_SOCKET)
1743 return(-1);
1744 snprintf(buf, sizeof(buf), "LIST -L %s\r\n", filename);
1745 }
1746 buf[sizeof(buf) - 1] = 0;
1747 len = strlen(buf);
1748 #ifdef DEBUG_FTP
1749 xmlGenericError(xmlGenericErrorContext, "%s", buf);
1750 #endif
1751 res = send(ctxt->controlFd, buf, len, 0);
1752 if (res < 0) {
1753 __xmlIOErr(XML_FROM_FTP, 0, "send failed");
1754 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
1755 return(res);
1756 }
1757 res = xmlNanoFTPReadResponse(ctxt);
1758 if (res != 1) {
1759 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
1760 return(-res);
1761 }
1762
1763 do {
1764 tv.tv_sec = 1;
1765 tv.tv_usec = 0;
1766 FD_ZERO(&rfd);
1767 FD_SET(ctxt->dataFd, &rfd);
1768 FD_ZERO(&efd);
1769 FD_SET(ctxt->dataFd, &efd);
1770 res = select(ctxt->dataFd + 1, &rfd, NULL, &efd, &tv);
1771 if (res < 0) {
1772 #ifdef DEBUG_FTP
1773 perror("select");
1774 #endif
1775 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
1776 return(-1);
1777 }
1778 if (res == 0) {
1779 res = xmlNanoFTPCheckResponse(ctxt);
1780 if (res < 0) {
1781 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
1782 ctxt->dataFd = INVALID_SOCKET;
1783 return(-1);
1784 }
1785 if (res == 2) {
1786 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
1787 return(0);
1788 }
1789
1790 continue;
1791 }
1792
1793 if ((len = recv(ctxt->dataFd, &buf[indx], sizeof(buf) - (indx + 1), 0)) < 0) {
1794 __xmlIOErr(XML_FROM_FTP, 0, "recv");
1795 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
1796 ctxt->dataFd = INVALID_SOCKET;
1797 return(-1);
1798 }
1799 #ifdef DEBUG_FTP
1800 write(1, &buf[indx], len);
1801 #endif
1802 indx += len;
1803 buf[indx] = 0;
1804 base = 0;
1805 do {
1806 res = xmlNanoFTPParseList(&buf[base], callback, userData);
1807 base += res;
1808 } while (res > 0);
1809
1810 memmove(&buf[0], &buf[base], indx - base);
1811 indx -= base;
1812 } while (len != 0);
1813 xmlNanoFTPCloseConnection(ctxt);
1814 return(0);
1815 }
1816
1817 /**
1818 * xmlNanoFTPGetSocket:
1819 * @ctx: an FTP context
1820 * @filename: the file to retrieve (or NULL if path is in context).
1821 *
1822 * Initiate fetch of the given file from the server.
1823 *
1824 * Returns the socket for the data connection, or <0 in case of error
1825 */
1826
1827
1828 SOCKET
xmlNanoFTPGetSocket(void * ctx,const char * filename)1829 xmlNanoFTPGetSocket(void *ctx, const char *filename) {
1830 xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
1831 char buf[300];
1832 int res, len;
1833 if (ctx == NULL)
1834 return INVALID_SOCKET;
1835 if ((filename == NULL) && (ctxt->path == NULL))
1836 return INVALID_SOCKET;
1837 ctxt->dataFd = xmlNanoFTPGetConnection(ctxt);
1838 if (ctxt->dataFd == INVALID_SOCKET)
1839 return INVALID_SOCKET;
1840
1841 snprintf(buf, sizeof(buf), "TYPE I\r\n");
1842 len = strlen(buf);
1843 #ifdef DEBUG_FTP
1844 xmlGenericError(xmlGenericErrorContext, "%s", buf);
1845 #endif
1846 res = send(ctxt->controlFd, buf, len, 0);
1847 if (res < 0) {
1848 __xmlIOErr(XML_FROM_FTP, 0, "send failed");
1849 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
1850 return INVALID_SOCKET;
1851 }
1852 res = xmlNanoFTPReadResponse(ctxt);
1853 if (res != 2) {
1854 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
1855 return INVALID_SOCKET;
1856 }
1857 if (filename == NULL)
1858 snprintf(buf, sizeof(buf), "RETR %s\r\n", ctxt->path);
1859 else
1860 snprintf(buf, sizeof(buf), "RETR %s\r\n", filename);
1861 buf[sizeof(buf) - 1] = 0;
1862 len = strlen(buf);
1863 #ifdef DEBUG_FTP
1864 xmlGenericError(xmlGenericErrorContext, "%s", buf);
1865 #endif
1866 res = send(ctxt->controlFd, buf, len, 0);
1867 if (res < 0) {
1868 __xmlIOErr(XML_FROM_FTP, 0, "send failed");
1869 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
1870 return INVALID_SOCKET;
1871 }
1872 res = xmlNanoFTPReadResponse(ctxt);
1873 if (res != 1) {
1874 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
1875 return INVALID_SOCKET;
1876 }
1877 return(ctxt->dataFd);
1878 }
1879
1880 /**
1881 * xmlNanoFTPGet:
1882 * @ctx: an FTP context
1883 * @callback: the user callback
1884 * @userData: the user callback data
1885 * @filename: the file to retrieve
1886 *
1887 * Fetch the given file from the server. All data are passed back
1888 * in the callbacks. The last callback has a size of 0 block.
1889 *
1890 * Returns -1 incase of error, 0 otherwise
1891 */
1892
1893 int
xmlNanoFTPGet(void * ctx,ftpDataCallback callback,void * userData,const char * filename)1894 xmlNanoFTPGet(void *ctx, ftpDataCallback callback, void *userData,
1895 const char *filename) {
1896 xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
1897 char buf[4096];
1898 int len = 0, res;
1899 fd_set rfd;
1900 struct timeval tv;
1901
1902 if (ctxt == NULL) return(-1);
1903 if ((filename == NULL) && (ctxt->path == NULL))
1904 return(-1);
1905 if (callback == NULL)
1906 return(-1);
1907 if (xmlNanoFTPGetSocket(ctxt, filename) == INVALID_SOCKET)
1908 return(-1);
1909
1910 do {
1911 tv.tv_sec = 1;
1912 tv.tv_usec = 0;
1913 FD_ZERO(&rfd);
1914 FD_SET(ctxt->dataFd, &rfd);
1915 res = select(ctxt->dataFd + 1, &rfd, NULL, NULL, &tv);
1916 if (res < 0) {
1917 #ifdef DEBUG_FTP
1918 perror("select");
1919 #endif
1920 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
1921 return(-1);
1922 }
1923 if (res == 0) {
1924 res = xmlNanoFTPCheckResponse(ctxt);
1925 if (res < 0) {
1926 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
1927 ctxt->dataFd = INVALID_SOCKET;
1928 return(-1);
1929 }
1930 if (res == 2) {
1931 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
1932 return(0);
1933 }
1934
1935 continue;
1936 }
1937 if ((len = recv(ctxt->dataFd, buf, sizeof(buf), 0)) < 0) {
1938 __xmlIOErr(XML_FROM_FTP, 0, "recv failed");
1939 callback(userData, buf, len);
1940 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
1941 return(-1);
1942 }
1943 callback(userData, buf, len);
1944 } while (len != 0);
1945
1946 return(xmlNanoFTPCloseConnection(ctxt));
1947 }
1948
1949 /**
1950 * xmlNanoFTPRead:
1951 * @ctx: the FTP context
1952 * @dest: a buffer
1953 * @len: the buffer length
1954 *
1955 * This function tries to read @len bytes from the existing FTP connection
1956 * and saves them in @dest. This is a blocking call.
1957 *
1958 * Returns the number of byte read. 0 is an indication of an end of connection.
1959 * -1 indicates a parameter error.
1960 */
1961 int
xmlNanoFTPRead(void * ctx,void * dest,int len)1962 xmlNanoFTPRead(void *ctx, void *dest, int len) {
1963 xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
1964
1965 if (ctx == NULL) return(-1);
1966 if (ctxt->dataFd == INVALID_SOCKET) return(0);
1967 if (dest == NULL) return(-1);
1968 if (len <= 0) return(0);
1969
1970 len = recv(ctxt->dataFd, dest, len, 0);
1971 if (len <= 0) {
1972 if (len < 0)
1973 __xmlIOErr(XML_FROM_FTP, 0, "recv failed");
1974 xmlNanoFTPCloseConnection(ctxt);
1975 }
1976 #ifdef DEBUG_FTP
1977 xmlGenericError(xmlGenericErrorContext, "Recvd %d bytes\n", len);
1978 #endif
1979 return(len);
1980 }
1981
1982 /**
1983 * xmlNanoFTPOpen:
1984 * @URL: the URL to the resource
1985 *
1986 * Start to fetch the given ftp:// resource
1987 *
1988 * Returns an FTP context, or NULL
1989 */
1990
1991 void*
xmlNanoFTPOpen(const char * URL)1992 xmlNanoFTPOpen(const char *URL) {
1993 xmlNanoFTPCtxtPtr ctxt;
1994 SOCKET sock;
1995
1996 xmlNanoFTPInit();
1997 if (URL == NULL) return(NULL);
1998 if (strncmp("ftp://", URL, 6)) return(NULL);
1999
2000 ctxt = (xmlNanoFTPCtxtPtr) xmlNanoFTPNewCtxt(URL);
2001 if (ctxt == NULL) return(NULL);
2002 if (xmlNanoFTPConnect(ctxt) < 0) {
2003 xmlNanoFTPFreeCtxt(ctxt);
2004 return(NULL);
2005 }
2006 sock = xmlNanoFTPGetSocket(ctxt, ctxt->path);
2007 if (sock == INVALID_SOCKET) {
2008 xmlNanoFTPFreeCtxt(ctxt);
2009 return(NULL);
2010 }
2011 return(ctxt);
2012 }
2013
2014 /**
2015 * xmlNanoFTPClose:
2016 * @ctx: an FTP context
2017 *
2018 * Close the connection and both control and transport
2019 *
2020 * Returns -1 incase of error, 0 otherwise
2021 */
2022
2023 int
xmlNanoFTPClose(void * ctx)2024 xmlNanoFTPClose(void *ctx) {
2025 xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
2026
2027 if (ctxt == NULL)
2028 return(-1);
2029
2030 if (ctxt->dataFd != INVALID_SOCKET) {
2031 closesocket(ctxt->dataFd);
2032 ctxt->dataFd = INVALID_SOCKET;
2033 }
2034 if (ctxt->controlFd != INVALID_SOCKET) {
2035 xmlNanoFTPQuit(ctxt);
2036 closesocket(ctxt->controlFd);
2037 ctxt->controlFd = INVALID_SOCKET;
2038 }
2039 xmlNanoFTPFreeCtxt(ctxt);
2040 return(0);
2041 }
2042
2043 #ifdef STANDALONE
2044 /************************************************************************
2045 * *
2046 * Basic test in Standalone mode *
2047 * *
2048 ************************************************************************/
2049 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)2050 void ftpList(void *userData, const char *filename, const char* attrib,
2051 const char *owner, const char *group, unsigned long size, int links,
2052 int year, const char *month, int day, int hour, int minute) {
2053 xmlGenericError(xmlGenericErrorContext,
2054 "%s %s %s %ld %s\n", attrib, owner, group, size, filename);
2055 }
2056 static
ftpData(void * userData,const char * data,int len)2057 void ftpData(void *userData, const char *data, int len) {
2058 if (userData == NULL) return;
2059 if (len <= 0) {
2060 fclose((FILE*)userData);
2061 return;
2062 }
2063 fwrite(data, len, 1, (FILE*)userData);
2064 }
2065
main(int argc,char ** argv)2066 int main(int argc, char **argv) {
2067 void *ctxt;
2068 FILE *output;
2069 char *tstfile = NULL;
2070
2071 xmlNanoFTPInit();
2072 if (argc > 1) {
2073 ctxt = xmlNanoFTPNewCtxt(argv[1]);
2074 if (xmlNanoFTPConnect(ctxt) < 0) {
2075 xmlGenericError(xmlGenericErrorContext,
2076 "Couldn't connect to %s\n", argv[1]);
2077 exit(1);
2078 }
2079 if (argc > 2)
2080 tstfile = argv[2];
2081 } else
2082 ctxt = xmlNanoFTPConnectTo("localhost", 0);
2083 if (ctxt == NULL) {
2084 xmlGenericError(xmlGenericErrorContext,
2085 "Couldn't connect to localhost\n");
2086 exit(1);
2087 }
2088 xmlNanoFTPList(ctxt, ftpList, NULL, tstfile);
2089 output = fopen("/tmp/tstdata", "w");
2090 if (output != NULL) {
2091 if (xmlNanoFTPGet(ctxt, ftpData, (void *) output, tstfile) < 0)
2092 xmlGenericError(xmlGenericErrorContext,
2093 "Failed to get file\n");
2094
2095 }
2096 xmlNanoFTPClose(ctxt);
2097 xmlMemoryDump();
2098 exit(0);
2099 }
2100 #endif /* STANDALONE */
2101 #else /* !LIBXML_FTP_ENABLED */
2102 #ifdef STANDALONE
2103 #include <stdio.h>
main(int argc,char ** argv)2104 int main(int argc, char **argv) {
2105 xmlGenericError(xmlGenericErrorContext,
2106 "%s : FTP support not compiled in\n", argv[0]);
2107 return(0);
2108 }
2109 #endif /* STANDALONE */
2110 #endif /* LIBXML_FTP_ENABLED */
2111 #define bottom_nanoftp
2112 #include "elfgcchack.h"
2113