/src/libxml2-2.9.7/nanoftp.c

Source (jump to first uncovered line)
/*
 * nanoftp.c: basic FTP client support
 *
 *  Reference: RFC 959
 */

#ifdef TESTING
#define STANDALONE
#define HAVE_STDLIB_H
#define HAVE_UNISTD_H
#define HAVE_SYS_SOCKET_H
#define HAVE_NETINET_IN_H
#define HAVE_NETDB_H
#define HAVE_SYS_TIME_H
#endif /* TESTING */

#define IN_LIBXML
#include "libxml.h"

#ifdef LIBXML_FTP_ENABLED
#include <string.h>

#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif
#ifdef HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
#ifdef HAVE_ARPA_INET_H
#include <arpa/inet.h>
#endif
#ifdef HAVE_NETDB_H
#include <netdb.h>
#endif
#ifdef HAVE_FCNTL_H
#include <fcntl.h>
#endif
#ifdef HAVE_ERRNO_H
#include <errno.h>
#endif
#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif
#ifdef HAVE_SYS_SELECT_H
#include <sys/select.h>
#endif
#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_STRINGS_H
#include <strings.h>
#endif

#include <libxml/xmlmemory.h>
#include <libxml/parser.h>
#include <libxml/xmlerror.h>
#include <libxml/uri.h>
#include <libxml/nanoftp.h>
#include <libxml/globals.h>

/* #define DEBUG_FTP 1  */
#ifdef STANDALONE
#ifndef DEBUG_FTP
#define DEBUG_FTP 1
#endif
#endif


#if defined(_WIN32) && !defined(__CYGWIN__)
#include <wsockcompat.h>
#endif

/**
 * A couple portability macros
 */
#ifndef _WINSOCKAPI_
#if !defined(__BEOS__) || defined(__HAIKU__)
#define closesocket(s) close(s)
#endif
#endif

#ifdef __BEOS__
#ifndef PF_INET
#define PF_INET AF_INET
#endif
#endif

#ifdef _AIX
#ifdef HAVE_BROKEN_SS_FAMILY
#define ss_family __ss_family
#endif
#endif

#ifndef XML_SOCKLEN_T
#define XML_SOCKLEN_T unsigned int
#endif

#define FTP_COMMAND_OK    200
#define FTP_SYNTAX_ERROR  500
#define FTP_GET_PASSWD    331
#define FTP_BUF_SIZE    1024

#define XML_NANO_MAX_URLBUF 4096

typedef struct xmlNanoFTPCtxt {
    char *protocol; /* the protocol name */
    char *hostname; /* the host name */
    int port;   /* the port */
    char *path;   /* the path within the URL */
    char *user;   /* user string */
    char *passwd; /* passwd string */
#ifdef SUPPORT_IP6
    struct sockaddr_storage ftpAddr; /* this is large enough to hold IPv6 address*/
#else
    struct sockaddr_in ftpAddr; /* the socket address struct */
#endif
    int passive;  /* currently we support only passive !!! */
    SOCKET controlFd; /* the file descriptor for the control socket */
    SOCKET dataFd;  /* the file descriptor for the data socket */
    int state;    /* WRITE / READ / CLOSED */
    int returnValue;  /* the protocol return value */
    /* buffer for data received from the control connection */
    char controlBuf[FTP_BUF_SIZE + 1];
    int controlBufIndex;
    int controlBufUsed;
    int controlBufAnswer;
} xmlNanoFTPCtxt, *xmlNanoFTPCtxtPtr;

static int initialized = 0;
static char *proxy = NULL;  /* the proxy name if any */
static int proxyPort = 0; /* the proxy port if any */
static char *proxyUser = NULL;  /* user for proxy authentication */
static char *proxyPasswd = NULL;/* passwd for proxy authentication */
static int proxyType = 0; /* uses TYPE or a@b ? */

#ifdef SUPPORT_IP6
static
int have_ipv6(void) {
    int s;

    s = socket (AF_INET6, SOCK_STREAM, 0);
    if (s != -1) {
  close (s);
  return (1);
    }
    return (0);
}
#endif

/**
 * xmlFTPErrMemory:
 * @extra:  extra informations
 *
 * Handle an out of memory condition
 */
static void
xmlFTPErrMemory(const char *extra)
{
    __xmlSimpleError(XML_FROM_FTP, XML_ERR_NO_MEMORY, NULL, NULL, extra);
}

/**
 * xmlNanoFTPInit:
 *
 * Initialize the FTP protocol layer.
 * Currently it just checks for proxy informations,
 * and get the hostname
 */

void
xmlNanoFTPInit(void) {
    const char *env;
#ifdef _WINSOCKAPI_
    WSADATA wsaData;
#endif

    if (initialized)
  return;

#ifdef _WINSOCKAPI_
    if (WSAStartup(MAKEWORD(1, 1), &wsaData) != 0)
  return;
#endif

    proxyPort = 21;
    env = getenv("no_proxy");
    if (env && ((env[0] == '*' ) && (env[1] == 0)))
  return;
    env = getenv("ftp_proxy");
    if (env != NULL) {
  xmlNanoFTPScanProxy(env);
    } else {
  env = getenv("FTP_PROXY");
  if (env != NULL) {
      xmlNanoFTPScanProxy(env);
  }
    }
    env = getenv("ftp_proxy_user");
    if (env != NULL) {
  proxyUser = xmlMemStrdup(env);
    }
    env = getenv("ftp_proxy_password");
    if (env != NULL) {
  proxyPasswd = xmlMemStrdup(env);
    }
    initialized = 1;
}

/**
 * xmlNanoFTPCleanup:
 *
 * Cleanup the FTP protocol layer. This cleanup proxy informations.
 */

void
xmlNanoFTPCleanup(void) {
    if (proxy != NULL) {
  xmlFree(proxy);
  proxy = NULL;
    }
    if (proxyUser != NULL) {
  xmlFree(proxyUser);
  proxyUser = NULL;
    }
    if (proxyPasswd != NULL) {
  xmlFree(proxyPasswd);
  proxyPasswd = NULL;
    }
#ifdef _WINSOCKAPI_
    if (initialized)
  WSACleanup();
#endif
    initialized = 0;
}

/**
 * xmlNanoFTPProxy:
 * @host:  the proxy host name
 * @port:  the proxy port
 * @user:  the proxy user name
 * @passwd:  the proxy password
 * @type:  the type of proxy 1 for using SITE, 2 for USER a@b
 *
 * Setup the FTP proxy informations.
 * This can also be done by using ftp_proxy ftp_proxy_user and
 * ftp_proxy_password environment variables.
 */

void
xmlNanoFTPProxy(const char *host, int port, const char *user,
          const char *passwd, int type) {
    if (proxy != NULL) {
  xmlFree(proxy);
  proxy = NULL;
    }
    if (proxyUser != NULL) {
  xmlFree(proxyUser);
  proxyUser = NULL;
    }
    if (proxyPasswd != NULL) {
  xmlFree(proxyPasswd);
  proxyPasswd = NULL;
    }
    if (host)
  proxy = xmlMemStrdup(host);
    if (user)
  proxyUser = xmlMemStrdup(user);
    if (passwd)
  proxyPasswd = xmlMemStrdup(passwd);
    proxyPort = port;
    proxyType = type;
}

/**
 * xmlNanoFTPScanURL:
 * @ctx:  an FTP context
 * @URL:  The URL used to initialize the context
 *
 * (Re)Initialize an FTP context by parsing the URL and finding
 * the protocol host port and path it indicates.
 */

static void
xmlNanoFTPScanURL(void *ctx, const char *URL) {
    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
    xmlURIPtr uri;

    /*
     * Clear any existing data from the context
     */
    if (ctxt->protocol != NULL) {
        xmlFree(ctxt->protocol);
  ctxt->protocol = NULL;
    }
    if (ctxt->hostname != NULL) {
        xmlFree(ctxt->hostname);
  ctxt->hostname = NULL;
    }
    if (ctxt->path != NULL) {
        xmlFree(ctxt->path);
  ctxt->path = NULL;
    }
    if (URL == NULL) return;

    uri = xmlParseURIRaw(URL, 1);
    if (uri == NULL)
  return;

    if ((uri->scheme == NULL) || (uri->server == NULL)) {
  xmlFreeURI(uri);
  return;
    }

    ctxt->protocol = xmlMemStrdup(uri->scheme);
    ctxt->hostname = xmlMemStrdup(uri->server);
    if (uri->path != NULL)
  ctxt->path = xmlMemStrdup(uri->path);
    else
  ctxt->path = xmlMemStrdup("/");
    if (uri->port != 0)
  ctxt->port = uri->port;

    if (uri->user != NULL) {
  char *cptr;
  if ((cptr=strchr(uri->user, ':')) == NULL)
      ctxt->user = xmlMemStrdup(uri->user);
  else {
      ctxt->user = (char *)xmlStrndup((xmlChar *)uri->user,
          (cptr - uri->user));
      ctxt->passwd = xmlMemStrdup(cptr+1);
  }
    }

    xmlFreeURI(uri);

}

/**
 * xmlNanoFTPUpdateURL:
 * @ctx:  an FTP context
 * @URL:  The URL used to update the context
 *
 * Update an FTP context by parsing the URL and finding
 * new path it indicates. If there is an error in the
 * protocol, hostname, port or other information, the
 * error is raised. It indicates a new connection has to
 * be established.
 *
 * Returns 0 if Ok, -1 in case of error (other host).
 */

int
xmlNanoFTPUpdateURL(void *ctx, const char *URL) {
    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
    xmlURIPtr uri;

    if (URL == NULL)
  return(-1);
    if (ctxt == NULL)
  return(-1);
    if (ctxt->protocol == NULL)
  return(-1);
    if (ctxt->hostname == NULL)
  return(-1);

    uri = xmlParseURIRaw(URL, 1);
    if (uri == NULL)
  return(-1);

    if ((uri->scheme == NULL) || (uri->server == NULL)) {
  xmlFreeURI(uri);
  return(-1);
    }
    if ((strcmp(ctxt->protocol, uri->scheme)) ||
  (strcmp(ctxt->hostname, uri->server)) ||
  ((uri->port != 0) && (ctxt->port != uri->port))) {
  xmlFreeURI(uri);
  return(-1);
    }

    if (uri->port != 0)
  ctxt->port = uri->port;

    if (ctxt->path != NULL) {
  xmlFree(ctxt->path);
  ctxt->path = NULL;
    }

    if (uri->path == NULL)
        ctxt->path = xmlMemStrdup("/");
    else
  ctxt->path = xmlMemStrdup(uri->path);

    xmlFreeURI(uri);

    return(0);
}

/**
 * xmlNanoFTPScanProxy:
 * @URL:  The proxy URL used to initialize the proxy context
 *
 * (Re)Initialize the FTP Proxy context by parsing the URL and finding
 * the protocol host port it indicates.
 * Should be like ftp://myproxy/ or ftp://myproxy:3128/
 * A NULL URL cleans up proxy informations.
 */

void
xmlNanoFTPScanProxy(const char *URL) {
    xmlURIPtr uri;

    if (proxy != NULL) {
        xmlFree(proxy);
  proxy = NULL;
    }
    proxyPort = 0;

#ifdef DEBUG_FTP
    if (URL == NULL)
  xmlGenericError(xmlGenericErrorContext,
    "Removing FTP proxy info\n");
    else
  xmlGenericError(xmlGenericErrorContext,
    "Using FTP proxy %s\n", URL);
#endif
    if (URL == NULL) return;

    uri = xmlParseURIRaw(URL, 1);
    if ((uri == NULL) || (uri->scheme == NULL) ||
  (strcmp(uri->scheme, "ftp")) || (uri->server == NULL)) {
  __xmlIOErr(XML_FROM_FTP, XML_FTP_URL_SYNTAX, "Syntax Error\n");
  if (uri != NULL)
      xmlFreeURI(uri);
  return;
    }

    proxy = xmlMemStrdup(uri->server);
    if (uri->port != 0)
  proxyPort = uri->port;

    xmlFreeURI(uri);
}

/**
 * xmlNanoFTPNewCtxt:
 * @URL:  The URL used to initialize the context
 *
 * Allocate and initialize a new FTP context.
 *
 * Returns an FTP context or NULL in case of error.
 */

void*
xmlNanoFTPNewCtxt(const char *URL) {
    xmlNanoFTPCtxtPtr ret;
    char *unescaped;

    ret = (xmlNanoFTPCtxtPtr) xmlMalloc(sizeof(xmlNanoFTPCtxt));
    if (ret == NULL) {
        xmlFTPErrMemory("allocating FTP context");
        return(NULL);
    }

    memset(ret, 0, sizeof(xmlNanoFTPCtxt));
    ret->port = 21;
    ret->passive = 1;
    ret->returnValue = 0;
    ret->controlBufIndex = 0;
    ret->controlBufUsed = 0;
    ret->controlFd = INVALID_SOCKET;

    unescaped = xmlURIUnescapeString(URL, 0, NULL);
    if (unescaped != NULL) {
  xmlNanoFTPScanURL(ret, unescaped);
  xmlFree(unescaped);
    } else if (URL != NULL)
  xmlNanoFTPScanURL(ret, URL);

    return(ret);
}

/**
 * xmlNanoFTPFreeCtxt:
 * @ctx:  an FTP context
 *
 * Frees the context after closing the connection.
 */

void
xmlNanoFTPFreeCtxt(void * ctx) {
    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
    if (ctxt == NULL) return;
    if (ctxt->hostname != NULL) xmlFree(ctxt->hostname);
    if (ctxt->protocol != NULL) xmlFree(ctxt->protocol);
    if (ctxt->path != NULL) xmlFree(ctxt->path);
    if (ctxt->user != NULL) xmlFree(ctxt->user);
    if (ctxt->passwd != NULL) xmlFree(ctxt->passwd);
    ctxt->passive = 1;
    if (ctxt->controlFd != INVALID_SOCKET) closesocket(ctxt->controlFd);
    ctxt->controlFd = INVALID_SOCKET;
    ctxt->controlBufIndex = -1;
    ctxt->controlBufUsed = -1;
    xmlFree(ctxt);
}

/**
 * xmlNanoFTPParseResponse:
 * @buf:  the buffer containing the response
 * @len:  the buffer length
 *
 * Parsing of the server answer, we just extract the code.
 *
 * returns 0 for errors
 *     +XXX for last line of response
 *     -XXX for response to be continued
 */
static int
xmlNanoFTPParseResponse(char *buf, int len) {
    int val = 0;

    if (len < 3) return(-1);
    if ((*buf >= '0') && (*buf <= '9'))
        val = val * 10 + (*buf - '0');
    else
        return(0);
    buf++;
    if ((*buf >= '0') && (*buf <= '9'))
        val = val * 10 + (*buf - '0');
    else
        return(0);
    buf++;
    if ((*buf >= '0') && (*buf <= '9'))
        val = val * 10 + (*buf - '0');
    else
        return(0);
    buf++;
    if (*buf == '-')
        return(-val);
    return(val);
}

/**
 * xmlNanoFTPGetMore:
 * @ctx:  an FTP context
 *
 * Read more information from the FTP control connection
 * Returns the number of bytes read, < 0 indicates an error
 */
static int
xmlNanoFTPGetMore(void *ctx) {
    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
    int len;
    int size;

    if ((ctxt == NULL) || (ctxt->controlFd == INVALID_SOCKET)) return(-1);

    if ((ctxt->controlBufIndex < 0) || (ctxt->controlBufIndex > FTP_BUF_SIZE)) {
#ifdef DEBUG_FTP
        xmlGenericError(xmlGenericErrorContext,
    "xmlNanoFTPGetMore : controlBufIndex = %d\n",
    ctxt->controlBufIndex);
#endif
  return(-1);
    }

    if ((ctxt->controlBufUsed < 0) || (ctxt->controlBufUsed > FTP_BUF_SIZE)) {
#ifdef DEBUG_FTP
        xmlGenericError(xmlGenericErrorContext,
    "xmlNanoFTPGetMore : controlBufUsed = %d\n",
    ctxt->controlBufUsed);
#endif
  return(-1);
    }
    if (ctxt->controlBufIndex > ctxt->controlBufUsed) {
#ifdef DEBUG_FTP
        xmlGenericError(xmlGenericErrorContext,
    "xmlNanoFTPGetMore : controlBufIndex > controlBufUsed %d > %d\n",
         ctxt->controlBufIndex, ctxt->controlBufUsed);
#endif
  return(-1);
    }

    /*
     * First pack the control buffer
     */
    if (ctxt->controlBufIndex > 0) {
  memmove(&ctxt->controlBuf[0], &ctxt->controlBuf[ctxt->controlBufIndex],
    ctxt->controlBufUsed - ctxt->controlBufIndex);
  ctxt->controlBufUsed -= ctxt->controlBufIndex;
  ctxt->controlBufIndex = 0;
    }
    size = FTP_BUF_SIZE - ctxt->controlBufUsed;
    if (size == 0) {
#ifdef DEBUG_FTP
        xmlGenericError(xmlGenericErrorContext,
    "xmlNanoFTPGetMore : buffer full %d \n", ctxt->controlBufUsed);
#endif
  return(0);
    }

    /*
     * Read the amount left on the control connection
     */
    if ((len = recv(ctxt->controlFd, &ctxt->controlBuf[ctxt->controlBufIndex],
        size, 0)) < 0) {
  __xmlIOErr(XML_FROM_FTP, 0, "recv failed");
  closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET;
        ctxt->controlFd = INVALID_SOCKET;
        return(-1);
    }
#ifdef DEBUG_FTP
    xmlGenericError(xmlGenericErrorContext,
      "xmlNanoFTPGetMore : read %d [%d - %d]\n", len,
     ctxt->controlBufUsed, ctxt->controlBufUsed + len);
#endif
    ctxt->controlBufUsed += len;
    ctxt->controlBuf[ctxt->controlBufUsed] = 0;

    return(len);
}

/**
 * xmlNanoFTPReadResponse:
 * @ctx:  an FTP context
 *
 * Read the response from the FTP server after a command.
 * Returns the code number
 */
static int
xmlNanoFTPReadResponse(void *ctx) {
    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
    char *ptr, *end;
    int len;
    int res = -1, cur = -1;

    if ((ctxt == NULL) || (ctxt->controlFd == INVALID_SOCKET)) return(-1);

get_more:
    /*
     * Assumes everything up to controlBuf[controlBufIndex] has been read
     * and analyzed.
     */
    len = xmlNanoFTPGetMore(ctx);
    if (len < 0) {
        return(-1);
    }
    if ((ctxt->controlBufUsed == 0) && (len == 0)) {
        return(-1);
    }
    ptr = &ctxt->controlBuf[ctxt->controlBufIndex];
    end = &ctxt->controlBuf[ctxt->controlBufUsed];

#ifdef DEBUG_FTP
    xmlGenericError(xmlGenericErrorContext,
      "\n<<<\n%s\n--\n", ptr);
#endif
    while (ptr < end) {
        cur = xmlNanoFTPParseResponse(ptr, end - ptr);
  if (cur > 0) {
      /*
       * Successfully scanned the control code, scratch
       * till the end of the line, but keep the index to be
       * able to analyze the result if needed.
       */
      res = cur;
      ptr += 3;
      ctxt->controlBufAnswer = ptr - ctxt->controlBuf;
      while ((ptr < end) && (*ptr != '\n')) ptr++;
      if (*ptr == '\n') ptr++;
      if (*ptr == '\r') ptr++;
      break;
  }
  while ((ptr < end) && (*ptr != '\n')) ptr++;
  if (ptr >= end) {
      ctxt->controlBufIndex = ctxt->controlBufUsed;
      goto get_more;
  }
  if (*ptr != '\r') ptr++;
    }

    if (res < 0) goto get_more;
    ctxt->controlBufIndex = ptr - ctxt->controlBuf;
#ifdef DEBUG_FTP
    ptr = &ctxt->controlBuf[ctxt->controlBufIndex];
    xmlGenericError(xmlGenericErrorContext, "\n---\n%s\n--\n", ptr);
#endif

#ifdef DEBUG_FTP
    xmlGenericError(xmlGenericErrorContext, "Got %d\n", res);
#endif
    return(res / 100);
}

/**
 * xmlNanoFTPGetResponse:
 * @ctx:  an FTP context
 *
 * Get the response from the FTP server after a command.
 * Returns the code number
 */

int
xmlNanoFTPGetResponse(void *ctx) {
    int res;

    res = xmlNanoFTPReadResponse(ctx);

    return(res);
}

/**
 * xmlNanoFTPCheckResponse:
 * @ctx:  an FTP context
 *
 * Check if there is a response from the FTP server after a command.
 * Returns the code number, or 0
 */

int
xmlNanoFTPCheckResponse(void *ctx) {
    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
    fd_set rfd;
    struct timeval tv;

    if ((ctxt == NULL) || (ctxt->controlFd == INVALID_SOCKET)) return(-1);
    tv.tv_sec = 0;
    tv.tv_usec = 0;
    FD_ZERO(&rfd);
    FD_SET(ctxt->controlFd, &rfd);
    switch(select(ctxt->controlFd + 1, &rfd, NULL, NULL, &tv)) {
  case 0:
      return(0);
  case -1:
      __xmlIOErr(XML_FROM_FTP, 0, "select");
      return(-1);

    }

    return(xmlNanoFTPReadResponse(ctx));
}

/**
 * Send the user authentication
 */

static int
xmlNanoFTPSendUser(void *ctx) {
    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
    char buf[200];
    int len;
    int res;

    if (ctxt->user == NULL)
  snprintf(buf, sizeof(buf), "USER anonymous\r\n");
    else
  snprintf(buf, sizeof(buf), "USER %s\r\n", ctxt->user);
    buf[sizeof(buf) - 1] = 0;
    len = strlen(buf);
#ifdef DEBUG_FTP
    xmlGenericError(xmlGenericErrorContext, "%s", buf);
#endif
    res = send(ctxt->controlFd, SEND_ARG2_CAST buf, len, 0);
    if (res < 0) {
  __xmlIOErr(XML_FROM_FTP, 0, "send failed");
  return(res);
    }
    return(0);
}

/**
 * Send the password authentication
 */

static int
xmlNanoFTPSendPasswd(void *ctx) {
    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
    char buf[200];
    int len;
    int res;

    if (ctxt->passwd == NULL)
  snprintf(buf, sizeof(buf), "PASS anonymous@\r\n");
    else
  snprintf(buf, sizeof(buf), "PASS %s\r\n", ctxt->passwd);
    buf[sizeof(buf) - 1] = 0;
    len = strlen(buf);
#ifdef DEBUG_FTP
    xmlGenericError(xmlGenericErrorContext, "%s", buf);
#endif
    res = send(ctxt->controlFd, SEND_ARG2_CAST buf, len, 0);
    if (res < 0) {
  __xmlIOErr(XML_FROM_FTP, 0, "send failed");
  return(res);
    }
    return(0);
}

/**
 * xmlNanoFTPQuit:
 * @ctx:  an FTP context
 *
 * Send a QUIT command to the server
 *
 * Returns -1 in case of error, 0 otherwise
 */


int
xmlNanoFTPQuit(void *ctx) {
    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
    char buf[200];
    int len, res;

    if ((ctxt == NULL) || (ctxt->controlFd == INVALID_SOCKET)) return(-1);

    snprintf(buf, sizeof(buf), "QUIT\r\n");
    len = strlen(buf);
#ifdef DEBUG_FTP
    xmlGenericError(xmlGenericErrorContext, "%s", buf); /* Just to be consistent, even though we know it can't have a % in it */
#endif
    res = send(ctxt->controlFd, SEND_ARG2_CAST buf, len, 0);
    if (res < 0) {
  __xmlIOErr(XML_FROM_FTP, 0, "send failed");
  return(res);
    }
    return(0);
}

/**
 * xmlNanoFTPConnect:
 * @ctx:  an FTP context
 *
 * Tries to open a control connection
 *
 * Returns -1 in case of error, 0 otherwise
 */

int
xmlNanoFTPConnect(void *ctx) {
    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
    struct hostent *hp;
    int port;
    int res;
    int addrlen = sizeof (struct sockaddr_in);

    if (ctxt == NULL)
  return(-1);
    if (ctxt->hostname == NULL)
  return(-1);

    /*
     * do the blocking DNS query.
     */
    if (proxy) {
        port = proxyPort;
    } else {
  port = ctxt->port;
    }
    if (port == 0)
  port = 21;

    memset (&ctxt->ftpAddr, 0, sizeof(ctxt->ftpAddr));

#ifdef SUPPORT_IP6
    if (have_ipv6 ()) {
  struct addrinfo hints, *tmp, *result;

  result = NULL;
  memset (&hints, 0, sizeof(hints));
  hints.ai_socktype = SOCK_STREAM;

  if (proxy) {
      if (getaddrinfo (proxy, NULL, &hints, &result) != 0) {
    __xmlIOErr(XML_FROM_FTP, 0, "getaddrinfo failed");
    return (-1);
      }
  }
  else
      if (getaddrinfo (ctxt->hostname, NULL, &hints, &result) != 0) {
    __xmlIOErr(XML_FROM_FTP, 0, "getaddrinfo failed");
    return (-1);
      }

  for (tmp = result; tmp; tmp = tmp->ai_next)
      if (tmp->ai_family == AF_INET || tmp->ai_family == AF_INET6)
    break;

  if (!tmp) {
      if (result)
    freeaddrinfo (result);
      __xmlIOErr(XML_FROM_FTP, 0, "getaddrinfo failed");
      return (-1);
  }
  if ((size_t)tmp->ai_addrlen > sizeof(ctxt->ftpAddr)) {
      if (result)
    freeaddrinfo (result);
      __xmlIOErr(XML_FROM_FTP, 0, "gethostbyname address mismatch");
      return (-1);
  }
  if (tmp->ai_family == AF_INET6) {
      memcpy (&ctxt->ftpAddr, tmp->ai_addr, tmp->ai_addrlen);
      ((struct sockaddr_in6 *) &ctxt->ftpAddr)->sin6_port = htons (port);
      ctxt->controlFd = socket (AF_INET6, SOCK_STREAM, 0);
  }
  else {
      memcpy (&ctxt->ftpAddr, tmp->ai_addr, tmp->ai_addrlen);
      ((struct sockaddr_in *) &ctxt->ftpAddr)->sin_port = htons (port);
      ctxt->controlFd = socket (AF_INET, SOCK_STREAM, 0);
  }
  addrlen = tmp->ai_addrlen;
  freeaddrinfo (result);
    }
    else
#endif
    {
  if (proxy)
      hp = gethostbyname (GETHOSTBYNAME_ARG_CAST proxy);
  else
      hp = gethostbyname (GETHOSTBYNAME_ARG_CAST ctxt->hostname);
  if (hp == NULL) {
      __xmlIOErr(XML_FROM_FTP, 0, "gethostbyname failed");
      return (-1);
  }
  if ((unsigned int) hp->h_length >
      sizeof(((struct sockaddr_in *)&ctxt->ftpAddr)->sin_addr)) {
      __xmlIOErr(XML_FROM_FTP, 0, "gethostbyname address mismatch");
      return (-1);
  }

  /*
   * Prepare the socket
   */
  ((struct sockaddr_in *)&ctxt->ftpAddr)->sin_family = AF_INET;
  memcpy (&((struct sockaddr_in *)&ctxt->ftpAddr)->sin_addr,
    hp->h_addr_list[0], hp->h_length);
  ((struct sockaddr_in *)&ctxt->ftpAddr)->sin_port =
             (unsigned short)htons ((unsigned short)port);
  ctxt->controlFd = socket (AF_INET, SOCK_STREAM, 0);
  addrlen = sizeof (struct sockaddr_in);
    }

    if (ctxt->controlFd == INVALID_SOCKET) {
  __xmlIOErr(XML_FROM_FTP, 0, "socket failed");
        return(-1);
    }

    /*
     * Do the connect.
     */
    if (connect(ctxt->controlFd, (struct sockaddr *) &ctxt->ftpAddr,
      addrlen) < 0) {
  __xmlIOErr(XML_FROM_FTP, 0, "Failed to create a connection");
        closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET;
        ctxt->controlFd = INVALID_SOCKET;
  return(-1);
    }

    /*
     * Wait for the HELLO from the server.
     */
    res = xmlNanoFTPGetResponse(ctxt);
    if (res != 2) {
        closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET;
        ctxt->controlFd = INVALID_SOCKET;
  return(-1);
    }

    /*
     * State diagram for the login operation on the FTP server
     *
     * Reference: RFC 959
     *
     *                       1
     * +---+   USER    +---+------------->+---+
     * | B |---------->| W | 2       ---->| E |
     * +---+           +---+------  |  -->+---+
     *                  | |       | | |
     *                3 | | 4,5   | | |
     *    --------------   -----  | | |
     *   |                      | | | |
     *   |                      | | | |
     *   |                 ---------  |
     *   |               1|     | |   |
     *   V                |     | |   |
     * +---+   PASS    +---+ 2  |  ------>+---+
     * |   |---------->| W |------------->| S |
     * +---+           +---+   ---------->+---+
     *                  | |   | |     |
     *                3 | |4,5| |     |
     *    --------------   --------   |
     *   |                    | |  |  |
     *   |                    | |  |  |
     *   |                 -----------
     *   |             1,3|   | |  |
     *   V                |  2| |  |
     * +---+   ACCT    +---+--  |   ----->+---+
     * |   |---------->| W | 4,5 -------->| F |
     * +---+           +---+------------->+---+
     *
     * Of course in case of using a proxy this get really nasty and is not
     * standardized at all :-(
     */
    if (proxy) {
        int len;
  char buf[400];

        if (proxyUser != NULL) {
      /*
       * We need proxy auth
       */
      snprintf(buf, sizeof(buf), "USER %s\r\n", proxyUser);
            buf[sizeof(buf) - 1] = 0;
            len = strlen(buf);
#ifdef DEBUG_FTP
      xmlGenericError(xmlGenericErrorContext, "%s", buf);
#endif
      res = send(ctxt->controlFd, SEND_ARG2_CAST buf, len, 0);
      if (res < 0) {
    __xmlIOErr(XML_FROM_FTP, 0, "send failed");
    closesocket(ctxt->controlFd);
    ctxt->controlFd = INVALID_SOCKET;
          return(res);
      }
      res = xmlNanoFTPGetResponse(ctxt);
      switch (res) {
    case 2:
        if (proxyPasswd == NULL)
      break;
                    /* Falls through. */
    case 3:
        if (proxyPasswd != NULL)
      snprintf(buf, sizeof(buf), "PASS %s\r\n", proxyPasswd);
        else
      snprintf(buf, sizeof(buf), "PASS anonymous@\r\n");
                    buf[sizeof(buf) - 1] = 0;
                    len = strlen(buf);
#ifdef DEBUG_FTP
        xmlGenericError(xmlGenericErrorContext, "%s", buf);
#endif
        res = send(ctxt->controlFd, SEND_ARG2_CAST buf, len, 0);
        if (res < 0) {
      __xmlIOErr(XML_FROM_FTP, 0, "send failed");
      closesocket(ctxt->controlFd);
      ctxt->controlFd = INVALID_SOCKET;
      return(res);
        }
        res = xmlNanoFTPGetResponse(ctxt);
        if (res > 3) {
      closesocket(ctxt->controlFd);
      ctxt->controlFd = INVALID_SOCKET;
      return(-1);
        }
        break;
    case 1:
        break;
    case 4:
    case 5:
    case -1:
    default:
        closesocket(ctxt->controlFd);
        ctxt->controlFd = INVALID_SOCKET;
        return(-1);
      }
  }

  /*
   * We assume we don't need more authentication to the proxy
   * and that it succeeded :-\
   */
  switch (proxyType) {
      case 0:
    /* we will try in sequence */
      case 1:
    /* Using SITE command */
    snprintf(buf, sizeof(buf), "SITE %s\r\n", ctxt->hostname);
                buf[sizeof(buf) - 1] = 0;
                len = strlen(buf);
#ifdef DEBUG_FTP
    xmlGenericError(xmlGenericErrorContext, "%s", buf);
#endif
    res = send(ctxt->controlFd, SEND_ARG2_CAST buf, len, 0);
    if (res < 0) {
        __xmlIOErr(XML_FROM_FTP, 0, "send failed");
        closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET;
        ctxt->controlFd = INVALID_SOCKET;
        return(res);
    }
    res = xmlNanoFTPGetResponse(ctxt);
    if (res == 2) {
        /* we assume it worked :-\ 1 is error for SITE command */
        proxyType = 1;
        break;
    }
    if (proxyType == 1) {
        closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET;
        ctxt->controlFd = INVALID_SOCKET;
        return(-1);
    }
                /* Falls through. */
      case 2:
    /* USER user@host command */
    if (ctxt->user == NULL)
        snprintf(buf, sizeof(buf), "USER anonymous@%s\r\n",
                 ctxt->hostname);
    else
        snprintf(buf, sizeof(buf), "USER %s@%s\r\n",
                 ctxt->user, ctxt->hostname);
                buf[sizeof(buf) - 1] = 0;
                len = strlen(buf);
#ifdef DEBUG_FTP
    xmlGenericError(xmlGenericErrorContext, "%s", buf);
#endif
    res = send(ctxt->controlFd, SEND_ARG2_CAST buf, len, 0);
    if (res < 0) {
        __xmlIOErr(XML_FROM_FTP, 0, "send failed");
        closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET;
        ctxt->controlFd = INVALID_SOCKET;
        return(res);
    }
    res = xmlNanoFTPGetResponse(ctxt);
    if ((res == 1) || (res == 2)) {
        /* we assume it worked :-\ */
        proxyType = 2;
        return(0);
    }
    if (ctxt->passwd == NULL)
        snprintf(buf, sizeof(buf), "PASS anonymous@\r\n");
    else
        snprintf(buf, sizeof(buf), "PASS %s\r\n", ctxt->passwd);
                buf[sizeof(buf) - 1] = 0;
                len = strlen(buf);
#ifdef DEBUG_FTP
    xmlGenericError(xmlGenericErrorContext, "%s", buf);
#endif
    res = send(ctxt->controlFd, SEND_ARG2_CAST buf, len, 0);
    if (res < 0) {
        __xmlIOErr(XML_FROM_FTP, 0, "send failed");
        closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET;
        ctxt->controlFd = INVALID_SOCKET;
        return(res);
    }
    res = xmlNanoFTPGetResponse(ctxt);
    if ((res == 1) || (res == 2)) {
        /* we assume it worked :-\ */
        proxyType = 2;
        return(0);
    }
    if (proxyType == 2) {
        closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET;
        ctxt->controlFd = INVALID_SOCKET;
        return(-1);
    }
                /* Falls through. */
      case 3:
    /*
     * If you need support for other Proxy authentication scheme
     * send the code or at least the sequence in use.
     */
      default:
    closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET;
    ctxt->controlFd = INVALID_SOCKET;
    return(-1);
  }
    }
    /*
     * Non-proxy handling.
     */
    res = xmlNanoFTPSendUser(ctxt);
    if (res < 0) {
        closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET;
        ctxt->controlFd = INVALID_SOCKET;
  return(-1);
    }
    res = xmlNanoFTPGetResponse(ctxt);
    switch (res) {
  case 2:
      return(0);
  case 3:
      break;
  case 1:
  case 4:
  case 5:
        case -1:
  default:
      closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET;
      ctxt->controlFd = INVALID_SOCKET;
      return(-1);
    }
    res = xmlNanoFTPSendPasswd(ctxt);
    if (res < 0) {
        closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET;
        ctxt->controlFd = INVALID_SOCKET;
  return(-1);
    }
    res = xmlNanoFTPGetResponse(ctxt);
    switch (res) {
  case 2:
      break;
  case 3:
      __xmlIOErr(XML_FROM_FTP, XML_FTP_ACCNT,
           "FTP server asking for ACCNT on anonymous\n");
           /* Falls through. */
  case 1:
  case 4:
  case 5:
        case -1:
  default:
      closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET;
      ctxt->controlFd = INVALID_SOCKET;
      return(-1);
    }

    return(0);
}

/**
 * xmlNanoFTPConnectTo:
 * @server:  an FTP server name
 * @port:  the port (use 21 if 0)
 *
 * Tries to open a control connection to the given server/port
 *
 * Returns an fTP context or NULL if it failed
 */

void*
xmlNanoFTPConnectTo(const char *server, int port) {
    xmlNanoFTPCtxtPtr ctxt;
    int res;

    xmlNanoFTPInit();
    if (server == NULL)
  return(NULL);
    if (port <= 0)
  return(NULL);
    ctxt = (xmlNanoFTPCtxtPtr) xmlNanoFTPNewCtxt(NULL);
    if (ctxt == NULL)
        return(NULL);
    ctxt->hostname = xmlMemStrdup(server);
    if (ctxt->hostname == NULL) {
  xmlNanoFTPFreeCtxt(ctxt);
  return(NULL);
    }
    if (port != 0)
  ctxt->port = port;
    res = xmlNanoFTPConnect(ctxt);
    if (res < 0) {
  xmlNanoFTPFreeCtxt(ctxt);
  return(NULL);
    }
    return(ctxt);
}

/**
 * xmlNanoFTPCwd:
 * @ctx:  an FTP context
 * @directory:  a directory on the server
 *
 * Tries to change the remote directory
 *
 * Returns -1 incase of error, 1 if CWD worked, 0 if it failed
 */

int
xmlNanoFTPCwd(void *ctx, const char *directory) {
    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
    char buf[400];
    int len;
    int res;

    if ((ctxt == NULL) || (ctxt->controlFd == INVALID_SOCKET)) return(-1);
    if (directory == NULL) return 0;

    /*
     * Expected response code for CWD:
     *
     * CWD
     *     250
     *     500, 501, 502, 421, 530, 550
     */
    snprintf(buf, sizeof(buf), "CWD %s\r\n", directory);
    buf[sizeof(buf) - 1] = 0;
    len = strlen(buf);
#ifdef DEBUG_FTP
    xmlGenericError(xmlGenericErrorContext, "%s", buf);
#endif
    res = send(ctxt->controlFd, SEND_ARG2_CAST buf, len, 0);
    if (res < 0) {
  __xmlIOErr(XML_FROM_FTP, 0, "send failed");
  return(res);
    }
    res = xmlNanoFTPGetResponse(ctxt);
    if (res == 4) {
  return(-1);
    }
    if (res == 2) return(1);
    if (res == 5) {
  return(0);
    }
    return(0);
}

/**
 * xmlNanoFTPDele:
 * @ctx:  an FTP context
 * @file:  a file or directory on the server
 *
 * Tries to delete an item (file or directory) from server
 *
 * Returns -1 incase of error, 1 if DELE worked, 0 if it failed
 */

int
xmlNanoFTPDele(void *ctx, const char *file) {
    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
    char buf[400];
    int len;
    int res;

    if ((ctxt == NULL) || (ctxt->controlFd == INVALID_SOCKET) ||
        (file == NULL)) return(-1);

    /*
     * Expected response code for DELE:
     *
     * DELE
     *       250
     *       450, 550
     *       500, 501, 502, 421, 530
     */

    snprintf(buf, sizeof(buf), "DELE %s\r\n", file);
    buf[sizeof(buf) - 1] = 0;
    len = strlen(buf);
#ifdef DEBUG_FTP
    xmlGenericError(xmlGenericErrorContext, "%s", buf);
#endif
    res = send(ctxt->controlFd, SEND_ARG2_CAST buf, len, 0);
    if (res < 0) {
  __xmlIOErr(XML_FROM_FTP, 0, "send failed");
  return(res);
    }
    res = xmlNanoFTPGetResponse(ctxt);
    if (res == 4) {
  return(-1);
    }
    if (res == 2) return(1);
    if (res == 5) {
  return(0);
    }
    return(0);
}
/**
 * xmlNanoFTPGetConnection:
 * @ctx:  an FTP context
 *
 * Try to open a data connection to the server. Currently only
 * passive mode is supported.
 *
 * Returns -1 incase of error, 0 otherwise
 */

SOCKET
xmlNanoFTPGetConnection(void *ctx) {
    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
    char buf[200], *cur;
    int len, i;
    int res;
    unsigned char ad[6], *adp, *portp;
    unsigned int temp[6];
#ifdef SUPPORT_IP6
    struct sockaddr_storage dataAddr;
#else
    struct sockaddr_in dataAddr;
#endif
    XML_SOCKLEN_T dataAddrLen;

    if (ctxt == NULL) return INVALID_SOCKET;

    memset (&dataAddr, 0, sizeof(dataAddr));
#ifdef SUPPORT_IP6
    if ((ctxt->ftpAddr).ss_family == AF_INET6) {
  ctxt->dataFd = socket (AF_INET6, SOCK_STREAM, IPPROTO_TCP);
  ((struct sockaddr_in6 *)&dataAddr)->sin6_family = AF_INET6;
  dataAddrLen = sizeof(struct sockaddr_in6);
    } else
#endif
    {
  ctxt->dataFd = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
  ((struct sockaddr_in *)&dataAddr)->sin_family = AF_INET;
  dataAddrLen = sizeof (struct sockaddr_in);
    }

    if (ctxt->dataFd == INVALID_SOCKET) {
  __xmlIOErr(XML_FROM_FTP, 0, "socket failed");
  return INVALID_SOCKET;
    }

    if (ctxt->passive) {
#ifdef SUPPORT_IP6
  if ((ctxt->ftpAddr).ss_family == AF_INET6)
      snprintf (buf, sizeof(buf), "EPSV\r\n");
  else
#endif
      snprintf (buf, sizeof(buf), "PASV\r\n");
        len = strlen (buf);
#ifdef DEBUG_FTP
  xmlGenericError(xmlGenericErrorContext, "%s", buf);
#endif
  res = send(ctxt->controlFd, SEND_ARG2_CAST buf, len, 0);
  if (res < 0) {
      __xmlIOErr(XML_FROM_FTP, 0, "send failed");
      closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
      return INVALID_SOCKET;
  }
        res = xmlNanoFTPReadResponse(ctx);
  if (res != 2) {
      if (res == 5) {
          closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
    return INVALID_SOCKET;
      } else {
    /*
     * retry with an active connection
     */
          closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
          ctxt->passive = 0;
      }
  }
  cur = &ctxt->controlBuf[ctxt->controlBufAnswer];
  while (((*cur < '0') || (*cur > '9')) && *cur != '\0') cur++;
#ifdef SUPPORT_IP6
  if ((ctxt->ftpAddr).ss_family == AF_INET6) {
      if (sscanf (cur, "%u", &temp[0]) != 1) {
    __xmlIOErr(XML_FROM_FTP, XML_FTP_EPSV_ANSWER,
      "Invalid answer to EPSV\n");
    if (ctxt->dataFd != INVALID_SOCKET) {
        closesocket (ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
    }
    return INVALID_SOCKET;
      }
      memcpy (&((struct sockaddr_in6 *)&dataAddr)->sin6_addr, &((struct sockaddr_in6 *)&ctxt->ftpAddr)->sin6_addr, sizeof(struct in6_addr));
      ((struct sockaddr_in6 *)&dataAddr)->sin6_port = htons (temp[0]);
  }
  else
#endif
  {
      if (sscanf (cur, "%u,%u,%u,%u,%u,%u", &temp[0], &temp[1], &temp[2],
    &temp[3], &temp[4], &temp[5]) != 6) {
    __xmlIOErr(XML_FROM_FTP, XML_FTP_PASV_ANSWER,
      "Invalid answer to PASV\n");
    if (ctxt->dataFd != INVALID_SOCKET) {
        closesocket (ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
    }
    return INVALID_SOCKET;
      }
      for (i=0; i<6; i++) ad[i] = (unsigned char) (temp[i] & 0xff);
      memcpy (&((struct sockaddr_in *)&dataAddr)->sin_addr, &ad[0], 4);
      memcpy (&((struct sockaddr_in *)&dataAddr)->sin_port, &ad[4], 2);
  }

  if (connect(ctxt->dataFd, (struct sockaddr *) &dataAddr, dataAddrLen) < 0) {
      __xmlIOErr(XML_FROM_FTP, 0, "Failed to create a data connection");
      closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
      return INVALID_SOCKET;
  }
    } else {
        getsockname(ctxt->dataFd, (struct sockaddr *) &dataAddr, &dataAddrLen);
#ifdef SUPPORT_IP6
  if ((ctxt->ftpAddr).ss_family == AF_INET6)
      ((struct sockaddr_in6 *)&dataAddr)->sin6_port = 0;
  else
#endif
      ((struct sockaddr_in *)&dataAddr)->sin_port = 0;

  if (bind(ctxt->dataFd, (struct sockaddr *) &dataAddr, dataAddrLen) < 0) {
      __xmlIOErr(XML_FROM_FTP, 0, "bind failed");
      closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
      return INVALID_SOCKET;
  }
        getsockname(ctxt->dataFd, (struct sockaddr *) &dataAddr, &dataAddrLen);

  if (listen(ctxt->dataFd, 1) < 0) {
      __xmlIOErr(XML_FROM_FTP, 0, "listen failed");
      closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
      return INVALID_SOCKET;
  }
#ifdef SUPPORT_IP6
  if ((ctxt->ftpAddr).ss_family == AF_INET6) {
      char buf6[INET6_ADDRSTRLEN];
      inet_ntop (AF_INET6, &((struct sockaddr_in6 *)&dataAddr)->sin6_addr,
        buf6, INET6_ADDRSTRLEN);
      adp = (unsigned char *) buf6;
      portp = (unsigned char *) &((struct sockaddr_in6 *)&dataAddr)->sin6_port;
      snprintf (buf, sizeof(buf), "EPRT |2|%s|%s|\r\n", adp, portp);
        } else
#endif
  {
      adp = (unsigned char *) &((struct sockaddr_in *)&dataAddr)->sin_addr;
      portp = (unsigned char *) &((struct sockaddr_in *)&dataAddr)->sin_port;
      snprintf (buf, sizeof(buf), "PORT %d,%d,%d,%d,%d,%d\r\n",
      adp[0] & 0xff, adp[1] & 0xff, adp[2] & 0xff, adp[3] & 0xff,
      portp[0] & 0xff, portp[1] & 0xff);
  }

        buf[sizeof(buf) - 1] = 0;
        len = strlen(buf);
#ifdef DEBUG_FTP
  xmlGenericError(xmlGenericErrorContext, "%s", buf);
#endif

  res = send(ctxt->controlFd, SEND_ARG2_CAST buf, len, 0);
  if (res < 0) {
      __xmlIOErr(XML_FROM_FTP, 0, "send failed");
      closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
      return INVALID_SOCKET;
  }
        res = xmlNanoFTPGetResponse(ctxt);
  if (res != 2) {
      closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
      return INVALID_SOCKET;
        }
    }
    return(ctxt->dataFd);

}

/**
 * xmlNanoFTPCloseConnection:
 * @ctx:  an FTP context
 *
 * Close the data connection from the server
 *
 * Returns -1 incase of error, 0 otherwise
 */

int
xmlNanoFTPCloseConnection(void *ctx) {
    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
    int res;
    fd_set rfd, efd;
    struct timeval tv;

    if ((ctxt == NULL) || (ctxt->controlFd == INVALID_SOCKET)) return(-1);

    closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
    tv.tv_sec = 15;
    tv.tv_usec = 0;
    FD_ZERO(&rfd);
    FD_SET(ctxt->controlFd, &rfd);
    FD_ZERO(&efd);
    FD_SET(ctxt->controlFd, &efd);
    res = select(ctxt->controlFd + 1, &rfd, NULL, &efd, &tv);
    if (res < 0) {
#ifdef DEBUG_FTP
  perror("select");
#endif
  closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET;
  return(-1);
    }
    if (res == 0) {
#ifdef DEBUG_FTP
  xmlGenericError(xmlGenericErrorContext,
    "xmlNanoFTPCloseConnection: timeout\n");
#endif
  closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET;
    } else {
  res = xmlNanoFTPGetResponse(ctxt);
  if (res != 2) {
      closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET;
      return(-1);
  }
    }
    return(0);
}

/**
 * xmlNanoFTPParseList:
 * @list:  some data listing received from the server
 * @callback:  the user callback
 * @userData:  the user callback data
 *
 * Parse at most one entry from the listing.
 *
 * Returns -1 incase of error, the length of data parsed otherwise
 */

static int
xmlNanoFTPParseList(const char *list, ftpListCallback callback, void *userData) {
    const char *cur = list;
    char filename[151];
    char attrib[11];
    char owner[11];
    char group[11];
    char month[4];
    int year = 0;
    int minute = 0;
    int hour = 0;
    int day = 0;
    unsigned long size = 0;
    int links = 0;
    int i;

    if (!strncmp(cur, "total", 5)) {
        cur += 5;
  while (*cur == ' ') cur++;
  while ((*cur >= '0') && (*cur <= '9'))
      links = (links * 10) + (*cur++ - '0');
  while ((*cur == ' ') || (*cur == '\n')  || (*cur == '\r'))
      cur++;
  return(cur - list);
    } else if (*list == '+') {
  return(0);
    } else {
  while ((*cur == ' ') || (*cur == '\n')  || (*cur == '\r'))
      cur++;
  if (*cur == 0) return(0);
  i = 0;
  while (*cur != ' ') {
      if (i < 10)
    attrib[i++] = *cur;
      cur++;
      if (*cur == 0) return(0);
  }
  attrib[10] = 0;
  while (*cur == ' ') cur++;
  if (*cur == 0) return(0);
  while ((*cur >= '0') && (*cur <= '9'))
      links = (links * 10) + (*cur++ - '0');
  while (*cur == ' ') cur++;
  if (*cur == 0) return(0);
  i = 0;
  while (*cur != ' ') {
      if (i < 10)
    owner[i++] = *cur;
      cur++;
      if (*cur == 0) return(0);
  }
  owner[i] = 0;
  while (*cur == ' ') cur++;
  if (*cur == 0) return(0);
  i = 0;
  while (*cur != ' ') {
      if (i < 10)
    group[i++] = *cur;
      cur++;
      if (*cur == 0) return(0);
  }
  group[i] = 0;
  while (*cur == ' ') cur++;
  if (*cur == 0) return(0);
  while ((*cur >= '0') && (*cur <= '9'))
      size = (size * 10) + (*cur++ - '0');
  while (*cur == ' ') cur++;
  if (*cur == 0) return(0);
  i = 0;
  while (*cur != ' ') {
      if (i < 3)
    month[i++] = *cur;
      cur++;
      if (*cur == 0) return(0);
  }
  month[i] = 0;
  while (*cur == ' ') cur++;
  if (*cur == 0) return(0);
        while ((*cur >= '0') && (*cur <= '9'))
      day = (day * 10) + (*cur++ - '0');
  while (*cur == ' ') cur++;
  if (*cur == 0) return(0);
  if ((cur[1] == 0) || (cur[2] == 0)) return(0);
  if ((cur[1] == ':') || (cur[2] == ':')) {
      while ((*cur >= '0') && (*cur <= '9'))
    hour = (hour * 10) + (*cur++ - '0');
      if (*cur == ':') cur++;
      while ((*cur >= '0') && (*cur <= '9'))
    minute = (minute * 10) + (*cur++ - '0');
  } else {
      while ((*cur >= '0') && (*cur <= '9'))
    year = (year * 10) + (*cur++ - '0');
  }
  while (*cur == ' ') cur++;
  if (*cur == 0) return(0);
  i = 0;
  while ((*cur != '\n')  && (*cur != '\r')) {
      if (i < 150)
    filename[i++] = *cur;
      cur++;
      if (*cur == 0) return(0);
  }
  filename[i] = 0;
  if ((*cur != '\n') && (*cur != '\r'))
      return(0);
  while ((*cur == '\n')  || (*cur == '\r'))
      cur++;
    }
    if (callback != NULL) {
        callback(userData, filename, attrib, owner, group, size, links,
     year, month, day, hour, minute);
    }
    return(cur - list);
}

/**
 * xmlNanoFTPList:
 * @ctx:  an FTP context
 * @callback:  the user callback
 * @userData:  the user callback data
 * @filename:  optional files to list
 *
 * Do a listing on the server. All files info are passed back
 * in the callbacks.
 *
 * Returns -1 incase of error, 0 otherwise
 */

int
xmlNanoFTPList(void *ctx, ftpListCallback callback, void *userData,
         const char *filename) {
    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
    char buf[4096 + 1];
    int len, res;
    int indx = 0, base;
    fd_set rfd, efd;
    struct timeval tv;

    if (ctxt == NULL) return (-1);
    if (filename == NULL) {
        if (xmlNanoFTPCwd(ctxt, ctxt->path) < 1)
      return(-1);
  ctxt->dataFd = xmlNanoFTPGetConnection(ctxt);
  if (ctxt->dataFd == INVALID_SOCKET)
      return(-1);
  snprintf(buf, sizeof(buf), "LIST -L\r\n");
    } else {
  if (filename[0] != '/') {
      if (xmlNanoFTPCwd(ctxt, ctxt->path) < 1)
    return(-1);
  }
  ctxt->dataFd = xmlNanoFTPGetConnection(ctxt);
  if (ctxt->dataFd == INVALID_SOCKET)
      return(-1);
  snprintf(buf, sizeof(buf), "LIST -L %s\r\n", filename);
    }
    buf[sizeof(buf) - 1] = 0;
    len = strlen(buf);
#ifdef DEBUG_FTP
    xmlGenericError(xmlGenericErrorContext, "%s", buf);
#endif
    res = send(ctxt->controlFd, SEND_ARG2_CAST buf, len, 0);
    if (res < 0) {
  __xmlIOErr(XML_FROM_FTP, 0, "send failed");
  closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
  return(res);
    }
    res = xmlNanoFTPReadResponse(ctxt);
    if (res != 1) {
  closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
  return(-res);
    }

    do {
  tv.tv_sec = 1;
  tv.tv_usec = 0;
  FD_ZERO(&rfd);
  FD_SET(ctxt->dataFd, &rfd);
  FD_ZERO(&efd);
  FD_SET(ctxt->dataFd, &efd);
  res = select(ctxt->dataFd + 1, &rfd, NULL, &efd, &tv);
  if (res < 0) {
#ifdef DEBUG_FTP
      perror("select");
#endif
      closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
      return(-1);
  }
  if (res == 0) {
      res = xmlNanoFTPCheckResponse(ctxt);
      if (res < 0) {
    closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
    ctxt->dataFd = INVALID_SOCKET;
    return(-1);
      }
      if (res == 2) {
    closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
    return(0);
      }

      continue;
  }

  if ((len = recv(ctxt->dataFd, &buf[indx], sizeof(buf) - (indx + 1), 0)) < 0) {
      __xmlIOErr(XML_FROM_FTP, 0, "recv");
      closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
      ctxt->dataFd = INVALID_SOCKET;
      return(-1);
  }
#ifdef DEBUG_FTP
        write(1, &buf[indx], len);
#endif
  indx += len;
  buf[indx] = 0;
  base = 0;
  do {
      res = xmlNanoFTPParseList(&buf[base], callback, userData);
      base += res;
  } while (res > 0);

  memmove(&buf[0], &buf[base], indx - base);
  indx -= base;
    } while (len != 0);
    xmlNanoFTPCloseConnection(ctxt);
    return(0);
}

/**
 * xmlNanoFTPGetSocket:
 * @ctx:  an FTP context
 * @filename:  the file to retrieve (or NULL if path is in context).
 *
 * Initiate fetch of the given file from the server.
 *
 * Returns the socket for the data connection, or <0 in case of error
 */


SOCKET
xmlNanoFTPGetSocket(void *ctx, const char *filename) {
    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
    char buf[300];
    int res, len;
    if (ctx == NULL)
  return INVALID_SOCKET;
    if ((filename == NULL) && (ctxt->path == NULL))
  return INVALID_SOCKET;
    ctxt->dataFd = xmlNanoFTPGetConnection(ctxt);
    if (ctxt->dataFd == INVALID_SOCKET)
  return INVALID_SOCKET;

    snprintf(buf, sizeof(buf), "TYPE I\r\n");
    len = strlen(buf);
#ifdef DEBUG_FTP
    xmlGenericError(xmlGenericErrorContext, "%s", buf);
#endif
    res = send(ctxt->controlFd, SEND_ARG2_CAST buf, len, 0);
    if (res < 0) {
  __xmlIOErr(XML_FROM_FTP, 0, "send failed");
  closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
  return INVALID_SOCKET;
    }
    res = xmlNanoFTPReadResponse(ctxt);
    if (res != 2) {
  closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
  return INVALID_SOCKET;
    }
    if (filename == NULL)
  snprintf(buf, sizeof(buf), "RETR %s\r\n", ctxt->path);
    else
  snprintf(buf, sizeof(buf), "RETR %s\r\n", filename);
    buf[sizeof(buf) - 1] = 0;
    len = strlen(buf);
#ifdef DEBUG_FTP
    xmlGenericError(xmlGenericErrorContext, "%s", buf);
#endif
    res = send(ctxt->controlFd, SEND_ARG2_CAST buf, len, 0);
    if (res < 0) {
  __xmlIOErr(XML_FROM_FTP, 0, "send failed");
  closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
  return INVALID_SOCKET;
    }
    res = xmlNanoFTPReadResponse(ctxt);
    if (res != 1) {
  closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
  return INVALID_SOCKET;
    }
    return(ctxt->dataFd);
}

/**
 * xmlNanoFTPGet:
 * @ctx:  an FTP context
 * @callback:  the user callback
 * @userData:  the user callback data
 * @filename:  the file to retrieve
 *
 * Fetch the given file from the server. All data are passed back
 * in the callbacks. The last callback has a size of 0 block.
 *
 * Returns -1 incase of error, 0 otherwise
 */

int
xmlNanoFTPGet(void *ctx, ftpDataCallback callback, void *userData,
        const char *filename) {
    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
    char buf[4096];
    int len = 0, res;
    fd_set rfd;
    struct timeval tv;

    if (ctxt == NULL) return(-1);
    if ((filename == NULL) && (ctxt->path == NULL))
  return(-1);
    if (callback == NULL)
  return(-1);
    if (xmlNanoFTPGetSocket(ctxt, filename) == INVALID_SOCKET)
  return(-1);

    do {
  tv.tv_sec = 1;
  tv.tv_usec = 0;
  FD_ZERO(&rfd);
  FD_SET(ctxt->dataFd, &rfd);
  res = select(ctxt->dataFd + 1, &rfd, NULL, NULL, &tv);
  if (res < 0) {
#ifdef DEBUG_FTP
      perror("select");
#endif
      closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
      return(-1);
  }
  if (res == 0) {
      res = xmlNanoFTPCheckResponse(ctxt);
      if (res < 0) {
    closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
    ctxt->dataFd = INVALID_SOCKET;
    return(-1);
      }
      if (res == 2) {
    closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
    return(0);
      }

      continue;
  }
  if ((len = recv(ctxt->dataFd, buf, sizeof(buf), 0)) < 0) {
      __xmlIOErr(XML_FROM_FTP, 0, "recv failed");
      callback(userData, buf, len);
      closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET;
      return(-1);
  }
  callback(userData, buf, len);
    } while (len != 0);

    return(xmlNanoFTPCloseConnection(ctxt));
}

/**
 * xmlNanoFTPRead:
 * @ctx:  the FTP context
 * @dest:  a buffer
 * @len:  the buffer length
 *
 * This function tries to read @len bytes from the existing FTP connection
 * and saves them in @dest. This is a blocking call.
 *
 * Returns the number of byte read. 0 is an indication of an end of connection.
 *         -1 indicates a parameter error.
 */
int
xmlNanoFTPRead(void *ctx, void *dest, int len) {
    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;

    if (ctx == NULL) return(-1);
    if (ctxt->dataFd == INVALID_SOCKET) return(0);
    if (dest == NULL) return(-1);
    if (len <= 0) return(0);

    len = recv(ctxt->dataFd, dest, len, 0);
    if (len <= 0) {
  if (len < 0)
      __xmlIOErr(XML_FROM_FTP, 0, "recv failed");
  xmlNanoFTPCloseConnection(ctxt);
    }
#ifdef DEBUG_FTP
    xmlGenericError(xmlGenericErrorContext, "Recvd %d bytes\n", len);
#endif
    return(len);
}

/**
 * xmlNanoFTPOpen:
 * @URL: the URL to the resource
 *
 * Start to fetch the given ftp:// resource
 *
 * Returns an FTP context, or NULL
 */

void*
xmlNanoFTPOpen(const char *URL) {
    xmlNanoFTPCtxtPtr ctxt;
    SOCKET sock;

    xmlNanoFTPInit();
    if (URL == NULL) return(NULL);
    if (strncmp("ftp://", URL, 6)) return(NULL);

    ctxt = (xmlNanoFTPCtxtPtr) xmlNanoFTPNewCtxt(URL);
    if (ctxt == NULL) return(NULL);
    if (xmlNanoFTPConnect(ctxt) < 0) {
  xmlNanoFTPFreeCtxt(ctxt);
  return(NULL);
    }
    sock = xmlNanoFTPGetSocket(ctxt, ctxt->path);
    if (sock == INVALID_SOCKET) {
  xmlNanoFTPFreeCtxt(ctxt);
  return(NULL);
    }
    return(ctxt);
}

/**
 * xmlNanoFTPClose:
 * @ctx: an FTP context
 *
 * Close the connection and both control and transport
 *
 * Returns -1 incase of error, 0 otherwise
 */

int
xmlNanoFTPClose(void *ctx) {
    xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;

    if (ctxt == NULL)
  return(-1);

    if (ctxt->dataFd != INVALID_SOCKET) {
  closesocket(ctxt->dataFd);
  ctxt->dataFd = INVALID_SOCKET;
    }
    if (ctxt->controlFd != INVALID_SOCKET) {
  xmlNanoFTPQuit(ctxt);
  closesocket(ctxt->controlFd);
  ctxt->controlFd = INVALID_SOCKET;
    }
    xmlNanoFTPFreeCtxt(ctxt);
    return(0);
}

#ifdef STANDALONE
/************************************************************************
 *                  *
 *      Basic test in Standalone mode     *
 *                  *
 ************************************************************************/
static
void ftpList(void *userData, const char *filename, const char* attrib,
       const char *owner, const char *group, unsigned long size, int links,
       int year, const char *month, int day, int hour, int minute) {
    xmlGenericError(xmlGenericErrorContext,
      "%s %s %s %ld %s\n", attrib, owner, group, size, filename);
}
static
void ftpData(void *userData, const char *data, int len) {
    if (userData == NULL) return;
    if (len <= 0) {
  fclose((FILE*)userData);
  return;
    }
    fwrite(data, len, 1, (FILE*)userData);
}

int main(int argc, char **argv) {
    void *ctxt;
    FILE *output;
    char *tstfile = NULL;

    xmlNanoFTPInit();
    if (argc > 1) {
  ctxt = xmlNanoFTPNewCtxt(argv[1]);
  if (xmlNanoFTPConnect(ctxt) < 0) {
      xmlGenericError(xmlGenericErrorContext,
        "Couldn't connect to %s\n", argv[1]);
      exit(1);
  }
  if (argc > 2)
      tstfile = argv[2];
    } else
  ctxt = xmlNanoFTPConnectTo("localhost", 0);
    if (ctxt == NULL) {
        xmlGenericError(xmlGenericErrorContext,
    "Couldn't connect to localhost\n");
        exit(1);
    }
    xmlNanoFTPList(ctxt, ftpList, NULL, tstfile);
    output = fopen("/tmp/tstdata", "w");
    if (output != NULL) {
  if (xmlNanoFTPGet(ctxt, ftpData, (void *) output, tstfile) < 0)
      xmlGenericError(xmlGenericErrorContext,
        "Failed to get file\n");

    }
    xmlNanoFTPClose(ctxt);
    xmlMemoryDump();
    exit(0);
}
#endif /* STANDALONE */
#else /* !LIBXML_FTP_ENABLED */
#ifdef STANDALONE
#include <stdio.h>
int main(int argc, char **argv) {
    xmlGenericError(xmlGenericErrorContext,
      "%s : FTP support not compiled in\n", argv[0]);
    return(0);
}
#endif /* STANDALONE */
#endif /* LIBXML_FTP_ENABLED */
#define bottom_nanoftp
#include "elfgcchack.h"

Coverage Report

Created: 2025-08-04 07:15