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