From 35a201cc8ef0c3f5b2df88d2e528aabee1048348 Mon Sep 17 00:00:00 2001 From: Wojtek Kosior Date: Fri, 30 Apr 2021 18:47:09 +0200 Subject: Initial/Final commit --- libxml2-2.9.10/nanoftp.c | 2119 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 2119 insertions(+) create mode 100644 libxml2-2.9.10/nanoftp.c (limited to 'libxml2-2.9.10/nanoftp.c') diff --git a/libxml2-2.9.10/nanoftp.c b/libxml2-2.9.10/nanoftp.c new file mode 100644 index 0000000..54fa026 --- /dev/null +++ b/libxml2-2.9.10/nanoftp.c @@ -0,0 +1,2119 @@ +/* + * 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 + +#ifdef HAVE_STDLIB_H +#include +#endif +#ifdef HAVE_UNISTD_H +#include +#endif +#ifdef HAVE_SYS_SOCKET_H +#include +#endif +#ifdef HAVE_NETINET_IN_H +#include +#endif +#ifdef HAVE_ARPA_INET_H +#include +#endif +#ifdef HAVE_NETDB_H +#include +#endif +#ifdef HAVE_FCNTL_H +#include +#endif +#ifdef HAVE_ERRNO_H +#include +#endif +#ifdef HAVE_SYS_TIME_H +#include +#endif +#ifdef HAVE_SYS_SELECT_H +#include +#endif +#ifdef HAVE_SYS_SOCKET_H +#include +#endif +#ifdef HAVE_SYS_TYPES_H +#include +#endif +#ifdef HAVE_STRINGS_H +#include +#endif + +#include +#include +#include +#include +#include +#include + +/* #define DEBUG_FTP 1 */ +#ifdef STANDALONE +#ifndef DEBUG_FTP +#define DEBUG_FTP 1 +#endif +#endif + + +#if defined(_WIN32) && !defined(__CYGWIN__) +#include +#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 +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" -- cgit v1.2.3