| Index: third_party/libxml/src/nanoftp.c
|
| diff --git a/third_party/libxml/src/nanoftp.c b/third_party/libxml/src/nanoftp.c
|
| deleted file mode 100644
|
| index a54b85b3a545ac3f1e89245124219e0bee06d282..0000000000000000000000000000000000000000
|
| --- a/third_party/libxml/src/nanoftp.c
|
| +++ /dev/null
|
| @@ -1,2111 +0,0 @@
|
| -/*
|
| - * 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
|
| -#else /* TESTING */
|
| -#define NEED_SOCKETS
|
| -#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(__MINGW32__) || defined(_WIN32_WCE)
|
| -#define _WINSOCKAPI_
|
| -#include <wsockcompat.h>
|
| -#include <winsock2.h>
|
| -#undef XML_SOCKLEN_T
|
| -#define XML_SOCKLEN_T unsigned int
|
| -#endif
|
| -
|
| -/**
|
| - * A couple portability macros
|
| - */
|
| -#ifndef _WINSOCKAPI_
|
| -#if !defined(__BEOS__) || defined(__HAIKU__)
|
| -#define closesocket(s) close(s)
|
| -#endif
|
| -#define SOCKET int
|
| -#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 = -1;
|
| -
|
| - 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);
|
| - ctxt->passive = 1;
|
| - if (ctxt->controlFd >= 0) closesocket(ctxt->controlFd);
|
| - ctxt->controlFd = -1;
|
| - 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 < 0)) 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 = -1;
|
| - ctxt->controlFd = -1;
|
| - 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 < 0)) 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 < 0)) 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, 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, 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 < 0)) 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, 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 (tmp->ai_addrlen > sizeof(ctxt->ftpAddr)) {
|
| - __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 (proxy);
|
| - else
|
| - hp = gethostbyname (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 = (u_short)htons ((unsigned short)port);
|
| - ctxt->controlFd = socket (AF_INET, SOCK_STREAM, 0);
|
| - addrlen = sizeof (struct sockaddr_in);
|
| - }
|
| -
|
| - if (ctxt->controlFd < 0) {
|
| - __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 = -1;
|
| - ctxt->controlFd = -1;
|
| - return(-1);
|
| - }
|
| -
|
| - /*
|
| - * Wait for the HELLO from the server.
|
| - */
|
| - res = xmlNanoFTPGetResponse(ctxt);
|
| - if (res != 2) {
|
| - closesocket(ctxt->controlFd); ctxt->controlFd = -1;
|
| - ctxt->controlFd = -1;
|
| - 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, buf, len, 0);
|
| - if (res < 0) {
|
| - __xmlIOErr(XML_FROM_FTP, 0, "send failed");
|
| - closesocket(ctxt->controlFd);
|
| - ctxt->controlFd = -1;
|
| - return(res);
|
| - }
|
| - res = xmlNanoFTPGetResponse(ctxt);
|
| - switch (res) {
|
| - case 2:
|
| - if (proxyPasswd == NULL)
|
| - break;
|
| - 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, buf, len, 0);
|
| - if (res < 0) {
|
| - __xmlIOErr(XML_FROM_FTP, 0, "send failed");
|
| - closesocket(ctxt->controlFd);
|
| - ctxt->controlFd = -1;
|
| - return(res);
|
| - }
|
| - res = xmlNanoFTPGetResponse(ctxt);
|
| - if (res > 3) {
|
| - closesocket(ctxt->controlFd);
|
| - ctxt->controlFd = -1;
|
| - return(-1);
|
| - }
|
| - break;
|
| - case 1:
|
| - break;
|
| - case 4:
|
| - case 5:
|
| - case -1:
|
| - default:
|
| - closesocket(ctxt->controlFd);
|
| - ctxt->controlFd = -1;
|
| - 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, buf, len, 0);
|
| - if (res < 0) {
|
| - __xmlIOErr(XML_FROM_FTP, 0, "send failed");
|
| - closesocket(ctxt->controlFd); ctxt->controlFd = -1;
|
| - ctxt->controlFd = -1;
|
| - 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 = -1;
|
| - ctxt->controlFd = -1;
|
| - return(-1);
|
| - }
|
| - 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, buf, len, 0);
|
| - if (res < 0) {
|
| - __xmlIOErr(XML_FROM_FTP, 0, "send failed");
|
| - closesocket(ctxt->controlFd); ctxt->controlFd = -1;
|
| - ctxt->controlFd = -1;
|
| - 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, buf, len, 0);
|
| - if (res < 0) {
|
| - __xmlIOErr(XML_FROM_FTP, 0, "send failed");
|
| - closesocket(ctxt->controlFd); ctxt->controlFd = -1;
|
| - ctxt->controlFd = -1;
|
| - 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 = -1;
|
| - ctxt->controlFd = -1;
|
| - return(-1);
|
| - }
|
| - 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 = -1;
|
| - ctxt->controlFd = -1;
|
| - return(-1);
|
| - }
|
| - }
|
| - /*
|
| - * Non-proxy handling.
|
| - */
|
| - res = xmlNanoFTPSendUser(ctxt);
|
| - if (res < 0) {
|
| - closesocket(ctxt->controlFd); ctxt->controlFd = -1;
|
| - ctxt->controlFd = -1;
|
| - 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 = -1;
|
| - ctxt->controlFd = -1;
|
| - return(-1);
|
| - }
|
| - res = xmlNanoFTPSendPasswd(ctxt);
|
| - if (res < 0) {
|
| - closesocket(ctxt->controlFd); ctxt->controlFd = -1;
|
| - ctxt->controlFd = -1;
|
| - 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");
|
| - case 1:
|
| - case 4:
|
| - case 5:
|
| - case -1:
|
| - default:
|
| - closesocket(ctxt->controlFd); ctxt->controlFd = -1;
|
| - ctxt->controlFd = -1;
|
| - 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);
|
| - ctxt->hostname = xmlMemStrdup(server);
|
| - 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 < 0)) 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, 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 < 0) || (file == NULL)) return(-1);
|
| - if (file == NULL) return (0);
|
| -
|
| - /*
|
| - * 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, 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
|
| - */
|
| -
|
| -int
|
| -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(-1);
|
| -
|
| - 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 < 0) {
|
| - __xmlIOErr(XML_FROM_FTP, 0, "socket failed");
|
| - return (-1);
|
| - }
|
| -
|
| - 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, buf, len, 0);
|
| - if (res < 0) {
|
| - __xmlIOErr(XML_FROM_FTP, 0, "send failed");
|
| - closesocket(ctxt->dataFd); ctxt->dataFd = -1;
|
| - return(res);
|
| - }
|
| - res = xmlNanoFTPReadResponse(ctx);
|
| - if (res != 2) {
|
| - if (res == 5) {
|
| - closesocket(ctxt->dataFd); ctxt->dataFd = -1;
|
| - return(-1);
|
| - } else {
|
| - /*
|
| - * retry with an active connection
|
| - */
|
| - closesocket(ctxt->dataFd); ctxt->dataFd = -1;
|
| - 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 != -1) {
|
| - closesocket (ctxt->dataFd); ctxt->dataFd = -1;
|
| - }
|
| - return (-1);
|
| - }
|
| - 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 != -1) {
|
| - closesocket (ctxt->dataFd); ctxt->dataFd = -1;
|
| - }
|
| - return (-1);
|
| - }
|
| - 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 = -1;
|
| - return (-1);
|
| - }
|
| - } 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 = -1;
|
| - return (-1);
|
| - }
|
| - 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 = -1;
|
| - return (-1);
|
| - }
|
| -#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, buf, len, 0);
|
| - if (res < 0) {
|
| - __xmlIOErr(XML_FROM_FTP, 0, "send failed");
|
| - closesocket(ctxt->dataFd); ctxt->dataFd = -1;
|
| - return(res);
|
| - }
|
| - res = xmlNanoFTPGetResponse(ctxt);
|
| - if (res != 2) {
|
| - closesocket(ctxt->dataFd); ctxt->dataFd = -1;
|
| - return(-1);
|
| - }
|
| - }
|
| - 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 < 0)) return(-1);
|
| -
|
| - closesocket(ctxt->dataFd); ctxt->dataFd = -1;
|
| - 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 = -1;
|
| - return(-1);
|
| - }
|
| - if (res == 0) {
|
| -#ifdef DEBUG_FTP
|
| - xmlGenericError(xmlGenericErrorContext,
|
| - "xmlNanoFTPCloseConnection: timeout\n");
|
| -#endif
|
| - closesocket(ctxt->controlFd); ctxt->controlFd = -1;
|
| - } else {
|
| - res = xmlNanoFTPGetResponse(ctxt);
|
| - if (res != 2) {
|
| - closesocket(ctxt->controlFd); ctxt->controlFd = -1;
|
| - 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 == -1)
|
| - 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 == -1)
|
| - 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, buf, len, 0);
|
| - if (res < 0) {
|
| - __xmlIOErr(XML_FROM_FTP, 0, "send failed");
|
| - closesocket(ctxt->dataFd); ctxt->dataFd = -1;
|
| - return(res);
|
| - }
|
| - res = xmlNanoFTPReadResponse(ctxt);
|
| - if (res != 1) {
|
| - closesocket(ctxt->dataFd); ctxt->dataFd = -1;
|
| - 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 = -1;
|
| - return(-1);
|
| - }
|
| - if (res == 0) {
|
| - res = xmlNanoFTPCheckResponse(ctxt);
|
| - if (res < 0) {
|
| - closesocket(ctxt->dataFd); ctxt->dataFd = -1;
|
| - ctxt->dataFd = -1;
|
| - return(-1);
|
| - }
|
| - if (res == 2) {
|
| - closesocket(ctxt->dataFd); ctxt->dataFd = -1;
|
| - 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 = -1;
|
| - ctxt->dataFd = -1;
|
| - 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
|
| - */
|
| -
|
| -
|
| -int
|
| -xmlNanoFTPGetSocket(void *ctx, const char *filename) {
|
| - xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
|
| - char buf[300];
|
| - int res, len;
|
| - if (ctx == NULL)
|
| - return(-1);
|
| - if ((filename == NULL) && (ctxt->path == NULL))
|
| - return(-1);
|
| - ctxt->dataFd = xmlNanoFTPGetConnection(ctxt);
|
| - if (ctxt->dataFd == -1)
|
| - return(-1);
|
| -
|
| - snprintf(buf, sizeof(buf), "TYPE I\r\n");
|
| - len = strlen(buf);
|
| -#ifdef DEBUG_FTP
|
| - xmlGenericError(xmlGenericErrorContext, "%s", buf);
|
| -#endif
|
| - res = send(ctxt->controlFd, buf, len, 0);
|
| - if (res < 0) {
|
| - __xmlIOErr(XML_FROM_FTP, 0, "send failed");
|
| - closesocket(ctxt->dataFd); ctxt->dataFd = -1;
|
| - return(res);
|
| - }
|
| - res = xmlNanoFTPReadResponse(ctxt);
|
| - if (res != 2) {
|
| - closesocket(ctxt->dataFd); ctxt->dataFd = -1;
|
| - return(-res);
|
| - }
|
| - 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, buf, len, 0);
|
| - if (res < 0) {
|
| - __xmlIOErr(XML_FROM_FTP, 0, "send failed");
|
| - closesocket(ctxt->dataFd); ctxt->dataFd = -1;
|
| - return(res);
|
| - }
|
| - res = xmlNanoFTPReadResponse(ctxt);
|
| - if (res != 1) {
|
| - closesocket(ctxt->dataFd); ctxt->dataFd = -1;
|
| - return(-res);
|
| - }
|
| - 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) < 0)
|
| - 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 = -1;
|
| - return(-1);
|
| - }
|
| - if (res == 0) {
|
| - res = xmlNanoFTPCheckResponse(ctxt);
|
| - if (res < 0) {
|
| - closesocket(ctxt->dataFd); ctxt->dataFd = -1;
|
| - ctxt->dataFd = -1;
|
| - return(-1);
|
| - }
|
| - if (res == 2) {
|
| - closesocket(ctxt->dataFd); ctxt->dataFd = -1;
|
| - 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 = -1;
|
| - 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 < 0) 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;
|
| - int 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 < 0) {
|
| - 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 >= 0) {
|
| - closesocket(ctxt->dataFd);
|
| - ctxt->dataFd = -1;
|
| - }
|
| - if (ctxt->controlFd >= 0) {
|
| - xmlNanoFTPQuit(ctxt);
|
| - closesocket(ctxt->controlFd);
|
| - ctxt->controlFd = -1;
|
| - }
|
| - 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"
|
|
|