source: bootcd/isolinux/syslinux-6.03/core/fs/pxe/ftp.c

/* ----------------------------------------------------------------------- *
 *   
 *   Copyright 2009-2011 Intel Corporation; author: H. Peter Anvin
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
 *   Boston MA 02110-1301, USA; either version 2 of the License, or
 *   (at your option) any later version; incorporated herein by reference.
 *
 * ----------------------------------------------------------------------- */

/*
 * ftp.c
 */
#include <ctype.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <minmax.h>
#include <sys/cpu.h>
#include <netinet/in.h>
#include <lwip/api.h>
#include "core.h"
#include "fs.h"
#include "pxe.h"
#include "thread.h"
#include "url.h"
#include "net.h"

static int ftp_cmd_response(struct inode *inode, const char *cmd,
                            const char *cmd_arg,
                            uint8_t *pasv_data, int *pn_ptr)
{
    struct pxe_pvt_inode *socket = PVT(inode);
    int c;
    int pos, code;
    int pb, pn;
    bool ps;
    bool first_line, done;
    char cmd_buf[4096];
    int cmd_len;
    const char *p;
    char *q;
    int err;

    if (cmd) {
        cmd_len = strlcpy(cmd_buf, cmd, sizeof cmd_buf);
        if (cmd_len >= sizeof cmd_buf - 3)
            return -1;
        q = cmd_buf + cmd_len;

        if (cmd_arg) {
            p = cmd_arg;

            *q++ = ' ';
            cmd_len++;
            while (*p) {
                if (++cmd_len < sizeof cmd_buf) *q++ = *p;
                if (*p == '\r')
                    if (++cmd_len < sizeof cmd_buf) *q++ = '\0';
                p++;
            }

            if (cmd_len >= sizeof cmd_buf - 2)
                return -1;
        }

        *q++ = '\r';
        *q++ = '\n';
        cmd_len += 2;

        err = core_tcp_write(socket, cmd_buf, cmd_len, true);
        if (err)
            return -1;
    }

    pos = code = pn = pb = 0;
    ps = false;
    first_line = true;
    done = false;

    while ((c = pxe_getc(inode)) >= 0) {
        if (c == '\n') {
            if (done) {
                if (pn) {
                    pn += ps;
                    if (pn_ptr)
                        *pn_ptr = pn;
                }
                return code;
            }
            pos = code = 0;
            first_line = false;
            continue;
        }

        switch (pos++) {
        case 0:
        case 1:
        case 2:
            if (c < '0' || c > '9') {
                if (first_line)
                    return -1;
                else
                    pos = 4;    /* Skip this line */
            } else {
                code = (code*10) + (c - '0');
            }
            break;

        case 3:
            pn = pb = 0;
            ps = false;
            if (c == ' ')
                done = true;
            else if (c == '-')
                done = false;
            else if (first_line)
                return -1;
            else
                done = false;
            break;

        default:
            if (pasv_data) {
                if (c >= '0' && c <= '9') {
                    pb = (pb*10) + (c-'0');
                    if (pn < 6)
                        pasv_data[pn] = pb;
                    ps = true;
                } else if (c == ',') {
                    pn++;
                    pb = 0;
                    ps = false;
                } else if (pn) {
                    pn += ps;
                    if (pn_ptr)
                        *pn_ptr = pn;
                    pn = pb = 0;
                    ps = false;
                }
            }
            break;
        }
    }

    return -1;
}

static void ftp_free(struct inode *inode)
{
    struct pxe_pvt_inode *socket = PVT(inode);

    if (socket->ctl) {
        core_tcp_close_file(socket->ctl);
        free_socket(socket->ctl);
        socket->ctl = NULL;
    }
    core_tcp_close_file(inode);
}

static void ftp_close_file(struct inode *inode)
{
    struct pxe_pvt_inode *socket  = PVT(inode);
    struct pxe_pvt_inode *ctlsock;
    int resp;

    ctlsock = socket->ctl ? PVT(socket->ctl) : NULL;
    if (core_tcp_is_connected(ctlsock)) {
        resp = ftp_cmd_response(socket->ctl, "QUIT", NULL, NULL, NULL);
        while (resp == 226) {
            resp = ftp_cmd_response(socket->ctl, NULL, NULL, NULL, NULL);
        }
    }
    ftp_free(inode);
}

static const struct pxe_conn_ops ftp_conn_ops = {
    .fill_buffer        = core_tcp_fill_buffer,
    .close              = ftp_close_file,
    .readdir            = ftp_readdir,
};

void ftp_open(struct url_info *url, int flags, struct inode *inode,
              const char **redir)
{
    struct pxe_pvt_inode *socket = PVT(inode);
    struct pxe_pvt_inode *ctlsock;
    uint8_t pasv_data[6];
    int pasv_bytes;
    int resp;
    err_t err;

    (void)redir;                /* FTP does not redirect */

    inode->size = 0;

    if (!url->port)
        url->port = 21;

    url_unescape(url->path, 0);

    socket->ops = &ftp_conn_ops;

    /* Set up the control connection */
    socket->ctl = alloc_inode(inode->fs, 0, sizeof(struct pxe_pvt_inode));
    if (!socket->ctl)
        return;
    ctlsock = PVT(socket->ctl);
    ctlsock->ops = &tcp_conn_ops; /* The control connection is just TCP */
    if (core_tcp_open(ctlsock))
        goto err_free;
    err = core_tcp_connect(ctlsock, url->ip, url->port);
    if (err)
        goto err_delete;

    do {
        resp = ftp_cmd_response(socket->ctl, NULL, NULL, NULL, NULL);
    } while (resp == 120);
    if (resp != 220)
        goto err_disconnect;

    if (!url->user)
        url->user = "anonymous";
    if (!url->passwd)
        url->passwd = "syslinux@";

    resp = ftp_cmd_response(socket->ctl, "USER", url->user, NULL, NULL);
    if (resp != 202 && resp != 230) {
        if (resp != 331)
            goto err_disconnect;

        resp = ftp_cmd_response(socket->ctl, "PASS", url->passwd, NULL, NULL);
        if (resp != 230)
            goto err_disconnect;
    }

    if (!(flags & O_DIRECTORY)) {
        resp = ftp_cmd_response(socket->ctl, "TYPE", "I", NULL, NULL);
        if (resp != 200)
            goto err_disconnect;
    }

    resp = ftp_cmd_response(socket->ctl, "PASV", NULL, pasv_data, &pasv_bytes);
    if (resp != 227 || pasv_bytes != 6)
        goto err_disconnect;

    err = core_tcp_open(socket);
    if (err)
        goto err_disconnect;
    err = core_tcp_connect(socket, *(uint32_t*)&pasv_data[0],
                           ntohs(*(uint16_t *)&pasv_data[4]));
    if (err)
        goto err_disconnect;

    resp = ftp_cmd_response(socket->ctl,
                            (flags & O_DIRECTORY) ? "LIST" : "RETR",
                            url->path, NULL, NULL);
    if (resp != 125 && resp != 150)
        goto err_disconnect;

    inode->size = -1;
    return;                     /* Sucess! */

err_disconnect:
    core_tcp_write(ctlsock, "QUIT\r\n", 6, false);
    core_tcp_close_file(inode);
err_delete:
    core_tcp_close_file(socket->ctl);
err_free:
    free_socket(socket->ctl);
}