VirtualBox

source: vbox/trunk/src/VBox/Runtime/common/misc/http.cpp@ 51635

Last change on this file since 51635 was 51635, checked in by vboxsync, 10 years ago

introduced RTHttpGetBinary(), renamed RTHttpGet() to RTHttpGetText()
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 16.8 KB
Line 
1/* $Id: http.cpp 51635 2014-06-17 15:58:40Z vboxsync $ */
2/** @file
3 * IPRT - HTTP communication API.
4 */
5
6/*
7 * Copyright (C) 2012-2013 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * The contents of this file may alternatively be used under the terms
18 * of the Common Development and Distribution License Version 1.0
19 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20 * VirtualBox OSE distribution, in which case the provisions of the
21 * CDDL are applicable instead of those of the GPL.
22 *
23 * You may elect to license modified versions of this file under the
24 * terms and conditions of either the GPL or the CDDL or both.
25 */
26
27
28/*******************************************************************************
29* Header Files *
30*******************************************************************************/
31#include <iprt/http.h>
32#include "internal/iprt.h"
33
34#include <iprt/assert.h>
35#include <iprt/env.h>
36#include <iprt/err.h>
37#include <iprt/mem.h>
38#include <iprt/string.h>
39#include <iprt/file.h>
40#include <iprt/stream.h>
41
42#include <curl/curl.h>
43#include <openssl/ssl.h>
44#include "internal/magics.h"
45
46
47/*******************************************************************************
48* Structures and Typedefs *
49*******************************************************************************/
50typedef struct RTHTTPINTERNAL
51{
52 /** magic value */
53 uint32_t u32Magic;
54 /** cURL handle */
55 CURL *pCurl;
56 long lLastResp;
57 /** custom headers */
58 struct curl_slist *pHeaders;
59 /** CA certificate for HTTPS authentication check */
60 char *pcszCAFile;
61 /** abort the current HTTP request if true */
62 bool fAbort;
63} RTHTTPINTERNAL;
64typedef RTHTTPINTERNAL *PRTHTTPINTERNAL;
65
66typedef struct RTHTTPMEMCHUNK
67{
68 uint8_t *pu8Mem;
69 size_t cb;
70} RTHTTPMEMCHUNK;
71typedef RTHTTPMEMCHUNK *PRTHTTPMEMCHUNK;
72
73/*******************************************************************************
74* Defined Constants And Macros *
75*******************************************************************************/
76#define CURL_FAILED(rcCurl) (RT_UNLIKELY(rcCurl != CURLE_OK))
77
78/** Validates a handle and returns VERR_INVALID_HANDLE if not valid. */
79#define RTHTTP_VALID_RETURN_RC(hHttp, rcCurl) \
80 do { \
81 AssertPtrReturn((hHttp), (rcCurl)); \
82 AssertReturn((hHttp)->u32Magic == RTHTTP_MAGIC, (rcCurl)); \
83 } while (0)
84
85/** Validates a handle and returns VERR_INVALID_HANDLE if not valid. */
86#define RTHTTP_VALID_RETURN(hHTTP) RTHTTP_VALID_RETURN_RC((hHttp), VERR_INVALID_HANDLE)
87
88/** Validates a handle and returns (void) if not valid. */
89#define RTHTTP_VALID_RETURN_VOID(hHttp) \
90 do { \
91 AssertPtrReturnVoid(hHttp); \
92 AssertReturnVoid((hHttp)->u32Magic == RTHTTP_MAGIC); \
93 } while (0)
94
95
96RTR3DECL(int) RTHttpCreate(PRTHTTP phHttp)
97{
98 AssertPtrReturn(phHttp, VERR_INVALID_PARAMETER);
99
100 CURLcode rcCurl = curl_global_init(CURL_GLOBAL_ALL);
101 if (CURL_FAILED(rcCurl))
102 return VERR_HTTP_INIT_FAILED;
103
104 CURL *pCurl = curl_easy_init();
105 if (!pCurl)
106 return VERR_HTTP_INIT_FAILED;
107
108 PRTHTTPINTERNAL pHttpInt = (PRTHTTPINTERNAL)RTMemAllocZ(sizeof(RTHTTPINTERNAL));
109 if (!pHttpInt)
110 return VERR_NO_MEMORY;
111
112 pHttpInt->u32Magic = RTHTTP_MAGIC;
113 pHttpInt->pCurl = pCurl;
114
115 *phHttp = (RTHTTP)pHttpInt;
116
117 return VINF_SUCCESS;
118}
119
120RTR3DECL(void) RTHttpDestroy(RTHTTP hHttp)
121{
122 if (!hHttp)
123 return;
124
125 PRTHTTPINTERNAL pHttpInt = hHttp;
126 RTHTTP_VALID_RETURN_VOID(pHttpInt);
127
128 pHttpInt->u32Magic = RTHTTP_MAGIC_DEAD;
129
130 curl_easy_cleanup(pHttpInt->pCurl);
131
132 if (pHttpInt->pHeaders)
133 curl_slist_free_all(pHttpInt->pHeaders);
134
135 if (pHttpInt->pcszCAFile)
136 RTStrFree(pHttpInt->pcszCAFile);
137
138 RTMemFree(pHttpInt);
139
140 curl_global_cleanup();
141}
142
143static DECLCALLBACK(size_t) rtHttpWriteData(void *pvBuf, size_t cb, size_t n, void *pvUser)
144{
145 PRTHTTPMEMCHUNK pMem = (PRTHTTPMEMCHUNK)pvUser;
146 size_t cbAll = cb * n;
147
148 pMem->pu8Mem = (uint8_t*)RTMemRealloc(pMem->pu8Mem, pMem->cb + cbAll + 1);
149 if (pMem->pu8Mem)
150 {
151 memcpy(&pMem->pu8Mem[pMem->cb], pvBuf, cbAll);
152 pMem->cb += cbAll;
153 pMem->pu8Mem[pMem->cb] = '\0';
154 }
155 return cbAll;
156}
157
158static DECLCALLBACK(int) rtHttpProgress(void *pData, double DlTotal, double DlNow,
159 double UlTotal, double UlNow)
160{
161 PRTHTTPINTERNAL pHttpInt = (PRTHTTPINTERNAL)pData;
162 AssertReturn(pHttpInt->u32Magic == RTHTTP_MAGIC, 1);
163
164 return pHttpInt->fAbort ? 1 : 0;
165}
166
167RTR3DECL(int) RTHttpAbort(RTHTTP hHttp)
168{
169 PRTHTTPINTERNAL pHttpInt = hHttp;
170 RTHTTP_VALID_RETURN(pHttpInt);
171
172 pHttpInt->fAbort = true;
173
174 return VINF_SUCCESS;
175}
176
177RTR3DECL(int) RTHttpUseSystemProxySettings(RTHTTP hHttp)
178{
179 PRTHTTPINTERNAL pHttpInt = hHttp;
180 RTHTTP_VALID_RETURN(pHttpInt);
181
182 /*
183 * Very limited right now, just enought to make it work for ourselves.
184 */
185 char szProxy[_1K];
186 int rc = RTEnvGetEx(RTENV_DEFAULT, "http_proxy", szProxy, sizeof(szProxy), NULL);
187 if (RT_SUCCESS(rc))
188 {
189 int rcCurl;
190 if (!strncmp(szProxy, RT_STR_TUPLE("http://")))
191 {
192 rcCurl = curl_easy_setopt(pHttpInt->pCurl, CURLOPT_PROXY, &szProxy[sizeof("http://") - 1]);
193 if (CURL_FAILED(rcCurl))
194 return VERR_INVALID_PARAMETER;
195 rcCurl = curl_easy_setopt(pHttpInt->pCurl, CURLOPT_PROXYPORT, 80);
196 if (CURL_FAILED(rcCurl))
197 return VERR_INVALID_PARAMETER;
198 }
199 else
200 {
201 rcCurl = curl_easy_setopt(pHttpInt->pCurl, CURLOPT_PROXY, &szProxy[sizeof("http://") - 1]);
202 if (CURL_FAILED(rcCurl))
203 return VERR_INVALID_PARAMETER;
204 }
205 }
206 else if (rc == VERR_ENV_VAR_NOT_FOUND)
207 rc = VINF_SUCCESS;
208
209 return rc;
210}
211
212RTR3DECL(int) RTHttpSetProxy(RTHTTP hHttp, const char *pcszProxy, uint32_t uPort,
213 const char *pcszProxyUser, const char *pcszProxyPwd)
214{
215 PRTHTTPINTERNAL pHttpInt = hHttp;
216 RTHTTP_VALID_RETURN(pHttpInt);
217 AssertPtrReturn(pcszProxy, VERR_INVALID_PARAMETER);
218
219 int rcCurl = curl_easy_setopt(pHttpInt->pCurl, CURLOPT_PROXY, pcszProxy);
220 if (CURL_FAILED(rcCurl))
221 return VERR_INVALID_PARAMETER;
222
223 if (uPort != 0)
224 {
225 rcCurl = curl_easy_setopt(pHttpInt->pCurl, CURLOPT_PROXYPORT, (long)uPort);
226 if (CURL_FAILED(rcCurl))
227 return VERR_INVALID_PARAMETER;
228 }
229
230 if (pcszProxyUser && pcszProxyPwd)
231 {
232 rcCurl = curl_easy_setopt(pHttpInt->pCurl, CURLOPT_PROXYUSERNAME, pcszProxyUser);
233 if (CURL_FAILED(rcCurl))
234 return VERR_INVALID_PARAMETER;
235
236 rcCurl = curl_easy_setopt(pHttpInt->pCurl, CURLOPT_PROXYPASSWORD, pcszProxyPwd);
237 if (CURL_FAILED(rcCurl))
238 return VERR_INVALID_PARAMETER;
239 }
240
241 return VINF_SUCCESS;
242}
243
244RTR3DECL(int) RTHttpSetHeaders(RTHTTP hHttp, size_t cHeaders, const char * const *papszHeaders)
245{
246 PRTHTTPINTERNAL pHttpInt = hHttp;
247 RTHTTP_VALID_RETURN(pHttpInt);
248
249 if (!cHeaders)
250 {
251 if (pHttpInt->pHeaders)
252 curl_slist_free_all(pHttpInt->pHeaders);
253 pHttpInt->pHeaders = 0;
254 return VINF_SUCCESS;
255 }
256
257 struct curl_slist *pHeaders = NULL;
258 for (size_t i = 0; i < cHeaders; i++)
259 pHeaders = curl_slist_append(pHeaders, papszHeaders[i]);
260
261 pHttpInt->pHeaders = pHeaders;
262 int rcCurl = curl_easy_setopt(pHttpInt->pCurl, CURLOPT_HTTPHEADER, pHeaders);
263 if (CURL_FAILED(rcCurl))
264 return VERR_INVALID_PARAMETER;
265
266 return VINF_SUCCESS;
267}
268
269RTR3DECL(int) RTHttpCertDigest(RTHTTP hHttp, char *pcszCert, size_t cbCert,
270 uint8_t **pabSha1, size_t *pcbSha1,
271 uint8_t **pabSha512, size_t *pcbSha512)
272{
273 int rc = VINF_SUCCESS;
274
275 BIO *cert = BIO_new_mem_buf(pcszCert, (int)cbCert);
276 if (cert)
277 {
278 X509 *crt = NULL;
279 if (PEM_read_bio_X509(cert, &crt, NULL, NULL))
280 {
281 unsigned cb;
282 unsigned char md[EVP_MAX_MD_SIZE];
283
284 int rc1 = X509_digest(crt, EVP_sha1(), md, &cb);
285 if (rc1 > 0)
286 {
287 *pabSha1 = (uint8_t*)RTMemAlloc(cb);
288 if (*pabSha1)
289 {
290 memcpy(*pabSha1, md, cb);
291 *pcbSha1 = cb;
292
293 rc1 = X509_digest(crt, EVP_sha512(), md, &cb);
294 if (rc1 > 0)
295 {
296 *pabSha512 = (uint8_t*)RTMemAlloc(cb);
297 if (*pabSha512)
298 {
299 memcpy(*pabSha512, md, cb);
300 *pcbSha512 = cb;
301 }
302 else
303 rc = VERR_NO_MEMORY;
304 }
305 else
306 rc = VERR_HTTP_CACERT_WRONG_FORMAT;
307 }
308 else
309 rc = VERR_NO_MEMORY;
310 }
311 else
312 rc = VERR_HTTP_CACERT_WRONG_FORMAT;
313 X509_free(crt);
314 }
315 else
316 rc = VERR_HTTP_CACERT_WRONG_FORMAT;
317 BIO_free(cert);
318 }
319 else
320 rc = VERR_INTERNAL_ERROR;
321
322 if (RT_FAILURE(rc))
323 {
324 RTMemFree(*pabSha512);
325 RTMemFree(*pabSha1);
326 }
327
328 return rc;
329}
330
331RTR3DECL(int) RTHttpSetCAFile(RTHTTP hHttp, const char *pcszCAFile)
332{
333 PRTHTTPINTERNAL pHttpInt = hHttp;
334 RTHTTP_VALID_RETURN(pHttpInt);
335
336 if (pHttpInt->pcszCAFile)
337 RTStrFree(pHttpInt->pcszCAFile);
338 pHttpInt->pcszCAFile = RTStrDup(pcszCAFile);
339 if (!pHttpInt->pcszCAFile)
340 return VERR_NO_MEMORY;
341
342 return VINF_SUCCESS;
343}
344
345
346/**
347 * Figures out the IPRT status code for a GET.
348 *
349 * @returns IPRT status code.
350 * @param pHttpInt HTTP instance.
351 * @param rcCurl What curl returned.
352 */
353static int rtHttpGetCalcStatus(PRTHTTPINTERNAL pHttpInt, int rcCurl)
354{
355 int rc = VERR_INTERNAL_ERROR;
356 if (rcCurl == CURLE_OK)
357 {
358 curl_easy_getinfo(pHttpInt->pCurl, CURLINFO_RESPONSE_CODE, &pHttpInt->lLastResp);
359 switch (pHttpInt->lLastResp)
360 {
361 case 200:
362 /* OK, request was fulfilled */
363 case 204:
364 /* empty response */
365 rc = VINF_SUCCESS;
366 break;
367 case 400:
368 /* bad request */
369 rc = VERR_HTTP_BAD_REQUEST;
370 break;
371 case 403:
372 /* forbidden, authorization will not help */
373 rc = VERR_HTTP_ACCESS_DENIED;
374 break;
375 case 404:
376 /* URL not found */
377 rc = VERR_HTTP_NOT_FOUND;
378 break;
379 }
380 }
381 else
382 {
383 switch (rcCurl)
384 {
385 case CURLE_URL_MALFORMAT:
386 case CURLE_COULDNT_RESOLVE_HOST:
387 rc = VERR_HTTP_NOT_FOUND;
388 break;
389 case CURLE_COULDNT_CONNECT:
390 rc = VERR_HTTP_COULDNT_CONNECT;
391 break;
392 case CURLE_SSL_CONNECT_ERROR:
393 rc = VERR_HTTP_SSL_CONNECT_ERROR;
394 break;
395 case CURLE_SSL_CACERT:
396 /* The peer certificate cannot be authenticated with the CA certificates
397 * set by RTHttpSetCAFile(). We need other or additional CA certificates. */
398 rc = VERR_HTTP_CACERT_CANNOT_AUTHENTICATE;
399 break;
400 case CURLE_SSL_CACERT_BADFILE:
401 /* CAcert file (see RTHttpSetCAFile()) has wrong format */
402 rc = VERR_HTTP_CACERT_WRONG_FORMAT;
403 break;
404 case CURLE_ABORTED_BY_CALLBACK:
405 /* forcefully aborted */
406 rc = VERR_HTTP_ABORTED;
407 break;
408 default:
409 break;
410 }
411 }
412
413 return rc;
414}
415
416RTR3DECL(int) rtHttpGet(RTHTTP hHttp, const char *pcszUrl, uint8_t **ppvResponse, size_t *pcb)
417{
418 PRTHTTPINTERNAL pHttpInt = hHttp;
419 RTHTTP_VALID_RETURN(pHttpInt);
420
421 pHttpInt->fAbort = false;
422
423 int rcCurl = curl_easy_setopt(pHttpInt->pCurl, CURLOPT_URL, pcszUrl);
424 if (CURL_FAILED(rcCurl))
425 return VERR_INVALID_PARAMETER;
426
427#if 0
428 rcCurl = curl_easy_setopt(pHttpInt->pCurl, CURLOPT_VERBOSE, 1);
429 if (CURL_FAILED(rcCurl))
430 return VERR_INVALID_PARAMETER;
431#endif
432
433 const char *pcszCAFile = "/etc/ssl/certs/ca-certificates.crt";
434 if (pHttpInt->pcszCAFile)
435 pcszCAFile = pHttpInt->pcszCAFile;
436 if (RTFileExists(pcszCAFile))
437 {
438 rcCurl = curl_easy_setopt(pHttpInt->pCurl, CURLOPT_CAINFO, pcszCAFile);
439 if (CURL_FAILED(rcCurl))
440 return VERR_INTERNAL_ERROR;
441 }
442
443 RTHTTPMEMCHUNK chunk = { NULL, 0 };
444 rcCurl = curl_easy_setopt(pHttpInt->pCurl, CURLOPT_WRITEFUNCTION, &rtHttpWriteData);
445 if (CURL_FAILED(rcCurl))
446 return VERR_INTERNAL_ERROR;
447 rcCurl = curl_easy_setopt(pHttpInt->pCurl, CURLOPT_WRITEDATA, (void*)&chunk);
448 if (CURL_FAILED(rcCurl))
449 return VERR_INTERNAL_ERROR;
450 rcCurl = curl_easy_setopt(pHttpInt->pCurl, CURLOPT_PROGRESSFUNCTION, &rtHttpProgress);
451 if (CURL_FAILED(rcCurl))
452 return VERR_INTERNAL_ERROR;
453 rcCurl = curl_easy_setopt(pHttpInt->pCurl, CURLOPT_PROGRESSDATA, (void*)pHttpInt);
454 if (CURL_FAILED(rcCurl))
455 return VERR_INTERNAL_ERROR;
456 rcCurl = curl_easy_setopt(pHttpInt->pCurl, CURLOPT_NOPROGRESS, (long)0);
457 if (CURL_FAILED(rcCurl))
458 return VERR_INTERNAL_ERROR;
459
460 rcCurl = curl_easy_perform(pHttpInt->pCurl);
461 int rc = rtHttpGetCalcStatus(pHttpInt, rcCurl);
462 *ppvResponse = chunk.pu8Mem;
463 *pcb = chunk.cb;
464
465 return rc;
466}
467
468
469RTR3DECL(int) RTHttpGetText(RTHTTP hHttp, const char *pcszUrl, char **ppszResponse)
470{
471 uint8_t *pv;
472 size_t cb;
473 int rc = rtHttpGet(hHttp, pcszUrl, &pv, &cb);
474 *ppszResponse = (char*)pv;
475 return rc;
476}
477
478
479RTR3DECL(int) RTHttpGetBinary(RTHTTP hHttp, const char *pcszUrl, void **ppvResponse, size_t *pcb)
480{
481 return rtHttpGet(hHttp, pcszUrl, (uint8_t**)ppvResponse, pcb);
482}
483
484
485static size_t rtHttpWriteDataToFile(void *pvBuf, size_t cb, size_t n, void *pvUser)
486{
487 size_t cbAll = cb * n;
488 RTFILE hFile = (RTFILE)(intptr_t)pvUser;
489
490 size_t cbWritten = 0;
491 int rc = RTFileWrite(hFile, pvBuf, cbAll, &cbWritten);
492 if (RT_SUCCESS(rc))
493 return cbWritten;
494 return 0;
495}
496
497
498RTR3DECL(int) RTHttpGetFile(RTHTTP hHttp, const char *pszUrl, const char *pszDstFile)
499{
500 PRTHTTPINTERNAL pHttpInt = hHttp;
501 RTHTTP_VALID_RETURN(pHttpInt);
502
503 /*
504 * Set up the request.
505 */
506 pHttpInt->fAbort = false;
507
508 int rcCurl = curl_easy_setopt(pHttpInt->pCurl, CURLOPT_URL, pszUrl);
509 if (CURL_FAILED(rcCurl))
510 return VERR_INVALID_PARAMETER;
511
512#if 0
513 rcCurl = curl_easy_setopt(pHttpInt->pCurl, CURLOPT_VERBOSE, 1);
514 if (CURL_FAILED(rcCurl))
515 return VERR_INVALID_PARAMETER;
516#endif
517
518 const char *pcszCAFile = "/etc/ssl/certs/ca-certificates.crt";
519 if (pHttpInt->pcszCAFile)
520 pcszCAFile = pHttpInt->pcszCAFile;
521 if (RTFileExists(pcszCAFile))
522 {
523 rcCurl = curl_easy_setopt(pHttpInt->pCurl, CURLOPT_CAINFO, pcszCAFile);
524 if (CURL_FAILED(rcCurl))
525 return VERR_INTERNAL_ERROR;
526 }
527
528 rcCurl = curl_easy_setopt(pHttpInt->pCurl, CURLOPT_WRITEFUNCTION, &rtHttpWriteDataToFile);
529 if (CURL_FAILED(rcCurl))
530 return VERR_INTERNAL_ERROR;
531 rcCurl = curl_easy_setopt(pHttpInt->pCurl, CURLOPT_PROGRESSFUNCTION, &rtHttpProgress);
532 if (CURL_FAILED(rcCurl))
533 return VERR_INTERNAL_ERROR;
534 rcCurl = curl_easy_setopt(pHttpInt->pCurl, CURLOPT_PROGRESSDATA, (void*)pHttpInt);
535 if (CURL_FAILED(rcCurl))
536 return VERR_INTERNAL_ERROR;
537 rcCurl = curl_easy_setopt(pHttpInt->pCurl, CURLOPT_NOPROGRESS, (long)0);
538 if (CURL_FAILED(rcCurl))
539 return VERR_INTERNAL_ERROR;
540
541 /*
542 * Open the output file.
543 */
544 RTFILE hFile;
545 int rc = RTFileOpen(&hFile, pszDstFile, RTFILE_O_WRITE | RTFILE_O_CREATE_REPLACE | RTFILE_O_DENY_READWRITE);
546 if (RT_SUCCESS(rc))
547 {
548 rcCurl = curl_easy_setopt(pHttpInt->pCurl, CURLOPT_WRITEDATA, (void *)(uintptr_t)hFile);
549 if (!CURL_FAILED(rcCurl))
550 {
551 /*
552 * Perform the request.
553 */
554 rcCurl = curl_easy_perform(pHttpInt->pCurl);
555 rc = rtHttpGetCalcStatus(pHttpInt, rcCurl);
556 }
557 else
558 rc = VERR_INTERNAL_ERROR;
559
560 int rc2 = RTFileClose(hFile);
561 if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
562 rc = rc2;
563 }
564
565 return rc;
566}
567
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette