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