source: filezilla/trunk/fuentes/src/engine/ControlSocket.h @ 130

Last change on this file since 130 was 130, checked in by jrpelegrina, 3 years ago

First release to xenial

File size: 7.7 KB
Line 
1#ifndef __CONTROLSOCKET_H__
2#define __CONTROLSOCKET_H__
3
4#include "socket.h"
5#include "logging_private.h"
6#include "backend.h"
7
8class COpData
9{
10public:
11        COpData(Command op_Id);
12        virtual ~COpData();
13
14        COpData(COpData const&) = delete;
15        COpData& operator=(COpData const&) = delete;
16
17        int opState;
18        Command const opId;
19
20        bool waitForAsyncRequest;
21        bool holdsLock;
22
23        COpData *pNextOpData;
24};
25
26class CConnectOpData : public COpData
27{
28public:
29        CConnectOpData()
30                : COpData(Command::connect)
31                , port(0)
32        {
33        }
34
35        wxString host;
36        unsigned int port;
37};
38
39class CFileTransferOpData : public COpData
40{
41public:
42        CFileTransferOpData(bool is_download, const wxString& local_file, const wxString& remote_file, const CServerPath& remote_path);
43        virtual ~CFileTransferOpData();
44        // Transfer data
45        wxString localFile, remoteFile;
46        CServerPath remotePath;
47        const bool download;
48
49        CDateTime fileTime;
50        int64_t localFileSize{-1};
51        int64_t remoteFileSize{-1};
52
53        bool tryAbsolutePath{};
54        bool resume{};
55
56        CFileTransferCommand::t_transferSettings transferSettings;
57
58        // Set to true when sending the command which
59        // starts the actual transfer
60        bool transferInitiated{};
61};
62
63class CMkdirOpData final : public COpData
64{
65public:
66        CMkdirOpData()
67                : COpData(Command::mkdir)
68        {
69        }
70
71        CServerPath path;
72        CServerPath currentPath;
73        CServerPath commonParent;
74        std::vector<wxString> segments;
75};
76
77class CChangeDirOpData : public COpData
78{
79public:
80        CChangeDirOpData()
81                : COpData(Command::cwd)
82        {
83                tryMkdOnFail = false;
84                link_discovery = false;
85        }
86
87        virtual ~CChangeDirOpData()
88        {
89        }
90
91        CServerPath path;
92        wxString subDir;
93        bool tryMkdOnFail;
94        CServerPath target;
95
96        bool link_discovery;
97};
98
99enum class TransferEndReason
100{
101        none,
102        successful,
103        timeout,
104        transfer_failure,                                       // Error during transfer, like lost connection. Retry automatically
105        transfer_failure_critical,                      // Error during transfer like lack of diskspace. Needs user interaction
106        pre_transfer_command_failure,           // If a command fails prior to sending the transfer command
107        transfer_command_failure_immediate,     // Used if server does not send the 150 reply after the transfer command
108        transfer_command_failure,                       // Used if the transfer command fails, but after receiving a 150 first
109        failure,                                                        // Other unspecific failure
110        failed_resumetest
111};
112
113class CTransferStatus;
114class CControlSocket: public CLogging, public CEventHandler
115{
116public:
117        CControlSocket(CFileZillaEnginePrivate & engine);
118        virtual ~CControlSocket();
119
120        CControlSocket(CControlSocket const&) = delete;
121        CControlSocket& operator=(CControlSocket const&) = delete;
122
123        virtual int Connect(const CServer &server) = 0;
124        virtual int Disconnect();
125        virtual void Cancel();
126        virtual int List(CServerPath path = CServerPath(), wxString subDir = wxString(), int flags = 0);
127        virtual int FileTransfer(const wxString localFile, const CServerPath &remotePath,
128                                                         const wxString &remoteFile, bool download,
129                                                         const CFileTransferCommand::t_transferSettings& transferSettings);
130        virtual int RawCommand(const wxString& command = wxString());
131        virtual int Delete(const CServerPath& path, std::deque<wxString>&& files);
132        virtual int RemoveDir(const CServerPath& path = CServerPath(), const wxString& subDir = wxString());
133        virtual int Mkdir(const CServerPath& path);
134        virtual int Rename(const CRenameCommand& command);
135        virtual int Chmod(const CChmodCommand& command);
136        virtual bool Connected() = 0;
137
138        // If m_pCurrentOpData is zero, this function returns the current command
139        // from the engine.
140        Command GetCurrentCommandId() const;
141
142        virtual void TransferEnd() {}
143
144        void SendAsyncRequest(CAsyncRequestNotification* pNotification);
145        virtual bool SetAsyncRequestReply(CAsyncRequestNotification *pNotification) = 0;
146        bool SetFileExistsAction(CFileExistsNotification *pFileExistsNotification);
147
148        const CServer* GetCurrentServer() const;
149
150        // Conversion function which convert between local and server charset.
151        wxString ConvToLocal(const char* buffer, size_t len);
152        wxChar* ConvToLocalBuffer(const char* buffer, size_t len, size_t& outlen);
153        wxChar* ConvToLocalBuffer(const char* buffer, wxMBConv& conv, size_t len, size_t& outlen);
154        wxCharBuffer ConvToServer(const wxString& str, bool force_utf8 = false);
155
156        void SetActive(CFileZillaEngine::_direction direction);
157
158        // ---
159        // The following two functions control the timeout behaviour:
160        // ---
161
162        // Call this if data could be sent or retrieved
163        void SetAlive();
164
165        // Set to true if waiting for data
166        void SetWait(bool waiting);
167
168        CFileZillaEnginePrivate& GetEngine() { return engine_; }
169
170        // Only called from the engine, see there for description
171        void InvalidateCurrentWorkingDir(const CServerPath& path);
172
173protected:
174        duration GetTimezoneOffset() const;
175
176        virtual int DoClose(int nErrorCode = FZ_REPLY_DISCONNECTED);
177        bool m_closed;
178
179        virtual int ResetOperation(int nErrorCode);
180
181        virtual int SendNextCommand();
182
183        void LogTransferResultMessage(int nErrorCode, CFileTransferOpData *pData);
184
185        // Called by ResetOperation if there's a queued operation
186        virtual int ParseSubcommandResult(int prevResult);
187
188        wxString ConvertDomainName(wxString const& domain);
189
190        int CheckOverwriteFile();
191
192        void CreateLocalDir(const wxString &local_file);
193
194        bool ParsePwdReply(wxString reply, bool unquoted = false, const CServerPath& defaultPath = CServerPath());
195
196        COpData *m_pCurOpData;
197        int m_nOpState;
198        CFileZillaEnginePrivate & engine_;
199        CServer *m_pCurrentServer;
200
201        CServerPath m_CurrentPath;
202
203        wxCSConv *m_pCSConv;
204        bool m_useUTF8;
205
206        // Timeout data
207        timer_id m_timer{};
208        CMonotonicClock m_lastActivity;
209
210        // -------------------------
211        // Begin cache locking stuff
212        // -------------------------
213
214        enum locking_reason
215        {
216                lock_unknown = -1,
217                lock_list,
218                lock_mkdir
219        };
220
221        // Tries to obtain lock. Returns true on success.
222        // On failure, caller has to pass control.
223        // SendNextCommand will be called once the lock gets available
224        // and engine could obtain it.
225        // Lock is recursive. Lock counter increases on suboperations.
226        bool TryLockCache(enum locking_reason reason, const CServerPath& directory);
227        bool IsLocked(enum locking_reason reason, const CServerPath& directory);
228
229        // Unlocks the cache. Can be called if not holding the lock
230        // Doesn't need reason as one engine can at most hold one lock
231        void UnlockCache();
232
233        // Called from the fzOBTAINLOCK event.
234        // Returns reason != unknown iff engine is the first waiting engine
235        // and obtains the lock.
236        // On failure, the engine was not waiting for a lock.
237        enum locking_reason ObtainLockFromEvent();
238
239        bool IsWaitingForLock();
240
241        struct t_lockInfo
242        {
243                CControlSocket* pControlSocket;
244                CServerPath directory;
245                enum locking_reason reason;
246                bool waiting;
247                int lockcount;
248        };
249        static std::list<t_lockInfo> m_lockInfoList;
250
251        const std::list<t_lockInfo>::iterator GetLockStatus();
252
253        // -----------------------
254        // End cache locking stuff
255        // -----------------------
256
257        bool m_invalidateCurrentPath;
258
259        virtual void operator()(CEventBase const& ev);
260
261        void OnTimer(timer_id id);
262        void OnObtainLock();
263};
264
265class CProxySocket;
266class CRealControlSocket : public CControlSocket
267{
268public:
269        CRealControlSocket(CFileZillaEnginePrivate & engine);
270        virtual ~CRealControlSocket();
271
272        virtual int Connect(const CServer &server);
273        virtual int ContinueConnect();
274
275        virtual bool Connected() { return m_pSocket->GetState() == CSocket::connected; }
276
277protected:
278        virtual int DoClose(int nErrorCode = FZ_REPLY_DISCONNECTED);
279        void ResetSocket();
280
281        virtual void operator()(CEventBase const& ev);
282        void OnSocketEvent(CSocketEventSource* source, SocketEventType t, int error);
283        void OnHostAddress(CSocketEventSource* source, wxString const& address);
284
285        virtual void OnConnect();
286        virtual void OnReceive();
287        void OnSend();
288        virtual void OnClose(int error);
289
290        bool Send(const char *buffer, int len);
291
292        CSocket* m_pSocket;
293
294        CBackend* m_pBackend;
295        CProxySocket* m_pProxyBackend;
296
297        char *m_pSendBuffer;
298        int m_nSendBufferLen;
299};
300
301#endif
Note: See TracBrowser for help on using the repository browser.