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/ftpcontrolsocket.cpp

    r130 r3185  
    55#include "engineprivate.h"
    66#include "externalipresolver.h"
    7 #include "file.h"
    87#include "ftpcontrolsocket.h"
    98#include "iothread.h"
     
    1211#include "tlssocket.h"
    1312#include "transfersocket.h"
    14 #include "local_filesys.h"
    1513#include "proxy.h"
     14
     15#include <libfilezilla/file.hpp>
     16#include <libfilezilla/iputils.hpp>
     17#include <libfilezilla/local_filesys.hpp>
     18#include <libfilezilla/util.hpp>
    1619
    1720#include <wx/filename.h>
     
    155158        bool omitPath{};
    156159
    157         // Set to CDateTime::Now initially and after
     160        // Set to fz::datetime::Now initially and after
    158161        // sending an updated listing to the UI.
    159         CDateTime m_time;
     162        fz::datetime m_time;
    160163
    161164        bool m_needSendListing{};
     
    190193CFtpControlSocket::~CFtpControlSocket()
    191194{
    192         RemoveHandler();
     195        remove_handler();
    193196        m_pSocket->SetSynchronousReadCallback(0);
    194197
     
    904907
    905908                if (pData->opState == LOGON_DONE) {
    906                         LogMessage(MessageType::Status, _("Connected"));
     909                        LogMessage(MessageType::Status, _("Logged in"));
    907910                        ResetOperation(FZ_REPLY_OK);
    908911                        LogMessage(MessageType::Debug_Info, _T("Measured latency of %d ms"), m_rtt.GetLatency());
     
    963966                        capabilities cap = CServerCapabilities::GetCapability(*GetCurrentServer(), opst_mlst_command);
    964967                        if (cap == unknown) {
    965                                 MakeLowerAscii(facts);
     968                                facts = fz::str_tolower_ascii(facts);
    966969
    967970                                bool had_unset = false;
     
    12421245        int mdtm_index;
    12431246
    1244         CMonotonicClock m_time_before_locking;
     1247        fz::monotonic_clock m_time_before_locking;
    12451248};
    12461249
     
    13561359                        if (!TryLockCache(lock_list, m_CurrentPath)) {
    13571360                                pData->opState = list_waitlock;
    1358                                 pData->m_time_before_locking = CMonotonicClock::now();
     1361                                pData->m_time_before_locking = fz::monotonic_clock::now();
    13591362                                return FZ_REPLY_WOULDBLOCK;
    13601363                        }
     
    14461449                                CDirectoryListing listing;
    14471450                                listing.path = m_CurrentPath;
    1448                                 listing.m_firstListTime = CMonotonicClock::now();
     1451                                listing.m_firstListTime = fz::monotonic_clock::now();
    14491452
    14501453                                if (pData->viewHiddenCheck) {
     
    16031606                m_Response.Left(4) == _T("213 ") && m_Response.Length() > 16)
    16041607        {
    1605                 CDateTime date(m_Response.Mid(4), CDateTime::utc);
    1606                 if (date.IsValid()) {
     1608                fz::datetime date(m_Response.Mid(4).ToStdWstring(), fz::datetime::utc);
     1609                if (date.empty()) {
    16071610                        wxASSERT(pData->directoryListing[pData->mdtm_index].has_date());
    1608                         CDateTime listTime = pData->directoryListing[pData->mdtm_index].time;
    1609                         listTime -= duration::from_minutes(m_pCurrentServer->GetTimezoneOffset());
     1611                        fz::datetime listTime = pData->directoryListing[pData->mdtm_index].time;
     1612                        listTime -= fz::duration::from_minutes(m_pCurrentServer->GetTimezoneOffset());
    16101613
    16111614                        int serveroffset = static_cast<int>((date - listTime).get_seconds());
     
    16191622                        LogMessage(MessageType::Status, _("Timezone offset of server is %d seconds."), -serveroffset);
    16201623
    1621                         duration span = duration::from_seconds(serveroffset);
     1624                        fz::duration span = fz::duration::from_seconds(serveroffset);
    16221625                        const int count = pData->directoryListing.GetCount();
    16231626                        for (int i = 0; i < count; ++i) {
     
    17021705                        int64_t size;
    17031706                        bool isLink;
    1704                         if (CLocalFileSystem::GetFileInfo(pData->localFile, isLink, &size, 0, 0) == CLocalFileSystem::file && size == 0) {
     1707                        if (fz::local_filesys::get_file_info(fz::to_native(pData->localFile), isLink, &size, 0, 0) == fz::local_filesys::file && size == 0) {
    17051708                                // Download failed and a new local file was created before, but
    17061709                                // nothing has been written to it. Remove it again, so we don't
     
    17321735        }
    17331736
    1734         m_lastCommandCompletionTime = CMonotonicClock::now();
     1737        m_lastCommandCompletionTime = fz::monotonic_clock::now();
    17351738        if (m_pCurOpData && !(nErrorCode & FZ_REPLY_DISCONNECTED))
    17361739                StartKeepaliveTimer();
    17371740        else {
    1738                 StopTimer(m_idleTimer);
     1741                stop_timer(m_idleTimer);
    17391742                m_idleTimer = 0;
    17401743        }
     
    21612164        int64_t size;
    21622165        bool isLink;
    2163         if (CLocalFileSystem::GetFileInfo(pData->localFile, isLink, &size, 0, 0) == CLocalFileSystem::file)
     2166        if (fz::local_filesys::get_file_info(fz::to_native(pData->localFile), isLink, &size, 0, 0) == fz::local_filesys::file)
    21642167                pData->localFileSize = size;
    21652168
     
    22422245                pData->opState = filetransfer_resumetest;
    22432246                if (m_Response.Left(4) == _T("213 ") && m_Response.Length() > 16) {
    2244                         pData->fileTime = CDateTime(m_Response.Mid(4), CDateTime::utc);
    2245                         if (pData->fileTime.IsValid()) {
    2246                                 pData->fileTime += duration::from_minutes(m_pCurrentServer->GetTimezoneOffset());
     2247                        pData->fileTime = fz::datetime(m_Response.Mid(4).ToStdWstring(), fz::datetime::utc);
     2248                        if (pData->fileTime.empty()) {
     2249                                pData->fileTime += fz::duration::from_minutes(m_pCurrentServer->GetTimezoneOffset());
    22472250                        }
    22482251                }
     
    23962399                                CServerCapabilities::GetCapability(*m_pCurrentServer, mfmt_command) == yes)
    23972400                        {
    2398                                 CDateTime mtime = CLocalFileSystem::GetModificationTime(pData->localFile);
    2399                                 if (mtime.IsValid()) {
     2401                                fz::datetime mtime = fz::local_filesys::get_modification_time(fz::to_native(pData->localFile));
     2402                                if (mtime.empty()) {
    24002403                                        pData->fileTime = mtime;
    24012404                                        pData->opState = filetransfer_mfmt;
     
    24032406                                }
    24042407                        }
    2405                         else if (pData->download && pData->fileTime.IsValid()) {
     2408                        else if (pData->download && pData->fileTime.empty()) {
    24062409                                delete pData->pIOThread;
    24072410                                pData->pIOThread = 0;
    2408                                 if (!CLocalFileSystem::SetModificationTime(pData->localFile, pData->fileTime))
     2411                                if (!fz::local_filesys::set_modification_time(fz::to_native(pData->localFile), pData->fileTime))
    24092412                                        LogMessage(__TFILE__, __LINE__, this, MessageType::Debug_Warning, _T("Could not set modification time"));
    24102413                        }
     
    24762479
    24772480                {
    2478                         auto pFile = std::make_unique<CFile>();
     2481                        auto pFile = std::make_unique<fz::file>();
    24792482                        if (pData->download) {
    24802483                                // Be quiet
     
    24872490
    24882491                                if (pData->resume) {
    2489                                         if (!pFile->Open(pData->localFile, CFile::write, CFile::existing)) {
     2492                                        if (!pFile->open(fz::to_native(pData->localFile), fz::file::writing, fz::file::existing)) {
    24902493                                                LogMessage(MessageType::Error, _("Failed to open \"%s\" for appending/writing"), pData->localFile);
    24912494                                                ResetOperation(FZ_REPLY_ERROR);
     
    24952498                                        pData->fileDidExist = didExist;
    24962499
    2497                                         startOffset = pFile->Seek(0, CFile::end);
     2500                                        startOffset = pFile->seek(0, fz::file::end);
    24982501
    24992502                                        if (startOffset == wxInvalidOffset) {
     
    25192522                                        CreateLocalDir(pData->localFile);
    25202523
    2521                                         if (!pFile->Open(pData->localFile, CFile::write, CFile::truncate)) {
     2524                                        if (!pFile->open(fz::to_native(pData->localFile), fz::file::writing, fz::file::empty)) {
    25222525                                                LogMessage(MessageType::Error, _("Failed to open \"%s\" for writing"), pData->localFile);
    25232526                                                ResetOperation(FZ_REPLY_ERROR);
     
    25382541                                if (engine_.GetOptions().GetOptionVal(OPTION_PREALLOCATE_SPACE)) {
    25392542                                        // Try to preallocate the file in order to reduce fragmentation
    2540                                         wxFileOffset sizeToPreallocate = pData->remoteFileSize - startOffset;
     2543                                        int64_t sizeToPreallocate = pData->remoteFileSize - startOffset;
    25412544                                        if (sizeToPreallocate > 0) {
    25422545                                                LogMessage(MessageType::Debug_Info, _T("Preallocating %") + wxString(wxFileOffsetFmtSpec) + _T("d bytes for the file \"%s\""), sizeToPreallocate, pData->localFile);
    2543                                                 wxFileOffset oldPos = pFile->Seek(0, CFile::current);
     2546                                                auto oldPos = pFile->seek(0, fz::file::current);
    25442547                                                if (oldPos >= 0) {
    2545                                                         if (pFile->Seek(sizeToPreallocate, CFile::end) == pData->remoteFileSize) {
    2546                                                                 if (!pFile->Truncate())
     2548                                                        if (pFile->seek(sizeToPreallocate, fz::file::end) == pData->remoteFileSize) {
     2549                                                                if (!pFile->truncate())
    25472550                                                                        LogMessage(MessageType::Debug_Warning, _T("Could not preallocate the file"));
    25482551                                                        }
    2549                                                         pFile->Seek(oldPos, CFile::begin);
     2552                                                        pFile->seek(oldPos, fz::file::begin);
    25502553                                                }
    25512554                                        }
     
    25532556                        }
    25542557                        else {
    2555                                 if (!pFile->Open(pData->localFile, CFile::read)) {
     2558                                if (!pFile->open(fz::to_native(pData->localFile), fz::file::reading)) {
    25562559                                        LogMessage(MessageType::Error, _("Failed to open \"%s\" for reading"), pData->localFile);
    25572560                                        ResetOperation(FZ_REPLY_ERROR);
     
    25642567                                                startOffset = pData->remoteFileSize;
    25652568
    2566                                                 if (pData->localFileSize < 0)
    2567                                                         pData->localFileSize = pFile->Length();
     2569                                                if (pData->localFileSize < 0) {
     2570                                                        auto s = pFile->size();
     2571                                                        if (s >= 0) {
     2572                                                                pData->localFileSize = s;
     2573                                                        }
     2574                                                }
    25682575
    25692576                                                if (startOffset == pData->localFileSize && pData->binary) {
     
    25732580                                                                CServerCapabilities::GetCapability(*m_pCurrentServer, mfmt_command) == yes)
    25742581                                                        {
    2575                                                                 CDateTime mtime = CLocalFileSystem::GetModificationTime(pData->localFile);
    2576                                                                 if (mtime.IsValid()) {
     2582                                                                fz::datetime mtime = fz::local_filesys::get_modification_time(fz::to_native(pData->localFile));
     2583                                                                if (mtime.empty()) {
    25772584                                                                        pData->fileTime = mtime;
    25782585                                                                        pData->opState = filetransfer_mfmt;
     
    25852592
    25862593                                                // Assume native 64 bit type exists
    2587                                                 if (pFile->Seek(startOffset, CFile::begin) == wxInvalidOffset) {
     2594                                                if (pFile->seek(startOffset, fz::file::begin) == wxInvalidOffset) {
    25882595                                                        wxString const s = std::to_wstring(startOffset);
    25892596                                                        LogMessage(MessageType::Error, _("Could not seek to offset %s within file"), s);
     
    26072614                                }
    26082615
    2609                                 wxFileOffset len = pFile->Length();
     2616                                auto len = pFile->size();
    26102617                                engine_.transfer_status_.Init(len, startOffset, false);
    26112618                        }
     
    26442651                {
    26452652                        cmd = _T("MFMT ");
    2646                         cmd += pData->fileTime.Format(_T("%Y%m%d%H%M%S "), CDateTime::utc);
     2653                        cmd += pData->fileTime.format(_T("%Y%m%d%H%M%S "), fz::datetime::utc);
    26472654                        cmd += pData->remotePath.FormatFilename(pData->remoteFile, !pData->tryAbsolutePath);
    26482655
     
    27432750                                        int64_t size;
    27442751                                        bool isLink;
    2745                                         if (CLocalFileSystem::GetFileInfo(pData->localFile, isLink, &size, 0, 0) == CLocalFileSystem::file)
     2752                                        if (fz::local_filesys::get_file_info(fz::to_native(pData->localFile), isLink, &size, 0, 0) == fz::local_filesys::file)
    27462753                                                pData->localFileSize = size;
    27472754                                        else
     
    27542761                                        pData->remoteFile = pFileExistsNotification->newName;
    27552762                                        pData->remoteFileSize = -1;
    2756                                         pData->fileTime = CDateTime();
     2763                                        pData->fileTime = fz::datetime();
    27572764
    27582765                                        CDirentry entry;
     
    29712978        }
    29722979
    2973         if (!pData->m_time.IsValid())
    2974                 pData->m_time = CDateTime::Now();
     2980        if (!pData->m_time.empty())
     2981                pData->m_time = fz::datetime::now();
    29752982
    29762983        engine_.GetDirectoryCache().InvalidateFile(*m_pCurrentServer, pData->path, file);
     
    30023009                engine_.GetDirectoryCache().RemoveFile(*m_pCurrentServer, pData->path, file);
    30033010
    3004                 CDateTime now = CDateTime::Now();
    3005                 if (now.IsValid() && pData->m_time.IsValid() && (now - pData->m_time).get_seconds() >= 1) {
     3011                fz::datetime now = fz::datetime::now();
     3012                if (now.empty() && pData->m_time.empty() && (now - pData->m_time).get_seconds() >= 1) {
    30063013                        engine_.SendDirectoryListingNotification(pData->path, false, true, false);
    30073014                        pData->m_time = now;
     
    37043711
    37053712        const wxString peerIP = m_pSocket->GetPeerIP();
    3706         if (!IsRoutableAddress(pData->host, m_pSocket->GetAddressFamily()) && IsRoutableAddress(peerIP, m_pSocket->GetAddressFamily())) {
     3713        if (!fz::is_routable_address(pData->host.ToStdWstring()) && fz::is_routable_address(peerIP.ToStdWstring())) {
    37073714                if (engine_.GetOptions().GetOptionVal(OPTION_PASVREPLYFALLBACKMODE) != 1 || pData->bTriedActive) {
    37083715                        LogMessage(MessageType::Status, _("Server sent passive reply with unroutable address. Using server address instead."));
     
    37353742                {
    37363743                        if (engine_.GetOptions().GetOptionVal(OPTION_NOEXTERNALONLOCAL) &&
    3737                                 !IsRoutableAddress(m_pSocket->GetPeerIP(), m_pSocket->GetAddressFamily()))
     3744                                !fz::is_routable_address(m_pSocket->GetPeerIP().ToStdWstring()))
    37383745                                // Skip next block, use local address
    37393746                                goto getLocalIP;
     
    39473954                break;
    39483955        case rawtransfer_transfer:
    3949                 if (code != 1) {
     3956                if (code == 1) {
     3957                        pData->opState = rawtransfer_waitfinish;
     3958                }
     3959                else if (code == 2 || code == 3) {
     3960                        // A few broken servers omit the 1yz reply.
     3961                        pData->opState = rawtransfer_waitsocket;
     3962                }
     3963                else {
    39503964                        if (pData->pOldData->transferEndReason == TransferEndReason::successful)
    39513965                                pData->pOldData->transferEndReason = TransferEndReason::transfer_command_failure_immediate;
    39523966                        error = true;
    39533967                }
    3954                 else
    3955                         pData->opState = rawtransfer_waitfinish;
    39563968                break;
    39573969        case rawtransfer_waittransferpre:
    3958                 if (code != 1) {
     3970                if (code == 1) {
     3971                        pData->opState = rawtransfer_waittransfer;
     3972                }
     3973                else if (code == 2 || code == 3) {
     3974                        // A few broken servers omit the 1yz reply.
     3975                        if (pData->pOldData->transferEndReason != TransferEndReason::successful) {
     3976                                error = true;
     3977                                break;
     3978                        }
     3979
     3980                        ResetOperation(FZ_REPLY_OK);
     3981                        return FZ_REPLY_OK;
     3982                }
     3983                else {
    39593984                        if (pData->pOldData->transferEndReason == TransferEndReason::successful)
    39603985                                pData->pOldData->transferEndReason = TransferEndReason::transfer_command_failure_immediate;
    39613986                        error = true;
    39623987                }
    3963                 else
    3964                         pData->opState = rawtransfer_waittransfer;
    39653988                break;
    39663989        case rawtransfer_waitfinish:
     
    39794002                        error = true;
    39804003                }
    3981                 else
    3982                 {
    3983                         if (pData->pOldData->transferEndReason != TransferEndReason::successful)
    3984                         {
     4004                else {
     4005                        if (pData->pOldData->transferEndReason != TransferEndReason::successful) {
    39854006                                error = true;
    39864007                                break;
     
    42714292                return false;
    42724293
    4273         std::vector<fzstring> names1, names2;
     4294        std::vector<std::wstring> names1, names2;
    42744295        listing1.GetFilenames(names1);
    42754296        listing2.GetFilenames(names2);
     
    42774298        std::sort(names2.begin(), names2.end());
    42784299
    4279         std::vector<fzstring>::const_iterator iter1, iter2;
     4300        std::vector<std::wstring>::const_iterator iter1, iter2;
    42804301        iter1 = names1.cbegin();
    42814302        iter2 = names2.cbegin();
     
    42964317}
    42974318
    4298 void CFtpControlSocket::OnTimer(timer_id id)
     4319void CFtpControlSocket::OnTimer(fz::timer_id id)
    42994320{
    43004321        if (id != m_idleTimer) {
     
    43124333
    43134334        wxString cmd;
    4314         int i = GetRandomNumber(0, 2);
     4335        int i = fz::random_number(0, 2);
    43154336        if (!i)
    43164337                cmd = _T("NOOP");
     
    43414362                return;
    43424363
    4343         duration const span = CMonotonicClock::now() - m_lastCommandCompletionTime;
     4364        fz::duration const span = fz::monotonic_clock::now() - m_lastCommandCompletionTime;
    43444365        if (span.get_minutes() >= 30) {
    43454366                return;
    43464367        }
    43474368
    4348         StopTimer(m_idleTimer);
    4349         m_idleTimer = AddTimer(duration::from_seconds(30), true);
     4369        stop_timer(m_idleTimer);
     4370        m_idleTimer = add_timer(fz::duration::from_seconds(30), true);
    43504371}
    43514372
     
    43854406}
    43864407
    4387 void CFtpControlSocket::operator()(CEventBase const& ev)
    4388 {
    4389         if (Dispatch<CTimerEvent>(ev, this, &CFtpControlSocket::OnTimer)) {
     4408void CFtpControlSocket::operator()(fz::event_base const& ev)
     4409{
     4410        if (fz::dispatch<fz::timer_event>(ev, this, &CFtpControlSocket::OnTimer)) {
    43904411                return;
    43914412        }
    43924413
    4393         if (Dispatch<CExternalIPResolveEvent>(ev, this, &CFtpControlSocket::OnExternalIPAddress)) {
     4414        if (fz::dispatch<CExternalIPResolveEvent>(ev, this, &CFtpControlSocket::OnExternalIPAddress)) {
    43944415                return;
    43954416        }
     
    44164437                ret = _T("EPSV");
    44174438        }
    4418 
    44194439        return ret;
    44204440}
Note: See TracChangeset for help on using the changeset viewer.