From 7d6b5d4e8a2f6caa5e62bcd81241b415ca8b940f Mon Sep 17 00:00:00 2001 From: iwbnwif Date: Tue, 12 Sep 2017 11:49:56 +0100 Subject: [PATCH] Initial commit. --- README.md | 9 + include/wx/curl/base.h | 711 +++++++++++ include/wx/curl/dav.h | 78 ++ include/wx/curl/davtool.h | 108 ++ include/wx/curl/dialog.h | 328 +++++ include/wx/curl/ftp.h | 156 +++ include/wx/curl/ftptool.h | 98 ++ include/wx/curl/http.h | 105 ++ include/wx/curl/panel.h | 101 ++ include/wx/curl/telnet.h | 28 + include/wx/curl/thread.h | 390 ++++++ include/wx/curl/utils.h | 107 ++ lib/README | 55 + lib/curl/curl.h | 2318 ++++++++++++++++++++++++++++++++++++ lib/curl/curlbuild.h | 585 +++++++++ lib/curl/curlbuild.h.cmake | 197 +++ lib/curl/curlbuild.h.in | 197 +++ lib/curl/curlrules.h | 262 ++++ lib/curl/curlver.h | 69 ++ lib/curl/easy.h | 102 ++ lib/curl/mprintf.h | 81 ++ lib/curl/multi.h | 399 +++++++ lib/curl/stdcheaders.h | 33 + lib/curl/typecheck-gcc.h | 610 ++++++++++ src/base.cpp | 988 +++++++++++++++ src/dav.cpp | 287 +++++ src/davtool.cpp | 431 +++++++ src/dialog.cpp | 653 ++++++++++ src/ftp.cpp | 602 ++++++++++ src/ftpparse.cpp | 459 +++++++ src/ftpparse.h | 51 + src/ftptool.cpp | 213 ++++ src/http.cpp | 396 ++++++ src/panel.cpp | 211 ++++ src/telnet.cpp | 44 + src/thread.cpp | 363 ++++++ src/utils.cpp | 118 ++ 37 files changed, 11943 insertions(+) create mode 100644 README.md create mode 100644 include/wx/curl/base.h create mode 100644 include/wx/curl/dav.h create mode 100644 include/wx/curl/davtool.h create mode 100644 include/wx/curl/dialog.h create mode 100644 include/wx/curl/ftp.h create mode 100644 include/wx/curl/ftptool.h create mode 100644 include/wx/curl/http.h create mode 100644 include/wx/curl/panel.h create mode 100644 include/wx/curl/telnet.h create mode 100644 include/wx/curl/thread.h create mode 100644 include/wx/curl/utils.h create mode 100644 lib/README create mode 100644 lib/curl/curl.h create mode 100644 lib/curl/curlbuild.h create mode 100644 lib/curl/curlbuild.h.cmake create mode 100644 lib/curl/curlbuild.h.in create mode 100644 lib/curl/curlrules.h create mode 100644 lib/curl/curlver.h create mode 100644 lib/curl/easy.h create mode 100644 lib/curl/mprintf.h create mode 100644 lib/curl/multi.h create mode 100644 lib/curl/stdcheaders.h create mode 100644 lib/curl/typecheck-gcc.h create mode 100644 src/base.cpp create mode 100644 src/dav.cpp create mode 100644 src/davtool.cpp create mode 100644 src/dialog.cpp create mode 100644 src/ftp.cpp create mode 100644 src/ftpparse.cpp create mode 100644 src/ftpparse.h create mode 100644 src/ftptool.cpp create mode 100644 src/http.cpp create mode 100644 src/panel.cpp create mode 100644 src/telnet.cpp create mode 100644 src/thread.cpp create mode 100644 src/utils.cpp diff --git a/README.md b/README.md new file mode 100644 index 0000000..4383f36 --- /dev/null +++ b/README.md @@ -0,0 +1,9 @@ +# wxCurl +Clone of improved wxCurl from OpenCPN. wxCURL is a simplified and integrated interface between LibCURL and wxWidgets. + +As libCURL authors state, libcurl is free, thread-safe, IPv6 compatible, feature rich, well supported, +fast, thoroughly documented and is already used by many known, big and successful companies and numerous +applications. + +wxCURL provides several sub-classes for simplified interfaces to HTTP, WebDAV, FTP and Telnet based resources, +threads specialized for non-blocking downloads/uploads, stock download and upload dialogs. diff --git a/include/wx/curl/base.h b/include/wx/curl/base.h new file mode 100644 index 0000000..c250078 --- /dev/null +++ b/include/wx/curl/base.h @@ -0,0 +1,711 @@ +/* +* base.h +* wxCURL +* +* Created by Casey O'Donnell on Tue Jun 29 2004. +* Copyright (c) 2004 Casey O'Donnell. All rights reserved. +* +* Contributions and Assistance: +* Ryan Wilcox - Verbose Options +* Francesco Montorsi - Unicode compatibility mode, misc other changes +* +* Licence: wxWidgets Licence +*/ + +#ifndef _WXCURLBASE_H__INCLUDED_ +#define _WXCURLBASE_H__INCLUDED_ + +#ifdef WXMAKINGDLL_WXCURL + #define WXDLLIMPEXP_CURL WXEXPORT +#elif defined(WXUSINGDLL) +// #define WXDLLIMPEXP_CURL WXIMPORT + #define WXDLLIMPEXP_CURL +#else // not making nor using DLL + #define WXDLLIMPEXP_CURL + + // if we do not define this symbol, cURL header will assume + // a DLL build is being done and will export symbols: + #ifndef CURL_STATICLIB + #define CURL_STATICLIB + #endif +#endif + +#include +#include +#include +#include +#include +#include +#include // for _() +#include + +// The cURL library header: +#include + + + +// base.h: wxWidgets Declarations for Event Types. +// +////////////////////////////////////////////////////////////////////// + +BEGIN_DECLARE_EVENT_TYPES() + DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_CURL, wxCURL_DOWNLOAD_EVENT, 6578) + DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_CURL, wxCURL_UPLOAD_EVENT, 6579) + DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_CURL, wxCURL_BEGIN_PERFORM_EVENT, 6580) + DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_CURL, wxCURL_END_PERFORM_EVENT, 6581) +END_DECLARE_EVENT_TYPES() + + +class WXDLLIMPEXP_CURL wxCurlBase; + + +//! Private internal class used as base class for wxCurlDownloadEvent and wxCurlUploadEvent. +class WXDLLIMPEXP_CURL wxCurlProgressBaseEvent : public wxEvent +{ +public: + wxCurlProgressBaseEvent(int id, wxEventType type, + wxCurlBase *p = NULL, const std::string &url = "") + : wxEvent(id, type) { m_pCURL = p; m_szURL = url; m_dt = wxDateTime::Now(); } + + +public: // misc getters + + //! Returns the curl session which generated this event. + wxCurlBase *GetCurlSession() const { return m_pCURL; } + + //! Returns the date & time at which this event was generated. + wxDateTime GetDateTime() const { return m_dt; } + + //! Returns a number in [0;100] range indicating how much has been transferred so far. + double GetPercent() const + { return GetTotalBytes() == 0 ? 0 : (100.0 * (GetTransferredBytes()/GetTotalBytes())); } + + //! Returns the current transfer speed in bytes/second. + virtual double GetSpeed() const + { return GetTransferredBytes()/GetElapsedTime().GetSeconds().ToDouble(); } + +public: // wxTimeSpan getters + + //! Returns the time elapsed since the beginning of the download up + //! to the time this function is called. + virtual wxTimeSpan GetElapsedTime() const; + + //! Returns the estimated time for the total download since it started. + virtual wxTimeSpan GetEstimatedTime() const; + + //! Returns the estimated remaining time to the completion of the download. + virtual wxTimeSpan GetEstimatedRemainingTime() const; + + +public: // wxString getters + + //! Returns the URL you are transfering from. + std::string GetURL() const { return m_szURL; } + + //! Returns the current download/upload speed in a human readable format. + std::string GetHumanReadableSpeed(const std::string &inv = GetNAText(), int prec = 1) const; + + //! Returns the total bytes to download in a human-readable format. + std::string GetHumanReadableTotalBytes(const std::string &inv = GetNAText(), int prec = 1) const + { + wxString s(inv.c_str(), wxConvUTF8); + return std::string(wxFileName::GetHumanReadableSize(wxULongLong((unsigned long)GetTotalBytes()), s, prec).mb_str()); + } + + //! Returns the currently transferred bytes in a human-readable format. + std::string GetHumanReadableTransferredBytes(const std::string &inv = GetNAText(), int prec = 1) const + { + wxString s(inv.c_str(), wxConvUTF8); + return std::string(wxFileName::GetHumanReadableSize(wxULongLong((unsigned long)GetTransferredBytes()), s, prec).mb_str()); + } + + +public: // pure virtual functions + + //! Returns the total bytes to transfer. + virtual double GetTotalBytes() const = 0; + + //! Returns the bytes transferred so far. + virtual double GetTransferredBytes() const = 0; + +protected: + wxCurlBase *m_pCURL; + std::string m_szURL; + + // NOTE: we need to store this date time to use it in GetElapsedTime: + // we cannot use wxDateTime::Now() there because once the event is constructed, + // GetElapsedTime() needs to return always the same value! + wxDateTime m_dt; + +public: + static std::string GetNAText() + { + wxString s = _("Not available"); + return std::string(s.mb_str()); + } +}; + + +// base.h: interface for the wxCurlDownloadEvent class. +// +////////////////////////////////////////////////////////////////////// + +//! This event gets posted by wxCURL with a frequent interval during operation +//! (roughly once per second) no matter if data is being transfered or not. +//! Unknown/unused argument values passed to the callback will be set to zero +//! (like if you only download data, the upload size will remain 0). +//! Use the EVT_CURL_PROGRESS(id, function) macro to intercept this event. +class WXDLLIMPEXP_CURL wxCurlDownloadEvent : public wxCurlProgressBaseEvent +{ +public: + wxCurlDownloadEvent(); + wxCurlDownloadEvent(int id, wxCurlBase *originator, + const double& rDownloadTotal, const double& rDownloadNow, + const std::string& szURL = ""); + wxCurlDownloadEvent(const wxCurlDownloadEvent& event); + + virtual wxEvent* Clone() const { return new wxCurlDownloadEvent(*this); } + + + //! Returns the number of bytes downloaded so far. + double GetDownloadedBytes() const { return m_rDownloadNow; } + double GetTransferredBytes() const { return m_rDownloadNow; } + + //! Returns the total number of bytes to download. + double GetTotalBytes() const { return m_rDownloadTotal; } + + //! Returns the currently downloaded bytes in a human-readable format. + std::string GetHumanReadableDownloadedBytes(const std::string &inv = wxCurlProgressBaseEvent::GetNAText(), int prec = 1) const + { + wxString s(inv.c_str(), wxConvUTF8); + return std::string(wxFileName::GetHumanReadableSize(wxULongLong((unsigned long)m_rDownloadNow), s, prec).mb_str()); + } + + +protected: + double m_rDownloadTotal, m_rDownloadNow; + +private: + DECLARE_DYNAMIC_CLASS(wxCurlDownloadEvent); +}; + +typedef void (wxEvtHandler::*wxCurlDownloadEventFunction)(wxCurlDownloadEvent&); + +#define wxCurlDownloadEventHandler(func) \ + (wxObjectEventFunction)(wxEventFunction)wxStaticCastEvent(wxCurlDownloadEventFunction, &func) + +#define EVT_CURL_DOWNLOAD(id, fn) \ + wx__DECLARE_EVT1(wxCURL_DOWNLOAD_EVENT, id, wxCurlDownloadEventHandler(fn)) + + +//! This event gets posted by wxCURL with a frequent interval during operation +//! (roughly once per second) no matter if data is being transfered or not. +//! Unknown/unused argument values passed to the callback will be set to zero +//! (like if you only download data, the upload size will remain 0). +//! Use the EVT_CURL_PROGRESS(id, function) macro to intercept this event. +class WXDLLIMPEXP_CURL wxCurlUploadEvent : public wxCurlProgressBaseEvent +{ +public: + wxCurlUploadEvent(); + wxCurlUploadEvent(int id, wxCurlBase *originator, + const double& rUploadTotal, const double& rUploadNow, + const std::string& szURL = ""); + wxCurlUploadEvent(const wxCurlUploadEvent& event); + + virtual wxEvent* Clone() const { return new wxCurlUploadEvent(*this); } + + + //! Returns the number of bytes uploaded so far. + double GetUploadedBytes() const { return m_rUploadNow; } + double GetTransferredBytes() const { return m_rUploadNow; } + + //! Returns the total number of bytes to upload. + double GetTotalBytes() const { return m_rUploadTotal; } + + //! Returns the currently uploaded bytes in a human-readable format. + std::string GetHumanReadableUploadedBytes(const std::string &inv = wxCurlProgressBaseEvent::GetNAText(), int prec = 1) const + { + wxString s(inv.c_str(), wxConvUTF8); + return std::string(wxFileName::GetHumanReadableSize(wxULongLong((unsigned long)m_rUploadNow), s, prec).mb_str()); + } + +protected: + double m_rUploadTotal, m_rUploadNow; + +private: + DECLARE_DYNAMIC_CLASS(wxCurlUploadEvent); +}; + +typedef void (wxEvtHandler::*wxCurlUploadEventFunction)(wxCurlUploadEvent&); + +#define wxCurlUploadEventHandler(func) \ + (wxObjectEventFunction)(wxEventFunction)wxStaticCastEvent(wxCurlUploadEventFunction, &func) + +#define EVT_CURL_UPLOAD(id, fn) \ + wx__DECLARE_EVT1(wxCURL_UPLOAD_EVENT, id, wxCurlUploadEventHandler(fn)) + + + +// base.h: interface for the wxCurlBeginPerformEvent class. +// +////////////////////////////////////////////////////////////////////// + +//! This event get posted before the beginning of any tranfer operation. +//! Use the EVT_CURL_BEGIN_PERFORM(id, function) macro to intercept this event. +class WXDLLIMPEXP_CURL wxCurlBeginPerformEvent : public wxEvent +{ +public: + wxCurlBeginPerformEvent(); + wxCurlBeginPerformEvent(int id, const std::string& szURL); + wxCurlBeginPerformEvent(const wxCurlBeginPerformEvent& event); + + virtual wxEvent* Clone() const { return new wxCurlBeginPerformEvent(*this); } + + //! Returns the URL you are going to transfering from/to. + std::string GetURL() const { return m_szURL; } + +protected: + std::string m_szURL; + +private: + DECLARE_DYNAMIC_CLASS(wxCurlBeginPerformEvent); +}; + +typedef void (wxEvtHandler::*wxCurlBeginPerformEventFunction)(wxCurlBeginPerformEvent&); + +#define wxCurlBeginPerformEventHandler(func) \ + (wxObjectEventFunction)(wxEventFunction)wxStaticCastEvent(wxCurlBeginPerformEventFunction, &func) + +#define EVT_CURL_BEGIN_PERFORM(id, fn) \ + wx__DECLARE_EVT1(wxCURL_BEGIN_PERFORM_EVENT, id, wxCurlBeginPerformEventHandler(fn)) + + + +// base.h: interface for the wxCurlEndPerformEvent class. +// +////////////////////////////////////////////////////////////////////// + +//! This event get posted at the end of any tranfer operation. +//! Use the EVT_CURL_END_PERFORM(id, function) macro to intercept this event. +class WXDLLIMPEXP_CURL wxCurlEndPerformEvent : public wxEvent +{ +public: + wxCurlEndPerformEvent(); + wxCurlEndPerformEvent(int id, const std::string& szURL, const long& iResponseCode); + wxCurlEndPerformEvent(const wxCurlEndPerformEvent& event); + + virtual wxEvent* Clone() const { return new wxCurlEndPerformEvent(*this); } + + //! Returns the URL you are going to transfering from/to. + std::string GetURL() const { return m_szURL; } + + //! Returns the response code for the operation. + long GetResponseCode() const { return m_iResponseCode; } + + //! Returns true if the response code indicates a valid transfer. + bool IsSuccessful() const { return ((m_iResponseCode > 199) && (m_iResponseCode < 300)); } + +protected: + std::string m_szURL; + long m_iResponseCode; + +private: + DECLARE_DYNAMIC_CLASS(wxCurlEndPerformEvent); +}; + +typedef void (wxEvtHandler::*wxCurlEndPerformEventFunction)(wxCurlEndPerformEvent&); + +#define wxCurlEndPerformEventHandler(func) \ + (wxObjectEventFunction)(wxEventFunction)wxStaticCastEvent(wxCurlEndPerformEventFunction, &func) + +#define EVT_CURL_END_PERFORM(id, fn) \ + wx__DECLARE_EVT1(wxCURL_END_PERFORM_EVENT, id, wxCurlEndPerformEventHandler(fn)) + + +// C Function Declarations for LibCURL +// +////////////////////////////////////////////////////////////////////// + +extern "C" +{ + int wxcurl_evt_progress_func(void* ptr, double rDlTotal, double rDlNow, + double rUlTotal, double rUlNow); + int wxcurl_verbose_stream_write (CURL * crlptr , curl_infotype info, char * cStrMessage, + size_t msgSize, void * buffer); + size_t wxcurl_header_func(void *ptr, size_t size, size_t nmemb, void *stream); + + size_t wxcurl_string_write(void* ptr, size_t size, size_t nmemb, void* stream); + size_t wxcurl_stream_write(void* ptr, size_t size, size_t nmemb, void* stream); + + size_t wxcurl_string_read(void* ptr, size_t size, size_t nmemb, void* stream); + size_t wxcurl_stream_read(void* ptr, size_t size, size_t nmemb, void* stream); +} + +// base.h: interface for the wxCurlBase class. +// +////////////////////////////////////////////////////////////////////// + +//! Tells wxCurlBase to send wxCurlDownloadEvent events +#define wxCURL_SEND_PROGRESS_EVENTS 0x01 + +//! Tells wxCurlBase to send wxCurlBeginPerformEvent and wxCurlEndPerformEvent events +#define wxCURL_SEND_BEGINEND_EVENTS 0x02 + +//! By default wxCurlBase won't send events +#define wxCURL_DEFAULT_FLAGS (0) + +//! The "easy" unspecialized interface to libCURL. +//! You may want to look at wxCurlFTP, wxCurlHTTP, wxCurlDAV if you want to have a specialized +//! interface for respectively the FTP, HTTP and WebDAV protocols. +//! +//! wxCurlBase represents a libCURL handle to a "session". +//! To use this interface you should: +//! - create an instance of wxCurlBase +//! - use #SetOpt to set libCURL options you're interested to +//! or alternatively the other various Set*() functions +//! - call #Perform to perform the operation +class WXDLLIMPEXP_CURL wxCurlBase +{ +public: + wxCurlBase(const wxString& szURL = wxEmptyString, + const wxString& szUserName = wxEmptyString, + const wxString& szPassword = wxEmptyString, + wxEvtHandler* pEvtHandler = NULL, int id = wxID_ANY, + long flags = wxCURL_DEFAULT_FLAGS); + + virtual ~wxCurlBase(); + + + // LibCURL Abstraction Methods - Wrapping curl_easy calls... + + //! Sets a transfer option for this libCURL session instance. + //! See the curl_easy_setopt() function call for more info. + bool SetOpt(CURLoption option, ...); + + //! Gets an info from this libCURL session instance. + //! See the curl_easy_getinfo() function call for more info. + bool GetInfo(CURLINFO info, ...) const; + + //! Start the operation as described by the options set previously with #SetOpt. + //! If you set CURLOPT_UPLOAD to zero and the CURLOPT_WRITEFUNCTION and CURLOPT_WRITEDATA + //! options to suitable values, a download will be performed. + //! If you set CURLOPT_UPLOAD to nonzero and the CURLOPT_READFUNCTION and CURLOPT_READDATA + //! options to suitable values, an upload will be performed. + //! See the curl_easy_perform() function call for more info. + bool Perform(); + + + // Internal handle management: + + //! Initializes the internal libCURL handle. This function is automatically called by + //! the constructor. + bool InitHandle(); + + //! Closes this libCURL session. This will effectively close all connections this handle + //! has used and possibly has kept open until now. + //! This function is automatically called by the destructor. + bool CleanupHandle(); + + //! Reinit the handle of this libCURL session. Equivalent to call #CleanupHandle and then #InitHandle. + bool ReInitHandle(); + + //! Re-initializes all options previously set on this libCURL session to the default values. + bool ResetHandle(); + + //! Is the underlying libCURL handle valid? + bool IsOk() const { return m_pCURL != NULL; } + + // Member Data Access Methods (MDA) + + //! Sets the event handler to which the wxCurlDownloadEvent, wxCurlBeginPerformEvent and + //! wxCurlEndPerformEvent will be sent if they are enabled (see #SetFlags). + bool SetEvtHandler(wxEvtHandler* pParent, int id = wxID_ANY); + wxEvtHandler* GetEvtHandler() const; + int GetId() const; + void SetAbort(bool a); + bool GetAbort() const; + + //! Sets the "event policy" of wxCURL: if you pass zero, then no events will ever be sent. + //! The wxCURL_SEND_PROGRESS_EVENTS and wxCURL_SEND_BEGINEND_EVENTS flags instead tell + //! wxCURL to send respectively the wxCurlDownloadEvent and wxCurlBeginPerformEvent, + //! wxCurlEndPerformEvent events. + void SetFlags(long flags); + long GetFlags() const; + + //! Sets the base URL. This allows you to specify a 'base' URL if you + //! are performing multiple actions. + void SetBaseURL(const wxString& szBaseURL); + std::string GetBaseURL() const; + + //! Sets the current URL. The 'base url' will be prepended to the given string. + void SetURL(const wxString &szRelativeURL); + + //! Returns the current 'full' URL. I.e. the real URL being used for the transfer. + std::string GetURL() const; + + //! Sets the host Port. This allows you to specify a specific (non- + //! default port) if you like. The value -1 means that the default port + //! will be used. + void SetPort(const long& iPort); + long GetPort() const; + + //! Sets the Username. If no username is + //! needed, simply assign an empty string (which is the default). + void SetUsername(const wxString& szUsername); + std::string GetUsername() const; + + //! Sets the Password. If no password is + //! needed, simply assign an empty string (which is the default). + void SetPassword(const wxString& szPassword); + std::string GetPassword() const; + + //! Returns the header of the response. + std::string GetResponseHeader() const; + std::string GetResponseBody() const; // May only contain data on NON-GET calls. + long GetResponseCode() const; + + //! Should the proxy be used? + void UseProxy(const bool& bUseProxy); + bool UseProxy() const; + + //! Sets proxy host. + void SetProxyHost(const wxString& szProxyHost); + std::string GetProxyHost() const; + + //! Sets the username for proxy access (if needed). + void SetProxyUsername(const wxString& szProxyUsername); + std::string GetProxyUsername() const; + + //! Sets the password for proxy access (if needed). + void SetProxyPassword(const wxString& szProxyPassword); + std::string GetProxyPassword() const; + + //! Sets the port for proxy access. + void SetProxyPort(const long& iProxyPort); + long GetProxyPort() const; + + //! Sets verbose mode on/off. Note that in verbose mode a lot of info + //! will be printed into an internal memory stream which can be queried + //! using #GetVerboseStream and #GetVerboseString. + void SetVerbose(const bool& bVerbose); + bool IsVerbose() const; + + //! Writes into the given stream the verbose messages collected so far. + bool GetVerboseStream(wxOutputStream& destStream) const; + + //! Appends to the given stream the verbose messages collected so far. + bool GetVerboseString(wxString& szStream) const; + + //! Returns a generic, short string describing the last occurred error. + std::string GetErrorString() const; + + //! Returns a short string with a detailed description of last occurred error. + //! This is typically something technical which you may want to hide from the + //! end users of your application (and e.g. show only in log files). + std::string GetDetailedErrorString() const; + + + // Static LibCURL Initialization Methods - Call At Program Init and Close... + + //! Initializes the libCURL. Call this only once at the beginning of your program. + static void Init(); + + //! Clean up libCURL. Call this only once at the end of your program. + static void Shutdown(); + + + // Static LibCURL Utility Methods + + static wxDateTime GetDateFromString(const wxString& szDate); + static std::string GetURLEncodedString(const wxString& szData); + static std::string GetStringFromURLEncoded(const wxString& szData); + + static std::string GetCURLVersion(); + + +protected: // protected utils used by wxCurl*Thread classes + + friend class wxCurlBaseThread; + friend class wxCurlSizeQueryThread; + friend class wxCurlProgressBaseEvent; + + //! Sets a custom callback as the progress callback. + //! Note that using this function you'll break the dispatching of + //! wxCurlDownloadEvent and wxCurlUploadEvent unless your own callback + //! does dispatch the events itself. + //! wxCURL users should never need to use this function. + void OverrideProgressCallback(curl_progress_callback newcallback, void *data) + { m_progressCallback=newcallback; m_progressData=data; } + + //! Returns the time at which started the last transfer "span". + wxDateTime GetBeginTransferSpan() const + { return m_dtBeginTransferSpan; } + + //! Returns the current time offset, i.e. the time elapsed in all previous + //! transfer spans. + wxTimeSpan GetElapsedTimeOffset() const + { return m_tsElapsedOffset; } + + //! A transfer span has been completed (i.e. the user paused the transfer). + void EndTransferSpan() + { + wxDateTime now = wxDateTime::Now(); + m_tsElapsedOffset += now - m_dtBeginTransferSpan; + } + + //! A new transfer span has begun (i.e. the user resumed the transfer). + void BeginTransferSpan() + { + m_dtBeginTransferSpan = wxDateTime::Now(); + } + +protected: + + // The internal pointer to the libCURL session. + CURL* m_pCURL; + // Flag for terminating a possibly hung transfer + bool m_bAbortHungTransfer; + + // libCURL <-> wxString conversions helpers (see below) + + #define wxCURL_BUF2STRING(x) wxString((const char*)(x), wxConvLibc) + +#if wxUSE_UNICODE + #define wxCURL_STRING2BUF(x) ((x).ToAscii()) +#else + #define wxCURL_STRING2BUF(x) wxCharBuffer((x).c_str()) +#endif + + #define wxCURL_BUF_ISEMPTY(x) (strlen(x) == 0) + + + + // VERY IMPORTANT: all these wxCharBuffers are passed to curl_easy_setopt() + // which does not take ownership of them. Thus we need + // to keep them alive here for all the time m_pCURL handle + // is valid. Also note that we don't use wxStrings to store + // them as libCURL always take char* and doesn't like wchar_t* + // and thus we always need wxCharBuffer storage while wxString + // in wxWidgets Unicode builds would use a wxWCharBuffer internally. + // wxCharBuffer is basically a thin class which handles auto-delete + // of a char[] array. + + // basic connection settings: + + wxCharBuffer m_szBaseURL; + wxCharBuffer m_szCurrFullURL; + wxCharBuffer m_szUsername; + wxCharBuffer m_szPassword; + wxCharBuffer m_szUserPass; + + long m_iHostPort; + + // about received headers: + + wxCharBuffer m_szResponseHeader; + wxCharBuffer m_szResponseBody; + long m_iResponseCode; + + // about headers to send: + + wxArrayString m_arrHeaders; + struct curl_slist* m_pHeaders; + + // proxy: + + bool m_bUseProxy; + wxCharBuffer m_szProxyHost; + wxCharBuffer m_szProxyUsername; + wxCharBuffer m_szProxyPassword; + wxCharBuffer m_szProxyUserPass; + long m_iProxyPort; + + // debugging/verbose mode: + + bool m_bVerbose; + wxStringOutputStream m_mosVerbose; + + char m_szDetailedErrorBuffer[CURL_ERROR_SIZE]; + wxCharBuffer m_szLastError; + + // for events: + wxEvtHandler* m_pEvtHandler; + int m_nId; + long m_nFlags; + + // callbacks which can be overridden by the user: + curl_progress_callback m_progressCallback; + void* m_progressData; + + // these two are required in order to be able to support PAUSE/RESUME + // features in wxCurl*Thread classes. In fact, since the pausing happens + // is not directly supported by libCURL needs to happen at wxThread::Entry + // level. This also means that the events which wxCurlBase's callbacks + // post to the event handler cannot trust libCURL's TOTAL_TIME as reported + // by easy_curl_getinfo. Rather we need to keep our own timing mechanism. + // + // It's very simple: a single transfer session may be divided in one or more + // transfer "spans" and idle periods. + // Resuming from idle means start a new transfer span. Pausing means ending + // the current transfer span. + // When a new transfer span starts (from Perform() if it's the first span or + // from BeginTransferSpan when resuming), its beginning is registered into + // m_dtBeginTransferSpan. When a transfer span ends, its length is added to + // the "elapsed time offset" m_tsElapsedOffset. + // This allows wxCurlProgressEvents to calculate the elapsed time just as: + // wxDateTime::Now() - m_dtBeginTransferSpan + m_tsElapsedOffset + wxDateTime m_dtBeginTransferSpan; + wxTimeSpan m_tsElapsedOffset; + + +protected: // internal functions + + // CURL Handle Initialization Helper Method + virtual void SetCurlHandleToDefaults(const wxString& relativeURL); + virtual void SetHeaders(); + virtual void ResetHeaders(); + virtual void ResetResponseVars(); + + // Output additional warnings/errors when in verbose mode. + void DumpErrorIfNeed(CURLcode error) const; + +protected: // specialized safe SetOpt-like functions + + // handy overload for char buffers + bool SetStringOpt(CURLoption option, const wxCharBuffer &str); + + + bool SetStringWriteFunction(const wxCharBuffer& str) + { + bool ret = true; + ret &= SetOpt(CURLOPT_WRITEFUNCTION, wxcurl_string_write); + ret &= SetOpt(CURLOPT_WRITEDATA, (void*)&str); + return ret; + } + + bool SetStreamWriteFunction(const wxOutputStream& buf) + { + bool ret = true; + ret &= SetOpt(CURLOPT_WRITEFUNCTION, wxcurl_stream_write); + ret &= SetOpt(CURLOPT_WRITEDATA, (void*)&buf); + return ret; + } + + bool SetStringReadFunction(const wxCharBuffer& str) + { + bool ret = true; + ret &= SetOpt(CURLOPT_READFUNCTION, wxcurl_string_read); + ret &= SetOpt(CURLOPT_READDATA, (void*)&str); + return ret; + } + + bool SetStreamReadFunction(const wxInputStream& buf) + { + bool ret = true; + ret &= SetOpt(CURLOPT_READFUNCTION, wxcurl_stream_read); + ret &= SetOpt(CURLOPT_READDATA, (void*)&buf); + return ret; + } +}; + +#endif // _WXCURLBASE_H__INCLUDED_ diff --git a/include/wx/curl/dav.h b/include/wx/curl/dav.h new file mode 100644 index 0000000..286cbbe --- /dev/null +++ b/include/wx/curl/dav.h @@ -0,0 +1,78 @@ +/* + * dav.h + * wxCURL + * + * Created by Casey O'Donnell on Wed Jun 02 2004. + * Copyright (c) 2004 Casey O'Donnell. All rights reserved. + * + * Licence: wxWidgets Licence + */ + +// dav.h: interface for the wxCurlDAV class. +// +////////////////////////////////////////////////////////////////////// + +#ifndef _WXCURLDAV_H__INCLUDED_ +#define _WXCURLDAV_H__INCLUDED_ + +#include + +#include +#include +#include +#include +#include + +#include + +class wxXmlNode; + + +//! A specialized interface to WebDAV derived from wxCurlBase. +class WXDLLIMPEXP_CURL wxCurlDAV : public wxCurlHTTP +{ +public: + wxCurlDAV(const wxString& szURL = wxEmptyString, + const wxString& szUserName = wxEmptyString, + const wxString& szPassword = wxEmptyString, + wxEvtHandler* pEvtHandler = NULL, + long flags = wxCURL_DEFAULT_FLAGS); + virtual ~wxCurlDAV(); + + // Action Methods - These All Make Calls To: curl_easy_perform() + + // MKCOL - Creates a Collection Resource at the Location Specified. + bool Mkcol(const wxString& szRemoteCol = wxEmptyString); + + // PROPFIND - Queries the Properties of the Resource Specified. An XML Buffer Can be Specified for Detailed Data. + bool Propfind(const wxString& szRemoteLoc = wxEmptyString); + bool Propfind(const wxArrayString& arrTags, const wxString& szRemoteLoc = wxEmptyString); + bool Propfind(const char* buffer, size_t size, const wxString& szRemoteLoc = wxEmptyString); + bool Propfind(wxInputStream& buffer, const wxString& szRemoteLoc = wxEmptyString); + + // PROPATCH - Alters the Properties of the Resource Specified. An XML Buffer Must be Specified to Modify Data. + bool Proppatch(const char* buffer, size_t size, const wxString& szRemoteLoc = wxEmptyString); + bool Proppatch(wxInputStream& buffer, const wxString& szRemoteLoc = wxEmptyString); + + // COPY - Copies the Specified Resource from one Location to Another. + bool Copy(const wxString& szRemoteLocDest, const bool& bOverwrite = true, const wxString& szRemoteLocSrc = wxEmptyString); + + // MOVE - Moves the Specified Resource from one Location to Another. + bool Move(const wxString& szRemoteLocDest, const bool& bOverwrite = true, const wxString& szRemoteLocSrc = wxEmptyString); + + // LOCK - Requests a Lock on the Specified Resource. + bool Lock(const wxString& szRemotLoc = wxEmptyString); + + // UNLOCk - Gives up a Lock on the Specified Resource. + bool Unlock(const wxString& szRemoteLoc = wxEmptyString); + +protected: + + // XML Helper Methods + virtual wxString ConstructPropfindXml(const wxArrayString& arrTags); + +private: + +}; + +#endif // _WXCURLDAV_H__INCLUDED_ diff --git a/include/wx/curl/davtool.h b/include/wx/curl/davtool.h new file mode 100644 index 0000000..3c5b9cf --- /dev/null +++ b/include/wx/curl/davtool.h @@ -0,0 +1,108 @@ +/* + * davtool.h + * wxCURL + * + * Created by Casey O'Donnell on Thu Jul 15 2004. + * Copyright (c) 2004 Casey O'Donnell. All rights reserved. + * + * Licence: wxWidgets Licence + */ + +// wxCurlDAVTool.h +// +////////////////////////////////////////////////////////////////////// + +#ifndef _WXCURLDAVTOOL_H__INCLUDED_ +#define _WXCURLDAVTOOL_H__INCLUDED_ + +#include + +// davtool.h: interface for the wxCurlDAVFs class. +// +////////////////////////////////////////////////////////////////////// + +class wxCurlDAVTool; + +class WXDLLIMPEXP_CURL wxCurlDAVFs +{ +friend class wxCurlDAVTool; + +public: + wxCurlDAVFs(); + wxCurlDAVFs(const wxString& szHREF , + const wxString& szStatus , + const wxString& szCreationDate , + const wxString& szLastModified , + const long& iContentLength , + const wxString& szContentType ); + ~wxCurlDAVFs(); + + bool IsDirectory() const { return m_szContentType == wxS("httpd/unix-directory"); } + bool IsOK() const { return m_szStatus.Right(6) == wxS("200 OK"); } + + wxString GetHREF() const { return m_szHREF; } + + wxString GetStatus() const { return m_szStatus; } + + wxDateTime GetCreationDate() const { return m_dtCreationDate; } + wxDateTime GetLastModified() const { return m_dtLastModified; } + + long GetContentLength() const { return m_iContentLength; } + + wxString GetContentType() const { return m_szContentType; } + wxString GetType() const { return m_szContentType.BeforeFirst('/'); } + wxString GetSubType() const { return m_szContentType.AfterLast('/'); } + + +protected: + wxString m_szHREF; + + wxString m_szStatus; + + wxDateTime m_dtCreationDate; + wxDateTime m_dtLastModified; + + long m_iContentLength; + + wxString m_szContentType; +}; + +WX_DECLARE_USER_EXPORTED_OBJARRAY(wxCurlDAVFs, wxArrayDAVFs, WXDLLIMPEXP_CURL); + +// davtool.h: interface for the wxCurlDAVTool class. +// +////////////////////////////////////////////////////////////////////// + +class WXDLLIMPEXP_CURL wxCurlDAVTool : public wxCurlDAV +{ +public: + wxCurlDAVTool(const wxString& szURL = wxEmptyString, + const wxString& szUserName = wxEmptyString, + const wxString& szPassword = wxEmptyString, + wxEvtHandler* pEvtHandler = NULL, + long flags = wxCURL_DEFAULT_FLAGS); + virtual ~wxCurlDAVTool(); + + // More Complex Action Methods - These All Make Calls To: curl_easy_perform() + // These routines have more 'intelligence' than simple WebDAV calls. + bool GetDAVFs(wxArrayDAVFs& fs, const wxString& szRemoteLoc = wxEmptyString); + bool Exists(const wxString& szRemoteLoc = wxEmptyString); + bool IsDirectory(const wxString& szRemoteLoc = wxEmptyString); + bool HasDirectory(const wxString& szRemoteLoc = wxEmptyString) { return IsDirectory(szRemoteLoc); } + bool IsOk(const wxString& szRemoteLoc = wxEmptyString); + wxDateTime GetLastModified(const wxString& szRemoteLoc = wxEmptyString); + wxDateTime GetCreationDate(const wxString& szRemoteLoc = wxEmptyString); + long GetContentLength(const wxString& szRemoteLoc = wxEmptyString); + wxString GetContentType(const wxString& szRemoteLoc = wxEmptyString); + +protected: + + // XML Helper Methods + bool ParseResponseXml(wxCurlDAVFs& fsItem, wxXmlNode* pNode); + bool ParsePropstatXml(wxCurlDAVFs& fsItem, wxXmlNode* pNode); + bool ParsePropsXml(wxCurlDAVFs& fsItem, wxXmlNode* pNode); + +private: +}; + +#endif // _WXCURLDAVTOOL_H__INCLUDED_ diff --git a/include/wx/curl/dialog.h b/include/wx/curl/dialog.h new file mode 100644 index 0000000..7c454b6 --- /dev/null +++ b/include/wx/curl/dialog.h @@ -0,0 +1,328 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: dialog.h +// Purpose: wxCurlDownloadDialog, wxCurlUploadDialog +// Author: Francesco Montorsi +// Created: 2007/04/14 +// RCS-ID: $Id: dialog.h 1240 2010-03-10 23:54:25Z frm $ +// Copyright: (c) 2007 Francesco Montorsi +// Licence: wxWidgets licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WXCURL_DIALOG_H_ +#define _WXCURL_DIALOG_H_ + +#include "wx/dialog.h" +#include "wx/curl/thread.h" +#include "wx/curl/panel.h" + +// forward declarations +//class WXDLLIMPEXP_CORE wxStaticText; +//class WXDLLIMPEXP_CORE wxTextCtrl; +//class WXDLLIMPEXP_CORE wxGauge; +//class WXDLLIMPEXP_CORE wxStaticBitmap; + + +//! Possible wxCurlTransferDialog styles. +enum wxCurlTransferDialogStyle +{ + wxCTDS_ELAPSED_TIME = 0x0001, //!< The dialog shows the elapsed time. + wxCTDS_ESTIMATED_TIME = 0x0002, //!< The dialog shows the estimated total time. + wxCTDS_REMAINING_TIME = 0x0004, //!< The dialog shows the remaining time. + wxCTDS_SPEED = 0x0008, //!< The dialog shows the transfer speed. + wxCTDS_SIZE = 0x0010, //!< The dialog shows the size of the resource to download/upload. + wxCTDS_URL = 0x0020, //!< The dialog shows the URL involved in the transfer. + + // styles related to the use of wxCurlConnectionSettingsDialog: + + wxCTDS_CONN_SETTINGS_AUTH = 0x0040, //!< The dialog allows the user to change the authentication settings. + wxCTDS_CONN_SETTINGS_PORT = 0x0080, //!< The dialog allows the user to change the port for the transfer. + wxCTDS_CONN_SETTINGS_PROXY = 0x0100, //!< The dialog allows the user to change the proxy settings. + + wxCTDS_CONN_SETTINGS_ALL = wxCTDS_CONN_SETTINGS_AUTH|wxCTDS_CONN_SETTINGS_PORT|wxCTDS_CONN_SETTINGS_PROXY, + + wxCTDS_SHOW_ALL = wxCTDS_ELAPSED_TIME|wxCTDS_ESTIMATED_TIME|wxCTDS_REMAINING_TIME| + wxCTDS_SPEED|wxCTDS_SIZE|wxCTDS_URL|wxCTDS_CONN_SETTINGS_ALL, + + wxCTDS_CAN_ABORT = 0x0200, //!< The transfer can be aborted by the user. + wxCTDS_CAN_START = 0x0400, //!< The transfer won't start automatically. The user needs to start it. + wxCTDS_CAN_PAUSE = 0x0800, //!< The transfer can be paused. + + wxCTDS_AUTO_CLOSE = 0x1000, //!< The dialog auto closes when transfer is complete. + + // by default all available features are enabled: + wxCTDS_DEFAULT_STYLE = wxCTDS_CAN_START|wxCTDS_CAN_PAUSE|wxCTDS_CAN_ABORT|wxCTDS_SHOW_ALL|wxCTDS_AUTO_CLOSE +}; + +//! The return flag of . +enum wxCurlDialogReturnFlag +{ + wxCDRF_SUCCESS, //!< Download successfully completed. + wxCDRF_USER_ABORTED, //!< User aborted the download. + wxCDRF_FAILED //!< Invalid URL / other networking problem happened. +}; + + +// ---------------------------------------------------------------------------- +// wxCurlTransferDialog +// ---------------------------------------------------------------------------- + +//! The base class for wxCurlDownloadDialog and wxCurlUploadDialog. +class WXDLLIMPEXP_CURL wxCurlTransferDialog : public wxDialog +{ +public: + wxCurlTransferDialog() + { + m_bTransferComplete = false; +#ifdef __WXDEBUG__ + m_bVerbose = true; +#else + m_bVerbose = false; +#endif + + // some of these may remain NULL: + m_pElapsedTime = m_pEstimatedTime = m_pRemainingTime = NULL; + m_pSpeed = m_pSize = NULL; + m_pBitmap = NULL; + m_pURL = NULL; + m_pGauge = NULL; + m_pLastEvent = NULL; + m_pThread = NULL; + m_nStyle = 0; + } + + bool Create(const wxString &url, + const wxString& title, + const wxString& message = wxEmptyString, + const wxString& sizeLabel = _("Transferred:"), + const wxBitmap& bitmap = wxNullBitmap, + wxWindow *parent = NULL, + long style = wxCTDS_DEFAULT_STYLE); + + ~wxCurlTransferDialog() + { + wxDELETE(m_pLastEvent); + wxDELETE(m_pThread); + } + + + //! Shows the dialog as modal. If the wxCTDS_CAN_START flag was not given, + //! then the transfer starts automatically. + //! Note that you should use this function instead of wxDialog::ShowModal(). + wxCurlDialogReturnFlag RunModal(); + +/* not yet tested + //! Shows the dialog as modeless. + bool Show(const bool show); +*/ + + //! Returns true if the creation of the dialog was successful. + bool IsOk() const { return m_pThread != NULL && m_pThread->IsOk(); } + + //! Returns the exit code of the dialog (call after #RunModal). + virtual wxCurlDialogReturnFlag GetReturnCode() const + { return (wxCurlDialogReturnFlag)wxDialog::GetReturnCode(); } + + //! Sets the internal wxCurlBase object to be verbose. + void SetVerbose(bool enable) + { m_bVerbose=enable; } + + //! Returns true if the internal wxCurlBase is verbose (on by default in debug builds). + bool IsVerbose() const + { return m_bVerbose; } + + virtual void EndModal(int retCode); + +protected: // internal utils + + + wxStaticText *AddSizerRow(wxSizer *sz, const wxString &name); + void CreateControls(const wxString &url, const wxString &msg, + const wxString& sizeLabel, const wxBitmap &bitmap); + void UpdateLabels(wxCurlProgressBaseEvent *ev); + + // returns true if the error can be ignored + bool HandleCurlThreadError(wxCurlThreadError err, wxCurlBaseThread *p, + const wxString &url = wxEmptyString); + + bool HasFlag(wxCurlTransferDialogStyle flag) const + { return (m_nStyle & flag) != 0; } + + + // change access policy: + + virtual int ShowModal() + { return wxDialog::ShowModal(); } + + virtual void SetReturnCode(wxCurlDialogReturnFlag ret) + { wxDialog::SetReturnCode(ret); } + +public: // event handlers + + void OnEndPerform(wxCurlEndPerformEvent &); + + void OnAbort(wxCommandEvent &); + void OnConnSettings(wxCommandEvent &); + void OnPauseResume(wxCommandEvent &); + void OnStart(wxCommandEvent &); + + void OnAbortUpdateUI(wxUpdateUIEvent &); + void OnConnSettingsUpdateUI(wxUpdateUIEvent &); + void OnStartUpdateUI(wxUpdateUIEvent &); + void OnPauseResumeUpdateUI(wxUpdateUIEvent &); + + void OnClose(wxCloseEvent &ev); + +protected: + + wxCurlBaseThread *m_pThread; + wxCurlProgressBaseEvent *m_pLastEvent; + bool m_bTransferComplete; + + // wxWindow's style member is too small for all our flags and wxWindow/wxDialog ones. + // So we use our own... + long m_nStyle; + + // should we be verbose? + bool m_bVerbose; + +protected: // controls + + wxStaticText* m_pURL; + wxStaticText* m_pSpeed; + wxStaticText* m_pSize; + wxGauge* m_pGauge; + wxStaticBitmap* m_pBitmap; + + wxStaticText* m_pElapsedTime; + wxStaticText* m_pRemainingTime; + wxStaticText* m_pEstimatedTime; + +private: + DECLARE_EVENT_TABLE() +}; + + +// ---------------------------------------------------------------------------- +// wxCurlDownloadDialog +// ---------------------------------------------------------------------------- + +//! An highly-configurable dialog which shows progress about a download. +class WXDLLIMPEXP_CURL wxCurlDownloadDialog : public wxCurlTransferDialog +{ +public: + wxCurlDownloadDialog() { } + + wxCurlDownloadDialog(const wxString &url, + wxOutputStream *out, + const wxString& title = wxS("Downloading..."), + const wxString& message = wxEmptyString, + const wxBitmap& bitmap = wxNullBitmap, + wxWindow *parent = NULL, + long style = wxCTDS_DEFAULT_STYLE) + { Create(url, out, title, message, bitmap, parent, style); } + + bool Create(const wxString &url, + wxOutputStream *out, + const wxString& title = wxS("Downloading..."), + const wxString& message = wxEmptyString, + const wxBitmap& bitmap = wxNullBitmap, + wxWindow *parent = NULL, + long style = wxCTDS_DEFAULT_STYLE); + + //! Returns the output stream where data has been downloaded. + //! This function can be used only when the download has been completed. + wxOutputStream *GetOutputStream() const + { return wx_static_cast(wxCurlDownloadThread*, m_pThread)->GetOutputStream(); } + +public: // event handlers + + void OnDownload(wxCurlDownloadEvent &); + +private: + DECLARE_EVENT_TABLE() + DECLARE_DYNAMIC_CLASS(wxCurlDownloadDialog) +}; + + +// ---------------------------------------------------------------------------- +// wxCurlUploadDialog +// ---------------------------------------------------------------------------- + +//! An highly-configurable dialog which shows progress about an upload. +class WXDLLIMPEXP_CURL wxCurlUploadDialog : public wxCurlTransferDialog +{ +public: + wxCurlUploadDialog() { } + + wxCurlUploadDialog(const wxString &url, + wxInputStream *in, + const wxString& title = wxS("Uploading..."), + const wxString& message = wxEmptyString, + const wxBitmap& bitmap = wxNullBitmap, + wxWindow *parent = NULL, + long style = wxCTDS_DEFAULT_STYLE) + { Create(url, in, title, message, bitmap, parent, style); } + + bool Create(const wxString &url, + wxInputStream *in, + const wxString& title = wxS("Uploading..."), + const wxString& message = wxEmptyString, + const wxBitmap& bitmap = wxNullBitmap, + wxWindow *parent = NULL, + long style = wxCTDS_DEFAULT_STYLE); + + +public: // event handlers + + void OnUpload(wxCurlUploadEvent &); + +private: + DECLARE_EVENT_TABLE() + DECLARE_DYNAMIC_CLASS(wxCurlUploadDialog) +}; + + +// ---------------------------------------------------------------------------- +// wxCurlConnectionSettingsDialog +// ---------------------------------------------------------------------------- + +//! A dialog which simply wraps a wxCurlConnectionSettingsPanel. +//! For a list of supported styles, please see wxCurlConnectionSettingsPanel. +class WXDLLIMPEXP_CURL wxCurlConnectionSettingsDialog : public wxDialog +{ +public: + wxCurlConnectionSettingsDialog() { m_pPanel = NULL; } + + wxCurlConnectionSettingsDialog(const wxString& title, + const wxString& message = wxEmptyString, + wxWindow *parent = NULL, + long style = wxCCSP_DEFAULT_STYLE) + { Create(title, message, parent, style); } + + bool Create(const wxString& title = wxS("Connection settings..."), + const wxString& message = wxEmptyString, + wxWindow *parent = NULL, + long style = wxCCSP_DEFAULT_STYLE); + +public: + + //! Runs this dialog as modal and updates the given wxCurlBase instance if needed + //! (i.e. if the user hits OK and not Cancel). + void RunModal(wxCurlBase *pcurl); + +protected: + + wxCurlConnectionSettingsPanel *m_pPanel; + + // change access policy: + + virtual int ShowModal() + { return wxDialog::ShowModal(); } + +private: + DECLARE_DYNAMIC_CLASS(wxCurlConnectionSettingsDialog) +}; + + +#endif // _WXCURL_DIALOG_H_ + diff --git a/include/wx/curl/ftp.h b/include/wx/curl/ftp.h new file mode 100644 index 0000000..aa44694 --- /dev/null +++ b/include/wx/curl/ftp.h @@ -0,0 +1,156 @@ +/* + * ftp.h + * wxCURL + * + * Created by Casey O'Donnell on Tue Jun 29 2004. + * Copyright (c) 2004 Casey O'Donnell. All rights reserved. + * + * Licence: wxWidgets Licence + */ + +#ifndef _WXCURLFTP_H__INCLUDED_ +#define _WXCURLFTP_H__INCLUDED_ + +#include + +// C Function Declarations for LibCURL +// +////////////////////////////////////////////////////////////////////// + +extern "C" +{ +} + +// ftp.h: interface for the wxCurlFTP class. +// +////////////////////////////////////////////////////////////////////// + +//! A specialized interface to FTP derived from wxCurlBase. +class WXDLLIMPEXP_CURL wxCurlFTP : public wxCurlBase +{ +public: + enum TransferMode + { + kASCII, + kBINARY + }; + + wxCurlFTP(const wxString& szURL = wxEmptyString, + const wxString& szUserName = wxEmptyString, + const wxString& szPassword = wxEmptyString, + wxEvtHandler* pEvtHandler = NULL, int id = wxID_ANY, + long flags = wxCURL_DEFAULT_FLAGS); + virtual ~wxCurlFTP(); + + // Member Data Access Methods (MDA) + + // MDA - Get/Set Transfer Mode + void SetTransferMode(const TransferMode& tmMode); + TransferMode GetTransferMode() const; + + void SetToBinary(); + void SetToAscii(); + + bool IsAscii() const; + bool IsBinary() const; + + // MDA - Get/Set PORT Options + void UsePortOption(const bool& bUsePort); + bool UsePortOption() const; + + void SetPortParam(const wxString& szParam = wxS("-")); + wxString GetPortParam() const; + + // MDA - Get/Set EPRT Use + void UseEPRT(const bool& bUseEPRT); + bool UseEPRT() const; + + // MDA - Get/Set EPSV Use + void UseEPSV(const bool& bUseEPSV); + bool UseEPSV() const; + + // MDA - Get/Set Append Setting + void AppendOnUpload(const bool& bAppend); + bool AppendOnUpload() const; + + // MDA - Get/Set Create Missing Dirs Setting + void CreateMissingDirs(const bool& bCreateMissing); + bool CreateMissingDirs() const; + + // MDA - Set Quote Strings + bool SetQuoteList(const wxArrayString& arrQuote); + bool AppendQuote(const wxString& szQuote, const bool& bClear = false); + + // MDA - Set Pre Quote Strings + bool SetPreQuoteList(const wxArrayString& arrQuote); + bool AppendPreQuote(const wxString& szQuote, const bool& bClear = false); + + // MDA - Set Post Quote Strings + bool SetPostQuoteList(const wxArrayString& arrQuote); + bool AppendPostQuote(const wxString& szQuote, const bool& bClear = false); + + // Action Methods - These All Make Calls To: curl_easy_perform() + + // GET - These Methods Allow a Caller to Retrieve a Given Resource + bool Get(const wxString& szFilePath, const wxString& szRemoteFile = wxEmptyString); + size_t Get(char*& buffer, const wxString& szRemoteFile = wxEmptyString); + bool Get(wxOutputStream& buffer, const wxString& szRemoteFile = wxEmptyString); + + // PUT - These Methods Allow a Caller to Place a Resource on the Host + bool Put(const wxString& szFilePath, const wxString& szRemoteFile = wxEmptyString); + bool Put(const char* buffer, size_t size, const wxString& szRemoteFile = wxEmptyString); + bool Put(wxInputStream& buffer, const wxString& szRemoteFile = wxEmptyString); + + // MKDIR - This Method Allows a Caller to Create a Directory + bool MkDir(const wxString& szRemoteLoc = wxEmptyString); + + // RMDIR - This Method Allows a Caller to Remove a Directory + bool RmDir(const wxString& szRemoteLoc = wxEmptyString); + + // DELETE - This Method Allows a Caller to Remove a Resource + bool Delete(const wxString& szRemoteLoc = wxEmptyString); + + // RENAME - This Method Allows a Caller to Rename a Resource + bool Rename(const wxString& szRemoteLocName, const wxString& szRemoteFile = wxEmptyString); + + // LIST - This Method Allows a Caller to Retrieve the Contents of a Resource + bool List(const wxString& szRemoteLoc = wxEmptyString); + bool Nlst(const wxString& szRemoteLoc = wxEmptyString); + + // INFO - This Method Allows a Caller to Retrieve Information Regarding a Resource + bool Info(const wxString& szRemoteLoc = wxEmptyString); + +protected: + + virtual void SetCurlHandleToDefaults(const wxString& relativeURL); + virtual void SetCurlHandleQuoteOpts(); + + void ResetAllQuoteLists(); + void ResetQuoteList(); + void ResetPreQuoteList(); + void ResetPostQuoteList(); + + struct curl_slist* m_pQuote; + struct curl_slist* m_pPreQuote; + struct curl_slist* m_pPostQuote; + + wxString m_szCurrFullPath; + wxString m_szCurrFilename; + + bool m_bCreateMissingDirs; + + bool m_bAppend; + bool m_bUsePortOption; + + TransferMode m_tmMode; + + bool m_bUseEPRT; + bool m_bUseEPSV; + + wxCharBuffer m_szPortParam; + +private: + +}; + +#endif // _WXCURLFTP_H__INCLUDED_ diff --git a/include/wx/curl/ftptool.h b/include/wx/curl/ftptool.h new file mode 100644 index 0000000..c522ce7 --- /dev/null +++ b/include/wx/curl/ftptool.h @@ -0,0 +1,98 @@ +/* + * ftptool.h + * wxCURL + * + * Created by Casey O'Donnell on Fri Aug 13 2004. + * Copyright (c) 2004 Casey O'Donnell. All rights reserved. + * + * Licence: wxWidgets Licence + */ + +#ifndef _WXCURLFTPTOOL_H__INCLUDED_ +#define _WXCURLFTPTOOL_H__INCLUDED_ + +#include + +// C Function Declarations for LibCURL +// +////////////////////////////////////////////////////////////////////// + +extern "C" +{ +} + +// ftptool.h: interface for the wxCurlFTPFs class. +// +////////////////////////////////////////////////////////////////////// + +class wxCurlFTPTool; + +class WXDLLIMPEXP_CURL wxCurlFTPFs +{ + friend class wxCurlFTPTool; + +public: + wxCurlFTPFs(); + wxCurlFTPFs(const wxString& szName , + const bool& bIsDir , + const bool& bIsFile , + const time_t& tLastModified , + const long& iContentLength ); + ~wxCurlFTPFs(); + + bool IsDirectory() const { return m_bIsDir; } + bool IsFile() const { return m_bIsFile; } + + wxString GetName() const { return m_szName; } + + wxDateTime GetLastModified() const { return m_dtLastModified; } + + long GetContentLength() const { return m_iContentLength; } + + wxString GetFileSuffix() const { return m_szName.AfterLast('.'); } + + +protected: + wxString m_szName; + + bool m_bIsDir; + bool m_bIsFile; + + wxDateTime m_dtLastModified; + + long m_iContentLength; +}; + +WX_DECLARE_USER_EXPORTED_OBJARRAY(wxCurlFTPFs, wxArrayFTPFs, WXDLLIMPEXP_CURL); + +// ftptool.h: interface for the wxCurlFTPTool class. +// +////////////////////////////////////////////////////////////////////// + +class WXDLLIMPEXP_CURL wxCurlFTPTool : public wxCurlFTP +{ +public: + wxCurlFTPTool(const wxString& szURL = wxEmptyString, + const wxString& szUserName = wxEmptyString, + const wxString& szPassword = wxEmptyString, + wxEvtHandler* pEvtHandler = NULL, int id = wxID_ANY, + long flags = wxCURL_DEFAULT_FLAGS); + virtual ~wxCurlFTPTool(); + + // More Complex Action Methods - These All Make Calls To: curl_easy_perform() + // These routines have more 'intelligence' than simple FTP calls. + bool GetFTPFs(wxArrayFTPFs& fs, const wxString& szRemoteLoc = wxEmptyString); + bool Exists(const wxString& szRemoteLoc = wxEmptyString); + bool IsDirectory(const wxString& szRemoteLoc = wxEmptyString); + bool HasDirectory(const wxString& szRemoteLoc = wxEmptyString) { return IsDirectory(szRemoteLoc); } + wxDateTime GetLastModified(const wxString& szRemoteLoc = wxEmptyString); + long GetContentLength(const wxString& szRemoteLoc = wxEmptyString); + wxString GetFileSuffix(const wxString& szRemoteLoc = wxEmptyString); + +protected: + +private: + +}; + +#endif // _WXCURLFTPTOOL_H__INCLUDED_ diff --git a/include/wx/curl/http.h b/include/wx/curl/http.h new file mode 100644 index 0000000..0c9e535 --- /dev/null +++ b/include/wx/curl/http.h @@ -0,0 +1,105 @@ +/* +* http.h +* wxCURL +* +* Created by Casey O'Donnell on Tue Jun 29 2004. +* Copyright (c) 2004 Casey O'Donnell. All rights reserved. +* +* Licence: wxWidgets Licence +*/ + +#ifndef _WXCURLHTTP_H__INCLUDED_ +#define _WXCURLHTTP_H__INCLUDED_ + +#include + +// C Function Declarations for LibCURL +// +////////////////////////////////////////////////////////////////////// + +extern "C" +{ +} + +// http.h: interface for the wxCurlHTTP class. +// +////////////////////////////////////////////////////////////////////// + +//! A specialized interface to HTTP derived from wxCurlBase. +class WXDLLIMPEXP_CURL wxCurlHTTP : public wxCurlBase +{ +public: + wxCurlHTTP(const wxString& szURL = wxEmptyString, + const wxString& szUserName = wxEmptyString, + const wxString& szPassword = wxEmptyString, + wxEvtHandler* pEvtHandler = NULL, int id = wxID_ANY, + long flags = wxCURL_DEFAULT_FLAGS); + virtual ~wxCurlHTTP(); + + // Post Data Methods + bool AddForm(const bool& bClear, const wxString& szName, + struct curl_forms* pForms, CURLFORMcode* outErr=NULL); + bool AddBufferToForm(const bool& bClear, const wxString& szName, + char* buffer, size_t len, CURLFORMcode* outErr=NULL); + + // Member Data Access Methods (MDA) + + // MDA - Get/Set Cookie Use + void UseCookies(const bool& bUseCookies); + bool UseCookies() const; + + // MDA - Get/Set Cookie File + void SetCookieFile(const wxString& szFilePath); + wxString GetCookieFile() const; + + // Action Methods - These All Make Calls To: curl_easy_perform() + + // OPTIONS - This Method Allows a Caller to Query the Capabilities of a Resource + bool Options(const wxString& szRemoteFile = wxEmptyString); + + // HEAD - This Method is Similar to GET, Though no Message Body is Retrieved + bool Head(const wxString& szRemoteFile = wxEmptyString); + + // POST - These Methods Post Data Passed In + bool Post(const char* buffer, size_t size, const wxString& szRemoteFile = wxEmptyString); + bool Post(wxInputStream& buffer, const wxString& szRemoteFile = wxEmptyString); + + // POST - This Method Uses Data As Defined By AddForm(...) + bool Post(const wxString& szRemoteFile = wxEmptyString); + + // TRACE - This Method Allows a Caller to Perform Diagnostic Tests + bool Trace(const wxString& szRemoteFile = wxEmptyString); + + // GET - These Methods Allow a Caller to Retrieve a Given Resource + bool Get(const wxString& szFilePath, const wxString& szRemoteFile = wxEmptyString); + size_t Get(char*& buffer, const wxString& szRemoteFile = wxEmptyString); + bool Get(wxOutputStream& buffer, const wxString& szRemoteFile = wxEmptyString); + + // PUT - These Methods Allow a Caller to Place a Resource on the Host + bool Put(const wxString& szFilePath, const wxString& szRemoteFile = wxEmptyString); + bool Put(const char* buffer, size_t size, const wxString& szRemoteFile = wxEmptyString); + bool Put(wxInputStream& buffer, const wxString& szRemoteFile = wxEmptyString); + + // DELETE - This Method Allows a Caller to Remove a Resource + bool Delete(const wxString& szRemoteLoc = wxEmptyString); + +protected: + + virtual void ResetPostData(); + virtual void SetCurlHandleToDefaults(const wxString& relativeURL); + + bool IsResponseOk() const; + + + struct curl_httppost* m_pPostHead; + struct curl_httppost* m_pPostTail; + + bool m_bUseCookies; + + wxCharBuffer m_szCookieFile; + + const char* m_pszPostFieldsData; + size_t m_iPostDataSize; +}; + +#endif // _WXCURLHTTP_H__INCLUDED_ diff --git a/include/wx/curl/panel.h b/include/wx/curl/panel.h new file mode 100644 index 0000000..ed458f8 --- /dev/null +++ b/include/wx/curl/panel.h @@ -0,0 +1,101 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: panel.h +// Purpose: wxCurlConnectionSettingsPanel +// Author: Francesco Montorsi +// Created: 2007/05/5 +// RCS-ID: $Id: panel.h 1237 2010-03-10 21:52:47Z frm $ +// Copyright: (c) 2007 Francesco Montorsi +// Licence: wxWidgets licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WXCURL_PANEL_H_ +#define _WXCURL_PANEL_H_ + +#include "wx/panel.h" +#include "wx/curl/base.h" + +// forward declarations +//class WXDLLIMPEXP_CORE wxStaticText; +//class WXDLLIMPEXP_CORE wxTextCtrl; +//class WXDLLIMPEXP_CORE wxCheckBox; +//class WXDLLIMPEXP_CORE wxStaticBitmap; + +// ---------------------------------------------------------------------------- +// wxCurlConnectionSettingsPanel +// ---------------------------------------------------------------------------- + +//! Possible wxCurlConnectionSettingsPanel styles. +enum +{ + wxCCSP_PROXY_OPTIONS = 0x0040, //!< Shows the proxy options. + wxCCSP_AUTHENTICATION_OPTIONS = 0x0080, //!< Shows username&password fields. + wxCCSP_PORT_OPTION = 0x0100, //!< Shows the port option. + + wxCCSP_DEFAULT_STYLE = wxCCSP_PROXY_OPTIONS|wxCCSP_AUTHENTICATION_OPTIONS|wxCCSP_PORT_OPTION +}; + +//! A configurable panel which shows connection settings which can be +//! modified by the user (whose changes will be reflected on a libCURL handle, +//! i.e. on the wxCurlBase class passed to #SetCURLOptions). +class WXDLLIMPEXP_CURL wxCurlConnectionSettingsPanel : public wxPanel +{ +public: + wxCurlConnectionSettingsPanel() + { + m_pUsername = NULL; + m_pPassword = NULL; + m_pPort = NULL; + + m_pProxyCheckBox = NULL; + m_pProxyHost = NULL; + m_pProxyUsername = NULL; + m_pProxyPassword = NULL; + m_pProxyPort = NULL; + } + + wxCurlConnectionSettingsPanel(wxWindow* parent, wxWindowID id = wxID_ANY, + const wxString &msg = wxEmptyString, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = wxCCSP_DEFAULT_STYLE, + const wxString& name = wxS("connsettingspanel")) + { Create(parent, id, msg, pos, size, style, name); } + + bool Create(wxWindow* parent, wxWindowID id = wxID_ANY, const wxString &msg = wxEmptyString, + const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, + long style = wxCCSP_DEFAULT_STYLE, const wxString& name = wxS("connsettingspanel")); + + + //! Sets all user-defined options of this panel into the given curl object. + void SetCURLOptions(wxCurlBase *); + + +public: // event handlers + + void OnUseProxy(wxCommandEvent &ev); + +protected: // utils + + wxTextCtrl *AddSizerRow(wxSizer *sz, const wxString &name, bool grow = true); + void CreateControls(const wxString &msg); + +protected: // controls + + wxTextCtrl* m_pUsername; + wxTextCtrl* m_pPassword; + wxTextCtrl* m_pPort; + + wxCheckBox* m_pProxyCheckBox; + wxTextCtrl* m_pProxyHost; + wxTextCtrl* m_pProxyUsername; + wxTextCtrl* m_pProxyPassword; + wxTextCtrl* m_pProxyPort; + +private: + DECLARE_EVENT_TABLE() + DECLARE_DYNAMIC_CLASS(wxCurlConnectionSettingsPanel) +}; + + +#endif // _WXCURL_PANEL_H_ + diff --git a/include/wx/curl/telnet.h b/include/wx/curl/telnet.h new file mode 100644 index 0000000..939423d --- /dev/null +++ b/include/wx/curl/telnet.h @@ -0,0 +1,28 @@ +/* + * telnet.h + * wxCURL + * + * Created by Casey O'Donnell on Tue Jun 29 2004. + * Copyright (c) 2004 Casey O'Donnell. All rights reserved. + * + * Licence: wxWidgets Licence + */ + +// wxCurlTelnet.h: interface for the wxCurlTelnet class. +// +////////////////////////////////////////////////////////////////////// + +#ifndef _WXCURLTELNET_H__INCLUDED_ +#define _WXCURLTELNET_H__INCLUDED_ + +#include + +//! A specialized interface to TELNET derived from wxCurlBase. +class WXDLLIMPEXP_CURL wxCurlTelnet : public wxCurlBase +{ +public: + wxCurlTelnet(); + virtual ~wxCurlTelnet(); +}; + +#endif // _WXCURLTELNET_H__INCLUDED_ diff --git a/include/wx/curl/thread.h b/include/wx/curl/thread.h new file mode 100644 index 0000000..a0496b8 --- /dev/null +++ b/include/wx/curl/thread.h @@ -0,0 +1,390 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: thread.h +// Purpose: wxCurlDownloadThread, wxCurlUploadThread +// Author: Francesco Montorsi +// Created: 2007/04/14 +// RCS-ID: $Id: thread.h 1237 2010-03-10 21:52:47Z frm $ +// Copyright: (c) 2007 Francesco Montorsi +// Licence: wxWidgets licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WXCURL_THREAD_H_ +#define _WXCURL_THREAD_H_ + +// wxWidgets headers +#include "wx/defs.h" +#include "wx/thread.h" + +#include "wx/curl/base.h" + + +//! One of the protocols supported by wxCurl. +enum wxCurlProtocol +{ + wxCP_INVALID = -1, + + wxCP_HTTP, + wxCP_FTP +}; + +//! One of the possible errors code returned by wxCurl. +enum wxCurlThreadError +{ + wxCTE_NO_ERROR = wxTHREAD_NO_ERROR, //!< There was no error. + + wxCTE_NO_RESOURCE = wxTHREAD_NO_RESOURCE, //!< There were insufficient resources to create a new thread. + wxCTE_ALREADY_RUNNING = wxTHREAD_RUNNING, //!< The thread is already running. + wxCTE_INVALID_PROTOCOL, //!< The given URL requires an unspported protocol. + wxCTE_NO_VALID_STREAM, //!< The input/output stream could not be created or is invalid. + wxCTE_ABORTED, //!< The thread was user-aborted through wxCurlBaseThread::Abort(). + wxCTE_CURL_ERROR + //!< LibCURL failed. You can use thread->GetCurlSession()->GetErrorString() to get more info. +}; + +//! The stack size for wxCurl threads. +#define wxCURL_THREAD_STACK_SIZE 2048 + + +// ---------------------------------------------------------------------------- +// wxCurlBaseThread +// ---------------------------------------------------------------------------- + +//! Base class for wxCurl threads. +class WXDLLIMPEXP_CURL wxCurlBaseThread : public wxThread +{ +protected: + + //! The URL identifying the resource to download/upload. + wxString m_url; + + //! The libcurl handle being used for the transfer. + wxCurlBase *m_pCurl; + + //! The protocol being used for the transfer. + wxCurlProtocol m_protocol; + + //! The event handler which gets m_pCurl's events. + wxEvtHandler *m_pHandler; + int m_nId; + + //! This flag is set to true when the thread has been cancelled using Delete(). + //! Since it's continuosly read by the running thread and maybe written from + //! other threads, it needs a mutex. + bool m_bAbort; + wxMutex m_bAbortMutex; + +public: + wxCurlBaseThread(wxEvtHandler *handler = NULL, + int id = wxID_ANY) + : wxThread(wxTHREAD_JOINABLE) + { + m_protocol = wxCP_INVALID; + m_pCurl = NULL; + + m_nId = id; + m_pHandler = handler; + + m_bAbort = false; + } + + ~wxCurlBaseThread() + { + wxDELETE(m_pCurl); + } + +public: // thread execution management + + //! Returns true if this thread is ready to be started using e.g. #StartTransfer. + virtual bool IsOk() const + { return !m_url.empty() && m_pCurl!=NULL; } + + //! Starts the transfer. This is equivalent to call wxCurlDownloadThread::Download or + //! wxCurlUploadThread::Upload. + virtual wxCurlThreadError StartTransfer() = 0; + + //! Aborts this thread. + virtual void Abort(); + + //! Waits for the completion of the transfer. + virtual wxCurlThreadError Wait(); + + //! Pauses the transfer. + virtual wxCurlThreadError Pause(); + + //! Resumes the transfer. + virtual wxCurlThreadError Resume(); + + +public: // setters + + //! Sets the event handler to which wxCurlBeginPerformEvent, wxCurlEndPerformEvent + //! and wxCurlDownloadEvent/wxCurlUploadEvents will be posted. + void SetEvtHandler(wxEvtHandler *handler, int id = wxID_ANY) + { + wxCHECK_RET(!IsAlive(), wxS("Cannot use this function after the tranfer has begun")); + m_pHandler=handler; m_nId=id; + } + + //! Sets the URL to download/upload from/to. + wxCurlThreadError SetURL(const wxString &url); + +public: // getters + + wxEvtHandler *GetEvtHandler() const + { return m_pHandler; } + int GetId() const + { return m_nId; } + + bool IsAborting() + { return m_bAbort; } + + + //! Returns the wxCurlBase-derived object which is being used for the transfer. + //! Note that the returned value will be NULL if you've not called #SetURL yet. + //! You can cast it to the wxCurlBase-derived class associated with the return + //! value of GetProtocol() (e.g. if GetProtocol() returns wxCP_HTTP, you can cast + //! GetCurlSession() to wxCurlHTTP). + wxCurlBase *GetCurlSession() const + { return m_pCurl; } + + //! Returns the protocol used for the transfer. + //! This function will return something different from wxCP_INVALID only after + //! a call to #SetURL with a valid URL. + wxCurlProtocol GetProtocol() const + { return m_protocol; } + + //! Returns the URL of current transfer. + wxString GetURL() const + { return m_url; } + +public: // public utils + + //! Returns the protocol which should be used to download the resource + //! associated with the given URL. + static wxCurlProtocol GetProtocolFromURL(const wxString &url); + + //! Returns a pointer to a wxCurlBase-derived class suitable for handling + //! transfers on the given protocol. + //! You'll need to wx_static_cast the return value to the + //! right class in order to be able to set/get further options + //! (e.g. url/username/password/proxy/etc etc). + static wxCurlBase *CreateHandlerFor(wxCurlProtocol prot); + +protected: + + virtual bool TestDestroy(); + virtual void OnExit(); + + + // change the access type of some wxThread functions which should not + // be used on wxCurlBaseThread-derived classes. + + virtual wxCurlThreadError Create(unsigned int stackSize) + { return (wxCurlThreadError)wxThread::Create(stackSize); } + virtual wxCurlThreadError Run() + { return (wxCurlThreadError)wxThread::Run(); } + virtual wxCurlThreadError Delete() + { return (wxCurlThreadError)wxThread::Delete(); } +}; + + +// ---------------------------------------------------------------------------- +// wxCurlDownloadThreadOutputFilter +// ---------------------------------------------------------------------------- + +class WXDLLIMPEXP_CURL wxCurlDownloadThread; + +// private class used by wxCurlDownloadThread +class wxCurlDownloadThreadOutputFilter : public wxOutputStream +{ +protected: + wxCurlDownloadThread *m_thread; + wxOutputStream *m_stream; + +public: + wxCurlDownloadThreadOutputFilter(wxCurlDownloadThread *thread) + { m_thread = thread; m_stream = NULL; } + + void SetStream(wxOutputStream *realStream) + { m_stream = realStream; } + + virtual size_t OnSysWrite(const void *buffer, size_t bufsize); + + virtual bool IsOk() const + { return m_thread && m_stream && m_stream->IsOk(); } + + wxOutputStream *GetRealStream() const + { return m_stream; } + + wxFileOffset GetLength() const + { return m_stream->GetLength(); } + + bool Close() + { return m_stream->Close(); } +}; + + +// ---------------------------------------------------------------------------- +// wxCurlDownloadThread +// ---------------------------------------------------------------------------- + +//! A simple joinable thread which allows downloading +//! resources from the net without blocking the GUI of your app. +class WXDLLIMPEXP_CURL wxCurlDownloadThread : public wxCurlBaseThread +{ + friend class wxCurlDownloadThreadOutputFilter; // needs to access our TestDestroy() + +protected: + + //! The output stream for downloaded data. + wxCurlDownloadThreadOutputFilter m_output; + +public: + wxCurlDownloadThread(wxEvtHandler *handler = NULL, + int id = wxID_ANY, + const wxString &url = wxEmptyString, + wxOutputStream *out = NULL) + : wxCurlBaseThread(handler, id), + m_output(this) + { + if (!url.IsEmpty()) + Download(url, out); + } + +public: // public API + + //! Sets the output stream where the downloaded data are written. + //! If you pass NULL to this function, then a new temporary file will be used. + wxCurlThreadError SetOutputStream(wxOutputStream *out = NULL); + + //! Returns the output stream for downloaded data. + wxOutputStream *GetOutputStream() const + { + wxCHECK_MSG(!IsRunning(), NULL, + wxS("You cannot access the output stream while the thread is running!")); + return m_output.GetRealStream(); + } + + //! Returns true if this thread is ready to be started using #Download. + virtual bool IsOk() const + { return wxCurlBaseThread::IsOk() && m_output.IsOk(); } + + //! Creates and runs this thread for download of the given URL in the given + //! output stream (internally calls #SetURL and #SetOutputStream). + wxCurlThreadError Download(const wxString &url, wxOutputStream *out = NULL); + + //! Downloads the URL previously set with #SetURL using the output stream + //! previously set with #SetOutputStream. + wxCurlThreadError Download(); + +protected: + + // change access policy to force the user of the better-readable Download() method: + virtual wxCurlThreadError StartTransfer() + { return Download(); } + + virtual void *Entry(); +}; + + +// ---------------------------------------------------------------------------- +// wxCurlUploadThreadInputFilter +// ---------------------------------------------------------------------------- + +class WXDLLIMPEXP_CURL wxCurlUploadThread; + +// private class +class wxCurlUploadThreadInputFilter : public wxInputStream +{ +protected: + wxCurlUploadThread *m_thread; + wxInputStream *m_stream; + +public: + wxCurlUploadThreadInputFilter(wxCurlUploadThread *thread) + { m_thread = thread; m_stream = NULL; } + + void SetStream(wxInputStream *realStream) + { m_stream = realStream; } + + virtual size_t OnSysRead(void *buffer, size_t bufsize); + + virtual bool IsOk() const + { return m_thread && m_stream && m_stream->IsOk(); } + + wxInputStream *GetRealStream() const + { return m_stream; } + + wxFileOffset GetLength() const + { return m_stream->GetLength(); } + + char Peek() + { return m_stream->Peek(); } +}; + + +// ---------------------------------------------------------------------------- +// wxCurlUploadThread +// ---------------------------------------------------------------------------- + +//! A simple joinable thread which allows uploading +//! resources to the net without blocking the GUI of your app. +class WXDLLIMPEXP_CURL wxCurlUploadThread : public wxCurlBaseThread +{ + friend class wxCurlUploadThreadInputFilter; // needs to access our TestDestroy() + +protected: + + //! The input stream for uploaded data. + wxCurlUploadThreadInputFilter m_input; + +public: + wxCurlUploadThread(wxEvtHandler *handler = NULL, + int id = wxID_ANY, + const wxString &url = wxEmptyString, + wxInputStream *in = NULL) + : wxCurlBaseThread(handler, id), + m_input(this) + { + if (!url.IsEmpty()) + Upload(url, in); + } + +public: // public API + + //! Sets the output stream where the downloaded data are written. + //! If you pass NULL to this function, then a new temporary file will be used. + wxCurlThreadError SetInputStream(wxInputStream *in = NULL); + + //! Returns the output stream for downloaded data. + wxInputStream *GetInputStream() const + { + wxCHECK_MSG(!IsRunning(), NULL, + wxS("You cannot access the output stream while the thread is running!")); + return m_input.GetRealStream(); + } + + //! Returns true if this thread is ready to be started using #Upload. + virtual bool IsOk() const + { return wxCurlBaseThread::IsOk() && m_input.IsOk(); } + + //! Creates and runs this thread for upload to the given URL of the given + //! input stream (internally calls #SetURL and #SetOutputStream). + wxCurlThreadError Upload(const wxString &url, wxInputStream *in = NULL); + + //! Uploads the URL previously set with #SetURL using the input stream + //! previously set with #SetInputStream. + wxCurlThreadError Upload(); + +protected: + + // change access policy to force the user of the better-readable Upload() method: + virtual wxCurlThreadError StartTransfer() + { return Upload(); } + + virtual void *Entry(); +}; + + +#endif // _WXCURL_THREAD_H_ + diff --git a/include/wx/curl/utils.h b/include/wx/curl/utils.h new file mode 100644 index 0000000..5bb2fe3 --- /dev/null +++ b/include/wx/curl/utils.h @@ -0,0 +1,107 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: utils.h +// Purpose: wxCurlSizeEvent, wxCurlSizeQueryThread +// Author: Francesco Montorsi +// Created: 2007/04/14 +// RCS-ID: $Id: utils.h 1237 2010-03-10 21:52:47Z frm $ +// Copyright: (c) 2007 Francesco Montorsi +// Licence: wxWidgets licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_DOWNLOAD_H_ +#define _WX_DOWNLOAD_H_ + +#include "wx/curl/thread.h" + + +// ---------------------------------------------------------------------------- +// wxCurlSizeEvent +// ---------------------------------------------------------------------------- + +BEGIN_DECLARE_EVENT_TYPES() + DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_CURL, wxCURL_SIZE_QUERY_EVENT, 66987) +END_DECLARE_EVENT_TYPES() + +//! This event gets posted by wxCurlSizeQueryThread. Use the EVT_CURL_SIZE_QUERY(id, func) +//! macro to intercept it. +class WXDLLIMPEXP_CURL wxCurlSizeEvent : public wxEvent +{ +protected: + wxString m_url; + double m_size; + +public: + wxCurlSizeEvent(int id, const wxString &url, double size) + : wxEvent(id, wxCURL_SIZE_QUERY_EVENT), m_url(url), m_size(size) {} + + double GetSize() const + { return m_size; } + wxString GetURL() const + { return m_url; } + + wxEvent* Clone() const + { return new wxCurlSizeEvent(*this); } +}; + +typedef void (wxEvtHandler::*wxCurlSizeEventFunction)(wxCurlSizeEvent&); + +#define wxCurlSizeEventHandler(func) \ + (wxObjectEventFunction)(wxEventFunction)wxStaticCastEvent(wxCurlSizeEventFunction, &func) + +#define EVT_CURL_SIZE_QUERY(id, fn) \ + wx__DECLARE_EVT1(wxCURL_SIZE_EVENT, id, wxCurlSizeEventHandler(fn)) + + + +// ---------------------------------------------------------------------------- +// wxCurlSizeQueryThread +// ---------------------------------------------------------------------------- + +//! This thread just retrieve the sizes of the given list of files and post them to +//! the registered event handler. +//! This is useful to show the size of one or more files to the user before downloading them. +class WXDLLIMPEXP_CURL wxCurlSizeQueryThread : public wxCurlBaseThread +{ + friend class wxCurlSizeQueryOutput; + +protected: + + //! The array with our retrieved sizes. + wxArrayLong m_urlSize; + + //! The list of the URLs for the files whose size must be queried. + wxArrayString m_urls; + +public: + wxCurlSizeQueryThread(wxEvtHandler *handler = NULL, + int id = wxID_ANY) + : wxCurlBaseThread(handler, id) { } + + //! Creates the thread for querying the size of given array of urls. + //! After calling the Run() function, the given event handler will get + //! a wxCurlSizeEvent for each URL passed in the list. + wxCurlSizeQueryThread(wxEvtHandler *handler, + int id, + const wxArrayString& urls) + : wxCurlBaseThread(handler, id) { m_urls=urls; } + + //! Sets the list of URLs to query the size for. + void SetURLs(const wxArrayString &urls) + { + wxCHECK_RET(!IsAlive(), wxS("Call this function before creating the thread!")); + m_urls=urls; + } + +protected: + + //! Caches the file sizes and then exits. + virtual void *Entry(); + + //! Sends the wxEVT_COMMAND_CACHESIZE_COMPLETE event + //! to the event handler. + virtual void OnExit(); +}; + + +#endif // _WX_DOWNLOAD_H_ + diff --git a/lib/README b/lib/README new file mode 100644 index 0000000..3e52a1d --- /dev/null +++ b/lib/README @@ -0,0 +1,55 @@ + _ _ ____ _ + ___| | | | _ \| | + / __| | | | |_) | | + | (__| |_| | _ <| |___ + \___|\___/|_| \_\_____| + +Include files for libcurl, external users. + +They're all placed in the curl subdirectory here for better fit in any kind +of environment. You must include files from here using... + + #include + +... style and point the compiler's include path to the directory holding the +curl subdirectory. It makes it more likely to survive future modifications. + +NOTE FOR LIBCURL HACKERS + +The following notes apply to libcurl version 7.19.0 and later. + +* The distributed curl/curlbuild.h file is only intended to be used on systems + which can not run the also distributed configure script. + +* The distributed curlbuild.h file is generated as a copy of curlbuild.h.dist + when the libcurl source code distribution archive file is originally created. + +* If you check out from git on a non-configure platform, you must run the + appropriate buildconf* script to set up curlbuild.h and other local files + before being able of compiling the library. + +* On systems capable of running the configure script, the configure process + will overwrite the distributed include/curl/curlbuild.h file with one that + is suitable and specific to the library being configured and built, which + is generated from the include/curl/curlbuild.h.in template file. + +* If you intend to distribute an already compiled libcurl library you _MUST_ + also distribute along with it the generated curl/curlbuild.h which has been + used to compile it. Otherwise the library will be of no use for the users of + the library that you have built. It is _your_ responsibility to provide this + file. No one at the cURL project can know how you have built the library. + +* File curl/curlbuild.h includes platform and configuration dependent info, + and must not be modified by anyone. Configure script generates it for you. + +* We cannot assume anything else but very basic compiler features being + present. While libcurl requires an ANSI C compiler to build, some of the + earlier ANSI compilers clearly can't deal with some preprocessor operators. + +* Newlines must remain unix-style for older compilers' sake. + +* Comments must be written in the old-style /* unnested C-fashion */ + +To figure out how to do good and portable checks for features, operating +systems or specific hardwarare, a very good resource is Bjorn Reese's +collection at http://predef.sf.net/ diff --git a/lib/curl/curl.h b/lib/curl/curl.h new file mode 100644 index 0000000..8384191 --- /dev/null +++ b/lib/curl/curl.h @@ -0,0 +1,2318 @@ +#ifndef __CURL_CURL_H +#define __CURL_CURL_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2014, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at http://curl.haxx.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ***************************************************************************/ + +/* + * If you have libcurl problems, all docs and details are found here: + * http://curl.haxx.se/libcurl/ + * + * curl-library mailing list subscription and unsubscription web interface: + * http://cool.haxx.se/mailman/listinfo/curl-library/ + */ + +#include "curlver.h" /* libcurl version defines */ +#include "curlbuild.h" /* libcurl build definitions */ +#include "curlrules.h" /* libcurl rules enforcement */ + +/* + * Define WIN32 when build target is Win32 API + */ + +#if (defined(_WIN32) || defined(__WIN32__)) && \ + !defined(WIN32) && !defined(__SYMBIAN32__) +#define WIN32 +#endif + +#include +#include + +#if defined(__FreeBSD__) && (__FreeBSD__ >= 2) +/* Needed for __FreeBSD_version symbol definition */ +#include +#endif + +/* The include stuff here below is mainly for time_t! */ +#include +#include + +#if defined(WIN32) && !defined(_WIN32_WCE) && !defined(__CYGWIN__) +#if !(defined(_WINSOCKAPI_) || defined(_WINSOCK_H) || defined(__LWIP_OPT_H__)) +/* The check above prevents the winsock2 inclusion if winsock.h already was + included, since they can't co-exist without problems */ +#include +#include +#endif +#endif + +/* HP-UX systems version 9, 10 and 11 lack sys/select.h and so does oldish + libc5-based Linux systems. Only include it on systems that are known to + require it! */ +#if defined(_AIX) || defined(__NOVELL_LIBC__) || defined(__NetBSD__) || \ + defined(__minix) || defined(__SYMBIAN32__) || defined(__INTEGRITY) || \ + defined(ANDROID) || defined(__ANDROID__) || defined(__OpenBSD__) || \ + (defined(__FreeBSD_version) && (__FreeBSD_version < 800000)) +#include +#endif + +#if !defined(WIN32) && !defined(_WIN32_WCE) +#include +#endif + +#if !defined(WIN32) && !defined(__WATCOMC__) && !defined(__VXWORKS__) +#include +#endif + +#ifdef __BEOS__ +#include +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void CURL; + +/* + * libcurl external API function linkage decorations. + */ + +#ifdef CURL_STATICLIB +# define CURL_EXTERN +#elif defined(WIN32) || defined(_WIN32) || defined(__SYMBIAN32__) +# if defined(BUILDING_LIBCURL) +# define CURL_EXTERN __declspec(dllexport) +# else +# define CURL_EXTERN __declspec(dllimport) +# endif +#elif defined(BUILDING_LIBCURL) && defined(CURL_HIDDEN_SYMBOLS) +# define CURL_EXTERN CURL_EXTERN_SYMBOL +#else +# define CURL_EXTERN +#endif + +#ifndef curl_socket_typedef +/* socket typedef */ +#if defined(WIN32) && !defined(__LWIP_OPT_H__) +typedef SOCKET curl_socket_t; +#define CURL_SOCKET_BAD INVALID_SOCKET +#else +typedef int curl_socket_t; +#define CURL_SOCKET_BAD -1 +#endif +#define curl_socket_typedef +#endif /* curl_socket_typedef */ + +struct curl_httppost { + struct curl_httppost *next; /* next entry in the list */ + char *name; /* pointer to allocated name */ + long namelength; /* length of name length */ + char *contents; /* pointer to allocated data contents */ + long contentslength; /* length of contents field */ + char *buffer; /* pointer to allocated buffer contents */ + long bufferlength; /* length of buffer field */ + char *contenttype; /* Content-Type */ + struct curl_slist* contentheader; /* list of extra headers for this form */ + struct curl_httppost *more; /* if one field name has more than one + file, this link should link to following + files */ + long flags; /* as defined below */ +#define HTTPPOST_FILENAME (1<<0) /* specified content is a file name */ +#define HTTPPOST_READFILE (1<<1) /* specified content is a file name */ +#define HTTPPOST_PTRNAME (1<<2) /* name is only stored pointer + do not free in formfree */ +#define HTTPPOST_PTRCONTENTS (1<<3) /* contents is only stored pointer + do not free in formfree */ +#define HTTPPOST_BUFFER (1<<4) /* upload file from buffer */ +#define HTTPPOST_PTRBUFFER (1<<5) /* upload file from pointer contents */ +#define HTTPPOST_CALLBACK (1<<6) /* upload file contents by using the + regular read callback to get the data + and pass the given pointer as custom + pointer */ + + char *showfilename; /* The file name to show. If not set, the + actual file name will be used (if this + is a file part) */ + void *userp; /* custom pointer used for + HTTPPOST_CALLBACK posts */ +}; + +/* This is the CURLOPT_PROGRESSFUNCTION callback proto. It is now considered + deprecated but was the only choice up until 7.31.0 */ +typedef int (*curl_progress_callback)(void *clientp, + double dltotal, + double dlnow, + double ultotal, + double ulnow); + +/* This is the CURLOPT_XFERINFOFUNCTION callback proto. It was introduced in + 7.32.0, it avoids floating point and provides more detailed information. */ +typedef int (*curl_xferinfo_callback)(void *clientp, + curl_off_t dltotal, + curl_off_t dlnow, + curl_off_t ultotal, + curl_off_t ulnow); + +#ifndef CURL_MAX_WRITE_SIZE + /* Tests have proven that 20K is a very bad buffer size for uploads on + Windows, while 16K for some odd reason performed a lot better. + We do the ifndef check to allow this value to easier be changed at build + time for those who feel adventurous. The practical minimum is about + 400 bytes since libcurl uses a buffer of this size as a scratch area + (unrelated to network send operations). */ +#define CURL_MAX_WRITE_SIZE 16384 +#endif + +#ifndef CURL_MAX_HTTP_HEADER +/* The only reason to have a max limit for this is to avoid the risk of a bad + server feeding libcurl with a never-ending header that will cause reallocs + infinitely */ +#define CURL_MAX_HTTP_HEADER (100*1024) +#endif + +/* This is a magic return code for the write callback that, when returned, + will signal libcurl to pause receiving on the current transfer. */ +#define CURL_WRITEFUNC_PAUSE 0x10000001 + +typedef size_t (*curl_write_callback)(char *buffer, + size_t size, + size_t nitems, + void *outstream); + + + +/* enumeration of file types */ +typedef enum { + CURLFILETYPE_FILE = 0, + CURLFILETYPE_DIRECTORY, + CURLFILETYPE_SYMLINK, + CURLFILETYPE_DEVICE_BLOCK, + CURLFILETYPE_DEVICE_CHAR, + CURLFILETYPE_NAMEDPIPE, + CURLFILETYPE_SOCKET, + CURLFILETYPE_DOOR, /* is possible only on Sun Solaris now */ + + CURLFILETYPE_UNKNOWN /* should never occur */ +} curlfiletype; + +#define CURLFINFOFLAG_KNOWN_FILENAME (1<<0) +#define CURLFINFOFLAG_KNOWN_FILETYPE (1<<1) +#define CURLFINFOFLAG_KNOWN_TIME (1<<2) +#define CURLFINFOFLAG_KNOWN_PERM (1<<3) +#define CURLFINFOFLAG_KNOWN_UID (1<<4) +#define CURLFINFOFLAG_KNOWN_GID (1<<5) +#define CURLFINFOFLAG_KNOWN_SIZE (1<<6) +#define CURLFINFOFLAG_KNOWN_HLINKCOUNT (1<<7) + +/* Content of this structure depends on information which is known and is + achievable (e.g. by FTP LIST parsing). Please see the url_easy_setopt(3) man + page for callbacks returning this structure -- some fields are mandatory, + some others are optional. The FLAG field has special meaning. */ +struct curl_fileinfo { + char *filename; + curlfiletype filetype; + time_t time; + unsigned int perm; + int uid; + int gid; + curl_off_t size; + long int hardlinks; + + struct { + /* If some of these fields is not NULL, it is a pointer to b_data. */ + char *time; + char *perm; + char *user; + char *group; + char *target; /* pointer to the target filename of a symlink */ + } strings; + + unsigned int flags; + + /* used internally */ + char * b_data; + size_t b_size; + size_t b_used; +}; + +/* return codes for CURLOPT_CHUNK_BGN_FUNCTION */ +#define CURL_CHUNK_BGN_FUNC_OK 0 +#define CURL_CHUNK_BGN_FUNC_FAIL 1 /* tell the lib to end the task */ +#define CURL_CHUNK_BGN_FUNC_SKIP 2 /* skip this chunk over */ + +/* if splitting of data transfer is enabled, this callback is called before + download of an individual chunk started. Note that parameter "remains" works + only for FTP wildcard downloading (for now), otherwise is not used */ +typedef long (*curl_chunk_bgn_callback)(const void *transfer_info, + void *ptr, + int remains); + +/* return codes for CURLOPT_CHUNK_END_FUNCTION */ +#define CURL_CHUNK_END_FUNC_OK 0 +#define CURL_CHUNK_END_FUNC_FAIL 1 /* tell the lib to end the task */ + +/* If splitting of data transfer is enabled this callback is called after + download of an individual chunk finished. + Note! After this callback was set then it have to be called FOR ALL chunks. + Even if downloading of this chunk was skipped in CHUNK_BGN_FUNC. + This is the reason why we don't need "transfer_info" parameter in this + callback and we are not interested in "remains" parameter too. */ +typedef long (*curl_chunk_end_callback)(void *ptr); + +/* return codes for FNMATCHFUNCTION */ +#define CURL_FNMATCHFUNC_MATCH 0 /* string corresponds to the pattern */ +#define CURL_FNMATCHFUNC_NOMATCH 1 /* pattern doesn't match the string */ +#define CURL_FNMATCHFUNC_FAIL 2 /* an error occurred */ + +/* callback type for wildcard downloading pattern matching. If the + string matches the pattern, return CURL_FNMATCHFUNC_MATCH value, etc. */ +typedef int (*curl_fnmatch_callback)(void *ptr, + const char *pattern, + const char *string); + +/* These are the return codes for the seek callbacks */ +#define CURL_SEEKFUNC_OK 0 +#define CURL_SEEKFUNC_FAIL 1 /* fail the entire transfer */ +#define CURL_SEEKFUNC_CANTSEEK 2 /* tell libcurl seeking can't be done, so + libcurl might try other means instead */ +typedef int (*curl_seek_callback)(void *instream, + curl_off_t offset, + int origin); /* 'whence' */ + +/* This is a return code for the read callback that, when returned, will + signal libcurl to immediately abort the current transfer. */ +#define CURL_READFUNC_ABORT 0x10000000 +/* This is a return code for the read callback that, when returned, will + signal libcurl to pause sending data on the current transfer. */ +#define CURL_READFUNC_PAUSE 0x10000001 + +typedef size_t (*curl_read_callback)(char *buffer, + size_t size, + size_t nitems, + void *instream); + +typedef enum { + CURLSOCKTYPE_IPCXN, /* socket created for a specific IP connection */ + CURLSOCKTYPE_ACCEPT, /* socket created by accept() call */ + CURLSOCKTYPE_LAST /* never use */ +} curlsocktype; + +/* The return code from the sockopt_callback can signal information back + to libcurl: */ +#define CURL_SOCKOPT_OK 0 +#define CURL_SOCKOPT_ERROR 1 /* causes libcurl to abort and return + CURLE_ABORTED_BY_CALLBACK */ +#define CURL_SOCKOPT_ALREADY_CONNECTED 2 + +typedef int (*curl_sockopt_callback)(void *clientp, + curl_socket_t curlfd, + curlsocktype purpose); + +struct curl_sockaddr { + int family; + int socktype; + int protocol; + unsigned int addrlen; /* addrlen was a socklen_t type before 7.18.0 but it + turned really ugly and painful on the systems that + lack this type */ + struct sockaddr addr; +}; + +typedef curl_socket_t +(*curl_opensocket_callback)(void *clientp, + curlsocktype purpose, + struct curl_sockaddr *address); + +typedef int +(*curl_closesocket_callback)(void *clientp, curl_socket_t item); + +typedef enum { + CURLIOE_OK, /* I/O operation successful */ + CURLIOE_UNKNOWNCMD, /* command was unknown to callback */ + CURLIOE_FAILRESTART, /* failed to restart the read */ + CURLIOE_LAST /* never use */ +} curlioerr; + +typedef enum { + CURLIOCMD_NOP, /* no operation */ + CURLIOCMD_RESTARTREAD, /* restart the read stream from start */ + CURLIOCMD_LAST /* never use */ +} curliocmd; + +typedef curlioerr (*curl_ioctl_callback)(CURL *handle, + int cmd, + void *clientp); + +/* + * The following typedef's are signatures of malloc, free, realloc, strdup and + * calloc respectively. Function pointers of these types can be passed to the + * curl_global_init_mem() function to set user defined memory management + * callback routines. + */ +typedef void *(*curl_malloc_callback)(size_t size); +typedef void (*curl_free_callback)(void *ptr); +typedef void *(*curl_realloc_callback)(void *ptr, size_t size); +typedef char *(*curl_strdup_callback)(const char *str); +typedef void *(*curl_calloc_callback)(size_t nmemb, size_t size); + +/* the kind of data that is passed to information_callback*/ +typedef enum { + CURLINFO_TEXT = 0, + CURLINFO_HEADER_IN, /* 1 */ + CURLINFO_HEADER_OUT, /* 2 */ + CURLINFO_DATA_IN, /* 3 */ + CURLINFO_DATA_OUT, /* 4 */ + CURLINFO_SSL_DATA_IN, /* 5 */ + CURLINFO_SSL_DATA_OUT, /* 6 */ + CURLINFO_END +} curl_infotype; + +typedef int (*curl_debug_callback) + (CURL *handle, /* the handle/transfer this concerns */ + curl_infotype type, /* what kind of data */ + char *data, /* points to the data */ + size_t size, /* size of the data pointed to */ + void *userptr); /* whatever the user please */ + +/* All possible error codes from all sorts of curl functions. Future versions + may return other values, stay prepared. + + Always add new return codes last. Never *EVER* remove any. The return + codes must remain the same! + */ + +typedef enum { + CURLE_OK = 0, + CURLE_UNSUPPORTED_PROTOCOL, /* 1 */ + CURLE_FAILED_INIT, /* 2 */ + CURLE_URL_MALFORMAT, /* 3 */ + CURLE_NOT_BUILT_IN, /* 4 - [was obsoleted in August 2007 for + 7.17.0, reused in April 2011 for 7.21.5] */ + CURLE_COULDNT_RESOLVE_PROXY, /* 5 */ + CURLE_COULDNT_RESOLVE_HOST, /* 6 */ + CURLE_COULDNT_CONNECT, /* 7 */ + CURLE_FTP_WEIRD_SERVER_REPLY, /* 8 */ + CURLE_REMOTE_ACCESS_DENIED, /* 9 a service was denied by the server + due to lack of access - when login fails + this is not returned. */ + CURLE_FTP_ACCEPT_FAILED, /* 10 - [was obsoleted in April 2006 for + 7.15.4, reused in Dec 2011 for 7.24.0]*/ + CURLE_FTP_WEIRD_PASS_REPLY, /* 11 */ + CURLE_FTP_ACCEPT_TIMEOUT, /* 12 - timeout occurred accepting server + [was obsoleted in August 2007 for 7.17.0, + reused in Dec 2011 for 7.24.0]*/ + CURLE_FTP_WEIRD_PASV_REPLY, /* 13 */ + CURLE_FTP_WEIRD_227_FORMAT, /* 14 */ + CURLE_FTP_CANT_GET_HOST, /* 15 */ + CURLE_OBSOLETE16, /* 16 - NOT USED */ + CURLE_FTP_COULDNT_SET_TYPE, /* 17 */ + CURLE_PARTIAL_FILE, /* 18 */ + CURLE_FTP_COULDNT_RETR_FILE, /* 19 */ + CURLE_OBSOLETE20, /* 20 - NOT USED */ + CURLE_QUOTE_ERROR, /* 21 - quote command failure */ + CURLE_HTTP_RETURNED_ERROR, /* 22 */ + CURLE_WRITE_ERROR, /* 23 */ + CURLE_OBSOLETE24, /* 24 - NOT USED */ + CURLE_UPLOAD_FAILED, /* 25 - failed upload "command" */ + CURLE_READ_ERROR, /* 26 - couldn't open/read from file */ + CURLE_OUT_OF_MEMORY, /* 27 */ + /* Note: CURLE_OUT_OF_MEMORY may sometimes indicate a conversion error + instead of a memory allocation error if CURL_DOES_CONVERSIONS + is defined + */ + CURLE_OPERATION_TIMEDOUT, /* 28 - the timeout time was reached */ + CURLE_OBSOLETE29, /* 29 - NOT USED */ + CURLE_FTP_PORT_FAILED, /* 30 - FTP PORT operation failed */ + CURLE_FTP_COULDNT_USE_REST, /* 31 - the REST command failed */ + CURLE_OBSOLETE32, /* 32 - NOT USED */ + CURLE_RANGE_ERROR, /* 33 - RANGE "command" didn't work */ + CURLE_HTTP_POST_ERROR, /* 34 */ + CURLE_SSL_CONNECT_ERROR, /* 35 - wrong when connecting with SSL */ + CURLE_BAD_DOWNLOAD_RESUME, /* 36 - couldn't resume download */ + CURLE_FILE_COULDNT_READ_FILE, /* 37 */ + CURLE_LDAP_CANNOT_BIND, /* 38 */ + CURLE_LDAP_SEARCH_FAILED, /* 39 */ + CURLE_OBSOLETE40, /* 40 - NOT USED */ + CURLE_FUNCTION_NOT_FOUND, /* 41 */ + CURLE_ABORTED_BY_CALLBACK, /* 42 */ + CURLE_BAD_FUNCTION_ARGUMENT, /* 43 */ + CURLE_OBSOLETE44, /* 44 - NOT USED */ + CURLE_INTERFACE_FAILED, /* 45 - CURLOPT_INTERFACE failed */ + CURLE_OBSOLETE46, /* 46 - NOT USED */ + CURLE_TOO_MANY_REDIRECTS , /* 47 - catch endless re-direct loops */ + CURLE_UNKNOWN_OPTION, /* 48 - User specified an unknown option */ + CURLE_TELNET_OPTION_SYNTAX , /* 49 - Malformed telnet option */ + CURLE_OBSOLETE50, /* 50 - NOT USED */ + CURLE_PEER_FAILED_VERIFICATION, /* 51 - peer's certificate or fingerprint + wasn't verified fine */ + CURLE_GOT_NOTHING, /* 52 - when this is a specific error */ + CURLE_SSL_ENGINE_NOTFOUND, /* 53 - SSL crypto engine not found */ + CURLE_SSL_ENGINE_SETFAILED, /* 54 - can not set SSL crypto engine as + default */ + CURLE_SEND_ERROR, /* 55 - failed sending network data */ + CURLE_RECV_ERROR, /* 56 - failure in receiving network data */ + CURLE_OBSOLETE57, /* 57 - NOT IN USE */ + CURLE_SSL_CERTPROBLEM, /* 58 - problem with the local certificate */ + CURLE_SSL_CIPHER, /* 59 - couldn't use specified cipher */ + CURLE_SSL_CACERT, /* 60 - problem with the CA cert (path?) */ + CURLE_BAD_CONTENT_ENCODING, /* 61 - Unrecognized/bad encoding */ + CURLE_LDAP_INVALID_URL, /* 62 - Invalid LDAP URL */ + CURLE_FILESIZE_EXCEEDED, /* 63 - Maximum file size exceeded */ + CURLE_USE_SSL_FAILED, /* 64 - Requested FTP SSL level failed */ + CURLE_SEND_FAIL_REWIND, /* 65 - Sending the data requires a rewind + that failed */ + CURLE_SSL_ENGINE_INITFAILED, /* 66 - failed to initialise ENGINE */ + CURLE_LOGIN_DENIED, /* 67 - user, password or similar was not + accepted and we failed to login */ + CURLE_TFTP_NOTFOUND, /* 68 - file not found on server */ + CURLE_TFTP_PERM, /* 69 - permission problem on server */ + CURLE_REMOTE_DISK_FULL, /* 70 - out of disk space on server */ + CURLE_TFTP_ILLEGAL, /* 71 - Illegal TFTP operation */ + CURLE_TFTP_UNKNOWNID, /* 72 - Unknown transfer ID */ + CURLE_REMOTE_FILE_EXISTS, /* 73 - File already exists */ + CURLE_TFTP_NOSUCHUSER, /* 74 - No such user */ + CURLE_CONV_FAILED, /* 75 - conversion failed */ + CURLE_CONV_REQD, /* 76 - caller must register conversion + callbacks using curl_easy_setopt options + CURLOPT_CONV_FROM_NETWORK_FUNCTION, + CURLOPT_CONV_TO_NETWORK_FUNCTION, and + CURLOPT_CONV_FROM_UTF8_FUNCTION */ + CURLE_SSL_CACERT_BADFILE, /* 77 - could not load CACERT file, missing + or wrong format */ + CURLE_REMOTE_FILE_NOT_FOUND, /* 78 - remote file not found */ + CURLE_SSH, /* 79 - error from the SSH layer, somewhat + generic so the error message will be of + interest when this has happened */ + + CURLE_SSL_SHUTDOWN_FAILED, /* 80 - Failed to shut down the SSL + connection */ + CURLE_AGAIN, /* 81 - socket is not ready for send/recv, + wait till it's ready and try again (Added + in 7.18.2) */ + CURLE_SSL_CRL_BADFILE, /* 82 - could not load CRL file, missing or + wrong format (Added in 7.19.0) */ + CURLE_SSL_ISSUER_ERROR, /* 83 - Issuer check failed. (Added in + 7.19.0) */ + CURLE_FTP_PRET_FAILED, /* 84 - a PRET command failed */ + CURLE_RTSP_CSEQ_ERROR, /* 85 - mismatch of RTSP CSeq numbers */ + CURLE_RTSP_SESSION_ERROR, /* 86 - mismatch of RTSP Session Ids */ + CURLE_FTP_BAD_FILE_LIST, /* 87 - unable to parse FTP file list */ + CURLE_CHUNK_FAILED, /* 88 - chunk callback reported error */ + CURLE_NO_CONNECTION_AVAILABLE, /* 89 - No connection available, the + session will be queued */ + CURL_LAST /* never use! */ +} CURLcode; + +#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all + the obsolete stuff removed! */ + +/* Previously obsoletes error codes re-used in 7.24.0 */ +#define CURLE_OBSOLETE10 CURLE_FTP_ACCEPT_FAILED +#define CURLE_OBSOLETE12 CURLE_FTP_ACCEPT_TIMEOUT + +/* compatibility with older names */ +#define CURLOPT_ENCODING CURLOPT_ACCEPT_ENCODING + +/* The following were added in 7.21.5, April 2011 */ +#define CURLE_UNKNOWN_TELNET_OPTION CURLE_UNKNOWN_OPTION + +/* The following were added in 7.17.1 */ +/* These are scheduled to disappear by 2009 */ +#define CURLE_SSL_PEER_CERTIFICATE CURLE_PEER_FAILED_VERIFICATION + +/* The following were added in 7.17.0 */ +/* These are scheduled to disappear by 2009 */ +#define CURLE_OBSOLETE CURLE_OBSOLETE50 /* no one should be using this! */ +#define CURLE_BAD_PASSWORD_ENTERED CURLE_OBSOLETE46 +#define CURLE_BAD_CALLING_ORDER CURLE_OBSOLETE44 +#define CURLE_FTP_USER_PASSWORD_INCORRECT CURLE_OBSOLETE10 +#define CURLE_FTP_CANT_RECONNECT CURLE_OBSOLETE16 +#define CURLE_FTP_COULDNT_GET_SIZE CURLE_OBSOLETE32 +#define CURLE_FTP_COULDNT_SET_ASCII CURLE_OBSOLETE29 +#define CURLE_FTP_WEIRD_USER_REPLY CURLE_OBSOLETE12 +#define CURLE_FTP_WRITE_ERROR CURLE_OBSOLETE20 +#define CURLE_LIBRARY_NOT_FOUND CURLE_OBSOLETE40 +#define CURLE_MALFORMAT_USER CURLE_OBSOLETE24 +#define CURLE_SHARE_IN_USE CURLE_OBSOLETE57 +#define CURLE_URL_MALFORMAT_USER CURLE_NOT_BUILT_IN + +#define CURLE_FTP_ACCESS_DENIED CURLE_REMOTE_ACCESS_DENIED +#define CURLE_FTP_COULDNT_SET_BINARY CURLE_FTP_COULDNT_SET_TYPE +#define CURLE_FTP_QUOTE_ERROR CURLE_QUOTE_ERROR +#define CURLE_TFTP_DISKFULL CURLE_REMOTE_DISK_FULL +#define CURLE_TFTP_EXISTS CURLE_REMOTE_FILE_EXISTS +#define CURLE_HTTP_RANGE_ERROR CURLE_RANGE_ERROR +#define CURLE_FTP_SSL_FAILED CURLE_USE_SSL_FAILED + +/* The following were added earlier */ + +#define CURLE_OPERATION_TIMEOUTED CURLE_OPERATION_TIMEDOUT + +#define CURLE_HTTP_NOT_FOUND CURLE_HTTP_RETURNED_ERROR +#define CURLE_HTTP_PORT_FAILED CURLE_INTERFACE_FAILED +#define CURLE_FTP_COULDNT_STOR_FILE CURLE_UPLOAD_FAILED + +#define CURLE_FTP_PARTIAL_FILE CURLE_PARTIAL_FILE +#define CURLE_FTP_BAD_DOWNLOAD_RESUME CURLE_BAD_DOWNLOAD_RESUME + +/* This was the error code 50 in 7.7.3 and a few earlier versions, this + is no longer used by libcurl but is instead #defined here only to not + make programs break */ +#define CURLE_ALREADY_COMPLETE 99999 + +#endif /*!CURL_NO_OLDIES*/ + +/* This prototype applies to all conversion callbacks */ +typedef CURLcode (*curl_conv_callback)(char *buffer, size_t length); + +typedef CURLcode (*curl_ssl_ctx_callback)(CURL *curl, /* easy handle */ + void *ssl_ctx, /* actually an + OpenSSL SSL_CTX */ + void *userptr); + +typedef enum { + CURLPROXY_HTTP = 0, /* added in 7.10, new in 7.19.4 default is to use + CONNECT HTTP/1.1 */ + CURLPROXY_HTTP_1_0 = 1, /* added in 7.19.4, force to use CONNECT + HTTP/1.0 */ + CURLPROXY_SOCKS4 = 4, /* support added in 7.15.2, enum existed already + in 7.10 */ + CURLPROXY_SOCKS5 = 5, /* added in 7.10 */ + CURLPROXY_SOCKS4A = 6, /* added in 7.18.0 */ + CURLPROXY_SOCKS5_HOSTNAME = 7 /* Use the SOCKS5 protocol but pass along the + host name rather than the IP address. added + in 7.18.0 */ +} curl_proxytype; /* this enum was added in 7.10 */ + +/* + * Bitmasks for CURLOPT_HTTPAUTH and CURLOPT_PROXYAUTH options: + * + * CURLAUTH_NONE - No HTTP authentication + * CURLAUTH_BASIC - HTTP Basic authentication (default) + * CURLAUTH_DIGEST - HTTP Digest authentication + * CURLAUTH_GSSNEGOTIATE - HTTP GSS-Negotiate authentication + * CURLAUTH_NTLM - HTTP NTLM authentication + * CURLAUTH_DIGEST_IE - HTTP Digest authentication with IE flavour + * CURLAUTH_NTLM_WB - HTTP NTLM authentication delegated to winbind helper + * CURLAUTH_ONLY - Use together with a single other type to force no + * authentication or just that single type + * CURLAUTH_ANY - All fine types set + * CURLAUTH_ANYSAFE - All fine types except Basic + */ + +#define CURLAUTH_NONE ((unsigned long)0) +#define CURLAUTH_BASIC (((unsigned long)1)<<0) +#define CURLAUTH_DIGEST (((unsigned long)1)<<1) +#define CURLAUTH_GSSNEGOTIATE (((unsigned long)1)<<2) +#define CURLAUTH_NTLM (((unsigned long)1)<<3) +#define CURLAUTH_DIGEST_IE (((unsigned long)1)<<4) +#define CURLAUTH_NTLM_WB (((unsigned long)1)<<5) +#define CURLAUTH_ONLY (((unsigned long)1)<<31) +#define CURLAUTH_ANY (~CURLAUTH_DIGEST_IE) +#define CURLAUTH_ANYSAFE (~(CURLAUTH_BASIC|CURLAUTH_DIGEST_IE)) + +#define CURLSSH_AUTH_ANY ~0 /* all types supported by the server */ +#define CURLSSH_AUTH_NONE 0 /* none allowed, silly but complete */ +#define CURLSSH_AUTH_PUBLICKEY (1<<0) /* public/private key files */ +#define CURLSSH_AUTH_PASSWORD (1<<1) /* password */ +#define CURLSSH_AUTH_HOST (1<<2) /* host key files */ +#define CURLSSH_AUTH_KEYBOARD (1<<3) /* keyboard interactive */ +#define CURLSSH_AUTH_AGENT (1<<4) /* agent (ssh-agent, pageant...) */ +#define CURLSSH_AUTH_DEFAULT CURLSSH_AUTH_ANY + +#define CURLGSSAPI_DELEGATION_NONE 0 /* no delegation (default) */ +#define CURLGSSAPI_DELEGATION_POLICY_FLAG (1<<0) /* if permitted by policy */ +#define CURLGSSAPI_DELEGATION_FLAG (1<<1) /* delegate always */ + +#define CURL_ERROR_SIZE 256 + +enum curl_khtype { + CURLKHTYPE_UNKNOWN, + CURLKHTYPE_RSA1, + CURLKHTYPE_RSA, + CURLKHTYPE_DSS +}; + +struct curl_khkey { + const char *key; /* points to a zero-terminated string encoded with base64 + if len is zero, otherwise to the "raw" data */ + size_t len; + enum curl_khtype keytype; +}; + +/* this is the set of return values expected from the curl_sshkeycallback + callback */ +enum curl_khstat { + CURLKHSTAT_FINE_ADD_TO_FILE, + CURLKHSTAT_FINE, + CURLKHSTAT_REJECT, /* reject the connection, return an error */ + CURLKHSTAT_DEFER, /* do not accept it, but we can't answer right now so + this causes a CURLE_DEFER error but otherwise the + connection will be left intact etc */ + CURLKHSTAT_LAST /* not for use, only a marker for last-in-list */ +}; + +/* this is the set of status codes pass in to the callback */ +enum curl_khmatch { + CURLKHMATCH_OK, /* match */ + CURLKHMATCH_MISMATCH, /* host found, key mismatch! */ + CURLKHMATCH_MISSING, /* no matching host/key found */ + CURLKHMATCH_LAST /* not for use, only a marker for last-in-list */ +}; + +typedef int + (*curl_sshkeycallback) (CURL *easy, /* easy handle */ + const struct curl_khkey *knownkey, /* known */ + const struct curl_khkey *foundkey, /* found */ + enum curl_khmatch, /* libcurl's view on the keys */ + void *clientp); /* custom pointer passed from app */ + +/* parameter for the CURLOPT_USE_SSL option */ +typedef enum { + CURLUSESSL_NONE, /* do not attempt to use SSL */ + CURLUSESSL_TRY, /* try using SSL, proceed anyway otherwise */ + CURLUSESSL_CONTROL, /* SSL for the control connection or fail */ + CURLUSESSL_ALL, /* SSL for all communication or fail */ + CURLUSESSL_LAST /* not an option, never use */ +} curl_usessl; + +/* Definition of bits for the CURLOPT_SSL_OPTIONS argument: */ + +/* - ALLOW_BEAST tells libcurl to allow the BEAST SSL vulnerability in the + name of improving interoperability with older servers. Some SSL libraries + have introduced work-arounds for this flaw but those work-arounds sometimes + make the SSL communication fail. To regain functionality with those broken + servers, a user can this way allow the vulnerability back. */ +#define CURLSSLOPT_ALLOW_BEAST (1<<0) + +#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all + the obsolete stuff removed! */ + +/* Backwards compatibility with older names */ +/* These are scheduled to disappear by 2009 */ + +#define CURLFTPSSL_NONE CURLUSESSL_NONE +#define CURLFTPSSL_TRY CURLUSESSL_TRY +#define CURLFTPSSL_CONTROL CURLUSESSL_CONTROL +#define CURLFTPSSL_ALL CURLUSESSL_ALL +#define CURLFTPSSL_LAST CURLUSESSL_LAST +#define curl_ftpssl curl_usessl +#endif /*!CURL_NO_OLDIES*/ + +/* parameter for the CURLOPT_FTP_SSL_CCC option */ +typedef enum { + CURLFTPSSL_CCC_NONE, /* do not send CCC */ + CURLFTPSSL_CCC_PASSIVE, /* Let the server initiate the shutdown */ + CURLFTPSSL_CCC_ACTIVE, /* Initiate the shutdown */ + CURLFTPSSL_CCC_LAST /* not an option, never use */ +} curl_ftpccc; + +/* parameter for the CURLOPT_FTPSSLAUTH option */ +typedef enum { + CURLFTPAUTH_DEFAULT, /* let libcurl decide */ + CURLFTPAUTH_SSL, /* use "AUTH SSL" */ + CURLFTPAUTH_TLS, /* use "AUTH TLS" */ + CURLFTPAUTH_LAST /* not an option, never use */ +} curl_ftpauth; + +/* parameter for the CURLOPT_FTP_CREATE_MISSING_DIRS option */ +typedef enum { + CURLFTP_CREATE_DIR_NONE, /* do NOT create missing dirs! */ + CURLFTP_CREATE_DIR, /* (FTP/SFTP) if CWD fails, try MKD and then CWD + again if MKD succeeded, for SFTP this does + similar magic */ + CURLFTP_CREATE_DIR_RETRY, /* (FTP only) if CWD fails, try MKD and then CWD + again even if MKD failed! */ + CURLFTP_CREATE_DIR_LAST /* not an option, never use */ +} curl_ftpcreatedir; + +/* parameter for the CURLOPT_FTP_FILEMETHOD option */ +typedef enum { + CURLFTPMETHOD_DEFAULT, /* let libcurl pick */ + CURLFTPMETHOD_MULTICWD, /* single CWD operation for each path part */ + CURLFTPMETHOD_NOCWD, /* no CWD at all */ + CURLFTPMETHOD_SINGLECWD, /* one CWD to full dir, then work on file */ + CURLFTPMETHOD_LAST /* not an option, never use */ +} curl_ftpmethod; + +/* bitmask defines for CURLOPT_HEADEROPT */ +#define CURLHEADER_UNIFIED 0 +#define CURLHEADER_SEPARATE (1<<0) + +/* CURLPROTO_ defines are for the CURLOPT_*PROTOCOLS options */ +#define CURLPROTO_HTTP (1<<0) +#define CURLPROTO_HTTPS (1<<1) +#define CURLPROTO_FTP (1<<2) +#define CURLPROTO_FTPS (1<<3) +#define CURLPROTO_SCP (1<<4) +#define CURLPROTO_SFTP (1<<5) +#define CURLPROTO_TELNET (1<<6) +#define CURLPROTO_LDAP (1<<7) +#define CURLPROTO_LDAPS (1<<8) +#define CURLPROTO_DICT (1<<9) +#define CURLPROTO_FILE (1<<10) +#define CURLPROTO_TFTP (1<<11) +#define CURLPROTO_IMAP (1<<12) +#define CURLPROTO_IMAPS (1<<13) +#define CURLPROTO_POP3 (1<<14) +#define CURLPROTO_POP3S (1<<15) +#define CURLPROTO_SMTP (1<<16) +#define CURLPROTO_SMTPS (1<<17) +#define CURLPROTO_RTSP (1<<18) +#define CURLPROTO_RTMP (1<<19) +#define CURLPROTO_RTMPT (1<<20) +#define CURLPROTO_RTMPE (1<<21) +#define CURLPROTO_RTMPTE (1<<22) +#define CURLPROTO_RTMPS (1<<23) +#define CURLPROTO_RTMPTS (1<<24) +#define CURLPROTO_GOPHER (1<<25) +#define CURLPROTO_ALL (~0) /* enable everything */ + +/* long may be 32 or 64 bits, but we should never depend on anything else + but 32 */ +#define CURLOPTTYPE_LONG 0 +#define CURLOPTTYPE_OBJECTPOINT 10000 +#define CURLOPTTYPE_FUNCTIONPOINT 20000 +#define CURLOPTTYPE_OFF_T 30000 + +/* name is uppercase CURLOPT_, + type is one of the defined CURLOPTTYPE_ + number is unique identifier */ +#ifdef CINIT +#undef CINIT +#endif + +#ifdef CURL_ISOCPP +#define CINIT(na,t,nu) CURLOPT_ ## na = CURLOPTTYPE_ ## t + nu +#else +/* The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */ +#define LONG CURLOPTTYPE_LONG +#define OBJECTPOINT CURLOPTTYPE_OBJECTPOINT +#define FUNCTIONPOINT CURLOPTTYPE_FUNCTIONPOINT +#define OFF_T CURLOPTTYPE_OFF_T +#define CINIT(name,type,number) CURLOPT_/**/name = type + number +#endif + +/* + * This macro-mania below setups the CURLOPT_[what] enum, to be used with + * curl_easy_setopt(). The first argument in the CINIT() macro is the [what] + * word. + */ + +typedef enum { + /* This is the FILE * or void * the regular output should be written to. */ + CINIT(FILE, OBJECTPOINT, 1), + + /* The full URL to get/put */ + CINIT(URL, OBJECTPOINT, 2), + + /* Port number to connect to, if other than default. */ + CINIT(PORT, LONG, 3), + + /* Name of proxy to use. */ + CINIT(PROXY, OBJECTPOINT, 4), + + /* "user:password;options" to use when fetching. */ + CINIT(USERPWD, OBJECTPOINT, 5), + + /* "user:password" to use with proxy. */ + CINIT(PROXYUSERPWD, OBJECTPOINT, 6), + + /* Range to get, specified as an ASCII string. */ + CINIT(RANGE, OBJECTPOINT, 7), + + /* not used */ + + /* Specified file stream to upload from (use as input): */ + CINIT(INFILE, OBJECTPOINT, 9), + + /* Buffer to receive error messages in, must be at least CURL_ERROR_SIZE + * bytes big. If this is not used, error messages go to stderr instead: */ + CINIT(ERRORBUFFER, OBJECTPOINT, 10), + + /* Function that will be called to store the output (instead of fwrite). The + * parameters will use fwrite() syntax, make sure to follow them. */ + CINIT(WRITEFUNCTION, FUNCTIONPOINT, 11), + + /* Function that will be called to read the input (instead of fread). The + * parameters will use fread() syntax, make sure to follow them. */ + CINIT(READFUNCTION, FUNCTIONPOINT, 12), + + /* Time-out the read operation after this amount of seconds */ + CINIT(TIMEOUT, LONG, 13), + + /* If the CURLOPT_INFILE is used, this can be used to inform libcurl about + * how large the file being sent really is. That allows better error + * checking and better verifies that the upload was successful. -1 means + * unknown size. + * + * For large file support, there is also a _LARGE version of the key + * which takes an off_t type, allowing platforms with larger off_t + * sizes to handle larger files. See below for INFILESIZE_LARGE. + */ + CINIT(INFILESIZE, LONG, 14), + + /* POST static input fields. */ + CINIT(POSTFIELDS, OBJECTPOINT, 15), + + /* Set the referrer page (needed by some CGIs) */ + CINIT(REFERER, OBJECTPOINT, 16), + + /* Set the FTP PORT string (interface name, named or numerical IP address) + Use i.e '-' to use default address. */ + CINIT(FTPPORT, OBJECTPOINT, 17), + + /* Set the User-Agent string (examined by some CGIs) */ + CINIT(USERAGENT, OBJECTPOINT, 18), + + /* If the download receives less than "low speed limit" bytes/second + * during "low speed time" seconds, the operations is aborted. + * You could i.e if you have a pretty high speed connection, abort if + * it is less than 2000 bytes/sec during 20 seconds. + */ + + /* Set the "low speed limit" */ + CINIT(LOW_SPEED_LIMIT, LONG, 19), + + /* Set the "low speed time" */ + CINIT(LOW_SPEED_TIME, LONG, 20), + + /* Set the continuation offset. + * + * Note there is also a _LARGE version of this key which uses + * off_t types, allowing for large file offsets on platforms which + * use larger-than-32-bit off_t's. Look below for RESUME_FROM_LARGE. + */ + CINIT(RESUME_FROM, LONG, 21), + + /* Set cookie in request: */ + CINIT(COOKIE, OBJECTPOINT, 22), + + /* This points to a linked list of headers, struct curl_slist kind. This + list is also used for RTSP (in spite of its name) */ + CINIT(HTTPHEADER, OBJECTPOINT, 23), + + /* This points to a linked list of post entries, struct curl_httppost */ + CINIT(HTTPPOST, OBJECTPOINT, 24), + + /* name of the file keeping your private SSL-certificate */ + CINIT(SSLCERT, OBJECTPOINT, 25), + + /* password for the SSL or SSH private key */ + CINIT(KEYPASSWD, OBJECTPOINT, 26), + + /* send TYPE parameter? */ + CINIT(CRLF, LONG, 27), + + /* send linked-list of QUOTE commands */ + CINIT(QUOTE, OBJECTPOINT, 28), + + /* send FILE * or void * to store headers to, if you use a callback it + is simply passed to the callback unmodified */ + CINIT(WRITEHEADER, OBJECTPOINT, 29), + + /* point to a file to read the initial cookies from, also enables + "cookie awareness" */ + CINIT(COOKIEFILE, OBJECTPOINT, 31), + + /* What version to specifically try to use. + See CURL_SSLVERSION defines below. */ + CINIT(SSLVERSION, LONG, 32), + + /* What kind of HTTP time condition to use, see defines */ + CINIT(TIMECONDITION, LONG, 33), + + /* Time to use with the above condition. Specified in number of seconds + since 1 Jan 1970 */ + CINIT(TIMEVALUE, LONG, 34), + + /* 35 = OBSOLETE */ + + /* Custom request, for customizing the get command like + HTTP: DELETE, TRACE and others + FTP: to use a different list command + */ + CINIT(CUSTOMREQUEST, OBJECTPOINT, 36), + + /* HTTP request, for odd commands like DELETE, TRACE and others */ + CINIT(STDERR, OBJECTPOINT, 37), + + /* 38 is not used */ + + /* send linked-list of post-transfer QUOTE commands */ + CINIT(POSTQUOTE, OBJECTPOINT, 39), + + CINIT(WRITEINFO, OBJECTPOINT, 40), /* DEPRECATED, do not use! */ + + CINIT(VERBOSE, LONG, 41), /* talk a lot */ + CINIT(HEADER, LONG, 42), /* throw the header out too */ + CINIT(NOPROGRESS, LONG, 43), /* shut off the progress meter */ + CINIT(NOBODY, LONG, 44), /* use HEAD to get http document */ + CINIT(FAILONERROR, LONG, 45), /* no output on http error codes >= 300 */ + CINIT(UPLOAD, LONG, 46), /* this is an upload */ + CINIT(POST, LONG, 47), /* HTTP POST method */ + CINIT(DIRLISTONLY, LONG, 48), /* bare names when listing directories */ + + CINIT(APPEND, LONG, 50), /* Append instead of overwrite on upload! */ + + /* Specify whether to read the user+password from the .netrc or the URL. + * This must be one of the CURL_NETRC_* enums below. */ + CINIT(NETRC, LONG, 51), + + CINIT(FOLLOWLOCATION, LONG, 52), /* use Location: Luke! */ + + CINIT(TRANSFERTEXT, LONG, 53), /* transfer data in text/ASCII format */ + CINIT(PUT, LONG, 54), /* HTTP PUT */ + + /* 55 = OBSOLETE */ + + /* DEPRECATED + * Function that will be called instead of the internal progress display + * function. This function should be defined as the curl_progress_callback + * prototype defines. */ + CINIT(PROGRESSFUNCTION, FUNCTIONPOINT, 56), + + /* Data passed to the CURLOPT_PROGRESSFUNCTION and CURLOPT_XFERINFOFUNCTION + callbacks */ + CINIT(PROGRESSDATA, OBJECTPOINT, 57), +#define CURLOPT_XFERINFODATA CURLOPT_PROGRESSDATA + + /* We want the referrer field set automatically when following locations */ + CINIT(AUTOREFERER, LONG, 58), + + /* Port of the proxy, can be set in the proxy string as well with: + "[host]:[port]" */ + CINIT(PROXYPORT, LONG, 59), + + /* size of the POST input data, if strlen() is not good to use */ + CINIT(POSTFIELDSIZE, LONG, 60), + + /* tunnel non-http operations through a HTTP proxy */ + CINIT(HTTPPROXYTUNNEL, LONG, 61), + + /* Set the interface string to use as outgoing network interface */ + CINIT(INTERFACE, OBJECTPOINT, 62), + + /* Set the krb4/5 security level, this also enables krb4/5 awareness. This + * is a string, 'clear', 'safe', 'confidential' or 'private'. If the string + * is set but doesn't match one of these, 'private' will be used. */ + CINIT(KRBLEVEL, OBJECTPOINT, 63), + + /* Set if we should verify the peer in ssl handshake, set 1 to verify. */ + CINIT(SSL_VERIFYPEER, LONG, 64), + + /* The CApath or CAfile used to validate the peer certificate + this option is used only if SSL_VERIFYPEER is true */ + CINIT(CAINFO, OBJECTPOINT, 65), + + /* 66 = OBSOLETE */ + /* 67 = OBSOLETE */ + + /* Maximum number of http redirects to follow */ + CINIT(MAXREDIRS, LONG, 68), + + /* Pass a long set to 1 to get the date of the requested document (if + possible)! Pass a zero to shut it off. */ + CINIT(FILETIME, LONG, 69), + + /* This points to a linked list of telnet options */ + CINIT(TELNETOPTIONS, OBJECTPOINT, 70), + + /* Max amount of cached alive connections */ + CINIT(MAXCONNECTS, LONG, 71), + + CINIT(CLOSEPOLICY, LONG, 72), /* DEPRECATED, do not use! */ + + /* 73 = OBSOLETE */ + + /* Set to explicitly use a new connection for the upcoming transfer. + Do not use this unless you're absolutely sure of this, as it makes the + operation slower and is less friendly for the network. */ + CINIT(FRESH_CONNECT, LONG, 74), + + /* Set to explicitly forbid the upcoming transfer's connection to be re-used + when done. Do not use this unless you're absolutely sure of this, as it + makes the operation slower and is less friendly for the network. */ + CINIT(FORBID_REUSE, LONG, 75), + + /* Set to a file name that contains random data for libcurl to use to + seed the random engine when doing SSL connects. */ + CINIT(RANDOM_FILE, OBJECTPOINT, 76), + + /* Set to the Entropy Gathering Daemon socket pathname */ + CINIT(EGDSOCKET, OBJECTPOINT, 77), + + /* Time-out connect operations after this amount of seconds, if connects are + OK within this time, then fine... This only aborts the connect phase. */ + CINIT(CONNECTTIMEOUT, LONG, 78), + + /* Function that will be called to store headers (instead of fwrite). The + * parameters will use fwrite() syntax, make sure to follow them. */ + CINIT(HEADERFUNCTION, FUNCTIONPOINT, 79), + + /* Set this to force the HTTP request to get back to GET. Only really usable + if POST, PUT or a custom request have been used first. + */ + CINIT(HTTPGET, LONG, 80), + + /* Set if we should verify the Common name from the peer certificate in ssl + * handshake, set 1 to check existence, 2 to ensure that it matches the + * provided hostname. */ + CINIT(SSL_VERIFYHOST, LONG, 81), + + /* Specify which file name to write all known cookies in after completed + operation. Set file name to "-" (dash) to make it go to stdout. */ + CINIT(COOKIEJAR, OBJECTPOINT, 82), + + /* Specify which SSL ciphers to use */ + CINIT(SSL_CIPHER_LIST, OBJECTPOINT, 83), + + /* Specify which HTTP version to use! This must be set to one of the + CURL_HTTP_VERSION* enums set below. */ + CINIT(HTTP_VERSION, LONG, 84), + + /* Specifically switch on or off the FTP engine's use of the EPSV command. By + default, that one will always be attempted before the more traditional + PASV command. */ + CINIT(FTP_USE_EPSV, LONG, 85), + + /* type of the file keeping your SSL-certificate ("DER", "PEM", "ENG") */ + CINIT(SSLCERTTYPE, OBJECTPOINT, 86), + + /* name of the file keeping your private SSL-key */ + CINIT(SSLKEY, OBJECTPOINT, 87), + + /* type of the file keeping your private SSL-key ("DER", "PEM", "ENG") */ + CINIT(SSLKEYTYPE, OBJECTPOINT, 88), + + /* crypto engine for the SSL-sub system */ + CINIT(SSLENGINE, OBJECTPOINT, 89), + + /* set the crypto engine for the SSL-sub system as default + the param has no meaning... + */ + CINIT(SSLENGINE_DEFAULT, LONG, 90), + + /* Non-zero value means to use the global dns cache */ + CINIT(DNS_USE_GLOBAL_CACHE, LONG, 91), /* DEPRECATED, do not use! */ + + /* DNS cache timeout */ + CINIT(DNS_CACHE_TIMEOUT, LONG, 92), + + /* send linked-list of pre-transfer QUOTE commands */ + CINIT(PREQUOTE, OBJECTPOINT, 93), + + /* set the debug function */ + CINIT(DEBUGFUNCTION, FUNCTIONPOINT, 94), + + /* set the data for the debug function */ + CINIT(DEBUGDATA, OBJECTPOINT, 95), + + /* mark this as start of a cookie session */ + CINIT(COOKIESESSION, LONG, 96), + + /* The CApath directory used to validate the peer certificate + this option is used only if SSL_VERIFYPEER is true */ + CINIT(CAPATH, OBJECTPOINT, 97), + + /* Instruct libcurl to use a smaller receive buffer */ + CINIT(BUFFERSIZE, LONG, 98), + + /* Instruct libcurl to not use any signal/alarm handlers, even when using + timeouts. This option is useful for multi-threaded applications. + See libcurl-the-guide for more background information. */ + CINIT(NOSIGNAL, LONG, 99), + + /* Provide a CURLShare for mutexing non-ts data */ + CINIT(SHARE, OBJECTPOINT, 100), + + /* indicates type of proxy. accepted values are CURLPROXY_HTTP (default), + CURLPROXY_SOCKS4, CURLPROXY_SOCKS4A and CURLPROXY_SOCKS5. */ + CINIT(PROXYTYPE, LONG, 101), + + /* Set the Accept-Encoding string. Use this to tell a server you would like + the response to be compressed. Before 7.21.6, this was known as + CURLOPT_ENCODING */ + CINIT(ACCEPT_ENCODING, OBJECTPOINT, 102), + + /* Set pointer to private data */ + CINIT(PRIVATE, OBJECTPOINT, 103), + + /* Set aliases for HTTP 200 in the HTTP Response header */ + CINIT(HTTP200ALIASES, OBJECTPOINT, 104), + + /* Continue to send authentication (user+password) when following locations, + even when hostname changed. This can potentially send off the name + and password to whatever host the server decides. */ + CINIT(UNRESTRICTED_AUTH, LONG, 105), + + /* Specifically switch on or off the FTP engine's use of the EPRT command ( + it also disables the LPRT attempt). By default, those ones will always be + attempted before the good old traditional PORT command. */ + CINIT(FTP_USE_EPRT, LONG, 106), + + /* Set this to a bitmask value to enable the particular authentications + methods you like. Use this in combination with CURLOPT_USERPWD. + Note that setting multiple bits may cause extra network round-trips. */ + CINIT(HTTPAUTH, LONG, 107), + + /* Set the ssl context callback function, currently only for OpenSSL ssl_ctx + in second argument. The function must be matching the + curl_ssl_ctx_callback proto. */ + CINIT(SSL_CTX_FUNCTION, FUNCTIONPOINT, 108), + + /* Set the userdata for the ssl context callback function's third + argument */ + CINIT(SSL_CTX_DATA, OBJECTPOINT, 109), + + /* FTP Option that causes missing dirs to be created on the remote server. + In 7.19.4 we introduced the convenience enums for this option using the + CURLFTP_CREATE_DIR prefix. + */ + CINIT(FTP_CREATE_MISSING_DIRS, LONG, 110), + + /* Set this to a bitmask value to enable the particular authentications + methods you like. Use this in combination with CURLOPT_PROXYUSERPWD. + Note that setting multiple bits may cause extra network round-trips. */ + CINIT(PROXYAUTH, LONG, 111), + + /* FTP option that changes the timeout, in seconds, associated with + getting a response. This is different from transfer timeout time and + essentially places a demand on the FTP server to acknowledge commands + in a timely manner. */ + CINIT(FTP_RESPONSE_TIMEOUT, LONG, 112), +#define CURLOPT_SERVER_RESPONSE_TIMEOUT CURLOPT_FTP_RESPONSE_TIMEOUT + + /* Set this option to one of the CURL_IPRESOLVE_* defines (see below) to + tell libcurl to resolve names to those IP versions only. This only has + affect on systems with support for more than one, i.e IPv4 _and_ IPv6. */ + CINIT(IPRESOLVE, LONG, 113), + + /* Set this option to limit the size of a file that will be downloaded from + an HTTP or FTP server. + + Note there is also _LARGE version which adds large file support for + platforms which have larger off_t sizes. See MAXFILESIZE_LARGE below. */ + CINIT(MAXFILESIZE, LONG, 114), + + /* See the comment for INFILESIZE above, but in short, specifies + * the size of the file being uploaded. -1 means unknown. + */ + CINIT(INFILESIZE_LARGE, OFF_T, 115), + + /* Sets the continuation offset. There is also a LONG version of this; + * look above for RESUME_FROM. + */ + CINIT(RESUME_FROM_LARGE, OFF_T, 116), + + /* Sets the maximum size of data that will be downloaded from + * an HTTP or FTP server. See MAXFILESIZE above for the LONG version. + */ + CINIT(MAXFILESIZE_LARGE, OFF_T, 117), + + /* Set this option to the file name of your .netrc file you want libcurl + to parse (using the CURLOPT_NETRC option). If not set, libcurl will do + a poor attempt to find the user's home directory and check for a .netrc + file in there. */ + CINIT(NETRC_FILE, OBJECTPOINT, 118), + + /* Enable SSL/TLS for FTP, pick one of: + CURLUSESSL_TRY - try using SSL, proceed anyway otherwise + CURLUSESSL_CONTROL - SSL for the control connection or fail + CURLUSESSL_ALL - SSL for all communication or fail + */ + CINIT(USE_SSL, LONG, 119), + + /* The _LARGE version of the standard POSTFIELDSIZE option */ + CINIT(POSTFIELDSIZE_LARGE, OFF_T, 120), + + /* Enable/disable the TCP Nagle algorithm */ + CINIT(TCP_NODELAY, LONG, 121), + + /* 122 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */ + /* 123 OBSOLETE. Gone in 7.16.0 */ + /* 124 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */ + /* 125 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */ + /* 126 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */ + /* 127 OBSOLETE. Gone in 7.16.0 */ + /* 128 OBSOLETE. Gone in 7.16.0 */ + + /* When FTP over SSL/TLS is selected (with CURLOPT_USE_SSL), this option + can be used to change libcurl's default action which is to first try + "AUTH SSL" and then "AUTH TLS" in this order, and proceed when a OK + response has been received. + + Available parameters are: + CURLFTPAUTH_DEFAULT - let libcurl decide + CURLFTPAUTH_SSL - try "AUTH SSL" first, then TLS + CURLFTPAUTH_TLS - try "AUTH TLS" first, then SSL + */ + CINIT(FTPSSLAUTH, LONG, 129), + + CINIT(IOCTLFUNCTION, FUNCTIONPOINT, 130), + CINIT(IOCTLDATA, OBJECTPOINT, 131), + + /* 132 OBSOLETE. Gone in 7.16.0 */ + /* 133 OBSOLETE. Gone in 7.16.0 */ + + /* zero terminated string for pass on to the FTP server when asked for + "account" info */ + CINIT(FTP_ACCOUNT, OBJECTPOINT, 134), + + /* feed cookies into cookie engine */ + CINIT(COOKIELIST, OBJECTPOINT, 135), + + /* ignore Content-Length */ + CINIT(IGNORE_CONTENT_LENGTH, LONG, 136), + + /* Set to non-zero to skip the IP address received in a 227 PASV FTP server + response. Typically used for FTP-SSL purposes but is not restricted to + that. libcurl will then instead use the same IP address it used for the + control connection. */ + CINIT(FTP_SKIP_PASV_IP, LONG, 137), + + /* Select "file method" to use when doing FTP, see the curl_ftpmethod + above. */ + CINIT(FTP_FILEMETHOD, LONG, 138), + + /* Local port number to bind the socket to */ + CINIT(LOCALPORT, LONG, 139), + + /* Number of ports to try, including the first one set with LOCALPORT. + Thus, setting it to 1 will make no additional attempts but the first. + */ + CINIT(LOCALPORTRANGE, LONG, 140), + + /* no transfer, set up connection and let application use the socket by + extracting it with CURLINFO_LASTSOCKET */ + CINIT(CONNECT_ONLY, LONG, 141), + + /* Function that will be called to convert from the + network encoding (instead of using the iconv calls in libcurl) */ + CINIT(CONV_FROM_NETWORK_FUNCTION, FUNCTIONPOINT, 142), + + /* Function that will be called to convert to the + network encoding (instead of using the iconv calls in libcurl) */ + CINIT(CONV_TO_NETWORK_FUNCTION, FUNCTIONPOINT, 143), + + /* Function that will be called to convert from UTF8 + (instead of using the iconv calls in libcurl) + Note that this is used only for SSL certificate processing */ + CINIT(CONV_FROM_UTF8_FUNCTION, FUNCTIONPOINT, 144), + + /* if the connection proceeds too quickly then need to slow it down */ + /* limit-rate: maximum number of bytes per second to send or receive */ + CINIT(MAX_SEND_SPEED_LARGE, OFF_T, 145), + CINIT(MAX_RECV_SPEED_LARGE, OFF_T, 146), + + /* Pointer to command string to send if USER/PASS fails. */ + CINIT(FTP_ALTERNATIVE_TO_USER, OBJECTPOINT, 147), + + /* callback function for setting socket options */ + CINIT(SOCKOPTFUNCTION, FUNCTIONPOINT, 148), + CINIT(SOCKOPTDATA, OBJECTPOINT, 149), + + /* set to 0 to disable session ID re-use for this transfer, default is + enabled (== 1) */ + CINIT(SSL_SESSIONID_CACHE, LONG, 150), + + /* allowed SSH authentication methods */ + CINIT(SSH_AUTH_TYPES, LONG, 151), + + /* Used by scp/sftp to do public/private key authentication */ + CINIT(SSH_PUBLIC_KEYFILE, OBJECTPOINT, 152), + CINIT(SSH_PRIVATE_KEYFILE, OBJECTPOINT, 153), + + /* Send CCC (Clear Command Channel) after authentication */ + CINIT(FTP_SSL_CCC, LONG, 154), + + /* Same as TIMEOUT and CONNECTTIMEOUT, but with ms resolution */ + CINIT(TIMEOUT_MS, LONG, 155), + CINIT(CONNECTTIMEOUT_MS, LONG, 156), + + /* set to zero to disable the libcurl's decoding and thus pass the raw body + data to the application even when it is encoded/compressed */ + CINIT(HTTP_TRANSFER_DECODING, LONG, 157), + CINIT(HTTP_CONTENT_DECODING, LONG, 158), + + /* Permission used when creating new files and directories on the remote + server for protocols that support it, SFTP/SCP/FILE */ + CINIT(NEW_FILE_PERMS, LONG, 159), + CINIT(NEW_DIRECTORY_PERMS, LONG, 160), + + /* Set the behaviour of POST when redirecting. Values must be set to one + of CURL_REDIR* defines below. This used to be called CURLOPT_POST301 */ + CINIT(POSTREDIR, LONG, 161), + + /* used by scp/sftp to verify the host's public key */ + CINIT(SSH_HOST_PUBLIC_KEY_MD5, OBJECTPOINT, 162), + + /* Callback function for opening socket (instead of socket(2)). Optionally, + callback is able change the address or refuse to connect returning + CURL_SOCKET_BAD. The callback should have type + curl_opensocket_callback */ + CINIT(OPENSOCKETFUNCTION, FUNCTIONPOINT, 163), + CINIT(OPENSOCKETDATA, OBJECTPOINT, 164), + + /* POST volatile input fields. */ + CINIT(COPYPOSTFIELDS, OBJECTPOINT, 165), + + /* set transfer mode (;type=) when doing FTP via an HTTP proxy */ + CINIT(PROXY_TRANSFER_MODE, LONG, 166), + + /* Callback function for seeking in the input stream */ + CINIT(SEEKFUNCTION, FUNCTIONPOINT, 167), + CINIT(SEEKDATA, OBJECTPOINT, 168), + + /* CRL file */ + CINIT(CRLFILE, OBJECTPOINT, 169), + + /* Issuer certificate */ + CINIT(ISSUERCERT, OBJECTPOINT, 170), + + /* (IPv6) Address scope */ + CINIT(ADDRESS_SCOPE, LONG, 171), + + /* Collect certificate chain info and allow it to get retrievable with + CURLINFO_CERTINFO after the transfer is complete. */ + CINIT(CERTINFO, LONG, 172), + + /* "name" and "pwd" to use when fetching. */ + CINIT(USERNAME, OBJECTPOINT, 173), + CINIT(PASSWORD, OBJECTPOINT, 174), + + /* "name" and "pwd" to use with Proxy when fetching. */ + CINIT(PROXYUSERNAME, OBJECTPOINT, 175), + CINIT(PROXYPASSWORD, OBJECTPOINT, 176), + + /* Comma separated list of hostnames defining no-proxy zones. These should + match both hostnames directly, and hostnames within a domain. For + example, local.com will match local.com and www.local.com, but NOT + notlocal.com or www.notlocal.com. For compatibility with other + implementations of this, .local.com will be considered to be the same as + local.com. A single * is the only valid wildcard, and effectively + disables the use of proxy. */ + CINIT(NOPROXY, OBJECTPOINT, 177), + + /* block size for TFTP transfers */ + CINIT(TFTP_BLKSIZE, LONG, 178), + + /* Socks Service */ + CINIT(SOCKS5_GSSAPI_SERVICE, OBJECTPOINT, 179), + + /* Socks Service */ + CINIT(SOCKS5_GSSAPI_NEC, LONG, 180), + + /* set the bitmask for the protocols that are allowed to be used for the + transfer, which thus helps the app which takes URLs from users or other + external inputs and want to restrict what protocol(s) to deal + with. Defaults to CURLPROTO_ALL. */ + CINIT(PROTOCOLS, LONG, 181), + + /* set the bitmask for the protocols that libcurl is allowed to follow to, + as a subset of the CURLOPT_PROTOCOLS ones. That means the protocol needs + to be set in both bitmasks to be allowed to get redirected to. Defaults + to all protocols except FILE and SCP. */ + CINIT(REDIR_PROTOCOLS, LONG, 182), + + /* set the SSH knownhost file name to use */ + CINIT(SSH_KNOWNHOSTS, OBJECTPOINT, 183), + + /* set the SSH host key callback, must point to a curl_sshkeycallback + function */ + CINIT(SSH_KEYFUNCTION, FUNCTIONPOINT, 184), + + /* set the SSH host key callback custom pointer */ + CINIT(SSH_KEYDATA, OBJECTPOINT, 185), + + /* set the SMTP mail originator */ + CINIT(MAIL_FROM, OBJECTPOINT, 186), + + /* set the SMTP mail receiver(s) */ + CINIT(MAIL_RCPT, OBJECTPOINT, 187), + + /* FTP: send PRET before PASV */ + CINIT(FTP_USE_PRET, LONG, 188), + + /* RTSP request method (OPTIONS, SETUP, PLAY, etc...) */ + CINIT(RTSP_REQUEST, LONG, 189), + + /* The RTSP session identifier */ + CINIT(RTSP_SESSION_ID, OBJECTPOINT, 190), + + /* The RTSP stream URI */ + CINIT(RTSP_STREAM_URI, OBJECTPOINT, 191), + + /* The Transport: header to use in RTSP requests */ + CINIT(RTSP_TRANSPORT, OBJECTPOINT, 192), + + /* Manually initialize the client RTSP CSeq for this handle */ + CINIT(RTSP_CLIENT_CSEQ, LONG, 193), + + /* Manually initialize the server RTSP CSeq for this handle */ + CINIT(RTSP_SERVER_CSEQ, LONG, 194), + + /* The stream to pass to INTERLEAVEFUNCTION. */ + CINIT(INTERLEAVEDATA, OBJECTPOINT, 195), + + /* Let the application define a custom write method for RTP data */ + CINIT(INTERLEAVEFUNCTION, FUNCTIONPOINT, 196), + + /* Turn on wildcard matching */ + CINIT(WILDCARDMATCH, LONG, 197), + + /* Directory matching callback called before downloading of an + individual file (chunk) started */ + CINIT(CHUNK_BGN_FUNCTION, FUNCTIONPOINT, 198), + + /* Directory matching callback called after the file (chunk) + was downloaded, or skipped */ + CINIT(CHUNK_END_FUNCTION, FUNCTIONPOINT, 199), + + /* Change match (fnmatch-like) callback for wildcard matching */ + CINIT(FNMATCH_FUNCTION, FUNCTIONPOINT, 200), + + /* Let the application define custom chunk data pointer */ + CINIT(CHUNK_DATA, OBJECTPOINT, 201), + + /* FNMATCH_FUNCTION user pointer */ + CINIT(FNMATCH_DATA, OBJECTPOINT, 202), + + /* send linked-list of name:port:address sets */ + CINIT(RESOLVE, OBJECTPOINT, 203), + + /* Set a username for authenticated TLS */ + CINIT(TLSAUTH_USERNAME, OBJECTPOINT, 204), + + /* Set a password for authenticated TLS */ + CINIT(TLSAUTH_PASSWORD, OBJECTPOINT, 205), + + /* Set authentication type for authenticated TLS */ + CINIT(TLSAUTH_TYPE, OBJECTPOINT, 206), + + /* Set to 1 to enable the "TE:" header in HTTP requests to ask for + compressed transfer-encoded responses. Set to 0 to disable the use of TE: + in outgoing requests. The current default is 0, but it might change in a + future libcurl release. + + libcurl will ask for the compressed methods it knows of, and if that + isn't any, it will not ask for transfer-encoding at all even if this + option is set to 1. + + */ + CINIT(TRANSFER_ENCODING, LONG, 207), + + /* Callback function for closing socket (instead of close(2)). The callback + should have type curl_closesocket_callback */ + CINIT(CLOSESOCKETFUNCTION, FUNCTIONPOINT, 208), + CINIT(CLOSESOCKETDATA, OBJECTPOINT, 209), + + /* allow GSSAPI credential delegation */ + CINIT(GSSAPI_DELEGATION, LONG, 210), + + /* Set the name servers to use for DNS resolution */ + CINIT(DNS_SERVERS, OBJECTPOINT, 211), + + /* Time-out accept operations (currently for FTP only) after this amount + of miliseconds. */ + CINIT(ACCEPTTIMEOUT_MS, LONG, 212), + + /* Set TCP keepalive */ + CINIT(TCP_KEEPALIVE, LONG, 213), + + /* non-universal keepalive knobs (Linux, AIX, HP-UX, more) */ + CINIT(TCP_KEEPIDLE, LONG, 214), + CINIT(TCP_KEEPINTVL, LONG, 215), + + /* Enable/disable specific SSL features with a bitmask, see CURLSSLOPT_* */ + CINIT(SSL_OPTIONS, LONG, 216), + + /* Set the SMTP auth originator */ + CINIT(MAIL_AUTH, OBJECTPOINT, 217), + + /* Enable/disable SASL initial response */ + CINIT(SASL_IR, LONG, 218), + + /* Function that will be called instead of the internal progress display + * function. This function should be defined as the curl_xferinfo_callback + * prototype defines. (Deprecates CURLOPT_PROGRESSFUNCTION) */ + CINIT(XFERINFOFUNCTION, FUNCTIONPOINT, 219), + + /* The XOAUTH2 bearer token */ + CINIT(XOAUTH2_BEARER, OBJECTPOINT, 220), + + /* Set the interface string to use as outgoing network + * interface for DNS requests. + * Only supported by the c-ares DNS backend */ + CINIT(DNS_INTERFACE, OBJECTPOINT, 221), + + /* Set the local IPv4 address to use for outgoing DNS requests. + * Only supported by the c-ares DNS backend */ + CINIT(DNS_LOCAL_IP4, OBJECTPOINT, 222), + + /* Set the local IPv4 address to use for outgoing DNS requests. + * Only supported by the c-ares DNS backend */ + CINIT(DNS_LOCAL_IP6, OBJECTPOINT, 223), + + /* Set authentication options directly */ + CINIT(LOGIN_OPTIONS, OBJECTPOINT, 224), + + /* Enable/disable TLS NPN extension (http2 over ssl might fail without) */ + CINIT(SSL_ENABLE_NPN, LONG, 225), + + /* Enable/disable TLS ALPN extension (http2 over ssl might fail without) */ + CINIT(SSL_ENABLE_ALPN, LONG, 226), + + /* Time to wait for a response to a HTTP request containing an + * Expect: 100-continue header before sending the data anyway. */ + CINIT(EXPECT_100_TIMEOUT_MS, LONG, 227), + + /* This points to a linked list of headers used for proxy requests only, + struct curl_slist kind */ + CINIT(PROXYHEADER, OBJECTPOINT, 228), + + /* Pass in a bitmask of "header options" */ + CINIT(HEADEROPT, LONG, 229), + + CURLOPT_LASTENTRY /* the last unused */ +} CURLoption; + +#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all + the obsolete stuff removed! */ + +/* Backwards compatibility with older names */ +/* These are scheduled to disappear by 2011 */ + +/* This was added in version 7.19.1 */ +#define CURLOPT_POST301 CURLOPT_POSTREDIR + +/* These are scheduled to disappear by 2009 */ + +/* The following were added in 7.17.0 */ +#define CURLOPT_SSLKEYPASSWD CURLOPT_KEYPASSWD +#define CURLOPT_FTPAPPEND CURLOPT_APPEND +#define CURLOPT_FTPLISTONLY CURLOPT_DIRLISTONLY +#define CURLOPT_FTP_SSL CURLOPT_USE_SSL + +/* The following were added earlier */ + +#define CURLOPT_SSLCERTPASSWD CURLOPT_KEYPASSWD +#define CURLOPT_KRB4LEVEL CURLOPT_KRBLEVEL + +#else +/* This is set if CURL_NO_OLDIES is defined at compile-time */ +#undef CURLOPT_DNS_USE_GLOBAL_CACHE /* soon obsolete */ +#endif + + + /* Below here follows defines for the CURLOPT_IPRESOLVE option. If a host + name resolves addresses using more than one IP protocol version, this + option might be handy to force libcurl to use a specific IP version. */ +#define CURL_IPRESOLVE_WHATEVER 0 /* default, resolves addresses to all IP + versions that your system allows */ +#define CURL_IPRESOLVE_V4 1 /* resolve to ipv4 addresses */ +#define CURL_IPRESOLVE_V6 2 /* resolve to ipv6 addresses */ + + /* three convenient "aliases" that follow the name scheme better */ +#define CURLOPT_WRITEDATA CURLOPT_FILE +#define CURLOPT_READDATA CURLOPT_INFILE +#define CURLOPT_HEADERDATA CURLOPT_WRITEHEADER +#define CURLOPT_RTSPHEADER CURLOPT_HTTPHEADER + + /* These enums are for use with the CURLOPT_HTTP_VERSION option. */ +enum { + CURL_HTTP_VERSION_NONE, /* setting this means we don't care, and that we'd + like the library to choose the best possible + for us! */ + CURL_HTTP_VERSION_1_0, /* please use HTTP 1.0 in the request */ + CURL_HTTP_VERSION_1_1, /* please use HTTP 1.1 in the request */ + CURL_HTTP_VERSION_2_0, /* please use HTTP 2.0 in the request */ + + CURL_HTTP_VERSION_LAST /* *ILLEGAL* http version */ +}; + +/* + * Public API enums for RTSP requests + */ +enum { + CURL_RTSPREQ_NONE, /* first in list */ + CURL_RTSPREQ_OPTIONS, + CURL_RTSPREQ_DESCRIBE, + CURL_RTSPREQ_ANNOUNCE, + CURL_RTSPREQ_SETUP, + CURL_RTSPREQ_PLAY, + CURL_RTSPREQ_PAUSE, + CURL_RTSPREQ_TEARDOWN, + CURL_RTSPREQ_GET_PARAMETER, + CURL_RTSPREQ_SET_PARAMETER, + CURL_RTSPREQ_RECORD, + CURL_RTSPREQ_RECEIVE, + CURL_RTSPREQ_LAST /* last in list */ +}; + + /* These enums are for use with the CURLOPT_NETRC option. */ +enum CURL_NETRC_OPTION { + CURL_NETRC_IGNORED, /* The .netrc will never be read. + * This is the default. */ + CURL_NETRC_OPTIONAL, /* A user:password in the URL will be preferred + * to one in the .netrc. */ + CURL_NETRC_REQUIRED, /* A user:password in the URL will be ignored. + * Unless one is set programmatically, the .netrc + * will be queried. */ + CURL_NETRC_LAST +}; + +enum { + CURL_SSLVERSION_DEFAULT, + CURL_SSLVERSION_TLSv1, /* TLS 1.x */ + CURL_SSLVERSION_SSLv2, + CURL_SSLVERSION_SSLv3, + CURL_SSLVERSION_TLSv1_0, + CURL_SSLVERSION_TLSv1_1, + CURL_SSLVERSION_TLSv1_2, + + CURL_SSLVERSION_LAST /* never use, keep last */ +}; + +enum CURL_TLSAUTH { + CURL_TLSAUTH_NONE, + CURL_TLSAUTH_SRP, + CURL_TLSAUTH_LAST /* never use, keep last */ +}; + +/* symbols to use with CURLOPT_POSTREDIR. + CURL_REDIR_POST_301, CURL_REDIR_POST_302 and CURL_REDIR_POST_303 + can be bitwise ORed so that CURL_REDIR_POST_301 | CURL_REDIR_POST_302 + | CURL_REDIR_POST_303 == CURL_REDIR_POST_ALL */ + +#define CURL_REDIR_GET_ALL 0 +#define CURL_REDIR_POST_301 1 +#define CURL_REDIR_POST_302 2 +#define CURL_REDIR_POST_303 4 +#define CURL_REDIR_POST_ALL \ + (CURL_REDIR_POST_301|CURL_REDIR_POST_302|CURL_REDIR_POST_303) + +typedef enum { + CURL_TIMECOND_NONE, + + CURL_TIMECOND_IFMODSINCE, + CURL_TIMECOND_IFUNMODSINCE, + CURL_TIMECOND_LASTMOD, + + CURL_TIMECOND_LAST +} curl_TimeCond; + + +/* curl_strequal() and curl_strnequal() are subject for removal in a future + libcurl, see lib/README.curlx for details */ +CURL_EXTERN int (curl_strequal)(const char *s1, const char *s2); +CURL_EXTERN int (curl_strnequal)(const char *s1, const char *s2, size_t n); + +/* name is uppercase CURLFORM_ */ +#ifdef CFINIT +#undef CFINIT +#endif + +#ifdef CURL_ISOCPP +#define CFINIT(name) CURLFORM_ ## name +#else +/* The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */ +#define CFINIT(name) CURLFORM_/**/name +#endif + +typedef enum { + CFINIT(NOTHING), /********* the first one is unused ************/ + + /* */ + CFINIT(COPYNAME), + CFINIT(PTRNAME), + CFINIT(NAMELENGTH), + CFINIT(COPYCONTENTS), + CFINIT(PTRCONTENTS), + CFINIT(CONTENTSLENGTH), + CFINIT(FILECONTENT), + CFINIT(ARRAY), + CFINIT(OBSOLETE), + CFINIT(FILE), + + CFINIT(BUFFER), + CFINIT(BUFFERPTR), + CFINIT(BUFFERLENGTH), + + CFINIT(CONTENTTYPE), + CFINIT(CONTENTHEADER), + CFINIT(FILENAME), + CFINIT(END), + CFINIT(OBSOLETE2), + + CFINIT(STREAM), + + CURLFORM_LASTENTRY /* the last unused */ +} CURLformoption; + +#undef CFINIT /* done */ + +/* structure to be used as parameter for CURLFORM_ARRAY */ +struct curl_forms { + CURLformoption option; + const char *value; +}; + +/* use this for multipart formpost building */ +/* Returns code for curl_formadd() + * + * Returns: + * CURL_FORMADD_OK on success + * CURL_FORMADD_MEMORY if the FormInfo allocation fails + * CURL_FORMADD_OPTION_TWICE if one option is given twice for one Form + * CURL_FORMADD_NULL if a null pointer was given for a char + * CURL_FORMADD_MEMORY if the allocation of a FormInfo struct failed + * CURL_FORMADD_UNKNOWN_OPTION if an unknown option was used + * CURL_FORMADD_INCOMPLETE if the some FormInfo is not complete (or error) + * CURL_FORMADD_MEMORY if a curl_httppost struct cannot be allocated + * CURL_FORMADD_MEMORY if some allocation for string copying failed. + * CURL_FORMADD_ILLEGAL_ARRAY if an illegal option is used in an array + * + ***************************************************************************/ +typedef enum { + CURL_FORMADD_OK, /* first, no error */ + + CURL_FORMADD_MEMORY, + CURL_FORMADD_OPTION_TWICE, + CURL_FORMADD_NULL, + CURL_FORMADD_UNKNOWN_OPTION, + CURL_FORMADD_INCOMPLETE, + CURL_FORMADD_ILLEGAL_ARRAY, + CURL_FORMADD_DISABLED, /* libcurl was built with this disabled */ + + CURL_FORMADD_LAST /* last */ +} CURLFORMcode; + +/* + * NAME curl_formadd() + * + * DESCRIPTION + * + * Pretty advanced function for building multi-part formposts. Each invoke + * adds one part that together construct a full post. Then use + * CURLOPT_HTTPPOST to send it off to libcurl. + */ +CURL_EXTERN CURLFORMcode curl_formadd(struct curl_httppost **httppost, + struct curl_httppost **last_post, + ...); + +/* + * callback function for curl_formget() + * The void *arg pointer will be the one passed as second argument to + * curl_formget(). + * The character buffer passed to it must not be freed. + * Should return the buffer length passed to it as the argument "len" on + * success. + */ +typedef size_t (*curl_formget_callback)(void *arg, const char *buf, + size_t len); + +/* + * NAME curl_formget() + * + * DESCRIPTION + * + * Serialize a curl_httppost struct built with curl_formadd(). + * Accepts a void pointer as second argument which will be passed to + * the curl_formget_callback function. + * Returns 0 on success. + */ +CURL_EXTERN int curl_formget(struct curl_httppost *form, void *arg, + curl_formget_callback append); +/* + * NAME curl_formfree() + * + * DESCRIPTION + * + * Free a multipart formpost previously built with curl_formadd(). + */ +CURL_EXTERN void curl_formfree(struct curl_httppost *form); + +/* + * NAME curl_getenv() + * + * DESCRIPTION + * + * Returns a malloc()'ed string that MUST be curl_free()ed after usage is + * complete. DEPRECATED - see lib/README.curlx + */ +CURL_EXTERN char *curl_getenv(const char *variable); + +/* + * NAME curl_version() + * + * DESCRIPTION + * + * Returns a static ascii string of the libcurl version. + */ +CURL_EXTERN char *curl_version(void); + +/* + * NAME curl_easy_escape() + * + * DESCRIPTION + * + * Escapes URL strings (converts all letters consider illegal in URLs to their + * %XX versions). This function returns a new allocated string or NULL if an + * error occurred. + */ +CURL_EXTERN char *curl_easy_escape(CURL *handle, + const char *string, + int length); + +/* the previous version: */ +CURL_EXTERN char *curl_escape(const char *string, + int length); + + +/* + * NAME curl_easy_unescape() + * + * DESCRIPTION + * + * Unescapes URL encoding in strings (converts all %XX codes to their 8bit + * versions). This function returns a new allocated string or NULL if an error + * occurred. + * Conversion Note: On non-ASCII platforms the ASCII %XX codes are + * converted into the host encoding. + */ +CURL_EXTERN char *curl_easy_unescape(CURL *handle, + const char *string, + int length, + int *outlength); + +/* the previous version */ +CURL_EXTERN char *curl_unescape(const char *string, + int length); + +/* + * NAME curl_free() + * + * DESCRIPTION + * + * Provided for de-allocation in the same translation unit that did the + * allocation. Added in libcurl 7.10 + */ +CURL_EXTERN void curl_free(void *p); + +/* + * NAME curl_global_init() + * + * DESCRIPTION + * + * curl_global_init() should be invoked exactly once for each application that + * uses libcurl and before any call of other libcurl functions. + * + * This function is not thread-safe! + */ +CURL_EXTERN CURLcode curl_global_init(long flags); + +/* + * NAME curl_global_init_mem() + * + * DESCRIPTION + * + * curl_global_init() or curl_global_init_mem() should be invoked exactly once + * for each application that uses libcurl. This function can be used to + * initialize libcurl and set user defined memory management callback + * functions. Users can implement memory management routines to check for + * memory leaks, check for mis-use of the curl library etc. User registered + * callback routines with be invoked by this library instead of the system + * memory management routines like malloc, free etc. + */ +CURL_EXTERN CURLcode curl_global_init_mem(long flags, + curl_malloc_callback m, + curl_free_callback f, + curl_realloc_callback r, + curl_strdup_callback s, + curl_calloc_callback c); + +/* + * NAME curl_global_cleanup() + * + * DESCRIPTION + * + * curl_global_cleanup() should be invoked exactly once for each application + * that uses libcurl + */ +CURL_EXTERN void curl_global_cleanup(void); + +/* linked-list structure for the CURLOPT_QUOTE option (and other) */ +struct curl_slist { + char *data; + struct curl_slist *next; +}; + +/* + * NAME curl_slist_append() + * + * DESCRIPTION + * + * Appends a string to a linked list. If no list exists, it will be created + * first. Returns the new list, after appending. + */ +CURL_EXTERN struct curl_slist *curl_slist_append(struct curl_slist *, + const char *); + +/* + * NAME curl_slist_free_all() + * + * DESCRIPTION + * + * free a previously built curl_slist. + */ +CURL_EXTERN void curl_slist_free_all(struct curl_slist *); + +/* + * NAME curl_getdate() + * + * DESCRIPTION + * + * Returns the time, in seconds since 1 Jan 1970 of the time string given in + * the first argument. The time argument in the second parameter is unused + * and should be set to NULL. + */ +CURL_EXTERN time_t curl_getdate(const char *p, const time_t *unused); + +/* info about the certificate chain, only for OpenSSL builds. Asked + for with CURLOPT_CERTINFO / CURLINFO_CERTINFO */ +struct curl_certinfo { + int num_of_certs; /* number of certificates with information */ + struct curl_slist **certinfo; /* for each index in this array, there's a + linked list with textual information in the + format "name: value" */ +}; + +/* enum for the different supported SSL backends */ +typedef enum { + CURLSSLBACKEND_NONE = 0, + CURLSSLBACKEND_OPENSSL = 1, + CURLSSLBACKEND_GNUTLS = 2, + CURLSSLBACKEND_NSS = 3, + CURLSSLBACKEND_QSOSSL = 4, + CURLSSLBACKEND_GSKIT = 5, + CURLSSLBACKEND_POLARSSL = 6, + CURLSSLBACKEND_CYASSL = 7, + CURLSSLBACKEND_SCHANNEL = 8, + CURLSSLBACKEND_DARWINSSL = 9 +} curl_sslbackend; + +/* Information about the SSL library used and the respective internal SSL + handle, which can be used to obtain further information regarding the + connection. Asked for with CURLINFO_TLS_SESSION. */ +struct curl_tlssessioninfo { + curl_sslbackend backend; + void *internals; +}; + +#define CURLINFO_STRING 0x100000 +#define CURLINFO_LONG 0x200000 +#define CURLINFO_DOUBLE 0x300000 +#define CURLINFO_SLIST 0x400000 +#define CURLINFO_MASK 0x0fffff +#define CURLINFO_TYPEMASK 0xf00000 + +typedef enum { + CURLINFO_NONE, /* first, never use this */ + CURLINFO_EFFECTIVE_URL = CURLINFO_STRING + 1, + CURLINFO_RESPONSE_CODE = CURLINFO_LONG + 2, + CURLINFO_TOTAL_TIME = CURLINFO_DOUBLE + 3, + CURLINFO_NAMELOOKUP_TIME = CURLINFO_DOUBLE + 4, + CURLINFO_CONNECT_TIME = CURLINFO_DOUBLE + 5, + CURLINFO_PRETRANSFER_TIME = CURLINFO_DOUBLE + 6, + CURLINFO_SIZE_UPLOAD = CURLINFO_DOUBLE + 7, + CURLINFO_SIZE_DOWNLOAD = CURLINFO_DOUBLE + 8, + CURLINFO_SPEED_DOWNLOAD = CURLINFO_DOUBLE + 9, + CURLINFO_SPEED_UPLOAD = CURLINFO_DOUBLE + 10, + CURLINFO_HEADER_SIZE = CURLINFO_LONG + 11, + CURLINFO_REQUEST_SIZE = CURLINFO_LONG + 12, + CURLINFO_SSL_VERIFYRESULT = CURLINFO_LONG + 13, + CURLINFO_FILETIME = CURLINFO_LONG + 14, + CURLINFO_CONTENT_LENGTH_DOWNLOAD = CURLINFO_DOUBLE + 15, + CURLINFO_CONTENT_LENGTH_UPLOAD = CURLINFO_DOUBLE + 16, + CURLINFO_STARTTRANSFER_TIME = CURLINFO_DOUBLE + 17, + CURLINFO_CONTENT_TYPE = CURLINFO_STRING + 18, + CURLINFO_REDIRECT_TIME = CURLINFO_DOUBLE + 19, + CURLINFO_REDIRECT_COUNT = CURLINFO_LONG + 20, + CURLINFO_PRIVATE = CURLINFO_STRING + 21, + CURLINFO_HTTP_CONNECTCODE = CURLINFO_LONG + 22, + CURLINFO_HTTPAUTH_AVAIL = CURLINFO_LONG + 23, + CURLINFO_PROXYAUTH_AVAIL = CURLINFO_LONG + 24, + CURLINFO_OS_ERRNO = CURLINFO_LONG + 25, + CURLINFO_NUM_CONNECTS = CURLINFO_LONG + 26, + CURLINFO_SSL_ENGINES = CURLINFO_SLIST + 27, + CURLINFO_COOKIELIST = CURLINFO_SLIST + 28, + CURLINFO_LASTSOCKET = CURLINFO_LONG + 29, + CURLINFO_FTP_ENTRY_PATH = CURLINFO_STRING + 30, + CURLINFO_REDIRECT_URL = CURLINFO_STRING + 31, + CURLINFO_PRIMARY_IP = CURLINFO_STRING + 32, + CURLINFO_APPCONNECT_TIME = CURLINFO_DOUBLE + 33, + CURLINFO_CERTINFO = CURLINFO_SLIST + 34, + CURLINFO_CONDITION_UNMET = CURLINFO_LONG + 35, + CURLINFO_RTSP_SESSION_ID = CURLINFO_STRING + 36, + CURLINFO_RTSP_CLIENT_CSEQ = CURLINFO_LONG + 37, + CURLINFO_RTSP_SERVER_CSEQ = CURLINFO_LONG + 38, + CURLINFO_RTSP_CSEQ_RECV = CURLINFO_LONG + 39, + CURLINFO_PRIMARY_PORT = CURLINFO_LONG + 40, + CURLINFO_LOCAL_IP = CURLINFO_STRING + 41, + CURLINFO_LOCAL_PORT = CURLINFO_LONG + 42, + CURLINFO_TLS_SESSION = CURLINFO_SLIST + 43, + /* Fill in new entries below here! */ + + CURLINFO_LASTONE = 43 +} CURLINFO; + +/* CURLINFO_RESPONSE_CODE is the new name for the option previously known as + CURLINFO_HTTP_CODE */ +#define CURLINFO_HTTP_CODE CURLINFO_RESPONSE_CODE + +typedef enum { + CURLCLOSEPOLICY_NONE, /* first, never use this */ + + CURLCLOSEPOLICY_OLDEST, + CURLCLOSEPOLICY_LEAST_RECENTLY_USED, + CURLCLOSEPOLICY_LEAST_TRAFFIC, + CURLCLOSEPOLICY_SLOWEST, + CURLCLOSEPOLICY_CALLBACK, + + CURLCLOSEPOLICY_LAST /* last, never use this */ +} curl_closepolicy; + +#define CURL_GLOBAL_SSL (1<<0) +#define CURL_GLOBAL_WIN32 (1<<1) +#define CURL_GLOBAL_ALL (CURL_GLOBAL_SSL|CURL_GLOBAL_WIN32) +#define CURL_GLOBAL_NOTHING 0 +#define CURL_GLOBAL_DEFAULT CURL_GLOBAL_ALL +#define CURL_GLOBAL_ACK_EINTR (1<<2) + + +/***************************************************************************** + * Setup defines, protos etc for the sharing stuff. + */ + +/* Different data locks for a single share */ +typedef enum { + CURL_LOCK_DATA_NONE = 0, + /* CURL_LOCK_DATA_SHARE is used internally to say that + * the locking is just made to change the internal state of the share + * itself. + */ + CURL_LOCK_DATA_SHARE, + CURL_LOCK_DATA_COOKIE, + CURL_LOCK_DATA_DNS, + CURL_LOCK_DATA_SSL_SESSION, + CURL_LOCK_DATA_CONNECT, + CURL_LOCK_DATA_LAST +} curl_lock_data; + +/* Different lock access types */ +typedef enum { + CURL_LOCK_ACCESS_NONE = 0, /* unspecified action */ + CURL_LOCK_ACCESS_SHARED = 1, /* for read perhaps */ + CURL_LOCK_ACCESS_SINGLE = 2, /* for write perhaps */ + CURL_LOCK_ACCESS_LAST /* never use */ +} curl_lock_access; + +typedef void (*curl_lock_function)(CURL *handle, + curl_lock_data data, + curl_lock_access locktype, + void *userptr); +typedef void (*curl_unlock_function)(CURL *handle, + curl_lock_data data, + void *userptr); + +typedef void CURLSH; + +typedef enum { + CURLSHE_OK, /* all is fine */ + CURLSHE_BAD_OPTION, /* 1 */ + CURLSHE_IN_USE, /* 2 */ + CURLSHE_INVALID, /* 3 */ + CURLSHE_NOMEM, /* 4 out of memory */ + CURLSHE_NOT_BUILT_IN, /* 5 feature not present in lib */ + CURLSHE_LAST /* never use */ +} CURLSHcode; + +typedef enum { + CURLSHOPT_NONE, /* don't use */ + CURLSHOPT_SHARE, /* specify a data type to share */ + CURLSHOPT_UNSHARE, /* specify which data type to stop sharing */ + CURLSHOPT_LOCKFUNC, /* pass in a 'curl_lock_function' pointer */ + CURLSHOPT_UNLOCKFUNC, /* pass in a 'curl_unlock_function' pointer */ + CURLSHOPT_USERDATA, /* pass in a user data pointer used in the lock/unlock + callback functions */ + CURLSHOPT_LAST /* never use */ +} CURLSHoption; + +CURL_EXTERN CURLSH *curl_share_init(void); +CURL_EXTERN CURLSHcode curl_share_setopt(CURLSH *, CURLSHoption option, ...); +CURL_EXTERN CURLSHcode curl_share_cleanup(CURLSH *); + +/**************************************************************************** + * Structures for querying information about the curl library at runtime. + */ + +typedef enum { + CURLVERSION_FIRST, + CURLVERSION_SECOND, + CURLVERSION_THIRD, + CURLVERSION_FOURTH, + CURLVERSION_LAST /* never actually use this */ +} CURLversion; + +/* The 'CURLVERSION_NOW' is the symbolic name meant to be used by + basically all programs ever that want to get version information. It is + meant to be a built-in version number for what kind of struct the caller + expects. If the struct ever changes, we redefine the NOW to another enum + from above. */ +#define CURLVERSION_NOW CURLVERSION_FOURTH + +typedef struct { + CURLversion age; /* age of the returned struct */ + const char *version; /* LIBCURL_VERSION */ + unsigned int version_num; /* LIBCURL_VERSION_NUM */ + const char *host; /* OS/host/cpu/machine when configured */ + int features; /* bitmask, see defines below */ + const char *ssl_version; /* human readable string */ + long ssl_version_num; /* not used anymore, always 0 */ + const char *libz_version; /* human readable string */ + /* protocols is terminated by an entry with a NULL protoname */ + const char * const *protocols; + + /* The fields below this were added in CURLVERSION_SECOND */ + const char *ares; + int ares_num; + + /* This field was added in CURLVERSION_THIRD */ + const char *libidn; + + /* These field were added in CURLVERSION_FOURTH */ + + /* Same as '_libiconv_version' if built with HAVE_ICONV */ + int iconv_ver_num; + + const char *libssh_version; /* human readable string */ + +} curl_version_info_data; + +#define CURL_VERSION_IPV6 (1<<0) /* IPv6-enabled */ +#define CURL_VERSION_KERBEROS4 (1<<1) /* kerberos auth is supported */ +#define CURL_VERSION_SSL (1<<2) /* SSL options are present */ +#define CURL_VERSION_LIBZ (1<<3) /* libz features are present */ +#define CURL_VERSION_NTLM (1<<4) /* NTLM auth is supported */ +#define CURL_VERSION_GSSNEGOTIATE (1<<5) /* Negotiate auth support */ +#define CURL_VERSION_DEBUG (1<<6) /* built with debug capabilities */ +#define CURL_VERSION_ASYNCHDNS (1<<7) /* asynchronous dns resolves */ +#define CURL_VERSION_SPNEGO (1<<8) /* SPNEGO auth */ +#define CURL_VERSION_LARGEFILE (1<<9) /* supports files bigger than 2GB */ +#define CURL_VERSION_IDN (1<<10) /* International Domain Names support */ +#define CURL_VERSION_SSPI (1<<11) /* SSPI is supported */ +#define CURL_VERSION_CONV (1<<12) /* character conversions supported */ +#define CURL_VERSION_CURLDEBUG (1<<13) /* debug memory tracking supported */ +#define CURL_VERSION_TLSAUTH_SRP (1<<14) /* TLS-SRP auth is supported */ +#define CURL_VERSION_NTLM_WB (1<<15) /* NTLM delegating to winbind helper */ +#define CURL_VERSION_HTTP2 (1<<16) /* HTTP2 support built-in */ + + /* + * NAME curl_version_info() + * + * DESCRIPTION + * + * This function returns a pointer to a static copy of the version info + * struct. See above. + */ +CURL_EXTERN curl_version_info_data *curl_version_info(CURLversion); + +/* + * NAME curl_easy_strerror() + * + * DESCRIPTION + * + * The curl_easy_strerror function may be used to turn a CURLcode value + * into the equivalent human readable error string. This is useful + * for printing meaningful error messages. + */ +CURL_EXTERN const char *curl_easy_strerror(CURLcode); + +/* + * NAME curl_share_strerror() + * + * DESCRIPTION + * + * The curl_share_strerror function may be used to turn a CURLSHcode value + * into the equivalent human readable error string. This is useful + * for printing meaningful error messages. + */ +CURL_EXTERN const char *curl_share_strerror(CURLSHcode); + +/* + * NAME curl_easy_pause() + * + * DESCRIPTION + * + * The curl_easy_pause function pauses or unpauses transfers. Select the new + * state by setting the bitmask, use the convenience defines below. + * + */ +CURL_EXTERN CURLcode curl_easy_pause(CURL *handle, int bitmask); + +#define CURLPAUSE_RECV (1<<0) +#define CURLPAUSE_RECV_CONT (0) + +#define CURLPAUSE_SEND (1<<2) +#define CURLPAUSE_SEND_CONT (0) + +#define CURLPAUSE_ALL (CURLPAUSE_RECV|CURLPAUSE_SEND) +#define CURLPAUSE_CONT (CURLPAUSE_RECV_CONT|CURLPAUSE_SEND_CONT) + +#ifdef __cplusplus +} +#endif + +/* unfortunately, the easy.h and multi.h include files need options and info + stuff before they can be included! */ +#include "easy.h" /* nothing in curl is fun without the easy stuff */ +#include "multi.h" + +/* the typechecker doesn't work in C++ (yet) */ +#if defined(__GNUC__) && defined(__GNUC_MINOR__) && \ + ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) && \ + !defined(__cplusplus) && !defined(CURL_DISABLE_TYPECHECK) +#include "typecheck-gcc.h" +#else +#if defined(__STDC__) && (__STDC__ >= 1) +/* This preprocessor magic that replaces a call with the exact same call is + only done to make sure application authors pass exactly three arguments + to these functions. */ +#define curl_easy_setopt(handle,opt,param) curl_easy_setopt(handle,opt,param) +#define curl_easy_getinfo(handle,info,arg) curl_easy_getinfo(handle,info,arg) +#define curl_share_setopt(share,opt,param) curl_share_setopt(share,opt,param) +#define curl_multi_setopt(handle,opt,param) curl_multi_setopt(handle,opt,param) +#endif /* __STDC__ >= 1 */ +#endif /* gcc >= 4.3 && !__cplusplus */ + +#endif /* __CURL_CURL_H */ diff --git a/lib/curl/curlbuild.h b/lib/curl/curlbuild.h new file mode 100644 index 0000000..3ad2f01 --- /dev/null +++ b/lib/curl/curlbuild.h @@ -0,0 +1,585 @@ +#ifndef __CURL_CURLBUILD_H +#define __CURL_CURLBUILD_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2013, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at http://curl.haxx.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ***************************************************************************/ + +/* ================================================================ */ +/* NOTES FOR CONFIGURE CAPABLE SYSTEMS */ +/* ================================================================ */ + +/* + * NOTE 1: + * ------- + * + * See file include/curl/curlbuild.h.in, run configure, and forget + * that this file exists it is only used for non-configure systems. + * But you can keep reading if you want ;-) + * + */ + +/* ================================================================ */ +/* NOTES FOR NON-CONFIGURE SYSTEMS */ +/* ================================================================ */ + +/* + * NOTE 1: + * ------- + * + * Nothing in this file is intended to be modified or adjusted by the + * curl library user nor by the curl library builder. + * + * If you think that something actually needs to be changed, adjusted + * or fixed in this file, then, report it on the libcurl development + * mailing list: http://cool.haxx.se/mailman/listinfo/curl-library/ + * + * Try to keep one section per platform, compiler and architecture, + * otherwise, if an existing section is reused for a different one and + * later on the original is adjusted, probably the piggybacking one can + * be adversely changed. + * + * In order to differentiate between platforms/compilers/architectures + * use only compiler built in predefined preprocessor symbols. + * + * This header file shall only export symbols which are 'curl' or 'CURL' + * prefixed, otherwise public name space would be polluted. + * + * NOTE 2: + * ------- + * + * For any given platform/compiler curl_off_t must be typedef'ed to a + * 64-bit wide signed integral data type. The width of this data type + * must remain constant and independent of any possible large file + * support settings. + * + * As an exception to the above, curl_off_t shall be typedef'ed to a + * 32-bit wide signed integral data type if there is no 64-bit type. + * + * As a general rule, curl_off_t shall not be mapped to off_t. This + * rule shall only be violated if off_t is the only 64-bit data type + * available and the size of off_t is independent of large file support + * settings. Keep your build on the safe side avoiding an off_t gating. + * If you have a 64-bit off_t then take for sure that another 64-bit + * data type exists, dig deeper and you will find it. + * + * NOTE 3: + * ------- + * + * Right now you might be staring at file include/curl/curlbuild.h.dist or + * at file include/curl/curlbuild.h, this is due to the following reason: + * file include/curl/curlbuild.h.dist is renamed to include/curl/curlbuild.h + * when the libcurl source code distribution archive file is created. + * + * File include/curl/curlbuild.h.dist is not included in the distribution + * archive. File include/curl/curlbuild.h is not present in the git tree. + * + * The distributed include/curl/curlbuild.h file is only intended to be used + * on systems which can not run the also distributed configure script. + * + * On systems capable of running the configure script, the configure process + * will overwrite the distributed include/curl/curlbuild.h file with one that + * is suitable and specific to the library being configured and built, which + * is generated from the include/curl/curlbuild.h.in template file. + * + * If you check out from git on a non-configure platform, you must run the + * appropriate buildconf* script to set up curlbuild.h and other local files. + * + */ + +/* ================================================================ */ +/* DEFINITION OF THESE SYMBOLS SHALL NOT TAKE PLACE ANYWHERE ELSE */ +/* ================================================================ */ + +#ifdef CURL_SIZEOF_LONG +# error "CURL_SIZEOF_LONG shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_SIZEOF_LONG_already_defined +#endif + +#ifdef CURL_TYPEOF_CURL_SOCKLEN_T +# error "CURL_TYPEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_TYPEOF_CURL_SOCKLEN_T_already_defined +#endif + +#ifdef CURL_SIZEOF_CURL_SOCKLEN_T +# error "CURL_SIZEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_SIZEOF_CURL_SOCKLEN_T_already_defined +#endif + +#ifdef CURL_TYPEOF_CURL_OFF_T +# error "CURL_TYPEOF_CURL_OFF_T shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_TYPEOF_CURL_OFF_T_already_defined +#endif + +#ifdef CURL_FORMAT_CURL_OFF_T +# error "CURL_FORMAT_CURL_OFF_T shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_FORMAT_CURL_OFF_T_already_defined +#endif + +#ifdef CURL_FORMAT_CURL_OFF_TU +# error "CURL_FORMAT_CURL_OFF_TU shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_FORMAT_CURL_OFF_TU_already_defined +#endif + +#ifdef CURL_FORMAT_OFF_T +# error "CURL_FORMAT_OFF_T shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_FORMAT_OFF_T_already_defined +#endif + +#ifdef CURL_SIZEOF_CURL_OFF_T +# error "CURL_SIZEOF_CURL_OFF_T shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_SIZEOF_CURL_OFF_T_already_defined +#endif + +#ifdef CURL_SUFFIX_CURL_OFF_T +# error "CURL_SUFFIX_CURL_OFF_T shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_T_already_defined +#endif + +#ifdef CURL_SUFFIX_CURL_OFF_TU +# error "CURL_SUFFIX_CURL_OFF_TU shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_TU_already_defined +#endif + +/* ================================================================ */ +/* EXTERNAL INTERFACE SETTINGS FOR NON-CONFIGURE SYSTEMS ONLY */ +/* ================================================================ */ + +#if defined(__DJGPP__) || defined(__GO32__) +# if defined(__DJGPP__) && (__DJGPP__ > 1) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_FORMAT_OFF_T "%lld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# else +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 4 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(__SALFORDC__) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 4 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(__BORLANDC__) +# if (__BORLANDC__ < 0x520) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 4 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# else +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T __int64 +# define CURL_FORMAT_CURL_OFF_T "I64d" +# define CURL_FORMAT_CURL_OFF_TU "I64u" +# define CURL_FORMAT_OFF_T "%I64d" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T i64 +# define CURL_SUFFIX_CURL_OFF_TU ui64 +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(__TURBOC__) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 4 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(__WATCOMC__) +# if defined(__386__) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T __int64 +# define CURL_FORMAT_CURL_OFF_T "I64d" +# define CURL_FORMAT_CURL_OFF_TU "I64u" +# define CURL_FORMAT_OFF_T "%I64d" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T i64 +# define CURL_SUFFIX_CURL_OFF_TU ui64 +# else +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 4 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(__POCC__) +# if (__POCC__ < 280) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 4 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# elif defined(_MSC_VER) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T __int64 +# define CURL_FORMAT_CURL_OFF_T "I64d" +# define CURL_FORMAT_CURL_OFF_TU "I64u" +# define CURL_FORMAT_OFF_T "%I64d" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T i64 +# define CURL_SUFFIX_CURL_OFF_TU ui64 +# else +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_FORMAT_OFF_T "%lld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(__LCC__) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 4 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(__SYMBIAN32__) +# if defined(__EABI__) /* Treat all ARM compilers equally */ +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_FORMAT_OFF_T "%lld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# elif defined(__CW32__) +# pragma longlong on +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_FORMAT_OFF_T "%lld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# elif defined(__VC32__) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T __int64 +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_FORMAT_OFF_T "%lld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(__MWERKS__) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_FORMAT_OFF_T "%lld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(_WIN32_WCE) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T __int64 +# define CURL_FORMAT_CURL_OFF_T "I64d" +# define CURL_FORMAT_CURL_OFF_TU "I64u" +# define CURL_FORMAT_OFF_T "%I64d" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T i64 +# define CURL_SUFFIX_CURL_OFF_TU ui64 +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(__MINGW32__) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "I64d" +# define CURL_FORMAT_CURL_OFF_TU "I64u" +# define CURL_FORMAT_OFF_T "%I64d" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(__VMS) +# if defined(__VAX) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 4 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# else +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_FORMAT_OFF_T "%lld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(__OS400__) +# if defined(__ILEC400__) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_FORMAT_OFF_T "%lld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 +# define CURL_PULL_SYS_TYPES_H 1 +# define CURL_PULL_SYS_SOCKET_H 1 +# endif + +#elif defined(__MVS__) +# if defined(__IBMC__) || defined(__IBMCPP__) +# if defined(_ILP32) +# define CURL_SIZEOF_LONG 4 +# elif defined(_LP64) +# define CURL_SIZEOF_LONG 8 +# endif +# if defined(_LONG_LONG) +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_FORMAT_OFF_T "%lld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# elif defined(_LP64) +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# else +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 4 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 +# define CURL_PULL_SYS_TYPES_H 1 +# define CURL_PULL_SYS_SOCKET_H 1 +# endif + +#elif defined(__370__) +# if defined(__IBMC__) || defined(__IBMCPP__) +# if defined(_ILP32) +# define CURL_SIZEOF_LONG 4 +# elif defined(_LP64) +# define CURL_SIZEOF_LONG 8 +# endif +# if defined(_LONG_LONG) +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_FORMAT_OFF_T "%lld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# elif defined(_LP64) +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# else +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 4 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 +# define CURL_PULL_SYS_TYPES_H 1 +# define CURL_PULL_SYS_SOCKET_H 1 +# endif + +#elif defined(TPF) +# define CURL_SIZEOF_LONG 8 +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +/* ===================================== */ +/* KEEP MSVC THE PENULTIMATE ENTRY */ +/* ===================================== */ + +#elif defined(_MSC_VER) +# if (_MSC_VER >= 900) && (_INTEGRAL_MAX_BITS >= 64) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T __int64 +# define CURL_FORMAT_CURL_OFF_T "I64d" +# define CURL_FORMAT_CURL_OFF_TU "I64u" +# define CURL_FORMAT_OFF_T "%I64d" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T i64 +# define CURL_SUFFIX_CURL_OFF_TU ui64 +# else +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 4 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +/* ===================================== */ +/* KEEP GENERIC GCC THE LAST ENTRY */ +/* ===================================== */ + +#elif defined(__GNUC__) +# if defined(__ILP32__) || \ + defined(__i386__) || defined(__ppc__) || defined(__arm__) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_FORMAT_OFF_T "%lld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# elif defined(__LP64__) || \ + defined(__x86_64__) || defined(__ppc64__) +# define CURL_SIZEOF_LONG 8 +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 +# define CURL_PULL_SYS_TYPES_H 1 +# define CURL_PULL_SYS_SOCKET_H 1 + +#else +# error "Unknown non-configure build target!" + Error Compilation_aborted_Unknown_non_configure_build_target +#endif + +/* CURL_PULL_SYS_TYPES_H is defined above when inclusion of header file */ +/* sys/types.h is required here to properly make type definitions below. */ +#ifdef CURL_PULL_SYS_TYPES_H +# include +#endif + +/* CURL_PULL_SYS_SOCKET_H is defined above when inclusion of header file */ +/* sys/socket.h is required here to properly make type definitions below. */ +#ifdef CURL_PULL_SYS_SOCKET_H +# include +#endif + +/* Data type definition of curl_socklen_t. */ + +#ifdef CURL_TYPEOF_CURL_SOCKLEN_T + typedef CURL_TYPEOF_CURL_SOCKLEN_T curl_socklen_t; +#endif + +/* Data type definition of curl_off_t. */ + +#ifdef CURL_TYPEOF_CURL_OFF_T + typedef CURL_TYPEOF_CURL_OFF_T curl_off_t; +#endif + +#endif /* __CURL_CURLBUILD_H */ diff --git a/lib/curl/curlbuild.h.cmake b/lib/curl/curlbuild.h.cmake new file mode 100644 index 0000000..60bc7a7 --- /dev/null +++ b/lib/curl/curlbuild.h.cmake @@ -0,0 +1,197 @@ +#ifndef __CURL_CURLBUILD_H +#define __CURL_CURLBUILD_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2008, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at http://curl.haxx.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ***************************************************************************/ + +/* ================================================================ */ +/* NOTES FOR CONFIGURE CAPABLE SYSTEMS */ +/* ================================================================ */ + +/* + * NOTE 1: + * ------- + * + * Nothing in this file is intended to be modified or adjusted by the + * curl library user nor by the curl library builder. + * + * If you think that something actually needs to be changed, adjusted + * or fixed in this file, then, report it on the libcurl development + * mailing list: http://cool.haxx.se/mailman/listinfo/curl-library/ + * + * This header file shall only export symbols which are 'curl' or 'CURL' + * prefixed, otherwise public name space would be polluted. + * + * NOTE 2: + * ------- + * + * Right now you might be staring at file include/curl/curlbuild.h.in or + * at file include/curl/curlbuild.h, this is due to the following reason: + * + * On systems capable of running the configure script, the configure process + * will overwrite the distributed include/curl/curlbuild.h file with one that + * is suitable and specific to the library being configured and built, which + * is generated from the include/curl/curlbuild.h.in template file. + * + */ + +/* ================================================================ */ +/* DEFINITION OF THESE SYMBOLS SHALL NOT TAKE PLACE ANYWHERE ELSE */ +/* ================================================================ */ + +#ifdef CURL_SIZEOF_LONG +#error "CURL_SIZEOF_LONG shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_SIZEOF_LONG_already_defined +#endif + +#ifdef CURL_TYPEOF_CURL_SOCKLEN_T +#error "CURL_TYPEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_TYPEOF_CURL_SOCKLEN_T_already_defined +#endif + +#ifdef CURL_SIZEOF_CURL_SOCKLEN_T +#error "CURL_SIZEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_SIZEOF_CURL_SOCKLEN_T_already_defined +#endif + +#ifdef CURL_TYPEOF_CURL_OFF_T +#error "CURL_TYPEOF_CURL_OFF_T shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_TYPEOF_CURL_OFF_T_already_defined +#endif + +#ifdef CURL_FORMAT_CURL_OFF_T +#error "CURL_FORMAT_CURL_OFF_T shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_FORMAT_CURL_OFF_T_already_defined +#endif + +#ifdef CURL_FORMAT_CURL_OFF_TU +#error "CURL_FORMAT_CURL_OFF_TU shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_FORMAT_CURL_OFF_TU_already_defined +#endif + +#ifdef CURL_FORMAT_OFF_T +#error "CURL_FORMAT_OFF_T shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_FORMAT_OFF_T_already_defined +#endif + +#ifdef CURL_SIZEOF_CURL_OFF_T +#error "CURL_SIZEOF_CURL_OFF_T shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_SIZEOF_CURL_OFF_T_already_defined +#endif + +#ifdef CURL_SUFFIX_CURL_OFF_T +#error "CURL_SUFFIX_CURL_OFF_T shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_T_already_defined +#endif + +#ifdef CURL_SUFFIX_CURL_OFF_TU +#error "CURL_SUFFIX_CURL_OFF_TU shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_TU_already_defined +#endif + +/* ================================================================ */ +/* EXTERNAL INTERFACE SETTINGS FOR CONFIGURE CAPABLE SYSTEMS ONLY */ +/* ================================================================ */ + +/* Configure process defines this to 1 when it finds out that system */ +/* header file ws2tcpip.h must be included by the external interface. */ +#cmakedefine CURL_PULL_WS2TCPIP_H +#ifdef CURL_PULL_WS2TCPIP_H +# ifndef WIN32_LEAN_AND_MEAN +# define WIN32_LEAN_AND_MEAN +# endif +# include +# include +# include +#endif + +/* Configure process defines this to 1 when it finds out that system */ +/* header file sys/types.h must be included by the external interface. */ +#cmakedefine CURL_PULL_SYS_TYPES_H +#ifdef CURL_PULL_SYS_TYPES_H +# include +#endif + +/* Configure process defines this to 1 when it finds out that system */ +/* header file stdint.h must be included by the external interface. */ +#cmakedefine CURL_PULL_STDINT_H +#ifdef CURL_PULL_STDINT_H +# include +#endif + +/* Configure process defines this to 1 when it finds out that system */ +/* header file inttypes.h must be included by the external interface. */ +#cmakedefine CURL_PULL_INTTYPES_H +#ifdef CURL_PULL_INTTYPES_H +# include +#endif + +/* Configure process defines this to 1 when it finds out that system */ +/* header file sys/socket.h must be included by the external interface. */ +#cmakedefine CURL_PULL_SYS_SOCKET_H +#ifdef CURL_PULL_SYS_SOCKET_H +# include +#endif + +/* Configure process defines this to 1 when it finds out that system */ +/* header file sys/poll.h must be included by the external interface. */ +#cmakedefine CURL_PULL_SYS_POLL_H +#ifdef CURL_PULL_SYS_POLL_H +# include +#endif + +/* The size of `long', as computed by sizeof. */ +#define CURL_SIZEOF_LONG ${CURL_SIZEOF_LONG} + +/* Integral data type used for curl_socklen_t. */ +#define CURL_TYPEOF_CURL_SOCKLEN_T ${CURL_TYPEOF_CURL_SOCKLEN_T} + +/* The size of `curl_socklen_t', as computed by sizeof. */ +#define CURL_SIZEOF_CURL_SOCKLEN_T ${CURL_SIZEOF_CURL_SOCKLEN_T} + +/* Data type definition of curl_socklen_t. */ +typedef CURL_TYPEOF_CURL_SOCKLEN_T curl_socklen_t; + +/* Signed integral data type used for curl_off_t. */ +#define CURL_TYPEOF_CURL_OFF_T ${CURL_TYPEOF_CURL_OFF_T} + +/* Data type definition of curl_off_t. */ +typedef CURL_TYPEOF_CURL_OFF_T curl_off_t; + +/* curl_off_t formatting string directive without "%" conversion specifier. */ +#define CURL_FORMAT_CURL_OFF_T "${CURL_FORMAT_CURL_OFF_T}" + +/* unsigned curl_off_t formatting string without "%" conversion specifier. */ +#define CURL_FORMAT_CURL_OFF_TU "${CURL_FORMAT_CURL_OFF_TU}" + +/* curl_off_t formatting string directive with "%" conversion specifier. */ +#define CURL_FORMAT_OFF_T "${CURL_FORMAT_OFF_T}" + +/* The size of `curl_off_t', as computed by sizeof. */ +#define CURL_SIZEOF_CURL_OFF_T ${CURL_SIZEOF_CURL_OFF_T} + +/* curl_off_t constant suffix. */ +#define CURL_SUFFIX_CURL_OFF_T ${CURL_SUFFIX_CURL_OFF_T} + +/* unsigned curl_off_t constant suffix. */ +#define CURL_SUFFIX_CURL_OFF_TU ${CURL_SUFFIX_CURL_OFF_TU} + +#endif /* __CURL_CURLBUILD_H */ diff --git a/lib/curl/curlbuild.h.in b/lib/curl/curlbuild.h.in new file mode 100644 index 0000000..e29f195 --- /dev/null +++ b/lib/curl/curlbuild.h.in @@ -0,0 +1,197 @@ +#ifndef __CURL_CURLBUILD_H +#define __CURL_CURLBUILD_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2012, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at http://curl.haxx.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ***************************************************************************/ + +/* ================================================================ */ +/* NOTES FOR CONFIGURE CAPABLE SYSTEMS */ +/* ================================================================ */ + +/* + * NOTE 1: + * ------- + * + * Nothing in this file is intended to be modified or adjusted by the + * curl library user nor by the curl library builder. + * + * If you think that something actually needs to be changed, adjusted + * or fixed in this file, then, report it on the libcurl development + * mailing list: http://cool.haxx.se/mailman/listinfo/curl-library/ + * + * This header file shall only export symbols which are 'curl' or 'CURL' + * prefixed, otherwise public name space would be polluted. + * + * NOTE 2: + * ------- + * + * Right now you might be staring at file include/curl/curlbuild.h.in or + * at file include/curl/curlbuild.h, this is due to the following reason: + * + * On systems capable of running the configure script, the configure process + * will overwrite the distributed include/curl/curlbuild.h file with one that + * is suitable and specific to the library being configured and built, which + * is generated from the include/curl/curlbuild.h.in template file. + * + */ + +/* ================================================================ */ +/* DEFINITION OF THESE SYMBOLS SHALL NOT TAKE PLACE ANYWHERE ELSE */ +/* ================================================================ */ + +#ifdef CURL_SIZEOF_LONG +#error "CURL_SIZEOF_LONG shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_SIZEOF_LONG_already_defined +#endif + +#ifdef CURL_TYPEOF_CURL_SOCKLEN_T +#error "CURL_TYPEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_TYPEOF_CURL_SOCKLEN_T_already_defined +#endif + +#ifdef CURL_SIZEOF_CURL_SOCKLEN_T +#error "CURL_SIZEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_SIZEOF_CURL_SOCKLEN_T_already_defined +#endif + +#ifdef CURL_TYPEOF_CURL_OFF_T +#error "CURL_TYPEOF_CURL_OFF_T shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_TYPEOF_CURL_OFF_T_already_defined +#endif + +#ifdef CURL_FORMAT_CURL_OFF_T +#error "CURL_FORMAT_CURL_OFF_T shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_FORMAT_CURL_OFF_T_already_defined +#endif + +#ifdef CURL_FORMAT_CURL_OFF_TU +#error "CURL_FORMAT_CURL_OFF_TU shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_FORMAT_CURL_OFF_TU_already_defined +#endif + +#ifdef CURL_FORMAT_OFF_T +#error "CURL_FORMAT_OFF_T shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_FORMAT_OFF_T_already_defined +#endif + +#ifdef CURL_SIZEOF_CURL_OFF_T +#error "CURL_SIZEOF_CURL_OFF_T shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_SIZEOF_CURL_OFF_T_already_defined +#endif + +#ifdef CURL_SUFFIX_CURL_OFF_T +#error "CURL_SUFFIX_CURL_OFF_T shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_T_already_defined +#endif + +#ifdef CURL_SUFFIX_CURL_OFF_TU +#error "CURL_SUFFIX_CURL_OFF_TU shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_TU_already_defined +#endif + +/* ================================================================ */ +/* EXTERNAL INTERFACE SETTINGS FOR CONFIGURE CAPABLE SYSTEMS ONLY */ +/* ================================================================ */ + +/* Configure process defines this to 1 when it finds out that system */ +/* header file ws2tcpip.h must be included by the external interface. */ +#undef CURL_PULL_WS2TCPIP_H +#ifdef CURL_PULL_WS2TCPIP_H +# ifndef WIN32_LEAN_AND_MEAN +# define WIN32_LEAN_AND_MEAN +# endif +# include +# include +# include +#endif + +/* Configure process defines this to 1 when it finds out that system */ +/* header file sys/types.h must be included by the external interface. */ +#undef CURL_PULL_SYS_TYPES_H +#ifdef CURL_PULL_SYS_TYPES_H +# include +#endif + +/* Configure process defines this to 1 when it finds out that system */ +/* header file stdint.h must be included by the external interface. */ +#undef CURL_PULL_STDINT_H +#ifdef CURL_PULL_STDINT_H +# include +#endif + +/* Configure process defines this to 1 when it finds out that system */ +/* header file inttypes.h must be included by the external interface. */ +#undef CURL_PULL_INTTYPES_H +#ifdef CURL_PULL_INTTYPES_H +# include +#endif + +/* Configure process defines this to 1 when it finds out that system */ +/* header file sys/socket.h must be included by the external interface. */ +#undef CURL_PULL_SYS_SOCKET_H +#ifdef CURL_PULL_SYS_SOCKET_H +# include +#endif + +/* Configure process defines this to 1 when it finds out that system */ +/* header file sys/poll.h must be included by the external interface. */ +#undef CURL_PULL_SYS_POLL_H +#ifdef CURL_PULL_SYS_POLL_H +# include +#endif + +/* The size of `long', as computed by sizeof. */ +#undef CURL_SIZEOF_LONG + +/* Integral data type used for curl_socklen_t. */ +#undef CURL_TYPEOF_CURL_SOCKLEN_T + +/* The size of `curl_socklen_t', as computed by sizeof. */ +#undef CURL_SIZEOF_CURL_SOCKLEN_T + +/* Data type definition of curl_socklen_t. */ +typedef CURL_TYPEOF_CURL_SOCKLEN_T curl_socklen_t; + +/* Signed integral data type used for curl_off_t. */ +#undef CURL_TYPEOF_CURL_OFF_T + +/* Data type definition of curl_off_t. */ +typedef CURL_TYPEOF_CURL_OFF_T curl_off_t; + +/* curl_off_t formatting string directive without "%" conversion specifier. */ +#undef CURL_FORMAT_CURL_OFF_T + +/* unsigned curl_off_t formatting string without "%" conversion specifier. */ +#undef CURL_FORMAT_CURL_OFF_TU + +/* curl_off_t formatting string directive with "%" conversion specifier. */ +#undef CURL_FORMAT_OFF_T + +/* The size of `curl_off_t', as computed by sizeof. */ +#undef CURL_SIZEOF_CURL_OFF_T + +/* curl_off_t constant suffix. */ +#undef CURL_SUFFIX_CURL_OFF_T + +/* unsigned curl_off_t constant suffix. */ +#undef CURL_SUFFIX_CURL_OFF_TU + +#endif /* __CURL_CURLBUILD_H */ diff --git a/lib/curl/curlrules.h b/lib/curl/curlrules.h new file mode 100644 index 0000000..7c2ede3 --- /dev/null +++ b/lib/curl/curlrules.h @@ -0,0 +1,262 @@ +#ifndef __CURL_CURLRULES_H +#define __CURL_CURLRULES_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2012, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at http://curl.haxx.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ***************************************************************************/ + +/* ================================================================ */ +/* COMPILE TIME SANITY CHECKS */ +/* ================================================================ */ + +/* + * NOTE 1: + * ------- + * + * All checks done in this file are intentionally placed in a public + * header file which is pulled by curl/curl.h when an application is + * being built using an already built libcurl library. Additionally + * this file is also included and used when building the library. + * + * If compilation fails on this file it is certainly sure that the + * problem is elsewhere. It could be a problem in the curlbuild.h + * header file, or simply that you are using different compilation + * settings than those used to build the library. + * + * Nothing in this file is intended to be modified or adjusted by the + * curl library user nor by the curl library builder. + * + * Do not deactivate any check, these are done to make sure that the + * library is properly built and used. + * + * You can find further help on the libcurl development mailing list: + * http://cool.haxx.se/mailman/listinfo/curl-library/ + * + * NOTE 2 + * ------ + * + * Some of the following compile time checks are based on the fact + * that the dimension of a constant array can not be a negative one. + * In this way if the compile time verification fails, the compilation + * will fail issuing an error. The error description wording is compiler + * dependent but it will be quite similar to one of the following: + * + * "negative subscript or subscript is too large" + * "array must have at least one element" + * "-1 is an illegal array size" + * "size of array is negative" + * + * If you are building an application which tries to use an already + * built libcurl library and you are getting this kind of errors on + * this file, it is a clear indication that there is a mismatch between + * how the library was built and how you are trying to use it for your + * application. Your already compiled or binary library provider is the + * only one who can give you the details you need to properly use it. + */ + +/* + * Verify that some macros are actually defined. + */ + +#ifndef CURL_SIZEOF_LONG +# error "CURL_SIZEOF_LONG definition is missing!" + Error Compilation_aborted_CURL_SIZEOF_LONG_is_missing +#endif + +#ifndef CURL_TYPEOF_CURL_SOCKLEN_T +# error "CURL_TYPEOF_CURL_SOCKLEN_T definition is missing!" + Error Compilation_aborted_CURL_TYPEOF_CURL_SOCKLEN_T_is_missing +#endif + +#ifndef CURL_SIZEOF_CURL_SOCKLEN_T +# error "CURL_SIZEOF_CURL_SOCKLEN_T definition is missing!" + Error Compilation_aborted_CURL_SIZEOF_CURL_SOCKLEN_T_is_missing +#endif + +#ifndef CURL_TYPEOF_CURL_OFF_T +# error "CURL_TYPEOF_CURL_OFF_T definition is missing!" + Error Compilation_aborted_CURL_TYPEOF_CURL_OFF_T_is_missing +#endif + +#ifndef CURL_FORMAT_CURL_OFF_T +# error "CURL_FORMAT_CURL_OFF_T definition is missing!" + Error Compilation_aborted_CURL_FORMAT_CURL_OFF_T_is_missing +#endif + +#ifndef CURL_FORMAT_CURL_OFF_TU +# error "CURL_FORMAT_CURL_OFF_TU definition is missing!" + Error Compilation_aborted_CURL_FORMAT_CURL_OFF_TU_is_missing +#endif + +#ifndef CURL_FORMAT_OFF_T +# error "CURL_FORMAT_OFF_T definition is missing!" + Error Compilation_aborted_CURL_FORMAT_OFF_T_is_missing +#endif + +#ifndef CURL_SIZEOF_CURL_OFF_T +# error "CURL_SIZEOF_CURL_OFF_T definition is missing!" + Error Compilation_aborted_CURL_SIZEOF_CURL_OFF_T_is_missing +#endif + +#ifndef CURL_SUFFIX_CURL_OFF_T +# error "CURL_SUFFIX_CURL_OFF_T definition is missing!" + Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_T_is_missing +#endif + +#ifndef CURL_SUFFIX_CURL_OFF_TU +# error "CURL_SUFFIX_CURL_OFF_TU definition is missing!" + Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_TU_is_missing +#endif + +/* + * Macros private to this header file. + */ + +#define CurlchkszEQ(t, s) sizeof(t) == s ? 1 : -1 + +#define CurlchkszGE(t1, t2) sizeof(t1) >= sizeof(t2) ? 1 : -1 + +/* + * Verify that the size previously defined and expected for long + * is the same as the one reported by sizeof() at compile time. + */ + +typedef char + __curl_rule_01__ + [CurlchkszEQ(long, CURL_SIZEOF_LONG)]; + +/* + * Verify that the size previously defined and expected for + * curl_off_t is actually the the same as the one reported + * by sizeof() at compile time. + */ + +typedef char + __curl_rule_02__ + [CurlchkszEQ(curl_off_t, CURL_SIZEOF_CURL_OFF_T)]; + +/* + * Verify at compile time that the size of curl_off_t as reported + * by sizeof() is greater or equal than the one reported for long + * for the current compilation. + */ + +typedef char + __curl_rule_03__ + [CurlchkszGE(curl_off_t, long)]; + +/* + * Verify that the size previously defined and expected for + * curl_socklen_t is actually the the same as the one reported + * by sizeof() at compile time. + */ + +typedef char + __curl_rule_04__ + [CurlchkszEQ(curl_socklen_t, CURL_SIZEOF_CURL_SOCKLEN_T)]; + +/* + * Verify at compile time that the size of curl_socklen_t as reported + * by sizeof() is greater or equal than the one reported for int for + * the current compilation. + */ + +typedef char + __curl_rule_05__ + [CurlchkszGE(curl_socklen_t, int)]; + +/* ================================================================ */ +/* EXTERNALLY AND INTERNALLY VISIBLE DEFINITIONS */ +/* ================================================================ */ + +/* + * CURL_ISOCPP and CURL_OFF_T_C definitions are done here in order to allow + * these to be visible and exported by the external libcurl interface API, + * while also making them visible to the library internals, simply including + * curl_setup.h, without actually needing to include curl.h internally. + * If some day this section would grow big enough, all this should be moved + * to its own header file. + */ + +/* + * Figure out if we can use the ## preprocessor operator, which is supported + * by ISO/ANSI C and C++. Some compilers support it without setting __STDC__ + * or __cplusplus so we need to carefully check for them too. + */ + +#if defined(__STDC__) || defined(_MSC_VER) || defined(__cplusplus) || \ + defined(__HP_aCC) || defined(__BORLANDC__) || defined(__LCC__) || \ + defined(__POCC__) || defined(__SALFORDC__) || defined(__HIGHC__) || \ + defined(__ILEC400__) + /* This compiler is believed to have an ISO compatible preprocessor */ +#define CURL_ISOCPP +#else + /* This compiler is believed NOT to have an ISO compatible preprocessor */ +#undef CURL_ISOCPP +#endif + +/* + * Macros for minimum-width signed and unsigned curl_off_t integer constants. + */ + +#if defined(__BORLANDC__) && (__BORLANDC__ == 0x0551) +# define __CURL_OFF_T_C_HLPR2(x) x +# define __CURL_OFF_T_C_HLPR1(x) __CURL_OFF_T_C_HLPR2(x) +# define CURL_OFF_T_C(Val) __CURL_OFF_T_C_HLPR1(Val) ## \ + __CURL_OFF_T_C_HLPR1(CURL_SUFFIX_CURL_OFF_T) +# define CURL_OFF_TU_C(Val) __CURL_OFF_T_C_HLPR1(Val) ## \ + __CURL_OFF_T_C_HLPR1(CURL_SUFFIX_CURL_OFF_TU) +#else +# ifdef CURL_ISOCPP +# define __CURL_OFF_T_C_HLPR2(Val,Suffix) Val ## Suffix +# else +# define __CURL_OFF_T_C_HLPR2(Val,Suffix) Val/**/Suffix +# endif +# define __CURL_OFF_T_C_HLPR1(Val,Suffix) __CURL_OFF_T_C_HLPR2(Val,Suffix) +# define CURL_OFF_T_C(Val) __CURL_OFF_T_C_HLPR1(Val,CURL_SUFFIX_CURL_OFF_T) +# define CURL_OFF_TU_C(Val) __CURL_OFF_T_C_HLPR1(Val,CURL_SUFFIX_CURL_OFF_TU) +#endif + +/* + * Get rid of macros private to this header file. + */ + +#undef CurlchkszEQ +#undef CurlchkszGE + +/* + * Get rid of macros not intended to exist beyond this point. + */ + +#undef CURL_PULL_WS2TCPIP_H +#undef CURL_PULL_SYS_TYPES_H +#undef CURL_PULL_SYS_SOCKET_H +#undef CURL_PULL_SYS_POLL_H +#undef CURL_PULL_STDINT_H +#undef CURL_PULL_INTTYPES_H + +#undef CURL_TYPEOF_CURL_SOCKLEN_T +#undef CURL_TYPEOF_CURL_OFF_T + +#ifdef CURL_NO_OLDIES +#undef CURL_FORMAT_OFF_T /* not required since 7.19.0 - obsoleted in 7.20.0 */ +#endif + +#endif /* __CURL_CURLRULES_H */ diff --git a/lib/curl/curlver.h b/lib/curl/curlver.h new file mode 100644 index 0000000..c472dbe --- /dev/null +++ b/lib/curl/curlver.h @@ -0,0 +1,69 @@ +#ifndef __CURL_CURLVER_H +#define __CURL_CURLVER_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2014, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at http://curl.haxx.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ***************************************************************************/ + +/* This header file contains nothing but libcurl version info, generated by + a script at release-time. This was made its own header file in 7.11.2 */ + +/* This is the global package copyright */ +#define LIBCURL_COPYRIGHT "1996 - 2014 Daniel Stenberg, ." + +/* This is the version number of the libcurl package from which this header + file origins: */ +#define LIBCURL_VERSION "7.37.0" + +/* The numeric version number is also available "in parts" by using these + defines: */ +#define LIBCURL_VERSION_MAJOR 7 +#define LIBCURL_VERSION_MINOR 37 +#define LIBCURL_VERSION_PATCH 0 + +/* This is the numeric version of the libcurl version number, meant for easier + parsing and comparions by programs. The LIBCURL_VERSION_NUM define will + always follow this syntax: + + 0xXXYYZZ + + Where XX, YY and ZZ are the main version, release and patch numbers in + hexadecimal (using 8 bits each). All three numbers are always represented + using two digits. 1.2 would appear as "0x010200" while version 9.11.7 + appears as "0x090b07". + + This 6-digit (24 bits) hexadecimal number does not show pre-release number, + and it is always a greater number in a more recent release. It makes + comparisons with greater than and less than work. +*/ +#define LIBCURL_VERSION_NUM 0x072500 + +/* + * This is the date and time when the full source package was created. The + * timestamp is not stored in git, as the timestamp is properly set in the + * tarballs by the maketgz script. + * + * The format of the date should follow this template: + * + * "Mon Feb 12 11:35:33 UTC 2007" + */ +#define LIBCURL_TIMESTAMP "Wed May 21 05:58:26 UTC 2014" + +#endif /* __CURL_CURLVER_H */ diff --git a/lib/curl/easy.h b/lib/curl/easy.h new file mode 100644 index 0000000..c1e3e76 --- /dev/null +++ b/lib/curl/easy.h @@ -0,0 +1,102 @@ +#ifndef __CURL_EASY_H +#define __CURL_EASY_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2008, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at http://curl.haxx.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ***************************************************************************/ +#ifdef __cplusplus +extern "C" { +#endif + +CURL_EXTERN CURL *curl_easy_init(void); +CURL_EXTERN CURLcode curl_easy_setopt(CURL *curl, CURLoption option, ...); +CURL_EXTERN CURLcode curl_easy_perform(CURL *curl); +CURL_EXTERN void curl_easy_cleanup(CURL *curl); + +/* + * NAME curl_easy_getinfo() + * + * DESCRIPTION + * + * Request internal information from the curl session with this function. The + * third argument MUST be a pointer to a long, a pointer to a char * or a + * pointer to a double (as the documentation describes elsewhere). The data + * pointed to will be filled in accordingly and can be relied upon only if the + * function returns CURLE_OK. This function is intended to get used *AFTER* a + * performed transfer, all results from this function are undefined until the + * transfer is completed. + */ +CURL_EXTERN CURLcode curl_easy_getinfo(CURL *curl, CURLINFO info, ...); + + +/* + * NAME curl_easy_duphandle() + * + * DESCRIPTION + * + * Creates a new curl session handle with the same options set for the handle + * passed in. Duplicating a handle could only be a matter of cloning data and + * options, internal state info and things like persistent connections cannot + * be transferred. It is useful in multithreaded applications when you can run + * curl_easy_duphandle() for each new thread to avoid a series of identical + * curl_easy_setopt() invokes in every thread. + */ +CURL_EXTERN CURL* curl_easy_duphandle(CURL *curl); + +/* + * NAME curl_easy_reset() + * + * DESCRIPTION + * + * Re-initializes a CURL handle to the default values. This puts back the + * handle to the same state as it was in when it was just created. + * + * It does keep: live connections, the Session ID cache, the DNS cache and the + * cookies. + */ +CURL_EXTERN void curl_easy_reset(CURL *curl); + +/* + * NAME curl_easy_recv() + * + * DESCRIPTION + * + * Receives data from the connected socket. Use after successful + * curl_easy_perform() with CURLOPT_CONNECT_ONLY option. + */ +CURL_EXTERN CURLcode curl_easy_recv(CURL *curl, void *buffer, size_t buflen, + size_t *n); + +/* + * NAME curl_easy_send() + * + * DESCRIPTION + * + * Sends data over the connected socket. Use after successful + * curl_easy_perform() with CURLOPT_CONNECT_ONLY option. + */ +CURL_EXTERN CURLcode curl_easy_send(CURL *curl, const void *buffer, + size_t buflen, size_t *n); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/curl/mprintf.h b/lib/curl/mprintf.h new file mode 100644 index 0000000..cc9e7f5 --- /dev/null +++ b/lib/curl/mprintf.h @@ -0,0 +1,81 @@ +#ifndef __CURL_MPRINTF_H +#define __CURL_MPRINTF_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2013, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at http://curl.haxx.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ***************************************************************************/ + +#include +#include /* needed for FILE */ + +#include "curl.h" + +#ifdef __cplusplus +extern "C" { +#endif + +CURL_EXTERN int curl_mprintf(const char *format, ...); +CURL_EXTERN int curl_mfprintf(FILE *fd, const char *format, ...); +CURL_EXTERN int curl_msprintf(char *buffer, const char *format, ...); +CURL_EXTERN int curl_msnprintf(char *buffer, size_t maxlength, + const char *format, ...); +CURL_EXTERN int curl_mvprintf(const char *format, va_list args); +CURL_EXTERN int curl_mvfprintf(FILE *fd, const char *format, va_list args); +CURL_EXTERN int curl_mvsprintf(char *buffer, const char *format, va_list args); +CURL_EXTERN int curl_mvsnprintf(char *buffer, size_t maxlength, + const char *format, va_list args); +CURL_EXTERN char *curl_maprintf(const char *format, ...); +CURL_EXTERN char *curl_mvaprintf(const char *format, va_list args); + +#ifdef _MPRINTF_REPLACE +# undef printf +# undef fprintf +# undef sprintf +# undef vsprintf +# undef snprintf +# undef vprintf +# undef vfprintf +# undef vsnprintf +# undef aprintf +# undef vaprintf +# define printf curl_mprintf +# define fprintf curl_mfprintf +#ifdef CURLDEBUG +/* When built with CURLDEBUG we define away the sprintf functions since we + don't want internal code to be using them */ +# define sprintf sprintf_was_used +# define vsprintf vsprintf_was_used +#else +# define sprintf curl_msprintf +# define vsprintf curl_mvsprintf +#endif +# define snprintf curl_msnprintf +# define vprintf curl_mvprintf +# define vfprintf curl_mvfprintf +# define vsnprintf curl_mvsnprintf +# define aprintf curl_maprintf +# define vaprintf curl_mvaprintf +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* __CURL_MPRINTF_H */ diff --git a/lib/curl/multi.h b/lib/curl/multi.h new file mode 100644 index 0000000..3c4acb0 --- /dev/null +++ b/lib/curl/multi.h @@ -0,0 +1,399 @@ +#ifndef __CURL_MULTI_H +#define __CURL_MULTI_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2013, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at http://curl.haxx.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ***************************************************************************/ +/* + This is an "external" header file. Don't give away any internals here! + + GOALS + + o Enable a "pull" interface. The application that uses libcurl decides where + and when to ask libcurl to get/send data. + + o Enable multiple simultaneous transfers in the same thread without making it + complicated for the application. + + o Enable the application to select() on its own file descriptors and curl's + file descriptors simultaneous easily. + +*/ + +/* + * This header file should not really need to include "curl.h" since curl.h + * itself includes this file and we expect user applications to do #include + * without the need for especially including multi.h. + * + * For some reason we added this include here at one point, and rather than to + * break existing (wrongly written) libcurl applications, we leave it as-is + * but with this warning attached. + */ +#include "curl.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void CURLM; + +typedef enum { + CURLM_CALL_MULTI_PERFORM = -1, /* please call curl_multi_perform() or + curl_multi_socket*() soon */ + CURLM_OK, + CURLM_BAD_HANDLE, /* the passed-in handle is not a valid CURLM handle */ + CURLM_BAD_EASY_HANDLE, /* an easy handle was not good/valid */ + CURLM_OUT_OF_MEMORY, /* if you ever get this, you're in deep sh*t */ + CURLM_INTERNAL_ERROR, /* this is a libcurl bug */ + CURLM_BAD_SOCKET, /* the passed in socket argument did not match */ + CURLM_UNKNOWN_OPTION, /* curl_multi_setopt() with unsupported option */ + CURLM_ADDED_ALREADY, /* an easy handle already added to a multi handle was + attempted to get added - again */ + CURLM_LAST +} CURLMcode; + +/* just to make code nicer when using curl_multi_socket() you can now check + for CURLM_CALL_MULTI_SOCKET too in the same style it works for + curl_multi_perform() and CURLM_CALL_MULTI_PERFORM */ +#define CURLM_CALL_MULTI_SOCKET CURLM_CALL_MULTI_PERFORM + +typedef enum { + CURLMSG_NONE, /* first, not used */ + CURLMSG_DONE, /* This easy handle has completed. 'result' contains + the CURLcode of the transfer */ + CURLMSG_LAST /* last, not used */ +} CURLMSG; + +struct CURLMsg { + CURLMSG msg; /* what this message means */ + CURL *easy_handle; /* the handle it concerns */ + union { + void *whatever; /* message-specific data */ + CURLcode result; /* return code for transfer */ + } data; +}; +typedef struct CURLMsg CURLMsg; + +/* Based on poll(2) structure and values. + * We don't use pollfd and POLL* constants explicitly + * to cover platforms without poll(). */ +#define CURL_WAIT_POLLIN 0x0001 +#define CURL_WAIT_POLLPRI 0x0002 +#define CURL_WAIT_POLLOUT 0x0004 + +struct curl_waitfd { + curl_socket_t fd; + short events; + short revents; /* not supported yet */ +}; + +/* + * Name: curl_multi_init() + * + * Desc: inititalize multi-style curl usage + * + * Returns: a new CURLM handle to use in all 'curl_multi' functions. + */ +CURL_EXTERN CURLM *curl_multi_init(void); + +/* + * Name: curl_multi_add_handle() + * + * Desc: add a standard curl handle to the multi stack + * + * Returns: CURLMcode type, general multi error code. + */ +CURL_EXTERN CURLMcode curl_multi_add_handle(CURLM *multi_handle, + CURL *curl_handle); + + /* + * Name: curl_multi_remove_handle() + * + * Desc: removes a curl handle from the multi stack again + * + * Returns: CURLMcode type, general multi error code. + */ +CURL_EXTERN CURLMcode curl_multi_remove_handle(CURLM *multi_handle, + CURL *curl_handle); + + /* + * Name: curl_multi_fdset() + * + * Desc: Ask curl for its fd_set sets. The app can use these to select() or + * poll() on. We want curl_multi_perform() called as soon as one of + * them are ready. + * + * Returns: CURLMcode type, general multi error code. + */ +CURL_EXTERN CURLMcode curl_multi_fdset(CURLM *multi_handle, + fd_set *read_fd_set, + fd_set *write_fd_set, + fd_set *exc_fd_set, + int *max_fd); + +/* + * Name: curl_multi_wait() + * + * Desc: Poll on all fds within a CURLM set as well as any + * additional fds passed to the function. + * + * Returns: CURLMcode type, general multi error code. + */ +CURL_EXTERN CURLMcode curl_multi_wait(CURLM *multi_handle, + struct curl_waitfd extra_fds[], + unsigned int extra_nfds, + int timeout_ms, + int *ret); + + /* + * Name: curl_multi_perform() + * + * Desc: When the app thinks there's data available for curl it calls this + * function to read/write whatever there is right now. This returns + * as soon as the reads and writes are done. This function does not + * require that there actually is data available for reading or that + * data can be written, it can be called just in case. It returns + * the number of handles that still transfer data in the second + * argument's integer-pointer. + * + * Returns: CURLMcode type, general multi error code. *NOTE* that this only + * returns errors etc regarding the whole multi stack. There might + * still have occurred problems on invidual transfers even when this + * returns OK. + */ +CURL_EXTERN CURLMcode curl_multi_perform(CURLM *multi_handle, + int *running_handles); + + /* + * Name: curl_multi_cleanup() + * + * Desc: Cleans up and removes a whole multi stack. It does not free or + * touch any individual easy handles in any way. We need to define + * in what state those handles will be if this function is called + * in the middle of a transfer. + * + * Returns: CURLMcode type, general multi error code. + */ +CURL_EXTERN CURLMcode curl_multi_cleanup(CURLM *multi_handle); + +/* + * Name: curl_multi_info_read() + * + * Desc: Ask the multi handle if there's any messages/informationals from + * the individual transfers. Messages include informationals such as + * error code from the transfer or just the fact that a transfer is + * completed. More details on these should be written down as well. + * + * Repeated calls to this function will return a new struct each + * time, until a special "end of msgs" struct is returned as a signal + * that there is no more to get at this point. + * + * The data the returned pointer points to will not survive calling + * curl_multi_cleanup(). + * + * The 'CURLMsg' struct is meant to be very simple and only contain + * very basic informations. If more involved information is wanted, + * we will provide the particular "transfer handle" in that struct + * and that should/could/would be used in subsequent + * curl_easy_getinfo() calls (or similar). The point being that we + * must never expose complex structs to applications, as then we'll + * undoubtably get backwards compatibility problems in the future. + * + * Returns: A pointer to a filled-in struct, or NULL if it failed or ran out + * of structs. It also writes the number of messages left in the + * queue (after this read) in the integer the second argument points + * to. + */ +CURL_EXTERN CURLMsg *curl_multi_info_read(CURLM *multi_handle, + int *msgs_in_queue); + +/* + * Name: curl_multi_strerror() + * + * Desc: The curl_multi_strerror function may be used to turn a CURLMcode + * value into the equivalent human readable error string. This is + * useful for printing meaningful error messages. + * + * Returns: A pointer to a zero-terminated error message. + */ +CURL_EXTERN const char *curl_multi_strerror(CURLMcode); + +/* + * Name: curl_multi_socket() and + * curl_multi_socket_all() + * + * Desc: An alternative version of curl_multi_perform() that allows the + * application to pass in one of the file descriptors that have been + * detected to have "action" on them and let libcurl perform. + * See man page for details. + */ +#define CURL_POLL_NONE 0 +#define CURL_POLL_IN 1 +#define CURL_POLL_OUT 2 +#define CURL_POLL_INOUT 3 +#define CURL_POLL_REMOVE 4 + +#define CURL_SOCKET_TIMEOUT CURL_SOCKET_BAD + +#define CURL_CSELECT_IN 0x01 +#define CURL_CSELECT_OUT 0x02 +#define CURL_CSELECT_ERR 0x04 + +typedef int (*curl_socket_callback)(CURL *easy, /* easy handle */ + curl_socket_t s, /* socket */ + int what, /* see above */ + void *userp, /* private callback + pointer */ + void *socketp); /* private socket + pointer */ +/* + * Name: curl_multi_timer_callback + * + * Desc: Called by libcurl whenever the library detects a change in the + * maximum number of milliseconds the app is allowed to wait before + * curl_multi_socket() or curl_multi_perform() must be called + * (to allow libcurl's timed events to take place). + * + * Returns: The callback should return zero. + */ +typedef int (*curl_multi_timer_callback)(CURLM *multi, /* multi handle */ + long timeout_ms, /* see above */ + void *userp); /* private callback + pointer */ + +CURL_EXTERN CURLMcode curl_multi_socket(CURLM *multi_handle, curl_socket_t s, + int *running_handles); + +CURL_EXTERN CURLMcode curl_multi_socket_action(CURLM *multi_handle, + curl_socket_t s, + int ev_bitmask, + int *running_handles); + +CURL_EXTERN CURLMcode curl_multi_socket_all(CURLM *multi_handle, + int *running_handles); + +#ifndef CURL_ALLOW_OLD_MULTI_SOCKET +/* This macro below was added in 7.16.3 to push users who recompile to use + the new curl_multi_socket_action() instead of the old curl_multi_socket() +*/ +#define curl_multi_socket(x,y,z) curl_multi_socket_action(x,y,0,z) +#endif + +/* + * Name: curl_multi_timeout() + * + * Desc: Returns the maximum number of milliseconds the app is allowed to + * wait before curl_multi_socket() or curl_multi_perform() must be + * called (to allow libcurl's timed events to take place). + * + * Returns: CURLM error code. + */ +CURL_EXTERN CURLMcode curl_multi_timeout(CURLM *multi_handle, + long *milliseconds); + +#undef CINIT /* re-using the same name as in curl.h */ + +#ifdef CURL_ISOCPP +#define CINIT(name,type,num) CURLMOPT_ ## name = CURLOPTTYPE_ ## type + num +#else +/* The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */ +#define LONG CURLOPTTYPE_LONG +#define OBJECTPOINT CURLOPTTYPE_OBJECTPOINT +#define FUNCTIONPOINT CURLOPTTYPE_FUNCTIONPOINT +#define OFF_T CURLOPTTYPE_OFF_T +#define CINIT(name,type,number) CURLMOPT_/**/name = type + number +#endif + +typedef enum { + /* This is the socket callback function pointer */ + CINIT(SOCKETFUNCTION, FUNCTIONPOINT, 1), + + /* This is the argument passed to the socket callback */ + CINIT(SOCKETDATA, OBJECTPOINT, 2), + + /* set to 1 to enable pipelining for this multi handle */ + CINIT(PIPELINING, LONG, 3), + + /* This is the timer callback function pointer */ + CINIT(TIMERFUNCTION, FUNCTIONPOINT, 4), + + /* This is the argument passed to the timer callback */ + CINIT(TIMERDATA, OBJECTPOINT, 5), + + /* maximum number of entries in the connection cache */ + CINIT(MAXCONNECTS, LONG, 6), + + /* maximum number of (pipelining) connections to one host */ + CINIT(MAX_HOST_CONNECTIONS, LONG, 7), + + /* maximum number of requests in a pipeline */ + CINIT(MAX_PIPELINE_LENGTH, LONG, 8), + + /* a connection with a content-length longer than this + will not be considered for pipelining */ + CINIT(CONTENT_LENGTH_PENALTY_SIZE, OFF_T, 9), + + /* a connection with a chunk length longer than this + will not be considered for pipelining */ + CINIT(CHUNK_LENGTH_PENALTY_SIZE, OFF_T, 10), + + /* a list of site names(+port) that are blacklisted from + pipelining */ + CINIT(PIPELINING_SITE_BL, OBJECTPOINT, 11), + + /* a list of server types that are blacklisted from + pipelining */ + CINIT(PIPELINING_SERVER_BL, OBJECTPOINT, 12), + + /* maximum number of open connections in total */ + CINIT(MAX_TOTAL_CONNECTIONS, LONG, 13), + + CURLMOPT_LASTENTRY /* the last unused */ +} CURLMoption; + + +/* + * Name: curl_multi_setopt() + * + * Desc: Sets options for the multi handle. + * + * Returns: CURLM error code. + */ +CURL_EXTERN CURLMcode curl_multi_setopt(CURLM *multi_handle, + CURLMoption option, ...); + + +/* + * Name: curl_multi_assign() + * + * Desc: This function sets an association in the multi handle between the + * given socket and a private pointer of the application. This is + * (only) useful for curl_multi_socket uses. + * + * Returns: CURLM error code. + */ +CURL_EXTERN CURLMcode curl_multi_assign(CURLM *multi_handle, + curl_socket_t sockfd, void *sockp); + +#ifdef __cplusplus +} /* end of extern "C" */ +#endif + +#endif diff --git a/lib/curl/stdcheaders.h b/lib/curl/stdcheaders.h new file mode 100644 index 0000000..ad82ef6 --- /dev/null +++ b/lib/curl/stdcheaders.h @@ -0,0 +1,33 @@ +#ifndef __STDC_HEADERS_H +#define __STDC_HEADERS_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2010, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at http://curl.haxx.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ***************************************************************************/ + +#include + +size_t fread (void *, size_t, size_t, FILE *); +size_t fwrite (const void *, size_t, size_t, FILE *); + +int strcasecmp(const char *, const char *); +int strncasecmp(const char *, const char *, size_t); + +#endif /* __STDC_HEADERS_H */ diff --git a/lib/curl/typecheck-gcc.h b/lib/curl/typecheck-gcc.h new file mode 100644 index 0000000..cdeba21 --- /dev/null +++ b/lib/curl/typecheck-gcc.h @@ -0,0 +1,610 @@ +#ifndef __CURL_TYPECHECK_GCC_H +#define __CURL_TYPECHECK_GCC_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2013, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at http://curl.haxx.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ***************************************************************************/ + +/* wraps curl_easy_setopt() with typechecking */ + +/* To add a new kind of warning, add an + * if(_curl_is_sometype_option(_curl_opt)) + * if(!_curl_is_sometype(value)) + * _curl_easy_setopt_err_sometype(); + * block and define _curl_is_sometype_option, _curl_is_sometype and + * _curl_easy_setopt_err_sometype below + * + * NOTE: We use two nested 'if' statements here instead of the && operator, in + * order to work around gcc bug #32061. It affects only gcc 4.3.x/4.4.x + * when compiling with -Wlogical-op. + * + * To add an option that uses the same type as an existing option, you'll just + * need to extend the appropriate _curl_*_option macro + */ +#define curl_easy_setopt(handle, option, value) \ +__extension__ ({ \ + __typeof__ (option) _curl_opt = option; \ + if(__builtin_constant_p(_curl_opt)) { \ + if(_curl_is_long_option(_curl_opt)) \ + if(!_curl_is_long(value)) \ + _curl_easy_setopt_err_long(); \ + if(_curl_is_off_t_option(_curl_opt)) \ + if(!_curl_is_off_t(value)) \ + _curl_easy_setopt_err_curl_off_t(); \ + if(_curl_is_string_option(_curl_opt)) \ + if(!_curl_is_string(value)) \ + _curl_easy_setopt_err_string(); \ + if(_curl_is_write_cb_option(_curl_opt)) \ + if(!_curl_is_write_cb(value)) \ + _curl_easy_setopt_err_write_callback(); \ + if((_curl_opt) == CURLOPT_READFUNCTION) \ + if(!_curl_is_read_cb(value)) \ + _curl_easy_setopt_err_read_cb(); \ + if((_curl_opt) == CURLOPT_IOCTLFUNCTION) \ + if(!_curl_is_ioctl_cb(value)) \ + _curl_easy_setopt_err_ioctl_cb(); \ + if((_curl_opt) == CURLOPT_SOCKOPTFUNCTION) \ + if(!_curl_is_sockopt_cb(value)) \ + _curl_easy_setopt_err_sockopt_cb(); \ + if((_curl_opt) == CURLOPT_OPENSOCKETFUNCTION) \ + if(!_curl_is_opensocket_cb(value)) \ + _curl_easy_setopt_err_opensocket_cb(); \ + if((_curl_opt) == CURLOPT_PROGRESSFUNCTION) \ + if(!_curl_is_progress_cb(value)) \ + _curl_easy_setopt_err_progress_cb(); \ + if((_curl_opt) == CURLOPT_DEBUGFUNCTION) \ + if(!_curl_is_debug_cb(value)) \ + _curl_easy_setopt_err_debug_cb(); \ + if((_curl_opt) == CURLOPT_SSL_CTX_FUNCTION) \ + if(!_curl_is_ssl_ctx_cb(value)) \ + _curl_easy_setopt_err_ssl_ctx_cb(); \ + if(_curl_is_conv_cb_option(_curl_opt)) \ + if(!_curl_is_conv_cb(value)) \ + _curl_easy_setopt_err_conv_cb(); \ + if((_curl_opt) == CURLOPT_SEEKFUNCTION) \ + if(!_curl_is_seek_cb(value)) \ + _curl_easy_setopt_err_seek_cb(); \ + if(_curl_is_cb_data_option(_curl_opt)) \ + if(!_curl_is_cb_data(value)) \ + _curl_easy_setopt_err_cb_data(); \ + if((_curl_opt) == CURLOPT_ERRORBUFFER) \ + if(!_curl_is_error_buffer(value)) \ + _curl_easy_setopt_err_error_buffer(); \ + if((_curl_opt) == CURLOPT_STDERR) \ + if(!_curl_is_FILE(value)) \ + _curl_easy_setopt_err_FILE(); \ + if(_curl_is_postfields_option(_curl_opt)) \ + if(!_curl_is_postfields(value)) \ + _curl_easy_setopt_err_postfields(); \ + if((_curl_opt) == CURLOPT_HTTPPOST) \ + if(!_curl_is_arr((value), struct curl_httppost)) \ + _curl_easy_setopt_err_curl_httpost(); \ + if(_curl_is_slist_option(_curl_opt)) \ + if(!_curl_is_arr((value), struct curl_slist)) \ + _curl_easy_setopt_err_curl_slist(); \ + if((_curl_opt) == CURLOPT_SHARE) \ + if(!_curl_is_ptr((value), CURLSH)) \ + _curl_easy_setopt_err_CURLSH(); \ + } \ + curl_easy_setopt(handle, _curl_opt, value); \ +}) + +/* wraps curl_easy_getinfo() with typechecking */ +/* FIXME: don't allow const pointers */ +#define curl_easy_getinfo(handle, info, arg) \ +__extension__ ({ \ + __typeof__ (info) _curl_info = info; \ + if(__builtin_constant_p(_curl_info)) { \ + if(_curl_is_string_info(_curl_info)) \ + if(!_curl_is_arr((arg), char *)) \ + _curl_easy_getinfo_err_string(); \ + if(_curl_is_long_info(_curl_info)) \ + if(!_curl_is_arr((arg), long)) \ + _curl_easy_getinfo_err_long(); \ + if(_curl_is_double_info(_curl_info)) \ + if(!_curl_is_arr((arg), double)) \ + _curl_easy_getinfo_err_double(); \ + if(_curl_is_slist_info(_curl_info)) \ + if(!_curl_is_arr((arg), struct curl_slist *)) \ + _curl_easy_getinfo_err_curl_slist(); \ + } \ + curl_easy_getinfo(handle, _curl_info, arg); \ +}) + +/* TODO: typechecking for curl_share_setopt() and curl_multi_setopt(), + * for now just make sure that the functions are called with three + * arguments + */ +#define curl_share_setopt(share,opt,param) curl_share_setopt(share,opt,param) +#define curl_multi_setopt(handle,opt,param) curl_multi_setopt(handle,opt,param) + + +/* the actual warnings, triggered by calling the _curl_easy_setopt_err* + * functions */ + +/* To define a new warning, use _CURL_WARNING(identifier, "message") */ +#define _CURL_WARNING(id, message) \ + static void __attribute__((__warning__(message))) \ + __attribute__((__unused__)) __attribute__((__noinline__)) \ + id(void) { __asm__(""); } + +_CURL_WARNING(_curl_easy_setopt_err_long, + "curl_easy_setopt expects a long argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_curl_off_t, + "curl_easy_setopt expects a curl_off_t argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_string, + "curl_easy_setopt expects a " + "string (char* or char[]) argument for this option" + ) +_CURL_WARNING(_curl_easy_setopt_err_write_callback, + "curl_easy_setopt expects a curl_write_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_read_cb, + "curl_easy_setopt expects a curl_read_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_ioctl_cb, + "curl_easy_setopt expects a curl_ioctl_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_sockopt_cb, + "curl_easy_setopt expects a curl_sockopt_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_opensocket_cb, + "curl_easy_setopt expects a " + "curl_opensocket_callback argument for this option" + ) +_CURL_WARNING(_curl_easy_setopt_err_progress_cb, + "curl_easy_setopt expects a curl_progress_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_debug_cb, + "curl_easy_setopt expects a curl_debug_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_ssl_ctx_cb, + "curl_easy_setopt expects a curl_ssl_ctx_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_conv_cb, + "curl_easy_setopt expects a curl_conv_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_seek_cb, + "curl_easy_setopt expects a curl_seek_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_cb_data, + "curl_easy_setopt expects a " + "private data pointer as argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_error_buffer, + "curl_easy_setopt expects a " + "char buffer of CURL_ERROR_SIZE as argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_FILE, + "curl_easy_setopt expects a FILE* argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_postfields, + "curl_easy_setopt expects a void* or char* argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_curl_httpost, + "curl_easy_setopt expects a struct curl_httppost* argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_curl_slist, + "curl_easy_setopt expects a struct curl_slist* argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_CURLSH, + "curl_easy_setopt expects a CURLSH* argument for this option") + +_CURL_WARNING(_curl_easy_getinfo_err_string, + "curl_easy_getinfo expects a pointer to char * for this info") +_CURL_WARNING(_curl_easy_getinfo_err_long, + "curl_easy_getinfo expects a pointer to long for this info") +_CURL_WARNING(_curl_easy_getinfo_err_double, + "curl_easy_getinfo expects a pointer to double for this info") +_CURL_WARNING(_curl_easy_getinfo_err_curl_slist, + "curl_easy_getinfo expects a pointer to struct curl_slist * for this info") + +/* groups of curl_easy_setops options that take the same type of argument */ + +/* To add a new option to one of the groups, just add + * (option) == CURLOPT_SOMETHING + * to the or-expression. If the option takes a long or curl_off_t, you don't + * have to do anything + */ + +/* evaluates to true if option takes a long argument */ +#define _curl_is_long_option(option) \ + (0 < (option) && (option) < CURLOPTTYPE_OBJECTPOINT) + +#define _curl_is_off_t_option(option) \ + ((option) > CURLOPTTYPE_OFF_T) + +/* evaluates to true if option takes a char* argument */ +#define _curl_is_string_option(option) \ + ((option) == CURLOPT_URL || \ + (option) == CURLOPT_PROXY || \ + (option) == CURLOPT_INTERFACE || \ + (option) == CURLOPT_NETRC_FILE || \ + (option) == CURLOPT_USERPWD || \ + (option) == CURLOPT_USERNAME || \ + (option) == CURLOPT_PASSWORD || \ + (option) == CURLOPT_PROXYUSERPWD || \ + (option) == CURLOPT_PROXYUSERNAME || \ + (option) == CURLOPT_PROXYPASSWORD || \ + (option) == CURLOPT_NOPROXY || \ + (option) == CURLOPT_ACCEPT_ENCODING || \ + (option) == CURLOPT_REFERER || \ + (option) == CURLOPT_USERAGENT || \ + (option) == CURLOPT_COOKIE || \ + (option) == CURLOPT_COOKIEFILE || \ + (option) == CURLOPT_COOKIEJAR || \ + (option) == CURLOPT_COOKIELIST || \ + (option) == CURLOPT_FTPPORT || \ + (option) == CURLOPT_FTP_ALTERNATIVE_TO_USER || \ + (option) == CURLOPT_FTP_ACCOUNT || \ + (option) == CURLOPT_RANGE || \ + (option) == CURLOPT_CUSTOMREQUEST || \ + (option) == CURLOPT_SSLCERT || \ + (option) == CURLOPT_SSLCERTTYPE || \ + (option) == CURLOPT_SSLKEY || \ + (option) == CURLOPT_SSLKEYTYPE || \ + (option) == CURLOPT_KEYPASSWD || \ + (option) == CURLOPT_SSLENGINE || \ + (option) == CURLOPT_CAINFO || \ + (option) == CURLOPT_CAPATH || \ + (option) == CURLOPT_RANDOM_FILE || \ + (option) == CURLOPT_EGDSOCKET || \ + (option) == CURLOPT_SSL_CIPHER_LIST || \ + (option) == CURLOPT_KRBLEVEL || \ + (option) == CURLOPT_SSH_HOST_PUBLIC_KEY_MD5 || \ + (option) == CURLOPT_SSH_PUBLIC_KEYFILE || \ + (option) == CURLOPT_SSH_PRIVATE_KEYFILE || \ + (option) == CURLOPT_CRLFILE || \ + (option) == CURLOPT_ISSUERCERT || \ + (option) == CURLOPT_SOCKS5_GSSAPI_SERVICE || \ + (option) == CURLOPT_SSH_KNOWNHOSTS || \ + (option) == CURLOPT_MAIL_FROM || \ + (option) == CURLOPT_RTSP_SESSION_ID || \ + (option) == CURLOPT_RTSP_STREAM_URI || \ + (option) == CURLOPT_RTSP_TRANSPORT || \ + (option) == CURLOPT_XOAUTH2_BEARER || \ + (option) == CURLOPT_DNS_SERVERS || \ + (option) == CURLOPT_DNS_INTERFACE || \ + (option) == CURLOPT_DNS_LOCAL_IP4 || \ + (option) == CURLOPT_DNS_LOCAL_IP6 || \ + (option) == CURLOPT_LOGIN_OPTIONS || \ + 0) + +/* evaluates to true if option takes a curl_write_callback argument */ +#define _curl_is_write_cb_option(option) \ + ((option) == CURLOPT_HEADERFUNCTION || \ + (option) == CURLOPT_WRITEFUNCTION) + +/* evaluates to true if option takes a curl_conv_callback argument */ +#define _curl_is_conv_cb_option(option) \ + ((option) == CURLOPT_CONV_TO_NETWORK_FUNCTION || \ + (option) == CURLOPT_CONV_FROM_NETWORK_FUNCTION || \ + (option) == CURLOPT_CONV_FROM_UTF8_FUNCTION) + +/* evaluates to true if option takes a data argument to pass to a callback */ +#define _curl_is_cb_data_option(option) \ + ((option) == CURLOPT_WRITEDATA || \ + (option) == CURLOPT_READDATA || \ + (option) == CURLOPT_IOCTLDATA || \ + (option) == CURLOPT_SOCKOPTDATA || \ + (option) == CURLOPT_OPENSOCKETDATA || \ + (option) == CURLOPT_PROGRESSDATA || \ + (option) == CURLOPT_WRITEHEADER || \ + (option) == CURLOPT_DEBUGDATA || \ + (option) == CURLOPT_SSL_CTX_DATA || \ + (option) == CURLOPT_SEEKDATA || \ + (option) == CURLOPT_PRIVATE || \ + (option) == CURLOPT_SSH_KEYDATA || \ + (option) == CURLOPT_INTERLEAVEDATA || \ + (option) == CURLOPT_CHUNK_DATA || \ + (option) == CURLOPT_FNMATCH_DATA || \ + 0) + +/* evaluates to true if option takes a POST data argument (void* or char*) */ +#define _curl_is_postfields_option(option) \ + ((option) == CURLOPT_POSTFIELDS || \ + (option) == CURLOPT_COPYPOSTFIELDS || \ + 0) + +/* evaluates to true if option takes a struct curl_slist * argument */ +#define _curl_is_slist_option(option) \ + ((option) == CURLOPT_HTTPHEADER || \ + (option) == CURLOPT_HTTP200ALIASES || \ + (option) == CURLOPT_QUOTE || \ + (option) == CURLOPT_POSTQUOTE || \ + (option) == CURLOPT_PREQUOTE || \ + (option) == CURLOPT_TELNETOPTIONS || \ + (option) == CURLOPT_MAIL_RCPT || \ + 0) + +/* groups of curl_easy_getinfo infos that take the same type of argument */ + +/* evaluates to true if info expects a pointer to char * argument */ +#define _curl_is_string_info(info) \ + (CURLINFO_STRING < (info) && (info) < CURLINFO_LONG) + +/* evaluates to true if info expects a pointer to long argument */ +#define _curl_is_long_info(info) \ + (CURLINFO_LONG < (info) && (info) < CURLINFO_DOUBLE) + +/* evaluates to true if info expects a pointer to double argument */ +#define _curl_is_double_info(info) \ + (CURLINFO_DOUBLE < (info) && (info) < CURLINFO_SLIST) + +/* true if info expects a pointer to struct curl_slist * argument */ +#define _curl_is_slist_info(info) \ + (CURLINFO_SLIST < (info)) + + +/* typecheck helpers -- check whether given expression has requested type*/ + +/* For pointers, you can use the _curl_is_ptr/_curl_is_arr macros, + * otherwise define a new macro. Search for __builtin_types_compatible_p + * in the GCC manual. + * NOTE: these macros MUST NOT EVALUATE their arguments! The argument is + * the actual expression passed to the curl_easy_setopt macro. This + * means that you can only apply the sizeof and __typeof__ operators, no + * == or whatsoever. + */ + +/* XXX: should evaluate to true iff expr is a pointer */ +#define _curl_is_any_ptr(expr) \ + (sizeof(expr) == sizeof(void*)) + +/* evaluates to true if expr is NULL */ +/* XXX: must not evaluate expr, so this check is not accurate */ +#define _curl_is_NULL(expr) \ + (__builtin_types_compatible_p(__typeof__(expr), __typeof__(NULL))) + +/* evaluates to true if expr is type*, const type* or NULL */ +#define _curl_is_ptr(expr, type) \ + (_curl_is_NULL(expr) || \ + __builtin_types_compatible_p(__typeof__(expr), type *) || \ + __builtin_types_compatible_p(__typeof__(expr), const type *)) + +/* evaluates to true if expr is one of type[], type*, NULL or const type* */ +#define _curl_is_arr(expr, type) \ + (_curl_is_ptr((expr), type) || \ + __builtin_types_compatible_p(__typeof__(expr), type [])) + +/* evaluates to true if expr is a string */ +#define _curl_is_string(expr) \ + (_curl_is_arr((expr), char) || \ + _curl_is_arr((expr), signed char) || \ + _curl_is_arr((expr), unsigned char)) + +/* evaluates to true if expr is a long (no matter the signedness) + * XXX: for now, int is also accepted (and therefore short and char, which + * are promoted to int when passed to a variadic function) */ +#define _curl_is_long(expr) \ + (__builtin_types_compatible_p(__typeof__(expr), long) || \ + __builtin_types_compatible_p(__typeof__(expr), signed long) || \ + __builtin_types_compatible_p(__typeof__(expr), unsigned long) || \ + __builtin_types_compatible_p(__typeof__(expr), int) || \ + __builtin_types_compatible_p(__typeof__(expr), signed int) || \ + __builtin_types_compatible_p(__typeof__(expr), unsigned int) || \ + __builtin_types_compatible_p(__typeof__(expr), short) || \ + __builtin_types_compatible_p(__typeof__(expr), signed short) || \ + __builtin_types_compatible_p(__typeof__(expr), unsigned short) || \ + __builtin_types_compatible_p(__typeof__(expr), char) || \ + __builtin_types_compatible_p(__typeof__(expr), signed char) || \ + __builtin_types_compatible_p(__typeof__(expr), unsigned char)) + +/* evaluates to true if expr is of type curl_off_t */ +#define _curl_is_off_t(expr) \ + (__builtin_types_compatible_p(__typeof__(expr), curl_off_t)) + +/* evaluates to true if expr is abuffer suitable for CURLOPT_ERRORBUFFER */ +/* XXX: also check size of an char[] array? */ +#define _curl_is_error_buffer(expr) \ + (_curl_is_NULL(expr) || \ + __builtin_types_compatible_p(__typeof__(expr), char *) || \ + __builtin_types_compatible_p(__typeof__(expr), char[])) + +/* evaluates to true if expr is of type (const) void* or (const) FILE* */ +#if 0 +#define _curl_is_cb_data(expr) \ + (_curl_is_ptr((expr), void) || \ + _curl_is_ptr((expr), FILE)) +#else /* be less strict */ +#define _curl_is_cb_data(expr) \ + _curl_is_any_ptr(expr) +#endif + +/* evaluates to true if expr is of type FILE* */ +#define _curl_is_FILE(expr) \ + (__builtin_types_compatible_p(__typeof__(expr), FILE *)) + +/* evaluates to true if expr can be passed as POST data (void* or char*) */ +#define _curl_is_postfields(expr) \ + (_curl_is_ptr((expr), void) || \ + _curl_is_arr((expr), char)) + +/* FIXME: the whole callback checking is messy... + * The idea is to tolerate char vs. void and const vs. not const + * pointers in arguments at least + */ +/* helper: __builtin_types_compatible_p distinguishes between functions and + * function pointers, hide it */ +#define _curl_callback_compatible(func, type) \ + (__builtin_types_compatible_p(__typeof__(func), type) || \ + __builtin_types_compatible_p(__typeof__(func), type*)) + +/* evaluates to true if expr is of type curl_read_callback or "similar" */ +#define _curl_is_read_cb(expr) \ + (_curl_is_NULL(expr) || \ + __builtin_types_compatible_p(__typeof__(expr), __typeof__(fread)) || \ + __builtin_types_compatible_p(__typeof__(expr), curl_read_callback) || \ + _curl_callback_compatible((expr), _curl_read_callback1) || \ + _curl_callback_compatible((expr), _curl_read_callback2) || \ + _curl_callback_compatible((expr), _curl_read_callback3) || \ + _curl_callback_compatible((expr), _curl_read_callback4) || \ + _curl_callback_compatible((expr), _curl_read_callback5) || \ + _curl_callback_compatible((expr), _curl_read_callback6)) +typedef size_t (_curl_read_callback1)(char *, size_t, size_t, void*); +typedef size_t (_curl_read_callback2)(char *, size_t, size_t, const void*); +typedef size_t (_curl_read_callback3)(char *, size_t, size_t, FILE*); +typedef size_t (_curl_read_callback4)(void *, size_t, size_t, void*); +typedef size_t (_curl_read_callback5)(void *, size_t, size_t, const void*); +typedef size_t (_curl_read_callback6)(void *, size_t, size_t, FILE*); + +/* evaluates to true if expr is of type curl_write_callback or "similar" */ +#define _curl_is_write_cb(expr) \ + (_curl_is_read_cb(expr) || \ + __builtin_types_compatible_p(__typeof__(expr), __typeof__(fwrite)) || \ + __builtin_types_compatible_p(__typeof__(expr), curl_write_callback) || \ + _curl_callback_compatible((expr), _curl_write_callback1) || \ + _curl_callback_compatible((expr), _curl_write_callback2) || \ + _curl_callback_compatible((expr), _curl_write_callback3) || \ + _curl_callback_compatible((expr), _curl_write_callback4) || \ + _curl_callback_compatible((expr), _curl_write_callback5) || \ + _curl_callback_compatible((expr), _curl_write_callback6)) +typedef size_t (_curl_write_callback1)(const char *, size_t, size_t, void*); +typedef size_t (_curl_write_callback2)(const char *, size_t, size_t, + const void*); +typedef size_t (_curl_write_callback3)(const char *, size_t, size_t, FILE*); +typedef size_t (_curl_write_callback4)(const void *, size_t, size_t, void*); +typedef size_t (_curl_write_callback5)(const void *, size_t, size_t, + const void*); +typedef size_t (_curl_write_callback6)(const void *, size_t, size_t, FILE*); + +/* evaluates to true if expr is of type curl_ioctl_callback or "similar" */ +#define _curl_is_ioctl_cb(expr) \ + (_curl_is_NULL(expr) || \ + __builtin_types_compatible_p(__typeof__(expr), curl_ioctl_callback) || \ + _curl_callback_compatible((expr), _curl_ioctl_callback1) || \ + _curl_callback_compatible((expr), _curl_ioctl_callback2) || \ + _curl_callback_compatible((expr), _curl_ioctl_callback3) || \ + _curl_callback_compatible((expr), _curl_ioctl_callback4)) +typedef curlioerr (_curl_ioctl_callback1)(CURL *, int, void*); +typedef curlioerr (_curl_ioctl_callback2)(CURL *, int, const void*); +typedef curlioerr (_curl_ioctl_callback3)(CURL *, curliocmd, void*); +typedef curlioerr (_curl_ioctl_callback4)(CURL *, curliocmd, const void*); + +/* evaluates to true if expr is of type curl_sockopt_callback or "similar" */ +#define _curl_is_sockopt_cb(expr) \ + (_curl_is_NULL(expr) || \ + __builtin_types_compatible_p(__typeof__(expr), curl_sockopt_callback) || \ + _curl_callback_compatible((expr), _curl_sockopt_callback1) || \ + _curl_callback_compatible((expr), _curl_sockopt_callback2)) +typedef int (_curl_sockopt_callback1)(void *, curl_socket_t, curlsocktype); +typedef int (_curl_sockopt_callback2)(const void *, curl_socket_t, + curlsocktype); + +/* evaluates to true if expr is of type curl_opensocket_callback or + "similar" */ +#define _curl_is_opensocket_cb(expr) \ + (_curl_is_NULL(expr) || \ + __builtin_types_compatible_p(__typeof__(expr), curl_opensocket_callback) ||\ + _curl_callback_compatible((expr), _curl_opensocket_callback1) || \ + _curl_callback_compatible((expr), _curl_opensocket_callback2) || \ + _curl_callback_compatible((expr), _curl_opensocket_callback3) || \ + _curl_callback_compatible((expr), _curl_opensocket_callback4)) +typedef curl_socket_t (_curl_opensocket_callback1) + (void *, curlsocktype, struct curl_sockaddr *); +typedef curl_socket_t (_curl_opensocket_callback2) + (void *, curlsocktype, const struct curl_sockaddr *); +typedef curl_socket_t (_curl_opensocket_callback3) + (const void *, curlsocktype, struct curl_sockaddr *); +typedef curl_socket_t (_curl_opensocket_callback4) + (const void *, curlsocktype, const struct curl_sockaddr *); + +/* evaluates to true if expr is of type curl_progress_callback or "similar" */ +#define _curl_is_progress_cb(expr) \ + (_curl_is_NULL(expr) || \ + __builtin_types_compatible_p(__typeof__(expr), curl_progress_callback) || \ + _curl_callback_compatible((expr), _curl_progress_callback1) || \ + _curl_callback_compatible((expr), _curl_progress_callback2)) +typedef int (_curl_progress_callback1)(void *, + double, double, double, double); +typedef int (_curl_progress_callback2)(const void *, + double, double, double, double); + +/* evaluates to true if expr is of type curl_debug_callback or "similar" */ +#define _curl_is_debug_cb(expr) \ + (_curl_is_NULL(expr) || \ + __builtin_types_compatible_p(__typeof__(expr), curl_debug_callback) || \ + _curl_callback_compatible((expr), _curl_debug_callback1) || \ + _curl_callback_compatible((expr), _curl_debug_callback2) || \ + _curl_callback_compatible((expr), _curl_debug_callback3) || \ + _curl_callback_compatible((expr), _curl_debug_callback4) || \ + _curl_callback_compatible((expr), _curl_debug_callback5) || \ + _curl_callback_compatible((expr), _curl_debug_callback6) || \ + _curl_callback_compatible((expr), _curl_debug_callback7) || \ + _curl_callback_compatible((expr), _curl_debug_callback8)) +typedef int (_curl_debug_callback1) (CURL *, + curl_infotype, char *, size_t, void *); +typedef int (_curl_debug_callback2) (CURL *, + curl_infotype, char *, size_t, const void *); +typedef int (_curl_debug_callback3) (CURL *, + curl_infotype, const char *, size_t, void *); +typedef int (_curl_debug_callback4) (CURL *, + curl_infotype, const char *, size_t, const void *); +typedef int (_curl_debug_callback5) (CURL *, + curl_infotype, unsigned char *, size_t, void *); +typedef int (_curl_debug_callback6) (CURL *, + curl_infotype, unsigned char *, size_t, const void *); +typedef int (_curl_debug_callback7) (CURL *, + curl_infotype, const unsigned char *, size_t, void *); +typedef int (_curl_debug_callback8) (CURL *, + curl_infotype, const unsigned char *, size_t, const void *); + +/* evaluates to true if expr is of type curl_ssl_ctx_callback or "similar" */ +/* this is getting even messier... */ +#define _curl_is_ssl_ctx_cb(expr) \ + (_curl_is_NULL(expr) || \ + __builtin_types_compatible_p(__typeof__(expr), curl_ssl_ctx_callback) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback1) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback2) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback3) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback4) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback5) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback6) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback7) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback8)) +typedef CURLcode (_curl_ssl_ctx_callback1)(CURL *, void *, void *); +typedef CURLcode (_curl_ssl_ctx_callback2)(CURL *, void *, const void *); +typedef CURLcode (_curl_ssl_ctx_callback3)(CURL *, const void *, void *); +typedef CURLcode (_curl_ssl_ctx_callback4)(CURL *, const void *, const void *); +#ifdef HEADER_SSL_H +/* hack: if we included OpenSSL's ssl.h, we know about SSL_CTX + * this will of course break if we're included before OpenSSL headers... + */ +typedef CURLcode (_curl_ssl_ctx_callback5)(CURL *, SSL_CTX, void *); +typedef CURLcode (_curl_ssl_ctx_callback6)(CURL *, SSL_CTX, const void *); +typedef CURLcode (_curl_ssl_ctx_callback7)(CURL *, const SSL_CTX, void *); +typedef CURLcode (_curl_ssl_ctx_callback8)(CURL *, const SSL_CTX, + const void *); +#else +typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback5; +typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback6; +typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback7; +typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback8; +#endif + +/* evaluates to true if expr is of type curl_conv_callback or "similar" */ +#define _curl_is_conv_cb(expr) \ + (_curl_is_NULL(expr) || \ + __builtin_types_compatible_p(__typeof__(expr), curl_conv_callback) || \ + _curl_callback_compatible((expr), _curl_conv_callback1) || \ + _curl_callback_compatible((expr), _curl_conv_callback2) || \ + _curl_callback_compatible((expr), _curl_conv_callback3) || \ + _curl_callback_compatible((expr), _curl_conv_callback4)) +typedef CURLcode (*_curl_conv_callback1)(char *, size_t length); +typedef CURLcode (*_curl_conv_callback2)(const char *, size_t length); +typedef CURLcode (*_curl_conv_callback3)(void *, size_t length); +typedef CURLcode (*_curl_conv_callback4)(const void *, size_t length); + +/* evaluates to true if expr is of type curl_seek_callback or "similar" */ +#define _curl_is_seek_cb(expr) \ + (_curl_is_NULL(expr) || \ + __builtin_types_compatible_p(__typeof__(expr), curl_seek_callback) || \ + _curl_callback_compatible((expr), _curl_seek_callback1) || \ + _curl_callback_compatible((expr), _curl_seek_callback2)) +typedef CURLcode (*_curl_seek_callback1)(void *, curl_off_t, int); +typedef CURLcode (*_curl_seek_callback2)(const void *, curl_off_t, int); + + +#endif /* __CURL_TYPECHECK_GCC_H */ diff --git a/src/base.cpp b/src/base.cpp new file mode 100644 index 0000000..2fea770 --- /dev/null +++ b/src/base.cpp @@ -0,0 +1,988 @@ +/* +* base.cpp +* wxCURL +* +* Created by Casey O'Donnell on Tue Jun 29 2004. +* Copyright (c) 2004 Casey O'Donnell. All rights reserved. +* +* +* Licence: wxWidgets Licence +*/ + +////////////////////////////////////////////////////////////////////// +// Headers +////////////////////////////////////////////////////////////////////// + +#include "wx/wxprec.h" + +#ifndef WX_PRECOMP + #include "wx/wx.h" +#endif + +#ifdef __WXMSW__ + #include // useful to catch memory leaks when compiling under MSVC +#endif + +#include +#include + +#include +#include + + +////////////////////////////////////////////////////////////////////// +// Constants +////////////////////////////////////////////////////////////////////// + +////////////////////////////////////////////////////////////////////// +// C Functions for LibCURL +////////////////////////////////////////////////////////////////////// + +extern "C" +{ + int wxcurl_evt_progress_func(void* ptr, double rDlTotal, double rDlNow, + double rUlTotal, double rUlNow) + { + wxCurlBase *curl = wx_static_cast(wxCurlBase*, ptr); + int res = 0; + if(curl) + { + if (rUlTotal == 0 || rUlNow == 0) + { + /* should be a download event */ + wxCurlDownloadEvent evt(curl->GetId(), curl, rDlTotal, rDlNow, curl->GetURL()); + wxPostEvent(curl->GetEvtHandler(), evt); + } + + if (rDlTotal == 0 || rDlNow == 0) + { + /* should be an upload event */ + wxCurlDownloadEvent evt(curl->GetId(), curl, rUlTotal, rUlNow, curl->GetURL()); + wxPostEvent(curl->GetEvtHandler(), evt); + } + + if ( curl->GetAbort() ) + res = 1; // This will cause curl_easy_perform() to return CURLE_WRITE_ERROR immediately + } + return res; + } + + int wxcurl_verbose_stream_write(CURL * crlptr, curl_infotype info, + char * cStrMessage, size_t msgSize, void * buffer) + { + wxString szMessage((const char*)cStrMessage, wxConvLibc, msgSize); + wxStringOutputStream* pBuf = (wxStringOutputStream*)buffer; + wxString szVerboseMessage; + + switch (info) + { + case CURLINFO_TEXT: + szVerboseMessage = wxString(wxS("Text: ")) + szMessage + wxS("\n"); + break; + case CURLINFO_HEADER_IN: + szVerboseMessage = wxString(wxS("Header in: ")) + szMessage + wxS("\n"); + break; + case CURLINFO_HEADER_OUT: + szVerboseMessage = wxString(wxS("Header out: ")) + szMessage + wxS("\n"); + break; + case CURLINFO_DATA_IN: + szVerboseMessage = wxString(wxS("Data in: ")) + szMessage + wxS("\n"); + break; + case CURLINFO_DATA_OUT: + szVerboseMessage = wxString(wxS("Data out: ")) + szMessage + wxS("\n"); + break; + case CURLINFO_END: + szVerboseMessage = wxString(wxS("End: ")) + szMessage + wxS("\n"); + break; + case CURLINFO_SSL_DATA_IN: + szVerboseMessage = wxString(wxS("SSL Data in: ")) + szMessage + wxS("\n"); + break; + case CURLINFO_SSL_DATA_OUT: + szVerboseMessage = wxString(wxS("SSL Data out: ")) + szMessage + wxS("\n"); + break; + } + + // here wxChar usage is correct as szVerboseMessage string is used: + pBuf->Write((const wxChar*)szVerboseMessage, szVerboseMessage.Len() * sizeof(wxChar)); + + return 0; + } + + size_t wxcurl_header_func(void *ptr, size_t size, size_t nmemb, void *stream) + { + size_t iRealSize = size * nmemb; + wxCharBuffer* pStr = (wxCharBuffer*) stream; + + if(pStr) + { + wxString str = wxCURL_BUF2STRING(*pStr) + wxString((const char*)ptr, wxConvLibc); + *pStr = wxCURL_STRING2BUF(str); + } + + return iRealSize; + } + + /* writes to a string */ + size_t wxcurl_string_write(void* ptr, size_t size, size_t nmemb, void* pcharbuf) + { + size_t iRealSize = size * nmemb; + wxCharBuffer* pStr = (wxCharBuffer*) pcharbuf; + + if(pStr) + { + wxString str = wxCURL_BUF2STRING(*pStr) + wxString((const char*)ptr, wxConvLibc); + *pStr = wxCURL_STRING2BUF(str); + } + + return iRealSize; + } + + /* writes to a stream */ + size_t wxcurl_stream_write(void* ptr, size_t size, size_t nmemb, void* stream) + { + size_t iRealSize = size * nmemb; + + wxOutputStream* pBuf = (wxOutputStream*)stream; + + if(pBuf) + { + pBuf->Write(ptr, iRealSize); + + return pBuf->LastWrite(); + } + + return 0; + } + + /* reads from a string */ + size_t wxcurl_string_read(void* ptr, size_t size, size_t nmemb, void* pcharbuf) + { + size_t iRealSize = size * nmemb; + size_t iRetVal = 0; + + wxCharBuffer* pStr = (wxCharBuffer*) pcharbuf; + size_t len = 0; + + if(pStr) + { + len = strlen(*pStr); + if(len >= iRealSize) + { + strncpy((char*)ptr, (const char*)(*pStr), iRealSize); + iRetVal = iRealSize; + } + else + { + strncpy((char*)ptr, (const char*)(*pStr), len); + iRetVal = len; + } + + wxString remaining = wxCURL_BUF2STRING(pStr).Right(len - iRetVal); + *pStr = wxCURL_STRING2BUF(remaining); + } + + return iRetVal; + } + + /* reads from a stream */ + size_t wxcurl_stream_read(void* ptr, size_t size, size_t nmemb, void* stream) + { + size_t iRealSize = size * nmemb; + + wxInputStream* pBuf = (wxInputStream*)stream; + + if(pBuf) + { + pBuf->Read(ptr, iRealSize); + + return pBuf->LastRead(); + } + + return 0; + } +} + + +// base.cpp: implementation of the wxCurlProgressBaseEvent class. +// +////////////////////////////////////////////////////////////////////// + +wxTimeSpan wxCurlProgressBaseEvent::GetElapsedTime() const +{ + // NOTE: we cannot trust libCURL's CURLINFO_TOTAL_TIME as the transfer may have + // been paused in one of libCURL's callbacks (and thus libCURL ignores it + // and won't remove the paused span from the return value). + wxTimeSpan elapsed = m_dt - m_pCURL->GetBeginTransferSpan(); + + // the elapsed time offset takes in count eventually-existing previous time spans + // where the transfer took place ( + return elapsed + m_pCURL->GetElapsedTimeOffset(); +} + +wxTimeSpan wxCurlProgressBaseEvent::GetEstimatedTime() const +{ + double nBytesPerSec = GetSpeed(); + if (nBytesPerSec == 0 || wxIsNaN(nBytesPerSec)) + return wxTimeSpan(0); // avoid division by zero + + // compute remaining seconds; here we assume that the current + // download speed will be constant also in future + double secs = GetTotalBytes() / nBytesPerSec; + + return wxTimeSpan(int(secs/3600.0), // hours + int(secs/60) % 60, // minutes + int(secs) % 60, // seconds + 0); // milliseconds +} + +wxTimeSpan wxCurlProgressBaseEvent::GetEstimatedRemainingTime() const +{ + wxTimeSpan est = GetEstimatedTime(), + elapsed = GetElapsedTime(); + + if (est.IsLongerThan(elapsed)) + return est - elapsed; + return wxTimeSpan(0); // probably est==0 because GetTotalBytes()==0 +} + +std::string wxCurlProgressBaseEvent::GetHumanReadableSpeed(const std::string &invalid, int precision) const +{ + double speed = GetSpeed(); + if (speed == 0 || wxIsNaN(speed)) + return invalid; + + wxULongLong ull((wxULongLong_t)speed); + wxString s(invalid.c_str(), wxConvUTF8); + return std::string( wxFileName::GetHumanReadableSize(ull, s, precision).mb_str() ) + "/s"; +} + + +// base.cpp: implementation of the wxCurlDownloadEvent class. +// +////////////////////////////////////////////////////////////////////// + +////////////////////////////////////////////////////////////////////// +// Construction/Destruction +////////////////////////////////////////////////////////////////////// + +DEFINE_EVENT_TYPE(wxCURL_DOWNLOAD_EVENT); + +IMPLEMENT_DYNAMIC_CLASS(wxCurlDownloadEvent, wxEvent); + +wxCurlDownloadEvent::wxCurlDownloadEvent() +: wxCurlProgressBaseEvent(-1, wxCURL_DOWNLOAD_EVENT), + m_rDownloadTotal(0.0), m_rDownloadNow(0.0) +{ +} + +wxCurlDownloadEvent::wxCurlDownloadEvent(int id, wxCurlBase *originator, + const double& rDownloadTotal, const double& rDownloadNow, + const std::string& szURL /*= wxEmptyString*/) +: wxCurlProgressBaseEvent(id, wxCURL_DOWNLOAD_EVENT, originator, szURL), +m_rDownloadTotal(rDownloadTotal), m_rDownloadNow(rDownloadNow) +{ +} + +wxCurlDownloadEvent::wxCurlDownloadEvent(const wxCurlDownloadEvent& event) +: wxCurlProgressBaseEvent(event) +{ + m_rDownloadNow = event.m_rDownloadNow; + m_rDownloadTotal = event.m_rDownloadTotal; +} + + + +// base.cpp: implementation of the wxCurlUploadEvent class. +// +////////////////////////////////////////////////////////////////////// + +////////////////////////////////////////////////////////////////////// +// Construction/Destruction +////////////////////////////////////////////////////////////////////// + +DEFINE_EVENT_TYPE(wxCURL_UPLOAD_EVENT); + +IMPLEMENT_DYNAMIC_CLASS(wxCurlUploadEvent, wxEvent); + +wxCurlUploadEvent::wxCurlUploadEvent() +: wxCurlProgressBaseEvent(-1, wxCURL_UPLOAD_EVENT), + m_rUploadTotal(0.0), m_rUploadNow(0.0) +{ +} + +wxCurlUploadEvent::wxCurlUploadEvent(int id, wxCurlBase *originator, + const double& rUploadTotal, const double& rUploadNow, + const std::string& szURL /*= wxEmptyString*/) +: wxCurlProgressBaseEvent(id, wxCURL_UPLOAD_EVENT, originator, szURL), +m_rUploadTotal(rUploadTotal), m_rUploadNow(rUploadNow) +{ +} + +wxCurlUploadEvent::wxCurlUploadEvent(const wxCurlUploadEvent& event) +: wxCurlProgressBaseEvent(event) +{ + m_rUploadNow = event.m_rUploadNow; + m_rUploadTotal = event.m_rUploadTotal; +} + + + +// wxCurlBase.cpp: implementation of the wxCurlBeginPerformEvent class. +// +////////////////////////////////////////////////////////////////////// + +////////////////////////////////////////////////////////////////////// +// Construction/Destruction +////////////////////////////////////////////////////////////////////// + +DEFINE_EVENT_TYPE(wxCURL_BEGIN_PERFORM_EVENT); + +IMPLEMENT_DYNAMIC_CLASS(wxCurlBeginPerformEvent, wxEvent); + +wxCurlBeginPerformEvent::wxCurlBeginPerformEvent() +: wxEvent(-1, wxCURL_BEGIN_PERFORM_EVENT) +{ +} + +wxCurlBeginPerformEvent::wxCurlBeginPerformEvent(int id, const std::string& szURL) +: wxEvent(id, wxCURL_BEGIN_PERFORM_EVENT), +m_szURL(szURL) +{ +} + +wxCurlBeginPerformEvent::wxCurlBeginPerformEvent(const wxCurlBeginPerformEvent& event) +: wxEvent(event) +{ + m_szURL = event.m_szURL; +} + +// wxCurlBase.cpp: implementation of the wxCurlEndPerformEvent class. +// +////////////////////////////////////////////////////////////////////// + +////////////////////////////////////////////////////////////////////// +// Construction/Destruction +////////////////////////////////////////////////////////////////////// + +DEFINE_EVENT_TYPE(wxCURL_END_PERFORM_EVENT); + +IMPLEMENT_DYNAMIC_CLASS(wxCurlEndPerformEvent, wxEvent); + +wxCurlEndPerformEvent::wxCurlEndPerformEvent() +: wxEvent(-1, wxCURL_END_PERFORM_EVENT), +m_iResponseCode(0) +{ +} + +wxCurlEndPerformEvent::wxCurlEndPerformEvent(int id, const std::string& szURL, const long& iResponseCode) +: wxEvent(id, wxCURL_END_PERFORM_EVENT), +m_szURL(szURL), +m_iResponseCode(iResponseCode) +{ +} + +wxCurlEndPerformEvent::wxCurlEndPerformEvent(const wxCurlEndPerformEvent& event) +: wxEvent(event) +{ + m_szURL = event.m_szURL; + m_iResponseCode = event.m_iResponseCode; +} + +// wxCurlBase.cpp: implementation of the wxCurlBase class. +// +////////////////////////////////////////////////////////////////////// + +////////////////////////////////////////////////////////////////////// +// Construction/Destruction +////////////////////////////////////////////////////////////////////// + +wxCurlBase::wxCurlBase(const wxString& szURL /*= wxEmptyString*/, + const wxString& szUserName /*= wxEmptyString*/, + const wxString& szPassword /*= wxEmptyString*/, + wxEvtHandler* pEvtHandler /*= NULL*/, + int id /*= wxID_ANY*/, + long flags /*=wxCURL_DEFAULT_FLAGS*/) + : m_pCURL(NULL), +m_bAbortHungTransfer(false), +m_szBaseURL(wxCURL_STRING2BUF(szURL)), +m_szCurrFullURL(wxCURL_STRING2BUF(szURL)), +m_szUsername(wxCURL_STRING2BUF(szUserName)), +m_szPassword(wxCURL_STRING2BUF(szPassword)), +m_iHostPort(-1), +m_iResponseCode(-1), +m_pHeaders(NULL), +m_bUseProxy(false), +m_iProxyPort(-1), +m_bVerbose(false), +m_pEvtHandler(pEvtHandler), +m_nId(id), +m_nFlags(flags) +{ + m_szDetailedErrorBuffer[0] = '\0'; + m_progressCallback = wxcurl_evt_progress_func; + m_progressData = this; + + InitHandle(); +} + +wxCurlBase::~wxCurlBase() +{ + CleanupHandle(); + ResetHeaders(); +} + +////////////////////////////////////////////////////////////////////// +// LibCURL Abstraction Methods +////////////////////////////////////////////////////////////////////// + +typedef int (*func_T)(void); +bool wxCurlBase::SetOpt(CURLoption option, ...) +{ + va_list arg; + + func_T param_func = (func_T)0; + long param_long = 0; + void *param_obj = NULL; + curl_off_t param_offset = 0; + + va_start(arg, option); + + CURLcode res = CURLE_OK; + + // This code stolen from easy.c from LibCURL - It is needed to ensure that + // types are maintained. + if(option < CURLOPTTYPE_OBJECTPOINT) { + /* This is a LONG type */ + param_long = va_arg(arg, long); + res = curl_easy_setopt(m_pCURL, option, param_long); + } + else if(option < CURLOPTTYPE_FUNCTIONPOINT) { + /* This is a object pointer type */ + param_obj = va_arg(arg, void *); + res = curl_easy_setopt(m_pCURL, option, param_obj); + } + else if(option < CURLOPTTYPE_OFF_T) { + /* This is a function pointer type */ + param_func = va_arg(arg, func_T ); + res = curl_easy_setopt(m_pCURL, option, param_func); + } else { + /* This is a curl_off_t type */ + param_offset = va_arg(arg, curl_off_t); + res = curl_easy_setopt(m_pCURL, option, param_offset); + } + + va_end(arg); + + DumpErrorIfNeed(res); + return (res == CURLE_OK); +} + +bool wxCurlBase::SetStringOpt(CURLoption option, const wxCharBuffer &str) +{ + // VERY IMPORTANT: the caller must ensure given wxCharBuffer is valid + // for all the time it's owned by libCURL + + /* FIXME: converting to plain ASCII is not always the Best Thing. E.g. + for CURLOPT_USERPWD, we'd need to consult RFC2616 (HTTP) or + another RFC depending on the authentication system in use, etc etc + For now we convert to pure ASCII which in 99% of the cases will + Just Do the Work + */ + + return SetOpt(option, (const char*)str); +} + +bool wxCurlBase::GetInfo(CURLINFO info, ...) const +{ + va_list arg; + void* pParam; + + va_start(arg, info); + pParam = va_arg(arg, void*); + + CURLcode res = CURLE_OK; + + res = curl_easy_getinfo(m_pCURL, info, pParam); + + DumpErrorIfNeed(res); + va_end(arg); + return (res == CURLE_OK); +} + +bool wxCurlBase::Perform() +{ + CURLcode res = CURLE_OK; + + if((m_nFlags & wxCURL_SEND_BEGINEND_EVENTS) && m_pEvtHandler) + { + wxString s = wxCURL_BUF2STRING(m_szCurrFullURL); + wxCurlBeginPerformEvent bgnEvent(m_nId, std::string(s.mb_str())); + wxPostEvent(m_pEvtHandler, bgnEvent); + } + + // reset time-related vars: + m_tsElapsedOffset = 0; + m_dtBeginTransferSpan = wxDateTime::Now(); + + // perform the operation: + res = curl_easy_perform(m_pCURL); + + // get the response code of the server + GetInfo(CURLINFO_RESPONSE_CODE, &m_iResponseCode); + + if((m_nFlags & wxCURL_SEND_BEGINEND_EVENTS) && m_pEvtHandler) + { + wxString s = wxCURL_BUF2STRING(m_szCurrFullURL); + wxCurlEndPerformEvent endEvent(m_nId, std::string(s.mb_str()), m_iResponseCode); + wxPostEvent(m_pEvtHandler, endEvent); + } + + DumpErrorIfNeed(res); + return (res == CURLE_OK); +} + +bool wxCurlBase::InitHandle() +{ + if(m_pCURL) + return false; + + m_pCURL = curl_easy_init(); + + return (m_pCURL != NULL); +} + +bool wxCurlBase::ReInitHandle() +{ + CleanupHandle(); + return InitHandle(); +} + +bool wxCurlBase::CleanupHandle() +{ + if(m_pCURL) + { + curl_easy_cleanup(m_pCURL); + m_pCURL = NULL; + } + + return true; +} + +bool wxCurlBase::ResetHandle() +{ + curl_easy_reset(m_pCURL); + + return true; +} + +void wxCurlBase::DumpErrorIfNeed(CURLcode error) const +{ + // save the error description: + wx_const_cast(wxCurlBase*, this)->m_szLastError = curl_easy_strerror(error); + + if (m_bVerbose && error != CURLE_OK) + { + // dump the error if needed: + wxLogDebug(wxS("[wxCURL] %hs"), (const char*)m_szLastError); + } +} + +////////////////////////////////////////////////////////////////////// +// Member Data Access Methods +////////////////////////////////////////////////////////////////////// + +bool wxCurlBase::SetEvtHandler(wxEvtHandler* pEvtHandler, int id) +{ + m_pEvtHandler = pEvtHandler; + m_nId = id; + + return true; +} + +wxEvtHandler* wxCurlBase::GetEvtHandler() const +{ + return m_pEvtHandler; +} + +int wxCurlBase::GetId() const +{ + return m_nId; +} + +void wxCurlBase::SetFlags(long flags) +{ + m_nFlags = flags; +} + +long wxCurlBase::GetFlags() const +{ + return m_nFlags; +} + +void wxCurlBase::SetBaseURL(const wxString& szBaseURL) +{ + m_szBaseURL = wxCURL_STRING2BUF(szBaseURL); +} + +std::string wxCurlBase::GetBaseURL() const +{ + wxString s = wxCURL_BUF2STRING(m_szBaseURL); + return std::string(s.mb_str()); +} + +void wxCurlBase::SetURL(const wxString& szRelativeURL) +{ + wxString str = wxCURL_BUF2STRING(m_szCurrFullURL) + szRelativeURL; + m_szCurrFullURL = wxCURL_STRING2BUF(str); +} + +std::string wxCurlBase::GetURL() const +{ + wxString s = wxCURL_BUF2STRING(m_szCurrFullURL); + return std::string(s.mb_str()); +} + +void wxCurlBase::SetPort(const long& iPort) +{ + m_iHostPort = iPort; +} + +long wxCurlBase::GetPort() const +{ + return m_iHostPort; +} + +void wxCurlBase::SetUsername(const wxString& szUsername) +{ + m_szUsername = wxCURL_STRING2BUF(szUsername); +} + +std::string wxCurlBase::GetUsername() const +{ + wxString s = wxCURL_BUF2STRING(m_szUsername); + return std::string(s.mb_str()); +} + +void wxCurlBase::SetPassword(const wxString& szPassword) +{ + m_szPassword = wxCURL_STRING2BUF(szPassword); +} + +std::string wxCurlBase::GetPassword() const +{ + wxString s = wxCURL_BUF2STRING(m_szPassword); + return std::string(s.mb_str()); +} + +std::string wxCurlBase::GetResponseHeader() const +{ + wxString s = wxCURL_BUF2STRING(m_szResponseHeader); + return std::string(s.mb_str()); +} + +std::string wxCurlBase::GetResponseBody() const +{ + wxString s = wxCURL_BUF2STRING(m_szResponseBody); + return std::string(s.mb_str()); +} + +long wxCurlBase::GetResponseCode() const +{ + return m_iResponseCode; +} + +std::string wxCurlBase::GetDetailedErrorString() const +{ + wxString s = wxString((const char*)m_szDetailedErrorBuffer, wxConvLibc); + return std::string(s.mb_str()); +} + +std::string wxCurlBase::GetErrorString() const +{ + wxString s = wxCURL_BUF2STRING(m_szLastError); + return std::string(s.mb_str()); +} + +void wxCurlBase::UseProxy(const bool& bUseProxy) +{ + m_bUseProxy = bUseProxy; +} + +bool wxCurlBase::UseProxy() const +{ + return m_bUseProxy; +} + +void wxCurlBase::SetProxyHost(const wxString& szProxyHost) +{ + m_szProxyHost = wxCURL_STRING2BUF(szProxyHost); +} + +std::string wxCurlBase::GetProxyHost() const +{ + wxString s = wxCURL_BUF2STRING(m_szProxyHost); + return std::string(s.mb_str()); +} + +void wxCurlBase::SetProxyUsername(const wxString& szProxyUsername) +{ + m_szProxyUsername = wxCURL_STRING2BUF(szProxyUsername); +} + +std::string wxCurlBase::GetProxyUsername() const +{ + wxString s = wxCURL_BUF2STRING(m_szProxyUsername); + return std::string(s.mb_str()); +} + +void wxCurlBase::SetProxyPassword(const wxString& szProxyPassword) +{ + m_szProxyPassword = wxCURL_STRING2BUF(szProxyPassword); +} + +std::string wxCurlBase::GetProxyPassword() const +{ + wxString s = wxCURL_BUF2STRING(m_szProxyPassword); + return std::string(s.mb_str()); +} + +void wxCurlBase::SetProxyPort(const long& iProxyPort) +{ + m_iProxyPort = iProxyPort; +} + +long wxCurlBase::GetProxyPort() const +{ + return m_iProxyPort; +} + +void wxCurlBase::SetVerbose(const bool& bVerbose) +{ + m_bVerbose = bVerbose; +} + +bool wxCurlBase::IsVerbose() const +{ + return m_bVerbose; +} + +bool wxCurlBase::GetVerboseStream(wxOutputStream& destStream) const +{ + if(m_bVerbose) + { + if(m_mosVerbose.IsOk()) + { + size_t sz = m_mosVerbose.GetSize(); + wxString buffer = m_mosVerbose.GetString(); + + destStream.Write(buffer.c_str(), sz); + return destStream.IsOk(); + } + } + + return false; +} + +bool wxCurlBase::GetVerboseString(wxString& szStream) const +{ + if(m_bVerbose) + { + szStream.Append(m_mosVerbose.GetString()); + return true; + } + + return false; +} + +void wxCurlBase::SetAbort(bool a) +{ + m_bAbortHungTransfer = a; +} + +bool wxCurlBase::GetAbort() const +{ + return m_bAbortHungTransfer; +} +////////////////////////////////////////////////////////////////////// +// Helper Methods +////////////////////////////////////////////////////////////////////// + +void wxCurlBase::SetCurlHandleToDefaults(const wxString& relativeURL) +{ + if (!relativeURL.empty()) + SetURL(relativeURL); // update the m_szCurrFullURL string + + if(m_pCURL && ResetHandle()) + { + ResetResponseVars(); + + SetStringOpt(CURLOPT_URL, m_szCurrFullURL); + + SetOpt(CURLOPT_HEADERFUNCTION, wxcurl_header_func); + SetOpt(CURLOPT_WRITEHEADER, &m_szResponseHeader); + SetOpt(CURLOPT_ERRORBUFFER, m_szDetailedErrorBuffer); + SetOpt(CURLOPT_USERAGENT, "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:35.0) Gecko/20100101 Firefox/35.0\r\n" \ + "Accept: application/xml,text/html,application/xhtml+xml;q=0.9,*/*;q=0.8\r\n" \ + "Connection: keep-alive"); //Pretend we are a normal browser + SetOpt(CURLOPT_FOLLOWLOCATION, 1L); +#ifdef __WXMSW__ + SetOpt(CURLOPT_CAINFO, "curl-ca-bundle.crt"); //Use our local certificate list on Windows + SetOpt(CURLOPT_SSL_VERIFYPEER, true); // FIXME: Temporary until we get certificates working +#endif + SetOpt(CURLOPT_ENCODING, "gzip,deflate"); //Save bandwidth by using compression + + if(m_pEvtHandler && (m_nFlags & wxCURL_SEND_PROGRESS_EVENTS)) + { + SetOpt(CURLOPT_NOPROGRESS, FALSE); + SetOpt(CURLOPT_PROGRESSFUNCTION, m_progressCallback); + SetOpt(CURLOPT_PROGRESSDATA, m_progressData); + } + + if(!wxCURL_BUF_ISEMPTY(m_szUsername) || !wxCURL_BUF_ISEMPTY(m_szPassword)) + { + wxString str = wxCURL_BUF2STRING(m_szUsername) + wxS(":") + wxCURL_BUF2STRING(m_szPassword); + + m_szUserPass = wxCURL_STRING2BUF(str); + SetStringOpt(CURLOPT_USERPWD, m_szUserPass); + + SetOpt(CURLOPT_HTTPAUTH, CURLAUTH_ANY); + } + + if(m_iHostPort != -1) + { + SetOpt(CURLOPT_PORT, m_iHostPort); + } + + if(m_bUseProxy && !wxCURL_BUF_ISEMPTY(m_szProxyHost)) + { + SetStringOpt(CURLOPT_PROXY, m_szProxyHost); + } + + if(m_bUseProxy && (m_iProxyPort != -1)) + { + SetOpt(CURLOPT_PROXYPORT, m_iProxyPort); + } + + if(m_bUseProxy && (!wxCURL_BUF_ISEMPTY(m_szProxyUsername) || !wxCURL_BUF_ISEMPTY(m_szProxyPassword))) + { + wxString str = wxCURL_BUF2STRING(m_szProxyUsername) + wxS(":") + wxCURL_BUF2STRING(m_szProxyPassword); + + m_szProxyUserPass = wxCURL_STRING2BUF(str); + SetStringOpt(CURLOPT_PROXYUSERPWD, m_szProxyUserPass); + } + + if(m_bVerbose) + { + SetOpt(CURLOPT_VERBOSE, TRUE); + SetOpt(CURLOPT_DEBUGFUNCTION, wxcurl_verbose_stream_write); + SetOpt(CURLOPT_DEBUGDATA, (void*) &m_mosVerbose); + } + } +} + +void wxCurlBase::SetHeaders() +{ + if(!m_arrHeaders.IsEmpty()) + { + if(m_pHeaders) + { + curl_slist_free_all(m_pHeaders); + + m_pHeaders = NULL; + + SetOpt(CURLOPT_HTTPHEADER, NULL); + } + + for(unsigned int i = 0; i < m_arrHeaders.Count(); i++) + { + m_pHeaders = curl_slist_append(m_pHeaders, wxCURL_STRING2BUF(m_arrHeaders[i])); + } + + SetOpt(CURLOPT_HTTPHEADER, m_pHeaders); + } +} + +void wxCurlBase::ResetHeaders() +{ + m_arrHeaders.Clear(); + + if(m_pHeaders) + { + curl_slist_free_all(m_pHeaders); + + m_pHeaders = NULL; + + SetOpt(CURLOPT_HTTPHEADER, NULL); + } +} + +void wxCurlBase::ResetResponseVars() +{ + m_szResponseHeader = ""; + m_szResponseBody = ""; + m_iResponseCode = -1; +} + +////////////////////////////////////////////////////////////////////// +// Static Initialization and Shutdown Methods +////////////////////////////////////////////////////////////////////// + +void wxCurlBase::Init() +{ + // Initialize LibCURL + curl_global_init(CURL_GLOBAL_ALL); +} + +void wxCurlBase::Shutdown() +{ + // Shutdown CurlLib + curl_global_cleanup(); +} + +////////////////////////////////////////////////////////////////////// +// Static Utility Methods +////////////////////////////////////////////////////////////////////// + +wxDateTime wxCurlBase::GetDateFromString(const wxString& szDate) +{ + time_t now = wxDateTime::Now().GetTicks(); + + return wxDateTime(curl_getdate((const char*)(szDate.c_str()), &now)); +} + +std::string wxCurlBase::GetURLEncodedString(const wxString& szData) +{ + char* pszRetVal = curl_escape((const char*)(szData.c_str()), szData.Len()); + + if(pszRetVal) + { + wxString szRetVal((const char*)pszRetVal, wxConvLibc); + + curl_free(pszRetVal); + + return std::string(szRetVal.mb_str()); + } + + return ""; +} + +std::string wxCurlBase::GetStringFromURLEncoded(const wxString& szData) +{ + char* pszRetVal = curl_unescape((const char*)(szData.c_str()), szData.Len()); + + if(pszRetVal) + { + wxString szRetVal = (wxChar*)pszRetVal; + + curl_free(pszRetVal); + + return std::string(szRetVal.mb_str()); + } + + return ""; +} + +std::string wxCurlBase::GetCURLVersion() +{ + return std::string(curl_version()); +} diff --git a/src/dav.cpp b/src/dav.cpp new file mode 100644 index 0000000..7900daa --- /dev/null +++ b/src/dav.cpp @@ -0,0 +1,287 @@ +/* + * dav.cpp + * wxCURL + * + * Created by Casey O'Donnell on Wed Jun 02 2004. + * Copyright (c) 2004 Casey O'Donnell. All rights reserved. + * + * + * Licence: wxWidgets Licence + */ + +// dav.cpp: implementation of the wxCurlDAV class. +// +////////////////////////////////////////////////////////////////////// + +////////////////////////////////////////////////////////////////////// +// Headers +////////////////////////////////////////////////////////////////////// + +#include "wx/wxprec.h" + +#ifndef WX_PRECOMP + #include "wx/wx.h" +#endif + +#ifdef __WXMSW__ + #include // useful to catch memory leaks when compiling under MSVC +#endif + +#include + +#include + +////////////////////////////////////////////////////////////////////// +// Constants +////////////////////////////////////////////////////////////////////// + +////////////////////////////////////////////////////////////////////// +// Construction/Destruction +////////////////////////////////////////////////////////////////////// + +wxCurlDAV::wxCurlDAV(const wxString& szURL /*= wxEmptyString*/, + const wxString& szUserName /*= wxEmptyString*/, + const wxString& szPassword /*= wxEmptyString*/, + wxEvtHandler* pEvtHandler /*= NULL*/, + long flags /*=wxCURL_DEFAULT_FLAGS*/) +: wxCurlHTTP(szURL, szUserName, szPassword, pEvtHandler, flags) +{ +} + +wxCurlDAV::~wxCurlDAV() +{ +} + +////////////////////////////////////////////////////////////////////// +// Member Data Access Methods +////////////////////////////////////////////////////////////////////// + +////////////////////////////////////////////////////////////////////// +// Action Methods +////////////////////////////////////////////////////////////////////// + +bool wxCurlDAV::Mkcol(const wxString& szRemoteCol /*= wxEmptyString*/) +{ + if(m_pCURL) + { + SetCurlHandleToDefaults(szRemoteCol); + + SetOpt(CURLOPT_CUSTOMREQUEST, "MKCOL"); + SetStringWriteFunction(m_szResponseBody); + + if(Perform()) + { + return ((m_iResponseCode > 199) && (m_iResponseCode < 300)); + } + } + + return false; +} + +bool wxCurlDAV::Propfind(const wxString& szRemoteLoc /*= wxEmptyString*/) +{ + return Propfind(NULL, 0, szRemoteLoc); +} + +bool wxCurlDAV::Propfind(const wxArrayString& arrTags, const wxString& szRemoteLoc /*= wxEmptyString*/) +{ + wxString szXml = ConstructPropfindXml(arrTags); + + return Propfind((const char*)(szXml.c_str()), szXml.Len(), szRemoteLoc); +} + +bool wxCurlDAV::Propfind(const char* buffer, size_t size, const wxString& szRemoteLoc /*= wxEmptyString*/) +{ + wxMemoryInputStream inStream(buffer, size); + + return Propfind(inStream, szRemoteLoc); +} + +bool wxCurlDAV::Propfind(wxInputStream& buffer, const wxString& szRemoteLoc /*= wxEmptyString*/) +{ + curl_off_t iSize = buffer.GetSize(); + + if(m_pCURL && buffer.IsOk()) + { + if(iSize == (~(ssize_t)0)) // wxCurlDAV does not know how to upload unknown length streams. + return false; + + SetCurlHandleToDefaults(szRemoteLoc); + + m_arrHeaders.Add(wxS("Depth: 1")); + m_arrHeaders.Add(wxS("Content-Type: text/xml; charset=\"utf-8\"")); + + SetHeaders(); + + if(iSize > 0) + { + SetOpt(CURLOPT_UPLOAD, TRUE); + SetOpt(CURLOPT_INFILESIZE_LARGE, iSize); + SetStreamReadFunction(buffer); + } + + SetOpt(CURLOPT_CUSTOMREQUEST, "PROPFIND"); + SetStringWriteFunction(m_szResponseBody); + + if(Perform()) + { + ResetHeaders(); + + return ((m_iResponseCode > 199) && (m_iResponseCode < 300)); + } + + ResetHeaders(); + } + + return false; +} + +bool wxCurlDAV::Proppatch(const char* buffer, size_t size, const wxString& szRemoteLoc /*= wxEmptyString*/) +{ + wxMemoryInputStream inStream(buffer, size); + + return Proppatch(inStream, szRemoteLoc); +} + +bool wxCurlDAV::Proppatch(wxInputStream& buffer, const wxString& szRemoteLoc /*= wxEmptyString*/) +{ + curl_off_t iSize = buffer.GetSize(); + + if(m_pCURL && buffer.IsOk()) + { + if(iSize == (~(ssize_t)0)) // wxCurlDAV does not know how to upload unknown length streams. + return false; + + SetCurlHandleToDefaults(szRemoteLoc); + + m_arrHeaders.Add(wxS("Content-Type: text/xml; charset=\"utf-8\"")); + + SetHeaders(); + + if(iSize > 0) + { + SetOpt(CURLOPT_UPLOAD, TRUE); + SetOpt(CURLOPT_INFILESIZE_LARGE, iSize); + SetStreamReadFunction(buffer); + } + + SetOpt(CURLOPT_CUSTOMREQUEST, "PROPPATCH"); + SetStringWriteFunction(m_szResponseBody); + + if(Perform()) + { + ResetHeaders(); + + return ((m_iResponseCode > 199) && (m_iResponseCode < 300)); + } + + ResetHeaders(); + } + + return false; +} + +bool wxCurlDAV::Copy(const wxString& szRemoteLocDest, const bool& bOverwrite /*= true*/, + const wxString& szRemoteLocSrc /*= wxEmptyString*/) +{ + if(m_pCURL) + { + SetCurlHandleToDefaults(szRemoteLocSrc); + + m_arrHeaders.Add(wxS("Destination: ") + szRemoteLocDest); + + if(!bOverwrite) + m_arrHeaders.Add(wxS("Overwrite: F")); + + SetHeaders(); + + SetOpt(CURLOPT_CUSTOMREQUEST, "COPY"); + SetStringWriteFunction(m_szResponseBody); + + if(Perform()) + { + ResetHeaders(); + + return ((m_iResponseCode > 199) && (m_iResponseCode < 300)); + } + + ResetHeaders(); + } + + return false; +} + +bool wxCurlDAV::Move(const wxString& szRemoteLocDest, const bool& bOverwrite /*= true*/, + const wxString& szRemoteLocSrc /*= wxEmptyString*/) +{ + if(m_pCURL) + { + SetCurlHandleToDefaults(szRemoteLocSrc); + + m_arrHeaders.Add(wxS("Destination: ") + szRemoteLocDest); + + if(!bOverwrite) + m_arrHeaders.Add(wxS("Overwrite: F")); + + SetHeaders(); + + SetOpt(CURLOPT_CUSTOMREQUEST, "MOVE"); + SetStringWriteFunction(m_szResponseBody); + + if(Perform()) + { + ResetHeaders(); + + return ((m_iResponseCode > 199) && (m_iResponseCode < 300)); + } + + ResetHeaders(); + } + + return false; +} + +bool wxCurlDAV::Lock(const wxString& WXUNUSED(szRemoteLoc /*=wxEmptyString*/)) +{ + return false; +} + +bool wxCurlDAV::Unlock(const wxString& WXUNUSED(szRemoteLoc /*=wxEmptyString*/)) +{ + return false; +} + +////////////////////////////////////////////////////////////////////// +// Helper Methods +////////////////////////////////////////////////////////////////////// + +wxString wxCurlDAV::ConstructPropfindXml(const wxArrayString& arrTags) +{ + wxString szXml; + + szXml += wxS("") wxS("\n"); + szXml += wxS("") wxS("\n"); + + if(arrTags.Count() > 0) + { + szXml += wxS("\t") wxS("") wxS("\n"); + + for(unsigned int i = 0; i < arrTags.Count(); i++) + { + szXml += wxS("\t\t") wxS("") wxS("\n"); + } + + szXml += wxS("\t") wxS("") wxS("\n"); + } + else + { + szXml += wxS("\t") wxS("") wxS("\n"); + } + + szXml += wxS("") wxS("\n"); + + return szXml; +} + diff --git a/src/davtool.cpp b/src/davtool.cpp new file mode 100644 index 0000000..998f3ee --- /dev/null +++ b/src/davtool.cpp @@ -0,0 +1,431 @@ +/* + * davtool.cpp + * wxCURL + * + * Created by Casey O'Donnell on Thu Jul 15 2004. + * Copyright (c) 2004 Casey O'Donnell. All rights reserved. + * + * + * Licence: wxWidgets Licence + */ + +// davtool.cpp +// +////////////////////////////////////////////////////////////////////// + +////////////////////////////////////////////////////////////////////// +// Headers +////////////////////////////////////////////////////////////////////// + +#include "wx/wxprec.h" + +#ifndef WX_PRECOMP + #include "wx/wx.h" +#endif + +#ifdef __WXMSW__ + #include // useful to catch memory leaks when compiling under MSVC +#endif + + +#include +#include +#include + +#include + +////////////////////////////////////////////////////////////////////// +// Constants +////////////////////////////////////////////////////////////////////// + +// davtool.cpp: implementation of the wxCurlDAVFs class. +// +////////////////////////////////////////////////////////////////////// + +////////////////////////////////////////////////////////////////////// +// Construction/Destruction +////////////////////////////////////////////////////////////////////// + +wxCurlDAVFs::wxCurlDAVFs() +: m_iContentLength(0) +{ +} + +wxCurlDAVFs::wxCurlDAVFs(const wxString& szHREF , + const wxString& szStatus , + const wxString& szCreationDate , + const wxString& szLastModified , + const long& iContentLength , + const wxString& szContentType ) +: m_szHREF(szHREF), m_szStatus(szStatus), +m_iContentLength(iContentLength), m_szContentType(szContentType) +{ + m_dtCreationDate = wxCurlBase::GetDateFromString(szCreationDate); + m_dtLastModified = wxCurlBase::GetDateFromString(szLastModified); +} + +wxCurlDAVFs::~wxCurlDAVFs() +{ +} + +// davtool.cpp: implementation of the wxCurlDAVTool class. +// +////////////////////////////////////////////////////////////////////// + +////////////////////////////////////////////////////////////////////// +// Construction/Destruction +////////////////////////////////////////////////////////////////////// + +wxCurlDAVTool::wxCurlDAVTool(const wxString& szURL /*= wxEmptyString*/, + const wxString& szUserName /*= wxEmptyString*/, + const wxString& szPassword /*= wxEmptyString*/, + wxEvtHandler* pEvtHandler /*= NULL*/, + long flags/*= wxCURL_DEFAULT_FLAGS*/) +: wxCurlDAV(szURL, szUserName, szPassword, pEvtHandler, flags) +{ +} + +wxCurlDAVTool::~wxCurlDAVTool() +{ +} + +////////////////////////////////////////////////////////////////////// +// Member Data Access Methods +////////////////////////////////////////////////////////////////////// + +////////////////////////////////////////////////////////////////////// +// Action Methods +////////////////////////////////////////////////////////////////////// + +bool wxCurlDAVTool::GetDAVFs(wxArrayDAVFs& fs, const wxString& szRemoteLoc /*= wxEmptyString*/) +{ + wxArrayString arrProps; + + arrProps.Add(wxS("creationdate")); + arrProps.Add(wxS("getlastmodified")); + arrProps.Add(wxS("getcontentlength")); + arrProps.Add(wxS("getcontenttype")); + + if(Propfind(arrProps, szRemoteLoc)) + { + // Construct Input Source... + wxStringInputStream inStream(wxCURL_BUF2STRING(m_szResponseBody)); + + if(inStream.IsOk()) + { + // Construct XML Parser + wxXmlDocument xmlPropfind(inStream); + + if(xmlPropfind.IsOk()) + { + // Process XML! + wxXmlNode* pNode = xmlPropfind.GetRoot(); + + // Strip Past First "Multistatus" tag... + while(pNode) + { + if(pNode->GetName().Find(wxS("multistatus")) != -1) + { + pNode = pNode->GetChildren(); + break; + } + else + pNode = pNode->GetNext(); + } + + // Process "Response" tags... + while(pNode) + { + wxCurlDAVFs fsItem; + + wxString szName = pNode->GetName(); + + if(pNode->GetName().Find(wxS("response")) != -1) + { + if(ParseResponseXml(fsItem, pNode)) + fs.Add(fsItem); + } + + pNode = pNode->GetNext(); + } + + return true; + } + } + } + + return false; +} + +bool wxCurlDAVTool::Exists(const wxString& szRemoteLoc /*= wxEmptyString*/) +{ + wxArrayDAVFs arrFs; + + if(GetDAVFs(arrFs, szRemoteLoc)) + { + return true; + } + + return false; +} + +bool wxCurlDAVTool::IsDirectory(const wxString& szRemoteLoc /*= wxEmptyString*/) +{ + wxArrayDAVFs arrFs; + + if(GetDAVFs(arrFs, szRemoteLoc)) + { + return arrFs.Last().IsDirectory(); + } + + return false; +} + +bool wxCurlDAVTool::IsOk(const wxString& szRemoteLoc /*= wxEmptyString*/) +{ + wxArrayDAVFs arrFs; + + if(GetDAVFs(arrFs, szRemoteLoc)) + { + return arrFs.Last().IsOK(); + } + + return false; +} + +wxDateTime wxCurlDAVTool::GetLastModified(const wxString& szRemoteLoc /*= wxEmptyString*/) +{ + wxArrayDAVFs arrFs; + + if(GetDAVFs(arrFs, szRemoteLoc)) + { + return arrFs.Last().GetLastModified(); + } + + return wxDateTime(); +} + +wxDateTime wxCurlDAVTool::GetCreationDate(const wxString& szRemoteLoc /*= wxEmptyString*/) +{ + wxArrayDAVFs arrFs; + + if(GetDAVFs(arrFs, szRemoteLoc)) + { + return arrFs.Last().GetCreationDate(); + } + + return wxDateTime(); +} + +long wxCurlDAVTool::GetContentLength(const wxString& szRemoteLoc /*= wxEmptyString*/) +{ + wxArrayDAVFs arrFs; + + if(GetDAVFs(arrFs, szRemoteLoc)) + { + return arrFs.Last().GetContentLength(); + } + + return -1; +} + +wxString wxCurlDAVTool::GetContentType(const wxString& szRemoteLoc /*= wxEmptyString*/) +{ + wxArrayDAVFs arrFs; + + if(GetDAVFs(arrFs, szRemoteLoc)) + { + return arrFs.Last().GetContentType(); + } + + return wxEmptyString; +} + +////////////////////////////////////////////////////////////////////// +// Helper Methods +////////////////////////////////////////////////////////////////////// + +bool wxCurlDAVTool::ParseResponseXml(wxCurlDAVFs& fsItem, wxXmlNode* pNode) +{ + if(pNode->GetName().Find(wxS("response")) != -1) + { + wxXmlNode* pChild = pNode->GetChildren(); + + bool bFoundHref = false; + bool bParsedPropstat = false; + + while(pChild) + { + if(pChild->GetName().Find(wxS("href")) != -1) + { + wxXmlNode* pText = pChild->GetChildren(); + + while(pText) + { + if(pText->GetType() == wxXML_TEXT_NODE) + { + fsItem.m_szHREF = pText->GetContent(); + bFoundHref = true; + } + + pText = pText->GetNext(); + } + } + + if(!bParsedPropstat) + { + if(pChild->GetName().Find(wxS("propstat")) != -1) + { + bParsedPropstat = ParsePropstatXml(fsItem, pChild); + } + } + + pChild = pChild->GetNext(); + } + + return bFoundHref && bParsedPropstat; + } + + return false; +} + +bool wxCurlDAVTool::ParsePropstatXml(wxCurlDAVFs& fsItem, wxXmlNode* pNode) +{ + if(pNode->GetName().Find(wxS("propstat")) != -1) + { + wxXmlNode* pChild = pNode->GetChildren(); + + bool bFoundStatus = false; + bool bParsedProps = false; + + while(pChild) + { + if(pChild->GetName().Find(wxS("status")) != -1) + { + wxXmlNode* pText = pChild->GetChildren(); + + while(pText) + { + if(pText->GetType() == wxXML_TEXT_NODE) + { + if(fsItem.m_szStatus.IsEmpty()) + fsItem.m_szStatus = pText->GetContent(); + + bFoundStatus = true; + } + + pText = pText->GetNext(); + } + } + + if(pChild->GetName().Find(wxS("prop")) != -1) + { + bParsedProps = ParsePropsXml(fsItem, pChild); + } + + pChild = pChild->GetNext(); + } + + return bFoundStatus && bParsedProps; + } + + return false; +} + +bool wxCurlDAVTool::ParsePropsXml(wxCurlDAVFs& fsItem, wxXmlNode* pNode) +{ + if(pNode->GetName().Find(wxS("prop")) != -1) + { + wxXmlNode* pChild = pNode->GetChildren(); + + bool bFoundCreationDate = false; + bool bFoundLastModified = false; +// bool bFoundGetContentLength = false; +// bool bFoundGetContentType = false; + + while(pChild) + { + if(pChild->GetName().Find(wxS("creationdate")) != -1) + { + wxXmlNode* pText = pChild->GetChildren(); + + while(pText) + { + if(pText->GetType() == wxXML_TEXT_NODE) + { + wxString szVal = pText->GetContent(); + + fsItem.m_dtCreationDate.ParseFormat(szVal, wxS("%Y-%m-%dT%H:%M:%S")); + bFoundCreationDate = true; + } + + pText = pText->GetNext(); + } + } + + if(pChild->GetName().Find(wxS("getlastmodified")) != -1) + { + wxXmlNode* pText = pChild->GetChildren(); + + while(pText) + { + if(pText->GetType() == wxXML_TEXT_NODE) + { + wxString szVal = pText->GetContent(); + + fsItem.m_dtLastModified.ParseRfc822Date(szVal); + bFoundLastModified = true; + } + + pText = pText->GetNext(); + } + } +#if 0 + if(pChild->GetName().Find(wxS("getcontentlength")) != -1) + { + wxXmlNode* pText = pChild->GetChildren(); + + while(pText) + { + if(pText->GetType() == wxXML_TEXT_NODE) + { + wxString szVal = pText->GetContent(); + + if(szVal.ToLong(&fsItem.m_iContentLength)) + ;// bFoundGetContentLength = true; + } + + pText = pText->GetNext(); + } + } +#endif + if(pChild->GetName().Find(wxS("getcontenttype")) != -1) + { + wxXmlNode* pText = pChild->GetChildren(); + + while(pText) + { + if(pText->GetType() == wxXML_TEXT_NODE) + { + fsItem.m_szContentType = pText->GetContent(); + //bFoundGetContentType = true; + } + + pText = pText->GetNext(); + } + } + + pChild = pChild->GetNext(); + } + + return bFoundCreationDate && bFoundLastModified; + } + + return false; +} + +////////////////////////////////////////////////////////////////////// +// wxArrayDAVFs Implementation +////////////////////////////////////////////////////////////////////// +#include // this is a magic incantation which must be done! +WX_DEFINE_USER_EXPORTED_OBJARRAY(wxArrayDAVFs); diff --git a/src/dialog.cpp b/src/dialog.cpp new file mode 100644 index 0000000..c840690 --- /dev/null +++ b/src/dialog.cpp @@ -0,0 +1,653 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: dialog.cpp +// Purpose: wxCurlDownloadDialog, wxCurlUploadDialog +// Author: Francesco Montorsi +// Created: 2007/04/14 +// RCS-ID: $Id: dialog.cpp 1240 2010-03-10 23:54:25Z frm $ +// Copyright: (c) 2007 Francesco Montorsi +// Licence: wxWidgets licence +///////////////////////////////////////////////////////////////////////////// + + +// For compilers that support precompilation, includes "wx.h". +#include "wx/wxprec.h" + +#ifdef __BORLANDC__ +#pragma hdrstop +#endif + +// includes +#ifndef WX_PRECOMP + #include + #include // for _() support + #include // for wxMilliSleep + + #if wxUSE_GUI + #include + #include + #include + #include + #include + #include + #include + #include + #endif +#endif + +#ifdef __WXMSW__ + #include // useful to catch memory leaks when compiling under MSVC +#endif + +#include +#include +#include + +//class WXDLLIMPEXP_CORE wxTextCtrl; +class WXDLLIMPEXP_CORE wxCheckBox; +#include "wx/curl/dialog.h" + + +// ---------------------------------------------------------------------------- +// wxCurlTransferDialog +// ---------------------------------------------------------------------------- + +enum +{ + AbortButtonId = wxID_HIGHEST+1, + PauseResumeButtonId, + StartButtonId, + ConnSettingsButtonId, + + ThreadId +}; + +BEGIN_EVENT_TABLE( wxCurlTransferDialog, wxDialog ) + + // network events + EVT_CURL_END_PERFORM( ThreadId, wxCurlTransferDialog::OnEndPerform ) + + // user events + EVT_BUTTON( AbortButtonId, wxCurlTransferDialog::OnAbort ) + EVT_BUTTON( ConnSettingsButtonId, wxCurlTransferDialog::OnConnSettings ) + EVT_BUTTON( PauseResumeButtonId, wxCurlTransferDialog::OnPauseResume ) + EVT_BUTTON( StartButtonId, wxCurlTransferDialog::OnStart ) + + // update UI + EVT_UPDATE_UI( AbortButtonId, wxCurlTransferDialog::OnAbortUpdateUI ) + EVT_UPDATE_UI( ConnSettingsButtonId, wxCurlTransferDialog::OnConnSettingsUpdateUI ) + EVT_UPDATE_UI( PauseResumeButtonId, wxCurlTransferDialog::OnPauseResumeUpdateUI ) + EVT_UPDATE_UI( StartButtonId, wxCurlTransferDialog::OnStartUpdateUI ) + + // misc + EVT_CLOSE( wxCurlTransferDialog::OnClose ) + +END_EVENT_TABLE() + +bool wxCurlTransferDialog::Create(const wxString &url, const wxString& title, const wxString& message, + const wxString &sizeLabel, const wxBitmap& bitmap, wxWindow *parent, long style) +{ + if (!wxDialog::Create(parent, wxID_ANY, title, wxDefaultPosition, wxDefaultSize, + (wxDEFAULT_DIALOG_STYLE |wxRESIZE_BORDER))) + return false; + + // save&check our style + m_nStyle = style; + wxASSERT_MSG(HasFlag(wxCTDS_AUTO_CLOSE) || HasFlag(wxCTDS_CAN_ABORT), + wxS("If both these flags are missing the user will be unable to close the dialog window!")); + + // do we need to use wxCurlConnectionSettingsDialog? + wxASSERT_MSG(!(HasFlag(wxCTDS_CONN_SETTINGS_AUTH) || + HasFlag(wxCTDS_CONN_SETTINGS_PORT) || + HasFlag(wxCTDS_CONN_SETTINGS_PROXY)) || HasFlag(wxCTDS_CAN_START), + wxS("the connection settings may only be changed before the transfer starts; if wxCTDS_CAN_START ") + wxS("is missing the user will be unable to use the connection settings button!")); + + // set up our controls + CreateControls(url, message, sizeLabel, bitmap); + + return true; +} + +wxCurlDialogReturnFlag wxCurlTransferDialog::RunModal() +{ + m_pThread->GetCurlSession()->SetVerbose(m_bVerbose); + + if (!HasFlag(wxCTDS_CAN_START)) + { + wxCommandEvent fake; + OnStart(fake); // start immediately + } + + CenterOnScreen(); + + return (wxCurlDialogReturnFlag)wxDialog::ShowModal(); +} + +#define OUTER_BORDER 12 +#define BORDER 5 +#define MINWIDTH 300 + +wxStaticText *wxCurlTransferDialog::AddSizerRow(wxSizer *sz, const wxString &name) +{ + // the static text + wxStaticText *st = new wxStaticText( this, wxID_STATIC, name, wxDefaultPosition, wxDefaultSize ); + st->SetFont(wxFont(8, wxSWISS, wxNORMAL, wxBOLD, false, wxS(""))); + + // the value + wxStaticText *ret = new wxStaticText( this, wxID_STATIC, _("Not available"), + wxDefaultPosition, wxDefaultSize, + wxALIGN_LEFT|wxST_NO_AUTORESIZE ); + + wxBoxSizer* time = new wxBoxSizer(wxHORIZONTAL); + time->Add(st, 0, wxALIGN_CENTER_VERTICAL|wxTOP|wxRIGHT, 5); + time->Add(ret, 1, wxALIGN_CENTER_VERTICAL|wxTOP|wxRIGHT, 5); + + sz->Add(time, 0, wxGROW|wxLEFT|wxRIGHT, OUTER_BORDER); + + return ret; +} + +void wxCurlTransferDialog::CreateControls(const wxString &url, const wxString &msg, + const wxString &sizeLabel, const wxBitmap &bitmap) +{ + wxBoxSizer* main = new wxBoxSizer(wxVERTICAL); + + // message row + if (!msg.IsEmpty()) + { + wxStaticText *st = new wxStaticText( this, wxID_STATIC, msg ); + st->SetMinSize(wxSize(MINWIDTH, -1)); + main->Add(st, 0, wxLEFT|wxTOP|wxRIGHT|wxBOTTOM|wxGROW, OUTER_BORDER); + } + + // URL row + if (HasFlag(wxCTDS_URL)) + { + wxBoxSizer* downloading = new wxBoxSizer(wxHORIZONTAL); + + wxStaticText *st = new wxStaticText( this, wxID_STATIC, _("URL:") ); + wxFont boldFont(st->GetFont()); + boldFont.SetWeight(wxFONTWEIGHT_BOLD); + st->SetFont(boldFont); + downloading->Add(st, 0, wxRIGHT|wxTOP|wxALIGN_CENTER_VERTICAL, BORDER); + + m_pURL = new wxStaticText( this, wxID_STATIC, url, wxDefaultPosition, + wxSize(MINWIDTH, -1));//, wxST_ELLIPSIZE_MIDDLE); + downloading->Add(m_pURL, 1, wxALIGN_CENTER_VERTICAL|wxTOP, BORDER); + + main->Add(downloading, 0, wxGROW|wxLEFT|wxRIGHT, OUTER_BORDER); + main->AddSpacer(5); + } + + + wxSizer *leftcolumn = new wxBoxSizer(wxVERTICAL); + + // speed & size row + if (HasFlag(wxCTDS_SPEED)) + m_pSpeed = AddSizerRow(leftcolumn, _("Speed:")); + if (HasFlag(wxCTDS_SIZE)) + m_pSize = AddSizerRow(leftcolumn, sizeLabel); + + // a spacer + leftcolumn->AddSpacer(5); + + // the time rows + if (HasFlag(wxCTDS_ELAPSED_TIME)) + m_pElapsedTime = AddSizerRow(leftcolumn, _("Elapsed time:")); + if (HasFlag(wxCTDS_ESTIMATED_TIME)) + m_pEstimatedTime = AddSizerRow(leftcolumn, _("Estimated total time:")); + if (HasFlag(wxCTDS_REMAINING_TIME)) + m_pRemainingTime = AddSizerRow(leftcolumn, _("Estimated remaining time:")); + + if (bitmap.IsOk()) + { + wxSizer *rightcolumn = new wxBoxSizer(wxVERTICAL); + rightcolumn->Add( new wxStaticBitmap(this, wxID_ANY, bitmap), + 0, wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT|wxALL, BORDER); + + wxSizer *both = new wxBoxSizer(wxHORIZONTAL); + both->Add(leftcolumn); + both->Add(rightcolumn, 1, wxGROW); + main->Add(both, 0, wxGROW); + } + else + main->Add(leftcolumn); + + + // the gauge + // VERY IMPORTANT: we set as range 101 so that when, because of some approximation, + // the update event handler will SetValue(100), while the transfer + // is not yet complete, the gauge will not appear completely filled. + m_pGauge = new wxGauge( this, wxID_ANY, 101 ); + + main->AddSpacer(5); + main->Add(m_pGauge, 0, wxGROW|wxLEFT|wxRIGHT|wxTOP, OUTER_BORDER); + + // do we need to use wxCurlConnectionSettingsDialog? + bool needsConnSettings = HasFlag(wxCTDS_CONN_SETTINGS_AUTH) || + HasFlag(wxCTDS_CONN_SETTINGS_PORT) || + HasFlag(wxCTDS_CONN_SETTINGS_PROXY); + + // an horizontal line of buttons + if (HasFlag(wxCTDS_CAN_ABORT) || HasFlag(wxCTDS_CAN_PAUSE) || HasFlag(wxCTDS_CAN_START) || + needsConnSettings) + { + main->AddStretchSpacer(1); + main->AddSpacer(BORDER*2); + main->Add( new wxStaticLine(this), 0, wxGROW|wxLEFT|wxRIGHT, OUTER_BORDER); + + // the button row + wxBoxSizer *btn = new wxBoxSizer(wxHORIZONTAL); + + if (HasFlag(wxCTDS_CAN_ABORT)) + btn->Add(new wxButton( this, AbortButtonId, _("Abort") ), 0, wxRIGHT, BORDER); + if (needsConnSettings) + btn->Add(new wxButton( this, ConnSettingsButtonId, _("Settings") ), 0); + + btn->AddStretchSpacer(1); + + if (HasFlag(wxCTDS_CAN_PAUSE)) + btn->Add(new wxButton( this, PauseResumeButtonId, _("Pause") ), 0); + if (HasFlag(wxCTDS_CAN_START)) + btn->Add(new wxButton( this, StartButtonId, _("Start") ), 0, wxLEFT, BORDER); + + btn->SetMinSize( wxSize( -1, wxButton::GetDefaultSize().GetHeight() + 2 * OUTER_BORDER ) ); + + main->Add(btn, 0, wxGROW|wxLEFT|wxRIGHT|wxTOP|wxBOTTOM, OUTER_BORDER); + } + + this->SetSizerAndFit(main); + main->SetSizeHints(this); +} + +void wxCurlTransferDialog::EndModal(int retCode) +{ + wxDialog::EndModal(retCode); + + // before dying we must be sure our thread has completed, too + // otherwise it will try to send events to a non-existent handler + // NB: this must be done *after* calling wxDialog::EndModal + // so that while we wait we are hidden + HandleCurlThreadError(m_pThread->Wait(), m_pThread); +} + +void wxCurlTransferDialog::UpdateLabels(wxCurlProgressBaseEvent *ev) +{ + // ignore this update if the thread has been paused + // since this event was generated... + if (m_pThread->IsPaused()) + return; + + // NOTE: we need instead to process this update if the thread has completed + // but that's for another reason: see m_pLastEvent stuff + + double fraction = ev->GetPercent(); + if (fraction != 0) + { + m_pGauge->SetValue((int)fraction); + } + else + { + // we don't know how much we progressed... + m_pGauge->Pulse(); + } + + // Correct an occasional ASSERT for invalid wxTimeSpan. dsr + if(ev->GetElapsedTime().IsShorterThan( wxTimeSpan::Minutes(120))){ + if (m_pElapsedTime) + m_pElapsedTime->SetLabel(ev->GetElapsedTime().Format()); + if (m_pRemainingTime) + m_pRemainingTime->SetLabel(ev->GetEstimatedRemainingTime().Format()); + if (m_pEstimatedTime) + m_pEstimatedTime->SetLabel(ev->GetEstimatedTime().Format()); + } + + if (m_pSize) + { + wxString currsize(ev->GetHumanReadableTransferredBytes().c_str(), wxConvUTF8); + wxString totalsize(ev->GetHumanReadableTotalBytes().c_str(), wxConvUTF8); + m_pSize->SetLabel( + wxString::Format(wxS("%s / %s (%0.1f%%)"), + currsize.c_str(), totalsize.c_str(), ev->GetPercent())); + } + + if (m_pSpeed) + { + wxString s(ev->GetHumanReadableSpeed().c_str(), wxConvUTF8); + m_pSpeed->SetLabel(s); + } +} + +bool wxCurlTransferDialog::HandleCurlThreadError(wxCurlThreadError err, wxCurlBaseThread *p, const wxString &url) +{ + switch (err) + { + case wxCTE_NO_ERROR: + return true; // ignore this + + case wxCTE_NO_RESOURCE: + wxLogError(wxS("Insufficient resources for correct execution of the program.")); + break; + + case wxCTE_ALREADY_RUNNING: + wxFAIL; // should never happen! + break; + + case wxCTE_INVALID_PROTOCOL: + wxLogError(wxS("The URL '%s' uses an unsupported protocol."), url.c_str()); + break; + + case wxCTE_NO_VALID_STREAM: + wxFAIL; // should never happen - the user streams should always be valid! + break; + + case wxCTE_ABORTED: + return true; // ignore this + + case wxCTE_CURL_ERROR: + { + wxString err = wxS("unknown"); + if (p->GetCurlSession()) + err = wxString(p->GetCurlSession()->GetErrorString().c_str(), wxConvUTF8); + wxLogError(wxS("Network error: %s"), err.c_str()); + } + break; + } + + // stop the thread + if (p->IsAlive()) p->Abort(); + + // this is an unrecoverable error: + return false; +} + + +// ---------------------------------------------------------------------------- +// wxCurlTransferDialog - button events +// ---------------------------------------------------------------------------- + +void wxCurlTransferDialog::OnClose(wxCloseEvent &WXUNUSED(ev)) +{ + wxCommandEvent fake; + OnAbort(fake); +} + +void wxCurlTransferDialog::OnAbort(wxCommandEvent &WXUNUSED(ev)) +{ + // NOTE: the wxCTDS_ABORT flag may be absent if the user wxASSERT(HasFlag(wxCTDS_CAN_ABORT)); + + if (m_pThread->IsAlive()) + { + m_pThread->Abort(); + EndModal(wxCDRF_USER_ABORTED); + } + else + { + wxASSERT(HasFlag(wxCTDS_CAN_START) || !HasFlag(wxCTDS_AUTO_CLOSE)); + // thread is not alive: means the user has not + // clicked on Start button yet or the download is complete + // and the dialog does not auto close + + // if the transfer has been completed, then the OnEndPerform event handler + // has already set the return code to a valid value: + EndModal(m_bTransferComplete ? GetReturnCode() : wxCDRF_USER_ABORTED); + } +} + +void wxCurlTransferDialog::OnAbortUpdateUI(wxUpdateUIEvent &ev) +{ + ev.SetText(m_pThread->IsAlive() ? _("Abort") : _("Close")); +} + +void wxCurlTransferDialog::OnPauseResume(wxCommandEvent &WXUNUSED(ev)) +{ + wxASSERT(HasFlag(wxCTDS_CAN_PAUSE)); + + if (m_pThread->IsRunning()) + { + if (HandleCurlThreadError(m_pThread->Pause(), m_pThread)) + { + FindWindowById(PauseResumeButtonId)->SetLabel(_("Resume")); + + if (m_pSpeed) + m_pSpeed->SetLabel(_("0 (transfer paused)")); + } + } + else + { + if (HandleCurlThreadError(m_pThread->Resume(), m_pThread)) + { + FindWindowById(PauseResumeButtonId)->SetLabel(_("Pause")); + } + } +} + +void wxCurlTransferDialog::OnPauseResumeUpdateUI(wxUpdateUIEvent &ev) +{ + ev.Enable(m_pThread->IsAlive()); +} + +void wxCurlTransferDialog::OnStart(wxCommandEvent &WXUNUSED(ev)) +{ + //wxASSERT(HasFlag(wxCTDS_CAN_START)); // OnStart() must be usable also from RunModal() when !HasFlag(wxCTDS_CAN_START) + + wxCurlThreadError err = m_pThread->StartTransfer(); + if (err != wxCTE_NO_ERROR) + { + HandleCurlThreadError(err, m_pThread); // shows a message to the user + m_pThread->Abort(); + EndModal(wxCDRF_FAILED); + } +} + +void wxCurlTransferDialog::OnStartUpdateUI(wxUpdateUIEvent &ev) +{ + ev.Enable(!m_pThread->IsAlive() && !m_bTransferComplete); +} + +void wxCurlTransferDialog::OnConnSettings(wxCommandEvent &WXUNUSED(ev)) +{ + long style = 0; + + // convert our style into wxCurlConnectionSettingsDialog style: + if (HasFlag(wxCTDS_CONN_SETTINGS_AUTH)) + style |= wxCCSP_AUTHENTICATION_OPTIONS; + if (HasFlag(wxCTDS_CONN_SETTINGS_PORT)) + style |= wxCCSP_PORT_OPTION; + if (HasFlag(wxCTDS_CONN_SETTINGS_PROXY)) + style |= wxCCSP_PROXY_OPTIONS; + + wxCurlConnectionSettingsDialog + dlg(_("Connection settings"), _("Connection settings used for the transfer:"), + this, style); + + dlg.RunModal(m_pThread->GetCurlSession()); +} + +void wxCurlTransferDialog::OnConnSettingsUpdateUI(wxUpdateUIEvent &ev) +{ + ev.Enable(!m_pThread->IsAlive() && !m_bTransferComplete); +} + + +// ---------------------------------------------------------------------------- +// wxCurlTransferDialog - network events +// ---------------------------------------------------------------------------- + +void wxCurlTransferDialog::OnEndPerform(wxCurlEndPerformEvent &ev) +{ + wxLogDebug(wxS("wxCurlTransferDialog::OnEndPerform")); + + // in case the very last transfer update event was skipped because + // of our anti-flickering label update policy, force the update with + // that event now (otherwise the dialog may remain open showing data + // related not to the end of the download!) + if (m_pLastEvent) + UpdateLabels(m_pLastEvent); + //else: we may have transferred a file of zero size and thus have never received any progress event... + + // now we're sure the transfer has completed: make the gauge + // completely "filled" + m_pGauge->SetValue(101); + + // this flag is used for updating labels etc: + m_bTransferComplete = true; + + // transfer has completed... + wxCurlDialogReturnFlag retCode = ev.IsSuccessful() ? wxCDRF_SUCCESS : wxCDRF_FAILED; +#if 0 // below is bugged because m_pThread->GetCurlSession() is NULL at this point... + if (retCode == wxCDRF_FAILED) + { + // show the user a message... + wxLogError(wxS("The transfer failed: %s (%s)"), + m_pThread->GetCurlSession()->GetErrorString().c_str(), + m_pThread->GetCurlSession()->GetDetailedErrorString().c_str()); + } +#endif + + // do we need to close this window? + if (HasFlag(wxCTDS_AUTO_CLOSE)) + EndModal(retCode); + else + { + SetReturnCode(retCode); // will exit later in OnAbort() + + if (m_pSpeed) + m_pSpeed->SetLabel(_("0 (transfer completed)")); + } +} + + + + +// ---------------------------------------------------------------------------- +// wxCurlDownloadDialog +// ---------------------------------------------------------------------------- + +IMPLEMENT_DYNAMIC_CLASS( wxCurlDownloadDialog, wxCurlTransferDialog ) +BEGIN_EVENT_TABLE( wxCurlDownloadDialog, wxCurlTransferDialog ) + EVT_CURL_DOWNLOAD( ThreadId, wxCurlDownloadDialog::OnDownload ) +END_EVENT_TABLE() + +bool wxCurlDownloadDialog::Create(const wxString &url, wxOutputStream *out, + const wxString& title, const wxString& message, + const wxBitmap& bitmap, + wxWindow *parent, long style) +{ + if (!wxCurlTransferDialog::Create(url, title, message, _("Downloaded:"), bitmap, parent, style)) + return false; + + // register as the thread's event handler + wxCurlDownloadThread *thread = new wxCurlDownloadThread(this, ThreadId); + + m_pThread = thread; // downcast our pointer for usage by wxCurlTransferDialog + + if (!HandleCurlThreadError(thread->SetURL(url), thread, url)) + return false; + if (!HandleCurlThreadError(thread->SetOutputStream(out), thread)) + return false; + + return true; +} + +void wxCurlDownloadDialog::OnDownload(wxCurlDownloadEvent &ev) +{ + static wxDateTime lastLabelUpdate(0, 0, 0, 0); // zero is to force always at least an update + if ((wxDateTime::Now() - lastLabelUpdate).GetMilliseconds() > 200) // avoid flickering + { + UpdateLabels(&ev); + + lastLabelUpdate = wxDateTime::Now(); + } + + // see OnEndPerform for more info. + if (m_pLastEvent) + delete m_pLastEvent; + m_pLastEvent = wx_static_cast(wxCurlProgressBaseEvent*, ev.Clone()); +} + + + +// ---------------------------------------------------------------------------- +// wxCurlUploadDialog +// ---------------------------------------------------------------------------- + +IMPLEMENT_DYNAMIC_CLASS( wxCurlUploadDialog, wxCurlTransferDialog ) +BEGIN_EVENT_TABLE( wxCurlUploadDialog, wxCurlTransferDialog ) + EVT_CURL_UPLOAD( ThreadId, wxCurlUploadDialog::OnUpload ) +END_EVENT_TABLE() + +bool wxCurlUploadDialog::Create(const wxString &url, wxInputStream *in, + const wxString& title, const wxString& message, + const wxBitmap& bitmap, + wxWindow *parent, long style) +{ + if (!wxCurlTransferDialog::Create(url, title, message, _("Uploaded:"), bitmap, parent, style)) + return false; + + // register as the thread's event handler + wxCurlUploadThread *thread = new wxCurlUploadThread(this, ThreadId); + + m_pThread = thread; // downcast our pointer for usage by wxCurlTransferDialog + + if (!HandleCurlThreadError(thread->SetURL(url), thread, url)) + return false; + if (!HandleCurlThreadError(thread->SetInputStream(in), thread)) + return false; + + return true; +} + +void wxCurlUploadDialog::OnUpload(wxCurlUploadEvent &ev) +{ + static wxDateTime lastLabelUpdate(0, 0, 0, 0); // zero is to force always at least an update + if ((wxDateTime::Now() - lastLabelUpdate).GetMilliseconds() > 200) // avoid flickering + { + UpdateLabels(&ev); + + lastLabelUpdate = wxDateTime::Now(); + } + + // see OnEndPerform for more info. + if (m_pLastEvent) + delete m_pLastEvent; + m_pLastEvent = wx_static_cast(wxCurlProgressBaseEvent*, ev.Clone()); +} + + + +// ---------------------------------------------------------------------------- +// wxCurlConnectionSettingsDialog +// ---------------------------------------------------------------------------- + +IMPLEMENT_DYNAMIC_CLASS( wxCurlConnectionSettingsDialog, wxDialog ) + +bool wxCurlConnectionSettingsDialog::Create(const wxString& title, + const wxString& message, + wxWindow *parent, + long style) +{ + if (!wxDialog::Create(parent, wxID_ANY, title, wxDefaultPosition, wxDefaultSize, + wxDEFAULT_DIALOG_STYLE|wxRESIZE_BORDER)) + return false; + + m_pPanel = new wxCurlConnectionSettingsPanel(this, wxID_ANY, message, wxDefaultPosition, + wxDefaultSize, style); + + wxSizer *main = new wxBoxSizer(wxVERTICAL); + wxSizer *buttons = CreateSeparatedButtonSizer(wxOK|wxCANCEL); + + main->Add(m_pPanel, 1, wxGROW|wxALL, 10); + main->Add(buttons, 0, wxGROW|wxALL, 10); + + SetSizerAndFit(main); + + return true; +} + +void wxCurlConnectionSettingsDialog::RunModal(wxCurlBase *pCURL) +{ + if (ShowModal() == wxID_OK) + m_pPanel->SetCURLOptions(pCURL); +} + diff --git a/src/ftp.cpp b/src/ftp.cpp new file mode 100644 index 0000000..d6f0a8f --- /dev/null +++ b/src/ftp.cpp @@ -0,0 +1,602 @@ +/* + * ftp.cpp + * wxCURL + * + * Created by Casey O'Donnell on Tue Jun 29 2004. + * Copyright (c) 2004 Casey O'Donnell. All rights reserved. + * + * + * Licence: wxWidgets Licence + */ + +// ftp.cpp: implementation of the wxCurlFTP class. +// +////////////////////////////////////////////////////////////////////// + +////////////////////////////////////////////////////////////////////// +// Headers +////////////////////////////////////////////////////////////////////// + +#include "wx/wxprec.h" + +#ifndef WX_PRECOMP + #include "wx/wx.h" +#endif + +#ifdef __WXMSW__ + #include // useful to catch memory leaks when compiling under MSVC +#endif + +#include +#include + +#include + +////////////////////////////////////////////////////////////////////// +// C Functions for LibCURL +////////////////////////////////////////////////////////////////////// +extern "C" +{ +} + +////////////////////////////////////////////////////////////////////// +// Construction/Destruction +////////////////////////////////////////////////////////////////////// + +wxCurlFTP::wxCurlFTP(const wxString& szURL /*= wxEmptyString*/, + const wxString& szUserName /*= wxEmptyString*/, + const wxString& szPassword /*= wxEmptyString*/, + wxEvtHandler* pEvtHandler /*= NULL*/, + int id /*= wxID_ANY*/, + long flags /*= wxCURL_DEFAULT_FLAGS*/) +: wxCurlBase(szURL, szUserName, szPassword, pEvtHandler, id, flags), + m_pQuote(NULL), m_pPreQuote(NULL), m_pPostQuote(NULL), + m_bCreateMissingDirs(true), m_bAppend(false), m_bUsePortOption(false), + m_tmMode(kASCII), m_bUseEPRT(false), m_bUseEPSV(false), + m_szPortParam("-") +{ +} + +wxCurlFTP::~wxCurlFTP() +{ + ResetAllQuoteLists(); +} + +////////////////////////////////////////////////////////////////////// +// Member Data Access Methods +////////////////////////////////////////////////////////////////////// + +void wxCurlFTP::SetTransferMode(const TransferMode& tmMode) +{ + m_tmMode = tmMode; +} + +wxCurlFTP::TransferMode wxCurlFTP::GetTransferMode() const +{ + return m_tmMode; +} + +void wxCurlFTP::SetToBinary() +{ + SetTransferMode(kBINARY); +} + +void wxCurlFTP::SetToAscii() +{ + SetTransferMode(kASCII); +} + +bool wxCurlFTP::IsAscii() const +{ + return m_tmMode == kASCII; +} + +bool wxCurlFTP::IsBinary() const +{ + return m_tmMode == kBINARY; +} + +void wxCurlFTP::UsePortOption(const bool& bUsePort) +{ + m_bUsePortOption = bUsePort; +} + +bool wxCurlFTP::UsePortOption() const +{ + return m_bUsePortOption; +} + +void wxCurlFTP::SetPortParam(const wxString& szParam /*= wxS("-")*/) +{ + m_szPortParam = wxCURL_STRING2BUF(szParam); +} + +wxString wxCurlFTP::GetPortParam() const +{ + return wxCURL_BUF2STRING(m_szPortParam); +} + +void wxCurlFTP::UseEPRT(const bool& bUseEPRT) +{ + m_bUseEPRT = bUseEPRT; +} + +bool wxCurlFTP::UseEPRT() const +{ + return m_bUseEPRT; +} + +void wxCurlFTP::UseEPSV(const bool& bUseEPSV) +{ + m_bUseEPSV = bUseEPSV; +} + +bool wxCurlFTP::UseEPSV() const +{ + return m_bUseEPSV; +} + +void wxCurlFTP::AppendOnUpload(const bool& bAppend) +{ + m_bAppend = bAppend; +} + +bool wxCurlFTP::AppendOnUpload() const +{ + return m_bAppend; +} + +void wxCurlFTP::CreateMissingDirs(const bool& bCreateMissing) +{ + m_bCreateMissingDirs = bCreateMissing; +} + +bool wxCurlFTP::CreateMissingDirs() const +{ + return m_bCreateMissingDirs; +} + +bool wxCurlFTP::SetQuoteList(const wxArrayString& arrQuote) +{ + ResetQuoteList(); + + for(unsigned int i = 0; i < arrQuote.Count(); i++) + { + m_pQuote = curl_slist_append(m_pQuote, (const char*)(arrQuote[i].c_str())); + } + + return (m_pQuote != NULL); +} + +bool wxCurlFTP::AppendQuote(const wxString& szQuote, const bool& bClear /*= false*/) +{ + if(bClear) + ResetQuoteList(); + + m_pQuote = curl_slist_append(m_pQuote, (const char*)(szQuote.c_str())); + + return (m_pQuote != NULL); +} + +bool wxCurlFTP::SetPreQuoteList(const wxArrayString& arrQuote) +{ + ResetPreQuoteList(); + + for(unsigned int i = 0; i < arrQuote.Count(); i++) + { + m_pPreQuote = curl_slist_append(m_pPreQuote, (const char*)(arrQuote[i].c_str())); + } + + return (m_pPreQuote != NULL); +} + +bool wxCurlFTP::AppendPreQuote(const wxString& szQuote, const bool& bClear /*= false*/) +{ + if(bClear) + ResetPreQuoteList(); + + m_pPreQuote = curl_slist_append(m_pPreQuote, (const char*)(szQuote.c_str())); + + return (m_pPreQuote != NULL); +} + +bool wxCurlFTP::SetPostQuoteList(const wxArrayString& arrQuote) +{ + ResetPostQuoteList(); + + for(unsigned int i = 0; i < arrQuote.Count(); i++) + { + m_pPostQuote = curl_slist_append(m_pPostQuote, (const char*)(arrQuote[i].c_str())); + } + + return (m_pPostQuote != NULL); +} + +bool wxCurlFTP::AppendPostQuote(const wxString& szQuote, const bool& bClear /*= false*/) +{ + if(bClear) + ResetPostQuoteList(); + + m_pPostQuote = curl_slist_append(m_pPostQuote, (const char*)(szQuote.c_str())); + + return (m_pPostQuote != NULL); +} + +////////////////////////////////////////////////////////////////////// +// Action Methods +////////////////////////////////////////////////////////////////////// + +bool wxCurlFTP::Get(const wxString& szFilePath, const wxString& szRemoteFile /*= wxEmptyString*/) +{ + wxFFileOutputStream outStream(szFilePath); + + return Get(outStream, szRemoteFile); +} + +size_t wxCurlFTP::Get(char*& buffer, const wxString& szRemoteFile /*= wxEmptyString*/) +{ + wxMemoryOutputStream outStream; + + buffer = NULL; + size_t iRetVal = 0; + + if(Get(outStream, szRemoteFile)) + { + iRetVal = outStream.GetSize(); + + buffer = (char*)malloc(iRetVal + 1); + + if(buffer) + { + outStream.CopyTo(buffer, outStream.GetSize()); + buffer[iRetVal] = '\0'; + return iRetVal; + } + + free(buffer); + buffer = NULL; + } + + return 0; +} + +bool wxCurlFTP::Get(wxOutputStream& buffer, const wxString& szRemoteFile /*= wxEmptyString*/) +{ + if(m_pCURL && buffer.IsOk()) + { + SetCurlHandleToDefaults(szRemoteFile); + + SetStreamWriteFunction(buffer); + + if(Perform()) + { + return ((m_iResponseCode > 199) && (m_iResponseCode < 299)); + } + } + + return false; +} + +bool wxCurlFTP::Put(const wxString& szFilePath, const wxString& szRemoteFile /*= wxEmptyString*/) +{ + wxFFileInputStream inStream(szFilePath); + + return Put(inStream, szRemoteFile); +} + +bool wxCurlFTP::Put(const char* buffer, size_t size, const wxString& szRemoteFile /*= wxEmptyString*/) +{ + wxMemoryInputStream inStream(buffer, size); + + return Put(inStream, szRemoteFile); +} + +bool wxCurlFTP::Put(wxInputStream& buffer, const wxString& szRemoteFile /*= wxEmptyString*/) +{ + curl_off_t iSize = 0; + + if(m_pCURL && buffer.IsOk()) + { + SetCurlHandleToDefaults(szRemoteFile); + + iSize = buffer.GetSize(); + + if(iSize == (~(ssize_t)0)) + return false; + + SetOpt(CURLOPT_UPLOAD, TRUE); + SetStreamReadFunction(buffer); + SetOpt(CURLOPT_INFILESIZE_LARGE, iSize); + + if(Perform()) + { + return ((m_iResponseCode > 199) && (m_iResponseCode < 300)); + } + } + + return false; +} + +bool wxCurlFTP::MkDir(const wxString& szRemoteLoc /*= wxEmptyString*/) +{ + if(m_pCURL) + { + wxString str(szRemoteLoc); + if(str.Last() != '/') + str += wxS("/"); + + SetCurlHandleToDefaults(str); + + SetOpt(CURLOPT_FTP_CREATE_MISSING_DIRS, TRUE); + SetOpt(CURLOPT_NOBODY, TRUE); + + if(Perform()) + { + return ((m_iResponseCode > 199) && (m_iResponseCode < 300)); + } + } + + return false; +} + +bool wxCurlFTP::RmDir(const wxString& szRemoteLoc /*= wxEmptyString*/) +{ + if(m_pCURL) + { + wxString str(szRemoteLoc); + if(str.Last() != wxS('/')) + str += wxS("/"); + SetCurlHandleToDefaults(str); + + wxString url(GetURL().c_str(), wxConvUTF8); + m_szCurrFullPath = url.Left(url.Len() - 1).BeforeLast(wxS('/')); + m_szCurrFullPath += wxS("/"); + m_szCurrFilename = url.Left(url.Len() - 1).AfterLast(wxS('/')); + + if(m_szCurrFilename.IsEmpty()) + return false; + + AppendPostQuote(wxS("RMD ") + m_szCurrFilename, true); + + SetCurlHandleQuoteOpts(); + SetOpt(CURLOPT_NOBODY, TRUE); + + if(Perform()) + { + ResetAllQuoteLists(); + + return ((m_iResponseCode > 199) && (m_iResponseCode < 300)); + } + + ResetAllQuoteLists(); + } + + return false; +} + +bool wxCurlFTP::Delete(const wxString& szRemoteLoc /*= wxEmptyString*/) +{ + if(m_pCURL) + { + SetCurlHandleToDefaults(szRemoteLoc); + + wxString url(GetURL().c_str(), wxConvUTF8); + m_szCurrFullPath = url.BeforeLast('/'); + m_szCurrFullPath += wxS("/"); + m_szCurrFilename = url.AfterLast('/'); + + if(m_szCurrFilename.IsEmpty()) + return RmDir(szRemoteLoc); + + AppendPostQuote(wxS("DELE ") + m_szCurrFilename, true); + + SetCurlHandleQuoteOpts(); + SetOpt(CURLOPT_NOBODY, TRUE); + + if(Perform()) + { + ResetAllQuoteLists(); + + return ((m_iResponseCode > 199) && (m_iResponseCode < 300)); + } + + ResetAllQuoteLists(); + } + + return false; +} + +bool wxCurlFTP::Rename(const wxString& szRemoteLocName, + const wxString& szRemoteFile /*= wxEmptyString*/) +{ + if(m_pCURL) + { + SetCurlHandleToDefaults(szRemoteFile); + + wxString url(GetURL().c_str(), wxConvUTF8); + m_szCurrFullPath = url.BeforeLast('/'); + m_szCurrFullPath += wxS("/"); + m_szCurrFilename = url.AfterLast('/'); + + if(m_szCurrFilename.IsEmpty()) + return false; + + AppendPostQuote(wxS("RNFR ") + m_szCurrFilename, true); + AppendPostQuote(wxS("RNTO ") + szRemoteLocName); + + SetCurlHandleQuoteOpts(); + SetOpt(CURLOPT_NOBODY, TRUE); + + if(Perform()) + { + ResetAllQuoteLists(); + + return ((m_iResponseCode > 199) && (m_iResponseCode < 300)); + } + + ResetAllQuoteLists(); + } + + return false; +} + +bool wxCurlFTP::List(const wxString& szRemoteLoc /*= wxEmptyString*/) +{ + if(m_pCURL) + { + SetCurlHandleToDefaults(szRemoteLoc); + + SetOpt(CURLOPT_CUSTOMREQUEST, "LIST"); + SetStringWriteFunction(m_szResponseBody); + + if(Perform()) + { + return ((m_iResponseCode > 199) && (m_iResponseCode < 300)); + } + } + + return false; +} + +bool wxCurlFTP::Nlst(const wxString& szRemoteLoc /*= wxEmptyString*/) +{ + if(m_pCURL) + { + SetCurlHandleToDefaults(szRemoteLoc); + + SetOpt(CURLOPT_CUSTOMREQUEST, "NLST"); + SetStringWriteFunction(m_szResponseBody); + + if(Perform()) + { + return ((m_iResponseCode > 199) && (m_iResponseCode < 300)); + } + } + + return false; +} + +bool wxCurlFTP::Info(const wxString& szRemoteLoc /*= wxEmptyString*/) +{ + if(m_pCURL) + { + SetCurlHandleToDefaults(szRemoteLoc); + + SetOpt(CURLOPT_HEADER, TRUE); + SetOpt(CURLOPT_NOBODY, TRUE); + SetStringWriteFunction(m_szResponseBody); + + if(Perform()) + { + return ((m_iResponseCode > 199) && (m_iResponseCode < 299)); + } + } + + return false; +} + +////////////////////////////////////////////////////////////////////// +// Helper Methods +////////////////////////////////////////////////////////////////////// + +void wxCurlFTP::SetCurlHandleToDefaults(const wxString& relativeURL) +{ + wxCurlBase::SetCurlHandleToDefaults(relativeURL); + + m_szCurrFilename = wxEmptyString; + m_szCurrFullPath = wxEmptyString; + + if(m_bUsePortOption) + { + SetStringOpt(CURLOPT_FTPPORT, m_szPortParam); + } + + if(m_bUseEPRT) + { + SetOpt(CURLOPT_FTP_USE_EPRT, TRUE); + } + + if(m_bUseEPSV) + { + SetOpt(CURLOPT_FTP_USE_EPSV, TRUE); + } + + if(m_bCreateMissingDirs) + { + SetOpt(CURLOPT_FTP_CREATE_MISSING_DIRS, TRUE); + } + + if(m_bAppend) + { + SetOpt(CURLOPT_FTPAPPEND, TRUE); + } + + if(m_tmMode == kASCII) + { + SetOpt(CURLOPT_TRANSFERTEXT, TRUE); + } +} + +void wxCurlFTP::SetCurlHandleQuoteOpts() +{ + if(m_pQuote) + { + SetOpt(CURLOPT_QUOTE, m_pQuote); + } + + if(m_pPreQuote) + { + SetOpt(CURLOPT_PREQUOTE, m_pPreQuote); + } + + if(m_pPostQuote) + { + SetOpt(CURLOPT_POSTQUOTE, m_pPostQuote); + } +} + +void wxCurlFTP::ResetAllQuoteLists() +{ + ResetQuoteList(); + ResetPreQuoteList(); + ResetPostQuoteList(); +} + +void wxCurlFTP::ResetQuoteList() +{ + if(m_pQuote) + { + curl_slist_free_all(m_pQuote); + + m_pQuote = NULL; + + SetOpt(CURLOPT_QUOTE, NULL); + } +} + +void wxCurlFTP::ResetPreQuoteList() +{ + if(m_pPreQuote) + { + curl_slist_free_all(m_pPreQuote); + + m_pPreQuote = NULL; + + SetOpt(CURLOPT_PREQUOTE, NULL); + } +} + +void wxCurlFTP::ResetPostQuoteList() +{ + if(m_pPostQuote) + { + curl_slist_free_all(m_pPostQuote); + + m_pPostQuote = NULL; + + SetOpt(CURLOPT_POSTQUOTE, NULL); + } +} + + + diff --git a/src/ftpparse.cpp b/src/ftpparse.cpp new file mode 100644 index 0000000..a1d5a8a --- /dev/null +++ b/src/ftpparse.cpp @@ -0,0 +1,459 @@ +/* ftpparse.c, ftpparse.h: library for parsing FTP LIST responses +20001223 +D. J. Bernstein, djb@cr.yp.to +http://cr.yp.to/ftpparse.html + +Commercial use is fine, if you let me know what programs you're using this in. + +Currently covered formats: +EPLF. +UNIX ls, with or without gid. +Microsoft FTP Service. +Windows NT FTP Server. +VMS. +WFTPD. +NetPresenz (Mac). +NetWare. +MSDOS. + +Definitely not covered: +Long VMS filenames, with information split across two lines. +NCSA Telnet FTP server. Has LIST = NLST (and bad NLST for directories). +*/ + +#include "wx/wxprec.h" + +#ifndef WX_PRECOMP + #include "wx/wx.h" +#endif + +#ifdef __WXMSW__ + #include // useful to catch memory leaks when compiling under MSVC +#endif + +#include +#include "ftpparse.h" + +static long totai(long year,long month,long mday) +{ + long result; + if (month >= 2) month -= 2; + else { month += 10; --year; } + result = (mday - 1) * 10 + 5 + 306 * month; + result /= 10; + if (result == 365) { year -= 3; result = 1460; } + else result += 365 * (year % 4); + year /= 4; + result += 1461 * (year % 25); + year /= 25; + if (result == 36524) { year -= 3; result = 146096; } + else { result += 36524 * (year % 4); } + year /= 4; + result += 146097 * (year - 5); + result += 11017; + return result * 86400; +} + +static int flagneedbase = 1; +static time_t base; /* time() value on this OS at the beginning of 1970 TAI */ +static long now; /* current time */ +static int flagneedcurrentyear = 1; +static long currentyear; /* approximation to current year */ + +static void initbase(void) +{ + struct tm *t; + if (!flagneedbase) return; + + base = 0; + t = gmtime(&base); + base = -(totai(t->tm_year + 1900,t->tm_mon,t->tm_mday) + t->tm_hour * 3600 + t->tm_min * 60 + t->tm_sec); + /* assumes the right time_t, counting seconds. */ + /* base may be slightly off if time_t counts non-leap seconds. */ + flagneedbase = 0; +} + +static void initnow(void) +{ + long day; + long year; + + initbase(); + now = time((time_t *) 0) - base; + + if (flagneedcurrentyear) { + day = now / 86400; + if ((now % 86400) < 0) --day; + day -= 11017; + year = 5 + day / 146097; + day = day % 146097; + if (day < 0) { day += 146097; --year; } + year *= 4; + if (day == 146096) { year += 3; day = 36524; } + else { year += day / 36524; day %= 36524; } + year *= 25; + year += day / 1461; + day %= 1461; + year *= 4; + if (day == 1460) { year += 3; day = 365; } + else { year += day / 365; day %= 365; } + day *= 10; + if ((day + 5) / 306 >= 10) ++year; + currentyear = year; + flagneedcurrentyear = 0; + } +} + +/* UNIX ls does not show the year for dates in the last six months. */ +/* So we have to guess the year. */ +/* Apparently NetWare uses ``twelve months'' instead of ``six months''; ugh. */ +/* Some versions of ls also fail to show the year for future dates. */ +static long guesstai(long month,long mday) +{ + long year; + long t; + + initnow(); + + for (year = currentyear - 1;year < currentyear + 100;++year) { + t = totai(year,month,mday); + if (now - t < 350 * 86400) + return t; + } + + return 0; +} + +static int check(char *buf,const char *monthname) +{ + if ((buf[0] != monthname[0]) && (buf[0] != monthname[0] - 32)) return 0; + if ((buf[1] != monthname[1]) && (buf[1] != monthname[1] - 32)) return 0; + if ((buf[2] != monthname[2]) && (buf[2] != monthname[2] - 32)) return 0; + return 1; +} + +static const char *months[12] = { + "jan","feb","mar","apr","may","jun","jul","aug","sep","oct","nov","dec" +} ; + +static int getmonth(char *buf,int len) +{ + int i; + if (len == 3) + for (i = 0;i < 12;++i) + if (check(buf,months[i])) return i; + return -1; +} + +static long getlong(char *buf,int len) +{ + long u = 0; + while (len-- > 0) + u = u * 10 + (*buf++ - '0'); + return u; +} + +int ftpparse(struct ftpparse *fp,char *buf,int len) +{ + int i = 0; + int j = 0; + int state = 0; + long size = 0; + long year = 0; + long month = 0; + long mday = 0; + long hour = 0; + long minute = 0; + + fp->name = 0; + fp->namelen = 0; + fp->flagtrycwd = 0; + fp->flagtryretr = 0; + fp->sizetype = FTPPARSE_SIZE_UNKNOWN; + fp->size = 0; + fp->mtimetype = FTPPARSE_MTIME_UNKNOWN; + fp->mtime = 0; + fp->idtype = FTPPARSE_ID_UNKNOWN; + fp->id = 0; + fp->idlen = 0; + + if (len < 2) /* an empty name in EPLF, with no info, could be 2 chars */ + return 0; + + switch(*buf) { + /* see http://pobox.com/~djb/proto/eplf.txt */ + /* "+i8388621.29609,m824255902,/,\tdev" */ + /* "+i8388621.44468,m839956783,r,s10376,\tRFCEPLF" */ + case '+': + i = 1; + for (j = 1;j < len;++j) { + if (buf[j] == 9) { + fp->name = buf + j + 1; + fp->namelen = len - j - 1; + return 1; + } + if (buf[j] == ',') { + switch(buf[i]) { + case '/': + fp->flagtrycwd = 1; + break; + case 'r': + fp->flagtryretr = 1; + break; + case 's': + fp->sizetype = FTPPARSE_SIZE_BINARY; + fp->size = getlong(buf + i + 1,j - i - 1); + break; + case 'm': + fp->mtimetype = FTPPARSE_MTIME_LOCAL; + initbase(); + fp->mtime = base + getlong(buf + i + 1,j - i - 1); + break; + case 'i': + fp->idtype = FTPPARSE_ID_FULL; + fp->id = buf + i + 1; + fp->idlen = j - i - 1; + } + i = j + 1; + } + } + return 0; + + /* UNIX-style listing, without inum and without blocks */ + /* "-rw-r--r-- 1 root other 531 Jan 29 03:26 README" */ + /* "dr-xr-xr-x 2 root other 512 Apr 8 1994 etc" */ + /* "dr-xr-xr-x 2 root 512 Apr 8 1994 etc" */ + /* "lrwxrwxrwx 1 root other 7 Jan 25 00:17 bin -> usr/bin" */ + /* Also produced by Microsoft's FTP servers for Windows: */ + /* "---------- 1 owner group 1803128 Jul 10 10:18 ls-lR.Z" */ + /* "d--------- 1 owner group 0 May 9 19:45 Softlib" */ + /* Also WFTPD for MSDOS: */ + /* "-rwxrwxrwx 1 noone nogroup 322 Aug 19 1996 message.ftp" */ + /* Also NetWare: */ + /* "d [R----F--] supervisor 512 Jan 16 18:53 login" */ + /* "- [R----F--] rhesus 214059 Oct 20 15:27 cx.exe" */ + /* Also NetPresenz for the Mac: */ + /* "-------r-- 326 1391972 1392298 Nov 22 1995 MegaPhone.sit" */ + /* "drwxrwxr-x folder 2 May 10 1996 network" */ + case 'b': + case 'c': + case 'd': + case 'l': + case 'p': + case 's': + case '-': + + if (*buf == 'd') fp->flagtrycwd = 1; + if (*buf == '-') fp->flagtryretr = 1; + if (*buf == 'l') fp->flagtrycwd = fp->flagtryretr = 1; + + state = 1; + i = 0; + for (j = 1;j < len;++j) + if ((buf[j] == ' ') && (buf[j - 1] != ' ')) { + switch(state) { + case 1: /* skipping perm */ + state = 2; + break; + case 2: /* skipping nlink */ + state = 3; + if ((j - i == 6) && (buf[i] == 'f')) /* for NetPresenz */ + state = 4; + break; + case 3: /* skipping uid */ + state = 4; + break; + case 4: /* getting tentative size */ + size = getlong(buf + i,j - i); + state = 5; + break; + case 5: /* searching for month, otherwise getting tentative size */ + month = getmonth(buf + i,j - i); + if (month >= 0) + state = 6; + else + size = getlong(buf + i,j - i); + break; + case 6: /* have size and month */ + mday = getlong(buf + i,j - i); + state = 7; + break; + case 7: /* have size, month, mday */ + if ((j - i == 4) && (buf[i + 1] == ':')) { + hour = getlong(buf + i,1); + minute = getlong(buf + i + 2,2); + fp->mtimetype = FTPPARSE_MTIME_REMOTEMINUTE; + initbase(); + fp->mtime = base + guesstai(month,mday) + hour * 3600 + minute * 60; + } else if ((j - i == 5) && (buf[i + 2] == ':')) { + hour = getlong(buf + i,2); + minute = getlong(buf + i + 3,2); + fp->mtimetype = FTPPARSE_MTIME_REMOTEMINUTE; + initbase(); + fp->mtime = base + guesstai(month,mday) + hour * 3600 + minute * 60; + } + else if (j - i >= 4) { + year = getlong(buf + i,j - i); + fp->mtimetype = FTPPARSE_MTIME_REMOTEDAY; + initbase(); + fp->mtime = base + totai(year,month,mday); + } + else + return 0; + fp->name = buf + j + 1; + fp->namelen = len - j - 1; + state = 8; + break; + case 8: /* twiddling thumbs */ + break; + } + i = j + 1; + while ((i < len) && (buf[i] == ' ')) ++i; + } + + if (state != 8) + return 0; + + fp->size = size; + fp->sizetype = FTPPARSE_SIZE_BINARY; + + if (*buf == 'l') + for (i = 0;i + 3 < fp->namelen;++i) + if (fp->name[i] == ' ') + if (fp->name[i + 1] == '-') + if (fp->name[i + 2] == '>') + if (fp->name[i + 3] == ' ') { + fp->namelen = i; + break; + } + + /* eliminate extra NetWare spaces */ + if ((buf[1] == ' ') || (buf[1] == '[')) + if (fp->namelen > 3) + if (fp->name[0] == ' ') + if (fp->name[1] == ' ') + if (fp->name[2] == ' ') { + fp->name += 3; + fp->namelen -= 3; + } + + return 1; + } + + /* MultiNet (some spaces removed from examples) */ + /* "00README.TXT;1 2 30-DEC-1996 17:44 [SYSTEM] (RWED,RWED,RE,RE)" */ + /* "CORE.DIR;1 1 8-SEP-1996 16:09 [SYSTEM] (RWE,RWE,RE,RE)" */ + /* and non-MutliNet VMS: */ + /* "CII-MANUAL.TEX;1 213/216 29-JAN-1996 03:33:12 [ANONYMOU,ANONYMOUS] (RWED,RWED,,)" */ + for (i = 0;i < len;++i) + if (buf[i] == ';') + break; + if (i < len) { + fp->name = buf; + fp->namelen = i; + if (i > 4) + if (buf[i - 4] == '.') + if (buf[i - 3] == 'D') + if (buf[i - 2] == 'I') + if (buf[i - 1] == 'R') { + fp->namelen -= 4; + fp->flagtrycwd = 1; + } + if (!fp->flagtrycwd) + fp->flagtryretr = 1; + while (buf[i] != ' ') if (++i == len) return 0; + while (buf[i] == ' ') if (++i == len) return 0; + while (buf[i] != ' ') if (++i == len) return 0; + while (buf[i] == ' ') if (++i == len) return 0; + j = i; + while (buf[j] != '-') if (++j == len) return 0; + mday = getlong(buf + i,j - i); + while (buf[j] == '-') if (++j == len) return 0; + i = j; + while (buf[j] != '-') if (++j == len) return 0; + month = getmonth(buf + i,j - i); + if (month < 0) return 0; + while (buf[j] == '-') if (++j == len) return 0; + i = j; + while (buf[j] != ' ') if (++j == len) return 0; + year = getlong(buf + i,j - i); + while (buf[j] == ' ') if (++j == len) return 0; + i = j; + while (buf[j] != ':') if (++j == len) return 0; + hour = getlong(buf + i,j - i); + while (buf[j] == ':') if (++j == len) return 0; + i = j; + while ((buf[j] != ':') && (buf[j] != ' ')) if (++j == len) return 0; + minute = getlong(buf + i,j - i); + + fp->mtimetype = FTPPARSE_MTIME_REMOTEMINUTE; + initbase(); + fp->mtime = base + totai(year,month,mday) + hour * 3600 + minute * 60; + + return 1; + } + + /* MSDOS format */ + /* 04-27-00 09:09PM licensed */ + /* 07-18-00 10:16AM pub */ + /* 04-14-00 03:47PM 589 readme.htm */ + if ((*buf >= '0') && (*buf <= '9')) { + i = 0; + j = 0; + while (buf[j] != '-') if (++j == len) return 0; + month = getlong(buf + i,j - i) - 1; + while (buf[j] == '-') if (++j == len) return 0; + i = j; + while (buf[j] != '-') if (++j == len) return 0; + mday = getlong(buf + i,j - i); + while (buf[j] == '-') if (++j == len) return 0; + i = j; + while (buf[j] != ' ') if (++j == len) return 0; + year = getlong(buf + i,j - i); + if (year < 50) year += 2000; + if (year < 1000) year += 1900; + while (buf[j] == ' ') if (++j == len) return 0; + i = j; + while (buf[j] != ':') if (++j == len) return 0; + hour = getlong(buf + i,j - i); + while (buf[j] == ':') if (++j == len) return 0; + i = j; + while ((buf[j] != 'A') && (buf[j] != 'P')) if (++j == len) return 0; + minute = getlong(buf + i,j - i); + if (hour == 12) hour = 0; + if (buf[j] == 'A') if (++j == len) return 0; + if (buf[j] == 'P') { hour += 12; if (++j == len) return 0; } + if (buf[j] == 'M') if (++j == len) return 0; + + while (buf[j] == ' ') if (++j == len) return 0; + if (buf[j] == '<') { + fp->flagtrycwd = 1; + while (buf[j] != ' ') if (++j == len) return 0; + } + else { + i = j; + while (buf[j] != ' ') if (++j == len) return 0; + fp->size = getlong(buf + i,j - i); + fp->sizetype = FTPPARSE_SIZE_BINARY; + fp->flagtryretr = 1; + } + while (buf[j] == ' ') if (++j == len) return 0; + + fp->name = buf + j; + fp->namelen = len - j; + + fp->mtimetype = FTPPARSE_MTIME_REMOTEMINUTE; + initbase(); + fp->mtime = base + totai(year,month,mday) + hour * 3600 + minute * 60; + + return 1; + } + + /* Some useless lines, safely ignored: */ + /* "Total of 11 Files, 10966 Blocks." (VMS) */ + /* "total 14786" (UNIX) */ + /* "DISK$ANONFTP:[ANONYMOUS]" (VMS) */ + /* "Directory DISK$PCSA:[ANONYM]" (VMS) */ + + return 0; +} diff --git a/src/ftpparse.h b/src/ftpparse.h new file mode 100644 index 0000000..a86bb17 --- /dev/null +++ b/src/ftpparse.h @@ -0,0 +1,51 @@ +#ifndef FTPPARSE_H +#define FTPPARSE_H + +/* +ftpparse(&fp,buf,len) tries to parse one line of LIST output. + +The line is an array of len characters stored in buf. +It should not include the terminating CR LF; so buf[len] is typically CR. + +If ftpparse() can't find a filename, it returns 0. + +If ftpparse() can find a filename, it fills in fp and returns 1. +fp is a struct ftpparse, defined below. +The name is an array of fp.namelen characters stored in fp.name; +fp.name points somewhere within buf. +*/ + +struct ftpparse { + char *name; /* not necessarily 0-terminated */ + int namelen; + int flagtrycwd; /* 0 if cwd is definitely pointless, 1 otherwise */ + int flagtryretr; /* 0 if retr is definitely pointless, 1 otherwise */ + int sizetype; + long size; /* number of octets */ + int mtimetype; + time_t mtime; /* modification time */ + int idtype; + char *id; /* not necessarily 0-terminated */ + int idlen; +} ; + +#define FTPPARSE_SIZE_UNKNOWN 0 +#define FTPPARSE_SIZE_BINARY 1 /* size is the number of octets in TYPE I */ +#define FTPPARSE_SIZE_ASCII 2 /* size is the number of octets in TYPE A */ + +#define FTPPARSE_MTIME_UNKNOWN 0 +#define FTPPARSE_MTIME_LOCAL 1 /* time is correct */ +#define FTPPARSE_MTIME_REMOTEMINUTE 2 /* time zone and secs are unknown */ +#define FTPPARSE_MTIME_REMOTEDAY 3 /* time zone and time of day are unknown */ +/* +When a time zone is unknown, it is assumed to be GMT. You may want +to use localtime() for LOCAL times, along with an indication that the +time is correct in the local time zone, and gmtime() for REMOTE* times. +*/ + +#define FTPPARSE_ID_UNKNOWN 0 +#define FTPPARSE_ID_FULL 1 /* unique identifier for files on this FTP server */ + +int ftpparse(struct ftpparse *,char *,int); + +#endif diff --git a/src/ftptool.cpp b/src/ftptool.cpp new file mode 100644 index 0000000..a27a09c --- /dev/null +++ b/src/ftptool.cpp @@ -0,0 +1,213 @@ +/* + * ftptool.cpp + * wxCURL + * + * Created by Casey O'Donnell on Fri Aug 13 2004. + * Copyright (c) 2004 Casey O'Donnell. All rights reserved. + * + * wxCurlFTPTool makes use of ftpparse, a set of C functions + * created by D. J. Bernstein (djb@cr.yp.to). The original + * site for these functions can be found at: + * http://cr.yp.to/ftpparse.html + * + * Licence: wxWidgets Licence + */ + +////////////////////////////////////////////////////////////////////// +// Headers +////////////////////////////////////////////////////////////////////// + +#include "wx/wxprec.h" + +#ifndef WX_PRECOMP + #include "wx/wx.h" +#endif + +#ifdef __WXMSW__ + #include // useful to catch memory leaks when compiling under MSVC +#endif + +#include + +#include +#include +#include + +#include "ftpparse.h" + +////////////////////////////////////////////////////////////////////// +// C Functions for LibCURL +////////////////////////////////////////////////////////////////////// +extern "C" +{ +} + +// davtool.cpp: implementation of the wxCurlFTPFs class. +// +////////////////////////////////////////////////////////////////////// + +////////////////////////////////////////////////////////////////////// +// Construction/Destruction +////////////////////////////////////////////////////////////////////// + +wxCurlFTPFs::wxCurlFTPFs() +: m_iContentLength(0) +{ + m_bIsDir = false; + m_bIsFile = false; +} + +wxCurlFTPFs::wxCurlFTPFs(const wxString& szName , + const bool& bIsDir , + const bool& bIsFile , + const time_t& tLastModified , + const long& iContentLength ) +: m_szName(szName), m_bIsDir(bIsDir), m_bIsFile(bIsFile), +m_dtLastModified(tLastModified), m_iContentLength(iContentLength) +{ +} + +wxCurlFTPFs::~wxCurlFTPFs() +{ +} + +// ftptool.cpp: implementation of the wxCurlFTPTool class. +// +////////////////////////////////////////////////////////////////////// + +////////////////////////////////////////////////////////////////////// +// Construction/Destruction +////////////////////////////////////////////////////////////////////// + +wxCurlFTPTool::wxCurlFTPTool(const wxString& szURL /*= wxEmptyString*/, + const wxString& szUserName /*= wxEmptyString*/, + const wxString& szPassword /*= wxEmptyString*/, + wxEvtHandler* pEvtHandler /*= NULL*/, + int id /*= wxID_ANY*/, + long flags/*= wxCURL_DEFAULT_FLAGS*/) +: wxCurlFTP(szURL, szUserName, szPassword, pEvtHandler, id, flags) +{ +} + +wxCurlFTPTool::~wxCurlFTPTool() +{ +} + +////////////////////////////////////////////////////////////////////// +// Member Data Access Methods +////////////////////////////////////////////////////////////////////// + +////////////////////////////////////////////////////////////////////// +// Action Methods +////////////////////////////////////////////////////////////////////// + +bool wxCurlFTPTool::GetFTPFs(wxArrayFTPFs& fs, const wxString& szRemoteLoc /*= wxEmptyString*/) + +{ + if(List(szRemoteLoc)) + { + wxString str = wxCURL_BUF2STRING(m_szResponseBody); + wxStringInputStream inStream(str); + + if(inStream.IsOk()) + { + wxTextInputStream txtInStream(inStream); + for(;;) + { + wxString szCurrentLine = txtInStream.ReadLine(); + if(szCurrentLine.empty()) + break; + + wxCharBuffer buf(szCurrentLine.mb_str()); + + struct ftpparse ftppItem; + if(ftpparse(&ftppItem, buf.data(), strlen(buf)) != 0) + { + fs.Add(wxCurlFTPFs(wxString(ftppItem.name, wxConvLibc), + (ftppItem.flagtrycwd == 1),(ftppItem.flagtryretr == 1), + ftppItem.mtime,ftppItem.size)); + } + } + + return true; + } + } + + return false; +} + +bool wxCurlFTPTool::Exists(const wxString& szRemoteLoc /*= wxEmptyString*/) +{ + wxArrayFTPFs arrFs; + + if(GetFTPFs(arrFs, szRemoteLoc)) + { + return true; + } + + return false; +} + +bool wxCurlFTPTool::IsDirectory(const wxString& szRemoteLoc /*= wxEmptyString*/) +{ + wxArrayFTPFs arrFs; + + if(GetFTPFs(arrFs, szRemoteLoc)) + { + if(arrFs.Count() > 1) + return true; + } + + return false; +} + +wxDateTime wxCurlFTPTool::GetLastModified(const wxString& szRemoteLoc /*= wxEmptyString*/) +{ + wxArrayFTPFs arrFs; + + if(GetFTPFs(arrFs, szRemoteLoc)) + { + return arrFs.Last().GetLastModified(); + } + + return wxDateTime(); +} + +long wxCurlFTPTool::GetContentLength(const wxString& szRemoteLoc /*= wxEmptyString*/) +{ + wxArrayFTPFs arrFs; + + if(GetFTPFs(arrFs, szRemoteLoc)) + { + return arrFs.Last().GetContentLength(); + } + + return -1; +} + +wxString wxCurlFTPTool::GetFileSuffix(const wxString& szRemoteLoc /*= wxEmptyString*/) +{ + wxArrayFTPFs arrFs; + + if(GetFTPFs(arrFs, szRemoteLoc)) + { + return arrFs.Last().GetFileSuffix(); + } + + return wxEmptyString; +} + +////////////////////////////////////////////////////////////////////// +// Helper Methods +////////////////////////////////////////////////////////////////////// + +////////////////////////////////////////////////////////////////////// +// wxArrayDAVFs Implementation +////////////////////////////////////////////////////////////////////// +#include // this is a magic incantation which must be done! +WX_DEFINE_USER_EXPORTED_OBJARRAY(wxArrayFTPFs); + + + + + diff --git a/src/http.cpp b/src/http.cpp new file mode 100644 index 0000000..52fbdbc --- /dev/null +++ b/src/http.cpp @@ -0,0 +1,396 @@ +/* +* http.cpp +* wxCURL +* +* Created by Casey O'Donnell on Tue Jun 29 2004. +* Copyright (c) 2004 Casey O'Donnell. All rights reserved. +* +* +* Licence: wxWidgets Licence +*/ + +// http.cpp: implementation of the wxCurlHTTP class. +// +////////////////////////////////////////////////////////////////////// + +////////////////////////////////////////////////////////////////////// +// Headers +////////////////////////////////////////////////////////////////////// + +#include "wx/wxprec.h" + +#ifndef WX_PRECOMP + #include "wx/wx.h" +#endif + +#ifdef __WXMSW__ + #include // useful to catch memory leaks when compiling under MSVC +#endif + +#include +#include + +#include + +////////////////////////////////////////////////////////////////////// +// C Functions for LibCURL +////////////////////////////////////////////////////////////////////// +extern "C" +{ +} + +////////////////////////////////////////////////////////////////////// +// Construction/Destruction +////////////////////////////////////////////////////////////////////// + +wxCurlHTTP::wxCurlHTTP(const wxString& szURL /*= wxEmptyString*/, + const wxString& szUserName /*= wxEmptyString*/, + const wxString& szPassword /*= wxEmptyString*/, + wxEvtHandler* pEvtHandler /*= NULL*/, + int id /*= wxID_ANY*/, + long flags /*= wxCURL_DEFAULT_FLAGS*/) +: wxCurlBase(szURL, szUserName, szPassword, pEvtHandler, id, flags), +m_pPostHead(NULL), m_pPostTail(NULL), m_bUseCookies(false), m_szCookieFile("-"), +m_pszPostFieldsData(NULL), m_iPostDataSize(0) +{ +} + +wxCurlHTTP::~wxCurlHTTP() +{ + ResetPostData(); +} + +bool wxCurlHTTP::IsResponseOk() const +{ + return ((m_iResponseCode > 199) && (m_iResponseCode < 300)); +} + +////////////////////////////////////////////////////////////////////// +// Member Data Access Methods +////////////////////////////////////////////////////////////////////// + +void wxCurlHTTP::UseCookies(const bool& bUseCookies) +{ + m_bUseCookies = bUseCookies; +} + +bool wxCurlHTTP::UseCookies() const +{ + return m_bUseCookies; +} + +void wxCurlHTTP::SetCookieFile(const wxString& szFilePath) +{ + m_szCookieFile = wxCURL_STRING2BUF(szFilePath); +} + +wxString wxCurlHTTP::GetCookieFile() const +{ + return wxCURL_BUF2STRING(m_szCookieFile); +} + +////////////////////////////////////////////////////////////////////// +// Post Data Methods +////////////////////////////////////////////////////////////////////// + +bool wxCurlHTTP::AddForm(const bool& bClear, const wxString& szName, + struct curl_forms* pForms, CURLFORMcode* outErr) +{ + if(bClear) + ResetPostData(); + + CURLFORMcode res = CURL_FORMADD_OK; + + res = curl_formadd(&m_pPostHead, &m_pPostTail, CURLFORM_COPYNAME, + (const char*)szName.ToAscii(), + CURLFORM_ARRAY, pForms, CURLFORM_END); + + if (outErr != NULL) + *outErr = res; // sometimes you want to/need to see what's going on + + return (res == CURL_FORMADD_OK); +} + +bool wxCurlHTTP::AddBufferToForm(const bool& bClear, const wxString& szName, + char* buffer, size_t len, CURLFORMcode* outErr) +{ + if(bClear) + ResetPostData(); + + CURLFORMcode res = CURL_FORMADD_OK; + + res = curl_formadd(&m_pPostHead, &m_pPostTail, CURLFORM_COPYNAME, + (const char*)szName.ToAscii(), + CURLFORM_COPYCONTENTS, buffer, CURLFORM_CONTENTSLENGTH, + len, CURLFORM_END); + + if (outErr != NULL) + *outErr = res; // sometimes you want to/need to see what's going on + + return (res == CURL_FORMADD_OK); + + +} + +////////////////////////////////////////////////////////////////////// +// Action Methods +////////////////////////////////////////////////////////////////////// + +bool wxCurlHTTP::Options(const wxString& szRemoteFile /*= wxEmptyString*/) +{ + if(m_pCURL) + { + SetCurlHandleToDefaults(szRemoteFile); + + SetOpt(CURLOPT_CUSTOMREQUEST, "OPTIONS"); + SetStringWriteFunction(m_szResponseBody); + + if(Perform()) + { + return IsResponseOk(); + } + } + + return false; +} + +bool wxCurlHTTP::Head(const wxString& szRemoteFile /*= wxEmptyString*/) +{ + if(m_pCURL) + { + SetCurlHandleToDefaults(szRemoteFile); + + SetOpt(CURLOPT_HTTPGET, TRUE); + SetOpt(CURLOPT_NOBODY, TRUE); + + if(Perform()) + { + return IsResponseOk(); + } + } + + return false; +} + +bool wxCurlHTTP::Post(const char* buffer, size_t size, const wxString& szRemoteFile /*= wxEmptyString*/) +{ + wxMemoryInputStream inStream(buffer, size); + + return Post(inStream, szRemoteFile); +} + +bool wxCurlHTTP::Post(wxInputStream& buffer, const wxString& szRemoteFile /*= wxEmptyString*/) +{ + curl_off_t iSize = 0; + + if(m_pCURL && buffer.IsOk()) + { + SetCurlHandleToDefaults(szRemoteFile); + + SetHeaders(); + iSize = buffer.GetSize(); + + if(iSize == (~(ssize_t)0)) // wxCurlHTTP does not know how to upload unknown length streams. + return false; + + SetOpt(CURLOPT_POST, TRUE); + SetOpt(CURLOPT_POSTFIELDSIZE_LARGE, iSize); + SetStreamReadFunction(buffer); + SetStringWriteFunction(m_szResponseBody); + + if(Perform()) + { + ResetHeaders(); + return IsResponseOk(); + } + } + + return false; +} + +bool wxCurlHTTP::Post(const wxString& szRemoteFile /*= wxEmptyString*/) +{ + if(m_pCURL && m_pPostHead && m_pPostTail) + { + SetCurlHandleToDefaults(szRemoteFile); + + SetOpt(CURLOPT_POST, TRUE); + SetOpt(CURLOPT_HTTPPOST, m_pPostHead); + SetStringWriteFunction(m_szResponseBody); + + if(Perform()) + { + return IsResponseOk(); + } + } + + return false; +} + +bool wxCurlHTTP::Trace(const wxString& szRemoteFile /*= wxEmptyString*/) +{ + if(m_pCURL) + { + SetCurlHandleToDefaults(szRemoteFile); + + m_arrHeaders.Add(wxS("Content-type: message/http")); + + SetHeaders(); + + SetOpt(CURLOPT_CUSTOMREQUEST, "TRACE"); + SetStringWriteFunction(m_szResponseBody); + + if(Perform()) + { + ResetHeaders(); + + return IsResponseOk(); + } + + ResetHeaders(); + } + + return false; +} + +bool wxCurlHTTP::Get(const wxString& szFilePath, const wxString& szRemoteFile /*= wxEmptyString*/) +{ + wxFFileOutputStream outStream(szFilePath); + + return Get(outStream, szRemoteFile); +} + +size_t wxCurlHTTP::Get(char*& buffer, const wxString& szRemoteFile /*= wxEmptyString*/) +{ + wxMemoryOutputStream outStream; + + buffer = NULL; + size_t iRetVal = 0; + + if(Get(outStream, szRemoteFile)) + { + iRetVal = outStream.GetSize(); + buffer = (char*)malloc(iRetVal + 1); + + if(buffer) + { + outStream.CopyTo(buffer, outStream.GetSize()); + buffer[iRetVal] = '\0'; + return iRetVal; + } + + free(buffer); + buffer = NULL; + } + + return 0; +} + +bool wxCurlHTTP::Get(wxOutputStream& buffer, const wxString& szRemoteFile /*=wxEmptyString*/) +{ + if(m_pCURL && buffer.IsOk()) + { + SetCurlHandleToDefaults(szRemoteFile); + + SetHeaders(); + SetOpt(CURLOPT_HTTPGET, TRUE); + SetStreamWriteFunction(buffer); + + if(Perform()) + { + ResetHeaders(); + return IsResponseOk(); + } + } + + return false; +} + +bool wxCurlHTTP::Put(const wxString& szFilePath, const wxString& szRemoteFile /*= wxEmptyString*/) +{ + wxFFileInputStream inStream(szFilePath); + + return Put(inStream, szRemoteFile); +} + +bool wxCurlHTTP::Put(const char* buffer, size_t size, const wxString& szRemoteFile /*= wxEmptyString*/) +{ + wxMemoryInputStream inStream(buffer, size); + + return Put(inStream, szRemoteFile); +} + +bool wxCurlHTTP::Put(wxInputStream& buffer, const wxString& szRemoteFile /*= wxEmptyString*/) +{ + curl_off_t iSize = 0; + + if(m_pCURL && buffer.IsOk()) + { + SetCurlHandleToDefaults(szRemoteFile); + + iSize = buffer.GetSize(); + + if(iSize == (~(ssize_t)0)) // wxCurlHTTP does not know how to upload unknown length streams. + return false; + + SetOpt(CURLOPT_UPLOAD, TRUE); + SetOpt(CURLOPT_PUT, TRUE); + SetStreamReadFunction(buffer); + SetOpt(CURLOPT_INFILESIZE_LARGE, (curl_off_t)iSize); + SetStringWriteFunction(m_szResponseBody); + + if(Perform()) + { + return IsResponseOk(); + } + } + + return false; +} + +bool wxCurlHTTP::Delete(const wxString& szRemoteLoc /*= wxEmptyString*/) +{ + if(m_pCURL) + { + SetCurlHandleToDefaults(szRemoteLoc); + + SetOpt(CURLOPT_CUSTOMREQUEST, "DELETE"); + SetStringWriteFunction(m_szResponseBody); + + if(Perform()) + { + return IsResponseOk(); + } + } + + return false; +} + +////////////////////////////////////////////////////////////////////// +// Helper Methods +////////////////////////////////////////////////////////////////////// + +void wxCurlHTTP::ResetPostData() +{ + m_pszPostFieldsData = NULL; + m_iPostDataSize = 0; + + if(m_pPostHead && m_pPostTail) + { + curl_formfree(m_pPostHead); + + m_pPostHead = NULL; + m_pPostTail = NULL; + } +} + +void wxCurlHTTP::SetCurlHandleToDefaults(const wxString& relativeURL) +{ + wxCurlBase::SetCurlHandleToDefaults(relativeURL); + + if(m_bUseCookies) + { + SetStringOpt(CURLOPT_COOKIEJAR, m_szCookieFile); + } +} + diff --git a/src/panel.cpp b/src/panel.cpp new file mode 100644 index 0000000..bdee4b7 --- /dev/null +++ b/src/panel.cpp @@ -0,0 +1,211 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: panel.cpp +// Purpose: wxCurlConnectionSettingsPanel +// Author: Francesco Montorsi +// Created: 2007/05/5 +// RCS-ID: $Id: panel.cpp 1240 2010-03-10 23:54:25Z frm $ +// Copyright: (c) 2007 Francesco Montorsi +// Licence: wxWidgets licence +///////////////////////////////////////////////////////////////////////////// + + +// For compilers that support precompilation, includes "wx.h". +#include "wx/wxprec.h" + +#ifdef __BORLANDC__ +#pragma hdrstop +#endif + +// includes +#ifndef WX_PRECOMP + #include + #include // for _() support + #include // for wxMilliSleep + + #if wxUSE_GUI + #include + #include + #include + #include + #include + #include + #include + #include + #endif +#endif + +#ifdef __WXMSW__ + #include // useful to catch memory leaks when compiling under MSVC +#endif + +#include +#include +#include +#include "wx/curl/panel.h" + + +// ---------------------------------------------------------------------------- +// wxCurlConnectionSettingsPanel +// ---------------------------------------------------------------------------- + +enum +{ + UseProxy = wxID_HIGHEST+1 +}; + +IMPLEMENT_DYNAMIC_CLASS( wxCurlConnectionSettingsPanel, wxPanel ) +BEGIN_EVENT_TABLE( wxCurlConnectionSettingsPanel, wxPanel ) + EVT_CHECKBOX( UseProxy, wxCurlConnectionSettingsPanel::OnUseProxy ) +END_EVENT_TABLE() + +bool wxCurlConnectionSettingsPanel::Create(wxWindow* parent, wxWindowID id, + const wxString &msg, + const wxPoint& pos, const wxSize& size, + long style, const wxString& name) +{ + if (!wxPanel::Create(parent, id, pos, size, style, name)) + return false; + + // set up our controls + CreateControls(msg); + + if (GetMinSize().GetWidth() < 250) + SetMinSize(wxSize(250, -1)); + + return true; +} + +#define BORDER 5 + +wxTextCtrl *wxCurlConnectionSettingsPanel::AddSizerRow(wxSizer *sz, const wxString &name, bool grow) +{ + // the static text + wxStaticText *st = new wxStaticText( this, wxID_STATIC, name, wxDefaultPosition, wxDefaultSize ); + + // the value + wxTextCtrl *ret = new wxTextCtrl( this, wxID_ANY ); + + long flags = wxALIGN_CENTER_VERTICAL|wxTOP|wxRIGHT; + sz->Add(st, 0, flags, BORDER); + sz->Add(ret, 1, grow ? flags|wxGROW : flags, BORDER); + + return ret; +} + +void wxCurlConnectionSettingsPanel::CreateControls(const wxString &msg) +{ + wxBoxSizer* main = new wxBoxSizer(wxVERTICAL); + + // message row + if (!msg.IsEmpty()) + { + wxStaticText *st = new wxStaticText( this, wxID_STATIC, msg ); + main->Add(st, 0, wxLEFT|wxTOP|wxRIGHT|wxBOTTOM|wxGROW, BORDER); + } + + wxFlexGridSizer *gs = new wxFlexGridSizer(0 /* calc automatically the # of rows */, 2, 0, 0); + + // authentication options + if (HasFlag(wxCCSP_AUTHENTICATION_OPTIONS)) + { + m_pUsername = AddSizerRow(gs, _("Username:")); + m_pPassword = AddSizerRow(gs, _("Password:")); + gs->AddStretchSpacer(1); + gs->AddStretchSpacer(1); + } + + // port options + if (HasFlag(wxCCSP_PORT_OPTION)) + { + m_pPort = AddSizerRow(gs, _("Port:"), false); + gs->AddStretchSpacer(1); + gs->AddStretchSpacer(1); + + m_pPort->SetValue(wxS("-1")); + } + + // column 1 contains the text controls: + gs->AddGrowableCol(1); + main->Add(gs, 1, wxGROW|wxALL, BORDER); + + // proxy options + if (HasFlag(wxCCSP_PROXY_OPTIONS)) + { + wxSizer* proxy = new wxStaticBoxSizer(wxVERTICAL, this, _("Proxy settings")); + + m_pProxyCheckBox = new wxCheckBox(this, UseProxy, _("Use proxy")); + m_pProxyCheckBox->SetValue(false); + proxy->Add(m_pProxyCheckBox, 0, wxLEFT|wxTOP, BORDER); + + wxFlexGridSizer *gs = new wxFlexGridSizer(0 /* calc automatically the # of rows */, 2, 0, 0); + m_pProxyHost = AddSizerRow(gs, _("Proxy host:")); + m_pProxyUsername = AddSizerRow(gs, _("Proxy username:")); + m_pProxyPassword = AddSizerRow(gs, _("Proxy password:")); + m_pProxyPort = AddSizerRow(gs, _("Proxy port:"), false); + m_pProxyPort->SetValue(wxS("-1")); + proxy->Add(gs, 0, wxGROW|wxALL, BORDER); + + // column 1 contains the text controls: + gs->AddGrowableCol(1); + + main->AddSpacer(10); + main->Add(proxy, 0, wxGROW|wxLEFT|wxRIGHT, BORDER); +#if wxCHECK_VERSION(2,9,0) + main->AddStretchSpacer(1); +#endif + + // be default disable the proxy controls + wxCommandEvent fake; + fake.SetInt(0); + OnUseProxy(fake); + } + + this->SetSizerAndFit(main); + main->SetSizeHints(this); +} + +void wxCurlConnectionSettingsPanel::SetCURLOptions(wxCurlBase *p) +{ + wxASSERT(p); + + if (HasFlag(wxCCSP_PORT_OPTION)) + { + long port = -1; // -1 tell libCURL to use the default port + m_pPort->GetValue().ToLong(&port); + p->SetPort(port); + } + + if (HasFlag(wxCCSP_AUTHENTICATION_OPTIONS)) + { + p->SetUsername(m_pUsername->GetValue()); + p->SetPassword(m_pPassword->GetValue()); + } + + if (HasFlag(wxCCSP_PROXY_OPTIONS)) + { + p->UseProxy(m_pProxyCheckBox->GetValue()); + + p->SetProxyHost(m_pProxyHost->GetValue()); + p->SetProxyUsername(m_pProxyUsername->GetValue()); + p->SetProxyPassword(m_pProxyPassword->GetValue()); + + long port = -1; // -1 tell libCURL to use the default port + m_pProxyPort->GetValue().ToLong(&port); + p->SetProxyPort(port); + } +} + + +// ---------------------------------------------------------------------------- +// wxCurlConnectionSettingsPanel - button events +// ---------------------------------------------------------------------------- + +void wxCurlConnectionSettingsPanel::OnUseProxy(wxCommandEvent &ev) +{ + m_pProxyHost->Enable(ev.IsChecked()); + m_pProxyUsername->Enable(ev.IsChecked()); + m_pProxyPassword->Enable(ev.IsChecked()); + m_pProxyPort->Enable(ev.IsChecked()); +} + + diff --git a/src/telnet.cpp b/src/telnet.cpp new file mode 100644 index 0000000..4a2041b --- /dev/null +++ b/src/telnet.cpp @@ -0,0 +1,44 @@ +/* + * telnet.cpp + * wxCURL + * + * Created by Casey O'Donnell on Tue Jun 29 2004. + * Copyright (c) 2004 Casey O'Donnell. All rights reserved. + * + * + * Licence: wxWidgets Licence + */ + +// telnet.cpp: implementation of the wxCurlTelnet class. +// +////////////////////////////////////////////////////////////////////// + +////////////////////////////////////////////////////////////////////// +// Headers +////////////////////////////////////////////////////////////////////// + +#include "wx/wxprec.h" + +#ifndef WX_PRECOMP + #include "wx/wx.h" +#endif + +#ifdef __WXMSW__ + #include // useful to catch memory leaks when compiling under MSVC +#endif + +#include + +////////////////////////////////////////////////////////////////////// +// Construction/Destruction +////////////////////////////////////////////////////////////////////// + +wxCurlTelnet::wxCurlTelnet() +{ + +} + +wxCurlTelnet::~wxCurlTelnet() +{ + +} diff --git a/src/thread.cpp b/src/thread.cpp new file mode 100644 index 0000000..66dd99c --- /dev/null +++ b/src/thread.cpp @@ -0,0 +1,363 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: thread.cpp +// Purpose: wxCurlDownloadThread, wxCurlUploadThread +// Author: Francesco Montorsi +// Created: 2007/04/14 +// RCS-ID: $Id: thread.cpp 1240 2010-03-10 23:54:25Z frm $ +// Copyright: (c) 2007 Francesco Montorsi +// Licence: wxWidgets licence +///////////////////////////////////////////////////////////////////////////// + + +// For compilers that support precompilation, includes "wx.h". +#include "wx/wxprec.h" + +#ifdef __BORLANDC__ +#pragma hdrstop +#endif + +// includes +#ifndef WX_PRECOMP + #include +#endif + +#ifdef __WXMSW__ + #include // useful to catch memory leaks when compiling under MSVC +#endif + +#include +#include + +#include "wx/curl/thread.h" +#include "wx/curl/http.h" +#include "wx/curl/ftp.h" + + +// --------------------- +// wxCurlBaseThread +// --------------------- + +/* static */ +wxCurlProtocol wxCurlBaseThread::GetProtocolFromURL(const wxString &url) +{ + // I'm sure this check could be done in a better way... + if (url.StartsWith(wxS("http:")) || url.StartsWith(wxS("https:"))) + return wxCP_HTTP; + if (url.StartsWith(wxS("ftp:")) || url.StartsWith(wxS("ftps:"))) + return wxCP_FTP; + return wxCP_INVALID; +} + +/* static */ +wxCurlBase *wxCurlBaseThread::CreateHandlerFor(wxCurlProtocol prot) +{ + switch (prot) + { + case wxCP_HTTP: + return new wxCurlHTTP; + case wxCP_FTP: + return new wxCurlFTP; + + default: + return NULL; + } +} + +wxCurlThreadError wxCurlBaseThread::SetURL(const wxString &url) +{ + wxCHECK_MSG(!IsAlive(), wxCTE_NO_RESOURCE, wxS("Cannot use this function after the tranfer has begun")); + + // which protocol is required by given url? + wxCurlProtocol curr = GetProtocolFromURL(url); + if (curr == wxCP_INVALID) + return wxCTE_INVALID_PROTOCOL; + + if (curr != m_protocol) + { + m_protocol = curr; + + // we need to (re)create the m_pCurl object + wxDELETE(m_pCurl); + m_pCurl = CreateHandlerFor(m_protocol); + } + + if (!m_pCurl || !m_pCurl->IsOk()) + return wxCTE_INVALID_PROTOCOL; + + // enable event sending (it's the only way the wxCurlDownloadThread user can + // receive info about the progress of the transfer) + m_pCurl->SetEvtHandler(GetEvtHandler(), GetId()); + m_pCurl->SetFlags(wxCURL_SEND_PROGRESS_EVENTS | wxCURL_SEND_BEGINEND_EVENTS); + + m_url = url; + + return wxCTE_NO_ERROR; +} + +void wxCurlBaseThread::OnExit() +{ + if (m_pCurl->IsVerbose()) + wxLogDebug(wxS("wxCurlBaseThread - exiting")); + +} + +bool wxCurlBaseThread::TestDestroy() +{ + if (wxThread::TestDestroy()) + return true; + + wxMutexLocker lock(m_bAbortMutex); + return m_bAbort; +} + +wxCurlThreadError wxCurlBaseThread::Wait() +{ + // Entry() returns 1 for success, 0 for failure + bool ret = (bool)(wxThread::Wait() != 0); + + if (m_bAbort) + // ret is false but that's not due to a network error: + // user stopped the thread through an Abort() call + return wxCTE_ABORTED; + + // if it was not user-aborted but ret is still false, then + // a network error occurred: + return ret ? wxCTE_NO_ERROR : wxCTE_CURL_ERROR; +} + +void wxCurlBaseThread::Abort() +{ + { + wxMutexLocker lock(m_bAbortMutex); + m_bAbort = true; + } + + if (IsPaused()) + Resume(); + else + if (m_pCurl) + m_pCurl->SetAbort(true); + + Wait(); // should always return wxCTE_ABORTED in this case +} + +wxCurlThreadError wxCurlBaseThread::Pause() +{ + if (m_pCurl) + m_pCurl->EndTransferSpan(); + + return (wxCurlThreadError)wxThread::Pause(); +} + +wxCurlThreadError wxCurlBaseThread::Resume() +{ + if (m_pCurl) + m_pCurl->BeginTransferSpan(); + + return (wxCurlThreadError)wxThread::Resume(); +} + + +// ----------------------------------- +// wxCurlDownloadThreadOutputFilter +// ----------------------------------- + +size_t wxCurlDownloadThreadOutputFilter::OnSysWrite(const void *buffer, size_t bufsize) +{ + // VERY IMPORTANT: we need to call TestDestroy() on the associated + // thread to make sure it can be paused/stopped (see wxThread docs) + + if (m_thread->TestDestroy()) + { + if (m_thread->m_pCurl->IsVerbose()) + wxLogDebug(wxS("[wxCURL] a wxCurlDownloadThread has been aborted - ignore following message:")); + + // returning a size != bufsize we tell libcurl to stop the tranfer + // and thus the wxCurlBase::Perform() call done (indirectly) by wxCurlDownloadThread::Entry() + // will immediately complete and we'll exit the thread. + // NOTE: we could also call wxThread::Exit() from here... but notifying libcurl + // of a "fake error" seems a better solution (allows libcurl to cleanup its internal) + return (size_t)-1; + } + + return m_stream->Write(buffer, bufsize).LastWrite(); +} + + +// --------------------- +// wxCurlDownloadThread +// --------------------- + +wxCurlThreadError wxCurlDownloadThread::SetOutputStream(wxOutputStream *out) +{ + wxCHECK_MSG(!IsAlive(), wxCTE_NO_RESOURCE, wxS("Cannot use this function after the transfer has begun")); + + if (!out) + { + if (!m_output) + { + // create a temporary file output stream + // NOTE: by default we create a wxFileOutputStream and not e.g. a wxMemoryOutputStream + // because the downloaded file may be quite large and thus we don't want to + // eat lots of RAM. Also, the hard disk should be fast enough for any download. + m_output.SetStream( new wxFileOutputStream(wxFileName::CreateTempFileName(wxS("download"))) ); + if (!m_output.IsOk()) + return wxCTE_NO_VALID_STREAM; + } + } + else + { + m_output.SetStream(out); + + // the user-provided output stream must be valid + if (!m_output.IsOk()) + return wxCTE_NO_VALID_STREAM; + } + + return wxCTE_NO_ERROR; +} + +wxCurlThreadError wxCurlDownloadThread::Download() +{ + wxCHECK_MSG(!IsAlive(), wxCTE_NO_RESOURCE, wxS("Cannot use this function after the transfer has begun")); + + // create & run this thread + wxCurlThreadError ret; + if ((ret=Create(wxCURL_THREAD_STACK_SIZE)) != wxCTE_NO_ERROR) + return ret; + if ((ret=Run()) != wxCTE_NO_ERROR) + return ret; + + return wxCTE_NO_ERROR; +} + +wxCurlThreadError wxCurlDownloadThread::Download(const wxString &url, wxOutputStream *out) +{ + wxCurlThreadError ret; + + if ((ret=SetURL(url)) != wxCTE_NO_ERROR) + return ret; + if ((ret=SetOutputStream(out)) != wxCTE_NO_ERROR) + return ret; + + return Download(); +} + +void *wxCurlDownloadThread::Entry() +{ + if (!m_pCurl || !m_pCurl->IsOk() || !m_output.IsOk()) + return NULL; + + // NOTE: the TestDestroy() function will still be called in this thread + // context by the m_output's OnSysWrite function which in turn is + // called from libcurl whenever some new data arrives + if (m_pCurl->IsVerbose()) + wxLogDebug(wxS("wxCurlDownloadThread - downloading from %s"), m_url.c_str()); + switch (m_protocol) + { + case wxCP_HTTP: + return (void*)wx_static_cast(wxCurlHTTP*, m_pCurl)->Get(m_output, m_url); + + case wxCP_FTP: + return (void*)wx_static_cast(wxCurlFTP*, m_pCurl)->Get(m_output, m_url); + + default: break; + } + + return NULL; +} + + + +// ----------------------------------- +// wxCurlUploadThreadInputFilter +// ----------------------------------- + +size_t wxCurlUploadThreadInputFilter::OnSysRead(void *buffer, size_t bufsize) +{ + // VERY IMPORTANT: we need to call TestDestroy() on the associated + // thread to make sure it can be paused/stopped (see wxThread docs) + + if (m_thread->TestDestroy()) + { + if (m_thread->m_pCurl->IsVerbose()) + wxLogDebug(wxS("[wxCURL] a wxCurlUploadThread has been aborted - ignore following message:")); + + // returning a size != bufsize we tell libcurl to stop the tranfer + // and thus the wxCurlBase::Perform() call done (indirectly) by wxCurlUploadThread::Entry() + // will immediately complete and we'll exit the thread. + // NOTE: we could also call wxThread::Exit() from here... but notifying libcurl + // of a "fake error" seems a better solution (allows libcurl to cleanup its internal) + return (size_t)-1; + } + + return m_stream->Read(buffer, bufsize).LastRead(); +} + + +// --------------------- +// wxCurlUploadThread +// --------------------- + +wxCurlThreadError wxCurlUploadThread::SetInputStream(wxInputStream *in) +{ + wxCHECK_MSG(!IsAlive(), wxCTE_NO_RESOURCE, wxS("Cannot use this function after the transfer has begun")); + + m_input.SetStream(in); + + // the user-provided input stream must be valid + if (!m_input.IsOk()) + return wxCTE_NO_VALID_STREAM; + + return wxCTE_NO_ERROR; +} + +wxCurlThreadError wxCurlUploadThread::Upload() +{ + wxCHECK_MSG(!IsAlive(), wxCTE_NO_RESOURCE, wxS("Cannot use this function after the tranfer has begun")); + + // create & run this thread + wxCurlThreadError ret; + if ((ret=Create(wxCURL_THREAD_STACK_SIZE)) != wxCTE_NO_ERROR) + return ret; + if ((ret=Run()) != wxCTE_NO_ERROR) + return ret; + + return wxCTE_NO_ERROR; +} + +wxCurlThreadError wxCurlUploadThread::Upload(const wxString &url, wxInputStream *in) +{ + wxCurlThreadError ret; + + if ((ret=SetURL(url)) != wxCTE_NO_ERROR) + return ret; + if ((ret=SetInputStream(in)) != wxCTE_NO_ERROR) + return ret; + + return Upload(); +} + +void *wxCurlUploadThread::Entry() +{ + if (!m_pCurl || !m_pCurl->IsOk() || !m_input.IsOk()) + return NULL; + + // NOTE: the TestDestroy() function will still be called in this thread + // context by the m_output's OnSysWrite function which in turn is + // called from libcurl whenever some new data arrives + if (m_pCurl->IsVerbose()) + wxLogDebug(wxS("wxCurlUploadThread - uploading to %s"), m_url.c_str()); + switch (m_protocol) + { + case wxCP_HTTP: + return (void*)wx_static_cast(wxCurlHTTP*, m_pCurl)->Put(m_input, m_url); + + case wxCP_FTP: + return (void*)wx_static_cast(wxCurlFTP*, m_pCurl)->Put(m_input, m_url); + + default: break; + } + + return NULL; +} diff --git a/src/utils.cpp b/src/utils.cpp new file mode 100644 index 0000000..0d43b66 --- /dev/null +++ b/src/utils.cpp @@ -0,0 +1,118 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: utils.cpp +// Purpose: wxCurlSizeQueryThread +// Author: Francesco Montorsi +// Created: 2005/04/23 +// RCS-ID: $Id: utils.cpp 1240 2010-03-10 23:54:25Z frm $ +// Copyright: (c) 2007 Francesco Montorsi +// Licence: wxWidgets licence +///////////////////////////////////////////////////////////////////////////// + + +// For compilers that support precompilation, includes "wx.h". +#include "wx/wxprec.h" + +#ifdef __BORLANDC__ +#pragma hdrstop +#endif + +// includes +#ifndef WX_PRECOMP + #include +#endif + +#ifdef __WXMSW__ + #include // useful to catch memory leaks when compiling under MSVC +#endif + +#include "wx/curl/utils.h" +#include "wx/curl/http.h" +#include "wx/curl/ftp.h" + + +DEFINE_EVENT_TYPE(wxCURL_SIZE_QUERY_EVENT) + + + +// ----------------------------------- +// wxCurlSizeQueryOutput +// ----------------------------------- + +extern "C" +{ + int wxcurl_size_query_progress_func(void* ptr, double rDlTotal, double WXUNUSED(rDlNow), + double WXUNUSED(rUlTotal), double WXUNUSED(rUlNow)) + { + unsigned long *p = (unsigned long *)ptr; + if (p) *p = (unsigned long)rDlTotal; + + // a non-zero value means to abort the transfer + // and that's what we want as we don't want to download the + // entire file but just get the rDlTotal info from the server + return 1; + } +} + +// --------------------- +// wxCurlSizeQueryThread +// --------------------- + +void *wxCurlSizeQueryThread::Entry() +{ + wxLogDebug(wxS("wxSizeCacherThread::Entry - caching file sizes")); + + wxMemoryOutputStream os; + bool allok = true; + wxCurlHTTP http; + wxCurlFTP ftp; + + m_urlSize.Clear(); + for (size_t i=0; i