Annotation of embedaddon/libxml2/nanoftp.c, revision 1.1.1.3

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

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>