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);