linux-user: Use safe_syscall for open and openat system calls
[qemu.git] / block / curl.c
1 /*
2 * QEMU Block driver for CURL images
3 *
4 * Copyright (c) 2009 Alexander Graf <agraf@suse.de>
5 *
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:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
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
22 * THE SOFTWARE.
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 // #define DEBUG_CURL
36 // #define DEBUG_VERBOSE
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 /* The multi interface timer callback was introduced in 7.16.0 */
52 #define NEED_CURL_TIMER_CALLBACK
53 #define HAVE_SOCKET_ACTION
54 #endif
55
56 #ifndef HAVE_SOCKET_ACTION
57 /* If curl_multi_socket_action isn't available, define it statically here in
58 * terms of curl_multi_socket. Note that ev_bitmask will be ignored, which is
59 * less efficient but still safe. */
60 static 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
95 struct BDRVCURLState;
96
97 typedef 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
109 typedef 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
124 typedef 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
142 static void curl_clean_state(CURLState *s);
143 static void curl_multi_do(void *arg);
144 static void curl_multi_read(void *arg);
145
146 #ifdef NEED_CURL_TIMER_CALLBACK
147 static 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
163 static 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
195 static 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
209 static 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 /* buffer full, read nothing */
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
246 static 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 // Does the existing buffer cover our section?
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 // Wait for unfinished chunks
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
300 static void curl_multi_check_completion(BDRVCURLState *s)
301 {
302 int msgs_in_queue;
303
304 /* Try to find done transfers, so we can free the easy
305 * handle again. */
306 for (;;) {
307 CURLMsg *msg;
308 msg = curl_multi_info_read(s->multi, &msgs_in_queue);
309
310 /* Quit when there are no more completions */
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 /* ACBs for successful messages get completed in curl_read_cb */
320 if (msg->data.result != CURLE_OK) {
321 int i;
322 static int errcount = 100;
323
324 /* Don't lose the original error message from curl, since
325 * it contains extra data.
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
353 static 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
369 static 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
377 static 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
395 static 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 /* Restrict supported protocols to avoid security issues in the more
455 * obscure protocols. For example, do not allow POP3/SMTP/IMAP see
456 * CVE-2013-0249.
457 *
458 * Restricting protocols is only supported from 7.19.4 upwards.
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
475 static 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
482 static 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
488 static 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
512 static 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
531 static 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 { /* end of list */ }
581 },
582 };
583
584
585 static 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 // Get file size
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
701 out:
702 error_setg(errp, "CURL: Error opening file: %s", state->errmsg);
703 curl_easy_cleanup(state->curl);
704 state->curl = NULL;
705 out_noclean:
706 g_free(s->cookie);
707 g_free(s->url);
708 qemu_opts_del(opts);
709 return -EINVAL;
710 }
711
712 static const AIOCBInfo curl_aiocb_info = {
713 .aiocb_size = sizeof(CURLAIOCB),
714 };
715
716
717 static 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 // In case we have the requested data already (e.g. read-ahead),
732 // we can just call the callback and be done.
733 switch (curl_find_buf(s, start, acb->nb_sectors * SECTOR_SIZE, acb)) {
734 case FIND_RET_OK:
735 qemu_aio_unref(acb);
736 // fall through
737 case FIND_RET_WAIT:
738 return;
739 default:
740 break;
741 }
742
743 // No cache found, so let's start a new request
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 /* Tell curl it needs to kick things off */
776 curl_multi_socket_action(s->multi, CURL_SOCKET_TIMEOUT, 0, &running);
777 }
778
779 static 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
796 static 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
807 static int64_t curl_getlength(BlockDriverState *bs)
808 {
809 BDRVCURLState *s = bs->opaque;
810 return s->len;
811 }
812
813 static 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
829 static 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
845 static 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
861 static 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
877 static 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
893 static 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
902 block_init(curl_block_init);