KiCad PCB EDA Suite
Loading...
Searching...
No Matches
kicad_curl_easy.cpp
Go to the documentation of this file.
1/*
2 * This program source code file is part of KiCad, a free EDA CAD application.
3 *
4 * Copyright (C) 2015 Mark Roszko <[email protected]>
5 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version 3
10 * of the License, or (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, you may find one here:
19 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
20 * or you may search the http://www.gnu.org website for the version 2 license,
21 * or you may write to the Free Software Foundation, Inc.,
22 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
23 */
24
25// kicad_curl_easy.h **must be** included before any wxWidgets header to avoid conflicts
26// at least on Windows/msys2
27#include <curl/curl.h>
28#include <curl/easy.h>
31
32#include <cstdarg>
33#include <cstddef>
34#include <exception>
35#include <sstream>
36#include <shared_mutex>
37#include <wx/app.h>
38
39#include <build_version.h>
40#include <ki_exception.h> // THROW_IO_ERROR
41#include <kiplatform/app.h>
43
44#include <kiplatform/policy.h>
45#include <policy_keys.h>
46
48{
51 curl_off_t m_Last_run_time;
52 curl_off_t m_Interval;
53
54 CURL_PROGRESS( KICAD_CURL_EASY* aCURL, TRANSFER_CALLBACK aCallback, curl_off_t aInterval ) :
55 m_Curl( aCURL ),
56 m_Callback( aCallback ),
57 m_Last_run_time( 0 ),
58 m_Interval( aInterval )
59 {
60 }
61};
62
63
64static size_t write_callback( void* aContents, size_t aSize, size_t aNmemb, void* aUserp )
65{
66 size_t realsize = aSize * aNmemb;
67
68 std::string* p = static_cast<std::string*>( aUserp );
69
70 p->append( static_cast<const char*>( aContents ), realsize );
71
72 return realsize;
73}
74
75
76static size_t stream_write_callback( void* aContents, size_t aSize, size_t aNmemb, void* aUserp )
77{
78 size_t realsize = aSize * aNmemb;
79
80 std::ostream* p = static_cast<std::ostream*>( aUserp );
81
82 p->write( static_cast<const char*>( aContents ), realsize );
83
84 return realsize;
85}
86
87
88#if LIBCURL_VERSION_NUM >= 0x072000 // 7.32.0
89
90static int xferinfo( void* aProgress, curl_off_t aDLtotal, curl_off_t aDLnow, curl_off_t aULtotal,
91 curl_off_t aULnow )
92{
94 return 1; // Should abort the operation
95
96 CURL_PROGRESS* progress = static_cast<CURL_PROGRESS*>( aProgress );
97 curl_off_t curtime = 0;
98
99 curl_easy_getinfo( progress->m_Curl->GetCurl(), CURLINFO_TOTAL_TIME, &curtime );
100
101 if( curtime - progress->m_Last_run_time >= progress->m_Interval )
102 {
103 progress->m_Last_run_time = curtime;
104 return progress->m_Callback( aDLtotal, aDLnow, aULtotal, aULnow );
105 }
106
107 return CURLE_OK;
108}
109
110#else
111
112static int progressinfo( void* aProgress, double aDLtotal, double aDLnow, double aULtotal,
113 double aULnow )
114{
115 return xferinfo( aProgress, static_cast<curl_off_t>( aDLtotal ),
116 static_cast<curl_off_t>( aDLnow ), static_cast<curl_off_t>( aULtotal ),
117 static_cast<curl_off_t>( aULnow ) );
118}
119
120#endif
121
122
124 m_headers( nullptr ),
125 m_curlSharedLock( KICAD_CURL::Mutex() )
126{
127 m_CURL = curl_easy_init();
128
129 if( !m_CURL )
130 THROW_IO_ERROR( "Unable to initialize CURL session" );
131
132 curl_easy_setopt( m_CURL, CURLOPT_WRITEFUNCTION, write_callback );
133 curl_easy_setopt( m_CURL, CURLOPT_WRITEDATA, static_cast<void*>( &m_buffer ) );
134
135 // Only allow HTTP and HTTPS protocols
136#if LIBCURL_VERSION_NUM >= 0x075500 // version 7.85.0
137 curl_easy_setopt(m_CURL, CURLOPT_PROTOCOLS_STR, "http,https");
138#else
139 curl_easy_setopt( m_CURL, CURLOPT_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS );
140#endif
141
142#ifdef _WIN32
143 long sslOpts = CURLSSLOPT_NATIVE_CA;
144
145 POLICY_CURL_SSL_REVOKE policyState = KIPLATFORM::POLICY::GetPolicyEnum<POLICY_CURL_SSL_REVOKE>(
147
148 if( policyState == POLICY_CURL_SSL_REVOKE::BEST_EFFORT )
149 {
150 sslOpts |= CURLSSLOPT_REVOKE_BEST_EFFORT;
151 }
152 else if( policyState == POLICY_CURL_SSL_REVOKE::NONE )
153 {
154 sslOpts |= CURLSSLOPT_NO_REVOKE;
155 }
156
157 // We need this to use the Windows Certificate store
158 curl_easy_setopt( m_CURL, CURLOPT_SSL_OPTIONS, sslOpts );
159#endif
160
161 if( wxGetEnv( wxT( "KICAD_CURL_VERBOSE" ), nullptr ) )
162 {
163 // note: curl verbose will end up in stderr
164 curl_easy_setopt( m_CURL, CURLOPT_VERBOSE, 1L );
165 }
166
167 wxString application( wxS( "KiCad" ) );
168 wxString version( GetBuildVersion() );
169 wxString platform = wxS( "(" ) + wxGetOsDescription() + wxS( ";" ) + GetPlatformGetBitnessName();
170
171#if defined( KICAD_BUILD_ARCH_X64 )
172 platform << wxS( ";64-bit" );
173#elif defined( KICAD_BUILD_ARCH_X86 )
174 platform << wxS( ";32-bit" );
175#elif defined( KICAD_BUILD_ARCH_ARM )
176 platform << wxS( ";ARM 32-bit" );
177#elif defined( KICAD_BUILD_ARCH_ARM64 )
178 platform << wxS( ";ARM 64-bit" );
179#endif
180
181 platform << wxS( ")" );
182
183 wxString user_agent = wxS( "KiCad/" ) + version + wxS( " " ) + platform + wxS( " " ) + application;
184
185 user_agent << wxS( "/" ) << GetBuildDate();
186 setOption<const char*>( CURLOPT_USERAGENT, user_agent.ToStdString().c_str() );
187 setOption( CURLOPT_ACCEPT_ENCODING, "gzip,deflate" );
188}
189
190
192{
193 if( m_headers )
194 curl_slist_free_all( m_headers );
195
196 curl_easy_cleanup( m_CURL );
197}
198
199
201{
202 if( m_headers )
203 curl_easy_setopt( m_CURL, CURLOPT_HTTPHEADER, m_headers );
204
205 // bonus: retain worst case memory allocation, should re-use occur
206 m_buffer.clear();
207
208 return curl_easy_perform( m_CURL );
209}
210
211
212void KICAD_CURL_EASY::SetHeader( const std::string& aName, const std::string& aValue )
213{
214 std::string header = aName + ':' + aValue;
215 m_headers = curl_slist_append( m_headers, header.c_str() );
216}
217
218
219template <typename T>
220int KICAD_CURL_EASY::setOption( int aOption, T aArg )
221{
222 return curl_easy_setopt( m_CURL, static_cast<CURLoption>( aOption ), aArg );
223}
224
225
226const std::string KICAD_CURL_EASY::GetErrorText( int aCode )
227{
228 return curl_easy_strerror( static_cast<CURLcode>( aCode ) );
229}
230
231
232bool KICAD_CURL_EASY::SetUserAgent( const std::string& aAgent )
233{
234 if( setOption<const char*>( CURLOPT_USERAGENT, aAgent.c_str() ) == CURLE_OK )
235 return true;
236
237 return false;
238}
239
240
241bool KICAD_CURL_EASY::SetPostFields( const std::vector<std::pair<std::string, std::string>>& aFields )
242{
243 std::string postfields;
244
245 for( size_t i = 0; i < aFields.size(); i++ )
246 {
247 if( i > 0 )
248 postfields += "&";
249
250 postfields += Escape( aFields[i].first );
251 postfields += "=";
252 postfields += Escape( aFields[i].second );
253 }
254
255 if( setOption<const char*>( CURLOPT_COPYPOSTFIELDS, postfields.c_str() ) != CURLE_OK )
256 return false;
257
258 return true;
259}
260
261
262bool KICAD_CURL_EASY::SetPostFields( const std::string& aField )
263{
264 if( setOption<const char*>( CURLOPT_COPYPOSTFIELDS, aField.c_str() ) != CURLE_OK )
265 return false;
266
267 return true;
268}
269
270
271bool KICAD_CURL_EASY::SetURL( const std::string& aURL )
272{
273 if( setOption<const char*>( CURLOPT_URL, aURL.c_str() ) == CURLE_OK )
274 {
276
277 // Unfortunately on Windows land, proxies can be configured depending on destination url
278 // So we also check and set any proxy config here
280 {
281 curl_easy_setopt( m_CURL, CURLOPT_PROXY, static_cast<const char*>( cfg.host.c_str() ) );
282
283 if( !cfg.username.empty() )
284 {
285 curl_easy_setopt( m_CURL, CURLOPT_PROXYUSERNAME,
286 static_cast<const char*>( cfg.username.c_str() ) );
287 }
288
289 if( !cfg.password.empty() )
290 {
291 curl_easy_setopt( m_CURL, CURLOPT_PROXYPASSWORD,
292 static_cast<const char*>( cfg.password.c_str() ) );
293 }
294 }
295
296 return true;
297 }
298
299 return false;
300}
301
302
304{
305 if( setOption<long>( CURLOPT_FOLLOWLOCATION, ( aFollow ? 1 : 0 ) ) == CURLE_OK )
306 return true;
307
308 return false;
309}
310
311
312std::string KICAD_CURL_EASY::Escape( const std::string& aUrl )
313{
314 char* escaped = curl_easy_escape( m_CURL, aUrl.c_str(), aUrl.length() );
315
316 std::string ret( escaped );
317 curl_free( escaped );
318
319 return ret;
320}
321
322
323bool KICAD_CURL_EASY::SetTransferCallback( const TRANSFER_CALLBACK& aCallback, size_t aInterval )
324{
325 progress = std::make_unique<CURL_PROGRESS>( this, aCallback, static_cast<curl_off_t>( aInterval ) );
326
327#if LIBCURL_VERSION_NUM >= 0x072000 // 7.32.0
328 setOption( CURLOPT_XFERINFOFUNCTION, xferinfo );
329 setOption( CURLOPT_XFERINFODATA, progress.get() );
330#else
331 setOption( CURLOPT_PROGRESSFUNCTION, progressinfo );
332 setOption( CURLOPT_PROGRESSDATA, progress.get() );
333#endif
334
335 setOption( CURLOPT_NOPROGRESS, 0L );
336 return true;
337}
338
339
340bool KICAD_CURL_EASY::SetOutputStream( const std::ostream* aOutput )
341{
342 curl_easy_setopt( m_CURL, CURLOPT_WRITEFUNCTION, stream_write_callback );
343 curl_easy_setopt( m_CURL, CURLOPT_WRITEDATA, reinterpret_cast<const void*>( aOutput ) );
344 return true;
345}
346
347
348int KICAD_CURL_EASY::GetTransferTotal( uint64_t& aDownloadedBytes ) const
349{
350#if LIBCURL_VERSION_NUM >= 0x073700 // 7.55.0
351 curl_off_t dl;
352 int result = curl_easy_getinfo( m_CURL, CURLINFO_SIZE_DOWNLOAD_T, &dl );
353 aDownloadedBytes = static_cast<uint64_t>( dl );
354#else
355 double dl;
356 int result = curl_easy_getinfo( m_CURL, CURLINFO_SIZE_DOWNLOAD, &dl );
357 aDownloadedBytes = static_cast<uint64_t>( dl );
358#endif
359
360 return result;
361}
362
363
365{
366 long http_code = 0;
367 curl_easy_getinfo( m_CURL, CURLINFO_RESPONSE_CODE, &http_code );
368
369 return static_cast<int>( http_code );
370}
wxString GetBuildVersion()
Get the full KiCad version string.
wxString GetPlatformGetBitnessName()
wxString GetBuildDate()
Get the build date as a string.
std::string m_buffer
int Perform()
Equivalent to curl_easy_perform.
bool SetPostFields(const std::vector< std::pair< std::string, std::string > > &aFields)
Set fields for application/x-www-form-urlencoded POST request.
std::unique_ptr< CURL_PROGRESS > progress
std::string Escape(const std::string &aUrl)
Escapes a string for use as a URL.
bool SetUserAgent(const std::string &aAgent)
Set the request user agent.
curl_slist * m_headers
void SetHeader(const std::string &aName, const std::string &aValue)
Set an arbitrary header for the HTTP(s) request.
bool SetTransferCallback(const TRANSFER_CALLBACK &aCallback, size_t aInterval)
bool SetURL(const std::string &aURL)
Set the request URL.
bool SetFollowRedirects(bool aFollow)
Enable the following of HTTP(s) and other redirects, by default curl does not follow redirects.
int GetTransferTotal(uint64_t &aDownloadedBytes) const
int setOption(int aOption, T aArg)
Set a curl option, only supports single parameter curl options.
bool SetOutputStream(const std::ostream *aOutput)
const std::string GetErrorText(int aCode)
Fetch CURL's "friendly" error string for a given error code.
Simple wrapper class to call curl_global_init and curl_global_cleanup for KiCad.
Definition: kicad_curl.h:62
static bool IsShuttingDown()
Returns true if all curl operations should terminate.
Definition: kicad_curl.cpp:64
#define THROW_IO_ERROR(msg)
Definition: ki_exception.h:39
static int progressinfo(void *aProgress, double aDLtotal, double aDLnow, double aULtotal, double aULnow)
static size_t write_callback(void *aContents, size_t aSize, size_t aNmemb, void *aUserp)
static size_t stream_write_callback(void *aContents, size_t aSize, size_t aNmemb, void *aUserp)
std::function< int(size_t, size_t, size_t, size_t)> TRANSFER_CALLBACK
Wrapper interface around the curl_easy API/.
bool GetSystemProxyConfig(const wxString &aURL, PROXY_CONFIG &aCfg)
Retrieves platform level proxying requirements to reach the given url.
#define POLICY_KEY_REQUESTS_CURL_REVOKE
Definition: policy_keys.h:32
POLICY_CURL_SSL_REVOKE
Definition: policy_keys.h:35
curl_off_t m_Interval
CURL_PROGRESS(KICAD_CURL_EASY *aCURL, TRANSFER_CALLBACK aCallback, curl_off_t aInterval)
TRANSFER_CALLBACK m_Callback
KICAD_CURL_EASY * m_Curl
curl_off_t m_Last_run_time