forked from Akimkin/kf5-kio-ftps
-
Notifications
You must be signed in to change notification settings - Fork 0
/
ftps.h
496 lines (412 loc) · 15.2 KB
/
ftps.h
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
/*
This file is part of the KDE libraries
SPDX-FileCopyrightText: 2000 David Faure <faure@kde.org>
SPDX-FileCopyrightText: 2019-2021 Harald Sitter <sitter@kde.org>
SPDX-License-Identifier: LGPL-2.0-or-later
*/
#ifndef KDELIBS_FTP_H
#define KDELIBS_FTP_H
#include <qplatformdefs.h>
#include <QDateTime>
#include <QUrl>
#include <kio/workerbase.h>
#include <QtNetwork/QSslSocket>
#include <QtNetwork/QTcpServer>
class QTcpServer;
class QTcpSocket;
class QNetworkProxy;
class QAuthenticator;
struct FtpEntry {
QString name;
QString owner;
QString group;
QString link;
KIO::filesize_t size;
mode_t type;
mode_t access;
QDateTime date;
};
class SslServer : public QTcpServer
{
private:
void incomingConnection(qintptr handle) override;
QSslSocket *m_socket;
public:
QSslSocket *socket() { return m_socket; };
};
class FtpInternal;
/**
* Login Mode for ftpOpenConnection
*/
enum class LoginMode {
Deferred,
Explicit,
Implicit,
};
using Result = KIO::WorkerResult;
/**
* Special Result composite for errors during connection.
*/
struct ConnectionResult {
QSslSocket *socket;
Result result;
};
QDebug operator<<(QDebug dbg, const Result &r);
//===============================================================================
// Ftp
// The API class. This class should not contain *any* FTP logic. It acts
// as a container for FtpInternal to prevent the latter from directly doing
// state manipulation via error/finished/opened etc.
//===============================================================================
class Ftp : public KIO::WorkerBase
{
public:
Ftp(const QByteArray &pool, const QByteArray &app);
~Ftp() override;
void setHost(const QString &host, quint16 port, const QString &user, const QString &pass) override;
/**
* Connects to a ftp server and logs us in
* m_bLoggedOn is set to true if logging on was successful.
* It is set to false if the connection becomes closed.
*
*/
KIO::WorkerResult openConnection() override;
/**
* Closes the connection
*/
void closeConnection() override;
KIO::WorkerResult stat(const QUrl &url) override;
KIO::WorkerResult listDir(const QUrl &url) override;
KIO::WorkerResult mkdir(const QUrl &url, int permissions) override;
KIO::WorkerResult rename(const QUrl &src, const QUrl &dst, KIO::JobFlags flags) override;
KIO::WorkerResult del(const QUrl &url, bool isfile) override;
KIO::WorkerResult chmod(const QUrl &url, int permissions) override;
KIO::WorkerResult get(const QUrl &url) override;
KIO::WorkerResult put(const QUrl &url, int permissions, KIO::JobFlags flags) override;
void worker_status() override;
/**
* Handles the case that one side of the job is a local file
*/
KIO::WorkerResult copy(const QUrl &src, const QUrl &dest, int permissions, KIO::JobFlags flags) override;
std::unique_ptr<FtpInternal> d;
};
/**
* Internal logic class.
*
* This class implements strict separation between the API (Ftp) and
* the logic behind the API (FtpInternal). This class' functions
* are meant to return Result objects up the call stack to Ftp where
* they will be turned into command results (e.g. error(),
* finished(), etc.). This class cannot and must not call these signals
* directly as it leads to unclear states.
*/
class FtpInternal : public QObject
{
Q_OBJECT
public:
explicit FtpInternal(Ftp *qptr);
~FtpInternal() override;
// ---------------------------------------- API
void setHost(const QString &host, quint16 port, const QString &user, const QString &pass);
/**
* Connects to a ftp server and logs us in
* m_bLoggedOn is set to true if logging on was successful.
* It is set to false if the connection becomes closed.
*
*/
Q_REQUIRED_RESULT Result openConnection();
/**
* Closes the connection
*/
void closeConnection();
Q_REQUIRED_RESULT Result stat(const QUrl &url);
Result listDir(const QUrl &url);
Q_REQUIRED_RESULT Result mkdir(const QUrl &url, int permissions);
Q_REQUIRED_RESULT Result rename(const QUrl &src, const QUrl &dst, KIO::JobFlags flags);
Q_REQUIRED_RESULT Result del(const QUrl &url, bool isfile);
Q_REQUIRED_RESULT Result chmod(const QUrl &url, int permissions);
Q_REQUIRED_RESULT Result get(const QUrl &url);
Q_REQUIRED_RESULT Result put(const QUrl &url, int permissions, KIO::JobFlags flags);
// virtual void mimetype( const QUrl& url );
void worker_status();
/**
* Handles the case that one side of the job is a local file
*/
Q_REQUIRED_RESULT Result copy(const QUrl &src, const QUrl &dest, int permissions, KIO::JobFlags flags);
// ---------------------------------------- END API
static bool isSocksProxyScheme(const QString &scheme);
bool isSocksProxy() const;
/**
* Connect and login to the FTP server.
*
* @param loginMode controls if login info should be sent<br>
* loginDeferred - must not be logged on, no login info is sent<br>
* loginExplicit - must not be logged on, login info is sent<br>
* loginImplicit - login info is sent if not logged on
*
* @return true on success (a login failure would return false).
*/
Q_REQUIRED_RESULT Result ftpOpenConnection(LoginMode loginMode);
/**
* Called by openConnection. It logs us in.
* m_initialPath is set to the current working directory
* if logging on was successful.
*
* @param userChanged if not nullptr, will be set to true if the user name
* was changed during login.
* @return true on success.
*/
Q_REQUIRED_RESULT Result ftpLogin(bool *userChanged = nullptr);
/**
* ftpSendCmd - send a command (@p cmd) and read response
*
* @param maxretries number of time it should retry. Since it recursively
* calls itself if it can't read the answer (this happens especially after
* timeouts), we need to limit the recursiveness ;-)
*
* return true if any response received, false on error
*/
Q_REQUIRED_RESULT bool ftpSendCmd(const QByteArray &cmd, int maxretries = 1);
/**
* Use the SIZE command to get the file size.
* @param mode the size depends on the transfer mode, hence this arg.
* @return true on success
* Gets the size into m_size.
*/
bool ftpSize(const QString &path, char mode);
/**
* Returns true if the file exists.
* Implemented using the SIZE command.
*/
bool ftpFileExists(const QString &path);
/**
* Set the current working directory, but only if not yet current
*/
Q_REQUIRED_RESULT bool ftpFolder(const QString &path);
/**
* Runs a command on the ftp server like "list" or "retr". In contrast to
* ftpSendCmd a data connection is opened. The corresponding socket
* sData is available for reading/writing on success.
* The connection must be closed afterwards with ftpCloseCommand.
*
* @param mode is 'A' or 'I'. 'A' means ASCII transfer, 'I' means binary transfer.
* @param errorcode the command-dependent error code to emit on error
*
* @return true if the command was accepted by the server.
*/
Q_REQUIRED_RESULT Result ftpOpenCommand(const char *command, const QString &path, char mode, int errorcode, KIO::fileoffset_t offset = 0);
/**
* The counterpart to openCommand.
* Closes data sockets and then reads line sent by server at
* end of command.
* @return false on error (line doesn't start with '2')
*/
bool ftpCloseCommand();
/**
* Send "TYPE I" or "TYPE A" only if required, see m_cDataMode.
*
* Use 'A' to select ASCII and 'I' to select BINARY mode. If
* cMode is '?' the m_bTextMode flag is used to choose a mode.
*/
bool ftpDataMode(char cMode);
// void ftpAbortTransfer();
/**
* Used by ftpOpenCommand, return 0 on success or an error code
*/
int ftpOpenDataConnection();
/**
* closes a data connection, see ftpOpenDataConnection()
*/
void ftpCloseDataConnection();
/**
* Helper for ftpOpenDataConnection
*/
int ftpOpenPASVDataConnection();
/**
* Helper for ftpOpenDataConnection
*/
int ftpOpenEPSVDataConnection();
/**
* Helper for ftpOpenDataConnection
*/
int ftpOpenPortDataConnection();
bool ftpChmod(const QString &path, int permissions);
// used by listDir
Q_REQUIRED_RESULT Result ftpOpenDir(const QString &path);
/**
* Called to parse directory listings, call this until it returns false
*/
bool ftpReadDir(FtpEntry &ftpEnt);
/**
* Helper to fill an UDSEntry
*/
void ftpCreateUDSEntry(const QString &filename, const FtpEntry &ftpEnt, KIO::UDSEntry &entry, bool isDir);
void ftpShortStatAnswer(const QString &filename, bool isDir);
Q_REQUIRED_RESULT Result ftpStatAnswerNotFound(const QString &path, const QString &filename);
/**
* This is the internal implementation of rename() - set put().
*
* @return true on success.
*/
Q_REQUIRED_RESULT Result ftpRename(const QString &src, const QString &dst, KIO::JobFlags flags);
/**
* Called by openConnection. It opens the control connection to the ftp server.
*
* @return true on success.
*/
Q_REQUIRED_RESULT Result ftpOpenControlConnection();
Q_REQUIRED_RESULT Result ftpOpenControlConnection(const QString &host, int port, bool ignoreSslErrors = false);
/**
* closes the socket holding the control connection (see ftpOpenControlConnection)
*/
void ftpCloseControlConnection();
/**
* read a response from the server (a trailing CR gets stripped)
* @param iOffset -1 to read a new line from the server<br>
* 0 to return the whole response string
* >0 to return the response with iOffset chars skipped
* @return the response message with iOffset chars skipped (or "" if iOffset points
* behind the available data)
*/
const char *ftpResponse(int iOffset);
/**
* This is the internal implementation of get() - see copy().
*
* IMPORTANT: the caller should call ftpCloseCommand() on return.
* The function does not call error(), the caller should do this.
*
* @param iError set to an ERR_xxxx code on error
* @param iCopyFile -1 -or- handle of a local destination file
* @param hCopyOffset local file only: non-zero for resume
* @return 0 for success, -1 for server error, -2 for client error
*/
Q_REQUIRED_RESULT Result ftpGet(int iCopyFile, const QString &sCopyFile, const QUrl &url, KIO::fileoffset_t hCopyOffset);
/**
* This is the internal implementation of put() - see copy().
*
* IMPORTANT: the caller should call ftpCloseCommand() on return.
* The function does not call error(), the caller should do this.
*
* @param iError set to an ERR_xxxx code on error
* @param iCopyFile -1 -or- handle of a local source file
* @return 0 for success, -1 for server error, -2 for client error
*/
Q_REQUIRED_RESULT Result ftpPut(int iCopyFile, const QUrl &url, int permissions, KIO::JobFlags flags);
/**
* helper called from copy() to implement FILE -> FTP transfers
*
* @param iError set to an ERR_xxxx code on error
* @param iCopyFile [out] handle of a local source file
* @param sCopyFile path of the local source file
* @return 0 for success, -1 for server error, -2 for client error
*/
Q_REQUIRED_RESULT Result ftpCopyPut(int &iCopyFile, const QString &sCopyFile, const QUrl &url, int permissions, KIO::JobFlags flags);
/**
* helper called from copy() to implement FTP -> FILE transfers
*
* @param iError set to an ERR_xxxx code on error
* @param iCopyFile [out] handle of a local source file
* @param sCopyFile path of the local destination file
* @return 0 for success, -1 for server error, -2 for client error
*/
Q_REQUIRED_RESULT Result ftpCopyGet(int &iCopyFile, const QString &sCopyFile, const QUrl &url, int permissions, KIO::JobFlags flags);
/**
* Sends the MIME type of the content to retrieved.
*
* @param iError set to an ERR_xxxx code on error
* @return 0 for success, -1 for server error, -2 for client error
*/
Q_REQUIRED_RESULT Result ftpSendMimeType(const QUrl &url);
/**
* Fixes up an entry name so that extraneous whitespaces do not cause
* problems. See bug# 88575 and bug# 300988.
*/
void fixupEntryName(FtpEntry *ftpEnt);
/**
* Calls @ref statEntry.
*/
bool maybeEmitStatEntry(FtpEntry &ftpEnt, const QString &filename, bool isDir);
/**
* Setup the connection to the server.
*/
Q_REQUIRED_RESULT ConnectionResult synchronousConnectToHost(const QString &host, quint16 port);
private: // data members
Ftp *const q;
QString m_host;
int m_port = 0;
QString m_user;
QString m_pass;
/**
* Where we end up after connecting
*/
QString m_initialPath;
QUrl m_proxyURL;
QStringList m_proxyUrls;
/**
* the current working directory - see ftpFolder
*/
QString m_currentPath;
/**
* the status returned by the FTP protocol, set in ftpResponse()
*/
int m_iRespCode = 0;
/**
* the status/100 returned by the FTP protocol, set in ftpResponse()
*/
int m_iRespType = 0;
/**
* This flag is maintained by ftpDataMode() and contains I or A after
* ftpDataMode() has successfully set the mode.
*/
char m_cDataMode;
/**
* true if logged on (m_control should also be non-nullptr)
*/
bool m_bLoggedOn;
/**
* true if a "textmode" metadata key was found by ftpLogin(). This
* switches the ftp data transfer mode from binary to ASCII.
*/
bool m_bTextMode;
/**
* true if a data stream is open, used in closeConnection().
*
* When the user cancels a get or put command the Ftp dtor will be called,
* which in turn calls closeConnection(). The later would try to send QUIT
* which won't work until timeout. ftpOpenCommand sets the m_bBusy flag so
* that the sockets will be closed immediately - the server should be
* capable of handling this and return an error code on thru the control
* connection. The m_bBusy gets cleared by the ftpCloseCommand() routine.
*/
bool m_bBusy;
bool m_bPasv;
KIO::filesize_t m_size;
static const KIO::filesize_t UnknownSize;
enum {
epsvUnknown = 0x01,
epsvAllUnknown = 0x02,
eprtUnknown = 0x04,
epsvAllSent = 0x10,
pasvUnknown = 0x20,
chmodUnknown = 0x100,
};
int m_extControl;
/**
* control connection socket, only set if openControl() succeeded
*/
QSslSocket *m_control = nullptr;
QByteArray m_lastControlLine;
/**
* data connection socket
*/
QSslSocket *m_data = nullptr;
/**
* active mode server socket
*/
// QTcpServer *m_server = nullptr;
SslServer *m_server = nullptr;
bool m_bIgnoreSslErrors;
bool requestDataEncryption();
int encryptDataChannel();
};
#endif // KDELIBS_FTP_H