third_party/libxml/src/nanoftp.c

   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"