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-common.h" 25 #include "block/block_int.h" 26 #include <curl/curl.h> 27 28 // #define DEBUG 29 // #define DEBUG_VERBOSE 30 31 #ifdef DEBUG_CURL 32 #define DPRINTF(fmt, ...) do { printf(fmt, ## __VA_ARGS__); } while (0) 33 #else 34 #define DPRINTF(fmt, ...) do { } while (0) 35 #endif 36 37 #if LIBCURL_VERSION_NUM >= 0x071000 38 /* The multi interface timer callback was introduced in 7.16.0 */ 39 #define NEED_CURL_TIMER_CALLBACK 40 #endif 41 42 #define PROTOCOLS (CURLPROTO_HTTP | CURLPROTO_HTTPS | \ 43 CURLPROTO_FTP | CURLPROTO_FTPS | \ 44 CURLPROTO_TFTP) 45 46 #define CURL_NUM_STATES 8 47 #define CURL_NUM_ACB 8 48 #define SECTOR_SIZE 512 49 #define READ_AHEAD_SIZE (256 * 1024) 50 51 #define FIND_RET_NONE 0 52 #define FIND_RET_OK 1 53 #define FIND_RET_WAIT 2 54 55 struct BDRVCURLState; 56 57 typedef struct CURLAIOCB { 58 BlockDriverAIOCB common; 59 QEMUBH *bh; 60 QEMUIOVector *qiov; 61 62 int64_t sector_num; 63 int nb_sectors; 64 65 size_t start; 66 size_t end; 67 } CURLAIOCB; 68 69 typedef struct CURLState 70 { 71 struct BDRVCURLState *s; 72 CURLAIOCB *acb[CURL_NUM_ACB]; 73 CURL *curl; 74 char *orig_buf; 75 size_t buf_start; 76 size_t buf_off; 77 size_t buf_len; 78 char range[128]; 79 char errmsg[CURL_ERROR_SIZE]; 80 char in_use; 81 } CURLState; 82 83 typedef struct BDRVCURLState { 84 CURLM *multi; 85 QEMUTimer timer; 86 size_t len; 87 CURLState states[CURL_NUM_STATES]; 88 char *url; 89 size_t readahead_size; 90 bool accept_range; 91 } BDRVCURLState; 92 93 static void curl_clean_state(CURLState *s); 94 static void curl_multi_do(void *arg); 95 96 #ifdef NEED_CURL_TIMER_CALLBACK 97 static int curl_timer_cb(CURLM *multi, long timeout_ms, void *opaque) 98 { 99 BDRVCURLState *s = opaque; 100 101 DPRINTF("CURL: timer callback timeout_ms %ld\n", timeout_ms); 102 if (timeout_ms == -1) { 103 timer_del(&s->timer); 104 } else { 105 int64_t timeout_ns = (int64_t)timeout_ms * 1000 * 1000; 106 timer_mod(&s->timer, 107 qemu_clock_get_ns(QEMU_CLOCK_REALTIME) + timeout_ns); 108 } 109 return 0; 110 } 111 #endif 112 113 static int curl_sock_cb(CURL *curl, curl_socket_t fd, int action, 114 void *s, void *sp) 115 { 116 DPRINTF("CURL (AIO): Sock action %d on fd %d\n", action, fd); 117 switch (action) { 118 case CURL_POLL_IN: 119 qemu_aio_set_fd_handler(fd, curl_multi_do, NULL, s); 120 break; 121 case CURL_POLL_OUT: 122 qemu_aio_set_fd_handler(fd, NULL, curl_multi_do, s); 123 break; 124 case CURL_POLL_INOUT: 125 qemu_aio_set_fd_handler(fd, curl_multi_do, curl_multi_do, s); 126 break; 127 case CURL_POLL_REMOVE: 128 qemu_aio_set_fd_handler(fd, NULL, NULL, NULL); 129 break; 130 } 131 132 return 0; 133 } 134 135 static size_t curl_header_cb(void *ptr, size_t size, size_t nmemb, void *opaque) 136 { 137 BDRVCURLState *s = opaque; 138 size_t realsize = size * nmemb; 139 const char *accept_line = "Accept-Ranges: bytes"; 140 141 if (realsize >= strlen(accept_line) 142 && strncmp((char *)ptr, accept_line, strlen(accept_line)) == 0) { 143 s->accept_range = true; 144 } 145 146 return realsize; 147 } 148 149 static size_t curl_read_cb(void *ptr, size_t size, size_t nmemb, void *opaque) 150 { 151 CURLState *s = ((CURLState*)opaque); 152 size_t realsize = size * nmemb; 153 int i; 154 155 DPRINTF("CURL: Just reading %zd bytes\n", realsize); 156 157 if (!s || !s->orig_buf) 158 goto read_end; 159 160 memcpy(s->orig_buf + s->buf_off, ptr, realsize); 161 s->buf_off += realsize; 162 163 for(i=0; i<CURL_NUM_ACB; i++) { 164 CURLAIOCB *acb = s->acb[i]; 165 166 if (!acb) 167 continue; 168 169 if ((s->buf_off >= acb->end)) { 170 qemu_iovec_from_buf(acb->qiov, 0, s->orig_buf + acb->start, 171 acb->end - acb->start); 172 acb->common.cb(acb->common.opaque, 0); 173 qemu_aio_release(acb); 174 s->acb[i] = NULL; 175 } 176 } 177 178 read_end: 179 return realsize; 180 } 181 182 static int curl_find_buf(BDRVCURLState *s, size_t start, size_t len, 183 CURLAIOCB *acb) 184 { 185 int i; 186 size_t end = start + len; 187 188 for (i=0; i<CURL_NUM_STATES; i++) { 189 CURLState *state = &s->states[i]; 190 size_t buf_end = (state->buf_start + state->buf_off); 191 size_t buf_fend = (state->buf_start + state->buf_len); 192 193 if (!state->orig_buf) 194 continue; 195 if (!state->buf_off) 196 continue; 197 198 // Does the existing buffer cover our section? 199 if ((start >= state->buf_start) && 200 (start <= buf_end) && 201 (end >= state->buf_start) && 202 (end <= buf_end)) 203 { 204 char *buf = state->orig_buf + (start - state->buf_start); 205 206 qemu_iovec_from_buf(acb->qiov, 0, buf, len); 207 acb->common.cb(acb->common.opaque, 0); 208 209 return FIND_RET_OK; 210 } 211 212 // Wait for unfinished chunks 213 if ((start >= state->buf_start) && 214 (start <= buf_fend) && 215 (end >= state->buf_start) && 216 (end <= buf_fend)) 217 { 218 int j; 219 220 acb->start = start - state->buf_start; 221 acb->end = acb->start + len; 222 223 for (j=0; j<CURL_NUM_ACB; j++) { 224 if (!state->acb[j]) { 225 state->acb[j] = acb; 226 return FIND_RET_WAIT; 227 } 228 } 229 } 230 } 231 232 return FIND_RET_NONE; 233 } 234 235 static void curl_multi_read(BDRVCURLState *s) 236 { 237 int msgs_in_queue; 238 239 /* Try to find done transfers, so we can free the easy 240 * handle again. */ 241 do { 242 CURLMsg *msg; 243 msg = curl_multi_info_read(s->multi, &msgs_in_queue); 244 245 if (!msg) 246 break; 247 if (msg->msg == CURLMSG_NONE) 248 break; 249 250 switch (msg->msg) { 251 case CURLMSG_DONE: 252 { 253 CURLState *state = NULL; 254 curl_easy_getinfo(msg->easy_handle, CURLINFO_PRIVATE, (char**)&state); 255 256 /* ACBs for successful messages get completed in curl_read_cb */ 257 if (msg->data.result != CURLE_OK) { 258 int i; 259 for (i = 0; i < CURL_NUM_ACB; i++) { 260 CURLAIOCB *acb = state->acb[i]; 261 262 if (acb == NULL) { 263 continue; 264 } 265 266 acb->common.cb(acb->common.opaque, -EIO); 267 qemu_aio_release(acb); 268 state->acb[i] = NULL; 269 } 270 } 271 272 curl_clean_state(state); 273 break; 274 } 275 default: 276 msgs_in_queue = 0; 277 break; 278 } 279 } while(msgs_in_queue); 280 } 281 282 static void curl_multi_do(void *arg) 283 { 284 BDRVCURLState *s = (BDRVCURLState *)arg; 285 int running; 286 int r; 287 288 if (!s->multi) { 289 return; 290 } 291 292 do { 293 r = curl_multi_socket_all(s->multi, &running); 294 } while(r == CURLM_CALL_MULTI_PERFORM); 295 296 curl_multi_read(s); 297 } 298 299 static void curl_multi_timeout_do(void *arg) 300 { 301 #ifdef NEED_CURL_TIMER_CALLBACK 302 BDRVCURLState *s = (BDRVCURLState *)arg; 303 int running; 304 305 if (!s->multi) { 306 return; 307 } 308 309 curl_multi_socket_action(s->multi, CURL_SOCKET_TIMEOUT, 0, &running); 310 311 curl_multi_read(s); 312 #else 313 abort(); 314 #endif 315 } 316 317 static CURLState *curl_init_state(BDRVCURLState *s) 318 { 319 CURLState *state = NULL; 320 int i, j; 321 322 do { 323 for (i=0; i<CURL_NUM_STATES; i++) { 324 for (j=0; j<CURL_NUM_ACB; j++) 325 if (s->states[i].acb[j]) 326 continue; 327 if (s->states[i].in_use) 328 continue; 329 330 state = &s->states[i]; 331 state->in_use = 1; 332 break; 333 } 334 if (!state) { 335 g_usleep(100); 336 curl_multi_do(s); 337 } 338 } while(!state); 339 340 if (state->curl) 341 goto has_curl; 342 343 state->curl = curl_easy_init(); 344 if (!state->curl) 345 return NULL; 346 curl_easy_setopt(state->curl, CURLOPT_URL, s->url); 347 curl_easy_setopt(state->curl, CURLOPT_TIMEOUT, 5); 348 curl_easy_setopt(state->curl, CURLOPT_WRITEFUNCTION, (void *)curl_read_cb); 349 curl_easy_setopt(state->curl, CURLOPT_WRITEDATA, (void *)state); 350 curl_easy_setopt(state->curl, CURLOPT_PRIVATE, (void *)state); 351 curl_easy_setopt(state->curl, CURLOPT_AUTOREFERER, 1); 352 curl_easy_setopt(state->curl, CURLOPT_FOLLOWLOCATION, 1); 353 curl_easy_setopt(state->curl, CURLOPT_NOSIGNAL, 1); 354 curl_easy_setopt(state->curl, CURLOPT_ERRORBUFFER, state->errmsg); 355 curl_easy_setopt(state->curl, CURLOPT_FAILONERROR, 1); 356 357 /* Restrict supported protocols to avoid security issues in the more 358 * obscure protocols. For example, do not allow POP3/SMTP/IMAP see 359 * CVE-2013-0249. 360 * 361 * Restricting protocols is only supported from 7.19.4 upwards. 362 */ 363 #if LIBCURL_VERSION_NUM >= 0x071304 364 curl_easy_setopt(state->curl, CURLOPT_PROTOCOLS, PROTOCOLS); 365 curl_easy_setopt(state->curl, CURLOPT_REDIR_PROTOCOLS, PROTOCOLS); 366 #endif 367 368 #ifdef DEBUG_VERBOSE 369 curl_easy_setopt(state->curl, CURLOPT_VERBOSE, 1); 370 #endif 371 372 has_curl: 373 374 state->s = s; 375 376 return state; 377 } 378 379 static void curl_clean_state(CURLState *s) 380 { 381 if (s->s->multi) 382 curl_multi_remove_handle(s->s->multi, s->curl); 383 s->in_use = 0; 384 } 385 386 static void curl_parse_filename(const char *filename, QDict *options, 387 Error **errp) 388 { 389 390 #define RA_OPTSTR ":readahead=" 391 char *file; 392 char *ra; 393 const char *ra_val; 394 int parse_state = 0; 395 396 file = g_strdup(filename); 397 398 /* Parse a trailing ":readahead=#:" param, if present. */ 399 ra = file + strlen(file) - 1; 400 while (ra >= file) { 401 if (parse_state == 0) { 402 if (*ra == ':') { 403 parse_state++; 404 } else { 405 break; 406 } 407 } else if (parse_state == 1) { 408 if (*ra > '9' || *ra < '0') { 409 char *opt_start = ra - strlen(RA_OPTSTR) + 1; 410 if (opt_start > file && 411 strncmp(opt_start, RA_OPTSTR, strlen(RA_OPTSTR)) == 0) { 412 ra_val = ra + 1; 413 ra -= strlen(RA_OPTSTR) - 1; 414 *ra = '\0'; 415 qdict_put(options, "readahead", qstring_from_str(ra_val)); 416 } 417 break; 418 } 419 } 420 ra--; 421 } 422 423 qdict_put(options, "url", qstring_from_str(file)); 424 425 g_free(file); 426 } 427 428 static QemuOptsList runtime_opts = { 429 .name = "curl", 430 .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head), 431 .desc = { 432 { 433 .name = "url", 434 .type = QEMU_OPT_STRING, 435 .help = "URL to open", 436 }, 437 { 438 .name = "readahead", 439 .type = QEMU_OPT_SIZE, 440 .help = "Readahead size", 441 }, 442 { /* end of list */ } 443 }, 444 }; 445 446 static int curl_open(BlockDriverState *bs, QDict *options, int flags, 447 Error **errp) 448 { 449 BDRVCURLState *s = bs->opaque; 450 CURLState *state = NULL; 451 QemuOpts *opts; 452 Error *local_err = NULL; 453 const char *file; 454 double d; 455 456 static int inited = 0; 457 458 if (flags & BDRV_O_RDWR) { 459 error_setg(errp, "curl block device does not support writes"); 460 return -EROFS; 461 } 462 463 opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort); 464 qemu_opts_absorb_qdict(opts, options, &local_err); 465 if (local_err) { 466 error_propagate(errp, local_err); 467 goto out_noclean; 468 } 469 470 s->readahead_size = qemu_opt_get_size(opts, "readahead", READ_AHEAD_SIZE); 471 if ((s->readahead_size & 0x1ff) != 0) { 472 error_setg(errp, "HTTP_READAHEAD_SIZE %zd is not a multiple of 512", 473 s->readahead_size); 474 goto out_noclean; 475 } 476 477 file = qemu_opt_get(opts, "url"); 478 if (file == NULL) { 479 error_setg(errp, "curl block driver requires an 'url' option"); 480 goto out_noclean; 481 } 482 483 if (!inited) { 484 curl_global_init(CURL_GLOBAL_ALL); 485 inited = 1; 486 } 487 488 DPRINTF("CURL: Opening %s\n", file); 489 s->url = g_strdup(file); 490 state = curl_init_state(s); 491 if (!state) 492 goto out_noclean; 493 494 // Get file size 495 496 s->accept_range = false; 497 curl_easy_setopt(state->curl, CURLOPT_NOBODY, 1); 498 curl_easy_setopt(state->curl, CURLOPT_HEADERFUNCTION, 499 curl_header_cb); 500 curl_easy_setopt(state->curl, CURLOPT_HEADERDATA, s); 501 if (curl_easy_perform(state->curl)) 502 goto out; 503 curl_easy_getinfo(state->curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &d); 504 if (d) 505 s->len = (size_t)d; 506 else if(!s->len) 507 goto out; 508 if ((!strncasecmp(s->url, "http://", strlen("http://")) 509 || !strncasecmp(s->url, "https://", strlen("https://"))) 510 && !s->accept_range) { 511 pstrcpy(state->errmsg, CURL_ERROR_SIZE, 512 "Server does not support 'range' (byte ranges)."); 513 goto out; 514 } 515 DPRINTF("CURL: Size = %zd\n", s->len); 516 517 curl_clean_state(state); 518 curl_easy_cleanup(state->curl); 519 state->curl = NULL; 520 521 aio_timer_init(bdrv_get_aio_context(bs), &s->timer, 522 QEMU_CLOCK_REALTIME, SCALE_NS, 523 curl_multi_timeout_do, s); 524 525 // Now we know the file exists and its size, so let's 526 // initialize the multi interface! 527 528 s->multi = curl_multi_init(); 529 curl_multi_setopt(s->multi, CURLMOPT_SOCKETDATA, s); 530 curl_multi_setopt(s->multi, CURLMOPT_SOCKETFUNCTION, curl_sock_cb); 531 #ifdef NEED_CURL_TIMER_CALLBACK 532 curl_multi_setopt(s->multi, CURLMOPT_TIMERDATA, s); 533 curl_multi_setopt(s->multi, CURLMOPT_TIMERFUNCTION, curl_timer_cb); 534 #endif 535 curl_multi_do(s); 536 537 qemu_opts_del(opts); 538 return 0; 539 540 out: 541 fprintf(stderr, "CURL: Error opening file: %s\n", state->errmsg); 542 curl_easy_cleanup(state->curl); 543 state->curl = NULL; 544 out_noclean: 545 g_free(s->url); 546 qemu_opts_del(opts); 547 return -EINVAL; 548 } 549 550 static void curl_aio_cancel(BlockDriverAIOCB *blockacb) 551 { 552 // Do we have to implement canceling? Seems to work without... 553 } 554 555 static const AIOCBInfo curl_aiocb_info = { 556 .aiocb_size = sizeof(CURLAIOCB), 557 .cancel = curl_aio_cancel, 558 }; 559 560 561 static void curl_readv_bh_cb(void *p) 562 { 563 CURLState *state; 564 565 CURLAIOCB *acb = p; 566 BDRVCURLState *s = acb->common.bs->opaque; 567 568 qemu_bh_delete(acb->bh); 569 acb->bh = NULL; 570 571 size_t start = acb->sector_num * SECTOR_SIZE; 572 size_t end; 573 574 // In case we have the requested data already (e.g. read-ahead), 575 // we can just call the callback and be done. 576 switch (curl_find_buf(s, start, acb->nb_sectors * SECTOR_SIZE, acb)) { 577 case FIND_RET_OK: 578 qemu_aio_release(acb); 579 // fall through 580 case FIND_RET_WAIT: 581 return; 582 default: 583 break; 584 } 585 586 // No cache found, so let's start a new request 587 state = curl_init_state(s); 588 if (!state) { 589 acb->common.cb(acb->common.opaque, -EIO); 590 qemu_aio_release(acb); 591 return; 592 } 593 594 acb->start = 0; 595 acb->end = (acb->nb_sectors * SECTOR_SIZE); 596 597 state->buf_off = 0; 598 if (state->orig_buf) 599 g_free(state->orig_buf); 600 state->buf_start = start; 601 state->buf_len = acb->end + s->readahead_size; 602 end = MIN(start + state->buf_len, s->len) - 1; 603 state->orig_buf = g_malloc(state->buf_len); 604 state->acb[0] = acb; 605 606 snprintf(state->range, 127, "%zd-%zd", start, end); 607 DPRINTF("CURL (AIO): Reading %d at %zd (%s)\n", 608 (acb->nb_sectors * SECTOR_SIZE), start, state->range); 609 curl_easy_setopt(state->curl, CURLOPT_RANGE, state->range); 610 611 curl_multi_add_handle(s->multi, state->curl); 612 curl_multi_do(s); 613 614 } 615 616 static BlockDriverAIOCB *curl_aio_readv(BlockDriverState *bs, 617 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, 618 BlockDriverCompletionFunc *cb, void *opaque) 619 { 620 CURLAIOCB *acb; 621 622 acb = qemu_aio_get(&curl_aiocb_info, bs, cb, opaque); 623 624 acb->qiov = qiov; 625 acb->sector_num = sector_num; 626 acb->nb_sectors = nb_sectors; 627 628 acb->bh = qemu_bh_new(curl_readv_bh_cb, acb); 629 qemu_bh_schedule(acb->bh); 630 return &acb->common; 631 } 632 633 static void curl_close(BlockDriverState *bs) 634 { 635 BDRVCURLState *s = bs->opaque; 636 int i; 637 638 DPRINTF("CURL: Close\n"); 639 for (i=0; i<CURL_NUM_STATES; i++) { 640 if (s->states[i].in_use) 641 curl_clean_state(&s->states[i]); 642 if (s->states[i].curl) { 643 curl_easy_cleanup(s->states[i].curl); 644 s->states[i].curl = NULL; 645 } 646 if (s->states[i].orig_buf) { 647 g_free(s->states[i].orig_buf); 648 s->states[i].orig_buf = NULL; 649 } 650 } 651 if (s->multi) 652 curl_multi_cleanup(s->multi); 653 654 timer_del(&s->timer); 655 656 g_free(s->url); 657 } 658 659 static int64_t curl_getlength(BlockDriverState *bs) 660 { 661 BDRVCURLState *s = bs->opaque; 662 return s->len; 663 } 664 665 static BlockDriver bdrv_http = { 666 .format_name = "http", 667 .protocol_name = "http", 668 669 .instance_size = sizeof(BDRVCURLState), 670 .bdrv_parse_filename = curl_parse_filename, 671 .bdrv_file_open = curl_open, 672 .bdrv_close = curl_close, 673 .bdrv_getlength = curl_getlength, 674 675 .bdrv_aio_readv = curl_aio_readv, 676 }; 677 678 static BlockDriver bdrv_https = { 679 .format_name = "https", 680 .protocol_name = "https", 681 682 .instance_size = sizeof(BDRVCURLState), 683 .bdrv_parse_filename = curl_parse_filename, 684 .bdrv_file_open = curl_open, 685 .bdrv_close = curl_close, 686 .bdrv_getlength = curl_getlength, 687 688 .bdrv_aio_readv = curl_aio_readv, 689 }; 690 691 static BlockDriver bdrv_ftp = { 692 .format_name = "ftp", 693 .protocol_name = "ftp", 694 695 .instance_size = sizeof(BDRVCURLState), 696 .bdrv_parse_filename = curl_parse_filename, 697 .bdrv_file_open = curl_open, 698 .bdrv_close = curl_close, 699 .bdrv_getlength = curl_getlength, 700 701 .bdrv_aio_readv = curl_aio_readv, 702 }; 703 704 static BlockDriver bdrv_ftps = { 705 .format_name = "ftps", 706 .protocol_name = "ftps", 707 708 .instance_size = sizeof(BDRVCURLState), 709 .bdrv_parse_filename = curl_parse_filename, 710 .bdrv_file_open = curl_open, 711 .bdrv_close = curl_close, 712 .bdrv_getlength = curl_getlength, 713 714 .bdrv_aio_readv = curl_aio_readv, 715 }; 716 717 static BlockDriver bdrv_tftp = { 718 .format_name = "tftp", 719 .protocol_name = "tftp", 720 721 .instance_size = sizeof(BDRVCURLState), 722 .bdrv_parse_filename = curl_parse_filename, 723 .bdrv_file_open = curl_open, 724 .bdrv_close = curl_close, 725 .bdrv_getlength = curl_getlength, 726 727 .bdrv_aio_readv = curl_aio_readv, 728 }; 729 730 static void curl_block_init(void) 731 { 732 bdrv_register(&bdrv_http); 733 bdrv_register(&bdrv_https); 734 bdrv_register(&bdrv_ftp); 735 bdrv_register(&bdrv_ftps); 736 bdrv_register(&bdrv_tftp); 737 } 738 739 block_init(curl_block_init); 740