Ignore:
Timestamp:
Jan 9, 2017, 11:09:38 AM (2 years ago)
Author:
jrpelegrina
Message:

Update new version: 3.15.02

File:
1 edited

Legend:

Unmodified
Added
Removed
  • filezilla/trunk/fuentes/src/engine/sftpcontrolsocket.cpp

    r130 r3185  
    44#include "directorylistingparser.h"
    55#include "engineprivate.h"
    6 #include "event_loop.h"
    76#include "pathcache.h"
    8 #include "local_filesys.h"
    9 #include "fzprocess.h"
    107#include "proxy.h"
    118#include "servercapabilities.h"
    129#include "sftpcontrolsocket.h"
     10
     11#include <libfilezilla/event_loop.hpp>
     12#include <libfilezilla/local_filesys.hpp>
     13#include <libfilezilla/process.hpp>
    1314
    1415#include <wx/filename.h>
     
    2021
    2122struct sftp_event_type;
    22 typedef CEvent<sftp_event_type> CSftpEvent;
     23typedef fz::simple_event<sftp_event_type> CSftpEvent;
    2324
    2425struct terminate_event_type;
    25 typedef CEvent<terminate_event_type> CTerminateEvent;
     26typedef fz::simple_event<terminate_event_type> CTerminateEvent;
    2627
    2728class CSftpFileTransferOpData : public CFileTransferOpData
     
    5556};
    5657
    57 class CSftpInputThread final : public wxThread
     58class CSftpInputThread final : public fz::thread
    5859{
    5960public:
    60         CSftpInputThread(CSftpControlSocket* pOwner, CProcess& process)
    61                 : wxThread(wxTHREAD_JOINABLE)
    62                 , process_(process)
     61        CSftpInputThread(CSftpControlSocket* pOwner, fz::process& proc)
     62                : process_(proc)
    6363                , m_pOwner(pOwner)
    6464        {
     
    6767        virtual ~CSftpInputThread()
    6868        {
    69                 scoped_lock l(m_sync);
     69                join();
     70
     71                fz::scoped_lock l(m_sync);
    7072                for (auto & msg : m_sftpMessages) {
    7173                        delete msg;
     
    7375        }
    7476
    75         bool Init()
    76         {
    77                 if (Create() != wxTHREAD_NO_ERROR)
    78                         return false;
    79 
    80                 Run();
    81 
    82                 return true;
    83         }
    84 
    8577        void GetMessages(std::vector<sftp_message*>& messages)
    8678        {
    87                 scoped_lock l(m_sync);
     79                fz::scoped_lock l(m_sync);
    8880                messages.swap(m_sftpMessages);
    8981        }
     
    9688
    9789                {
    98                         scoped_lock l(m_sync);
     90                        fz::scoped_lock l(m_sync);
    9991                        sendEvent = m_sftpMessages.empty();
    10092                        m_sftpMessages.push_back(message);
     
    10294
    10395                if (sendEvent)
    104                         m_pOwner->SendEvent<CSftpEvent>();
     96                        m_pOwner->send_event<CSftpEvent>();
    10597        }
    10698
     
    111103                while(true) {
    112104                        char c;
    113                         int read = process_.Read(&c, 1);
     105                        int read = process_.read(&c, 1);
    114106                        if (read != 1) {
    115107                                if (!read)
     
    139131                while(true) {
    140132                        char c;
    141                         int read = process_.Read(&c, 1);
     133                        int read = process_.read(&c, 1);
    142134                        if (read != 1) {
    143135                                if (!read)
     
    174166        }
    175167
    176         virtual ExitCode Entry()
     168        virtual void entry()
    177169        {
    178170                bool error = false;
    179171                while (!error) {
    180172                        char readType = 0;
    181                         int read = process_.Read(&readType, 1);
     173                        int read = process_.read(&readType, 1);
    182174                        if (read != 1)
    183175                                break;
     
    285277loopexit:
    286278
    287                 m_pOwner->SendEvent<CTerminateEvent>();
    288                 return reinterpret_cast<ExitCode>(Close());
    289         }
    290 
    291         int Close()
    292         {
    293                 return 0;
    294         }
    295 
    296         CProcess& process_;
     279                m_pOwner->send_event<CTerminateEvent>();
     280        }
     281
     282        fz::process& process_;
    297283        CSftpControlSocket* m_pOwner;
    298284
    299285        std::vector<sftp_message*> m_sftpMessages;
    300         mutex m_sync;
     286        fz::mutex m_sync;
    301287};
    302288
     
    314300        std::deque<wxString> files;
    315301
    316         // Set to CDateTime::Now initially and after
     302        // Set to fz::datetime::Now initially and after
    317303        // sending an updated listing to the UI.
    318         CDateTime m_time;
     304        fz::datetime m_time;
    319305
    320306        bool m_needSendListing{};
     
    332318CSftpControlSocket::~CSftpControlSocket()
    333319{
    334         RemoveHandler();
     320        remove_handler();
    335321        DoClose();
    336322}
     
    406392                pData->pKeyFiles = pTokenizer;
    407393
    408         m_pProcess = new CProcess();
     394        m_pProcess = new fz::process();
    409395
    410396        engine_.GetRateLimiter().AddObject(this);
    411397
    412         wxString executable = engine_.GetOptions().GetOption(OPTION_FZSFTP_EXECUTABLE);
     398        auto executable = fz::to_native(engine_.GetOptions().GetOption(OPTION_FZSFTP_EXECUTABLE));
    413399        if (executable.empty())
    414                 executable = _T("fzsftp");
     400                executable = fzT("fzsftp");
    415401        LogMessage(MessageType::Debug_Verbose, _T("Going to execute %s"), executable);
    416402
    417         std::vector<wxString> args = {_T("-v")};
     403        std::vector<fz::native_string> args = {fzT("-v")};
    418404        if (engine_.GetOptions().GetOptionVal(OPTION_SFTP_COMPRESSION)) {
    419                 args.push_back(_T("-C"));
    420         }
    421         if (!m_pProcess->Execute(executable, args)) {
     405                args.push_back(fzT("-C"));
     406        }
     407        if (!m_pProcess->spawn(executable, args)) {
    422408                LogMessage(MessageType::Debug_Warning, _T("Could not create process: %s"), wxSysErrorMsg());
    423409                DoClose();
     
    426412
    427413        m_pInputThread = new CSftpInputThread(this, *m_pProcess);
    428         if (!m_pInputThread->Init()) {
     414        if (!m_pInputThread->run()) {
    429415                LogMessage(MessageType::Debug_Warning, _T("Thread creation failed"));
    430416                delete m_pInputThread;
     
    805791
    806792        unsigned int len = strlen(str);
    807         return m_pProcess->Write(str, len);
     793        return m_pProcess->write(str, len);
    808794}
    809795
     
    10301016                        }
    10311017                        if (parsed) {
    1032                                 CDateTime date(seconds, CDateTime::seconds);
    1033                                 if (date.IsValid()) {
     1018                                fz::datetime date(seconds, fz::datetime::seconds);
     1019                                if (date.empty()) {
    10341020                                        wxASSERT(pData->directoryListing[pData->mtime_index].has_date());
    1035                                         CDateTime listTime = pData->directoryListing[pData->mtime_index].time;
    1036                                         listTime -= duration::from_minutes(m_pCurrentServer->GetTimezoneOffset());
     1021                                        fz::datetime listTime = pData->directoryListing[pData->mtime_index].time;
     1022                                        listTime -= fz::duration::from_minutes(m_pCurrentServer->GetTimezoneOffset());
    10371023
    10381024                                        int serveroffset = static_cast<int>((date - listTime).get_seconds());
     
    10461032                                        LogMessage(MessageType::Status, _("Timezone offset of server is %d seconds."), -serveroffset);
    10471033
    1048                                         duration span = duration::from_seconds(serveroffset);
     1034                                        fz::duration span = fz::duration::from_seconds(serveroffset);
    10491035                                        const int count = pData->directoryListing.GetCount();
    10501036                                        for (int i = 0; i < count; ++i) {
     
    15971583        int64_t size;
    15981584        bool isLink;
    1599         if (CLocalFileSystem::GetFileInfo(pData->localFile, isLink, &size, 0, 0) == CLocalFileSystem::file)
     1585        if (fz::local_filesys::get_file_info(fz::to_native(pData->localFile), isLink, &size, 0, 0) == fz::local_filesys::file)
    16001586                pData->localFileSize = size;
    16011587
     
    18011787        else if (pData->opState == filetransfer_chmtime)
    18021788        {
    1803                 wxASSERT(pData->fileTime.IsValid());
     1789                wxASSERT(pData->fileTime.empty());
    18041790                if (pData->download)
    18051791                {
     
    18111797                wxString quotedFilename = QuoteFilename(pData->remotePath.FormatFilename(pData->remoteFile, !pData->tryAbsolutePath));
    18121798                // Y2K38
    1813                 time_t ticks = pData->fileTime.GetTimeT();
     1799                time_t ticks = pData->fileTime.get_time_t();
    18141800                wxString seconds = wxString::Format(_T("%d"), (int)ticks);
    18151801                if (!SendCommand(_T("chmtime ") + seconds + _T(" ") + WildcardEscape(quotedFilename),
     
    18411827                if (engine_.GetOptions().GetOptionVal(OPTION_PRESERVE_TIMESTAMPS)) {
    18421828                        if (pData->download) {
    1843                                 if (pData->fileTime.IsValid()) {
    1844                                         if (!CLocalFileSystem::SetModificationTime(pData->localFile, pData->fileTime))
     1829                                if (pData->fileTime.empty()) {
     1830                                        if (!fz::local_filesys::set_modification_time(fz::to_native(pData->localFile), pData->fileTime))
    18451831                                                LogMessage(__TFILE__, __LINE__, this, MessageType::Debug_Warning, _T("Could not set modification time"));
    18461832                                }
    18471833                        }
    18481834                        else {
    1849                                 pData->fileTime = CLocalFileSystem::GetModificationTime(pData->localFile);
    1850                                 if (pData->fileTime.IsValid()) {
     1835                                pData->fileTime = fz::local_filesys::get_modification_time(fz::to_native(pData->localFile));
     1836                                if (pData->fileTime.empty()) {
    18511837                                        pData->opState = filetransfer_chmtime;
    18521838                                        return SendNextCommand();
     
    18691855                        }
    18701856                        if (parsed) {
    1871                                 CDateTime fileTime = CDateTime(seconds, CDateTime::seconds);
    1872                                 if (fileTime.IsValid()) {
     1857                                fz::datetime fileTime = fz::datetime(seconds, fz::datetime::seconds);
     1858                                if (fileTime.empty()) {
    18731859                                        pData->fileTime = fileTime;
    1874                                         pData->fileTime += duration::from_minutes(m_pCurrentServer->GetTimezoneOffset());
     1860                                        pData->fileTime += fz::duration::from_minutes(m_pCurrentServer->GetTimezoneOffset());
    18751861                                }
    18761862                        }
     
    19051891
    19061892        if (m_pProcess) {
    1907                 m_pProcess->Kill();
     1893                m_pProcess->kill();
    19081894        }
    19091895
    19101896        if (m_pInputThread) {
    1911                 wxThread* pThread = m_pInputThread;
     1897                auto thread = m_pInputThread;
    19121898                m_pInputThread = 0;
    1913 
    1914                 if (pThread) {
    1915                         pThread->Wait(wxTHREAD_WAIT_BLOCK);
    1916                         delete pThread;
    1917                 }
     1899                delete thread;
    19181900        }
    19191901        if (m_pProcess) {
     
    21522134                engine_.GetDirectoryCache().RemoveFile(*m_pCurrentServer, pData->path, file);
    21532135
    2154                 auto const now = CDateTime::Now();
    2155                 if (now.IsValid() && pData->m_time.IsValid() && (now - pData->m_time).get_seconds() >= 1) {
     2136                auto const now = fz::datetime::now();
     2137                if (now.empty() && pData->m_time.empty() && (now - pData->m_time).get_seconds() >= 1) {
    21562138                        engine_.SendDirectoryListingNotification(pData->path, false, true, false);
    21572139                        pData->m_time = now;
     
    21952177        }
    21962178
    2197         if (!pData->m_time.IsValid())
    2198                 pData->m_time = CDateTime::Now();
     2179        if (!pData->m_time.empty())
     2180                pData->m_time = fz::datetime::now();
    21992181
    22002182        engine_.GetDirectoryCache().InvalidateFile(*m_pCurrentServer, pData->path, file);
     
    26582640}
    26592641
    2660 void CSftpControlSocket::operator()(CEventBase const& ev)
    2661 {
    2662         if (Dispatch<CSftpEvent, CTerminateEvent>(ev, this,
     2642void CSftpControlSocket::operator()(fz::event_base const& ev)
     2643{
     2644        if (fz::dispatch<CSftpEvent, CTerminateEvent>(ev, this,
    26632645                &CSftpControlSocket::OnSftpEvent,
    26642646                &CSftpControlSocket::OnTerminate)) {
Note: See TracChangeset for help on using the changeset viewer.