1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include "qemu/osdep.h"
25#include "qapi/error.h"
26#include "qemu-common.h"
27#include "qemu/error-report.h"
28#include "block/block_int.h"
29#include "qapi/qmp/qbool.h"
30#include "qapi/qmp/qstring.h"
31#include "crypto/secret.h"
32#include <curl/curl.h>
33#include "qemu/cutils.h"
34
35
36
37
38#ifdef DEBUG_CURL
39#define DEBUG_CURL_PRINT 1
40#else
41#define DEBUG_CURL_PRINT 0
42#endif
43#define DPRINTF(fmt, ...) \
44 do { \
45 if (DEBUG_CURL_PRINT) { \
46 fprintf(stderr, fmt, ## __VA_ARGS__); \
47 } \
48 } while (0)
49
50#if LIBCURL_VERSION_NUM >= 0x071000
51
52#define NEED_CURL_TIMER_CALLBACK
53#define HAVE_SOCKET_ACTION
54#endif
55
56#ifndef HAVE_SOCKET_ACTION
57
58
59
60static CURLMcode __curl_multi_socket_action(CURLM *multi_handle,
61 curl_socket_t sockfd,
62 int ev_bitmask,
63 int *running_handles)
64{
65 return curl_multi_socket(multi_handle, sockfd, running_handles);
66}
67#define curl_multi_socket_action __curl_multi_socket_action
68#endif
69
70#define PROTOCOLS (CURLPROTO_HTTP | CURLPROTO_HTTPS | \
71 CURLPROTO_FTP | CURLPROTO_FTPS | \
72 CURLPROTO_TFTP)
73
74#define CURL_NUM_STATES 8
75#define CURL_NUM_ACB 8
76#define SECTOR_SIZE 512
77#define READ_AHEAD_DEFAULT (256 * 1024)
78#define CURL_TIMEOUT_DEFAULT 5
79#define CURL_TIMEOUT_MAX 10000
80
81#define FIND_RET_NONE 0
82#define FIND_RET_OK 1
83#define FIND_RET_WAIT 2
84
85#define CURL_BLOCK_OPT_URL "url"
86#define CURL_BLOCK_OPT_READAHEAD "readahead"
87#define CURL_BLOCK_OPT_SSLVERIFY "sslverify"
88#define CURL_BLOCK_OPT_TIMEOUT "timeout"
89#define CURL_BLOCK_OPT_COOKIE "cookie"
90#define CURL_BLOCK_OPT_USERNAME "username"
91#define CURL_BLOCK_OPT_PASSWORD_SECRET "password-secret"
92#define CURL_BLOCK_OPT_PROXY_USERNAME "proxy-username"
93#define CURL_BLOCK_OPT_PROXY_PASSWORD_SECRET "proxy-password-secret"
94
95struct BDRVCURLState;
96
97typedef struct CURLAIOCB {
98 BlockAIOCB common;
99 QEMUBH *bh;
100 QEMUIOVector *qiov;
101
102 int64_t sector_num;
103 int nb_sectors;
104
105 size_t start;
106 size_t end;
107} CURLAIOCB;
108
109typedef struct CURLState
110{
111 struct BDRVCURLState *s;
112 CURLAIOCB *acb[CURL_NUM_ACB];
113 CURL *curl;
114 curl_socket_t sock_fd;
115 char *orig_buf;
116 size_t buf_start;
117 size_t buf_off;
118 size_t buf_len;
119 char range[128];
120 char errmsg[CURL_ERROR_SIZE];
121 char in_use;
122} CURLState;
123
124typedef struct BDRVCURLState {
125 CURLM *multi;
126 QEMUTimer timer;
127 size_t len;
128 CURLState states[CURL_NUM_STATES];
129 char *url;
130 size_t readahead_size;
131 bool sslverify;
132 uint64_t timeout;
133 char *cookie;
134 bool accept_range;
135 AioContext *aio_context;
136 char *username;
137 char *password;
138 char *proxyusername;
139 char *proxypassword;
140} BDRVCURLState;
141
142static void curl_clean_state(CURLState *s);
143static void curl_multi_do(void *arg);
144static void curl_multi_read(void *arg);
145
146#ifdef NEED_CURL_TIMER_CALLBACK
147static int curl_timer_cb(CURLM *multi, long timeout_ms, void *opaque)
148{
149 BDRVCURLState *s = opaque;
150
151 DPRINTF("CURL: timer callback timeout_ms %ld\n", timeout_ms);
152 if (timeout_ms == -1) {
153 timer_del(&s->timer);
154 } else {
155 int64_t timeout_ns = (int64_t)timeout_ms * 1000 * 1000;
156 timer_mod(&s->timer,
157 qemu_clock_get_ns(QEMU_CLOCK_REALTIME) + timeout_ns);
158 }
159 return 0;
160}
161#endif
162
163static int curl_sock_cb(CURL *curl, curl_socket_t fd, int action,
164 void *userp, void *sp)
165{
166 BDRVCURLState *s;
167 CURLState *state = NULL;
168 curl_easy_getinfo(curl, CURLINFO_PRIVATE, (char **)&state);
169 state->sock_fd = fd;
170 s = state->s;
171
172 DPRINTF("CURL (AIO): Sock action %d on fd %d\n", action, fd);
173 switch (action) {
174 case CURL_POLL_IN:
175 aio_set_fd_handler(s->aio_context, fd, false,
176 curl_multi_read, NULL, state);
177 break;
178 case CURL_POLL_OUT:
179 aio_set_fd_handler(s->aio_context, fd, false,
180 NULL, curl_multi_do, state);
181 break;
182 case CURL_POLL_INOUT:
183 aio_set_fd_handler(s->aio_context, fd, false,
184 curl_multi_read, curl_multi_do, state);
185 break;
186 case CURL_POLL_REMOVE:
187 aio_set_fd_handler(s->aio_context, fd, false,
188 NULL, NULL, NULL);
189 break;
190 }
191
192 return 0;
193}
194
195static size_t curl_header_cb(void *ptr, size_t size, size_t nmemb, void *opaque)
196{
197 BDRVCURLState *s = opaque;
198 size_t realsize = size * nmemb;
199 const char *accept_line = "Accept-Ranges: bytes";
200
201 if (realsize >= strlen(accept_line)
202 && strncmp((char *)ptr, accept_line, strlen(accept_line)) == 0) {
203 s->accept_range = true;
204 }
205
206 return realsize;
207}
208
209static size_t curl_read_cb(void *ptr, size_t size, size_t nmemb, void *opaque)
210{
211 CURLState *s = ((CURLState*)opaque);
212 size_t realsize = size * nmemb;
213 int i;
214
215 DPRINTF("CURL: Just reading %zd bytes\n", realsize);
216
217 if (!s || !s->orig_buf)
218 return 0;
219
220 if (s->buf_off >= s->buf_len) {
221
222 return 0;
223 }
224 realsize = MIN(realsize, s->buf_len - s->buf_off);
225 memcpy(s->orig_buf + s->buf_off, ptr, realsize);
226 s->buf_off += realsize;
227
228 for(i=0; i<CURL_NUM_ACB; i++) {
229 CURLAIOCB *acb = s->acb[i];
230
231 if (!acb)
232 continue;
233
234 if ((s->buf_off >= acb->end)) {
235 qemu_iovec_from_buf(acb->qiov, 0, s->orig_buf + acb->start,
236 acb->end - acb->start);
237 acb->common.cb(acb->common.opaque, 0);
238 qemu_aio_unref(acb);
239 s->acb[i] = NULL;
240 }
241 }
242
243 return realsize;
244}
245
246static int curl_find_buf(BDRVCURLState *s, size_t start, size_t len,
247 CURLAIOCB *acb)
248{
249 int i;
250 size_t end = start + len;
251
252 for (i=0; i<CURL_NUM_STATES; i++) {
253 CURLState *state = &s->states[i];
254 size_t buf_end = (state->buf_start + state->buf_off);
255 size_t buf_fend = (state->buf_start + state->buf_len);
256
257 if (!state->orig_buf)
258 continue;
259 if (!state->buf_off)
260 continue;
261
262
263 if ((start >= state->buf_start) &&
264 (start <= buf_end) &&
265 (end >= state->buf_start) &&
266 (end <= buf_end))
267 {
268 char *buf = state->orig_buf + (start - state->buf_start);
269
270 qemu_iovec_from_buf(acb->qiov, 0, buf, len);
271 acb->common.cb(acb->common.opaque, 0);
272
273 return FIND_RET_OK;
274 }
275
276
277 if (state->in_use &&
278 (start >= state->buf_start) &&
279 (start <= buf_fend) &&
280 (end >= state->buf_start) &&
281 (end <= buf_fend))
282 {
283 int j;
284
285 acb->start = start - state->buf_start;
286 acb->end = acb->start + len;
287
288 for (j=0; j<CURL_NUM_ACB; j++) {
289 if (!state->acb[j]) {
290 state->acb[j] = acb;
291 return FIND_RET_WAIT;
292 }
293 }
294 }
295 }
296
297 return FIND_RET_NONE;
298}
299
300static void curl_multi_check_completion(BDRVCURLState *s)
301{
302 int msgs_in_queue;
303
304
305
306 for (;;) {
307 CURLMsg *msg;
308 msg = curl_multi_info_read(s->multi, &msgs_in_queue);
309
310
311 if (!msg)
312 break;
313
314 if (msg->msg == CURLMSG_DONE) {
315 CURLState *state = NULL;
316 curl_easy_getinfo(msg->easy_handle, CURLINFO_PRIVATE,
317 (char **)&state);
318
319
320 if (msg->data.result != CURLE_OK) {
321 int i;
322 static int errcount = 100;
323
324
325
326
327 if (errcount > 0) {
328 error_report("curl: %s", state->errmsg);
329 if (--errcount == 0) {
330 error_report("curl: further errors suppressed");
331 }
332 }
333
334 for (i = 0; i < CURL_NUM_ACB; i++) {
335 CURLAIOCB *acb = state->acb[i];
336
337 if (acb == NULL) {
338 continue;
339 }
340
341 acb->common.cb(acb->common.opaque, -EPROTO);
342 qemu_aio_unref(acb);
343 state->acb[i] = NULL;
344 }
345 }
346
347 curl_clean_state(state);
348 break;
349 }
350 }
351}
352
353static void curl_multi_do(void *arg)
354{
355 CURLState *s = (CURLState *)arg;
356 int running;
357 int r;
358
359 if (!s->s->multi) {
360 return;
361 }
362
363 do {
364 r = curl_multi_socket_action(s->s->multi, s->sock_fd, 0, &running);
365 } while(r == CURLM_CALL_MULTI_PERFORM);
366
367}
368
369static void curl_multi_read(void *arg)
370{
371 CURLState *s = (CURLState *)arg;
372
373 curl_multi_do(arg);
374 curl_multi_check_completion(s->s);
375}
376
377static void curl_multi_timeout_do(void *arg)
378{
379#ifdef NEED_CURL_TIMER_CALLBACK
380 BDRVCURLState *s = (BDRVCURLState *)arg;
381 int running;
382
383 if (!s->multi) {
384 return;
385 }
386
387 curl_multi_socket_action(s->multi, CURL_SOCKET_TIMEOUT, 0, &running);
388
389 curl_multi_check_completion(s);
390#else
391 abort();
392#endif
393}
394
395static CURLState *curl_init_state(BlockDriverState *bs, BDRVCURLState *s)
396{
397 CURLState *state = NULL;
398 int i, j;
399
400 do {
401 for (i=0; i<CURL_NUM_STATES; i++) {
402 for (j=0; j<CURL_NUM_ACB; j++)
403 if (s->states[i].acb[j])
404 continue;
405 if (s->states[i].in_use)
406 continue;
407
408 state = &s->states[i];
409 state->in_use = 1;
410 break;
411 }
412 if (!state) {
413 aio_poll(bdrv_get_aio_context(bs), true);
414 }
415 } while(!state);
416
417 if (!state->curl) {
418 state->curl = curl_easy_init();
419 if (!state->curl) {
420 return NULL;
421 }
422 curl_easy_setopt(state->curl, CURLOPT_URL, s->url);
423 curl_easy_setopt(state->curl, CURLOPT_SSL_VERIFYPEER,
424 (long) s->sslverify);
425 if (s->cookie) {
426 curl_easy_setopt(state->curl, CURLOPT_COOKIE, s->cookie);
427 }
428 curl_easy_setopt(state->curl, CURLOPT_TIMEOUT, (long)s->timeout);
429 curl_easy_setopt(state->curl, CURLOPT_WRITEFUNCTION,
430 (void *)curl_read_cb);
431 curl_easy_setopt(state->curl, CURLOPT_WRITEDATA, (void *)state);
432 curl_easy_setopt(state->curl, CURLOPT_PRIVATE, (void *)state);
433 curl_easy_setopt(state->curl, CURLOPT_AUTOREFERER, 1);
434 curl_easy_setopt(state->curl, CURLOPT_FOLLOWLOCATION, 1);
435 curl_easy_setopt(state->curl, CURLOPT_NOSIGNAL, 1);
436 curl_easy_setopt(state->curl, CURLOPT_ERRORBUFFER, state->errmsg);
437 curl_easy_setopt(state->curl, CURLOPT_FAILONERROR, 1);
438
439 if (s->username) {
440 curl_easy_setopt(state->curl, CURLOPT_USERNAME, s->username);
441 }
442 if (s->password) {
443 curl_easy_setopt(state->curl, CURLOPT_PASSWORD, s->password);
444 }
445 if (s->proxyusername) {
446 curl_easy_setopt(state->curl,
447 CURLOPT_PROXYUSERNAME, s->proxyusername);
448 }
449 if (s->proxypassword) {
450 curl_easy_setopt(state->curl,
451 CURLOPT_PROXYPASSWORD, s->proxypassword);
452 }
453
454
455
456
457
458
459
460#if LIBCURL_VERSION_NUM >= 0x071304
461 curl_easy_setopt(state->curl, CURLOPT_PROTOCOLS, PROTOCOLS);
462 curl_easy_setopt(state->curl, CURLOPT_REDIR_PROTOCOLS, PROTOCOLS);
463#endif
464
465#ifdef DEBUG_VERBOSE
466 curl_easy_setopt(state->curl, CURLOPT_VERBOSE, 1);
467#endif
468 }
469
470 state->s = s;
471
472 return state;
473}
474
475static void curl_clean_state(CURLState *s)
476{
477 if (s->s->multi)
478 curl_multi_remove_handle(s->s->multi, s->curl);
479 s->in_use = 0;
480}
481
482static void curl_parse_filename(const char *filename, QDict *options,
483 Error **errp)
484{
485 qdict_put(options, CURL_BLOCK_OPT_URL, qstring_from_str(filename));
486}
487
488static void curl_detach_aio_context(BlockDriverState *bs)
489{
490 BDRVCURLState *s = bs->opaque;
491 int i;
492
493 for (i = 0; i < CURL_NUM_STATES; i++) {
494 if (s->states[i].in_use) {
495 curl_clean_state(&s->states[i]);
496 }
497 if (s->states[i].curl) {
498 curl_easy_cleanup(s->states[i].curl);
499 s->states[i].curl = NULL;
500 }
501 g_free(s->states[i].orig_buf);
502 s->states[i].orig_buf = NULL;
503 }
504 if (s->multi) {
505 curl_multi_cleanup(s->multi);
506 s->multi = NULL;
507 }
508
509 timer_del(&s->timer);
510}
511
512static void curl_attach_aio_context(BlockDriverState *bs,
513 AioContext *new_context)
514{
515 BDRVCURLState *s = bs->opaque;
516
517 aio_timer_init(new_context, &s->timer,
518 QEMU_CLOCK_REALTIME, SCALE_NS,
519 curl_multi_timeout_do, s);
520
521 assert(!s->multi);
522 s->multi = curl_multi_init();
523 s->aio_context = new_context;
524 curl_multi_setopt(s->multi, CURLMOPT_SOCKETFUNCTION, curl_sock_cb);
525#ifdef NEED_CURL_TIMER_CALLBACK
526 curl_multi_setopt(s->multi, CURLMOPT_TIMERDATA, s);
527 curl_multi_setopt(s->multi, CURLMOPT_TIMERFUNCTION, curl_timer_cb);
528#endif
529}
530
531static QemuOptsList runtime_opts = {
532 .name = "curl",
533 .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
534 .desc = {
535 {
536 .name = CURL_BLOCK_OPT_URL,
537 .type = QEMU_OPT_STRING,
538 .help = "URL to open",
539 },
540 {
541 .name = CURL_BLOCK_OPT_READAHEAD,
542 .type = QEMU_OPT_SIZE,
543 .help = "Readahead size",
544 },
545 {
546 .name = CURL_BLOCK_OPT_SSLVERIFY,
547 .type = QEMU_OPT_BOOL,
548 .help = "Verify SSL certificate"
549 },
550 {
551 .name = CURL_BLOCK_OPT_TIMEOUT,
552 .type = QEMU_OPT_NUMBER,
553 .help = "Curl timeout"
554 },
555 {
556 .name = CURL_BLOCK_OPT_COOKIE,
557 .type = QEMU_OPT_STRING,
558 .help = "Pass the cookie or list of cookies with each request"
559 },
560 {
561 .name = CURL_BLOCK_OPT_USERNAME,
562 .type = QEMU_OPT_STRING,
563 .help = "Username for HTTP auth"
564 },
565 {
566 .name = CURL_BLOCK_OPT_PASSWORD_SECRET,
567 .type = QEMU_OPT_STRING,
568 .help = "ID of secret used as password for HTTP auth",
569 },
570 {
571 .name = CURL_BLOCK_OPT_PROXY_USERNAME,
572 .type = QEMU_OPT_STRING,
573 .help = "Username for HTTP proxy auth"
574 },
575 {
576 .name = CURL_BLOCK_OPT_PROXY_PASSWORD_SECRET,
577 .type = QEMU_OPT_STRING,
578 .help = "ID of secret used as password for HTTP proxy auth",
579 },
580 { }
581 },
582};
583
584
585static int curl_open(BlockDriverState *bs, QDict *options, int flags,
586 Error **errp)
587{
588 BDRVCURLState *s = bs->opaque;
589 CURLState *state = NULL;
590 QemuOpts *opts;
591 Error *local_err = NULL;
592 const char *file;
593 const char *cookie;
594 double d;
595 const char *secretid;
596
597 static int inited = 0;
598
599 if (flags & BDRV_O_RDWR) {
600 error_setg(errp, "curl block device does not support writes");
601 return -EROFS;
602 }
603
604 opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
605 qemu_opts_absorb_qdict(opts, options, &local_err);
606 if (local_err) {
607 error_propagate(errp, local_err);
608 goto out_noclean;
609 }
610
611 s->readahead_size = qemu_opt_get_size(opts, CURL_BLOCK_OPT_READAHEAD,
612 READ_AHEAD_DEFAULT);
613 if ((s->readahead_size & 0x1ff) != 0) {
614 error_setg(errp, "HTTP_READAHEAD_SIZE %zd is not a multiple of 512",
615 s->readahead_size);
616 goto out_noclean;
617 }
618
619 s->timeout = qemu_opt_get_number(opts, CURL_BLOCK_OPT_TIMEOUT,
620 CURL_TIMEOUT_DEFAULT);
621 if (s->timeout > CURL_TIMEOUT_MAX) {
622 error_setg(errp, "timeout parameter is too large or negative");
623 goto out_noclean;
624 }
625
626 s->sslverify = qemu_opt_get_bool(opts, CURL_BLOCK_OPT_SSLVERIFY, true);
627
628 cookie = qemu_opt_get(opts, CURL_BLOCK_OPT_COOKIE);
629 s->cookie = g_strdup(cookie);
630
631 file = qemu_opt_get(opts, CURL_BLOCK_OPT_URL);
632 if (file == NULL) {
633 error_setg(errp, "curl block driver requires an 'url' option");
634 goto out_noclean;
635 }
636
637 s->username = g_strdup(qemu_opt_get(opts, CURL_BLOCK_OPT_USERNAME));
638 secretid = qemu_opt_get(opts, CURL_BLOCK_OPT_PASSWORD_SECRET);
639
640 if (secretid) {
641 s->password = qcrypto_secret_lookup_as_utf8(secretid, errp);
642 if (!s->password) {
643 goto out_noclean;
644 }
645 }
646
647 s->proxyusername = g_strdup(
648 qemu_opt_get(opts, CURL_BLOCK_OPT_PROXY_USERNAME));
649 secretid = qemu_opt_get(opts, CURL_BLOCK_OPT_PROXY_PASSWORD_SECRET);
650 if (secretid) {
651 s->proxypassword = qcrypto_secret_lookup_as_utf8(secretid, errp);
652 if (!s->proxypassword) {
653 goto out_noclean;
654 }
655 }
656
657 if (!inited) {
658 curl_global_init(CURL_GLOBAL_ALL);
659 inited = 1;
660 }
661
662 DPRINTF("CURL: Opening %s\n", file);
663 s->aio_context = bdrv_get_aio_context(bs);
664 s->url = g_strdup(file);
665 state = curl_init_state(bs, s);
666 if (!state)
667 goto out_noclean;
668
669
670
671 s->accept_range = false;
672 curl_easy_setopt(state->curl, CURLOPT_NOBODY, 1);
673 curl_easy_setopt(state->curl, CURLOPT_HEADERFUNCTION,
674 curl_header_cb);
675 curl_easy_setopt(state->curl, CURLOPT_HEADERDATA, s);
676 if (curl_easy_perform(state->curl))
677 goto out;
678 curl_easy_getinfo(state->curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &d);
679 if (d)
680 s->len = (size_t)d;
681 else if(!s->len)
682 goto out;
683 if ((!strncasecmp(s->url, "http://", strlen("http://"))
684 || !strncasecmp(s->url, "https://", strlen("https://")))
685 && !s->accept_range) {
686 pstrcpy(state->errmsg, CURL_ERROR_SIZE,
687 "Server does not support 'range' (byte ranges).");
688 goto out;
689 }
690 DPRINTF("CURL: Size = %zd\n", s->len);
691
692 curl_clean_state(state);
693 curl_easy_cleanup(state->curl);
694 state->curl = NULL;
695
696 curl_attach_aio_context(bs, bdrv_get_aio_context(bs));
697
698 qemu_opts_del(opts);
699 return 0;
700
701out:
702 error_setg(errp, "CURL: Error opening file: %s", state->errmsg);
703 curl_easy_cleanup(state->curl);
704 state->curl = NULL;
705out_noclean:
706 g_free(s->cookie);
707 g_free(s->url);
708 qemu_opts_del(opts);
709 return -EINVAL;
710}
711
712static const AIOCBInfo curl_aiocb_info = {
713 .aiocb_size = sizeof(CURLAIOCB),
714};
715
716
717static void curl_readv_bh_cb(void *p)
718{
719 CURLState *state;
720 int running;
721
722 CURLAIOCB *acb = p;
723 BDRVCURLState *s = acb->common.bs->opaque;
724
725 qemu_bh_delete(acb->bh);
726 acb->bh = NULL;
727
728 size_t start = acb->sector_num * SECTOR_SIZE;
729 size_t end;
730
731
732
733 switch (curl_find_buf(s, start, acb->nb_sectors * SECTOR_SIZE, acb)) {
734 case FIND_RET_OK:
735 qemu_aio_unref(acb);
736
737 case FIND_RET_WAIT:
738 return;
739 default:
740 break;
741 }
742
743
744 state = curl_init_state(acb->common.bs, s);
745 if (!state) {
746 acb->common.cb(acb->common.opaque, -EIO);
747 qemu_aio_unref(acb);
748 return;
749 }
750
751 acb->start = 0;
752 acb->end = (acb->nb_sectors * SECTOR_SIZE);
753
754 state->buf_off = 0;
755 g_free(state->orig_buf);
756 state->buf_start = start;
757 state->buf_len = acb->end + s->readahead_size;
758 end = MIN(start + state->buf_len, s->len) - 1;
759 state->orig_buf = g_try_malloc(state->buf_len);
760 if (state->buf_len && state->orig_buf == NULL) {
761 curl_clean_state(state);
762 acb->common.cb(acb->common.opaque, -ENOMEM);
763 qemu_aio_unref(acb);
764 return;
765 }
766 state->acb[0] = acb;
767
768 snprintf(state->range, 127, "%zd-%zd", start, end);
769 DPRINTF("CURL (AIO): Reading %d at %zd (%s)\n",
770 (acb->nb_sectors * SECTOR_SIZE), start, state->range);
771 curl_easy_setopt(state->curl, CURLOPT_RANGE, state->range);
772
773 curl_multi_add_handle(s->multi, state->curl);
774
775
776 curl_multi_socket_action(s->multi, CURL_SOCKET_TIMEOUT, 0, &running);
777}
778
779static BlockAIOCB *curl_aio_readv(BlockDriverState *bs,
780 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
781 BlockCompletionFunc *cb, void *opaque)
782{
783 CURLAIOCB *acb;
784
785 acb = qemu_aio_get(&curl_aiocb_info, bs, cb, opaque);
786
787 acb->qiov = qiov;
788 acb->sector_num = sector_num;
789 acb->nb_sectors = nb_sectors;
790
791 acb->bh = aio_bh_new(bdrv_get_aio_context(bs), curl_readv_bh_cb, acb);
792 qemu_bh_schedule(acb->bh);
793 return &acb->common;
794}
795
796static void curl_close(BlockDriverState *bs)
797{
798 BDRVCURLState *s = bs->opaque;
799
800 DPRINTF("CURL: Close\n");
801 curl_detach_aio_context(bs);
802
803 g_free(s->cookie);
804 g_free(s->url);
805}
806
807static int64_t curl_getlength(BlockDriverState *bs)
808{
809 BDRVCURLState *s = bs->opaque;
810 return s->len;
811}
812
813static BlockDriver bdrv_http = {
814 .format_name = "http",
815 .protocol_name = "http",
816
817 .instance_size = sizeof(BDRVCURLState),
818 .bdrv_parse_filename = curl_parse_filename,
819 .bdrv_file_open = curl_open,
820 .bdrv_close = curl_close,
821 .bdrv_getlength = curl_getlength,
822
823 .bdrv_aio_readv = curl_aio_readv,
824
825 .bdrv_detach_aio_context = curl_detach_aio_context,
826 .bdrv_attach_aio_context = curl_attach_aio_context,
827};
828
829static BlockDriver bdrv_https = {
830 .format_name = "https",
831 .protocol_name = "https",
832
833 .instance_size = sizeof(BDRVCURLState),
834 .bdrv_parse_filename = curl_parse_filename,
835 .bdrv_file_open = curl_open,
836 .bdrv_close = curl_close,
837 .bdrv_getlength = curl_getlength,
838
839 .bdrv_aio_readv = curl_aio_readv,
840
841 .bdrv_detach_aio_context = curl_detach_aio_context,
842 .bdrv_attach_aio_context = curl_attach_aio_context,
843};
844
845static BlockDriver bdrv_ftp = {
846 .format_name = "ftp",
847 .protocol_name = "ftp",
848
849 .instance_size = sizeof(BDRVCURLState),
850 .bdrv_parse_filename = curl_parse_filename,
851 .bdrv_file_open = curl_open,
852 .bdrv_close = curl_close,
853 .bdrv_getlength = curl_getlength,
854
855 .bdrv_aio_readv = curl_aio_readv,
856
857 .bdrv_detach_aio_context = curl_detach_aio_context,
858 .bdrv_attach_aio_context = curl_attach_aio_context,
859};
860
861static BlockDriver bdrv_ftps = {
862 .format_name = "ftps",
863 .protocol_name = "ftps",
864
865 .instance_size = sizeof(BDRVCURLState),
866 .bdrv_parse_filename = curl_parse_filename,
867 .bdrv_file_open = curl_open,
868 .bdrv_close = curl_close,
869 .bdrv_getlength = curl_getlength,
870
871 .bdrv_aio_readv = curl_aio_readv,
872
873 .bdrv_detach_aio_context = curl_detach_aio_context,
874 .bdrv_attach_aio_context = curl_attach_aio_context,
875};
876
877static BlockDriver bdrv_tftp = {
878 .format_name = "tftp",
879 .protocol_name = "tftp",
880
881 .instance_size = sizeof(BDRVCURLState),
882 .bdrv_parse_filename = curl_parse_filename,
883 .bdrv_file_open = curl_open,
884 .bdrv_close = curl_close,
885 .bdrv_getlength = curl_getlength,
886
887 .bdrv_aio_readv = curl_aio_readv,
888
889 .bdrv_detach_aio_context = curl_detach_aio_context,
890 .bdrv_attach_aio_context = curl_attach_aio_context,
891};
892
893static void curl_block_init(void)
894{
895 bdrv_register(&bdrv_http);
896 bdrv_register(&bdrv_https);
897 bdrv_register(&bdrv_ftp);
898 bdrv_register(&bdrv_ftps);
899 bdrv_register(&bdrv_tftp);
900}
901
902block_init(curl_block_init);
903