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