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
  73 #define CURL_NUM_STATES 8
  74 #define CURL_NUM_ACB    8
  75 #define READ_AHEAD_DEFAULT (256 * 1024)
  76 #define CURL_TIMEOUT_DEFAULT 5
  77 #define CURL_TIMEOUT_MAX 10000
  78
  79 #define FIND_RET_NONE   0
  80 #define FIND_RET_OK     1
  81 #define FIND_RET_WAIT   2
  82
  83 #define CURL_BLOCK_OPT_URL       "url"
  84 #define CURL_BLOCK_OPT_READAHEAD "readahead"
  85 #define CURL_BLOCK_OPT_SSLVERIFY "sslverify"
  86 #define CURL_BLOCK_OPT_TIMEOUT "timeout"
  87 #define CURL_BLOCK_OPT_COOKIE    "cookie"
  88 #define CURL_BLOCK_OPT_USERNAME "username"
  89 #define CURL_BLOCK_OPT_PASSWORD_SECRET "password-secret"
  90 #define CURL_BLOCK_OPT_PROXY_USERNAME "proxy-username"
  91 #define CURL_BLOCK_OPT_PROXY_PASSWORD_SECRET "proxy-password-secret"
  92
  93 struct BDRVCURLState;
  94
  95 typedef struct CURLAIOCB {
  96     BlockAIOCB common;
  97     QEMUIOVector *qiov;
  98
  99     int64_t sector_num;
 100     int nb_sectors;
 101
 102     size_t start;
 103     size_t end;
 104 } CURLAIOCB;
 105
 106 typedef struct CURLSocket {
 107     int fd;
 108     QLIST_ENTRY(CURLSocket) next;
 109 } CURLSocket;
 110
 111 typedef struct CURLState
 112 {
 113     struct BDRVCURLState *s;
 114     CURLAIOCB *acb[CURL_NUM_ACB];
 115     CURL *curl;
 116     QLIST_HEAD(, CURLSocket) sockets;
 117     char *orig_buf;
 118     size_t buf_start;
 119     size_t buf_off;
 120     size_t buf_len;
 121     char range[128];
 122     char errmsg[CURL_ERROR_SIZE];
 123     char in_use;
 124 } CURLState;
 125
 126 typedef struct BDRVCURLState {
 127     CURLM *multi;
 128     QEMUTimer timer;
 129     size_t len;
 130     CURLState states[CURL_NUM_STATES];
 131     char *url;
 132     size_t readahead_size;
 133     bool sslverify;
 134     uint64_t timeout;
 135     char *cookie;
 136     bool accept_range;
 137     AioContext *aio_context;
 138     QemuMutex mutex;
 139     char *username;
 140     char *password;
 141     char *proxyusername;
 142     char *proxypassword;
 143 } BDRVCURLState;
 144
 145 static void curl_clean_state(CURLState *s);
 146 static void curl_multi_do(void *arg);
 147 static void curl_multi_read(void *arg);
 148
 149 #ifdef NEED_CURL_TIMER_CALLBACK
 150 static int curl_timer_cb(CURLM *multi, long timeout_ms, void *opaque)
 151 {
 152     BDRVCURLState *s = opaque;
 153
 154     DPRINTF("CURL: timer callback timeout_ms %ld\n", timeout_ms);
 155     if (timeout_ms == -1) {
 156         timer_del(&s->timer);
 157     } else {
 158         int64_t timeout_ns = (int64_t)timeout_ms * 1000 * 1000;
 159         timer_mod(&s->timer,
 160                   qemu_clock_get_ns(QEMU_CLOCK_REALTIME) + timeout_ns);
 161     }
 162     return 0;
 163 }
 164 #endif
 165
 166 static int curl_sock_cb(CURL *curl, curl_socket_t fd, int action,
 167                         void *userp, void *sp)
 168 {
 169     BDRVCURLState *s;
 170     CURLState *state = NULL;
 171     CURLSocket *socket;
 172
 173     curl_easy_getinfo(curl, CURLINFO_PRIVATE, (char **)&state);
 174     s = state->s;
 175
 176     QLIST_FOREACH(socket, &state->sockets, next) {
 177         if (socket->fd == fd) {
 178             if (action == CURL_POLL_REMOVE) {
 179                 QLIST_REMOVE(socket, next);
 180                 g_free(socket);
 181             }
 182             break;
 183         }
 184     }
 185     if (!socket) {
 186         socket = g_new0(CURLSocket, 1);
 187         socket->fd = fd;
 188         QLIST_INSERT_HEAD(&state->sockets, socket, next);
 189     }
 190     socket = NULL;
 191
 192     DPRINTF("CURL (AIO): Sock action %d on fd %d\n", action, (int)fd);
 193     switch (action) {
 194         case CURL_POLL_IN:
 195             aio_set_fd_handler(s->aio_context, fd, false,
 196                                curl_multi_read, NULL, NULL, state);
 197             break;
 198         case CURL_POLL_OUT:
 199             aio_set_fd_handler(s->aio_context, fd, false,
 200                                NULL, curl_multi_do, NULL, state);
 201             break;
 202         case CURL_POLL_INOUT:
 203             aio_set_fd_handler(s->aio_context, fd, false,
 204                                curl_multi_read, curl_multi_do, NULL, state);
 205             break;
 206         case CURL_POLL_REMOVE:
 207             aio_set_fd_handler(s->aio_context, fd, false,
 208                                NULL, NULL, NULL, NULL);
 209             break;
 210     }
 211
 212     return 0;
 213 }
 214
 215 static size_t curl_header_cb(void *ptr, size_t size, size_t nmemb, void *opaque)
 216 {
 217     BDRVCURLState *s = opaque;
 218     size_t realsize = size * nmemb;
 219     const char *accept_line = "Accept-Ranges: bytes";
 220
 221     if (realsize >= strlen(accept_line)
 222         && strncmp((char *)ptr, accept_line, strlen(accept_line)) == 0) {
 223         s->accept_range = true;
 224     }
 225
 226     return realsize;
 227 }
 228
 229 static size_t curl_read_cb(void *ptr, size_t size, size_t nmemb, void *opaque)
 230 {
 231     CURLState *s = ((CURLState*)opaque);
 232     size_t realsize = size * nmemb;
 233     int i;
 234
 235     DPRINTF("CURL: Just reading %zd bytes\n", realsize);
 236
 237     if (!s || !s->orig_buf) {
 238         goto read_end;
 239     }
 240
 241     if (s->buf_off >= s->buf_len) {
 242         /* buffer full, read nothing */
 243         goto read_end;
 244     }
 245     realsize = MIN(realsize, s->buf_len - s->buf_off);
 246     memcpy(s->orig_buf + s->buf_off, ptr, realsize);
 247     s->buf_off += realsize;
 248
 249     for(i=0; i<CURL_NUM_ACB; i++) {
 250         CURLAIOCB *acb = s->acb[i];
 251
 252         if (!acb)
 253             continue;
 254
 255         if ((s->buf_off >= acb->end)) {
 256             size_t request_length = acb->nb_sectors * BDRV_SECTOR_SIZE;
 257
 258             qemu_iovec_from_buf(acb->qiov, 0, s->orig_buf + acb->start,
 259                                 acb->end - acb->start);
 260
 261             if (acb->end - acb->start < request_length) {
 262                 size_t offset = acb->end - acb->start;
 263                 qemu_iovec_memset(acb->qiov, offset, 0,
 264                                   request_length - offset);
 265             }
 266
 267             acb->common.cb(acb->common.opaque, 0);
 268             qemu_aio_unref(acb);
 269             s->acb[i] = NULL;
 270         }
 271     }
 272
 273 read_end:
 274     /* curl will error out if we do not return this value */
 275     return size * nmemb;
 276 }
 277
 278 static int curl_find_buf(BDRVCURLState *s, size_t start, size_t len,
 279                          CURLAIOCB *acb)
 280 {
 281     int i;
 282     size_t end = start + len;
 283     size_t clamped_end = MIN(end, s->len);
 284     size_t clamped_len = clamped_end - start;
 285
 286     for (i=0; i<CURL_NUM_STATES; i++) {
 287         CURLState *state = &s->states[i];
 288         size_t buf_end = (state->buf_start + state->buf_off);
 289         size_t buf_fend = (state->buf_start + state->buf_len);
 290
 291         if (!state->orig_buf)
 292             continue;
 293         if (!state->buf_off)
 294             continue;
 295
 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))
 301         {
 302             char *buf = state->orig_buf + (start - state->buf_start);
 303
 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);
 307             }
 308             acb->common.cb(acb->common.opaque, 0);
 309
 310             return FIND_RET_OK;
 311         }
 312
 313         // Wait for unfinished chunks
 314         if (state->in_use &&
 315             (start >= state->buf_start) &&
 316             (start <= buf_fend) &&
 317             (clamped_end >= state->buf_start) &&
 318             (clamped_end <= buf_fend))
 319         {
 320             int j;
 321
 322             acb->start = start - state->buf_start;
 323             acb->end = acb->start + clamped_len;
 324
 325             for (j=0; j<CURL_NUM_ACB; j++) {
 326                 if (!state->acb[j]) {
 327                     state->acb[j] = acb;
 328                     return FIND_RET_WAIT;
 329                 }
 330             }
 331         }
 332     }
 333
 334     return FIND_RET_NONE;
 335 }
 336
 337 /* Called with s->mutex held.  */
 338 static void curl_multi_check_completion(BDRVCURLState *s)
 339 {
 340     int msgs_in_queue;
 341
 342     /* Try to find done transfers, so we can free the easy
 343      * handle again. */
 344     for (;;) {
 345         CURLMsg *msg;
 346         msg = curl_multi_info_read(s->multi, &msgs_in_queue);
 347
 348         /* Quit when there are no more completions */
 349         if (!msg)
 350             break;
 351
 352         if (msg->msg == CURLMSG_DONE) {
 353             CURLState *state = NULL;
 354             curl_easy_getinfo(msg->easy_handle, CURLINFO_PRIVATE,
 355                               (char **)&state);
 356
 357             /* ACBs for successful messages get completed in curl_read_cb */
 358             if (msg->data.result != CURLE_OK) {
 359                 int i;
 360                 static int errcount = 100;
 361
 362                 /* Don't lose the original error message from curl, since
 363                  * it contains extra data.
 364                  */
 365                 if (errcount > 0) {
 366                     error_report("curl: %s", state->errmsg);
 367                     if (--errcount == 0) {
 368                         error_report("curl: further errors suppressed");
 369                     }
 370                 }
 371
 372                 for (i = 0; i < CURL_NUM_ACB; i++) {
 373                     CURLAIOCB *acb = state->acb[i];
 374
 375                     if (acb == NULL) {
 376                         continue;
 377                     }
 378
 379                     qemu_mutex_unlock(&s->mutex);
 380                     acb->common.cb(acb->common.opaque, -EIO);
 381                     qemu_mutex_lock(&s->mutex);
 382                     qemu_aio_unref(acb);
 383                     state->acb[i] = NULL;
 384                 }
 385             }
 386
 387             curl_clean_state(state);
 388             break;
 389         }
 390     }
 391 }
 392
 393 /* Called with s->mutex held.  */
 394 static void curl_multi_do_locked(CURLState *s)
 395 {
 396     CURLSocket *socket, *next_socket;
 397     int running;
 398     int r;
 399
 400     if (!s->s->multi) {
 401         return;
 402     }
 403
 404     /* Need to use _SAFE because curl_multi_socket_action() may trigger
 405      * curl_sock_cb() which might modify this list */
 406     QLIST_FOREACH_SAFE(socket, &s->sockets, next, next_socket) {
 407         do {
 408             r = curl_multi_socket_action(s->s->multi, socket->fd, 0, &running);
 409         } while (r == CURLM_CALL_MULTI_PERFORM);
 410     }
 411 }
 412
 413 static void curl_multi_do(void *arg)
 414 {
 415     CURLState *s = (CURLState *)arg;
 416
 417     qemu_mutex_lock(&s->s->mutex);
 418     curl_multi_do_locked(s);
 419     qemu_mutex_unlock(&s->s->mutex);
 420 }
 421
 422 static void curl_multi_read(void *arg)
 423 {
 424     CURLState *s = (CURLState *)arg;
 425
 426     qemu_mutex_lock(&s->s->mutex);
 427     curl_multi_do_locked(s);
 428     curl_multi_check_completion(s->s);
 429     qemu_mutex_unlock(&s->s->mutex);
 430 }
 431
 432 static void curl_multi_timeout_do(void *arg)
 433 {
 434 #ifdef NEED_CURL_TIMER_CALLBACK
 435     BDRVCURLState *s = (BDRVCURLState *)arg;
 436     int running;
 437
 438     if (!s->multi) {
 439         return;
 440     }
 441
 442     qemu_mutex_lock(&s->mutex);
 443     curl_multi_socket_action(s->multi, CURL_SOCKET_TIMEOUT, 0, &running);
 444
 445     curl_multi_check_completion(s);
 446     qemu_mutex_unlock(&s->mutex);
 447 #else
 448     abort();
 449 #endif
 450 }
 451
 452 static CURLState *curl_init_state(BlockDriverState *bs, BDRVCURLState *s)
 453 {
 454     CURLState *state = NULL;
 455     int i, j;
 456
 457     do {
 458         for (i=0; i<CURL_NUM_STATES; i++) {
 459             for (j=0; j<CURL_NUM_ACB; j++)
 460                 if (s->states[i].acb[j])
 461                     continue;
 462             if (s->states[i].in_use)
 463                 continue;
 464
 465             state = &s->states[i];
 466             state->in_use = 1;
 467             break;
 468         }
 469         if (!state) {
 470             aio_poll(bdrv_get_aio_context(bs), true);
 471         }
 472     } while(!state);
 473
 474     if (!state->curl) {
 475         state->curl = curl_easy_init();
 476         if (!state->curl) {
 477             return NULL;
 478         }
 479         curl_easy_setopt(state->curl, CURLOPT_URL, s->url);
 480         curl_easy_setopt(state->curl, CURLOPT_SSL_VERIFYPEER,
 481                          (long) s->sslverify);
 482         if (s->cookie) {
 483             curl_easy_setopt(state->curl, CURLOPT_COOKIE, s->cookie);
 484         }
 485         curl_easy_setopt(state->curl, CURLOPT_TIMEOUT, (long)s->timeout);
 486         curl_easy_setopt(state->curl, CURLOPT_WRITEFUNCTION,
 487                          (void *)curl_read_cb);
 488         curl_easy_setopt(state->curl, CURLOPT_WRITEDATA, (void *)state);
 489         curl_easy_setopt(state->curl, CURLOPT_PRIVATE, (void *)state);
 490         curl_easy_setopt(state->curl, CURLOPT_AUTOREFERER, 1);
 491         curl_easy_setopt(state->curl, CURLOPT_FOLLOWLOCATION, 1);
 492         curl_easy_setopt(state->curl, CURLOPT_NOSIGNAL, 1);
 493         curl_easy_setopt(state->curl, CURLOPT_ERRORBUFFER, state->errmsg);
 494         curl_easy_setopt(state->curl, CURLOPT_FAILONERROR, 1);
 495
 496         if (s->username) {
 497             curl_easy_setopt(state->curl, CURLOPT_USERNAME, s->username);
 498         }
 499         if (s->password) {
 500             curl_easy_setopt(state->curl, CURLOPT_PASSWORD, s->password);
 501         }
 502         if (s->proxyusername) {
 503             curl_easy_setopt(state->curl,
 504                              CURLOPT_PROXYUSERNAME, s->proxyusername);
 505         }
 506         if (s->proxypassword) {
 507             curl_easy_setopt(state->curl,
 508                              CURLOPT_PROXYPASSWORD, s->proxypassword);
 509         }
 510
 511         /* Restrict supported protocols to avoid security issues in the more
 512          * obscure protocols.  For example, do not allow POP3/SMTP/IMAP see
 513          * CVE-2013-0249.
 514          *
 515          * Restricting protocols is only supported from 7.19.4 upwards.
 516          */
 517 #if LIBCURL_VERSION_NUM >= 0x071304
 518         curl_easy_setopt(state->curl, CURLOPT_PROTOCOLS, PROTOCOLS);
 519         curl_easy_setopt(state->curl, CURLOPT_REDIR_PROTOCOLS, PROTOCOLS);
 520 #endif
 521
 522 #ifdef DEBUG_VERBOSE
 523         curl_easy_setopt(state->curl, CURLOPT_VERBOSE, 1);
 524 #endif
 525     }
 526
 527     QLIST_INIT(&state->sockets);
 528     state->s = s;
 529
 530     return state;
 531 }
 532
 533 static void curl_clean_state(CURLState *s)
 534 {
 535     if (s->s->multi)
 536         curl_multi_remove_handle(s->s->multi, s->curl);
 537
 538     while (!QLIST_EMPTY(&s->sockets)) {
 539         CURLSocket *socket = QLIST_FIRST(&s->sockets);
 540
 541         QLIST_REMOVE(socket, next);
 542         g_free(socket);
 543     }
 544
 545     s->in_use = 0;
 546 }
 547
 548 static void curl_parse_filename(const char *filename, QDict *options,
 549                                 Error **errp)
 550 {
 551     qdict_put_str(options, CURL_BLOCK_OPT_URL, filename);
 552 }
 553
 554 static void curl_detach_aio_context(BlockDriverState *bs)
 555 {
 556     BDRVCURLState *s = bs->opaque;
 557     int i;
 558
 559     for (i = 0; i < CURL_NUM_STATES; i++) {
 560         if (s->states[i].in_use) {
 561             curl_clean_state(&s->states[i]);
 562         }
 563         if (s->states[i].curl) {
 564             curl_easy_cleanup(s->states[i].curl);
 565             s->states[i].curl = NULL;
 566         }
 567         g_free(s->states[i].orig_buf);
 568         s->states[i].orig_buf = NULL;
 569     }
 570     if (s->multi) {
 571         curl_multi_cleanup(s->multi);
 572         s->multi = NULL;
 573     }
 574
 575     timer_del(&s->timer);
 576 }
 577
 578 static void curl_attach_aio_context(BlockDriverState *bs,
 579                                     AioContext *new_context)
 580 {
 581     BDRVCURLState *s = bs->opaque;
 582
 583     aio_timer_init(new_context, &s->timer,
 584                    QEMU_CLOCK_REALTIME, SCALE_NS,
 585                    curl_multi_timeout_do, s);
 586
 587     assert(!s->multi);
 588     s->multi = curl_multi_init();
 589     s->aio_context = new_context;
 590     curl_multi_setopt(s->multi, CURLMOPT_SOCKETFUNCTION, curl_sock_cb);
 591 #ifdef NEED_CURL_TIMER_CALLBACK
 592     curl_multi_setopt(s->multi, CURLMOPT_TIMERDATA, s);
 593     curl_multi_setopt(s->multi, CURLMOPT_TIMERFUNCTION, curl_timer_cb);
 594 #endif
 595 }
 596
 597 static QemuOptsList runtime_opts = {
 598     .name = "curl",
 599     .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
 600     .desc = {
 601         {
 602             .name = CURL_BLOCK_OPT_URL,
 603             .type = QEMU_OPT_STRING,
 604             .help = "URL to open",
 605         },
 606         {
 607             .name = CURL_BLOCK_OPT_READAHEAD,
 608             .type = QEMU_OPT_SIZE,
 609             .help = "Readahead size",
 610         },
 611         {
 612             .name = CURL_BLOCK_OPT_SSLVERIFY,
 613             .type = QEMU_OPT_BOOL,
 614             .help = "Verify SSL certificate"
 615         },
 616         {
 617             .name = CURL_BLOCK_OPT_TIMEOUT,
 618             .type = QEMU_OPT_NUMBER,
 619             .help = "Curl timeout"
 620         },
 621         {
 622             .name = CURL_BLOCK_OPT_COOKIE,
 623             .type = QEMU_OPT_STRING,
 624             .help = "Pass the cookie or list of cookies with each request"
 625         },
 626         {
 627             .name = CURL_BLOCK_OPT_USERNAME,
 628             .type = QEMU_OPT_STRING,
 629             .help = "Username for HTTP auth"
 630         },
 631         {
 632             .name = CURL_BLOCK_OPT_PASSWORD_SECRET,
 633             .type = QEMU_OPT_STRING,
 634             .help = "ID of secret used as password for HTTP auth",
 635         },
 636         {
 637             .name = CURL_BLOCK_OPT_PROXY_USERNAME,
 638             .type = QEMU_OPT_STRING,
 639             .help = "Username for HTTP proxy auth"
 640         },
 641         {
 642             .name = CURL_BLOCK_OPT_PROXY_PASSWORD_SECRET,
 643             .type = QEMU_OPT_STRING,
 644             .help = "ID of secret used as password for HTTP proxy auth",
 645         },
 646         { /* end of list */ }
 647     },
 648 };
 649
 650
 651 static int curl_open(BlockDriverState *bs, QDict *options, int flags,
 652                      Error **errp)
 653 {
 654     BDRVCURLState *s = bs->opaque;
 655     CURLState *state = NULL;
 656     QemuOpts *opts;
 657     Error *local_err = NULL;
 658     const char *file;
 659     const char *cookie;
 660     double d;
 661     const char *secretid;
 662     const char *protocol_delimiter;
 663
 664     static int inited = 0;
 665
 666     if (flags & BDRV_O_RDWR) {
 667         error_setg(errp, "curl block device does not support writes");
 668         return -EROFS;
 669     }
 670
 671     opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
 672     qemu_opts_absorb_qdict(opts, options, &local_err);
 673     if (local_err) {
 674         error_propagate(errp, local_err);
 675         goto out_noclean;
 676     }
 677
 678     s->readahead_size = qemu_opt_get_size(opts, CURL_BLOCK_OPT_READAHEAD,
 679                                           READ_AHEAD_DEFAULT);
 680     if ((s->readahead_size & 0x1ff) != 0) {
 681         error_setg(errp, "HTTP_READAHEAD_SIZE %zd is not a multiple of 512",
 682                    s->readahead_size);
 683         goto out_noclean;
 684     }
 685
 686     s->timeout = qemu_opt_get_number(opts, CURL_BLOCK_OPT_TIMEOUT,
 687                                      CURL_TIMEOUT_DEFAULT);
 688     if (s->timeout > CURL_TIMEOUT_MAX) {
 689         error_setg(errp, "timeout parameter is too large or negative");
 690         goto out_noclean;
 691     }
 692
 693     s->sslverify = qemu_opt_get_bool(opts, CURL_BLOCK_OPT_SSLVERIFY, true);
 694
 695     cookie = qemu_opt_get(opts, CURL_BLOCK_OPT_COOKIE);
 696     s->cookie = g_strdup(cookie);
 697
 698     file = qemu_opt_get(opts, CURL_BLOCK_OPT_URL);
 699     if (file == NULL) {
 700         error_setg(errp, "curl block driver requires an 'url' option");
 701         goto out_noclean;
 702     }
 703
 704     if (!strstart(file, bs->drv->protocol_name, &protocol_delimiter) ||
 705         !strstart(protocol_delimiter, "://", NULL))
 706     {
 707         error_setg(errp, "%s curl driver cannot handle the URL '%s' (does not "
 708                    "start with '%s://')", bs->drv->protocol_name, file,
 709                    bs->drv->protocol_name);
 710         goto out_noclean;
 711     }
 712
 713     s->username = g_strdup(qemu_opt_get(opts, CURL_BLOCK_OPT_USERNAME));
 714     secretid = qemu_opt_get(opts, CURL_BLOCK_OPT_PASSWORD_SECRET);
 715
 716     if (secretid) {
 717         s->password = qcrypto_secret_lookup_as_utf8(secretid, errp);
 718         if (!s->password) {
 719             goto out_noclean;
 720         }
 721     }
 722
 723     s->proxyusername = g_strdup(
 724         qemu_opt_get(opts, CURL_BLOCK_OPT_PROXY_USERNAME));
 725     secretid = qemu_opt_get(opts, CURL_BLOCK_OPT_PROXY_PASSWORD_SECRET);
 726     if (secretid) {
 727         s->proxypassword = qcrypto_secret_lookup_as_utf8(secretid, errp);
 728         if (!s->proxypassword) {
 729             goto out_noclean;
 730         }
 731     }
 732
 733     if (!inited) {
 734         curl_global_init(CURL_GLOBAL_ALL);
 735         inited = 1;
 736     }
 737
 738     DPRINTF("CURL: Opening %s\n", file);
 739     s->aio_context = bdrv_get_aio_context(bs);
 740     s->url = g_strdup(file);
 741     state = curl_init_state(bs, s);
 742     if (!state)
 743         goto out_noclean;
 744
 745     // Get file size
 746
 747     s->accept_range = false;
 748     curl_easy_setopt(state->curl, CURLOPT_NOBODY, 1);
 749     curl_easy_setopt(state->curl, CURLOPT_HEADERFUNCTION,
 750                      curl_header_cb);
 751     curl_easy_setopt(state->curl, CURLOPT_HEADERDATA, s);
 752     if (curl_easy_perform(state->curl))
 753         goto out;
 754     if (curl_easy_getinfo(state->curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &d)) {
 755         goto out;
 756     }
 757     /* Prior CURL 7.19.4 return value of 0 could mean that the file size is not
 758      * know or the size is zero. From 7.19.4 CURL returns -1 if size is not
 759      * known and zero if it is realy zero-length file. */
 760 #if LIBCURL_VERSION_NUM >= 0x071304
 761     if (d < 0) {
 762         pstrcpy(state->errmsg, CURL_ERROR_SIZE,
 763                 "Server didn't report file size.");
 764         goto out;
 765     }
 766 #else
 767     if (d <= 0) {
 768         pstrcpy(state->errmsg, CURL_ERROR_SIZE,
 769                 "Unknown file size or zero-length file.");
 770         goto out;
 771     }
 772 #endif
 773
 774     s->len = (size_t)d;
 775
 776     if ((!strncasecmp(s->url, "http://", strlen("http://"))
 777         || !strncasecmp(s->url, "https://", strlen("https://")))
 778         && !s->accept_range) {
 779         pstrcpy(state->errmsg, CURL_ERROR_SIZE,
 780                 "Server does not support 'range' (byte ranges).");
 781         goto out;
 782     }
 783     DPRINTF("CURL: Size = %zd\n", s->len);
 784
 785     curl_clean_state(state);
 786     curl_easy_cleanup(state->curl);
 787     state->curl = NULL;
 788
 789     qemu_mutex_init(&s->mutex);
 790     curl_attach_aio_context(bs, bdrv_get_aio_context(bs));
 791
 792     qemu_opts_del(opts);
 793     return 0;
 794
 795 out:
 796     error_setg(errp, "CURL: Error opening file: %s", state->errmsg);
 797     curl_easy_cleanup(state->curl);
 798     state->curl = NULL;
 799 out_noclean:
 800     g_free(s->cookie);
 801     g_free(s->url);
 802     qemu_opts_del(opts);
 803     return -EINVAL;
 804 }
 805
 806 static const AIOCBInfo curl_aiocb_info = {
 807     .aiocb_size         = sizeof(CURLAIOCB),
 808 };
 809
 810
 811 static void curl_readv_bh_cb(void *p)
 812 {
 813     CURLState *state;
 814     int running;
 815     int ret = -EINPROGRESS;
 816
 817     CURLAIOCB *acb = p;
 818     BlockDriverState *bs = acb->common.bs;
 819     BDRVCURLState *s = bs->opaque;
 820
 821     size_t start = acb->sector_num * BDRV_SECTOR_SIZE;
 822     size_t end;
 823
 824     qemu_mutex_lock(&s->mutex);
 825
 826     // In case we have the requested data already (e.g. read-ahead),
 827     // we can just call the callback and be done.
 828     switch (curl_find_buf(s, start, acb->nb_sectors * BDRV_SECTOR_SIZE, acb)) {
 829         case FIND_RET_OK:
 830             qemu_aio_unref(acb);
 831             // fall through
 832         case FIND_RET_WAIT:
 833             goto out;
 834         default:
 835             break;
 836     }
 837
 838     // No cache found, so let's start a new request
 839     state = curl_init_state(acb->common.bs, s);
 840     if (!state) {
 841         ret = -EIO;
 842         goto out;
 843     }
 844
 845     acb->start = 0;
 846     acb->end = MIN(acb->nb_sectors * BDRV_SECTOR_SIZE, s->len - start);
 847
 848     state->buf_off = 0;
 849     g_free(state->orig_buf);
 850     state->buf_start = start;
 851     state->buf_len = MIN(acb->end + s->readahead_size, s->len - start);
 852     end = start + state->buf_len - 1;
 853     state->orig_buf = g_try_malloc(state->buf_len);
 854     if (state->buf_len && state->orig_buf == NULL) {
 855         curl_clean_state(state);
 856         ret = -ENOMEM;
 857         goto out;
 858     }
 859     state->acb[0] = acb;
 860
 861     snprintf(state->range, 127, "%zd-%zd", start, end);
 862     DPRINTF("CURL (AIO): Reading %llu at %zd (%s)\n",
 863             (acb->nb_sectors * BDRV_SECTOR_SIZE), start, state->range);
 864     curl_easy_setopt(state->curl, CURLOPT_RANGE, state->range);
 865
 866     curl_multi_add_handle(s->multi, state->curl);
 867
 868     /* Tell curl it needs to kick things off */
 869     curl_multi_socket_action(s->multi, CURL_SOCKET_TIMEOUT, 0, &running);
 870
 871 out:
 872     qemu_mutex_unlock(&s->mutex);
 873     if (ret != -EINPROGRESS) {
 874         acb->common.cb(acb->common.opaque, ret);
 875         qemu_aio_unref(acb);
 876     }
 877 }
 878
 879 static BlockAIOCB *curl_aio_readv(BlockDriverState *bs,
 880         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
 881         BlockCompletionFunc *cb, void *opaque)
 882 {
 883     CURLAIOCB *acb;
 884
 885     acb = qemu_aio_get(&curl_aiocb_info, bs, cb, opaque);
 886
 887     acb->qiov = qiov;
 888     acb->sector_num = sector_num;
 889     acb->nb_sectors = nb_sectors;
 890
 891     aio_bh_schedule_oneshot(bdrv_get_aio_context(bs), curl_readv_bh_cb, acb);
 892     return &acb->common;
 893 }
 894
 895 static void curl_close(BlockDriverState *bs)
 896 {
 897     BDRVCURLState *s = bs->opaque;
 898
 899     DPRINTF("CURL: Close\n");
 900     curl_detach_aio_context(bs);
 901     qemu_mutex_destroy(&s->mutex);
 902
 903     g_free(s->cookie);
 904     g_free(s->url);
 905 }
 906
 907 static int64_t curl_getlength(BlockDriverState *bs)
 908 {
 909     BDRVCURLState *s = bs->opaque;
 910     return s->len;
 911 }
 912
 913 static BlockDriver bdrv_http = {
 914     .format_name                = "http",
 915     .protocol_name              = "http",
 916
 917     .instance_size              = sizeof(BDRVCURLState),
 918     .bdrv_parse_filename        = curl_parse_filename,
 919     .bdrv_file_open             = curl_open,
 920     .bdrv_close                 = curl_close,
 921     .bdrv_getlength             = curl_getlength,
 922
 923     .bdrv_aio_readv             = curl_aio_readv,
 924
 925     .bdrv_detach_aio_context    = curl_detach_aio_context,
 926     .bdrv_attach_aio_context    = curl_attach_aio_context,
 927 };
 928
 929 static BlockDriver bdrv_https = {
 930     .format_name                = "https",
 931     .protocol_name              = "https",
 932
 933     .instance_size              = sizeof(BDRVCURLState),
 934     .bdrv_parse_filename        = curl_parse_filename,
 935     .bdrv_file_open             = curl_open,
 936     .bdrv_close                 = curl_close,
 937     .bdrv_getlength             = curl_getlength,
 938
 939     .bdrv_aio_readv             = curl_aio_readv,
 940
 941     .bdrv_detach_aio_context    = curl_detach_aio_context,
 942     .bdrv_attach_aio_context    = curl_attach_aio_context,
 943 };
 944
 945 static BlockDriver bdrv_ftp = {
 946     .format_name                = "ftp",
 947     .protocol_name              = "ftp",
 948
 949     .instance_size              = sizeof(BDRVCURLState),
 950     .bdrv_parse_filename        = curl_parse_filename,
 951     .bdrv_file_open             = curl_open,
 952     .bdrv_close                 = curl_close,
 953     .bdrv_getlength             = curl_getlength,
 954
 955     .bdrv_aio_readv             = curl_aio_readv,
 956
 957     .bdrv_detach_aio_context    = curl_detach_aio_context,
 958     .bdrv_attach_aio_context    = curl_attach_aio_context,
 959 };
 960
 961 static BlockDriver bdrv_ftps = {
 962     .format_name                = "ftps",
 963     .protocol_name              = "ftps",
 964
 965     .instance_size              = sizeof(BDRVCURLState),
 966     .bdrv_parse_filename        = curl_parse_filename,
 967     .bdrv_file_open             = curl_open,
 968     .bdrv_close                 = curl_close,
 969     .bdrv_getlength             = curl_getlength,
 970
 971     .bdrv_aio_readv             = curl_aio_readv,
 972
 973     .bdrv_detach_aio_context    = curl_detach_aio_context,
 974     .bdrv_attach_aio_context    = curl_attach_aio_context,
 975 };
 976
 977 static void curl_block_init(void)
 978 {
 979     bdrv_register(&bdrv_http);
 980     bdrv_register(&bdrv_https);
 981     bdrv_register(&bdrv_ftp);
 982     bdrv_register(&bdrv_ftps);
 983 }
 984
 985 block_init(curl_block_init);