LCOV - code coverage report
Current view: top level - port - cpl_vsil_curl_class.h (source / functions) Hit Total Coverage
Test: gdal_filtered.info Lines: 127 161 78.9 %
Date: 2025-10-22 13:51:22 Functions: 55 71 77.5 %

          Line data    Source code
       1             : /******************************************************************************
       2             :  *
       3             :  * Project:  CPL - Common Portability Library
       4             :  * Purpose:  Declarations for /vsicurl/ and related file systems
       5             :  * Author:   Even Rouault, even.rouault at spatialys.com
       6             :  *
       7             :  ******************************************************************************
       8             :  * Copyright (c) 2010-2018, Even Rouault <even.rouault at spatialys.com>
       9             :  *
      10             :  * SPDX-License-Identifier: MIT
      11             :  ****************************************************************************/
      12             : 
      13             : #ifndef CPL_VSIL_CURL_CLASS_H_INCLUDED
      14             : #define CPL_VSIL_CURL_CLASS_H_INCLUDED
      15             : 
      16             : #ifdef HAVE_CURL
      17             : 
      18             : #include "cpl_aws.h"
      19             : #include "cpl_azure.h"
      20             : #include "cpl_port.h"
      21             : #include "cpl_json.h"
      22             : #include "cpl_http.h"
      23             : #include "cpl_string.h"
      24             : #include "cpl_vsil_curl_priv.h"
      25             : #include "cpl_mem_cache.h"
      26             : #include "cpl_multiproc.h"
      27             : 
      28             : #include "cpl_curl_priv.h"
      29             : 
      30             : #include <algorithm>
      31             : #include <atomic>
      32             : #include <condition_variable>
      33             : #include <set>
      34             : #include <map>
      35             : #include <memory>
      36             : #include <mutex>
      37             : #include <thread>
      38             : #include <utility>
      39             : 
      40             : // To avoid aliasing to CopyFile to CopyFileA on Windows
      41             : #ifdef CopyFile
      42             : #undef CopyFile
      43             : #endif
      44             : 
      45             : //! @cond Doxygen_Suppress
      46             : 
      47             : // Leave it for backward compatibility, but deprecate.
      48             : #define HAVE_CURLINFO_REDIRECT_URL
      49             : 
      50             : void VSICurlStreamingClearCache(void);  // from cpl_vsil_curl_streaming.cpp
      51             : 
      52             : struct curl_slist *VSICurlSetOptions(CURL *hCurlHandle, const char *pszURL,
      53             :                                      const char *const *papszOptions);
      54             : 
      55             : struct curl_slist *VSICurlSetContentTypeFromExt(struct curl_slist *polist,
      56             :                                                 const char *pszPath);
      57             : 
      58             : struct curl_slist *VSICurlSetCreationHeadersFromOptions(
      59             :     struct curl_slist *headers, CSLConstList papszOptions, const char *pszPath);
      60             : 
      61             : namespace cpl
      62             : {
      63             : 
      64             : typedef enum
      65             : {
      66             :     EXIST_UNKNOWN = -1,
      67             :     EXIST_NO,
      68             :     EXIST_YES,
      69             : } ExistStatus;
      70             : 
      71             : class FileProp
      72             : {
      73             :   public:
      74             :     unsigned int nGenerationAuthParameters = 0;
      75             :     ExistStatus eExists = EXIST_UNKNOWN;
      76             :     int nHTTPCode = 0;
      77             :     vsi_l_offset fileSize = 0;
      78             :     time_t mTime = 0;
      79             :     time_t nExpireTimestampLocal = 0;
      80             :     std::string osRedirectURL{};
      81             :     bool bHasComputedFileSize = false;
      82             :     bool bIsDirectory = false;
      83             :     bool bIsAzureFolder = false;
      84             :     int nMode = 0;  // st_mode member of struct stat
      85             :     bool bS3LikeRedirect = false;
      86             :     std::string ETag{};
      87             : };
      88             : 
      89             : struct CachedDirList
      90             : {
      91             :     bool bGotFileList = false;
      92             :     unsigned int nGenerationAuthParameters = 0;
      93             :     CPLStringList oFileList{}; /* only file name without path */
      94             : };
      95             : 
      96             : struct WriteFuncStruct
      97             : {
      98             :     char *pBuffer = nullptr;
      99             :     size_t nSize = 0;
     100             :     bool bIsHTTP = false;
     101             :     bool bMultiRange = false;
     102             :     vsi_l_offset nStartOffset = 0;
     103             :     vsi_l_offset nEndOffset = 0;
     104             :     int nHTTPCode = 0;       // potentially after redirect
     105             :     int nFirstHTTPCode = 0;  // the one of the redirect
     106             :     vsi_l_offset nContentLength = 0;
     107             :     bool bFoundContentRange = false;
     108             :     bool bError = false;
     109             :     bool bInterruptDownload = false;
     110             :     bool bDetectRangeDownloadingError = false;
     111             :     GIntBig nTimestampDate = 0;  // Corresponds to Date: header field
     112             : 
     113             :     VSILFILE *fp = nullptr;
     114             :     VSICurlReadCbkFunc pfnReadCbk = nullptr;
     115             :     void *pReadCbkUserData = nullptr;
     116             :     bool bInterrupted = false;
     117             : };
     118             : 
     119             : struct PutData
     120             : {
     121             :     const GByte *pabyData = nullptr;
     122             :     size_t nOff = 0;
     123             :     size_t nTotalSize = 0;
     124             : 
     125          35 :     static size_t ReadCallBackBuffer(char *buffer, size_t size, size_t nitems,
     126             :                                      void *instream)
     127             :     {
     128          35 :         PutData *poThis = static_cast<PutData *>(instream);
     129          35 :         const size_t nSizeMax = size * nitems;
     130             :         const size_t nSizeToWrite =
     131          35 :             std::min(nSizeMax, poThis->nTotalSize - poThis->nOff);
     132          35 :         memcpy(buffer, poThis->pabyData + poThis->nOff, nSizeToWrite);
     133          35 :         poThis->nOff += nSizeToWrite;
     134          35 :         return nSizeToWrite;
     135             :     }
     136             : };
     137             : 
     138             : /************************************************************************/
     139             : /*                     VSICurlFilesystemHandler                         */
     140             : /************************************************************************/
     141             : 
     142             : class VSICurlHandle;
     143             : 
     144             : class VSICurlFilesystemHandlerBase : public VSIFilesystemHandler
     145             : {
     146             :     CPL_DISALLOW_COPY_ASSIGN(VSICurlFilesystemHandlerBase)
     147             : 
     148             :     struct FilenameOffsetPair
     149             :     {
     150             :         std::string filename_;
     151             :         vsi_l_offset offset_;
     152             : 
     153       46680 :         FilenameOffsetPair(const std::string &filename, vsi_l_offset offset)
     154       46680 :             : filename_(filename), offset_(offset)
     155             :         {
     156       46680 :         }
     157             : 
     158       45834 :         bool operator==(const FilenameOffsetPair &other) const
     159             :         {
     160       45834 :             return filename_ == other.filename_ && offset_ == other.offset_;
     161             :         }
     162             :     };
     163             : 
     164             :     struct FilenameOffsetPairHasher
     165             :     {
     166       47325 :         std::size_t operator()(const FilenameOffsetPair &k) const
     167             :         {
     168       47325 :             return std::hash<std::string>()(k.filename_) ^
     169       47325 :                    std::hash<vsi_l_offset>()(k.offset_);
     170             :         }
     171             :     };
     172             : 
     173             :     using RegionCacheType = lru11::Cache<
     174             :         FilenameOffsetPair, std::shared_ptr<std::string>, lru11::NullLock,
     175             :         std::unordered_map<
     176             :             FilenameOffsetPair,
     177             :             typename std::list<lru11::KeyValuePair<
     178             :                 FilenameOffsetPair, std::shared_ptr<std::string>>>::iterator,
     179             :             FilenameOffsetPairHasher>>;
     180             : 
     181             :     std::unique_ptr<RegionCacheType>
     182             :         m_poRegionCacheDoNotUseDirectly{};  // do not access directly. Use
     183             :                                             // GetRegionCache();
     184             :     RegionCacheType *GetRegionCache();
     185             : 
     186             :     // LRU cache that just keeps in memory if this file system handler is
     187             :     // spposed to know the file properties of a file. The actual cache is a
     188             :     // shared one among all network file systems.
     189             :     // The aim of that design is that invalidating /vsis3/foo results in
     190             :     // /vsis3_streaming/foo to be invalidated as well.
     191             :     lru11::Cache<std::string, bool> oCacheFileProp;
     192             : 
     193             :     int nCachedFilesInDirList = 0;
     194             :     lru11::Cache<std::string, CachedDirList> oCacheDirList;
     195             : 
     196             :     char **ParseHTMLFileList(const char *pszFilename, int nMaxFiles,
     197             :                              char *pszData, bool *pbGotFileList);
     198             : 
     199             :     // Data structure and map to store regions that are in progress, to
     200             :     // avoid simultaneous downloads of the same region in different threads
     201             :     // Cf https://github.com/OSGeo/gdal/issues/8041
     202             :     struct RegionInDownload
     203             :     {
     204             :         std::mutex oMutex{};
     205             :         std::condition_variable oCond{};
     206             :         bool bDownloadInProgress = false;
     207             :         int nWaiters = 0;
     208             :         std::string osData{};
     209             :     };
     210             : 
     211             :     std::mutex m_oMutex{};
     212             :     std::map<std::string, std::unique_ptr<RegionInDownload>>
     213             :         m_oMapRegionInDownload{};
     214             : 
     215             :   protected:
     216             :     CPLMutex *hMutex = nullptr;
     217             : 
     218             :     virtual VSICurlHandle *CreateFileHandle(const char *pszFilename);
     219             :     virtual char **GetFileList(const char *pszFilename, int nMaxFiles,
     220             :                                bool *pbGotFileList);
     221             : 
     222             :     void RegisterEmptyDir(const std::string &osDirname);
     223             : 
     224             :     bool
     225             :     AnalyseS3FileList(const std::string &osBaseURL, const char *pszXML,
     226             :                       CPLStringList &osFileList, int nMaxFiles,
     227             :                       const std::set<std::string> &oSetIgnoredStorageClasses,
     228             :                       bool &bIsTruncated);
     229             : 
     230             :     void AnalyseSwiftFileList(const std::string &osBaseURL,
     231             :                               const std::string &osPrefix, const char *pszJson,
     232             :                               CPLStringList &osFileList, int nMaxFilesThisQuery,
     233             :                               int nMaxFiles, bool &bIsTruncated,
     234             :                               std::string &osNextMarker);
     235             : 
     236             :     static const char *GetOptionsStatic();
     237             : 
     238             :     VSICurlFilesystemHandlerBase();
     239             : 
     240             :   public:
     241             :     ~VSICurlFilesystemHandlerBase() override;
     242             : 
     243             :     static bool IsAllowedFilename(const char *pszFilename);
     244             : 
     245             :     VSIVirtualHandleUniquePtr Open(const char *pszFilename,
     246             :                                    const char *pszAccess, bool bSetError,
     247             :                                    CSLConstList /* papszOptions */) override;
     248             : 
     249             :     int Stat(const char *pszFilename, VSIStatBufL *pStatBuf,
     250             :              int nFlags) override;
     251             :     char **ReadDirEx(const char *pszDirname, int nMaxFiles) override;
     252             :     char **SiblingFiles(const char *pszFilename) override;
     253             : 
     254          18 :     int HasOptimizedReadMultiRange(const char * /* pszPath */) override
     255             :     {
     256          18 :         return true;
     257             :     }
     258             : 
     259             :     const char *GetActualURL(const char *pszFilename) override;
     260             : 
     261             :     const char *GetOptions() override;
     262             : 
     263             :     char **GetFileMetadata(const char *pszFilename, const char *pszDomain,
     264             :                            CSLConstList papszOptions) override;
     265             : 
     266             :     char **ReadDirInternal(const char *pszDirname, int nMaxFiles,
     267             :                            bool *pbGotFileList);
     268             :     void InvalidateDirContent(const std::string &osDirname);
     269             : 
     270             :     virtual const char *GetDebugKey() const = 0;
     271             : 
     272             :     virtual std::string GetFSPrefix() const = 0;
     273             :     virtual bool AllowCachedDataFor(const char *pszFilename);
     274             : 
     275           6 :     bool IsLocal(const char * /* pszPath */) const override
     276             :     {
     277           6 :         return false;
     278             :     }
     279             : 
     280             :     virtual bool
     281           2 :     SupportsSequentialWrite(const char * /* pszPath */,
     282             :                             bool /* bAllowLocalTempFile */) override
     283             :     {
     284           2 :         return false;
     285             :     }
     286             : 
     287           1 :     virtual bool SupportsRandomWrite(const char * /* pszPath */,
     288             :                                      bool /* bAllowLocalTempFile */) override
     289             :     {
     290           1 :         return false;
     291             :     }
     292             : 
     293             :     std::shared_ptr<std::string> GetRegion(const char *pszURL,
     294             :                                            vsi_l_offset nFileOffsetStart);
     295             : 
     296             :     void AddRegion(const char *pszURL, vsi_l_offset nFileOffsetStart,
     297             :                    size_t nSize, const char *pData);
     298             : 
     299             :     std::pair<bool, std::string>
     300             :     NotifyStartDownloadRegion(const std::string &osURL,
     301             :                               vsi_l_offset startOffset, int nBlocks);
     302             :     void NotifyStopDownloadRegion(const std::string &osURL,
     303             :                                   vsi_l_offset startOffset, int nBlocks,
     304             :                                   const std::string &osData);
     305             : 
     306             :     bool GetCachedFileProp(const char *pszURL, FileProp &oFileProp);
     307             :     void SetCachedFileProp(const char *pszURL, FileProp &oFileProp);
     308             :     void InvalidateCachedData(const char *pszURL);
     309             : 
     310             :     CURLM *GetCurlMultiHandleFor(const std::string &osURL);
     311             : 
     312             :     virtual void ClearCache();
     313             :     virtual void PartialClearCache(const char *pszFilename);
     314             : 
     315             :     bool GetCachedDirList(const char *pszURL, CachedDirList &oCachedDirList);
     316             :     void SetCachedDirList(const char *pszURL, CachedDirList &oCachedDirList);
     317             :     bool ExistsInCacheDirList(const std::string &osDirname, bool *pbIsDir);
     318             : 
     319             :     virtual std::string GetURLFromFilename(const std::string &osFilename) const;
     320             : 
     321             :     std::string
     322             :     GetStreamingFilename(const std::string &osFilename) const override = 0;
     323             : 
     324             :     static std::set<std::string> GetS3IgnoredStorageClasses();
     325             : };
     326             : 
     327             : class VSICurlFilesystemHandler final : public VSICurlFilesystemHandlerBase
     328             : {
     329             :     CPL_DISALLOW_COPY_ASSIGN(VSICurlFilesystemHandler)
     330             : 
     331             :   public:
     332        1768 :     VSICurlFilesystemHandler() = default;
     333             : 
     334         848 :     const char *GetDebugKey() const override
     335             :     {
     336         848 :         return "VSICURL";
     337             :     }
     338             : 
     339       47861 :     std::string GetFSPrefix() const override
     340             :     {
     341       47861 :         return "/vsicurl/";
     342             :     }
     343             : 
     344             :     std::string
     345             :     GetStreamingFilename(const std::string &osFilename) const override;
     346             : };
     347             : 
     348             : /************************************************************************/
     349             : /*                           VSICurlHandle                              */
     350             : /************************************************************************/
     351             : 
     352             : class VSICurlHandle /* non final*/ : public VSIVirtualHandle
     353             : {
     354             :     CPL_DISALLOW_COPY_ASSIGN(VSICurlHandle)
     355             : 
     356             :   protected:
     357             :     VSICurlFilesystemHandlerBase *poFS = nullptr;
     358             : 
     359             :     bool m_bCached = true;
     360             : 
     361             :     mutable FileProp oFileProp{};
     362             : 
     363             :     mutable std::mutex m_oMutex{};
     364             :     std::string m_osFilename{};  // e.g "/vsicurl/http://example.com/foo"
     365             :     char *m_pszURL = nullptr;    // e.g "http://example.com/foo"
     366             :     mutable std::string m_osQueryString{};  // e.g. an Azure SAS
     367             : 
     368             :     CPLStringList m_aosHTTPOptions{};
     369             :     CPLHTTPRetryParameters
     370             :         m_oRetryParameters;  // must be initialized in constructor
     371             : 
     372             :     vsi_l_offset lastDownloadedOffset = VSI_L_OFFSET_MAX;
     373             :     int nBlocksToDownload = 1;
     374             : 
     375             :     bool bStopOnInterruptUntilUninstall = false;
     376             :     bool bInterrupted = false;
     377             :     VSICurlReadCbkFunc pfnReadCbk = nullptr;
     378             :     void *pReadCbkUserData = nullptr;
     379             : 
     380             :     CPLStringList m_aosHeaders{};
     381             : 
     382             :     void DownloadRegionPostProcess(const vsi_l_offset startOffset,
     383             :                                    const int nBlocks, const char *pBuffer,
     384             :                                    size_t nSize);
     385             : 
     386             :   private:
     387             :     vsi_l_offset curOffset = 0;
     388             : 
     389             :     bool bEOF = false;
     390             :     bool bError = false;
     391             : 
     392             :     virtual std::string DownloadRegion(vsi_l_offset startOffset, int nBlocks);
     393             : 
     394             :     bool m_bUseHead = false;
     395             :     bool m_bUseRedirectURLIfNoQueryStringParams = false;
     396             : 
     397             :     mutable std::atomic<bool> m_bInterrupt = false;
     398             : 
     399             :     // Specific to Planetary Computer signing:
     400             :     // https://planetarycomputer.microsoft.com/docs/concepts/sas/
     401             :     mutable bool m_bPlanetaryComputerURLSigning = false;
     402             :     mutable std::string m_osPlanetaryComputerCollection{};
     403             :     void ManagePlanetaryComputerSigning() const;
     404             : 
     405             :     void UpdateQueryString() const;
     406             : 
     407             :     int ReadMultiRangeSingleGet(int nRanges, void **ppData,
     408             :                                 const vsi_l_offset *panOffsets,
     409             :                                 const size_t *panSizes);
     410             :     std::string GetRedirectURLIfValid(bool &bHasExpired,
     411             :                                       CPLStringList &aosHTTPOptions) const;
     412             : 
     413             :     void UpdateRedirectInfo(CURL *hCurlHandle,
     414             :                             const WriteFuncStruct &sWriteFuncHeaderData);
     415             : 
     416             :     // Used by AdviseRead()
     417             :     struct AdviseReadRange
     418             :     {
     419             :         bool bDone = false;
     420             :         bool bToRetry = true;
     421             :         double dfSleepDelay = 0.0;
     422             :         std::mutex oMutex{};
     423             :         std::condition_variable oCV{};
     424             :         vsi_l_offset nStartOffset = 0;
     425             :         size_t nSize = 0;
     426             :         std::vector<GByte> abyData{};
     427             :         CPLHTTPRetryContext retryContext;
     428             : 
     429           6 :         explicit AdviseReadRange(const CPLHTTPRetryParameters &oRetryParameters)
     430           6 :             : retryContext(oRetryParameters)
     431             :         {
     432           6 :         }
     433             : 
     434             :         AdviseReadRange(const AdviseReadRange &) = delete;
     435             :         AdviseReadRange &operator=(const AdviseReadRange &) = delete;
     436             :         AdviseReadRange(AdviseReadRange &&) = delete;
     437             :         AdviseReadRange &operator=(AdviseReadRange &&) = delete;
     438             :     };
     439             : 
     440             :     std::vector<std::unique_ptr<AdviseReadRange>> m_aoAdviseReadRanges{};
     441             :     std::thread m_oThreadAdviseRead{};
     442             :     CURLM *m_hCurlMultiHandleForAdviseRead = nullptr;
     443             : 
     444             :   protected:
     445         519 :     virtual struct curl_slist *GetCurlHeaders(const std::string & /*osVerb*/,
     446             :                                               struct curl_slist *psHeaders)
     447             :     {
     448         519 :         return psHeaders;
     449             :     }
     450             : 
     451         586 :     virtual bool AllowAutomaticRedirection()
     452             :     {
     453         586 :         return true;
     454             :     }
     455             : 
     456         125 :     virtual bool CanRestartOnError(const char *, const char *, bool)
     457             :     {
     458         125 :         return false;
     459             :     }
     460             : 
     461         705 :     virtual bool UseLimitRangeGetInsteadOfHead()
     462             :     {
     463         705 :         return false;
     464             :     }
     465             : 
     466         257 :     virtual bool IsDirectoryFromExists(const char * /*pszVerb*/,
     467             :                                        int /*response_code*/)
     468             :     {
     469         257 :         return false;
     470             :     }
     471             : 
     472         118 :     virtual void ProcessGetFileSizeResult(const char * /* pszContent */)
     473             :     {
     474         118 :     }
     475             : 
     476             :     void SetURL(const char *pszURL);
     477             : 
     478           0 :     virtual bool Authenticate(const char * /* pszFilename */)
     479             :     {
     480           0 :         return false;
     481             :     }
     482             : 
     483             :   public:
     484             :     VSICurlHandle(VSICurlFilesystemHandlerBase *poFS, const char *pszFilename,
     485             :                   const char *pszURLIn = nullptr);
     486             :     ~VSICurlHandle() override;
     487             : 
     488             :     int Seek(vsi_l_offset nOffset, int nWhence) override;
     489             :     vsi_l_offset Tell() override;
     490             :     size_t Read(void *pBuffer, size_t nSize, size_t nMemb) override;
     491             :     int ReadMultiRange(int nRanges, void **ppData,
     492             :                        const vsi_l_offset *panOffsets,
     493             :                        const size_t *panSizes) override;
     494             :     size_t Write(const void *pBuffer, size_t nSize, size_t nMemb) override;
     495             :     void ClearErr() override;
     496             :     int Eof() override;
     497             :     int Error() override;
     498             :     int Flush() override;
     499             :     int Close() override;
     500             : 
     501           0 :     void Interrupt() override
     502             :     {
     503           0 :         m_bInterrupt = true;
     504           0 :     }
     505             : 
     506          18 :     bool HasPRead() const override
     507             :     {
     508          18 :         return true;
     509             :     }
     510             : 
     511             :     size_t PRead(void *pBuffer, size_t nSize,
     512             :                  vsi_l_offset nOffset) const override;
     513             : 
     514             :     void AdviseRead(int nRanges, const vsi_l_offset *panOffsets,
     515             :                     const size_t *panSizes) override;
     516             : 
     517             :     size_t GetAdviseReadTotalBytesLimit() const override;
     518             : 
     519         585 :     bool IsKnownFileSize() const
     520             :     {
     521         585 :         return oFileProp.bHasComputedFileSize;
     522             :     }
     523             : 
     524             :     vsi_l_offset GetFileSizeOrHeaders(bool bSetError, bool bGetHeaders);
     525             : 
     526         939 :     virtual vsi_l_offset GetFileSize(bool bSetError)
     527             :     {
     528         939 :         return GetFileSizeOrHeaders(bSetError, false);
     529             :     }
     530             : 
     531             :     bool Exists(bool bSetError);
     532             : 
     533         716 :     bool IsDirectory() const
     534             :     {
     535         716 :         return oFileProp.bIsDirectory;
     536             :     }
     537             : 
     538         585 :     int GetMode() const
     539             :     {
     540         585 :         return oFileProp.nMode;
     541             :     }
     542             : 
     543         585 :     time_t GetMTime() const
     544             :     {
     545         585 :         return oFileProp.mTime;
     546             :     }
     547             : 
     548           4 :     const CPLStringList &GetHeaders()
     549             :     {
     550           4 :         return m_aosHeaders;
     551             :     }
     552             : 
     553             :     int InstallReadCbk(VSICurlReadCbkFunc pfnReadCbk, void *pfnUserData,
     554             :                        int bStopOnInterruptUntilUninstall);
     555             :     int UninstallReadCbk();
     556             : 
     557           5 :     const char *GetURL() const
     558             :     {
     559           5 :         return m_pszURL;
     560             :     }
     561             : 
     562             :     //! Whether caching of file content and metadata should persist after file closing
     563         415 :     void SetCache(bool bCache)
     564             :     {
     565         415 :         m_bCached = bCache;
     566         415 :     }
     567             : };
     568             : 
     569             : /************************************************************************/
     570             : /*                  VSICurlFilesystemHandlerBaseWritable                */
     571             : /************************************************************************/
     572             : 
     573             : class VSICurlFilesystemHandlerBaseWritable /* non final */
     574             :     : public VSICurlFilesystemHandlerBase
     575             : {
     576             :     CPL_DISALLOW_COPY_ASSIGN(VSICurlFilesystemHandlerBaseWritable)
     577             : 
     578             :   protected:
     579       12376 :     VSICurlFilesystemHandlerBaseWritable() = default;
     580             : 
     581             :     virtual VSIVirtualHandleUniquePtr
     582             :     CreateWriteHandle(const char *pszFilename, CSLConstList papszOptions) = 0;
     583             : 
     584             :   public:
     585             :     VSIVirtualHandleUniquePtr Open(const char *pszFilename,
     586             :                                    const char *pszAccess, bool bSetError,
     587             :                                    CSLConstList /* papszOptions */) override;
     588             : 
     589           1 :     bool SupportsSequentialWrite(const char * /* pszPath */,
     590             :                                  bool /* bAllowLocalTempFile */) override
     591             :     {
     592           1 :         return true;
     593             :     }
     594             : 
     595             :     bool SupportsRandomWrite(const char * /* pszPath */,
     596             :                              bool /* bAllowLocalTempFile */) override;
     597             : };
     598             : 
     599             : /************************************************************************/
     600             : /*                        IVSIS3LikeFSHandler                           */
     601             : /************************************************************************/
     602             : 
     603             : class IVSIS3LikeFSHandler /* non final */
     604             :     : public VSICurlFilesystemHandlerBaseWritable
     605             : {
     606             :     CPL_DISALLOW_COPY_ASSIGN(IVSIS3LikeFSHandler)
     607             : 
     608             :     virtual int MkdirInternal(const char *pszDirname, long nMode,
     609             :                               bool bDoStatCheck);
     610             : 
     611             :   protected:
     612             :     char **GetFileList(const char *pszFilename, int nMaxFiles,
     613             :                        bool *pbGotFileList) override;
     614             : 
     615             :     virtual IVSIS3LikeHandleHelper *CreateHandleHelper(const char *pszURI,
     616             :                                                        bool bAllowNoObject) = 0;
     617             : 
     618             :     virtual int CopyObject(const char *oldpath, const char *newpath,
     619             :                            CSLConstList papszMetadata);
     620             : 
     621             :     int RmdirRecursiveInternal(const char *pszDirname, int nBatchSize);
     622             : 
     623             :     virtual bool
     624           0 :     IsAllowedHeaderForObjectCreation(const char * /* pszHeaderName */)
     625             :     {
     626           0 :         return false;
     627             :     }
     628             : 
     629       10608 :     IVSIS3LikeFSHandler() = default;
     630             : 
     631             :   public:
     632             :     int Unlink(const char *pszFilename) override;
     633             :     int Mkdir(const char *pszDirname, long nMode) override;
     634             :     int Rmdir(const char *pszDirname) override;
     635             :     int Stat(const char *pszFilename, VSIStatBufL *pStatBuf,
     636             :              int nFlags) override;
     637             :     int Rename(const char *oldpath, const char *newpath, GDALProgressFunc,
     638             :                void *) override;
     639             : 
     640             :     virtual int CopyFile(const char *pszSource, const char *pszTarget,
     641             :                          VSILFILE *fpSource, vsi_l_offset nSourceSize,
     642             :                          const char *const *papszOptions,
     643             :                          GDALProgressFunc pProgressFunc,
     644             :                          void *pProgressData) override;
     645             : 
     646             :     virtual int DeleteObject(const char *pszFilename);
     647             : 
     648             :     virtual int *DeleteObjectBatch(CSLConstList papszFilesOrDirs);
     649             : 
     650             :     bool Sync(const char *pszSource, const char *pszTarget,
     651             :               const char *const *papszOptions, GDALProgressFunc pProgressFunc,
     652             :               void *pProgressData, char ***ppapszOutputs) override;
     653             : 
     654             :     VSIDIR *OpenDir(const char *pszPath, int nRecurseDepth,
     655             :                     const char *const *papszOptions) override;
     656             : };
     657             : 
     658             : /************************************************************************/
     659             : /*                 IVSIS3LikeFSHandlerWithMultipartUpload               */
     660             : /************************************************************************/
     661             : 
     662             : class IVSIS3LikeFSHandlerWithMultipartUpload /* non final */
     663             :     : public IVSIS3LikeFSHandler
     664             : {
     665             :     CPL_DISALLOW_COPY_ASSIGN(IVSIS3LikeFSHandlerWithMultipartUpload)
     666             : 
     667             :   protected:
     668        8840 :     IVSIS3LikeFSHandlerWithMultipartUpload() = default;
     669             : 
     670             :   public:
     671           5 :     virtual bool SupportsNonSequentialMultipartUpload() const
     672             :     {
     673           5 :         return true;
     674             :     }
     675             : 
     676          36 :     virtual bool SupportsParallelMultipartUpload() const
     677             :     {
     678          36 :         return true;
     679             :     }
     680             : 
     681             :     virtual bool SupportsMultipartAbort() const = 0;
     682             : 
     683             :     size_t GetUploadChunkSizeInBytes(const char *pszFilename,
     684             :                                      const char *pszSpecifiedValInBytes);
     685             : 
     686             :     virtual int CopyFileRestartable(const char *pszSource,
     687             :                                     const char *pszTarget,
     688             :                                     const char *pszInputPayload,
     689             :                                     char **ppszOutputPayload,
     690             :                                     CSLConstList papszOptions,
     691             :                                     GDALProgressFunc pProgressFunc,
     692             :                                     void *pProgressData) override;
     693             : 
     694             :     //! Maximum number of parts for multipart upload
     695             :     // Limit currently used by S3 and GS.
     696             :     // Cf https://docs.aws.amazon.com/AmazonS3/latest/userguide/qfacts.html
     697             :     // and https://cloud.google.com/storage/quotas#requests
     698          11 :     virtual int GetMaximumPartCount()
     699             :     {
     700          11 :         return 10000;
     701             :     }
     702             : 
     703             :     //! Minimum size of a part for multipart upload (except last one), in MiB.
     704             :     // Limit currently used by S3 and GS.
     705             :     // Cf https://docs.aws.amazon.com/AmazonS3/latest/userguide/qfacts.html
     706             :     // and https://cloud.google.com/storage/quotas#requests
     707           5 :     virtual int GetMinimumPartSizeInMiB()
     708             :     {
     709           5 :         return 5;
     710             :     }
     711             : 
     712             :     //! Maximum size of a part for multipart upload, in MiB.
     713             :     // Limit currently used by S3 and GS.
     714             :     // Cf https://docs.aws.amazon.com/AmazonS3/latest/userguide/qfacts.html
     715             :     // and https://cloud.google.com/storage/quotas#requests
     716          50 :     virtual int GetMaximumPartSizeInMiB()
     717             :     {
     718             : #if SIZEOF_VOIDP == 8
     719          50 :         return 5 * 1024;
     720             : #else
     721             :         // Cannot be larger than 4, otherwise integer overflow would occur
     722             :         // 1 GiB is the maximum reasonable value on a 32-bit machine
     723             :         return 1 * 1024;
     724             : #endif
     725             :     }
     726             : 
     727             :     //! Default size of a part for multipart upload, in MiB.
     728          47 :     virtual int GetDefaultPartSizeInMiB()
     729             :     {
     730          47 :         return 50;
     731             :     }
     732             : 
     733             :     virtual std::string
     734             :     InitiateMultipartUpload(const std::string &osFilename,
     735             :                             IVSIS3LikeHandleHelper *poS3HandleHelper,
     736             :                             const CPLHTTPRetryParameters &oRetryParameters,
     737             :                             CSLConstList papszOptions);
     738             : 
     739             :     virtual std::string
     740             :     UploadPart(const std::string &osFilename, int nPartNumber,
     741             :                const std::string &osUploadID, vsi_l_offset nPosition,
     742             :                const void *pabyBuffer, size_t nBufferSize,
     743             :                IVSIS3LikeHandleHelper *poS3HandleHelper,
     744             :                const CPLHTTPRetryParameters &oRetryParameters,
     745             :                CSLConstList papszOptions);
     746             : 
     747             :     virtual bool CompleteMultipart(
     748             :         const std::string &osFilename, const std::string &osUploadID,
     749             :         const std::vector<std::string> &aosEtags, vsi_l_offset nTotalSize,
     750             :         IVSIS3LikeHandleHelper *poS3HandleHelper,
     751             :         const CPLHTTPRetryParameters &oRetryParameters);
     752             : 
     753             :     virtual bool AbortMultipart(const std::string &osFilename,
     754             :                                 const std::string &osUploadID,
     755             :                                 IVSIS3LikeHandleHelper *poS3HandleHelper,
     756             :                                 const CPLHTTPRetryParameters &oRetryParameters);
     757             : 
     758             :     bool AbortPendingUploads(const char *pszFilename) override;
     759             : 
     760             :     bool MultipartUploadGetCapabilities(int *pbNonSequentialUploadSupported,
     761             :                                         int *pbParallelUploadSupported,
     762             :                                         int *pbAbortSupported,
     763             :                                         size_t *pnMinPartSize,
     764             :                                         size_t *pnMaxPartSize,
     765             :                                         int *pnMaxPartCount) override;
     766             : 
     767             :     char *MultipartUploadStart(const char *pszFilename,
     768             :                                CSLConstList papszOptions) override;
     769             : 
     770             :     char *MultipartUploadAddPart(const char *pszFilename,
     771             :                                  const char *pszUploadId, int nPartNumber,
     772             :                                  vsi_l_offset nFileOffset, const void *pData,
     773             :                                  size_t nDataLength,
     774             :                                  CSLConstList papszOptions) override;
     775             : 
     776             :     bool MultipartUploadEnd(const char *pszFilename, const char *pszUploadId,
     777             :                             size_t nPartIdsCount,
     778             :                             const char *const *apszPartIds,
     779             :                             vsi_l_offset nTotalSize,
     780             :                             CSLConstList papszOptions) override;
     781             : 
     782             :     bool MultipartUploadAbort(const char *pszFilename, const char *pszUploadId,
     783             :                               CSLConstList papszOptions) override;
     784             : };
     785             : 
     786             : /************************************************************************/
     787             : /*                          IVSIS3LikeHandle                            */
     788             : /************************************************************************/
     789             : 
     790         261 : class IVSIS3LikeHandle /* non final */ : public VSICurlHandle
     791             : {
     792             :     CPL_DISALLOW_COPY_ASSIGN(IVSIS3LikeHandle)
     793             : 
     794             :   protected:
     795         269 :     bool UseLimitRangeGetInsteadOfHead() override
     796             :     {
     797         269 :         return true;
     798             :     }
     799             : 
     800         111 :     bool IsDirectoryFromExists(const char *pszVerb, int response_code) override
     801             :     {
     802             :         // A bit dirty, but on S3, a GET on a existing directory returns a 416
     803         115 :         return response_code == 416 && EQUAL(pszVerb, "GET") &&
     804         115 :                std::string(m_pszURL).back() == '/';
     805             :     }
     806             : 
     807          55 :     void ProcessGetFileSizeResult(const char *pszContent) override
     808             :     {
     809          55 :         oFileProp.bIsDirectory =
     810          55 :             strstr(pszContent, "ListBucketResult") != nullptr;
     811          55 :     }
     812             : 
     813             :   public:
     814         261 :     IVSIS3LikeHandle(VSICurlFilesystemHandlerBase *poFSIn,
     815             :                      const char *pszFilename, const char *pszURLIn)
     816         261 :         : VSICurlHandle(poFSIn, pszFilename, pszURLIn)
     817             :     {
     818         261 :     }
     819             : 
     820             :     ~IVSIS3LikeHandle() override;
     821             : };
     822             : 
     823             : /************************************************************************/
     824             : /*                       VSIMultipartWriteHandle                        */
     825             : /************************************************************************/
     826             : 
     827             : class VSIMultipartWriteHandle final : public VSIVirtualHandle
     828             : {
     829             :     CPL_DISALLOW_COPY_ASSIGN(VSIMultipartWriteHandle)
     830             : 
     831             :     IVSIS3LikeFSHandlerWithMultipartUpload *m_poFS = nullptr;
     832             :     std::string m_osFilename{};
     833             :     IVSIS3LikeHandleHelper *m_poS3HandleHelper = nullptr;
     834             :     CPLStringList m_aosOptions{};
     835             :     CPLStringList m_aosHTTPOptions{};
     836             :     CPLHTTPRetryParameters m_oRetryParameters;
     837             : 
     838             :     vsi_l_offset m_nCurOffset = 0;
     839             :     size_t m_nBufferOff = 0;
     840             :     size_t m_nBufferSize = 0;
     841             :     bool m_bClosed = false;
     842             :     GByte *m_pabyBuffer = nullptr;
     843             :     std::string m_osUploadID{};
     844             :     int m_nPartNumber = 0;
     845             :     std::vector<std::string> m_aosEtags{};
     846             :     bool m_bError = false;
     847             : 
     848             :     WriteFuncStruct m_sWriteFuncHeaderData{};
     849             : 
     850             :     bool UploadPart();
     851             :     bool DoSinglePartPUT();
     852             : 
     853             :     void InvalidateParentDirectory();
     854             : 
     855             :   public:
     856             :     VSIMultipartWriteHandle(IVSIS3LikeFSHandlerWithMultipartUpload *poFS,
     857             :                             const char *pszFilename,
     858             :                             IVSIS3LikeHandleHelper *poS3HandleHelper,
     859             :                             CSLConstList papszOptions);
     860             :     ~VSIMultipartWriteHandle() override;
     861             : 
     862             :     int Seek(vsi_l_offset nOffset, int nWhence) override;
     863             :     vsi_l_offset Tell() override;
     864             :     size_t Read(void *pBuffer, size_t nSize, size_t nMemb) override;
     865             :     size_t Write(const void *pBuffer, size_t nSize, size_t nMemb) override;
     866             : 
     867           0 :     void ClearErr() override
     868             :     {
     869           0 :     }
     870             : 
     871           0 :     int Error() override
     872             :     {
     873           0 :         return FALSE;
     874             :     }
     875             : 
     876           0 :     int Eof() override
     877             :     {
     878           0 :         return FALSE;
     879             :     }
     880             : 
     881             :     int Close() override;
     882             : 
     883          31 :     bool IsOK()
     884             :     {
     885          31 :         return m_pabyBuffer != nullptr;
     886             :     }
     887             : };
     888             : 
     889             : /************************************************************************/
     890             : /*                         VSIChunkedWriteHandle()                      */
     891             : /************************************************************************/
     892             : 
     893             : /** Class with Write() append-only implementation using
     894             :  * "Transfer-Encoding: chunked" writing
     895             :  */
     896             : class VSIChunkedWriteHandle final : public VSIVirtualHandle
     897             : {
     898             :     CPL_DISALLOW_COPY_ASSIGN(VSIChunkedWriteHandle)
     899             : 
     900             :     IVSIS3LikeFSHandler *m_poFS = nullptr;
     901             :     std::string m_osFilename{};
     902             :     IVSIS3LikeHandleHelper *m_poS3HandleHelper = nullptr;
     903             :     CPLStringList m_aosOptions{};
     904             :     CPLStringList m_aosHTTPOptions{};
     905             :     CPLHTTPRetryParameters m_oRetryParameters;
     906             : 
     907             :     vsi_l_offset m_nCurOffset = 0;
     908             :     size_t m_nBufferOff = 0;
     909             :     bool m_bError = false;
     910             :     bool m_bClosed = false;
     911             : 
     912             :     CURLM *m_hCurlMulti = nullptr;
     913             :     CURL *m_hCurl = nullptr;
     914             :     const void *m_pBuffer = nullptr;
     915             :     std::string m_osCurlErrBuf{};
     916             :     size_t m_nChunkedBufferOff = 0;
     917             :     size_t m_nChunkedBufferSize = 0;
     918             :     size_t m_nWrittenInPUT = 0;
     919             : 
     920             :     WriteFuncStruct m_sWriteFuncHeaderData{};
     921             : 
     922             :     static size_t ReadCallBackBufferChunked(char *buffer, size_t size,
     923             :                                             size_t nitems, void *instream);
     924             :     int FinishChunkedTransfer();
     925             : 
     926             :     bool DoEmptyPUT();
     927             : 
     928             :     void InvalidateParentDirectory();
     929             : 
     930             :   public:
     931             :     VSIChunkedWriteHandle(IVSIS3LikeFSHandler *poFS, const char *pszFilename,
     932             :                           IVSIS3LikeHandleHelper *poS3HandleHelper,
     933             :                           CSLConstList papszOptions);
     934             :     ~VSIChunkedWriteHandle() override;
     935             : 
     936             :     int Seek(vsi_l_offset nOffset, int nWhence) override;
     937             :     vsi_l_offset Tell() override;
     938             :     size_t Read(void *pBuffer, size_t nSize, size_t nMemb) override;
     939             :     size_t Write(const void *pBuffer, size_t nSize, size_t nMemb) override;
     940             : 
     941           0 :     void ClearErr() override
     942             :     {
     943           0 :     }
     944             : 
     945           0 :     int Error() override
     946             :     {
     947           0 :         return FALSE;
     948             :     }
     949             : 
     950           0 :     int Eof() override
     951             :     {
     952           0 :         return FALSE;
     953             :     }
     954             : 
     955             :     int Close() override;
     956             : };
     957             : 
     958             : /************************************************************************/
     959             : /*                        VSIAppendWriteHandle                          */
     960             : /************************************************************************/
     961             : 
     962             : class VSIAppendWriteHandle CPL_NON_FINAL : public VSIVirtualHandle
     963             : {
     964             :     CPL_DISALLOW_COPY_ASSIGN(VSIAppendWriteHandle)
     965             : 
     966             :   protected:
     967             :     VSICurlFilesystemHandlerBase *m_poFS = nullptr;
     968             :     std::string m_osFSPrefix{};
     969             :     std::string m_osFilename{};
     970             :     CPLHTTPRetryParameters m_oRetryParameters{};
     971             : 
     972             :     vsi_l_offset m_nCurOffset = 0;
     973             :     int m_nBufferOff = 0;
     974             :     int m_nBufferSize = 0;
     975             :     int m_nBufferOffReadCallback = 0;
     976             :     bool m_bClosed = false;
     977             :     GByte *m_pabyBuffer = nullptr;
     978             :     bool m_bError = false;
     979             : 
     980             :     static size_t ReadCallBackBuffer(char *buffer, size_t size, size_t nitems,
     981             :                                      void *instream);
     982             :     virtual bool Send(bool bIsLastBlock) = 0;
     983             : 
     984             :   public:
     985             :     VSIAppendWriteHandle(VSICurlFilesystemHandlerBase *poFS,
     986             :                          const char *pszFSPrefix, const char *pszFilename,
     987             :                          int nChunkSize);
     988             :     ~VSIAppendWriteHandle() override;
     989             : 
     990             :     int Seek(vsi_l_offset nOffset, int nWhence) override;
     991             :     vsi_l_offset Tell() override;
     992             :     size_t Read(void *pBuffer, size_t nSize, size_t nMemb) override;
     993             :     size_t Write(const void *pBuffer, size_t nSize, size_t nMemb) override;
     994             : 
     995           0 :     void ClearErr() override
     996             :     {
     997           0 :     }
     998             : 
     999           0 :     int Error() override
    1000             :     {
    1001           0 :         return FALSE;
    1002             :     }
    1003             : 
    1004           0 :     int Eof() override
    1005             :     {
    1006           0 :         return FALSE;
    1007             :     }
    1008             : 
    1009             :     int Close() override;
    1010             : 
    1011          10 :     bool IsOK()
    1012             :     {
    1013          10 :         return m_pabyBuffer != nullptr;
    1014             :     }
    1015             : };
    1016             : 
    1017             : /************************************************************************/
    1018             : /*                     VSIDIRWithMissingDirSynthesis                    */
    1019             : /************************************************************************/
    1020             : 
    1021         128 : struct VSIDIRWithMissingDirSynthesis /* non final */ : public VSIDIR
    1022             : {
    1023             :     std::vector<std::unique_ptr<VSIDIREntry>> aoEntries{};
    1024             : 
    1025             :   protected:
    1026             :     ~VSIDIRWithMissingDirSynthesis() override;
    1027             : 
    1028             :     std::vector<std::string> m_aosSubpathsStack{};
    1029             : 
    1030             :     void SynthetizeMissingDirectories(const std::string &osCurSubdir,
    1031             :                                       bool bAddEntryForThisSubdir);
    1032             : };
    1033             : 
    1034             : /************************************************************************/
    1035             : /*                          VSIDIRS3Like                                */
    1036             : /************************************************************************/
    1037             : 
    1038             : struct VSIDIRS3Like /* non final */ : public VSIDIRWithMissingDirSynthesis
    1039             : {
    1040             :     const std::string m_osDirName;
    1041             : 
    1042             :     int nRecurseDepth = 0;
    1043             : 
    1044             :     std::string osNextMarker{};
    1045             :     int nPos = 0;
    1046             : 
    1047             :     std::string osBucket{};
    1048             :     std::string osObjectKey{};
    1049             :     VSICurlFilesystemHandlerBase *poFS = nullptr;
    1050             :     IVSIS3LikeFSHandler *poS3FS = nullptr;
    1051             :     std::unique_ptr<IVSIS3LikeHandleHelper> poHandleHelper{};
    1052             :     int nMaxFiles = 0;
    1053             :     bool bCacheEntries = true;
    1054             :     bool m_bSynthetizeMissingDirectories = false;
    1055             :     std::string m_osFilterPrefix{};
    1056             : 
    1057             :     // used when listing only the file system prefix
    1058             :     std::unique_ptr<VSIDIR, decltype(&VSICloseDir)> m_subdir{nullptr,
    1059         128 :                                                              VSICloseDir};
    1060             : 
    1061         128 :     VSIDIRS3Like(const std::string &osDirName, IVSIS3LikeFSHandler *poFSIn)
    1062         128 :         : m_osDirName(osDirName), poFS(poFSIn), poS3FS(poFSIn)
    1063             :     {
    1064         128 :     }
    1065             : 
    1066           0 :     VSIDIRS3Like(const std::string &osDirName,
    1067             :                  VSICurlFilesystemHandlerBase *poFSIn)
    1068           0 :         : m_osDirName(osDirName), poFS(poFSIn)
    1069             :     {
    1070           0 :     }
    1071             : 
    1072             :     VSIDIRS3Like(const VSIDIRS3Like &) = delete;
    1073             :     VSIDIRS3Like &operator=(const VSIDIRS3Like &) = delete;
    1074             : 
    1075             :     const VSIDIREntry *NextDirEntry() override;
    1076             : 
    1077             :     virtual bool IssueListDir() = 0;
    1078             :     void clear();
    1079             : };
    1080             : 
    1081             : /************************************************************************/
    1082             : /*                         CurlRequestHelper                            */
    1083             : /************************************************************************/
    1084             : 
    1085             : struct CurlRequestHelper
    1086             : {
    1087             :     WriteFuncStruct sWriteFuncData{};
    1088             :     WriteFuncStruct sWriteFuncHeaderData{};
    1089             :     char szCurlErrBuf[CURL_ERROR_SIZE + 1] = {};
    1090             : 
    1091             :     CurlRequestHelper();
    1092             :     ~CurlRequestHelper();
    1093             :     long perform(CURL *hCurlHandle,
    1094             :                  struct curl_slist *headers,  // ownership transferred
    1095             :                  VSICurlFilesystemHandlerBase *poFS,
    1096             :                  IVSIS3LikeHandleHelper *poS3HandleHelper);
    1097             : };
    1098             : 
    1099             : /************************************************************************/
    1100             : /*                       NetworkStatisticsLogger                        */
    1101             : /************************************************************************/
    1102             : 
    1103             : class NetworkStatisticsLogger
    1104             : {
    1105             :     static int gnEnabled;
    1106             :     static NetworkStatisticsLogger gInstance;
    1107             : 
    1108        1591 :     NetworkStatisticsLogger() = default;
    1109             : 
    1110             :     std::mutex m_mutex{};
    1111             : 
    1112             :     struct Counters
    1113             :     {
    1114             :         GIntBig nHEAD = 0;
    1115             :         GIntBig nGET = 0;
    1116             :         GIntBig nPUT = 0;
    1117             :         GIntBig nPOST = 0;
    1118             :         GIntBig nDELETE = 0;
    1119             :         GIntBig nGETDownloadedBytes = 0;
    1120             :         GIntBig nPUTUploadedBytes = 0;
    1121             :         GIntBig nPOSTDownloadedBytes = 0;
    1122             :         GIntBig nPOSTUploadedBytes = 0;
    1123             :     };
    1124             : 
    1125             :     enum class ContextPathType
    1126             :     {
    1127             :         FILESYSTEM,
    1128             :         FILE,
    1129             :         ACTION,
    1130             :     };
    1131             : 
    1132             :     struct ContextPathItem
    1133             :     {
    1134             :         ContextPathType eType;
    1135             :         std::string osName;
    1136             : 
    1137           3 :         ContextPathItem(ContextPathType eTypeIn, const std::string &osNameIn)
    1138           3 :             : eType(eTypeIn), osName(osNameIn)
    1139             :         {
    1140           3 :         }
    1141             : 
    1142           0 :         bool operator<(const ContextPathItem &other) const
    1143             :         {
    1144           0 :             if (static_cast<int>(eType) < static_cast<int>(other.eType))
    1145           0 :                 return true;
    1146           0 :             if (static_cast<int>(eType) > static_cast<int>(other.eType))
    1147           0 :                 return false;
    1148           0 :             return osName < other.osName;
    1149             :         }
    1150             :     };
    1151             : 
    1152             :     struct Stats
    1153             :     {
    1154             :         Counters counters{};
    1155             :         std::map<ContextPathItem, Stats> children{};
    1156             : 
    1157             :         void AsJSON(CPLJSONObject &oJSON) const;
    1158             :     };
    1159             : 
    1160             :     // Workaround bug in Coverity Scan
    1161             :     // coverity[generated_default_constructor_used_in_field_initializer]
    1162             :     Stats m_stats{};
    1163             :     std::map<GIntBig, std::vector<ContextPathItem>>
    1164             :         m_mapThreadIdToContextPath{};
    1165             : 
    1166             :     static void ReadEnabled();
    1167             : 
    1168             :     std::vector<Counters *> GetCountersForContext();
    1169             : 
    1170             :   public:
    1171      282729 :     static inline bool IsEnabled()
    1172             :     {
    1173      282729 :         if (gnEnabled < 0)
    1174             :         {
    1175           8 :             ReadEnabled();
    1176             :         }
    1177      282729 :         return gnEnabled == TRUE;
    1178             :     }
    1179             : 
    1180             :     static void EnterFileSystem(const char *pszName);
    1181             : 
    1182             :     static void LeaveFileSystem();
    1183             : 
    1184             :     static void EnterFile(const char *pszName);
    1185             : 
    1186             :     static void LeaveFile();
    1187             : 
    1188             :     static void EnterAction(const char *pszName);
    1189             : 
    1190             :     static void LeaveAction();
    1191             : 
    1192             :     static void LogHEAD();
    1193             : 
    1194             :     static void LogGET(size_t nDownloadedBytes);
    1195             : 
    1196             :     static void LogPUT(size_t nUploadedBytes);
    1197             : 
    1198             :     static void LogPOST(size_t nUploadedBytes, size_t nDownloadedBytes);
    1199             : 
    1200             :     static void LogDELETE();
    1201             : 
    1202             :     static void Reset();
    1203             : 
    1204             :     static std::string GetReportAsSerializedJSON();
    1205             : };
    1206             : 
    1207             : struct NetworkStatisticsFileSystem
    1208             : {
    1209       47428 :     inline explicit NetworkStatisticsFileSystem(const char *pszName)
    1210             :     {
    1211       47428 :         NetworkStatisticsLogger::EnterFileSystem(pszName);
    1212       47428 :     }
    1213             : 
    1214       47428 :     inline ~NetworkStatisticsFileSystem()
    1215             :     {
    1216       47428 :         NetworkStatisticsLogger::LeaveFileSystem();
    1217       47428 :     }
    1218             : };
    1219             : 
    1220             : struct NetworkStatisticsFile
    1221             : {
    1222       45887 :     inline explicit NetworkStatisticsFile(const char *pszName)
    1223             :     {
    1224       45887 :         NetworkStatisticsLogger::EnterFile(pszName);
    1225       45887 :     }
    1226             : 
    1227       45887 :     inline ~NetworkStatisticsFile()
    1228             :     {
    1229       45887 :         NetworkStatisticsLogger::LeaveFile();
    1230       45887 :     }
    1231             : };
    1232             : 
    1233             : struct NetworkStatisticsAction
    1234             : {
    1235       47428 :     inline explicit NetworkStatisticsAction(const char *pszName)
    1236             :     {
    1237       47428 :         NetworkStatisticsLogger::EnterAction(pszName);
    1238       47428 :     }
    1239             : 
    1240       47428 :     inline ~NetworkStatisticsAction()
    1241             :     {
    1242       47428 :         NetworkStatisticsLogger::LeaveAction();
    1243       47428 :     }
    1244             : };
    1245             : 
    1246             : }  // namespace cpl
    1247             : 
    1248             : int VSICURLGetDownloadChunkSize();
    1249             : 
    1250             : void VSICURLInitWriteFuncStruct(cpl::WriteFuncStruct *psStruct, VSILFILE *fp,
    1251             :                                 VSICurlReadCbkFunc pfnReadCbk,
    1252             :                                 void *pReadCbkUserData);
    1253             : size_t VSICurlHandleWriteFunc(void *buffer, size_t count, size_t nmemb,
    1254             :                               void *req);
    1255             : void VSICURLMultiPerform(CURLM *hCurlMultiHandle, CURL *hEasyHandle = nullptr,
    1256             :                          std::atomic<bool> *pbInterrupt = nullptr);
    1257             : void VSICURLResetHeaderAndWriterFunctions(CURL *hCurlHandle);
    1258             : 
    1259             : int VSICurlParseUnixPermissions(const char *pszPermissions);
    1260             : 
    1261             : // Cache of file properties (size, etc.)
    1262             : bool VSICURLGetCachedFileProp(const char *pszURL, cpl::FileProp &oFileProp);
    1263             : void VSICURLSetCachedFileProp(const char *pszURL, cpl::FileProp &oFileProp);
    1264             : void VSICURLInvalidateCachedFileProp(const char *pszURL);
    1265             : void VSICURLInvalidateCachedFilePropPrefix(const char *pszURL);
    1266             : void VSICURLDestroyCacheFileProp();
    1267             : 
    1268             : void VSICURLMultiCleanup(CURLM *hCurlMultiHandle);
    1269             : 
    1270             : //! @endcond
    1271             : 
    1272             : #endif  // HAVE_CURL
    1273             : 
    1274             : #endif  // CPL_VSIL_CURL_CLASS_H_INCLUDED

Generated by: LCOV version 1.14