Ticket #1519: filezilla3_rc1_keepalive2.patch

src/engine/ControlSocket.h

@@ -115 +115 @@
     virtual int Chmod(const CChmodCommand& command) { return FZ_REPLY_NOTSUPPORTED; }
     virtual bool Connected() const = 0;
 
+    virtual int KeepAlive(const CKeepAliveCommand& command) { return FZ_REPLY_OK; }
+
     // If m_pCurrentOpData is zero, this function returns the current command
     // from the engine.
     enum Command GetCurrentCommandId() const;

src/engine/FileZillaEngine.cpp

@@ -70 +70 @@
     case cmd_chmod:
         res = Chmod(reinterpret_cast<const CChmodCommand&>(command));
         break;
+    case cmd_keepalive:
+        res = KeepAlive(reinterpret_cast<const CKeepAliveCommand &>(command));
+        break;
     default:
         return FZ_REPLY_SYNTAXERROR;
     }

src/engine/commands.cpp

@@ -10 +10 @@
     return m_Server;
 }
 
+CKeepAliveCommand::CKeepAliveCommand(bool keepAlive /*=true*/)
+    : m_keepAlive(keepAlive)
+{
+}
+
+bool CKeepAliveCommand::IsKeepAlive() const
+{
+    return m_keepAlive;
+}
+
 CListCommand::CListCommand(bool refresh /*=false*/)
     : m_refresh(refresh)
 {

src/engine/engineprivate.cpp

@@ -525 +525 @@
     return m_pControlSocket->Chmod(command);
 }
 
+int CFileZillaEnginePrivate::KeepAlive(const CKeepAliveCommand& command)
+{
+    m_pCurrentCommand = command.Clone();
+    return m_pControlSocket->KeepAlive(command);
+}
+
 void CFileZillaEnginePrivate::SendDirectoryListingNotification(const CServerPath& path, bool onList, bool modified, bool failed)
 {
     wxASSERT(m_pControlSocket);

src/engine/ftpcontrolsocket.cpp

@@ -24 +24 @@
 #define LOGON_CUSTOMCOMMANDS 10
 #define LOGON_DONE      11
 
+#define KEEPALIVE_TIMER_ID wxID_HIGHEST + 5
+
 BEGIN_EVENT_TABLE(CFtpControlSocket, CRealControlSocket)
 EVT_FZ_EXTERNALIPRESOLVE(wxID_ANY, CFtpControlSocket::OnExternalIPAddress)
+EVT_TIMER(wxID_ANY, CFtpControlSocket::OnTimer)
 END_EVENT_TABLE();
 
 CRawTransferOpData::CRawTransferOpData()
@@ -137 +140 @@
     m_pTlsSocket = 0;
     m_protectDataChannel = false;
     m_lastTypeBinary = -1;
+    m_bEnableKeepAlive = false;
+    m_keepAliveTimer.SetOwner(this, KEEPALIVE_TIMER_ID);
 }
 
 CFtpControlSocket::~CFtpControlSocket()
@@ -147 +152 @@
 {
     LogMessage(Debug_Verbose, _T("CFtpControlSocket::OnReceive()"));
 
+    m_keepAliveStopWatch.Start();
+
     m_pBackend->Read(m_receiveBuffer + m_bufferLen, RECVBUFFERSIZE - m_bufferLen);
     
     if (m_pBackend->Error())
     {
         if (m_pBackend->LastError() != wxSOCKET_WOULDBLOCK)
         {
+            m_bEnableKeepAlive = false;
+            m_keepAliveTimer.Stop();
             LogMessage(::Error, _("Disconnected from server"));
             DoClose();
         }
@@ -386 +395 @@
     case cmd_rawtransfer:
         TransferParseResponse();
         break;
+    case cmd_keepalive:
+        KeepAliveParseResponse();
+        break;
     case cmd_none:
         LogMessage(Debug_Verbose, _T("Out-of-order reply, ignoring."));
         break;
@@ -798 +810 @@
         LogMessage(::Error, _T("Failed to convert command to 8 bit charset"));
         return false;
     }
+    m_keepAliveStopWatch.Start();
     unsigned int len = (unsigned int)strlen(buffer);
     bool res = CRealControlSocket::Send(buffer, len);
     if (res)
@@ -1254 +1267 @@
         return DeleteSend(prevResult);
     case cmd_removedir:
         return RemoveDirSend(prevResult);
+    case cmd_keepalive:
+        return KeepAliveSend();
     default:
         LogMessage(__TFILE__, __LINE__, this, ::Debug_Warning, _T("Unknown opID (%d) in SendNextCommand"), m_pCurOpData->opId);
         ResetOperation(FZ_REPLY_INTERNALERROR);
@@ -3006 +3021 @@
     }
 
     return FZ_REPLY_WOULDBLOCK;
+}
+
+class CKeepAliveOpData : public COpData
+{
+public:
+    CKeepAliveOpData(const wxString& command)
+        : COpData(cmd_keepalive)
+    {
+        m_command = command;
+    }
+
+    wxString m_command;
+};
+
+int CFtpControlSocket::KeepAlive(const CKeepAliveCommand& command)
+{
+    LogMessage(Debug_Verbose, _T("CFtpControlSocket::KeepAlive"));
+
+    if (command.IsKeepAlive())
+    {
+        if (!m_bEnableKeepAlive)
+        {
+            m_bEnableKeepAlive = true;
+            // FIXME:
+            // read keepalive option here
+            int min_wait = 30;
+            int max_wait = 60;
+            int waitsecond = min_wait + (int)(rand()*(max_wait - min_wait)/(RAND_MAX+1));
+            m_keepAliveTimer.Start(waitsecond * 1000);
+        }
+    }
+    else
+    {
+        if (m_bEnableKeepAlive)
+        {
+            m_bEnableKeepAlive = false;
+            m_keepAliveTimer.Stop();
+        }
+    }
+
+    m_bEnableKeepAlive = true;
+    return FZ_REPLY_OK;
+}
+
+int CFtpControlSocket::DoKeepAlive()
+{
+    LogMessage(Debug_Verbose, _T("CFtpControlSocket::DoKeepAlive"));
+
+    // ignore keepalive for last I/O for socket less than 15 seconds
+    if (m_keepAliveStopWatch.Time() < 15000)
+        return FZ_REPLY_OK;
+    // choose any command
+    wxString commands[6] = {_T("PWD"),_T("REST 0"), _T("NOOP"), _T("STAT"), _T("RMD"), _T("MKD") };
+    int choice=(rand()*6)/(RAND_MAX+1);
+    m_pCurOpData = new CKeepAliveOpData(commands[choice]);
+
+    return SendNextCommand();
+}
+
+int CFtpControlSocket::KeepAliveSend()
+{
+    LogMessage(Debug_Verbose, _T("CFtpControlSocket::KeepAliveSend"));
+
+    if (!m_pCurOpData)
+    {
+        LogMessage(__TFILE__, __LINE__, this, Debug_Info, _T("Empty m_pCurOpData"));
+        ResetOperation(FZ_REPLY_INTERNALERROR);
+        return FZ_REPLY_ERROR;
+    }
+
+    CDirectoryCache cache;
+    cache.InvalidateServer(*m_pCurrentServer);
+    m_CurrentPath = CServerPath();
+
+    CKeepAliveOpData *pData = static_cast<CKeepAliveOpData *>(m_pCurOpData);
+
+    if (!Send(pData->m_command))
+        return FZ_REPLY_ERROR;
+
+    return FZ_REPLY_WOULDBLOCK;
+}
+
+int CFtpControlSocket::KeepAliveParseResponse()
+{
+    LogMessage(Debug_Verbose, _T("CFtpControlSocket::KeepAliveParseResponse"));
+
+    int code = GetReplyCode();
+    if (code == 2 || code == 3 || code == 5)
+    {
+        ResetOperation(FZ_REPLY_OK);
+        return FZ_REPLY_OK;
+    }
+    else
+    {
+        ResetOperation(FZ_REPLY_ERROR);
+        return FZ_REPLY_ERROR;
+    }
+}
+
+void CFtpControlSocket::OnTimer(wxTimerEvent& event)
+{
+    if (event.GetId() == KEEPALIVE_TIMER_ID)
+    {
+        if (m_keepAliveTimer.IsRunning())
+        {
+            m_keepAliveTimer.Stop();
+            if (m_bEnableKeepAlive) {
+                // FIXME:
+                // need to read the values from options...
+                int min_wait = 30;
+                int max_wait = 60;
+
+                int waitsecond = min_wait + (int)(rand()*(max_wait - min_wait)/(RAND_MAX+1));
+                m_keepAliveTimer.Start(waitsecond * 1000);
+                DoKeepAlive();
+            }
+        }
+    }
+    else
+        CControlSocket::OnTimer(event);
 }
 
 bool CFtpControlSocket::IsMisleadingListResponse() const

src/engine/ftpcontrolsocket.h

@@ -24 +24 @@
 
 protected:
     
+    bool m_bEnableKeepAlive;
+    wxTimer m_keepAliveTimer;
+    wxStopWatch m_keepAliveStopWatch;
+    virtual int KeepAlive(const CKeepAliveCommand& command);
+    int DoKeepAlive();
+    int KeepAliveParseResponse();
+    int KeepAliveSend();
+
     virtual int ResetOperation(int nErrorCode);
 
     virtual int Connect(const CServer &server);
@@ -128 +136 @@
 
     DECLARE_EVENT_TABLE();
     void OnExternalIPAddress(fzExternalIPResolveEvent& event);
+    void OnTimer(wxTimerEvent& event);
 };
 
 class CIOThread;

src/include/commands.h

@@ -19 +19 @@
     cmd_rename,
     cmd_chmod,
     cmd_raw,
+    cmd_keepalive,
 
     // Only used internally
     cmd_cwd,
@@ -74 +75 @@
     const CServer GetServer() const;
 protected:
     CServer m_Server;
+};
+
+DECLARE_COMMAND(CKeepAliveCommand, cmd_keepalive)
+    CKeepAliveCommand(bool keepAlive = true);
+
+    bool IsKeepAlive() const;
+
+protected:
+    bool m_keepAlive;
 };
 
 DECLARE_COMMAND(CDisconnectCommand, cmd_disconnect)

src/include/engineprivate.h

@@ -69 +69 @@
     int Mkdir(const CMkdirCommand& command);
     int Rename(const CRenameCommand& command);
     int Chmod(const CChmodCommand& command);
+    int KeepAlive(const CKeepAliveCommand& command);
 
     int ContinueConnect();
 

src/interface/Mainfrm.cpp

@@ -825 +825 @@
 
     CServerPath path;
     path.SetSafePath(COptions::Get()->GetOption(OPTION_LASTSERVERPATH));
-    m_pState->Connect(server, false, path);
+    // FIXME:
+    // read keepalive from option
+    bool keepAlive = true;
+    m_pState->Connect(server, false, path, keepAlive);
 }
 
 void CMainFrame::OnRefresh(wxCommandEvent &event)
@@ -1341 +1344 @@
             return;
     }
 
-    m_pState->Connect(pData->m_server, true, pData->m_remoteDir);
+    // FIXME:
+    // read keepalive from option
+    bool keepAlive = true;
+    m_pState->Connect(pData->m_server, true, pData->m_remoteDir, keepAlive);
 
     if (pData->m_localDir != _T(""))
         m_pState->SetLocalDir(pData->m_localDir);

src/interface/state.cpp

@@ -247 +247 @@
     NotifyHandlers(STATECHANGE_APPLYFILTER);
 }
 
-bool CState::Connect(const CServer& server, bool askBreak, const CServerPath& path /*=CServerPath()*/)
+bool CState::Connect(const CServer& server, bool askBreak, const CServerPath& path /*=CServerPath()*/, bool keepAlive)
 {
     if (!m_pEngine)
         return false;
@@ -261 +261 @@
 
     m_pCommandQueue->ProcessCommand(new CConnectCommand(server));
     m_pCommandQueue->ProcessCommand(new CListCommand(path));
+    if (keepAlive)
+        m_pCommandQueue->ProcessCommand(new CKeepAliveCommand(true));
     
     COptions::Get()->SetLastServer(server);
     COptions::Get()->SetOption(OPTION_LASTSERVERPATH, path.GetSafePath());

src/interface/state.h

@@ -40 +40 @@
     static bool LocalDirHasParent(const wxString& dir);
     static bool LocalDirIsWriteable(const wxString& dir);
 
-    bool Connect(const CServer& server, bool askBreak, const CServerPath& path = CServerPath());
+    bool Connect(const CServer& server, bool askBreak, const CServerPath& path = CServerPath(), bool keepAlive = false);
 
     bool SetRemoteDir(const CDirectoryListing *m_pDirectoryListing, bool modified = false);
     const CDirectoryListing *GetRemoteDir() const;