2009-05-11 23:41:42 +08:00
|
|
|
/*
|
|
|
|
* QEMU Block driver for CURL images
|
|
|
|
*
|
|
|
|
* Copyright (c) 2009 Alexander Graf <agraf@suse.de>
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
|
|
* in the Software without restriction, including without limitation the rights
|
|
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
* THE SOFTWARE.
|
|
|
|
*/
|
|
|
|
#include "qemu-common.h"
|
2012-12-18 01:19:44 +08:00
|
|
|
#include "block/block_int.h"
|
2009-05-11 23:41:42 +08:00
|
|
|
#include <curl/curl.h>
|
|
|
|
|
|
|
|
// #define DEBUG
|
|
|
|
// #define DEBUG_VERBOSE
|
|
|
|
|
|
|
|
#ifdef DEBUG_CURL
|
2010-02-07 07:03:50 +08:00
|
|
|
#define DPRINTF(fmt, ...) do { printf(fmt, ## __VA_ARGS__); } while (0)
|
2009-05-11 23:41:42 +08:00
|
|
|
#else
|
2010-02-07 07:03:50 +08:00
|
|
|
#define DPRINTF(fmt, ...) do { } while (0)
|
2009-05-11 23:41:42 +08:00
|
|
|
#endif
|
|
|
|
|
2013-02-08 15:49:10 +08:00
|
|
|
#define PROTOCOLS (CURLPROTO_HTTP | CURLPROTO_HTTPS | \
|
|
|
|
CURLPROTO_FTP | CURLPROTO_FTPS | \
|
|
|
|
CURLPROTO_TFTP)
|
|
|
|
|
2009-05-11 23:41:42 +08:00
|
|
|
#define CURL_NUM_STATES 8
|
|
|
|
#define CURL_NUM_ACB 8
|
|
|
|
#define SECTOR_SIZE 512
|
|
|
|
#define READ_AHEAD_SIZE (256 * 1024)
|
|
|
|
|
|
|
|
#define FIND_RET_NONE 0
|
|
|
|
#define FIND_RET_OK 1
|
|
|
|
#define FIND_RET_WAIT 2
|
|
|
|
|
|
|
|
struct BDRVCURLState;
|
|
|
|
|
|
|
|
typedef struct CURLAIOCB {
|
|
|
|
BlockDriverAIOCB common;
|
2011-09-21 18:55:50 +08:00
|
|
|
QEMUBH *bh;
|
2009-05-11 23:41:42 +08:00
|
|
|
QEMUIOVector *qiov;
|
2011-09-21 18:55:50 +08:00
|
|
|
|
|
|
|
int64_t sector_num;
|
|
|
|
int nb_sectors;
|
|
|
|
|
2009-05-11 23:41:42 +08:00
|
|
|
size_t start;
|
|
|
|
size_t end;
|
|
|
|
} CURLAIOCB;
|
|
|
|
|
|
|
|
typedef struct CURLState
|
|
|
|
{
|
|
|
|
struct BDRVCURLState *s;
|
|
|
|
CURLAIOCB *acb[CURL_NUM_ACB];
|
|
|
|
CURL *curl;
|
|
|
|
char *orig_buf;
|
|
|
|
size_t buf_start;
|
|
|
|
size_t buf_off;
|
|
|
|
size_t buf_len;
|
|
|
|
char range[128];
|
|
|
|
char errmsg[CURL_ERROR_SIZE];
|
|
|
|
char in_use;
|
|
|
|
} CURLState;
|
|
|
|
|
|
|
|
typedef struct BDRVCURLState {
|
|
|
|
CURLM *multi;
|
|
|
|
size_t len;
|
|
|
|
CURLState states[CURL_NUM_STATES];
|
|
|
|
char *url;
|
2009-07-02 08:16:52 +08:00
|
|
|
size_t readahead_size;
|
curl: refuse to open URL from HTTP server without range support
CURL driver requests partial data from server on guest IO req. For HTTP
and HTTPS, it uses "Range: ***" in requests, and this will not work if
server not accepting range. This patch does this check when open.
* Removed curl_size_cb, which is not used: On one hand it's registered to
libcurl as CURLOPT_WRITEFUNCTION, instead of CURLOPT_HEADERFUNCTION,
which will get called with *data*, not *header*. On the other hand the
s->len is assigned unconditionally later.
In this gone function, the sscanf for "Content-Length: %zd", on
(void *)ptr, which is not guaranteed to be zero-terminated, is
potentially a security bug. So this patch fixes it as a side-effect. The
bug is reported as: https://bugs.launchpad.net/qemu/+bug/1188943
(Note the bug is marked "private" so you might not be able to see it)
* Introduced curl_header_cb, which is used to parse header and mark the
server as accepting range if "Accept-Ranges: bytes" line is seen from
response header. If protocol is HTTP or HTTPS, but server response has
no not this support, refuse to open this URL.
Note that python builtin module SimpleHTTPServer is an example of not
supporting range, if you need to test this driver, get a better server
or use internet URLs.
Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2013-07-02 15:19:21 +08:00
|
|
|
bool accept_range;
|
2009-05-11 23:41:42 +08:00
|
|
|
} BDRVCURLState;
|
|
|
|
|
|
|
|
static void curl_clean_state(CURLState *s);
|
|
|
|
static void curl_multi_do(void *arg);
|
2011-09-21 18:55:49 +08:00
|
|
|
static int curl_aio_flush(void *opaque);
|
2009-05-11 23:41:42 +08:00
|
|
|
|
|
|
|
static int curl_sock_cb(CURL *curl, curl_socket_t fd, int action,
|
|
|
|
void *s, void *sp)
|
|
|
|
{
|
2010-02-07 07:03:50 +08:00
|
|
|
DPRINTF("CURL (AIO): Sock action %d on fd %d\n", action, fd);
|
2009-05-11 23:41:42 +08:00
|
|
|
switch (action) {
|
|
|
|
case CURL_POLL_IN:
|
2012-04-12 20:00:54 +08:00
|
|
|
qemu_aio_set_fd_handler(fd, curl_multi_do, NULL, curl_aio_flush, s);
|
2009-05-11 23:41:42 +08:00
|
|
|
break;
|
|
|
|
case CURL_POLL_OUT:
|
2012-04-12 20:00:54 +08:00
|
|
|
qemu_aio_set_fd_handler(fd, NULL, curl_multi_do, curl_aio_flush, s);
|
2009-05-11 23:41:42 +08:00
|
|
|
break;
|
|
|
|
case CURL_POLL_INOUT:
|
2011-09-21 18:55:49 +08:00
|
|
|
qemu_aio_set_fd_handler(fd, curl_multi_do, curl_multi_do,
|
2012-04-12 20:00:54 +08:00
|
|
|
curl_aio_flush, s);
|
2009-05-11 23:41:42 +08:00
|
|
|
break;
|
|
|
|
case CURL_POLL_REMOVE:
|
2012-04-12 20:00:54 +08:00
|
|
|
qemu_aio_set_fd_handler(fd, NULL, NULL, NULL, NULL);
|
2009-05-11 23:41:42 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
curl: refuse to open URL from HTTP server without range support
CURL driver requests partial data from server on guest IO req. For HTTP
and HTTPS, it uses "Range: ***" in requests, and this will not work if
server not accepting range. This patch does this check when open.
* Removed curl_size_cb, which is not used: On one hand it's registered to
libcurl as CURLOPT_WRITEFUNCTION, instead of CURLOPT_HEADERFUNCTION,
which will get called with *data*, not *header*. On the other hand the
s->len is assigned unconditionally later.
In this gone function, the sscanf for "Content-Length: %zd", on
(void *)ptr, which is not guaranteed to be zero-terminated, is
potentially a security bug. So this patch fixes it as a side-effect. The
bug is reported as: https://bugs.launchpad.net/qemu/+bug/1188943
(Note the bug is marked "private" so you might not be able to see it)
* Introduced curl_header_cb, which is used to parse header and mark the
server as accepting range if "Accept-Ranges: bytes" line is seen from
response header. If protocol is HTTP or HTTPS, but server response has
no not this support, refuse to open this URL.
Note that python builtin module SimpleHTTPServer is an example of not
supporting range, if you need to test this driver, get a better server
or use internet URLs.
Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2013-07-02 15:19:21 +08:00
|
|
|
static size_t curl_header_cb(void *ptr, size_t size, size_t nmemb, void *opaque)
|
2009-05-11 23:41:42 +08:00
|
|
|
{
|
curl: refuse to open URL from HTTP server without range support
CURL driver requests partial data from server on guest IO req. For HTTP
and HTTPS, it uses "Range: ***" in requests, and this will not work if
server not accepting range. This patch does this check when open.
* Removed curl_size_cb, which is not used: On one hand it's registered to
libcurl as CURLOPT_WRITEFUNCTION, instead of CURLOPT_HEADERFUNCTION,
which will get called with *data*, not *header*. On the other hand the
s->len is assigned unconditionally later.
In this gone function, the sscanf for "Content-Length: %zd", on
(void *)ptr, which is not guaranteed to be zero-terminated, is
potentially a security bug. So this patch fixes it as a side-effect. The
bug is reported as: https://bugs.launchpad.net/qemu/+bug/1188943
(Note the bug is marked "private" so you might not be able to see it)
* Introduced curl_header_cb, which is used to parse header and mark the
server as accepting range if "Accept-Ranges: bytes" line is seen from
response header. If protocol is HTTP or HTTPS, but server response has
no not this support, refuse to open this URL.
Note that python builtin module SimpleHTTPServer is an example of not
supporting range, if you need to test this driver, get a better server
or use internet URLs.
Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2013-07-02 15:19:21 +08:00
|
|
|
BDRVCURLState *s = opaque;
|
2009-05-11 23:41:42 +08:00
|
|
|
size_t realsize = size * nmemb;
|
curl: refuse to open URL from HTTP server without range support
CURL driver requests partial data from server on guest IO req. For HTTP
and HTTPS, it uses "Range: ***" in requests, and this will not work if
server not accepting range. This patch does this check when open.
* Removed curl_size_cb, which is not used: On one hand it's registered to
libcurl as CURLOPT_WRITEFUNCTION, instead of CURLOPT_HEADERFUNCTION,
which will get called with *data*, not *header*. On the other hand the
s->len is assigned unconditionally later.
In this gone function, the sscanf for "Content-Length: %zd", on
(void *)ptr, which is not guaranteed to be zero-terminated, is
potentially a security bug. So this patch fixes it as a side-effect. The
bug is reported as: https://bugs.launchpad.net/qemu/+bug/1188943
(Note the bug is marked "private" so you might not be able to see it)
* Introduced curl_header_cb, which is used to parse header and mark the
server as accepting range if "Accept-Ranges: bytes" line is seen from
response header. If protocol is HTTP or HTTPS, but server response has
no not this support, refuse to open this URL.
Note that python builtin module SimpleHTTPServer is an example of not
supporting range, if you need to test this driver, get a better server
or use internet URLs.
Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2013-07-02 15:19:21 +08:00
|
|
|
const char *accept_line = "Accept-Ranges: bytes";
|
2009-05-11 23:41:42 +08:00
|
|
|
|
curl: refuse to open URL from HTTP server without range support
CURL driver requests partial data from server on guest IO req. For HTTP
and HTTPS, it uses "Range: ***" in requests, and this will not work if
server not accepting range. This patch does this check when open.
* Removed curl_size_cb, which is not used: On one hand it's registered to
libcurl as CURLOPT_WRITEFUNCTION, instead of CURLOPT_HEADERFUNCTION,
which will get called with *data*, not *header*. On the other hand the
s->len is assigned unconditionally later.
In this gone function, the sscanf for "Content-Length: %zd", on
(void *)ptr, which is not guaranteed to be zero-terminated, is
potentially a security bug. So this patch fixes it as a side-effect. The
bug is reported as: https://bugs.launchpad.net/qemu/+bug/1188943
(Note the bug is marked "private" so you might not be able to see it)
* Introduced curl_header_cb, which is used to parse header and mark the
server as accepting range if "Accept-Ranges: bytes" line is seen from
response header. If protocol is HTTP or HTTPS, but server response has
no not this support, refuse to open this URL.
Note that python builtin module SimpleHTTPServer is an example of not
supporting range, if you need to test this driver, get a better server
or use internet URLs.
Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2013-07-02 15:19:21 +08:00
|
|
|
if (realsize >= strlen(accept_line)
|
|
|
|
&& strncmp((char *)ptr, accept_line, strlen(accept_line)) == 0) {
|
|
|
|
s->accept_range = true;
|
2010-05-22 16:02:12 +08:00
|
|
|
}
|
2009-05-11 23:41:42 +08:00
|
|
|
|
|
|
|
return realsize;
|
|
|
|
}
|
|
|
|
|
|
|
|
static size_t curl_read_cb(void *ptr, size_t size, size_t nmemb, void *opaque)
|
|
|
|
{
|
|
|
|
CURLState *s = ((CURLState*)opaque);
|
|
|
|
size_t realsize = size * nmemb;
|
|
|
|
int i;
|
|
|
|
|
2010-05-22 16:02:12 +08:00
|
|
|
DPRINTF("CURL: Just reading %zd bytes\n", realsize);
|
2009-05-11 23:41:42 +08:00
|
|
|
|
|
|
|
if (!s || !s->orig_buf)
|
|
|
|
goto read_end;
|
|
|
|
|
|
|
|
memcpy(s->orig_buf + s->buf_off, ptr, realsize);
|
|
|
|
s->buf_off += realsize;
|
|
|
|
|
|
|
|
for(i=0; i<CURL_NUM_ACB; i++) {
|
|
|
|
CURLAIOCB *acb = s->acb[i];
|
|
|
|
|
|
|
|
if (!acb)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if ((s->buf_off >= acb->end)) {
|
allow qemu_iovec_from_buffer() to specify offset from which to start copying
Similar to
qemu_iovec_memset(QEMUIOVector *qiov, size_t offset,
int c, size_t bytes);
the new prototype is:
qemu_iovec_from_buf(QEMUIOVector *qiov, size_t offset,
const void *buf, size_t bytes);
The processing starts at offset bytes within qiov.
This way, we may copy a bounce buffer directly to
a middle of qiov.
This is exactly the same function as iov_from_buf() from
iov.c, so use the existing implementation and rename it
to qemu_iovec_from_buf() to be shorter and to match the
utility function.
As with utility implementation, we now assert that the
offset is inside actual iovec. Nothing changed for
current callers, because `offset' parameter is new.
While at it, stop using "bounce-qiov" in block/qcow2.c
and copy decrypted data directly from cluster_data
instead of recreating a temp qiov for doing that.
Signed-off-by: Michael Tokarev <mjt@tls.msk.ru>
2012-06-08 00:17:55 +08:00
|
|
|
qemu_iovec_from_buf(acb->qiov, 0, s->orig_buf + acb->start,
|
|
|
|
acb->end - acb->start);
|
2009-05-11 23:41:42 +08:00
|
|
|
acb->common.cb(acb->common.opaque, 0);
|
|
|
|
qemu_aio_release(acb);
|
|
|
|
s->acb[i] = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
read_end:
|
|
|
|
return realsize;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int curl_find_buf(BDRVCURLState *s, size_t start, size_t len,
|
|
|
|
CURLAIOCB *acb)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
size_t end = start + len;
|
|
|
|
|
|
|
|
for (i=0; i<CURL_NUM_STATES; i++) {
|
|
|
|
CURLState *state = &s->states[i];
|
|
|
|
size_t buf_end = (state->buf_start + state->buf_off);
|
|
|
|
size_t buf_fend = (state->buf_start + state->buf_len);
|
|
|
|
|
|
|
|
if (!state->orig_buf)
|
|
|
|
continue;
|
|
|
|
if (!state->buf_off)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Does the existing buffer cover our section?
|
|
|
|
if ((start >= state->buf_start) &&
|
|
|
|
(start <= buf_end) &&
|
|
|
|
(end >= state->buf_start) &&
|
|
|
|
(end <= buf_end))
|
|
|
|
{
|
|
|
|
char *buf = state->orig_buf + (start - state->buf_start);
|
|
|
|
|
allow qemu_iovec_from_buffer() to specify offset from which to start copying
Similar to
qemu_iovec_memset(QEMUIOVector *qiov, size_t offset,
int c, size_t bytes);
the new prototype is:
qemu_iovec_from_buf(QEMUIOVector *qiov, size_t offset,
const void *buf, size_t bytes);
The processing starts at offset bytes within qiov.
This way, we may copy a bounce buffer directly to
a middle of qiov.
This is exactly the same function as iov_from_buf() from
iov.c, so use the existing implementation and rename it
to qemu_iovec_from_buf() to be shorter and to match the
utility function.
As with utility implementation, we now assert that the
offset is inside actual iovec. Nothing changed for
current callers, because `offset' parameter is new.
While at it, stop using "bounce-qiov" in block/qcow2.c
and copy decrypted data directly from cluster_data
instead of recreating a temp qiov for doing that.
Signed-off-by: Michael Tokarev <mjt@tls.msk.ru>
2012-06-08 00:17:55 +08:00
|
|
|
qemu_iovec_from_buf(acb->qiov, 0, buf, len);
|
2009-05-11 23:41:42 +08:00
|
|
|
acb->common.cb(acb->common.opaque, 0);
|
|
|
|
|
|
|
|
return FIND_RET_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Wait for unfinished chunks
|
|
|
|
if ((start >= state->buf_start) &&
|
|
|
|
(start <= buf_fend) &&
|
|
|
|
(end >= state->buf_start) &&
|
|
|
|
(end <= buf_fend))
|
|
|
|
{
|
|
|
|
int j;
|
|
|
|
|
|
|
|
acb->start = start - state->buf_start;
|
|
|
|
acb->end = acb->start + len;
|
|
|
|
|
|
|
|
for (j=0; j<CURL_NUM_ACB; j++) {
|
|
|
|
if (!state->acb[j]) {
|
|
|
|
state->acb[j] = acb;
|
|
|
|
return FIND_RET_WAIT;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return FIND_RET_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void curl_multi_do(void *arg)
|
|
|
|
{
|
|
|
|
BDRVCURLState *s = (BDRVCURLState *)arg;
|
|
|
|
int running;
|
|
|
|
int r;
|
|
|
|
int msgs_in_queue;
|
|
|
|
|
|
|
|
if (!s->multi)
|
|
|
|
return;
|
|
|
|
|
|
|
|
do {
|
|
|
|
r = curl_multi_socket_all(s->multi, &running);
|
|
|
|
} while(r == CURLM_CALL_MULTI_PERFORM);
|
|
|
|
|
|
|
|
/* Try to find done transfers, so we can free the easy
|
|
|
|
* handle again. */
|
|
|
|
do {
|
|
|
|
CURLMsg *msg;
|
|
|
|
msg = curl_multi_info_read(s->multi, &msgs_in_queue);
|
|
|
|
|
|
|
|
if (!msg)
|
|
|
|
break;
|
|
|
|
if (msg->msg == CURLMSG_NONE)
|
|
|
|
break;
|
|
|
|
|
|
|
|
switch (msg->msg) {
|
|
|
|
case CURLMSG_DONE:
|
|
|
|
{
|
|
|
|
CURLState *state = NULL;
|
|
|
|
curl_easy_getinfo(msg->easy_handle, CURLINFO_PRIVATE, (char**)&state);
|
2011-08-15 17:00:34 +08:00
|
|
|
|
|
|
|
/* ACBs for successful messages get completed in curl_read_cb */
|
|
|
|
if (msg->data.result != CURLE_OK) {
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < CURL_NUM_ACB; i++) {
|
|
|
|
CURLAIOCB *acb = state->acb[i];
|
|
|
|
|
|
|
|
if (acb == NULL) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
acb->common.cb(acb->common.opaque, -EIO);
|
|
|
|
qemu_aio_release(acb);
|
|
|
|
state->acb[i] = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-05-11 23:41:42 +08:00
|
|
|
curl_clean_state(state);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
msgs_in_queue = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} while(msgs_in_queue);
|
|
|
|
}
|
|
|
|
|
|
|
|
static CURLState *curl_init_state(BDRVCURLState *s)
|
|
|
|
{
|
|
|
|
CURLState *state = NULL;
|
|
|
|
int i, j;
|
|
|
|
|
|
|
|
do {
|
|
|
|
for (i=0; i<CURL_NUM_STATES; i++) {
|
|
|
|
for (j=0; j<CURL_NUM_ACB; j++)
|
|
|
|
if (s->states[i].acb[j])
|
|
|
|
continue;
|
|
|
|
if (s->states[i].in_use)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
state = &s->states[i];
|
|
|
|
state->in_use = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!state) {
|
2012-03-31 23:34:41 +08:00
|
|
|
g_usleep(100);
|
2009-05-11 23:41:42 +08:00
|
|
|
curl_multi_do(s);
|
|
|
|
}
|
|
|
|
} while(!state);
|
|
|
|
|
|
|
|
if (state->curl)
|
|
|
|
goto has_curl;
|
|
|
|
|
|
|
|
state->curl = curl_easy_init();
|
|
|
|
if (!state->curl)
|
|
|
|
return NULL;
|
|
|
|
curl_easy_setopt(state->curl, CURLOPT_URL, s->url);
|
|
|
|
curl_easy_setopt(state->curl, CURLOPT_TIMEOUT, 5);
|
2009-08-01 18:13:44 +08:00
|
|
|
curl_easy_setopt(state->curl, CURLOPT_WRITEFUNCTION, (void *)curl_read_cb);
|
2009-05-11 23:41:42 +08:00
|
|
|
curl_easy_setopt(state->curl, CURLOPT_WRITEDATA, (void *)state);
|
|
|
|
curl_easy_setopt(state->curl, CURLOPT_PRIVATE, (void *)state);
|
|
|
|
curl_easy_setopt(state->curl, CURLOPT_AUTOREFERER, 1);
|
|
|
|
curl_easy_setopt(state->curl, CURLOPT_FOLLOWLOCATION, 1);
|
|
|
|
curl_easy_setopt(state->curl, CURLOPT_NOSIGNAL, 1);
|
|
|
|
curl_easy_setopt(state->curl, CURLOPT_ERRORBUFFER, state->errmsg);
|
2011-08-15 17:00:34 +08:00
|
|
|
curl_easy_setopt(state->curl, CURLOPT_FAILONERROR, 1);
|
|
|
|
|
2013-02-08 15:49:10 +08:00
|
|
|
/* Restrict supported protocols to avoid security issues in the more
|
|
|
|
* obscure protocols. For example, do not allow POP3/SMTP/IMAP see
|
|
|
|
* CVE-2013-0249.
|
2013-02-13 16:25:34 +08:00
|
|
|
*
|
|
|
|
* Restricting protocols is only supported from 7.19.4 upwards.
|
2013-02-08 15:49:10 +08:00
|
|
|
*/
|
2013-02-13 16:25:34 +08:00
|
|
|
#if LIBCURL_VERSION_NUM >= 0x071304
|
2013-02-08 15:49:10 +08:00
|
|
|
curl_easy_setopt(state->curl, CURLOPT_PROTOCOLS, PROTOCOLS);
|
|
|
|
curl_easy_setopt(state->curl, CURLOPT_REDIR_PROTOCOLS, PROTOCOLS);
|
2013-02-13 16:25:34 +08:00
|
|
|
#endif
|
2013-02-08 15:49:10 +08:00
|
|
|
|
2009-05-11 23:41:42 +08:00
|
|
|
#ifdef DEBUG_VERBOSE
|
|
|
|
curl_easy_setopt(state->curl, CURLOPT_VERBOSE, 1);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
has_curl:
|
|
|
|
|
|
|
|
state->s = s;
|
|
|
|
|
|
|
|
return state;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void curl_clean_state(CURLState *s)
|
|
|
|
{
|
|
|
|
if (s->s->multi)
|
|
|
|
curl_multi_remove_handle(s->s->multi, s->curl);
|
|
|
|
s->in_use = 0;
|
|
|
|
}
|
|
|
|
|
2013-04-10 21:31:33 +08:00
|
|
|
static void curl_parse_filename(const char *filename, QDict *options,
|
|
|
|
Error **errp)
|
2009-05-11 23:41:42 +08:00
|
|
|
{
|
2009-07-02 08:16:52 +08:00
|
|
|
|
|
|
|
#define RA_OPTSTR ":readahead="
|
|
|
|
char *file;
|
|
|
|
char *ra;
|
|
|
|
const char *ra_val;
|
|
|
|
int parse_state = 0;
|
|
|
|
|
2011-08-21 11:09:37 +08:00
|
|
|
file = g_strdup(filename);
|
2009-07-02 08:16:52 +08:00
|
|
|
|
|
|
|
/* Parse a trailing ":readahead=#:" param, if present. */
|
|
|
|
ra = file + strlen(file) - 1;
|
|
|
|
while (ra >= file) {
|
|
|
|
if (parse_state == 0) {
|
2013-04-10 21:31:33 +08:00
|
|
|
if (*ra == ':') {
|
2009-07-02 08:16:52 +08:00
|
|
|
parse_state++;
|
2013-04-10 21:31:33 +08:00
|
|
|
} else {
|
2009-07-02 08:16:52 +08:00
|
|
|
break;
|
2013-04-10 21:31:33 +08:00
|
|
|
}
|
2009-07-02 08:16:52 +08:00
|
|
|
} else if (parse_state == 1) {
|
|
|
|
if (*ra > '9' || *ra < '0') {
|
|
|
|
char *opt_start = ra - strlen(RA_OPTSTR) + 1;
|
|
|
|
if (opt_start > file &&
|
|
|
|
strncmp(opt_start, RA_OPTSTR, strlen(RA_OPTSTR)) == 0) {
|
|
|
|
ra_val = ra + 1;
|
|
|
|
ra -= strlen(RA_OPTSTR) - 1;
|
|
|
|
*ra = '\0';
|
2013-04-10 21:31:33 +08:00
|
|
|
qdict_put(options, "readahead", qstring_from_str(ra_val));
|
2009-07-02 08:16:52 +08:00
|
|
|
}
|
2013-04-10 21:31:33 +08:00
|
|
|
break;
|
2009-07-02 08:16:52 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
ra--;
|
|
|
|
}
|
|
|
|
|
2013-04-10 21:31:33 +08:00
|
|
|
qdict_put(options, "url", qstring_from_str(file));
|
|
|
|
|
|
|
|
g_free(file);
|
|
|
|
}
|
|
|
|
|
|
|
|
static QemuOptsList runtime_opts = {
|
|
|
|
.name = "curl",
|
|
|
|
.head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
|
|
|
|
.desc = {
|
|
|
|
{
|
|
|
|
.name = "url",
|
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
.help = "URL to open",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "readahead",
|
|
|
|
.type = QEMU_OPT_SIZE,
|
|
|
|
.help = "Readahead size",
|
|
|
|
},
|
|
|
|
{ /* end of list */ }
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2013-04-13 02:02:37 +08:00
|
|
|
static int curl_open(BlockDriverState *bs, QDict *options, int flags)
|
2013-04-10 21:31:33 +08:00
|
|
|
{
|
|
|
|
BDRVCURLState *s = bs->opaque;
|
|
|
|
CURLState *state = NULL;
|
|
|
|
QemuOpts *opts;
|
|
|
|
Error *local_err = NULL;
|
|
|
|
const char *file;
|
|
|
|
double d;
|
|
|
|
|
|
|
|
static int inited = 0;
|
|
|
|
|
2013-06-10 19:38:43 +08:00
|
|
|
if (flags & BDRV_O_RDWR) {
|
|
|
|
qerror_report(ERROR_CLASS_GENERIC_ERROR,
|
|
|
|
"curl block device does not support writes");
|
|
|
|
return -EROFS;
|
|
|
|
}
|
|
|
|
|
2013-04-10 21:31:33 +08:00
|
|
|
opts = qemu_opts_create_nofail(&runtime_opts);
|
|
|
|
qemu_opts_absorb_qdict(opts, options, &local_err);
|
|
|
|
if (error_is_set(&local_err)) {
|
|
|
|
qerror_report_err(local_err);
|
|
|
|
error_free(local_err);
|
|
|
|
goto out_noclean;
|
|
|
|
}
|
|
|
|
|
|
|
|
s->readahead_size = qemu_opt_get_size(opts, "readahead", READ_AHEAD_SIZE);
|
2009-07-02 08:16:52 +08:00
|
|
|
if ((s->readahead_size & 0x1ff) != 0) {
|
2010-02-08 17:44:55 +08:00
|
|
|
fprintf(stderr, "HTTP_READAHEAD_SIZE %zd is not a multiple of 512\n",
|
2009-07-02 08:16:52 +08:00
|
|
|
s->readahead_size);
|
|
|
|
goto out_noclean;
|
|
|
|
}
|
|
|
|
|
2013-04-10 21:31:33 +08:00
|
|
|
file = qemu_opt_get(opts, "url");
|
|
|
|
if (file == NULL) {
|
|
|
|
qerror_report(ERROR_CLASS_GENERIC_ERROR, "curl block driver requires "
|
|
|
|
"an 'url' option");
|
|
|
|
goto out_noclean;
|
|
|
|
}
|
|
|
|
|
2009-05-11 23:41:42 +08:00
|
|
|
if (!inited) {
|
|
|
|
curl_global_init(CURL_GLOBAL_ALL);
|
|
|
|
inited = 1;
|
|
|
|
}
|
|
|
|
|
2010-02-07 07:03:50 +08:00
|
|
|
DPRINTF("CURL: Opening %s\n", file);
|
2013-04-10 21:31:33 +08:00
|
|
|
s->url = g_strdup(file);
|
2009-05-11 23:41:42 +08:00
|
|
|
state = curl_init_state(s);
|
|
|
|
if (!state)
|
|
|
|
goto out_noclean;
|
|
|
|
|
|
|
|
// Get file size
|
|
|
|
|
curl: refuse to open URL from HTTP server without range support
CURL driver requests partial data from server on guest IO req. For HTTP
and HTTPS, it uses "Range: ***" in requests, and this will not work if
server not accepting range. This patch does this check when open.
* Removed curl_size_cb, which is not used: On one hand it's registered to
libcurl as CURLOPT_WRITEFUNCTION, instead of CURLOPT_HEADERFUNCTION,
which will get called with *data*, not *header*. On the other hand the
s->len is assigned unconditionally later.
In this gone function, the sscanf for "Content-Length: %zd", on
(void *)ptr, which is not guaranteed to be zero-terminated, is
potentially a security bug. So this patch fixes it as a side-effect. The
bug is reported as: https://bugs.launchpad.net/qemu/+bug/1188943
(Note the bug is marked "private" so you might not be able to see it)
* Introduced curl_header_cb, which is used to parse header and mark the
server as accepting range if "Accept-Ranges: bytes" line is seen from
response header. If protocol is HTTP or HTTPS, but server response has
no not this support, refuse to open this URL.
Note that python builtin module SimpleHTTPServer is an example of not
supporting range, if you need to test this driver, get a better server
or use internet URLs.
Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2013-07-02 15:19:21 +08:00
|
|
|
s->accept_range = false;
|
2009-05-11 23:41:42 +08:00
|
|
|
curl_easy_setopt(state->curl, CURLOPT_NOBODY, 1);
|
curl: refuse to open URL from HTTP server without range support
CURL driver requests partial data from server on guest IO req. For HTTP
and HTTPS, it uses "Range: ***" in requests, and this will not work if
server not accepting range. This patch does this check when open.
* Removed curl_size_cb, which is not used: On one hand it's registered to
libcurl as CURLOPT_WRITEFUNCTION, instead of CURLOPT_HEADERFUNCTION,
which will get called with *data*, not *header*. On the other hand the
s->len is assigned unconditionally later.
In this gone function, the sscanf for "Content-Length: %zd", on
(void *)ptr, which is not guaranteed to be zero-terminated, is
potentially a security bug. So this patch fixes it as a side-effect. The
bug is reported as: https://bugs.launchpad.net/qemu/+bug/1188943
(Note the bug is marked "private" so you might not be able to see it)
* Introduced curl_header_cb, which is used to parse header and mark the
server as accepting range if "Accept-Ranges: bytes" line is seen from
response header. If protocol is HTTP or HTTPS, but server response has
no not this support, refuse to open this URL.
Note that python builtin module SimpleHTTPServer is an example of not
supporting range, if you need to test this driver, get a better server
or use internet URLs.
Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2013-07-02 15:19:21 +08:00
|
|
|
curl_easy_setopt(state->curl, CURLOPT_HEADERFUNCTION,
|
|
|
|
curl_header_cb);
|
|
|
|
curl_easy_setopt(state->curl, CURLOPT_HEADERDATA, s);
|
2009-05-11 23:41:42 +08:00
|
|
|
if (curl_easy_perform(state->curl))
|
|
|
|
goto out;
|
|
|
|
curl_easy_getinfo(state->curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &d);
|
|
|
|
if (d)
|
|
|
|
s->len = (size_t)d;
|
|
|
|
else if(!s->len)
|
|
|
|
goto out;
|
curl: refuse to open URL from HTTP server without range support
CURL driver requests partial data from server on guest IO req. For HTTP
and HTTPS, it uses "Range: ***" in requests, and this will not work if
server not accepting range. This patch does this check when open.
* Removed curl_size_cb, which is not used: On one hand it's registered to
libcurl as CURLOPT_WRITEFUNCTION, instead of CURLOPT_HEADERFUNCTION,
which will get called with *data*, not *header*. On the other hand the
s->len is assigned unconditionally later.
In this gone function, the sscanf for "Content-Length: %zd", on
(void *)ptr, which is not guaranteed to be zero-terminated, is
potentially a security bug. So this patch fixes it as a side-effect. The
bug is reported as: https://bugs.launchpad.net/qemu/+bug/1188943
(Note the bug is marked "private" so you might not be able to see it)
* Introduced curl_header_cb, which is used to parse header and mark the
server as accepting range if "Accept-Ranges: bytes" line is seen from
response header. If protocol is HTTP or HTTPS, but server response has
no not this support, refuse to open this URL.
Note that python builtin module SimpleHTTPServer is an example of not
supporting range, if you need to test this driver, get a better server
or use internet URLs.
Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2013-07-02 15:19:21 +08:00
|
|
|
if ((!strncasecmp(s->url, "http://", strlen("http://"))
|
|
|
|
|| !strncasecmp(s->url, "https://", strlen("https://")))
|
|
|
|
&& !s->accept_range) {
|
|
|
|
pstrcpy(state->errmsg, CURL_ERROR_SIZE,
|
|
|
|
"Server does not support 'range' (byte ranges).");
|
|
|
|
goto out;
|
|
|
|
}
|
2010-05-22 16:02:12 +08:00
|
|
|
DPRINTF("CURL: Size = %zd\n", s->len);
|
2009-05-11 23:41:42 +08:00
|
|
|
|
|
|
|
curl_clean_state(state);
|
|
|
|
curl_easy_cleanup(state->curl);
|
|
|
|
state->curl = NULL;
|
|
|
|
|
|
|
|
// Now we know the file exists and its size, so let's
|
|
|
|
// initialize the multi interface!
|
|
|
|
|
|
|
|
s->multi = curl_multi_init();
|
2013-06-10 21:14:35 +08:00
|
|
|
curl_multi_setopt(s->multi, CURLMOPT_SOCKETDATA, s);
|
|
|
|
curl_multi_setopt(s->multi, CURLMOPT_SOCKETFUNCTION, curl_sock_cb);
|
2009-05-11 23:41:42 +08:00
|
|
|
curl_multi_do(s);
|
|
|
|
|
2013-04-10 21:31:33 +08:00
|
|
|
qemu_opts_del(opts);
|
2009-05-11 23:41:42 +08:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
out:
|
|
|
|
fprintf(stderr, "CURL: Error opening file: %s\n", state->errmsg);
|
|
|
|
curl_easy_cleanup(state->curl);
|
|
|
|
state->curl = NULL;
|
|
|
|
out_noclean:
|
2013-04-10 21:31:33 +08:00
|
|
|
g_free(s->url);
|
|
|
|
qemu_opts_del(opts);
|
2009-05-11 23:41:42 +08:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2011-09-21 18:55:49 +08:00
|
|
|
static int curl_aio_flush(void *opaque)
|
|
|
|
{
|
|
|
|
BDRVCURLState *s = opaque;
|
|
|
|
int i, j;
|
|
|
|
|
|
|
|
for (i=0; i < CURL_NUM_STATES; i++) {
|
|
|
|
for(j=0; j < CURL_NUM_ACB; j++) {
|
|
|
|
if (s->states[i].acb[j]) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-05-25 18:37:32 +08:00
|
|
|
static void curl_aio_cancel(BlockDriverAIOCB *blockacb)
|
|
|
|
{
|
|
|
|
// Do we have to implement canceling? Seems to work without...
|
|
|
|
}
|
|
|
|
|
2012-10-31 23:34:37 +08:00
|
|
|
static const AIOCBInfo curl_aiocb_info = {
|
2009-05-25 18:37:32 +08:00
|
|
|
.aiocb_size = sizeof(CURLAIOCB),
|
|
|
|
.cancel = curl_aio_cancel,
|
|
|
|
};
|
|
|
|
|
2011-09-21 18:55:50 +08:00
|
|
|
|
|
|
|
static void curl_readv_bh_cb(void *p)
|
2009-05-11 23:41:42 +08:00
|
|
|
{
|
|
|
|
CURLState *state;
|
|
|
|
|
2011-09-21 18:55:50 +08:00
|
|
|
CURLAIOCB *acb = p;
|
|
|
|
BDRVCURLState *s = acb->common.bs->opaque;
|
2009-05-11 23:41:42 +08:00
|
|
|
|
2011-09-21 18:55:50 +08:00
|
|
|
qemu_bh_delete(acb->bh);
|
|
|
|
acb->bh = NULL;
|
|
|
|
|
|
|
|
size_t start = acb->sector_num * SECTOR_SIZE;
|
|
|
|
size_t end;
|
2009-05-11 23:41:42 +08:00
|
|
|
|
|
|
|
// In case we have the requested data already (e.g. read-ahead),
|
|
|
|
// we can just call the callback and be done.
|
2011-09-21 18:55:50 +08:00
|
|
|
switch (curl_find_buf(s, start, acb->nb_sectors * SECTOR_SIZE, acb)) {
|
2009-05-11 23:41:42 +08:00
|
|
|
case FIND_RET_OK:
|
|
|
|
qemu_aio_release(acb);
|
|
|
|
// fall through
|
|
|
|
case FIND_RET_WAIT:
|
2011-09-21 18:55:50 +08:00
|
|
|
return;
|
2009-05-11 23:41:42 +08:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// No cache found, so let's start a new request
|
|
|
|
state = curl_init_state(s);
|
2011-09-21 18:55:50 +08:00
|
|
|
if (!state) {
|
|
|
|
acb->common.cb(acb->common.opaque, -EIO);
|
|
|
|
qemu_aio_release(acb);
|
|
|
|
return;
|
|
|
|
}
|
2009-05-11 23:41:42 +08:00
|
|
|
|
|
|
|
acb->start = 0;
|
2011-09-21 18:55:50 +08:00
|
|
|
acb->end = (acb->nb_sectors * SECTOR_SIZE);
|
2009-05-11 23:41:42 +08:00
|
|
|
|
|
|
|
state->buf_off = 0;
|
|
|
|
if (state->orig_buf)
|
2011-08-21 11:09:37 +08:00
|
|
|
g_free(state->orig_buf);
|
2009-05-11 23:41:42 +08:00
|
|
|
state->buf_start = start;
|
2009-07-02 08:16:52 +08:00
|
|
|
state->buf_len = acb->end + s->readahead_size;
|
2009-05-11 23:41:42 +08:00
|
|
|
end = MIN(start + state->buf_len, s->len) - 1;
|
2011-08-21 11:09:37 +08:00
|
|
|
state->orig_buf = g_malloc(state->buf_len);
|
2009-05-11 23:41:42 +08:00
|
|
|
state->acb[0] = acb;
|
|
|
|
|
2010-05-22 16:02:12 +08:00
|
|
|
snprintf(state->range, 127, "%zd-%zd", start, end);
|
|
|
|
DPRINTF("CURL (AIO): Reading %d at %zd (%s)\n",
|
2011-09-21 18:55:50 +08:00
|
|
|
(acb->nb_sectors * SECTOR_SIZE), start, state->range);
|
2009-05-11 23:41:42 +08:00
|
|
|
curl_easy_setopt(state->curl, CURLOPT_RANGE, state->range);
|
|
|
|
|
|
|
|
curl_multi_add_handle(s->multi, state->curl);
|
|
|
|
curl_multi_do(s);
|
|
|
|
|
2011-09-21 18:55:50 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static BlockDriverAIOCB *curl_aio_readv(BlockDriverState *bs,
|
|
|
|
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
|
|
|
|
BlockDriverCompletionFunc *cb, void *opaque)
|
|
|
|
{
|
|
|
|
CURLAIOCB *acb;
|
|
|
|
|
2012-10-31 23:34:37 +08:00
|
|
|
acb = qemu_aio_get(&curl_aiocb_info, bs, cb, opaque);
|
2011-09-21 18:55:50 +08:00
|
|
|
|
|
|
|
acb->qiov = qiov;
|
|
|
|
acb->sector_num = sector_num;
|
|
|
|
acb->nb_sectors = nb_sectors;
|
|
|
|
|
|
|
|
acb->bh = qemu_bh_new(curl_readv_bh_cb, acb);
|
|
|
|
|
|
|
|
if (!acb->bh) {
|
|
|
|
DPRINTF("CURL: qemu_bh_new failed\n");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
qemu_bh_schedule(acb->bh);
|
2009-05-11 23:41:42 +08:00
|
|
|
return &acb->common;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void curl_close(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
BDRVCURLState *s = bs->opaque;
|
|
|
|
int i;
|
|
|
|
|
2010-02-07 07:03:50 +08:00
|
|
|
DPRINTF("CURL: Close\n");
|
2009-05-11 23:41:42 +08:00
|
|
|
for (i=0; i<CURL_NUM_STATES; i++) {
|
|
|
|
if (s->states[i].in_use)
|
|
|
|
curl_clean_state(&s->states[i]);
|
|
|
|
if (s->states[i].curl) {
|
|
|
|
curl_easy_cleanup(s->states[i].curl);
|
|
|
|
s->states[i].curl = NULL;
|
|
|
|
}
|
|
|
|
if (s->states[i].orig_buf) {
|
2011-08-21 11:09:37 +08:00
|
|
|
g_free(s->states[i].orig_buf);
|
2009-05-11 23:41:42 +08:00
|
|
|
s->states[i].orig_buf = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (s->multi)
|
|
|
|
curl_multi_cleanup(s->multi);
|
2012-09-01 17:06:45 +08:00
|
|
|
g_free(s->url);
|
2009-05-11 23:41:42 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int64_t curl_getlength(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
BDRVCURLState *s = bs->opaque;
|
|
|
|
return s->len;
|
|
|
|
}
|
|
|
|
|
|
|
|
static BlockDriver bdrv_http = {
|
2013-04-10 21:31:33 +08:00
|
|
|
.format_name = "http",
|
|
|
|
.protocol_name = "http",
|
2009-05-11 23:41:42 +08:00
|
|
|
|
2013-04-10 21:31:33 +08:00
|
|
|
.instance_size = sizeof(BDRVCURLState),
|
|
|
|
.bdrv_parse_filename = curl_parse_filename,
|
|
|
|
.bdrv_file_open = curl_open,
|
|
|
|
.bdrv_close = curl_close,
|
|
|
|
.bdrv_getlength = curl_getlength,
|
2009-05-11 23:41:42 +08:00
|
|
|
|
2013-04-10 21:31:33 +08:00
|
|
|
.bdrv_aio_readv = curl_aio_readv,
|
2009-05-11 23:41:42 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
static BlockDriver bdrv_https = {
|
2013-04-10 21:31:33 +08:00
|
|
|
.format_name = "https",
|
|
|
|
.protocol_name = "https",
|
2009-05-11 23:41:42 +08:00
|
|
|
|
2013-04-10 21:31:33 +08:00
|
|
|
.instance_size = sizeof(BDRVCURLState),
|
|
|
|
.bdrv_parse_filename = curl_parse_filename,
|
|
|
|
.bdrv_file_open = curl_open,
|
|
|
|
.bdrv_close = curl_close,
|
|
|
|
.bdrv_getlength = curl_getlength,
|
2009-05-11 23:41:42 +08:00
|
|
|
|
2013-04-10 21:31:33 +08:00
|
|
|
.bdrv_aio_readv = curl_aio_readv,
|
2009-05-11 23:41:42 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
static BlockDriver bdrv_ftp = {
|
2013-04-10 21:31:33 +08:00
|
|
|
.format_name = "ftp",
|
|
|
|
.protocol_name = "ftp",
|
2009-05-11 23:41:42 +08:00
|
|
|
|
2013-04-10 21:31:33 +08:00
|
|
|
.instance_size = sizeof(BDRVCURLState),
|
|
|
|
.bdrv_parse_filename = curl_parse_filename,
|
|
|
|
.bdrv_file_open = curl_open,
|
|
|
|
.bdrv_close = curl_close,
|
|
|
|
.bdrv_getlength = curl_getlength,
|
2009-05-11 23:41:42 +08:00
|
|
|
|
2013-04-10 21:31:33 +08:00
|
|
|
.bdrv_aio_readv = curl_aio_readv,
|
2009-05-11 23:41:42 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
static BlockDriver bdrv_ftps = {
|
2013-04-10 21:31:33 +08:00
|
|
|
.format_name = "ftps",
|
|
|
|
.protocol_name = "ftps",
|
2009-05-11 23:41:42 +08:00
|
|
|
|
2013-04-10 21:31:33 +08:00
|
|
|
.instance_size = sizeof(BDRVCURLState),
|
|
|
|
.bdrv_parse_filename = curl_parse_filename,
|
|
|
|
.bdrv_file_open = curl_open,
|
|
|
|
.bdrv_close = curl_close,
|
|
|
|
.bdrv_getlength = curl_getlength,
|
2009-05-11 23:41:42 +08:00
|
|
|
|
2013-04-10 21:31:33 +08:00
|
|
|
.bdrv_aio_readv = curl_aio_readv,
|
2009-05-11 23:41:42 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
static BlockDriver bdrv_tftp = {
|
2013-04-10 21:31:33 +08:00
|
|
|
.format_name = "tftp",
|
|
|
|
.protocol_name = "tftp",
|
2009-05-11 23:41:42 +08:00
|
|
|
|
2013-04-10 21:31:33 +08:00
|
|
|
.instance_size = sizeof(BDRVCURLState),
|
|
|
|
.bdrv_parse_filename = curl_parse_filename,
|
|
|
|
.bdrv_file_open = curl_open,
|
|
|
|
.bdrv_close = curl_close,
|
|
|
|
.bdrv_getlength = curl_getlength,
|
2009-05-11 23:41:42 +08:00
|
|
|
|
2013-04-10 21:31:33 +08:00
|
|
|
.bdrv_aio_readv = curl_aio_readv,
|
2009-05-11 23:41:42 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
static void curl_block_init(void)
|
|
|
|
{
|
|
|
|
bdrv_register(&bdrv_http);
|
|
|
|
bdrv_register(&bdrv_https);
|
|
|
|
bdrv_register(&bdrv_ftp);
|
|
|
|
bdrv_register(&bdrv_ftps);
|
|
|
|
bdrv_register(&bdrv_tftp);
|
|
|
|
}
|
|
|
|
|
|
|
|
block_init(curl_block_init);
|