Subversion Repositories tpanel

/*
 * Copyright (C) 2022 by Andreas Theofilu <andreas@theosys.at>
 *
 * 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; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 */

#include <fstream>

#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/sendfile.h>
#include <fcntl.h>
#include <unistd.h>

#include "tfsfreader.h"
#include "tsocket.h"
#include "tconfig.h"
#include "terror.h"
#include "tresources.h"
#include "readtp4.h"

#define FTP_PORT    21

#define FTP_CMD_USER    0
#define FTP_CMD_PASS    1
#define FTP_CMD_PASV    2
#define FTP_CMD_TYPE    3
#define FTP_CMD_RETR    4
#define FTP_CMD_QUIT    5

using std::string;
using std::vector;

TFsfReader::TFsfReader()
{
    DECL_TRACER("TFsfReader::TFsfReader()");

    mFtpCmds = {
        { "USER", 331 },    // 0
        { "PASS", 230 },    // 1
        { "PASV", 227 },    // 2
        { "TYPE", 200 },    // 3
        { "RETR", 150 },    // 4
        { "QUIT", 221 }     // 5
    };
}

TFsfReader::~TFsfReader()
{
    DECL_TRACER("TFsfReader::~TFsfReader()");

    if (mFtp)
        delete mFtp;

    if (mFtpData)
        delete mFtpData;
}

bool TFsfReader::sendCommand(int cmd, const string& param)
{
    DECL_TRACER("TFsfReader::sendCommand(int cmd, const string& param)");

    if (cmd < 0 || cmd > (int)mFtpCmds.size() || !mFtp)
        return false;

    string buf;

    if (!param.empty())
        buf = mFtpCmds[cmd].cmd + "\r\n";
    else
        buf = mFtpCmds[cmd].cmd + " " + param + "\r\n";

    if (mFtp->send((char *)buf.c_str(), buf.length()) != TSocket::npos)
        return false;

    char buffer[128];
    size_t size;
    memset(buffer, 0, sizeof(buffer));

    if ((size = mFtp->receive(buffer, sizeof(buffer))) == TSocket::npos)
        return false;

    mLastCmdBuffer = buffer;
    int code = 0;

    if (mFtpCmds[cmd].success && !isdigit(buffer[0]))
    {
        MSG_ERROR("Unexpected answer: " << buffer);
        return false;
    }
    else if (mFtpCmds[cmd].success)
        code = atoi(buffer);

    if (code != mFtpCmds[cmd].success)
    {
        MSG_ERROR("FTP error: " << buffer);
        return false;
    }

    MSG_DEBUG("FTP command " << mFtpCmds[cmd].cmd << " returned: " << buffer);
    return true;
}

bool TFsfReader::copyOverFTP(const string& fname, const string& target)
{
    DECL_TRACER("TFsfReader::copyOverFTP(const string& fname, const string& target, const string& user, const string& pw)");

    if (mFtp)
        delete mFtp;

    mFtp = new TSocket(TConfig::getController(), FTP_PORT);

    string buf, filename;
    char *f, buffer[128];
    size_t size;

    if (!mFtp->connect())
        return false;

    // Server should answer with: 220 <message>
    memset(buffer, 0, sizeof(buffer));

    if ((size = mFtp->receive(buffer, sizeof(buffer))) == TSocket::npos)
    {
        mFtp->close();
        return false;
    }

    if (!startsWith(buffer, "220 "))
    {
        MSG_ERROR("Unexpected answer: " << buffer);
        mFtp->close();
        return false;
    }

    // We send the authentication
    if (!sendCommand(FTP_CMD_USER, TConfig::getFtpUser()))
    {
        mFtp->close();
        return false;
    }

    // Here we send the password
    if (!sendCommand(FTP_CMD_PASS, TConfig::getFtpPassword()))
    {
        mFtp->close();
        return false;
    }

    // Switching to passive mode
    if (!sendCommand(FTP_CMD_PASV, ""))
    {
        mFtp->close();
        return false;
    }

    size_t pos = mLastCmdBuffer.find_last_of("(");

    if (pos != string::npos)
    {
        size_t end = mLastCmdBuffer.find_last_of(")");

        if (end != string::npos)
        {
            string info = mLastCmdBuffer.substr(pos + 1, end-pos-2);
            MSG_DEBUG("PASV " << info);
            vector<string> parts = StrSplit(info, ",");

            if (parts.size() < 6)
            {
                MSG_ERROR("PASV command failed!");
            }
            else
            {
                mDataPort = atoi(parts[4].c_str()) * 256 + atoi(parts[5].c_str());
                mPassive = true;
            }
        }
    }
    else
    {
        MSG_ERROR("Unexpected response from FTP server!");
        mFtp->close();
        return false;
    }

    // We connect to the data port
    if (mFtpData)
        delete mFtpData;

    mFtpData = new TSocket(TConfig::getController(), mDataPort);

    if (!mFtpData->connect())
    {
        mFtp->close();
        return false;
    }

    // Switch to image mode
    if (!sendCommand(FTP_CMD_TYPE, "I"))
    {
        mFtp->close();
        return false;
    }

    // GET a file
    if (!sendCommand(FTP_CMD_RETR, fname))
    {
        mFtp->close();
        return false;
    }

    size = 0;
    pos = mLastCmdBuffer.find_last_of("(");

    if (pos != string::npos)
    {
        string info = mLastCmdBuffer.substr(pos + 1);
        MSG_DEBUG("RETR size: " << info);
        size = atoi(info.c_str());
    }
    else
    {
        MSG_ERROR("Unexpected response: " << mLastCmdBuffer);
        mFtp->close();
        return false;
    }

    // FIXME: Add code to receive file
    f = new char[size+1];

    if (mFtpData->readAbsolut(f, size) == TSocket::npos)
    {
        MSG_ERROR("Error receiving file " << fname << " from FTP server!");
        mFtpData->close();
        mFtp->close();
        delete[] f;
        return false;
    }

    // Write the file into place
    try
    {
        std::ofstream file;

        file.open(target, std::ios_base::binary);
        file.write(f, size);
        file.close();
    }
    catch (std::exception& e)
    {
        MSG_ERROR("Error on file " << target << ": " << e.what());
        mFtpData->close();
        mFtp->close();
        delete[] f;
        return false;
    }

    // QUIT from FTP-server
    if (!sendCommand(FTP_CMD_QUIT, ""))
    {
        mFtp->close();
        mFtpData->close();
        return false;
    }

    mFtp->close();
    mFtpData->close();
    return true;
}

bool TFsfReader::unpack(const string& fname, const string& path)
{
    DECL_TRACER("TFsfReader::unpack(const string& fname, const string& path)");

    if (fname.empty() || path.empty())
    {
        MSG_ERROR("Invalid parameters!");
        return false;
    }

    reader::ReadTP4 readtp4(fname, path);
    return readtp4.doRead();
}