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
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
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
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
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
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
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
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
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*
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
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
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
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
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
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
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
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
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
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
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*
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
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
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
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
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
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
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
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
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
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*
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
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
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
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:
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>
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"
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to nanoftp.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2