2 * QEMU Block driver for CURL images
4 * Copyright (c) 2009 Alexander Graf <agraf@suse.de>
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 #include "qemu/osdep.h"
26 #include "qapi/error.h"
27 #include "qemu/error-report.h"
28 #include "qemu/module.h"
29 #include "qemu/option.h"
30 #include "block/block_int.h"
31 #include "qapi/qmp/qdict.h"
32 #include "qapi/qmp/qstring.h"
33 #include "crypto/secret.h"
34 #include <curl/curl.h>
35 #include "qemu/cutils.h"
38 // #define DEBUG_VERBOSE
40 #if LIBCURL_VERSION_NUM >= 0x071000
41 /* The multi interface timer callback was introduced in 7.16.0 */
42 #define NEED_CURL_TIMER_CALLBACK
43 #define HAVE_SOCKET_ACTION
46 #ifndef HAVE_SOCKET_ACTION
47 /* If curl_multi_socket_action isn't available, define it statically here in
48 * terms of curl_multi_socket. Note that ev_bitmask will be ignored, which is
49 * less efficient but still safe. */
50 static CURLMcode
__curl_multi_socket_action(CURLM
*multi_handle
,
55 return curl_multi_socket(multi_handle
, sockfd
, running_handles
);
57 #define curl_multi_socket_action __curl_multi_socket_action
60 #define PROTOCOLS (CURLPROTO_HTTP | CURLPROTO_HTTPS | \
61 CURLPROTO_FTP | CURLPROTO_FTPS)
63 #define CURL_NUM_STATES 8
64 #define CURL_NUM_ACB 8
65 #define CURL_TIMEOUT_MAX 10000
67 #define CURL_BLOCK_OPT_URL "url"
68 #define CURL_BLOCK_OPT_READAHEAD "readahead"
69 #define CURL_BLOCK_OPT_SSLVERIFY "sslverify"
70 #define CURL_BLOCK_OPT_TIMEOUT "timeout"
71 #define CURL_BLOCK_OPT_COOKIE "cookie"
72 #define CURL_BLOCK_OPT_COOKIE_SECRET "cookie-secret"
73 #define CURL_BLOCK_OPT_USERNAME "username"
74 #define CURL_BLOCK_OPT_PASSWORD_SECRET "password-secret"
75 #define CURL_BLOCK_OPT_PROXY_USERNAME "proxy-username"
76 #define CURL_BLOCK_OPT_PROXY_PASSWORD_SECRET "proxy-password-secret"
78 #define CURL_BLOCK_OPT_READAHEAD_DEFAULT (256 * 1024)
79 #define CURL_BLOCK_OPT_SSLVERIFY_DEFAULT true
80 #define CURL_BLOCK_OPT_TIMEOUT_DEFAULT 5
84 static bool libcurl_initialized
;
86 typedef struct CURLAIOCB
{
98 typedef struct CURLSocket
{
100 QLIST_ENTRY(CURLSocket
) next
;
103 typedef struct CURLState
105 struct BDRVCURLState
*s
;
106 CURLAIOCB
*acb
[CURL_NUM_ACB
];
108 QLIST_HEAD(, CURLSocket
) sockets
;
114 char errmsg
[CURL_ERROR_SIZE
];
118 typedef struct BDRVCURLState
{
122 CURLState states
[CURL_NUM_STATES
];
124 size_t readahead_size
;
129 AioContext
*aio_context
;
131 CoQueue free_state_waitq
;
138 static void curl_clean_state(CURLState
*s
);
139 static void curl_multi_do(void *arg
);
140 static void curl_multi_read(void *arg
);
142 #ifdef NEED_CURL_TIMER_CALLBACK
143 /* Called from curl_multi_do_locked, with s->mutex held. */
144 static int curl_timer_cb(CURLM
*multi
, long timeout_ms
, void *opaque
)
146 BDRVCURLState
*s
= opaque
;
148 trace_curl_timer_cb(timeout_ms
);
149 if (timeout_ms
== -1) {
150 timer_del(&s
->timer
);
152 int64_t timeout_ns
= (int64_t)timeout_ms
* 1000 * 1000;
154 qemu_clock_get_ns(QEMU_CLOCK_REALTIME
) + timeout_ns
);
160 /* Called from curl_multi_do_locked, with s->mutex held. */
161 static int curl_sock_cb(CURL
*curl
, curl_socket_t fd
, int action
,
162 void *userp
, void *sp
)
165 CURLState
*state
= NULL
;
168 curl_easy_getinfo(curl
, CURLINFO_PRIVATE
, (char **)&state
);
171 QLIST_FOREACH(socket
, &state
->sockets
, next
) {
172 if (socket
->fd
== fd
) {
173 if (action
== CURL_POLL_REMOVE
) {
174 QLIST_REMOVE(socket
, next
);
181 socket
= g_new0(CURLSocket
, 1);
183 QLIST_INSERT_HEAD(&state
->sockets
, socket
, next
);
187 trace_curl_sock_cb(action
, (int)fd
);
190 aio_set_fd_handler(s
->aio_context
, fd
, false,
191 curl_multi_read
, NULL
, NULL
, state
);
194 aio_set_fd_handler(s
->aio_context
, fd
, false,
195 NULL
, curl_multi_do
, NULL
, state
);
197 case CURL_POLL_INOUT
:
198 aio_set_fd_handler(s
->aio_context
, fd
, false,
199 curl_multi_read
, curl_multi_do
, NULL
, state
);
201 case CURL_POLL_REMOVE
:
202 aio_set_fd_handler(s
->aio_context
, fd
, false,
203 NULL
, NULL
, NULL
, NULL
);
210 /* Called from curl_multi_do_locked, with s->mutex held. */
211 static size_t curl_header_cb(void *ptr
, size_t size
, size_t nmemb
, void *opaque
)
213 BDRVCURLState
*s
= opaque
;
214 size_t realsize
= size
* nmemb
;
215 const char *accept_line
= "Accept-Ranges: bytes";
217 if (realsize
>= strlen(accept_line
)
218 && strncmp((char *)ptr
, accept_line
, strlen(accept_line
)) == 0) {
219 s
->accept_range
= true;
225 /* Called from curl_multi_do_locked, with s->mutex held. */
226 static size_t curl_read_cb(void *ptr
, size_t size
, size_t nmemb
, void *opaque
)
228 CURLState
*s
= ((CURLState
*)opaque
);
229 size_t realsize
= size
* nmemb
;
232 trace_curl_read_cb(realsize
);
234 if (!s
|| !s
->orig_buf
) {
238 if (s
->buf_off
>= s
->buf_len
) {
239 /* buffer full, read nothing */
242 realsize
= MIN(realsize
, s
->buf_len
- s
->buf_off
);
243 memcpy(s
->orig_buf
+ s
->buf_off
, ptr
, realsize
);
244 s
->buf_off
+= realsize
;
246 for(i
=0; i
<CURL_NUM_ACB
; i
++) {
247 CURLAIOCB
*acb
= s
->acb
[i
];
252 if ((s
->buf_off
>= acb
->end
)) {
253 size_t request_length
= acb
->bytes
;
255 qemu_iovec_from_buf(acb
->qiov
, 0, s
->orig_buf
+ acb
->start
,
256 acb
->end
- acb
->start
);
258 if (acb
->end
- acb
->start
< request_length
) {
259 size_t offset
= acb
->end
- acb
->start
;
260 qemu_iovec_memset(acb
->qiov
, offset
, 0,
261 request_length
- offset
);
266 qemu_mutex_unlock(&s
->s
->mutex
);
267 aio_co_wake(acb
->co
);
268 qemu_mutex_lock(&s
->s
->mutex
);
273 /* curl will error out if we do not return this value */
277 /* Called with s->mutex held. */
278 static bool curl_find_buf(BDRVCURLState
*s
, uint64_t start
, uint64_t len
,
282 uint64_t end
= start
+ len
;
283 uint64_t clamped_end
= MIN(end
, s
->len
);
284 uint64_t clamped_len
= clamped_end
- start
;
286 for (i
=0; i
<CURL_NUM_STATES
; i
++) {
287 CURLState
*state
= &s
->states
[i
];
288 uint64_t buf_end
= (state
->buf_start
+ state
->buf_off
);
289 uint64_t buf_fend
= (state
->buf_start
+ state
->buf_len
);
291 if (!state
->orig_buf
)
296 // Does the existing buffer cover our section?
297 if ((start
>= state
->buf_start
) &&
298 (start
<= buf_end
) &&
299 (clamped_end
>= state
->buf_start
) &&
300 (clamped_end
<= buf_end
))
302 char *buf
= state
->orig_buf
+ (start
- state
->buf_start
);
304 qemu_iovec_from_buf(acb
->qiov
, 0, buf
, clamped_len
);
305 if (clamped_len
< len
) {
306 qemu_iovec_memset(acb
->qiov
, clamped_len
, 0, len
- clamped_len
);
312 // Wait for unfinished chunks
314 (start
>= state
->buf_start
) &&
315 (start
<= buf_fend
) &&
316 (clamped_end
>= state
->buf_start
) &&
317 (clamped_end
<= buf_fend
))
321 acb
->start
= start
- state
->buf_start
;
322 acb
->end
= acb
->start
+ clamped_len
;
324 for (j
=0; j
<CURL_NUM_ACB
; j
++) {
325 if (!state
->acb
[j
]) {
336 /* Called with s->mutex held. */
337 static void curl_multi_check_completion(BDRVCURLState
*s
)
341 /* Try to find done transfers, so we can free the easy
345 msg
= curl_multi_info_read(s
->multi
, &msgs_in_queue
);
347 /* Quit when there are no more completions */
351 if (msg
->msg
== CURLMSG_DONE
) {
352 CURLState
*state
= NULL
;
353 curl_easy_getinfo(msg
->easy_handle
, CURLINFO_PRIVATE
,
356 /* ACBs for successful messages get completed in curl_read_cb */
357 if (msg
->data
.result
!= CURLE_OK
) {
359 static int errcount
= 100;
361 /* Don't lose the original error message from curl, since
362 * it contains extra data.
365 error_report("curl: %s", state
->errmsg
);
366 if (--errcount
== 0) {
367 error_report("curl: further errors suppressed");
371 for (i
= 0; i
< CURL_NUM_ACB
; i
++) {
372 CURLAIOCB
*acb
= state
->acb
[i
];
379 state
->acb
[i
] = NULL
;
380 qemu_mutex_unlock(&s
->mutex
);
381 aio_co_wake(acb
->co
);
382 qemu_mutex_lock(&s
->mutex
);
386 curl_clean_state(state
);
392 /* Called with s->mutex held. */
393 static void curl_multi_do_locked(CURLState
*s
)
395 CURLSocket
*socket
, *next_socket
;
403 /* Need to use _SAFE because curl_multi_socket_action() may trigger
404 * curl_sock_cb() which might modify this list */
405 QLIST_FOREACH_SAFE(socket
, &s
->sockets
, next
, next_socket
) {
407 r
= curl_multi_socket_action(s
->s
->multi
, socket
->fd
, 0, &running
);
408 } while (r
== CURLM_CALL_MULTI_PERFORM
);
412 static void curl_multi_do(void *arg
)
414 CURLState
*s
= (CURLState
*)arg
;
416 qemu_mutex_lock(&s
->s
->mutex
);
417 curl_multi_do_locked(s
);
418 qemu_mutex_unlock(&s
->s
->mutex
);
421 static void curl_multi_read(void *arg
)
423 CURLState
*s
= (CURLState
*)arg
;
425 qemu_mutex_lock(&s
->s
->mutex
);
426 curl_multi_do_locked(s
);
427 curl_multi_check_completion(s
->s
);
428 qemu_mutex_unlock(&s
->s
->mutex
);
431 static void curl_multi_timeout_do(void *arg
)
433 #ifdef NEED_CURL_TIMER_CALLBACK
434 BDRVCURLState
*s
= (BDRVCURLState
*)arg
;
441 qemu_mutex_lock(&s
->mutex
);
442 curl_multi_socket_action(s
->multi
, CURL_SOCKET_TIMEOUT
, 0, &running
);
444 curl_multi_check_completion(s
);
445 qemu_mutex_unlock(&s
->mutex
);
451 /* Called with s->mutex held. */
452 static CURLState
*curl_find_state(BDRVCURLState
*s
)
454 CURLState
*state
= NULL
;
457 for (i
= 0; i
< CURL_NUM_STATES
; i
++) {
458 if (!s
->states
[i
].in_use
) {
459 state
= &s
->states
[i
];
467 static int curl_init_state(BDRVCURLState
*s
, CURLState
*state
)
470 state
->curl
= curl_easy_init();
474 curl_easy_setopt(state
->curl
, CURLOPT_URL
, s
->url
);
475 curl_easy_setopt(state
->curl
, CURLOPT_SSL_VERIFYPEER
,
476 (long) s
->sslverify
);
477 curl_easy_setopt(state
->curl
, CURLOPT_SSL_VERIFYHOST
,
478 s
->sslverify
? 2L : 0L);
480 curl_easy_setopt(state
->curl
, CURLOPT_COOKIE
, s
->cookie
);
482 curl_easy_setopt(state
->curl
, CURLOPT_TIMEOUT
, (long)s
->timeout
);
483 curl_easy_setopt(state
->curl
, CURLOPT_WRITEFUNCTION
,
484 (void *)curl_read_cb
);
485 curl_easy_setopt(state
->curl
, CURLOPT_WRITEDATA
, (void *)state
);
486 curl_easy_setopt(state
->curl
, CURLOPT_PRIVATE
, (void *)state
);
487 curl_easy_setopt(state
->curl
, CURLOPT_AUTOREFERER
, 1);
488 curl_easy_setopt(state
->curl
, CURLOPT_FOLLOWLOCATION
, 1);
489 curl_easy_setopt(state
->curl
, CURLOPT_NOSIGNAL
, 1);
490 curl_easy_setopt(state
->curl
, CURLOPT_ERRORBUFFER
, state
->errmsg
);
491 curl_easy_setopt(state
->curl
, CURLOPT_FAILONERROR
, 1);
494 curl_easy_setopt(state
->curl
, CURLOPT_USERNAME
, s
->username
);
497 curl_easy_setopt(state
->curl
, CURLOPT_PASSWORD
, s
->password
);
499 if (s
->proxyusername
) {
500 curl_easy_setopt(state
->curl
,
501 CURLOPT_PROXYUSERNAME
, s
->proxyusername
);
503 if (s
->proxypassword
) {
504 curl_easy_setopt(state
->curl
,
505 CURLOPT_PROXYPASSWORD
, s
->proxypassword
);
508 /* Restrict supported protocols to avoid security issues in the more
509 * obscure protocols. For example, do not allow POP3/SMTP/IMAP see
512 * Restricting protocols is only supported from 7.19.4 upwards.
514 #if LIBCURL_VERSION_NUM >= 0x071304
515 curl_easy_setopt(state
->curl
, CURLOPT_PROTOCOLS
, PROTOCOLS
);
516 curl_easy_setopt(state
->curl
, CURLOPT_REDIR_PROTOCOLS
, PROTOCOLS
);
520 curl_easy_setopt(state
->curl
, CURLOPT_VERBOSE
, 1);
524 QLIST_INIT(&state
->sockets
);
530 /* Called with s->mutex held. */
531 static void curl_clean_state(CURLState
*s
)
534 for (j
= 0; j
< CURL_NUM_ACB
; j
++) {
539 curl_multi_remove_handle(s
->s
->multi
, s
->curl
);
541 while (!QLIST_EMPTY(&s
->sockets
)) {
542 CURLSocket
*socket
= QLIST_FIRST(&s
->sockets
);
544 QLIST_REMOVE(socket
, next
);
550 qemu_co_enter_next(&s
->s
->free_state_waitq
, &s
->s
->mutex
);
553 static void curl_parse_filename(const char *filename
, QDict
*options
,
556 qdict_put_str(options
, CURL_BLOCK_OPT_URL
, filename
);
559 static void curl_detach_aio_context(BlockDriverState
*bs
)
561 BDRVCURLState
*s
= bs
->opaque
;
564 qemu_mutex_lock(&s
->mutex
);
565 for (i
= 0; i
< CURL_NUM_STATES
; i
++) {
566 if (s
->states
[i
].in_use
) {
567 curl_clean_state(&s
->states
[i
]);
569 if (s
->states
[i
].curl
) {
570 curl_easy_cleanup(s
->states
[i
].curl
);
571 s
->states
[i
].curl
= NULL
;
573 g_free(s
->states
[i
].orig_buf
);
574 s
->states
[i
].orig_buf
= NULL
;
577 curl_multi_cleanup(s
->multi
);
580 qemu_mutex_unlock(&s
->mutex
);
582 timer_del(&s
->timer
);
585 static void curl_attach_aio_context(BlockDriverState
*bs
,
586 AioContext
*new_context
)
588 BDRVCURLState
*s
= bs
->opaque
;
590 aio_timer_init(new_context
, &s
->timer
,
591 QEMU_CLOCK_REALTIME
, SCALE_NS
,
592 curl_multi_timeout_do
, s
);
595 s
->multi
= curl_multi_init();
596 s
->aio_context
= new_context
;
597 curl_multi_setopt(s
->multi
, CURLMOPT_SOCKETFUNCTION
, curl_sock_cb
);
598 #ifdef NEED_CURL_TIMER_CALLBACK
599 curl_multi_setopt(s
->multi
, CURLMOPT_TIMERDATA
, s
);
600 curl_multi_setopt(s
->multi
, CURLMOPT_TIMERFUNCTION
, curl_timer_cb
);
604 static QemuOptsList runtime_opts
= {
606 .head
= QTAILQ_HEAD_INITIALIZER(runtime_opts
.head
),
609 .name
= CURL_BLOCK_OPT_URL
,
610 .type
= QEMU_OPT_STRING
,
611 .help
= "URL to open",
614 .name
= CURL_BLOCK_OPT_READAHEAD
,
615 .type
= QEMU_OPT_SIZE
,
616 .help
= "Readahead size",
619 .name
= CURL_BLOCK_OPT_SSLVERIFY
,
620 .type
= QEMU_OPT_BOOL
,
621 .help
= "Verify SSL certificate"
624 .name
= CURL_BLOCK_OPT_TIMEOUT
,
625 .type
= QEMU_OPT_NUMBER
,
626 .help
= "Curl timeout"
629 .name
= CURL_BLOCK_OPT_COOKIE
,
630 .type
= QEMU_OPT_STRING
,
631 .help
= "Pass the cookie or list of cookies with each request"
634 .name
= CURL_BLOCK_OPT_COOKIE_SECRET
,
635 .type
= QEMU_OPT_STRING
,
636 .help
= "ID of secret used as cookie passed with each request"
639 .name
= CURL_BLOCK_OPT_USERNAME
,
640 .type
= QEMU_OPT_STRING
,
641 .help
= "Username for HTTP auth"
644 .name
= CURL_BLOCK_OPT_PASSWORD_SECRET
,
645 .type
= QEMU_OPT_STRING
,
646 .help
= "ID of secret used as password for HTTP auth",
649 .name
= CURL_BLOCK_OPT_PROXY_USERNAME
,
650 .type
= QEMU_OPT_STRING
,
651 .help
= "Username for HTTP proxy auth"
654 .name
= CURL_BLOCK_OPT_PROXY_PASSWORD_SECRET
,
655 .type
= QEMU_OPT_STRING
,
656 .help
= "ID of secret used as password for HTTP proxy auth",
658 { /* end of list */ }
663 static int curl_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
666 BDRVCURLState
*s
= bs
->opaque
;
667 CURLState
*state
= NULL
;
669 Error
*local_err
= NULL
;
672 const char *cookie_secret
;
674 const char *secretid
;
675 const char *protocol_delimiter
;
678 ret
= bdrv_apply_auto_read_only(bs
, "curl driver does not support writes",
684 if (!libcurl_initialized
) {
685 ret
= curl_global_init(CURL_GLOBAL_ALL
);
687 error_setg(errp
, "libcurl initialization failed with %d", ret
);
690 libcurl_initialized
= true;
693 qemu_mutex_init(&s
->mutex
);
694 opts
= qemu_opts_create(&runtime_opts
, NULL
, 0, &error_abort
);
695 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
697 error_propagate(errp
, local_err
);
701 s
->readahead_size
= qemu_opt_get_size(opts
, CURL_BLOCK_OPT_READAHEAD
,
702 CURL_BLOCK_OPT_READAHEAD_DEFAULT
);
703 if ((s
->readahead_size
& 0x1ff) != 0) {
704 error_setg(errp
, "HTTP_READAHEAD_SIZE %zd is not a multiple of 512",
709 s
->timeout
= qemu_opt_get_number(opts
, CURL_BLOCK_OPT_TIMEOUT
,
710 CURL_BLOCK_OPT_TIMEOUT_DEFAULT
);
711 if (s
->timeout
> CURL_TIMEOUT_MAX
) {
712 error_setg(errp
, "timeout parameter is too large or negative");
716 s
->sslverify
= qemu_opt_get_bool(opts
, CURL_BLOCK_OPT_SSLVERIFY
,
717 CURL_BLOCK_OPT_SSLVERIFY_DEFAULT
);
719 cookie
= qemu_opt_get(opts
, CURL_BLOCK_OPT_COOKIE
);
720 cookie_secret
= qemu_opt_get(opts
, CURL_BLOCK_OPT_COOKIE_SECRET
);
722 if (cookie
&& cookie_secret
) {
724 "curl driver cannot handle both cookie and cookie secret");
729 s
->cookie
= qcrypto_secret_lookup_as_utf8(cookie_secret
, errp
);
734 s
->cookie
= g_strdup(cookie
);
737 file
= qemu_opt_get(opts
, CURL_BLOCK_OPT_URL
);
739 error_setg(errp
, "curl block driver requires an 'url' option");
743 if (!strstart(file
, bs
->drv
->protocol_name
, &protocol_delimiter
) ||
744 !strstart(protocol_delimiter
, "://", NULL
))
746 error_setg(errp
, "%s curl driver cannot handle the URL '%s' (does not "
747 "start with '%s://')", bs
->drv
->protocol_name
, file
,
748 bs
->drv
->protocol_name
);
752 s
->username
= g_strdup(qemu_opt_get(opts
, CURL_BLOCK_OPT_USERNAME
));
753 secretid
= qemu_opt_get(opts
, CURL_BLOCK_OPT_PASSWORD_SECRET
);
756 s
->password
= qcrypto_secret_lookup_as_utf8(secretid
, errp
);
762 s
->proxyusername
= g_strdup(
763 qemu_opt_get(opts
, CURL_BLOCK_OPT_PROXY_USERNAME
));
764 secretid
= qemu_opt_get(opts
, CURL_BLOCK_OPT_PROXY_PASSWORD_SECRET
);
766 s
->proxypassword
= qcrypto_secret_lookup_as_utf8(secretid
, errp
);
767 if (!s
->proxypassword
) {
772 trace_curl_open(file
);
773 qemu_co_queue_init(&s
->free_state_waitq
);
774 s
->aio_context
= bdrv_get_aio_context(bs
);
775 s
->url
= g_strdup(file
);
776 qemu_mutex_lock(&s
->mutex
);
777 state
= curl_find_state(s
);
778 qemu_mutex_unlock(&s
->mutex
);
785 if (curl_init_state(s
, state
) < 0) {
789 s
->accept_range
= false;
790 curl_easy_setopt(state
->curl
, CURLOPT_NOBODY
, 1);
791 curl_easy_setopt(state
->curl
, CURLOPT_HEADERFUNCTION
,
793 curl_easy_setopt(state
->curl
, CURLOPT_HEADERDATA
, s
);
794 if (curl_easy_perform(state
->curl
))
796 if (curl_easy_getinfo(state
->curl
, CURLINFO_CONTENT_LENGTH_DOWNLOAD
, &d
)) {
799 /* Prior CURL 7.19.4 return value of 0 could mean that the file size is not
800 * know or the size is zero. From 7.19.4 CURL returns -1 if size is not
801 * known and zero if it is really zero-length file. */
802 #if LIBCURL_VERSION_NUM >= 0x071304
804 pstrcpy(state
->errmsg
, CURL_ERROR_SIZE
,
805 "Server didn't report file size.");
810 pstrcpy(state
->errmsg
, CURL_ERROR_SIZE
,
811 "Unknown file size or zero-length file.");
818 if ((!strncasecmp(s
->url
, "http://", strlen("http://"))
819 || !strncasecmp(s
->url
, "https://", strlen("https://")))
820 && !s
->accept_range
) {
821 pstrcpy(state
->errmsg
, CURL_ERROR_SIZE
,
822 "Server does not support 'range' (byte ranges).");
825 trace_curl_open_size(s
->len
);
827 qemu_mutex_lock(&s
->mutex
);
828 curl_clean_state(state
);
829 qemu_mutex_unlock(&s
->mutex
);
830 curl_easy_cleanup(state
->curl
);
833 curl_attach_aio_context(bs
, bdrv_get_aio_context(bs
));
839 error_setg(errp
, "CURL: Error opening file: %s", state
->errmsg
);
840 curl_easy_cleanup(state
->curl
);
843 qemu_mutex_destroy(&s
->mutex
);
847 g_free(s
->proxyusername
);
848 g_free(s
->proxypassword
);
853 static void curl_setup_preadv(BlockDriverState
*bs
, CURLAIOCB
*acb
)
858 BDRVCURLState
*s
= bs
->opaque
;
860 uint64_t start
= acb
->offset
;
863 qemu_mutex_lock(&s
->mutex
);
865 // In case we have the requested data already (e.g. read-ahead),
866 // we can just call the callback and be done.
867 if (curl_find_buf(s
, start
, acb
->bytes
, acb
)) {
871 // No cache found, so let's start a new request
873 state
= curl_find_state(s
);
877 qemu_co_queue_wait(&s
->free_state_waitq
, &s
->mutex
);
880 if (curl_init_state(s
, state
) < 0) {
881 curl_clean_state(state
);
887 acb
->end
= MIN(acb
->bytes
, s
->len
- start
);
890 g_free(state
->orig_buf
);
891 state
->buf_start
= start
;
892 state
->buf_len
= MIN(acb
->end
+ s
->readahead_size
, s
->len
- start
);
893 end
= start
+ state
->buf_len
- 1;
894 state
->orig_buf
= g_try_malloc(state
->buf_len
);
895 if (state
->buf_len
&& state
->orig_buf
== NULL
) {
896 curl_clean_state(state
);
902 snprintf(state
->range
, 127, "%" PRIu64
"-%" PRIu64
, start
, end
);
903 trace_curl_setup_preadv(acb
->bytes
, start
, state
->range
);
904 curl_easy_setopt(state
->curl
, CURLOPT_RANGE
, state
->range
);
906 curl_multi_add_handle(s
->multi
, state
->curl
);
908 /* Tell curl it needs to kick things off */
909 curl_multi_socket_action(s
->multi
, CURL_SOCKET_TIMEOUT
, 0, &running
);
912 qemu_mutex_unlock(&s
->mutex
);
915 static int coroutine_fn
curl_co_preadv(BlockDriverState
*bs
,
916 uint64_t offset
, uint64_t bytes
, QEMUIOVector
*qiov
, int flags
)
919 .co
= qemu_coroutine_self(),
926 curl_setup_preadv(bs
, &acb
);
927 while (acb
.ret
== -EINPROGRESS
) {
928 qemu_coroutine_yield();
933 static void curl_close(BlockDriverState
*bs
)
935 BDRVCURLState
*s
= bs
->opaque
;
938 curl_detach_aio_context(bs
);
939 qemu_mutex_destroy(&s
->mutex
);
944 g_free(s
->proxyusername
);
945 g_free(s
->proxypassword
);
948 static int64_t curl_getlength(BlockDriverState
*bs
)
950 BDRVCURLState
*s
= bs
->opaque
;
954 static void curl_refresh_filename(BlockDriverState
*bs
)
956 BDRVCURLState
*s
= bs
->opaque
;
958 /* "readahead" and "timeout" do not change the guest-visible data,
960 if (s
->sslverify
!= CURL_BLOCK_OPT_SSLVERIFY_DEFAULT
||
961 s
->cookie
|| s
->username
|| s
->password
|| s
->proxyusername
||
967 pstrcpy(bs
->exact_filename
, sizeof(bs
->exact_filename
), s
->url
);
971 static const char *const curl_strong_runtime_opts
[] = {
973 CURL_BLOCK_OPT_SSLVERIFY
,
974 CURL_BLOCK_OPT_COOKIE
,
975 CURL_BLOCK_OPT_COOKIE_SECRET
,
976 CURL_BLOCK_OPT_USERNAME
,
977 CURL_BLOCK_OPT_PASSWORD_SECRET
,
978 CURL_BLOCK_OPT_PROXY_USERNAME
,
979 CURL_BLOCK_OPT_PROXY_PASSWORD_SECRET
,
984 static BlockDriver bdrv_http
= {
985 .format_name
= "http",
986 .protocol_name
= "http",
988 .instance_size
= sizeof(BDRVCURLState
),
989 .bdrv_parse_filename
= curl_parse_filename
,
990 .bdrv_file_open
= curl_open
,
991 .bdrv_close
= curl_close
,
992 .bdrv_getlength
= curl_getlength
,
994 .bdrv_co_preadv
= curl_co_preadv
,
996 .bdrv_detach_aio_context
= curl_detach_aio_context
,
997 .bdrv_attach_aio_context
= curl_attach_aio_context
,
999 .bdrv_refresh_filename
= curl_refresh_filename
,
1000 .strong_runtime_opts
= curl_strong_runtime_opts
,
1003 static BlockDriver bdrv_https
= {
1004 .format_name
= "https",
1005 .protocol_name
= "https",
1007 .instance_size
= sizeof(BDRVCURLState
),
1008 .bdrv_parse_filename
= curl_parse_filename
,
1009 .bdrv_file_open
= curl_open
,
1010 .bdrv_close
= curl_close
,
1011 .bdrv_getlength
= curl_getlength
,
1013 .bdrv_co_preadv
= curl_co_preadv
,
1015 .bdrv_detach_aio_context
= curl_detach_aio_context
,
1016 .bdrv_attach_aio_context
= curl_attach_aio_context
,
1018 .bdrv_refresh_filename
= curl_refresh_filename
,
1019 .strong_runtime_opts
= curl_strong_runtime_opts
,
1022 static BlockDriver bdrv_ftp
= {
1023 .format_name
= "ftp",
1024 .protocol_name
= "ftp",
1026 .instance_size
= sizeof(BDRVCURLState
),
1027 .bdrv_parse_filename
= curl_parse_filename
,
1028 .bdrv_file_open
= curl_open
,
1029 .bdrv_close
= curl_close
,
1030 .bdrv_getlength
= curl_getlength
,
1032 .bdrv_co_preadv
= curl_co_preadv
,
1034 .bdrv_detach_aio_context
= curl_detach_aio_context
,
1035 .bdrv_attach_aio_context
= curl_attach_aio_context
,
1037 .bdrv_refresh_filename
= curl_refresh_filename
,
1038 .strong_runtime_opts
= curl_strong_runtime_opts
,
1041 static BlockDriver bdrv_ftps
= {
1042 .format_name
= "ftps",
1043 .protocol_name
= "ftps",
1045 .instance_size
= sizeof(BDRVCURLState
),
1046 .bdrv_parse_filename
= curl_parse_filename
,
1047 .bdrv_file_open
= curl_open
,
1048 .bdrv_close
= curl_close
,
1049 .bdrv_getlength
= curl_getlength
,
1051 .bdrv_co_preadv
= curl_co_preadv
,
1053 .bdrv_detach_aio_context
= curl_detach_aio_context
,
1054 .bdrv_attach_aio_context
= curl_attach_aio_context
,
1056 .bdrv_refresh_filename
= curl_refresh_filename
,
1057 .strong_runtime_opts
= curl_strong_runtime_opts
,
1060 static void curl_block_init(void)
1062 bdrv_register(&bdrv_http
);
1063 bdrv_register(&bdrv_https
);
1064 bdrv_register(&bdrv_ftp
);
1065 bdrv_register(&bdrv_ftps
);
1068 block_init(curl_block_init
);