FTP-proxy/proxy.cpp at master · cxxx1828/FTP-proxy · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
#include "proxy.h"
#include <QDebug>

#define PROXY_PORT 2121
#define FTP_SERVER_IP "127.0.0.1"
#define FTP_SERVER_PORT 21

FTPProxy::FTPProxy(QObject *parent)
    : QObject(parent),
    clientSocket(nullptr),
    serverSocket(nullptr)
{
    connect(&proxyServer, &QTcpServer::newConnection,
            this, &FTPProxy::acceptClient);
}

bool FTPProxy::start()
{
    if (!proxyServer.listen(QHostAddress::Any, PROXY_PORT)) {
        qCritical() << "Proxy failed to start";
        return false;
    }

    qDebug() << "FTP Proxy listening on port" << PROXY_PORT;
    return true;
}


void FTPProxy::acceptClient()
{

    if (clientSocket || serverSocket) {
        cleanupConnections();
    }

    clientSocket = proxyServer.nextPendingConnection();
    qDebug() << "Client connected from"
             << clientSocket->peerAddress().toString();

    serverSocket = new QTcpSocket(this);
    serverSocket->connectToHost(FTP_SERVER_IP, FTP_SERVER_PORT);
    connect(clientSocket, &QTcpSocket::readyRead,
            this, &FTPProxy::fromClient);
    connect(serverSocket, &QTcpSocket::readyRead,
            this, &FTPProxy::fromServer);

    connect(clientSocket, &QTcpSocket::disconnected,
            this, &FTPProxy::clientDisconnected);
    connect(serverSocket, &QTcpSocket::disconnected,
            this, &FTPProxy::serverDisconnected);
}

void FTPProxy::fromClient()
{
    if (!clientSocket || !serverSocket) return;

    QByteArray data = clientSocket->readAll();
    QString cmd = QString::fromUtf8(data).trimmed();

    qDebug() << "CLIENT -> SERVER:" << cmd;


    if (cmd.startsWith("AUTH TLS") || cmd.startsWith("AUTH SSL")) {
        clientSocket->write("500 TLS not supported\r\n");
        return;
    }


    if (cmd.startsWith("QUIT")) {
        qDebug() << "QUIT command received";
    }

    if (serverSocket->state() == QAbstractSocket::ConnectedState) {
        serverSocket->write(data);
    }
}

void FTPProxy::fromServer()
{
    if (!clientSocket || !serverSocket) return;

    QByteArray data = serverSocket->readAll();
    if (data.isEmpty()) return;

    QString response = QString::fromUtf8(data).trimmed();

    qDebug() << "SERVER -> CLIENT:" << response;


    if (response.startsWith("221")) {
        qDebug() << "Server sent QUIT response: 221 Goodbye";
    }

    if (clientSocket->state() == QAbstractSocket::ConnectedState) {
        clientSocket->write(data);
    }
}

void FTPProxy::cleanupConnections()
{
    qDebug() << "Cleaning up connections...";

    if (clientSocket) {
        disconnect(clientSocket, nullptr, this, nullptr);
        clientSocket->close();
        clientSocket->deleteLater();
        clientSocket = nullptr;
    }

    if (serverSocket) {
        disconnect(serverSocket, nullptr, this, nullptr);
        serverSocket->close();
        serverSocket->deleteLater();
        serverSocket = nullptr;
    }
}

void FTPProxy::clientDisconnected()
{
    qDebug() << "Client disconnected signal received";
    cleanupConnections();
}

void FTPProxy::serverDisconnected()
{
    qDebug() << "Server disconnected signal received";
    cleanupConnections();
}