2009-05-11 17:41:42 +02: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.
|
|
|
|
*/
|
2016-01-18 19:01:42 +01:00
|
|
|
#include "qemu/osdep.h"
|
include/qemu/osdep.h: Don't include qapi/error.h
Commit 57cb38b included qapi/error.h into qemu/osdep.h to get the
Error typedef. Since then, we've moved to include qemu/osdep.h
everywhere. Its file comment explains: "To avoid getting into
possible circular include dependencies, this file should not include
any other QEMU headers, with the exceptions of config-host.h,
compiler.h, os-posix.h and os-win32.h, all of which are doing a
similar job to this file and are under similar constraints."
qapi/error.h doesn't do a similar job, and it doesn't adhere to
similar constraints: it includes qapi-types.h. That's in excess of
100KiB of crap most .c files don't actually need.
Add the typedef to qemu/typedefs.h, and include that instead of
qapi/error.h. Include qapi/error.h in .c files that need it and don't
get it now. Include qapi-types.h in qom/object.h for uint16List.
Update scripts/clean-includes accordingly. Update it further to match
reality: replace config.h by config-target.h, add sysemu/os-posix.h,
sysemu/os-win32.h. Update the list of includes in the qemu/osdep.h
comment quoted above similarly.
This reduces the number of objects depending on qapi/error.h from "all
of them" to less than a third. Unfortunately, the number depending on
qapi-types.h shrinks only a little. More work is needed for that one.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
[Fix compilation without the spice devel packages. - Paolo]
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2016-03-14 09:01:28 +01:00
|
|
|
#include "qapi/error.h"
|
2009-05-11 17:41:42 +02:00
|
|
|
#include "qemu-common.h"
|
2015-07-08 15:37:48 +02:00
|
|
|
#include "qemu/error-report.h"
|
2012-12-17 18:19:44 +01:00
|
|
|
#include "block/block_int.h"
|
2014-05-15 01:28:42 +02:00
|
|
|
#include "qapi/qmp/qbool.h"
|
2015-03-17 18:29:20 +01:00
|
|
|
#include "qapi/qmp/qstring.h"
|
curl: add support for HTTP authentication parameters
If connecting to a web server which has authentication
turned on, QEMU gets a 401 as curl has not been configured
with any authentication credentials.
This adds 4 new parameters to the curl block driver
options 'username', 'password-secret', 'proxy-username'
and 'proxy-password-secret'. Passwords are provided using
the recently added 'secret' object type
$QEMU \
-object secret,id=sec0,filename=/home/berrange/example.pw \
-object secret,id=sec1,filename=/home/berrange/proxy.pw \
-drive driver=http,url=http://example.com/some.img,\
username=dan,password-secret=sec0,\
proxy-username=dan,proxy-password-secret=sec1
Of course it is possible to use the same secret for both the
proxy & server passwords if desired, or omit the proxy auth
details, or the server auth details as required.
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Message-id: 1453385961-10718-3-git-send-email-berrange@redhat.com
Signed-off-by: Jeff Cody <jcody@redhat.com>
2016-01-21 15:19:20 +01:00
|
|
|
#include "crypto/secret.h"
|
2009-05-11 17:41:42 +02:00
|
|
|
#include <curl/curl.h>
|
2016-03-20 18:16:19 +01:00
|
|
|
#include "qemu/cutils.h"
|
2009-05-11 17:41:42 +02:00
|
|
|
|
2014-08-26 22:31:08 +02:00
|
|
|
// #define DEBUG_CURL
|
2009-05-11 17:41:42 +02:00
|
|
|
// #define DEBUG_VERBOSE
|
|
|
|
|
|
|
|
#ifdef DEBUG_CURL
|
2016-04-29 07:12:01 +02:00
|
|
|
#define DEBUG_CURL_PRINT 1
|
2009-05-11 17:41:42 +02:00
|
|
|
#else
|
2016-04-29 07:12:01 +02:00
|
|
|
#define DEBUG_CURL_PRINT 0
|
2009-05-11 17:41:42 +02:00
|
|
|
#endif
|
2016-04-29 07:12:01 +02:00
|
|
|
#define DPRINTF(fmt, ...) \
|
|
|
|
do { \
|
|
|
|
if (DEBUG_CURL_PRINT) { \
|
|
|
|
fprintf(stderr, fmt, ## __VA_ARGS__); \
|
|
|
|
} \
|
|
|
|
} while (0)
|
2009-05-11 17:41:42 +02:00
|
|
|
|
2014-01-24 14:56:17 +01:00
|
|
|
#if LIBCURL_VERSION_NUM >= 0x071000
|
|
|
|
/* The multi interface timer callback was introduced in 7.16.0 */
|
|
|
|
#define NEED_CURL_TIMER_CALLBACK
|
2014-05-15 01:28:40 +02:00
|
|
|
#define HAVE_SOCKET_ACTION
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef HAVE_SOCKET_ACTION
|
|
|
|
/* If curl_multi_socket_action isn't available, define it statically here in
|
|
|
|
* terms of curl_multi_socket. Note that ev_bitmask will be ignored, which is
|
|
|
|
* less efficient but still safe. */
|
|
|
|
static CURLMcode __curl_multi_socket_action(CURLM *multi_handle,
|
|
|
|
curl_socket_t sockfd,
|
|
|
|
int ev_bitmask,
|
|
|
|
int *running_handles)
|
|
|
|
{
|
|
|
|
return curl_multi_socket(multi_handle, sockfd, running_handles);
|
|
|
|
}
|
|
|
|
#define curl_multi_socket_action __curl_multi_socket_action
|
2014-01-24 14:56:17 +01:00
|
|
|
#endif
|
|
|
|
|
2013-02-08 08:49:10 +01:00
|
|
|
#define PROTOCOLS (CURLPROTO_HTTP | CURLPROTO_HTTPS | \
|
block/curl: Drop TFTP "support"
Because TFTP does not support byte ranges, it was never usable with our
curl block driver. Since apparently nobody has ever complained loudly
enough for someone to take care of the issue until now, it seems
reasonable to assume that nobody has ever actually used it.
Therefore, it should be safe to just drop it from curl's protocol list.
[Jeff Cody: Below is additional summary pulled, with some rewording,
from followup emails between Max and Markus, to explain what
worked and what didn't]
TFTP would sometimes work, to a limited extent, for images <= the curl
"readahead" size, so long as reads started at offset zero. By default,
that readahead size is 256KB.
Reads starting at a non-zero offset would also have returned data from a
zero offset. It can become more complicated still, with mixed reads at
zero offset and non-zero offsets, due to data buffering.
In short, TFTP could only have worked before in very specific scenarios
with unrealistic expectations and constraints.
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Jeff Cody <jcody@redhat.com>
Message-id: 20161102175539.4375-4-mreitz@redhat.com
Signed-off-by: Jeff Cody <jcody@redhat.com>
2016-11-02 18:55:37 +01:00
|
|
|
CURLPROTO_FTP | CURLPROTO_FTPS)
|
2013-02-08 08:49:10 +01:00
|
|
|
|
2009-05-11 17:41:42 +02:00
|
|
|
#define CURL_NUM_STATES 8
|
|
|
|
#define CURL_NUM_ACB 8
|
2014-05-15 01:28:41 +02:00
|
|
|
#define READ_AHEAD_DEFAULT (256 * 1024)
|
2014-08-13 17:44:27 +02:00
|
|
|
#define CURL_TIMEOUT_DEFAULT 5
|
2014-10-26 12:05:27 +01:00
|
|
|
#define CURL_TIMEOUT_MAX 10000
|
2009-05-11 17:41:42 +02:00
|
|
|
|
|
|
|
#define FIND_RET_NONE 0
|
|
|
|
#define FIND_RET_OK 1
|
|
|
|
#define FIND_RET_WAIT 2
|
|
|
|
|
2014-05-15 01:28:41 +02:00
|
|
|
#define CURL_BLOCK_OPT_URL "url"
|
|
|
|
#define CURL_BLOCK_OPT_READAHEAD "readahead"
|
2014-05-15 01:28:42 +02:00
|
|
|
#define CURL_BLOCK_OPT_SSLVERIFY "sslverify"
|
2014-08-13 17:44:27 +02:00
|
|
|
#define CURL_BLOCK_OPT_TIMEOUT "timeout"
|
2014-08-29 17:03:12 +02:00
|
|
|
#define CURL_BLOCK_OPT_COOKIE "cookie"
|
curl: add support for HTTP authentication parameters
If connecting to a web server which has authentication
turned on, QEMU gets a 401 as curl has not been configured
with any authentication credentials.
This adds 4 new parameters to the curl block driver
options 'username', 'password-secret', 'proxy-username'
and 'proxy-password-secret'. Passwords are provided using
the recently added 'secret' object type
$QEMU \
-object secret,id=sec0,filename=/home/berrange/example.pw \
-object secret,id=sec1,filename=/home/berrange/proxy.pw \
-drive driver=http,url=http://example.com/some.img,\
username=dan,password-secret=sec0,\
proxy-username=dan,proxy-password-secret=sec1
Of course it is possible to use the same secret for both the
proxy & server passwords if desired, or omit the proxy auth
details, or the server auth details as required.
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Message-id: 1453385961-10718-3-git-send-email-berrange@redhat.com
Signed-off-by: Jeff Cody <jcody@redhat.com>
2016-01-21 15:19:20 +01:00
|
|
|
#define CURL_BLOCK_OPT_USERNAME "username"
|
|
|
|
#define CURL_BLOCK_OPT_PASSWORD_SECRET "password-secret"
|
|
|
|
#define CURL_BLOCK_OPT_PROXY_USERNAME "proxy-username"
|
|
|
|
#define CURL_BLOCK_OPT_PROXY_PASSWORD_SECRET "proxy-password-secret"
|
2014-05-15 01:28:41 +02:00
|
|
|
|
2009-05-11 17:41:42 +02:00
|
|
|
struct BDRVCURLState;
|
|
|
|
|
|
|
|
typedef struct CURLAIOCB {
|
2014-10-07 13:59:14 +02:00
|
|
|
BlockAIOCB common;
|
2009-05-11 17:41:42 +02:00
|
|
|
QEMUIOVector *qiov;
|
2011-09-21 12:55:50 +02:00
|
|
|
|
|
|
|
int64_t sector_num;
|
|
|
|
int nb_sectors;
|
|
|
|
|
2009-05-11 17:41:42 +02:00
|
|
|
size_t start;
|
|
|
|
size_t end;
|
|
|
|
} CURLAIOCB;
|
|
|
|
|
2016-10-25 04:54:30 +02:00
|
|
|
typedef struct CURLSocket {
|
|
|
|
int fd;
|
|
|
|
QLIST_ENTRY(CURLSocket) next;
|
|
|
|
} CURLSocket;
|
|
|
|
|
2009-05-11 17:41:42 +02:00
|
|
|
typedef struct CURLState
|
|
|
|
{
|
|
|
|
struct BDRVCURLState *s;
|
|
|
|
CURLAIOCB *acb[CURL_NUM_ACB];
|
|
|
|
CURL *curl;
|
2016-10-25 04:54:30 +02:00
|
|
|
QLIST_HEAD(, CURLSocket) sockets;
|
2009-05-11 17:41:42 +02:00
|
|
|
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;
|
2014-01-24 14:56:17 +01:00
|
|
|
QEMUTimer timer;
|
2009-05-11 17:41:42 +02:00
|
|
|
size_t len;
|
|
|
|
CURLState states[CURL_NUM_STATES];
|
|
|
|
char *url;
|
2009-07-02 02:16:52 +02:00
|
|
|
size_t readahead_size;
|
2014-05-15 01:28:42 +02:00
|
|
|
bool sslverify;
|
2014-10-26 12:05:27 +01:00
|
|
|
uint64_t timeout;
|
2014-08-29 17:03:12 +02:00
|
|
|
char *cookie;
|
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 09:19:21 +02:00
|
|
|
bool accept_range;
|
2014-05-08 16:34:40 +02:00
|
|
|
AioContext *aio_context;
|
2017-02-22 19:07:23 +01:00
|
|
|
QemuMutex mutex;
|
curl: add support for HTTP authentication parameters
If connecting to a web server which has authentication
turned on, QEMU gets a 401 as curl has not been configured
with any authentication credentials.
This adds 4 new parameters to the curl block driver
options 'username', 'password-secret', 'proxy-username'
and 'proxy-password-secret'. Passwords are provided using
the recently added 'secret' object type
$QEMU \
-object secret,id=sec0,filename=/home/berrange/example.pw \
-object secret,id=sec1,filename=/home/berrange/proxy.pw \
-drive driver=http,url=http://example.com/some.img,\
username=dan,password-secret=sec0,\
proxy-username=dan,proxy-password-secret=sec1
Of course it is possible to use the same secret for both the
proxy & server passwords if desired, or omit the proxy auth
details, or the server auth details as required.
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Message-id: 1453385961-10718-3-git-send-email-berrange@redhat.com
Signed-off-by: Jeff Cody <jcody@redhat.com>
2016-01-21 15:19:20 +01:00
|
|
|
char *username;
|
|
|
|
char *password;
|
|
|
|
char *proxyusername;
|
|
|
|
char *proxypassword;
|
2009-05-11 17:41:42 +02:00
|
|
|
} BDRVCURLState;
|
|
|
|
|
|
|
|
static void curl_clean_state(CURLState *s);
|
|
|
|
static void curl_multi_do(void *arg);
|
2014-04-29 17:03:30 +02:00
|
|
|
static void curl_multi_read(void *arg);
|
2009-05-11 17:41:42 +02:00
|
|
|
|
2014-01-24 14:56:17 +01:00
|
|
|
#ifdef NEED_CURL_TIMER_CALLBACK
|
|
|
|
static int curl_timer_cb(CURLM *multi, long timeout_ms, void *opaque)
|
|
|
|
{
|
|
|
|
BDRVCURLState *s = opaque;
|
|
|
|
|
|
|
|
DPRINTF("CURL: timer callback timeout_ms %ld\n", timeout_ms);
|
|
|
|
if (timeout_ms == -1) {
|
|
|
|
timer_del(&s->timer);
|
|
|
|
} else {
|
|
|
|
int64_t timeout_ns = (int64_t)timeout_ms * 1000 * 1000;
|
|
|
|
timer_mod(&s->timer,
|
|
|
|
qemu_clock_get_ns(QEMU_CLOCK_REALTIME) + timeout_ns);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2009-05-11 17:41:42 +02:00
|
|
|
static int curl_sock_cb(CURL *curl, curl_socket_t fd, int action,
|
2014-05-08 16:34:40 +02:00
|
|
|
void *userp, void *sp)
|
2009-05-11 17:41:42 +02:00
|
|
|
{
|
2014-05-08 16:34:40 +02:00
|
|
|
BDRVCURLState *s;
|
2014-04-29 17:03:30 +02:00
|
|
|
CURLState *state = NULL;
|
2016-10-25 04:54:30 +02:00
|
|
|
CURLSocket *socket;
|
|
|
|
|
2014-04-29 17:03:30 +02:00
|
|
|
curl_easy_getinfo(curl, CURLINFO_PRIVATE, (char **)&state);
|
2014-05-08 16:34:40 +02:00
|
|
|
s = state->s;
|
2014-04-29 17:03:30 +02:00
|
|
|
|
2016-10-25 04:54:30 +02:00
|
|
|
QLIST_FOREACH(socket, &state->sockets, next) {
|
|
|
|
if (socket->fd == fd) {
|
|
|
|
if (action == CURL_POLL_REMOVE) {
|
|
|
|
QLIST_REMOVE(socket, next);
|
|
|
|
g_free(socket);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!socket) {
|
|
|
|
socket = g_new0(CURLSocket, 1);
|
|
|
|
socket->fd = fd;
|
|
|
|
QLIST_INSERT_HEAD(&state->sockets, socket, next);
|
|
|
|
}
|
|
|
|
socket = NULL;
|
|
|
|
|
2016-08-01 07:04:48 +02:00
|
|
|
DPRINTF("CURL (AIO): Sock action %d on fd %d\n", action, (int)fd);
|
2009-05-11 17:41:42 +02:00
|
|
|
switch (action) {
|
|
|
|
case CURL_POLL_IN:
|
2015-10-23 05:08:05 +02:00
|
|
|
aio_set_fd_handler(s->aio_context, fd, false,
|
2016-12-01 20:26:41 +01:00
|
|
|
curl_multi_read, NULL, NULL, state);
|
2009-05-11 17:41:42 +02:00
|
|
|
break;
|
|
|
|
case CURL_POLL_OUT:
|
2015-10-23 05:08:05 +02:00
|
|
|
aio_set_fd_handler(s->aio_context, fd, false,
|
2016-12-01 20:26:41 +01:00
|
|
|
NULL, curl_multi_do, NULL, state);
|
2009-05-11 17:41:42 +02:00
|
|
|
break;
|
|
|
|
case CURL_POLL_INOUT:
|
2015-10-23 05:08:05 +02:00
|
|
|
aio_set_fd_handler(s->aio_context, fd, false,
|
2016-12-01 20:26:41 +01:00
|
|
|
curl_multi_read, curl_multi_do, NULL, state);
|
2009-05-11 17:41:42 +02:00
|
|
|
break;
|
|
|
|
case CURL_POLL_REMOVE:
|
2015-10-23 05:08:05 +02:00
|
|
|
aio_set_fd_handler(s->aio_context, fd, false,
|
2016-12-01 20:26:41 +01:00
|
|
|
NULL, NULL, NULL, NULL);
|
2009-05-11 17:41:42 +02: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 09:19:21 +02:00
|
|
|
static size_t curl_header_cb(void *ptr, size_t size, size_t nmemb, void *opaque)
|
2009-05-11 17:41:42 +02: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 09:19:21 +02:00
|
|
|
BDRVCURLState *s = opaque;
|
2009-05-11 17:41:42 +02: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 09:19:21 +02:00
|
|
|
const char *accept_line = "Accept-Ranges: bytes";
|
2009-05-11 17:41:42 +02: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 09:19:21 +02:00
|
|
|
if (realsize >= strlen(accept_line)
|
|
|
|
&& strncmp((char *)ptr, accept_line, strlen(accept_line)) == 0) {
|
|
|
|
s->accept_range = true;
|
2010-05-22 10:02:12 +02:00
|
|
|
}
|
2009-05-11 17:41:42 +02: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 10:02:12 +02:00
|
|
|
DPRINTF("CURL: Just reading %zd bytes\n", realsize);
|
2009-05-11 17:41:42 +02:00
|
|
|
|
2016-10-25 04:54:29 +02:00
|
|
|
if (!s || !s->orig_buf) {
|
|
|
|
goto read_end;
|
|
|
|
}
|
2009-05-11 17:41:42 +02:00
|
|
|
|
2014-03-26 13:05:40 +01:00
|
|
|
if (s->buf_off >= s->buf_len) {
|
|
|
|
/* buffer full, read nothing */
|
2016-10-25 04:54:29 +02:00
|
|
|
goto read_end;
|
2014-03-26 13:05:40 +01:00
|
|
|
}
|
|
|
|
realsize = MIN(realsize, s->buf_len - s->buf_off);
|
2009-05-11 17:41:42 +02:00
|
|
|
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)) {
|
2016-10-25 04:54:31 +02:00
|
|
|
size_t request_length = acb->nb_sectors * BDRV_SECTOR_SIZE;
|
|
|
|
|
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-07 18:17:55 +02:00
|
|
|
qemu_iovec_from_buf(acb->qiov, 0, s->orig_buf + acb->start,
|
|
|
|
acb->end - acb->start);
|
2016-10-25 04:54:31 +02:00
|
|
|
|
|
|
|
if (acb->end - acb->start < request_length) {
|
|
|
|
size_t offset = acb->end - acb->start;
|
|
|
|
qemu_iovec_memset(acb->qiov, offset, 0,
|
|
|
|
request_length - offset);
|
|
|
|
}
|
|
|
|
|
2009-05-11 17:41:42 +02:00
|
|
|
acb->common.cb(acb->common.opaque, 0);
|
2014-09-11 07:41:28 +02:00
|
|
|
qemu_aio_unref(acb);
|
2009-05-11 17:41:42 +02:00
|
|
|
s->acb[i] = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-25 04:54:29 +02:00
|
|
|
read_end:
|
|
|
|
/* curl will error out if we do not return this value */
|
|
|
|
return size * nmemb;
|
2009-05-11 17:41:42 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int curl_find_buf(BDRVCURLState *s, size_t start, size_t len,
|
|
|
|
CURLAIOCB *acb)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
size_t end = start + len;
|
2016-10-25 04:54:31 +02:00
|
|
|
size_t clamped_end = MIN(end, s->len);
|
|
|
|
size_t clamped_len = clamped_end - start;
|
2009-05-11 17:41:42 +02:00
|
|
|
|
|
|
|
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) &&
|
2016-10-25 04:54:31 +02:00
|
|
|
(clamped_end >= state->buf_start) &&
|
|
|
|
(clamped_end <= buf_end))
|
2009-05-11 17:41:42 +02:00
|
|
|
{
|
|
|
|
char *buf = state->orig_buf + (start - state->buf_start);
|
|
|
|
|
2016-10-25 04:54:31 +02:00
|
|
|
qemu_iovec_from_buf(acb->qiov, 0, buf, clamped_len);
|
|
|
|
if (clamped_len < len) {
|
|
|
|
qemu_iovec_memset(acb->qiov, clamped_len, 0, len - clamped_len);
|
|
|
|
}
|
2009-05-11 17:41:42 +02:00
|
|
|
acb->common.cb(acb->common.opaque, 0);
|
|
|
|
|
|
|
|
return FIND_RET_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Wait for unfinished chunks
|
2014-04-29 17:03:32 +02:00
|
|
|
if (state->in_use &&
|
|
|
|
(start >= state->buf_start) &&
|
2009-05-11 17:41:42 +02:00
|
|
|
(start <= buf_fend) &&
|
2016-10-25 04:54:31 +02:00
|
|
|
(clamped_end >= state->buf_start) &&
|
|
|
|
(clamped_end <= buf_fend))
|
2009-05-11 17:41:42 +02:00
|
|
|
{
|
|
|
|
int j;
|
|
|
|
|
|
|
|
acb->start = start - state->buf_start;
|
2016-10-25 04:54:31 +02:00
|
|
|
acb->end = acb->start + clamped_len;
|
2009-05-11 17:41:42 +02:00
|
|
|
|
|
|
|
for (j=0; j<CURL_NUM_ACB; j++) {
|
|
|
|
if (!state->acb[j]) {
|
|
|
|
state->acb[j] = acb;
|
|
|
|
return FIND_RET_WAIT;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return FIND_RET_NONE;
|
|
|
|
}
|
|
|
|
|
2017-02-22 19:07:23 +01:00
|
|
|
/* Called with s->mutex held. */
|
2014-04-29 17:03:30 +02:00
|
|
|
static void curl_multi_check_completion(BDRVCURLState *s)
|
2009-05-11 17:41:42 +02:00
|
|
|
{
|
|
|
|
int msgs_in_queue;
|
|
|
|
|
|
|
|
/* Try to find done transfers, so we can free the easy
|
|
|
|
* handle again. */
|
2014-04-29 17:03:31 +02:00
|
|
|
for (;;) {
|
2009-05-11 17:41:42 +02:00
|
|
|
CURLMsg *msg;
|
|
|
|
msg = curl_multi_info_read(s->multi, &msgs_in_queue);
|
|
|
|
|
2014-04-29 17:03:31 +02:00
|
|
|
/* Quit when there are no more completions */
|
2009-05-11 17:41:42 +02:00
|
|
|
if (!msg)
|
|
|
|
break;
|
|
|
|
|
2014-04-29 17:03:31 +02:00
|
|
|
if (msg->msg == CURLMSG_DONE) {
|
|
|
|
CURLState *state = NULL;
|
|
|
|
curl_easy_getinfo(msg->easy_handle, CURLINFO_PRIVATE,
|
|
|
|
(char **)&state);
|
|
|
|
|
|
|
|
/* ACBs for successful messages get completed in curl_read_cb */
|
|
|
|
if (msg->data.result != CURLE_OK) {
|
|
|
|
int i;
|
2015-07-08 15:37:48 +02:00
|
|
|
static int errcount = 100;
|
|
|
|
|
|
|
|
/* Don't lose the original error message from curl, since
|
|
|
|
* it contains extra data.
|
|
|
|
*/
|
|
|
|
if (errcount > 0) {
|
|
|
|
error_report("curl: %s", state->errmsg);
|
|
|
|
if (--errcount == 0) {
|
|
|
|
error_report("curl: further errors suppressed");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-29 17:03:31 +02:00
|
|
|
for (i = 0; i < CURL_NUM_ACB; i++) {
|
|
|
|
CURLAIOCB *acb = state->acb[i];
|
|
|
|
|
|
|
|
if (acb == NULL) {
|
|
|
|
continue;
|
2011-08-15 11:00:34 +02:00
|
|
|
}
|
|
|
|
|
2017-02-22 19:07:23 +01:00
|
|
|
qemu_mutex_unlock(&s->mutex);
|
2015-07-08 15:37:48 +02:00
|
|
|
acb->common.cb(acb->common.opaque, -EPROTO);
|
2017-02-22 19:07:23 +01:00
|
|
|
qemu_mutex_lock(&s->mutex);
|
2014-09-11 07:41:28 +02:00
|
|
|
qemu_aio_unref(acb);
|
2014-04-29 17:03:31 +02:00
|
|
|
state->acb[i] = NULL;
|
|
|
|
}
|
2009-05-11 17:41:42 +02:00
|
|
|
}
|
2014-04-29 17:03:31 +02:00
|
|
|
|
|
|
|
curl_clean_state(state);
|
|
|
|
break;
|
2009-05-11 17:41:42 +02:00
|
|
|
}
|
2014-04-29 17:03:31 +02:00
|
|
|
}
|
2009-05-11 17:41:42 +02:00
|
|
|
}
|
|
|
|
|
2017-02-22 19:07:23 +01:00
|
|
|
/* Called with s->mutex held. */
|
2017-02-13 14:52:30 +01:00
|
|
|
static void curl_multi_do_locked(CURLState *s)
|
2014-01-24 14:56:17 +01:00
|
|
|
{
|
2016-10-25 04:54:30 +02:00
|
|
|
CURLSocket *socket, *next_socket;
|
2014-01-24 14:56:17 +01:00
|
|
|
int running;
|
|
|
|
int r;
|
|
|
|
|
2014-04-29 17:03:30 +02:00
|
|
|
if (!s->s->multi) {
|
2014-01-24 14:56:17 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-10-25 04:54:30 +02:00
|
|
|
/* Need to use _SAFE because curl_multi_socket_action() may trigger
|
|
|
|
* curl_sock_cb() which might modify this list */
|
|
|
|
QLIST_FOREACH_SAFE(socket, &s->sockets, next, next_socket) {
|
|
|
|
do {
|
|
|
|
r = curl_multi_socket_action(s->s->multi, socket->fd, 0, &running);
|
|
|
|
} while (r == CURLM_CALL_MULTI_PERFORM);
|
|
|
|
}
|
2014-04-29 17:03:30 +02:00
|
|
|
}
|
|
|
|
|
2017-02-13 14:52:30 +01:00
|
|
|
static void curl_multi_do(void *arg)
|
|
|
|
{
|
|
|
|
CURLState *s = (CURLState *)arg;
|
|
|
|
|
2017-02-22 19:07:23 +01:00
|
|
|
qemu_mutex_lock(&s->s->mutex);
|
2017-02-13 14:52:30 +01:00
|
|
|
curl_multi_do_locked(s);
|
2017-02-22 19:07:23 +01:00
|
|
|
qemu_mutex_unlock(&s->s->mutex);
|
2017-02-13 14:52:30 +01:00
|
|
|
}
|
|
|
|
|
2014-04-29 17:03:30 +02:00
|
|
|
static void curl_multi_read(void *arg)
|
|
|
|
{
|
|
|
|
CURLState *s = (CURLState *)arg;
|
|
|
|
|
2017-02-22 19:07:23 +01:00
|
|
|
qemu_mutex_lock(&s->s->mutex);
|
2017-02-13 14:52:30 +01:00
|
|
|
curl_multi_do_locked(s);
|
2014-04-29 17:03:30 +02:00
|
|
|
curl_multi_check_completion(s->s);
|
2017-02-22 19:07:23 +01:00
|
|
|
qemu_mutex_unlock(&s->s->mutex);
|
2014-01-24 14:56:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void curl_multi_timeout_do(void *arg)
|
|
|
|
{
|
|
|
|
#ifdef NEED_CURL_TIMER_CALLBACK
|
|
|
|
BDRVCURLState *s = (BDRVCURLState *)arg;
|
|
|
|
int running;
|
|
|
|
|
|
|
|
if (!s->multi) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-02-22 19:07:23 +01:00
|
|
|
qemu_mutex_lock(&s->mutex);
|
2014-01-24 14:56:17 +01:00
|
|
|
curl_multi_socket_action(s->multi, CURL_SOCKET_TIMEOUT, 0, &running);
|
|
|
|
|
2014-04-29 17:03:30 +02:00
|
|
|
curl_multi_check_completion(s);
|
2017-02-22 19:07:23 +01:00
|
|
|
qemu_mutex_unlock(&s->mutex);
|
2014-01-24 14:56:17 +01:00
|
|
|
#else
|
|
|
|
abort();
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2014-08-28 10:04:21 +02:00
|
|
|
static CURLState *curl_init_state(BlockDriverState *bs, BDRVCURLState *s)
|
2009-05-11 17:41:42 +02:00
|
|
|
{
|
|
|
|
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) {
|
2014-08-28 10:04:21 +02:00
|
|
|
aio_poll(bdrv_get_aio_context(bs), true);
|
2009-05-11 17:41:42 +02:00
|
|
|
}
|
|
|
|
} while(!state);
|
|
|
|
|
2014-04-29 17:03:26 +02:00
|
|
|
if (!state->curl) {
|
|
|
|
state->curl = curl_easy_init();
|
|
|
|
if (!state->curl) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
curl_easy_setopt(state->curl, CURLOPT_URL, s->url);
|
2014-05-15 01:28:42 +02:00
|
|
|
curl_easy_setopt(state->curl, CURLOPT_SSL_VERIFYPEER,
|
|
|
|
(long) s->sslverify);
|
2014-08-29 17:03:12 +02:00
|
|
|
if (s->cookie) {
|
|
|
|
curl_easy_setopt(state->curl, CURLOPT_COOKIE, s->cookie);
|
|
|
|
}
|
2014-10-26 12:05:27 +01:00
|
|
|
curl_easy_setopt(state->curl, CURLOPT_TIMEOUT, (long)s->timeout);
|
2014-04-29 17:03:26 +02:00
|
|
|
curl_easy_setopt(state->curl, CURLOPT_WRITEFUNCTION,
|
|
|
|
(void *)curl_read_cb);
|
|
|
|
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);
|
|
|
|
curl_easy_setopt(state->curl, CURLOPT_FAILONERROR, 1);
|
|
|
|
|
curl: add support for HTTP authentication parameters
If connecting to a web server which has authentication
turned on, QEMU gets a 401 as curl has not been configured
with any authentication credentials.
This adds 4 new parameters to the curl block driver
options 'username', 'password-secret', 'proxy-username'
and 'proxy-password-secret'. Passwords are provided using
the recently added 'secret' object type
$QEMU \
-object secret,id=sec0,filename=/home/berrange/example.pw \
-object secret,id=sec1,filename=/home/berrange/proxy.pw \
-drive driver=http,url=http://example.com/some.img,\
username=dan,password-secret=sec0,\
proxy-username=dan,proxy-password-secret=sec1
Of course it is possible to use the same secret for both the
proxy & server passwords if desired, or omit the proxy auth
details, or the server auth details as required.
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Message-id: 1453385961-10718-3-git-send-email-berrange@redhat.com
Signed-off-by: Jeff Cody <jcody@redhat.com>
2016-01-21 15:19:20 +01:00
|
|
|
if (s->username) {
|
|
|
|
curl_easy_setopt(state->curl, CURLOPT_USERNAME, s->username);
|
|
|
|
}
|
|
|
|
if (s->password) {
|
|
|
|
curl_easy_setopt(state->curl, CURLOPT_PASSWORD, s->password);
|
|
|
|
}
|
|
|
|
if (s->proxyusername) {
|
|
|
|
curl_easy_setopt(state->curl,
|
|
|
|
CURLOPT_PROXYUSERNAME, s->proxyusername);
|
|
|
|
}
|
|
|
|
if (s->proxypassword) {
|
|
|
|
curl_easy_setopt(state->curl,
|
|
|
|
CURLOPT_PROXYPASSWORD, s->proxypassword);
|
|
|
|
}
|
|
|
|
|
2014-04-29 17:03:26 +02: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.
|
|
|
|
*
|
|
|
|
* Restricting protocols is only supported from 7.19.4 upwards.
|
|
|
|
*/
|
2013-02-13 09:25:34 +01:00
|
|
|
#if LIBCURL_VERSION_NUM >= 0x071304
|
2014-04-29 17:03:26 +02:00
|
|
|
curl_easy_setopt(state->curl, CURLOPT_PROTOCOLS, PROTOCOLS);
|
|
|
|
curl_easy_setopt(state->curl, CURLOPT_REDIR_PROTOCOLS, PROTOCOLS);
|
2013-02-13 09:25:34 +01:00
|
|
|
#endif
|
2013-02-08 08:49:10 +01:00
|
|
|
|
2009-05-11 17:41:42 +02:00
|
|
|
#ifdef DEBUG_VERBOSE
|
2014-04-29 17:03:26 +02:00
|
|
|
curl_easy_setopt(state->curl, CURLOPT_VERBOSE, 1);
|
2009-05-11 17:41:42 +02:00
|
|
|
#endif
|
2014-04-29 17:03:26 +02:00
|
|
|
}
|
2009-05-11 17:41:42 +02:00
|
|
|
|
2016-10-25 04:54:30 +02:00
|
|
|
QLIST_INIT(&state->sockets);
|
2009-05-11 17:41:42 +02:00
|
|
|
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);
|
2016-10-25 04:54:30 +02:00
|
|
|
|
|
|
|
while (!QLIST_EMPTY(&s->sockets)) {
|
|
|
|
CURLSocket *socket = QLIST_FIRST(&s->sockets);
|
|
|
|
|
|
|
|
QLIST_REMOVE(socket, next);
|
|
|
|
g_free(socket);
|
|
|
|
}
|
|
|
|
|
2009-05-11 17:41:42 +02:00
|
|
|
s->in_use = 0;
|
|
|
|
}
|
|
|
|
|
2013-04-10 15:31:33 +02:00
|
|
|
static void curl_parse_filename(const char *filename, QDict *options,
|
|
|
|
Error **errp)
|
2009-05-11 17:41:42 +02:00
|
|
|
{
|
2014-05-15 01:28:41 +02:00
|
|
|
qdict_put(options, CURL_BLOCK_OPT_URL, qstring_from_str(filename));
|
2013-04-10 15:31:33 +02:00
|
|
|
}
|
|
|
|
|
2014-05-08 16:34:40 +02:00
|
|
|
static void curl_detach_aio_context(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
BDRVCURLState *s = bs->opaque;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
2014-06-06 18:25:12 +02:00
|
|
|
g_free(s->states[i].orig_buf);
|
|
|
|
s->states[i].orig_buf = NULL;
|
2014-05-08 16:34:40 +02:00
|
|
|
}
|
|
|
|
if (s->multi) {
|
|
|
|
curl_multi_cleanup(s->multi);
|
|
|
|
s->multi = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
timer_del(&s->timer);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void curl_attach_aio_context(BlockDriverState *bs,
|
|
|
|
AioContext *new_context)
|
|
|
|
{
|
|
|
|
BDRVCURLState *s = bs->opaque;
|
|
|
|
|
|
|
|
aio_timer_init(new_context, &s->timer,
|
|
|
|
QEMU_CLOCK_REALTIME, SCALE_NS,
|
|
|
|
curl_multi_timeout_do, s);
|
|
|
|
|
|
|
|
assert(!s->multi);
|
|
|
|
s->multi = curl_multi_init();
|
|
|
|
s->aio_context = new_context;
|
|
|
|
curl_multi_setopt(s->multi, CURLMOPT_SOCKETFUNCTION, curl_sock_cb);
|
|
|
|
#ifdef NEED_CURL_TIMER_CALLBACK
|
|
|
|
curl_multi_setopt(s->multi, CURLMOPT_TIMERDATA, s);
|
|
|
|
curl_multi_setopt(s->multi, CURLMOPT_TIMERFUNCTION, curl_timer_cb);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2013-04-10 15:31:33 +02:00
|
|
|
static QemuOptsList runtime_opts = {
|
|
|
|
.name = "curl",
|
|
|
|
.head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
|
|
|
|
.desc = {
|
|
|
|
{
|
2014-05-15 01:28:41 +02:00
|
|
|
.name = CURL_BLOCK_OPT_URL,
|
2013-04-10 15:31:33 +02:00
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
.help = "URL to open",
|
|
|
|
},
|
|
|
|
{
|
2014-05-15 01:28:41 +02:00
|
|
|
.name = CURL_BLOCK_OPT_READAHEAD,
|
2013-04-10 15:31:33 +02:00
|
|
|
.type = QEMU_OPT_SIZE,
|
|
|
|
.help = "Readahead size",
|
|
|
|
},
|
2014-05-15 01:28:42 +02:00
|
|
|
{
|
|
|
|
.name = CURL_BLOCK_OPT_SSLVERIFY,
|
|
|
|
.type = QEMU_OPT_BOOL,
|
|
|
|
.help = "Verify SSL certificate"
|
|
|
|
},
|
2014-08-13 17:44:27 +02:00
|
|
|
{
|
|
|
|
.name = CURL_BLOCK_OPT_TIMEOUT,
|
|
|
|
.type = QEMU_OPT_NUMBER,
|
|
|
|
.help = "Curl timeout"
|
|
|
|
},
|
2014-08-29 17:03:12 +02:00
|
|
|
{
|
|
|
|
.name = CURL_BLOCK_OPT_COOKIE,
|
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
.help = "Pass the cookie or list of cookies with each request"
|
|
|
|
},
|
curl: add support for HTTP authentication parameters
If connecting to a web server which has authentication
turned on, QEMU gets a 401 as curl has not been configured
with any authentication credentials.
This adds 4 new parameters to the curl block driver
options 'username', 'password-secret', 'proxy-username'
and 'proxy-password-secret'. Passwords are provided using
the recently added 'secret' object type
$QEMU \
-object secret,id=sec0,filename=/home/berrange/example.pw \
-object secret,id=sec1,filename=/home/berrange/proxy.pw \
-drive driver=http,url=http://example.com/some.img,\
username=dan,password-secret=sec0,\
proxy-username=dan,proxy-password-secret=sec1
Of course it is possible to use the same secret for both the
proxy & server passwords if desired, or omit the proxy auth
details, or the server auth details as required.
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Message-id: 1453385961-10718-3-git-send-email-berrange@redhat.com
Signed-off-by: Jeff Cody <jcody@redhat.com>
2016-01-21 15:19:20 +01:00
|
|
|
{
|
|
|
|
.name = CURL_BLOCK_OPT_USERNAME,
|
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
.help = "Username for HTTP auth"
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = CURL_BLOCK_OPT_PASSWORD_SECRET,
|
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
.help = "ID of secret used as password for HTTP auth",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = CURL_BLOCK_OPT_PROXY_USERNAME,
|
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
.help = "Username for HTTP proxy auth"
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = CURL_BLOCK_OPT_PROXY_PASSWORD_SECRET,
|
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
.help = "ID of secret used as password for HTTP proxy auth",
|
|
|
|
},
|
2013-04-10 15:31:33 +02:00
|
|
|
{ /* end of list */ }
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
curl: add support for HTTP authentication parameters
If connecting to a web server which has authentication
turned on, QEMU gets a 401 as curl has not been configured
with any authentication credentials.
This adds 4 new parameters to the curl block driver
options 'username', 'password-secret', 'proxy-username'
and 'proxy-password-secret'. Passwords are provided using
the recently added 'secret' object type
$QEMU \
-object secret,id=sec0,filename=/home/berrange/example.pw \
-object secret,id=sec1,filename=/home/berrange/proxy.pw \
-drive driver=http,url=http://example.com/some.img,\
username=dan,password-secret=sec0,\
proxy-username=dan,proxy-password-secret=sec1
Of course it is possible to use the same secret for both the
proxy & server passwords if desired, or omit the proxy auth
details, or the server auth details as required.
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Message-id: 1453385961-10718-3-git-send-email-berrange@redhat.com
Signed-off-by: Jeff Cody <jcody@redhat.com>
2016-01-21 15:19:20 +01:00
|
|
|
|
2013-09-05 14:22:29 +02:00
|
|
|
static int curl_open(BlockDriverState *bs, QDict *options, int flags,
|
|
|
|
Error **errp)
|
2013-04-10 15:31:33 +02:00
|
|
|
{
|
|
|
|
BDRVCURLState *s = bs->opaque;
|
|
|
|
CURLState *state = NULL;
|
|
|
|
QemuOpts *opts;
|
|
|
|
Error *local_err = NULL;
|
|
|
|
const char *file;
|
2014-08-29 17:03:12 +02:00
|
|
|
const char *cookie;
|
2013-04-10 15:31:33 +02:00
|
|
|
double d;
|
curl: add support for HTTP authentication parameters
If connecting to a web server which has authentication
turned on, QEMU gets a 401 as curl has not been configured
with any authentication credentials.
This adds 4 new parameters to the curl block driver
options 'username', 'password-secret', 'proxy-username'
and 'proxy-password-secret'. Passwords are provided using
the recently added 'secret' object type
$QEMU \
-object secret,id=sec0,filename=/home/berrange/example.pw \
-object secret,id=sec1,filename=/home/berrange/proxy.pw \
-drive driver=http,url=http://example.com/some.img,\
username=dan,password-secret=sec0,\
proxy-username=dan,proxy-password-secret=sec1
Of course it is possible to use the same secret for both the
proxy & server passwords if desired, or omit the proxy auth
details, or the server auth details as required.
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Message-id: 1453385961-10718-3-git-send-email-berrange@redhat.com
Signed-off-by: Jeff Cody <jcody@redhat.com>
2016-01-21 15:19:20 +01:00
|
|
|
const char *secretid;
|
2013-04-10 15:31:33 +02:00
|
|
|
|
|
|
|
static int inited = 0;
|
|
|
|
|
2013-06-10 13:38:43 +02:00
|
|
|
if (flags & BDRV_O_RDWR) {
|
2014-02-17 14:43:57 +01:00
|
|
|
error_setg(errp, "curl block device does not support writes");
|
2013-06-10 13:38:43 +02:00
|
|
|
return -EROFS;
|
|
|
|
}
|
|
|
|
|
2014-01-02 03:49:17 +01:00
|
|
|
opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
|
2013-04-10 15:31:33 +02:00
|
|
|
qemu_opts_absorb_qdict(opts, options, &local_err);
|
2014-01-30 15:07:28 +01:00
|
|
|
if (local_err) {
|
2014-02-17 14:43:57 +01:00
|
|
|
error_propagate(errp, local_err);
|
2013-04-10 15:31:33 +02:00
|
|
|
goto out_noclean;
|
|
|
|
}
|
|
|
|
|
2014-05-15 01:28:41 +02:00
|
|
|
s->readahead_size = qemu_opt_get_size(opts, CURL_BLOCK_OPT_READAHEAD,
|
|
|
|
READ_AHEAD_DEFAULT);
|
2009-07-02 02:16:52 +02:00
|
|
|
if ((s->readahead_size & 0x1ff) != 0) {
|
2014-02-17 14:43:57 +01:00
|
|
|
error_setg(errp, "HTTP_READAHEAD_SIZE %zd is not a multiple of 512",
|
|
|
|
s->readahead_size);
|
2009-07-02 02:16:52 +02:00
|
|
|
goto out_noclean;
|
|
|
|
}
|
|
|
|
|
2014-08-13 17:44:27 +02:00
|
|
|
s->timeout = qemu_opt_get_number(opts, CURL_BLOCK_OPT_TIMEOUT,
|
|
|
|
CURL_TIMEOUT_DEFAULT);
|
2014-10-26 12:05:27 +01:00
|
|
|
if (s->timeout > CURL_TIMEOUT_MAX) {
|
|
|
|
error_setg(errp, "timeout parameter is too large or negative");
|
|
|
|
goto out_noclean;
|
|
|
|
}
|
2014-08-13 17:44:27 +02:00
|
|
|
|
2014-05-15 01:28:42 +02:00
|
|
|
s->sslverify = qemu_opt_get_bool(opts, CURL_BLOCK_OPT_SSLVERIFY, true);
|
|
|
|
|
2014-08-29 17:03:12 +02:00
|
|
|
cookie = qemu_opt_get(opts, CURL_BLOCK_OPT_COOKIE);
|
|
|
|
s->cookie = g_strdup(cookie);
|
|
|
|
|
2014-05-15 01:28:41 +02:00
|
|
|
file = qemu_opt_get(opts, CURL_BLOCK_OPT_URL);
|
2013-04-10 15:31:33 +02:00
|
|
|
if (file == NULL) {
|
2014-02-17 14:43:57 +01:00
|
|
|
error_setg(errp, "curl block driver requires an 'url' option");
|
2013-04-10 15:31:33 +02:00
|
|
|
goto out_noclean;
|
|
|
|
}
|
|
|
|
|
curl: add support for HTTP authentication parameters
If connecting to a web server which has authentication
turned on, QEMU gets a 401 as curl has not been configured
with any authentication credentials.
This adds 4 new parameters to the curl block driver
options 'username', 'password-secret', 'proxy-username'
and 'proxy-password-secret'. Passwords are provided using
the recently added 'secret' object type
$QEMU \
-object secret,id=sec0,filename=/home/berrange/example.pw \
-object secret,id=sec1,filename=/home/berrange/proxy.pw \
-drive driver=http,url=http://example.com/some.img,\
username=dan,password-secret=sec0,\
proxy-username=dan,proxy-password-secret=sec1
Of course it is possible to use the same secret for both the
proxy & server passwords if desired, or omit the proxy auth
details, or the server auth details as required.
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Message-id: 1453385961-10718-3-git-send-email-berrange@redhat.com
Signed-off-by: Jeff Cody <jcody@redhat.com>
2016-01-21 15:19:20 +01:00
|
|
|
s->username = g_strdup(qemu_opt_get(opts, CURL_BLOCK_OPT_USERNAME));
|
|
|
|
secretid = qemu_opt_get(opts, CURL_BLOCK_OPT_PASSWORD_SECRET);
|
|
|
|
|
|
|
|
if (secretid) {
|
|
|
|
s->password = qcrypto_secret_lookup_as_utf8(secretid, errp);
|
|
|
|
if (!s->password) {
|
|
|
|
goto out_noclean;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
s->proxyusername = g_strdup(
|
|
|
|
qemu_opt_get(opts, CURL_BLOCK_OPT_PROXY_USERNAME));
|
|
|
|
secretid = qemu_opt_get(opts, CURL_BLOCK_OPT_PROXY_PASSWORD_SECRET);
|
|
|
|
if (secretid) {
|
|
|
|
s->proxypassword = qcrypto_secret_lookup_as_utf8(secretid, errp);
|
|
|
|
if (!s->proxypassword) {
|
|
|
|
goto out_noclean;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-05-11 17:41:42 +02:00
|
|
|
if (!inited) {
|
|
|
|
curl_global_init(CURL_GLOBAL_ALL);
|
|
|
|
inited = 1;
|
|
|
|
}
|
|
|
|
|
2010-02-07 00:03:50 +01:00
|
|
|
DPRINTF("CURL: Opening %s\n", file);
|
2014-05-08 16:34:40 +02:00
|
|
|
s->aio_context = bdrv_get_aio_context(bs);
|
2013-04-10 15:31:33 +02:00
|
|
|
s->url = g_strdup(file);
|
2014-08-28 10:04:21 +02:00
|
|
|
state = curl_init_state(bs, s);
|
2009-05-11 17:41:42 +02:00
|
|
|
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 09:19:21 +02:00
|
|
|
s->accept_range = false;
|
2009-05-11 17:41:42 +02: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 09:19:21 +02:00
|
|
|
curl_easy_setopt(state->curl, CURLOPT_HEADERFUNCTION,
|
|
|
|
curl_header_cb);
|
|
|
|
curl_easy_setopt(state->curl, CURLOPT_HEADERDATA, s);
|
2009-05-11 17:41:42 +02:00
|
|
|
if (curl_easy_perform(state->curl))
|
|
|
|
goto out;
|
2016-07-08 13:18:09 +02:00
|
|
|
if (curl_easy_getinfo(state->curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &d)) {
|
2009-05-11 17:41:42 +02:00
|
|
|
goto out;
|
2016-07-08 13:18:09 +02:00
|
|
|
}
|
|
|
|
/* Prior CURL 7.19.4 return value of 0 could mean that the file size is not
|
|
|
|
* know or the size is zero. From 7.19.4 CURL returns -1 if size is not
|
|
|
|
* known and zero if it is realy zero-length file. */
|
|
|
|
#if LIBCURL_VERSION_NUM >= 0x071304
|
|
|
|
if (d < 0) {
|
|
|
|
pstrcpy(state->errmsg, CURL_ERROR_SIZE,
|
|
|
|
"Server didn't report file size.");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
if (d <= 0) {
|
|
|
|
pstrcpy(state->errmsg, CURL_ERROR_SIZE,
|
|
|
|
"Unknown file size or zero-length file.");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
s->len = (size_t)d;
|
|
|
|
|
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 09:19:21 +02: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 10:02:12 +02:00
|
|
|
DPRINTF("CURL: Size = %zd\n", s->len);
|
2009-05-11 17:41:42 +02:00
|
|
|
|
|
|
|
curl_clean_state(state);
|
|
|
|
curl_easy_cleanup(state->curl);
|
|
|
|
state->curl = NULL;
|
|
|
|
|
2017-02-22 19:07:23 +01:00
|
|
|
qemu_mutex_init(&s->mutex);
|
2014-05-08 16:34:40 +02:00
|
|
|
curl_attach_aio_context(bs, bdrv_get_aio_context(bs));
|
2009-05-11 17:41:42 +02:00
|
|
|
|
2013-04-10 15:31:33 +02:00
|
|
|
qemu_opts_del(opts);
|
2009-05-11 17:41:42 +02:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
out:
|
2014-03-18 06:59:18 +01:00
|
|
|
error_setg(errp, "CURL: Error opening file: %s", state->errmsg);
|
2009-05-11 17:41:42 +02:00
|
|
|
curl_easy_cleanup(state->curl);
|
|
|
|
state->curl = NULL;
|
|
|
|
out_noclean:
|
2014-08-29 17:03:12 +02:00
|
|
|
g_free(s->cookie);
|
2013-04-10 15:31:33 +02:00
|
|
|
g_free(s->url);
|
|
|
|
qemu_opts_del(opts);
|
2009-05-11 17:41:42 +02:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2012-10-31 16:34:37 +01:00
|
|
|
static const AIOCBInfo curl_aiocb_info = {
|
2009-05-25 12:37:32 +02:00
|
|
|
.aiocb_size = sizeof(CURLAIOCB),
|
|
|
|
};
|
|
|
|
|
2011-09-21 12:55:50 +02:00
|
|
|
|
|
|
|
static void curl_readv_bh_cb(void *p)
|
2009-05-11 17:41:42 +02:00
|
|
|
{
|
|
|
|
CURLState *state;
|
2014-04-29 17:03:29 +02:00
|
|
|
int running;
|
2017-02-13 14:52:31 +01:00
|
|
|
int ret = -EINPROGRESS;
|
2009-05-11 17:41:42 +02:00
|
|
|
|
2011-09-21 12:55:50 +02:00
|
|
|
CURLAIOCB *acb = p;
|
2017-02-13 14:52:31 +01:00
|
|
|
BlockDriverState *bs = acb->common.bs;
|
|
|
|
BDRVCURLState *s = bs->opaque;
|
2009-05-11 17:41:42 +02:00
|
|
|
|
2016-10-25 04:54:28 +02:00
|
|
|
size_t start = acb->sector_num * BDRV_SECTOR_SIZE;
|
2011-09-21 12:55:50 +02:00
|
|
|
size_t end;
|
2009-05-11 17:41:42 +02:00
|
|
|
|
2017-02-22 19:07:23 +01:00
|
|
|
qemu_mutex_lock(&s->mutex);
|
2017-02-13 14:52:31 +01:00
|
|
|
|
2009-05-11 17:41:42 +02:00
|
|
|
// In case we have the requested data already (e.g. read-ahead),
|
|
|
|
// we can just call the callback and be done.
|
2016-10-25 04:54:28 +02:00
|
|
|
switch (curl_find_buf(s, start, acb->nb_sectors * BDRV_SECTOR_SIZE, acb)) {
|
2009-05-11 17:41:42 +02:00
|
|
|
case FIND_RET_OK:
|
2014-09-11 07:41:28 +02:00
|
|
|
qemu_aio_unref(acb);
|
2009-05-11 17:41:42 +02:00
|
|
|
// fall through
|
|
|
|
case FIND_RET_WAIT:
|
2017-02-13 14:52:31 +01:00
|
|
|
goto out;
|
2009-05-11 17:41:42 +02:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// No cache found, so let's start a new request
|
2014-08-28 10:04:21 +02:00
|
|
|
state = curl_init_state(acb->common.bs, s);
|
2011-09-21 12:55:50 +02:00
|
|
|
if (!state) {
|
2017-02-13 14:52:31 +01:00
|
|
|
ret = -EIO;
|
|
|
|
goto out;
|
2011-09-21 12:55:50 +02:00
|
|
|
}
|
2009-05-11 17:41:42 +02:00
|
|
|
|
|
|
|
acb->start = 0;
|
2016-10-25 04:54:31 +02:00
|
|
|
acb->end = MIN(acb->nb_sectors * BDRV_SECTOR_SIZE, s->len - start);
|
2009-05-11 17:41:42 +02:00
|
|
|
|
|
|
|
state->buf_off = 0;
|
2014-06-06 18:25:12 +02:00
|
|
|
g_free(state->orig_buf);
|
2009-05-11 17:41:42 +02:00
|
|
|
state->buf_start = start;
|
2016-10-25 04:54:31 +02:00
|
|
|
state->buf_len = MIN(acb->end + s->readahead_size, s->len - start);
|
|
|
|
end = start + state->buf_len - 1;
|
2014-05-20 13:26:40 +02:00
|
|
|
state->orig_buf = g_try_malloc(state->buf_len);
|
|
|
|
if (state->buf_len && state->orig_buf == NULL) {
|
|
|
|
curl_clean_state(state);
|
2017-02-13 14:52:31 +01:00
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
2014-05-20 13:26:40 +02:00
|
|
|
}
|
2009-05-11 17:41:42 +02:00
|
|
|
state->acb[0] = acb;
|
|
|
|
|
2010-05-22 10:02:12 +02:00
|
|
|
snprintf(state->range, 127, "%zd-%zd", start, end);
|
2016-10-25 04:54:28 +02:00
|
|
|
DPRINTF("CURL (AIO): Reading %llu at %zd (%s)\n",
|
|
|
|
(acb->nb_sectors * BDRV_SECTOR_SIZE), start, state->range);
|
2009-05-11 17:41:42 +02:00
|
|
|
curl_easy_setopt(state->curl, CURLOPT_RANGE, state->range);
|
|
|
|
|
|
|
|
curl_multi_add_handle(s->multi, state->curl);
|
|
|
|
|
2014-04-29 17:03:29 +02:00
|
|
|
/* Tell curl it needs to kick things off */
|
|
|
|
curl_multi_socket_action(s->multi, CURL_SOCKET_TIMEOUT, 0, &running);
|
2017-02-13 14:52:31 +01:00
|
|
|
|
|
|
|
out:
|
2017-02-22 19:07:23 +01:00
|
|
|
qemu_mutex_unlock(&s->mutex);
|
2017-02-13 14:52:31 +01:00
|
|
|
if (ret != -EINPROGRESS) {
|
|
|
|
acb->common.cb(acb->common.opaque, ret);
|
|
|
|
qemu_aio_unref(acb);
|
|
|
|
}
|
2011-09-21 12:55:50 +02:00
|
|
|
}
|
|
|
|
|
2014-10-07 13:59:14 +02:00
|
|
|
static BlockAIOCB *curl_aio_readv(BlockDriverState *bs,
|
2011-09-21 12:55:50 +02:00
|
|
|
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
|
2014-10-07 13:59:15 +02:00
|
|
|
BlockCompletionFunc *cb, void *opaque)
|
2011-09-21 12:55:50 +02:00
|
|
|
{
|
|
|
|
CURLAIOCB *acb;
|
|
|
|
|
2012-10-31 16:34:37 +01:00
|
|
|
acb = qemu_aio_get(&curl_aiocb_info, bs, cb, opaque);
|
2011-09-21 12:55:50 +02:00
|
|
|
|
|
|
|
acb->qiov = qiov;
|
|
|
|
acb->sector_num = sector_num;
|
|
|
|
acb->nb_sectors = nb_sectors;
|
|
|
|
|
2016-10-03 18:14:16 +02:00
|
|
|
aio_bh_schedule_oneshot(bdrv_get_aio_context(bs), curl_readv_bh_cb, acb);
|
2009-05-11 17:41:42 +02:00
|
|
|
return &acb->common;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void curl_close(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
BDRVCURLState *s = bs->opaque;
|
|
|
|
|
2010-02-07 00:03:50 +01:00
|
|
|
DPRINTF("CURL: Close\n");
|
2014-05-08 16:34:40 +02:00
|
|
|
curl_detach_aio_context(bs);
|
2017-02-22 19:07:23 +01:00
|
|
|
qemu_mutex_destroy(&s->mutex);
|
2014-01-24 14:56:17 +01:00
|
|
|
|
2014-08-29 17:03:12 +02:00
|
|
|
g_free(s->cookie);
|
2012-09-01 11:06:45 +02:00
|
|
|
g_free(s->url);
|
2009-05-11 17:41:42 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int64_t curl_getlength(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
BDRVCURLState *s = bs->opaque;
|
|
|
|
return s->len;
|
|
|
|
}
|
|
|
|
|
|
|
|
static BlockDriver bdrv_http = {
|
2014-05-08 16:34:40 +02:00
|
|
|
.format_name = "http",
|
|
|
|
.protocol_name = "http",
|
|
|
|
|
|
|
|
.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 17:41:42 +02:00
|
|
|
|
2014-05-08 16:34:40 +02:00
|
|
|
.bdrv_aio_readv = curl_aio_readv,
|
2009-05-11 17:41:42 +02:00
|
|
|
|
2014-05-08 16:34:40 +02:00
|
|
|
.bdrv_detach_aio_context = curl_detach_aio_context,
|
|
|
|
.bdrv_attach_aio_context = curl_attach_aio_context,
|
2009-05-11 17:41:42 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
static BlockDriver bdrv_https = {
|
2014-05-08 16:34:40 +02:00
|
|
|
.format_name = "https",
|
|
|
|
.protocol_name = "https",
|
2009-05-11 17:41:42 +02:00
|
|
|
|
2014-05-08 16:34:40 +02: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 17:41:42 +02:00
|
|
|
|
2014-05-08 16:34:40 +02:00
|
|
|
.bdrv_aio_readv = curl_aio_readv,
|
|
|
|
|
|
|
|
.bdrv_detach_aio_context = curl_detach_aio_context,
|
|
|
|
.bdrv_attach_aio_context = curl_attach_aio_context,
|
2009-05-11 17:41:42 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
static BlockDriver bdrv_ftp = {
|
2014-05-08 16:34:40 +02:00
|
|
|
.format_name = "ftp",
|
|
|
|
.protocol_name = "ftp",
|
|
|
|
|
|
|
|
.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 17:41:42 +02:00
|
|
|
|
2014-05-08 16:34:40 +02:00
|
|
|
.bdrv_aio_readv = curl_aio_readv,
|
2009-05-11 17:41:42 +02:00
|
|
|
|
2014-05-08 16:34:40 +02:00
|
|
|
.bdrv_detach_aio_context = curl_detach_aio_context,
|
|
|
|
.bdrv_attach_aio_context = curl_attach_aio_context,
|
2009-05-11 17:41:42 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
static BlockDriver bdrv_ftps = {
|
2014-05-08 16:34:40 +02:00
|
|
|
.format_name = "ftps",
|
|
|
|
.protocol_name = "ftps",
|
2009-05-11 17:41:42 +02:00
|
|
|
|
2014-05-08 16:34:40 +02: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 17:41:42 +02:00
|
|
|
|
2014-05-08 16:34:40 +02:00
|
|
|
.bdrv_aio_readv = curl_aio_readv,
|
|
|
|
|
|
|
|
.bdrv_detach_aio_context = curl_detach_aio_context,
|
|
|
|
.bdrv_attach_aio_context = curl_attach_aio_context,
|
2009-05-11 17:41:42 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
static void curl_block_init(void)
|
|
|
|
{
|
|
|
|
bdrv_register(&bdrv_http);
|
|
|
|
bdrv_register(&bdrv_https);
|
|
|
|
bdrv_register(&bdrv_ftp);
|
|
|
|
bdrv_register(&bdrv_ftps);
|
|
|
|
}
|
|
|
|
|
|
|
|
block_init(curl_block_init);
|