2009-05-11 15:41:42 +00: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.
|
|
|
|
*/
|
2018-02-01 11:18:39 +00:00
|
|
|
|
2016-01-18 18:01:42 +00: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 08:01:28 +00:00
|
|
|
#include "qapi/error.h"
|
2015-07-08 13:37:48 +00:00
|
|
|
#include "qemu/error-report.h"
|
2019-05-23 14:35:07 +00:00
|
|
|
#include "qemu/module.h"
|
2018-02-01 11:18:46 +00:00
|
|
|
#include "qemu/option.h"
|
2012-12-17 17:19:44 +00:00
|
|
|
#include "block/block_int.h"
|
2018-02-01 11:18:39 +00:00
|
|
|
#include "qapi/qmp/qdict.h"
|
2015-03-17 17:29:20 +00: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 14:19:20 +00:00
|
|
|
#include "crypto/secret.h"
|
2009-05-11 15:41:42 +00:00
|
|
|
#include <curl/curl.h>
|
2016-03-20 17:16:19 +00:00
|
|
|
#include "qemu/cutils.h"
|
2018-12-13 16:27:25 +00:00
|
|
|
#include "trace.h"
|
2009-05-11 15:41:42 +00:00
|
|
|
|
|
|
|
// #define DEBUG_VERBOSE
|
|
|
|
|
2014-01-24 13:56:17 +00:00
|
|
|
#if LIBCURL_VERSION_NUM >= 0x071000
|
|
|
|
/* The multi interface timer callback was introduced in 7.16.0 */
|
|
|
|
#define NEED_CURL_TIMER_CALLBACK
|
2014-05-14 23:28:40 +00: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 13:56:17 +00:00
|
|
|
#endif
|
|
|
|
|
2013-02-08 07:49:10 +00: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 17:55:37 +00:00
|
|
|
CURLPROTO_FTP | CURLPROTO_FTPS)
|
2013-02-08 07:49:10 +00:00
|
|
|
|
2009-05-11 15:41:42 +00:00
|
|
|
#define CURL_NUM_STATES 8
|
|
|
|
#define CURL_NUM_ACB 8
|
2014-10-26 11:05:27 +00:00
|
|
|
#define CURL_TIMEOUT_MAX 10000
|
2009-05-11 15:41:42 +00:00
|
|
|
|
2014-05-14 23:28:41 +00:00
|
|
|
#define CURL_BLOCK_OPT_URL "url"
|
|
|
|
#define CURL_BLOCK_OPT_READAHEAD "readahead"
|
2014-05-14 23:28:42 +00:00
|
|
|
#define CURL_BLOCK_OPT_SSLVERIFY "sslverify"
|
2014-08-13 15:44:27 +00:00
|
|
|
#define CURL_BLOCK_OPT_TIMEOUT "timeout"
|
2014-08-29 15:03:12 +00:00
|
|
|
#define CURL_BLOCK_OPT_COOKIE "cookie"
|
2017-05-04 14:00:06 +00:00
|
|
|
#define CURL_BLOCK_OPT_COOKIE_SECRET "cookie-secret"
|
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 14:19:20 +00: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-14 23:28:41 +00:00
|
|
|
|
2019-02-01 19:29:31 +00:00
|
|
|
#define CURL_BLOCK_OPT_READAHEAD_DEFAULT (256 * 1024)
|
|
|
|
#define CURL_BLOCK_OPT_SSLVERIFY_DEFAULT true
|
|
|
|
#define CURL_BLOCK_OPT_TIMEOUT_DEFAULT 5
|
|
|
|
|
2009-05-11 15:41:42 +00:00
|
|
|
struct BDRVCURLState;
|
2019-09-10 12:41:30 +00:00
|
|
|
struct CURLState;
|
2009-05-11 15:41:42 +00:00
|
|
|
|
2017-11-07 22:27:22 +00:00
|
|
|
static bool libcurl_initialized;
|
|
|
|
|
2009-05-11 15:41:42 +00:00
|
|
|
typedef struct CURLAIOCB {
|
2017-05-15 10:00:58 +00:00
|
|
|
Coroutine *co;
|
2009-05-11 15:41:42 +00:00
|
|
|
QEMUIOVector *qiov;
|
2011-09-21 10:55:50 +00:00
|
|
|
|
2017-05-15 10:00:57 +00:00
|
|
|
uint64_t offset;
|
|
|
|
uint64_t bytes;
|
2017-05-15 10:00:58 +00:00
|
|
|
int ret;
|
2011-09-21 10:55:50 +00:00
|
|
|
|
2009-05-11 15:41:42 +00:00
|
|
|
size_t start;
|
|
|
|
size_t end;
|
|
|
|
} CURLAIOCB;
|
|
|
|
|
2016-10-25 02:54:30 +00:00
|
|
|
typedef struct CURLSocket {
|
|
|
|
int fd;
|
2019-09-10 12:41:30 +00:00
|
|
|
struct CURLState *state;
|
2016-10-25 02:54:30 +00:00
|
|
|
QLIST_ENTRY(CURLSocket) next;
|
|
|
|
} CURLSocket;
|
|
|
|
|
2009-05-11 15:41:42 +00:00
|
|
|
typedef struct CURLState
|
|
|
|
{
|
|
|
|
struct BDRVCURLState *s;
|
|
|
|
CURLAIOCB *acb[CURL_NUM_ACB];
|
|
|
|
CURL *curl;
|
2016-10-25 02:54:30 +00:00
|
|
|
QLIST_HEAD(, CURLSocket) sockets;
|
2009-05-11 15:41:42 +00:00
|
|
|
char *orig_buf;
|
2017-05-15 10:00:57 +00:00
|
|
|
uint64_t buf_start;
|
2009-05-11 15:41:42 +00:00
|
|
|
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 13:56:17 +00:00
|
|
|
QEMUTimer timer;
|
2017-05-15 10:00:57 +00:00
|
|
|
uint64_t len;
|
2009-05-11 15:41:42 +00:00
|
|
|
CURLState states[CURL_NUM_STATES];
|
|
|
|
char *url;
|
2009-07-02 00:16:52 +00:00
|
|
|
size_t readahead_size;
|
2014-05-14 23:28:42 +00:00
|
|
|
bool sslverify;
|
2014-10-26 11:05:27 +00:00
|
|
|
uint64_t timeout;
|
2014-08-29 15:03:12 +00: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 07:19:21 +00:00
|
|
|
bool accept_range;
|
2014-05-08 14:34:40 +00:00
|
|
|
AioContext *aio_context;
|
2017-02-22 18:07:23 +00:00
|
|
|
QemuMutex mutex;
|
2018-02-03 15:39:35 +00:00
|
|
|
CoQueue free_state_waitq;
|
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 14:19:20 +00:00
|
|
|
char *username;
|
|
|
|
char *password;
|
|
|
|
char *proxyusername;
|
|
|
|
char *proxypassword;
|
2009-05-11 15:41:42 +00:00
|
|
|
} BDRVCURLState;
|
|
|
|
|
|
|
|
static void curl_clean_state(CURLState *s);
|
|
|
|
static void curl_multi_do(void *arg);
|
|
|
|
|
2014-01-24 13:56:17 +00:00
|
|
|
#ifdef NEED_CURL_TIMER_CALLBACK
|
2017-05-15 10:00:54 +00:00
|
|
|
/* Called from curl_multi_do_locked, with s->mutex held. */
|
2014-01-24 13:56:17 +00:00
|
|
|
static int curl_timer_cb(CURLM *multi, long timeout_ms, void *opaque)
|
|
|
|
{
|
|
|
|
BDRVCURLState *s = opaque;
|
|
|
|
|
2018-12-13 16:27:25 +00:00
|
|
|
trace_curl_timer_cb(timeout_ms);
|
2014-01-24 13:56:17 +00:00
|
|
|
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
|
|
|
|
|
2017-05-15 10:00:54 +00:00
|
|
|
/* Called from curl_multi_do_locked, with s->mutex held. */
|
2009-05-11 15:41:42 +00:00
|
|
|
static int curl_sock_cb(CURL *curl, curl_socket_t fd, int action,
|
2014-05-08 14:34:40 +00:00
|
|
|
void *userp, void *sp)
|
2009-05-11 15:41:42 +00:00
|
|
|
{
|
2014-05-08 14:34:40 +00:00
|
|
|
BDRVCURLState *s;
|
2014-04-29 15:03:30 +00:00
|
|
|
CURLState *state = NULL;
|
2016-10-25 02:54:30 +00:00
|
|
|
CURLSocket *socket;
|
|
|
|
|
2014-04-29 15:03:30 +00:00
|
|
|
curl_easy_getinfo(curl, CURLINFO_PRIVATE, (char **)&state);
|
2014-05-08 14:34:40 +00:00
|
|
|
s = state->s;
|
2014-04-29 15:03:30 +00:00
|
|
|
|
2016-10-25 02:54:30 +00:00
|
|
|
QLIST_FOREACH(socket, &state->sockets, next) {
|
|
|
|
if (socket->fd == fd) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!socket) {
|
|
|
|
socket = g_new0(CURLSocket, 1);
|
|
|
|
socket->fd = fd;
|
2019-09-10 12:41:30 +00:00
|
|
|
socket->state = state;
|
2016-10-25 02:54:30 +00:00
|
|
|
QLIST_INSERT_HEAD(&state->sockets, socket, next);
|
|
|
|
}
|
|
|
|
|
2018-12-13 16:27:25 +00:00
|
|
|
trace_curl_sock_cb(action, (int)fd);
|
2009-05-11 15:41:42 +00:00
|
|
|
switch (action) {
|
|
|
|
case CURL_POLL_IN:
|
2015-10-23 03:08:05 +00:00
|
|
|
aio_set_fd_handler(s->aio_context, fd, false,
|
2019-09-10 12:41:33 +00:00
|
|
|
curl_multi_do, NULL, NULL, socket);
|
2009-05-11 15:41:42 +00:00
|
|
|
break;
|
|
|
|
case CURL_POLL_OUT:
|
2015-10-23 03:08:05 +00:00
|
|
|
aio_set_fd_handler(s->aio_context, fd, false,
|
2019-09-10 12:41:33 +00:00
|
|
|
NULL, curl_multi_do, NULL, socket);
|
2009-05-11 15:41:42 +00:00
|
|
|
break;
|
|
|
|
case CURL_POLL_INOUT:
|
2015-10-23 03:08:05 +00:00
|
|
|
aio_set_fd_handler(s->aio_context, fd, false,
|
2019-09-10 12:41:33 +00:00
|
|
|
curl_multi_do, curl_multi_do, NULL, socket);
|
2009-05-11 15:41:42 +00:00
|
|
|
break;
|
|
|
|
case CURL_POLL_REMOVE:
|
2015-10-23 03:08:05 +00:00
|
|
|
aio_set_fd_handler(s->aio_context, fd, false,
|
2016-12-01 19:26:41 +00:00
|
|
|
NULL, NULL, NULL, NULL);
|
2009-05-11 15:41:42 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2019-09-10 12:41:31 +00:00
|
|
|
if (action == CURL_POLL_REMOVE) {
|
|
|
|
QLIST_REMOVE(socket, next);
|
|
|
|
g_free(socket);
|
|
|
|
}
|
|
|
|
|
2009-05-11 15:41:42 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-05-15 10:00:54 +00:00
|
|
|
/* Called from curl_multi_do_locked, with s->mutex held. */
|
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 07:19:21 +00:00
|
|
|
static size_t curl_header_cb(void *ptr, size_t size, size_t nmemb, void *opaque)
|
2009-05-11 15:41:42 +00: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 07:19:21 +00:00
|
|
|
BDRVCURLState *s = opaque;
|
2009-05-11 15:41:42 +00:00
|
|
|
size_t realsize = size * nmemb;
|
2020-02-24 10:13:09 +00:00
|
|
|
const char *header = (char *)ptr;
|
|
|
|
const char *end = header + realsize;
|
|
|
|
const char *accept_ranges = "Accept-Ranges:";
|
|
|
|
const char *bytes = "bytes";
|
2009-05-11 15:41:42 +00:00
|
|
|
|
2020-02-24 10:13:09 +00:00
|
|
|
if (realsize >= strlen(accept_ranges)
|
|
|
|
&& strncmp(header, accept_ranges, strlen(accept_ranges)) == 0) {
|
|
|
|
|
|
|
|
char *p = strchr(header, ':') + 1;
|
|
|
|
|
|
|
|
/* Skip whitespace between the header name and value. */
|
|
|
|
while (p < end && *p && g_ascii_isspace(*p)) {
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (end - p >= strlen(bytes)
|
|
|
|
&& strncmp(p, bytes, strlen(bytes)) == 0) {
|
|
|
|
|
|
|
|
/* Check that there is nothing but whitespace after the value. */
|
|
|
|
p += strlen(bytes);
|
|
|
|
while (p < end && *p && g_ascii_isspace(*p)) {
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (p == end || !*p) {
|
|
|
|
s->accept_range = true;
|
|
|
|
}
|
|
|
|
}
|
2010-05-22 08:02:12 +00:00
|
|
|
}
|
2009-05-11 15:41:42 +00:00
|
|
|
|
|
|
|
return realsize;
|
|
|
|
}
|
|
|
|
|
2017-05-15 10:00:54 +00:00
|
|
|
/* Called from curl_multi_do_locked, with s->mutex held. */
|
2009-05-11 15:41:42 +00:00
|
|
|
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;
|
|
|
|
|
2018-12-13 16:27:25 +00:00
|
|
|
trace_curl_read_cb(realsize);
|
2009-05-11 15:41:42 +00:00
|
|
|
|
2016-10-25 02:54:29 +00:00
|
|
|
if (!s || !s->orig_buf) {
|
|
|
|
goto read_end;
|
|
|
|
}
|
2009-05-11 15:41:42 +00:00
|
|
|
|
2014-03-26 12:05:40 +00:00
|
|
|
if (s->buf_off >= s->buf_len) {
|
|
|
|
/* buffer full, read nothing */
|
2016-10-25 02:54:29 +00:00
|
|
|
goto read_end;
|
2014-03-26 12:05:40 +00:00
|
|
|
}
|
|
|
|
realsize = MIN(realsize, s->buf_len - s->buf_off);
|
2009-05-11 15:41:42 +00:00
|
|
|
memcpy(s->orig_buf + s->buf_off, ptr, realsize);
|
|
|
|
s->buf_off += realsize;
|
|
|
|
|
2016-10-25 02:54:29 +00:00
|
|
|
read_end:
|
|
|
|
/* curl will error out if we do not return this value */
|
|
|
|
return size * nmemb;
|
2009-05-11 15:41:42 +00:00
|
|
|
}
|
|
|
|
|
2017-05-15 10:00:55 +00:00
|
|
|
/* Called with s->mutex held. */
|
2017-05-15 10:00:58 +00:00
|
|
|
static bool curl_find_buf(BDRVCURLState *s, uint64_t start, uint64_t len,
|
|
|
|
CURLAIOCB *acb)
|
2009-05-11 15:41:42 +00:00
|
|
|
{
|
|
|
|
int i;
|
2017-05-15 10:00:57 +00:00
|
|
|
uint64_t end = start + len;
|
|
|
|
uint64_t clamped_end = MIN(end, s->len);
|
|
|
|
uint64_t clamped_len = clamped_end - start;
|
2009-05-11 15:41:42 +00:00
|
|
|
|
|
|
|
for (i=0; i<CURL_NUM_STATES; i++) {
|
|
|
|
CURLState *state = &s->states[i];
|
2017-05-15 10:00:57 +00:00
|
|
|
uint64_t buf_end = (state->buf_start + state->buf_off);
|
|
|
|
uint64_t buf_fend = (state->buf_start + state->buf_len);
|
2009-05-11 15:41:42 +00:00
|
|
|
|
|
|
|
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 02:54:31 +00:00
|
|
|
(clamped_end >= state->buf_start) &&
|
|
|
|
(clamped_end <= buf_end))
|
2009-05-11 15:41:42 +00:00
|
|
|
{
|
|
|
|
char *buf = state->orig_buf + (start - state->buf_start);
|
|
|
|
|
2016-10-25 02:54:31 +00: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);
|
|
|
|
}
|
2017-05-15 10:00:58 +00:00
|
|
|
acb->ret = 0;
|
|
|
|
return true;
|
2009-05-11 15:41:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Wait for unfinished chunks
|
2014-04-29 15:03:32 +00:00
|
|
|
if (state->in_use &&
|
|
|
|
(start >= state->buf_start) &&
|
2009-05-11 15:41:42 +00:00
|
|
|
(start <= buf_fend) &&
|
2016-10-25 02:54:31 +00:00
|
|
|
(clamped_end >= state->buf_start) &&
|
|
|
|
(clamped_end <= buf_fend))
|
2009-05-11 15:41:42 +00:00
|
|
|
{
|
|
|
|
int j;
|
|
|
|
|
|
|
|
acb->start = start - state->buf_start;
|
2016-10-25 02:54:31 +00:00
|
|
|
acb->end = acb->start + clamped_len;
|
2009-05-11 15:41:42 +00:00
|
|
|
|
|
|
|
for (j=0; j<CURL_NUM_ACB; j++) {
|
|
|
|
if (!state->acb[j]) {
|
|
|
|
state->acb[j] = acb;
|
2017-05-15 10:00:58 +00:00
|
|
|
return true;
|
2009-05-11 15:41:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-05-15 10:00:58 +00:00
|
|
|
return false;
|
2009-05-11 15:41:42 +00:00
|
|
|
}
|
|
|
|
|
2017-02-22 18:07:23 +00:00
|
|
|
/* Called with s->mutex held. */
|
2014-04-29 15:03:30 +00:00
|
|
|
static void curl_multi_check_completion(BDRVCURLState *s)
|
2009-05-11 15:41:42 +00:00
|
|
|
{
|
|
|
|
int msgs_in_queue;
|
|
|
|
|
|
|
|
/* Try to find done transfers, so we can free the easy
|
|
|
|
* handle again. */
|
2014-04-29 15:03:31 +00:00
|
|
|
for (;;) {
|
2009-05-11 15:41:42 +00:00
|
|
|
CURLMsg *msg;
|
|
|
|
msg = curl_multi_info_read(s->multi, &msgs_in_queue);
|
|
|
|
|
2014-04-29 15:03:31 +00:00
|
|
|
/* Quit when there are no more completions */
|
2009-05-11 15:41:42 +00:00
|
|
|
if (!msg)
|
|
|
|
break;
|
|
|
|
|
2014-04-29 15:03:31 +00:00
|
|
|
if (msg->msg == CURLMSG_DONE) {
|
2019-09-10 12:41:35 +00:00
|
|
|
int i;
|
2014-04-29 15:03:31 +00:00
|
|
|
CURLState *state = NULL;
|
2019-09-10 12:41:35 +00:00
|
|
|
bool error = msg->data.result != CURLE_OK;
|
|
|
|
|
2014-04-29 15:03:31 +00:00
|
|
|
curl_easy_getinfo(msg->easy_handle, CURLINFO_PRIVATE,
|
|
|
|
(char **)&state);
|
|
|
|
|
2019-09-10 12:41:35 +00:00
|
|
|
if (error) {
|
2015-07-08 13:37:48 +00: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");
|
|
|
|
}
|
|
|
|
}
|
2019-09-10 12:41:35 +00:00
|
|
|
}
|
2015-07-08 13:37:48 +00:00
|
|
|
|
2019-09-10 12:41:35 +00:00
|
|
|
for (i = 0; i < CURL_NUM_ACB; i++) {
|
|
|
|
CURLAIOCB *acb = state->acb[i];
|
2014-04-29 15:03:31 +00:00
|
|
|
|
2019-09-10 12:41:35 +00:00
|
|
|
if (acb == NULL) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!error) {
|
|
|
|
/* Assert that we have read all data */
|
|
|
|
assert(state->buf_off >= acb->end);
|
|
|
|
|
|
|
|
qemu_iovec_from_buf(acb->qiov, 0,
|
|
|
|
state->orig_buf + acb->start,
|
|
|
|
acb->end - acb->start);
|
2011-08-15 09:00:34 +00:00
|
|
|
|
2019-09-10 12:41:35 +00:00
|
|
|
if (acb->end - acb->start < acb->bytes) {
|
|
|
|
size_t offset = acb->end - acb->start;
|
|
|
|
qemu_iovec_memset(acb->qiov, offset, 0,
|
|
|
|
acb->bytes - offset);
|
|
|
|
}
|
2014-04-29 15:03:31 +00:00
|
|
|
}
|
2019-09-10 12:41:35 +00:00
|
|
|
|
|
|
|
acb->ret = error ? -EIO : 0;
|
|
|
|
state->acb[i] = NULL;
|
|
|
|
qemu_mutex_unlock(&s->mutex);
|
|
|
|
aio_co_wake(acb->co);
|
|
|
|
qemu_mutex_lock(&s->mutex);
|
2009-05-11 15:41:42 +00:00
|
|
|
}
|
2014-04-29 15:03:31 +00:00
|
|
|
|
|
|
|
curl_clean_state(state);
|
|
|
|
break;
|
2009-05-11 15:41:42 +00:00
|
|
|
}
|
2014-04-29 15:03:31 +00:00
|
|
|
}
|
2009-05-11 15:41:42 +00:00
|
|
|
}
|
|
|
|
|
2017-02-22 18:07:23 +00:00
|
|
|
/* Called with s->mutex held. */
|
2019-09-10 12:41:34 +00:00
|
|
|
static void curl_multi_do_locked(CURLSocket *socket)
|
2014-01-24 13:56:17 +00:00
|
|
|
{
|
2019-09-10 12:41:34 +00:00
|
|
|
BDRVCURLState *s = socket->state->s;
|
2014-01-24 13:56:17 +00:00
|
|
|
int running;
|
|
|
|
int r;
|
|
|
|
|
2019-09-10 12:41:34 +00:00
|
|
|
if (!s->multi) {
|
2014-01-24 13:56:17 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-09-10 12:41:34 +00:00
|
|
|
do {
|
|
|
|
r = curl_multi_socket_action(s->multi, socket->fd, 0, &running);
|
|
|
|
} while (r == CURLM_CALL_MULTI_PERFORM);
|
2014-04-29 15:03:30 +00:00
|
|
|
}
|
|
|
|
|
2017-02-13 13:52:30 +00:00
|
|
|
static void curl_multi_do(void *arg)
|
|
|
|
{
|
2019-09-10 12:41:33 +00:00
|
|
|
CURLSocket *socket = arg;
|
|
|
|
BDRVCURLState *s = socket->state->s;
|
2017-02-13 13:52:30 +00:00
|
|
|
|
2019-09-10 12:41:33 +00:00
|
|
|
qemu_mutex_lock(&s->mutex);
|
|
|
|
curl_multi_do_locked(socket);
|
|
|
|
curl_multi_check_completion(s);
|
|
|
|
qemu_mutex_unlock(&s->mutex);
|
2014-01-24 13:56:17 +00: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 18:07:23 +00:00
|
|
|
qemu_mutex_lock(&s->mutex);
|
2014-01-24 13:56:17 +00:00
|
|
|
curl_multi_socket_action(s->multi, CURL_SOCKET_TIMEOUT, 0, &running);
|
|
|
|
|
2014-04-29 15:03:30 +00:00
|
|
|
curl_multi_check_completion(s);
|
2017-02-22 18:07:23 +00:00
|
|
|
qemu_mutex_unlock(&s->mutex);
|
2014-01-24 13:56:17 +00:00
|
|
|
#else
|
|
|
|
abort();
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2017-05-15 10:00:55 +00:00
|
|
|
/* Called with s->mutex held. */
|
2017-05-15 10:00:56 +00:00
|
|
|
static CURLState *curl_find_state(BDRVCURLState *s)
|
2009-05-11 15:41:42 +00:00
|
|
|
{
|
|
|
|
CURLState *state = NULL;
|
2017-05-15 10:00:56 +00:00
|
|
|
int i;
|
2009-05-11 15:41:42 +00:00
|
|
|
|
2017-05-15 10:00:56 +00:00
|
|
|
for (i = 0; i < CURL_NUM_STATES; i++) {
|
|
|
|
if (!s->states[i].in_use) {
|
2009-05-11 15:41:42 +00:00
|
|
|
state = &s->states[i];
|
|
|
|
state->in_use = 1;
|
|
|
|
break;
|
|
|
|
}
|
2017-05-15 10:00:56 +00:00
|
|
|
}
|
|
|
|
return state;
|
|
|
|
}
|
2009-05-11 15:41:42 +00:00
|
|
|
|
2017-05-15 10:00:56 +00:00
|
|
|
static int curl_init_state(BDRVCURLState *s, CURLState *state)
|
|
|
|
{
|
2014-04-29 15:03:26 +00:00
|
|
|
if (!state->curl) {
|
|
|
|
state->curl = curl_easy_init();
|
|
|
|
if (!state->curl) {
|
2017-05-15 10:00:56 +00:00
|
|
|
return -EIO;
|
2014-04-29 15:03:26 +00:00
|
|
|
}
|
|
|
|
curl_easy_setopt(state->curl, CURLOPT_URL, s->url);
|
2014-05-14 23:28:42 +00:00
|
|
|
curl_easy_setopt(state->curl, CURLOPT_SSL_VERIFYPEER,
|
|
|
|
(long) s->sslverify);
|
2018-09-14 09:56:22 +00:00
|
|
|
curl_easy_setopt(state->curl, CURLOPT_SSL_VERIFYHOST,
|
|
|
|
s->sslverify ? 2L : 0L);
|
2014-08-29 15:03:12 +00:00
|
|
|
if (s->cookie) {
|
|
|
|
curl_easy_setopt(state->curl, CURLOPT_COOKIE, s->cookie);
|
|
|
|
}
|
2014-10-26 11:05:27 +00:00
|
|
|
curl_easy_setopt(state->curl, CURLOPT_TIMEOUT, (long)s->timeout);
|
2014-04-29 15:03:26 +00: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 14:19:20 +00: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 15:03:26 +00: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 08:25:34 +00:00
|
|
|
#if LIBCURL_VERSION_NUM >= 0x071304
|
2014-04-29 15:03:26 +00:00
|
|
|
curl_easy_setopt(state->curl, CURLOPT_PROTOCOLS, PROTOCOLS);
|
|
|
|
curl_easy_setopt(state->curl, CURLOPT_REDIR_PROTOCOLS, PROTOCOLS);
|
2013-02-13 08:25:34 +00:00
|
|
|
#endif
|
2013-02-08 07:49:10 +00:00
|
|
|
|
2009-05-11 15:41:42 +00:00
|
|
|
#ifdef DEBUG_VERBOSE
|
2014-04-29 15:03:26 +00:00
|
|
|
curl_easy_setopt(state->curl, CURLOPT_VERBOSE, 1);
|
2009-05-11 15:41:42 +00:00
|
|
|
#endif
|
2014-04-29 15:03:26 +00:00
|
|
|
}
|
2009-05-11 15:41:42 +00:00
|
|
|
|
2016-10-25 02:54:30 +00:00
|
|
|
QLIST_INIT(&state->sockets);
|
2009-05-11 15:41:42 +00:00
|
|
|
state->s = s;
|
|
|
|
|
2017-05-15 10:00:56 +00:00
|
|
|
return 0;
|
2009-05-11 15:41:42 +00:00
|
|
|
}
|
|
|
|
|
2017-05-15 10:00:55 +00:00
|
|
|
/* Called with s->mutex held. */
|
2009-05-11 15:41:42 +00:00
|
|
|
static void curl_clean_state(CURLState *s)
|
|
|
|
{
|
2017-05-15 10:00:53 +00:00
|
|
|
int j;
|
|
|
|
for (j = 0; j < CURL_NUM_ACB; j++) {
|
|
|
|
assert(!s->acb[j]);
|
|
|
|
}
|
|
|
|
|
2009-05-11 15:41:42 +00:00
|
|
|
if (s->s->multi)
|
|
|
|
curl_multi_remove_handle(s->s->multi, s->curl);
|
2016-10-25 02:54:30 +00:00
|
|
|
|
|
|
|
while (!QLIST_EMPTY(&s->sockets)) {
|
|
|
|
CURLSocket *socket = QLIST_FIRST(&s->sockets);
|
|
|
|
|
|
|
|
QLIST_REMOVE(socket, next);
|
|
|
|
g_free(socket);
|
|
|
|
}
|
|
|
|
|
2009-05-11 15:41:42 +00:00
|
|
|
s->in_use = 0;
|
2017-05-15 10:00:59 +00:00
|
|
|
|
2018-02-03 15:39:35 +00:00
|
|
|
qemu_co_enter_next(&s->s->free_state_waitq, &s->s->mutex);
|
2009-05-11 15:41:42 +00:00
|
|
|
}
|
|
|
|
|
2013-04-10 13:31:33 +00:00
|
|
|
static void curl_parse_filename(const char *filename, QDict *options,
|
|
|
|
Error **errp)
|
2009-05-11 15:41:42 +00:00
|
|
|
{
|
2017-04-27 21:58:17 +00:00
|
|
|
qdict_put_str(options, CURL_BLOCK_OPT_URL, filename);
|
2013-04-10 13:31:33 +00:00
|
|
|
}
|
|
|
|
|
2014-05-08 14:34:40 +00:00
|
|
|
static void curl_detach_aio_context(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
BDRVCURLState *s = bs->opaque;
|
|
|
|
int i;
|
|
|
|
|
2017-05-15 10:00:55 +00:00
|
|
|
qemu_mutex_lock(&s->mutex);
|
2014-05-08 14:34:40 +00: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;
|
|
|
|
}
|
2014-06-06 16:25:12 +00:00
|
|
|
g_free(s->states[i].orig_buf);
|
|
|
|
s->states[i].orig_buf = NULL;
|
2014-05-08 14:34:40 +00:00
|
|
|
}
|
|
|
|
if (s->multi) {
|
|
|
|
curl_multi_cleanup(s->multi);
|
|
|
|
s->multi = NULL;
|
|
|
|
}
|
2017-05-15 10:00:55 +00:00
|
|
|
qemu_mutex_unlock(&s->mutex);
|
2014-05-08 14:34:40 +00:00
|
|
|
|
|
|
|
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 13:31:33 +00:00
|
|
|
static QemuOptsList runtime_opts = {
|
|
|
|
.name = "curl",
|
|
|
|
.head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
|
|
|
|
.desc = {
|
|
|
|
{
|
2014-05-14 23:28:41 +00:00
|
|
|
.name = CURL_BLOCK_OPT_URL,
|
2013-04-10 13:31:33 +00:00
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
.help = "URL to open",
|
|
|
|
},
|
|
|
|
{
|
2014-05-14 23:28:41 +00:00
|
|
|
.name = CURL_BLOCK_OPT_READAHEAD,
|
2013-04-10 13:31:33 +00:00
|
|
|
.type = QEMU_OPT_SIZE,
|
|
|
|
.help = "Readahead size",
|
|
|
|
},
|
2014-05-14 23:28:42 +00:00
|
|
|
{
|
|
|
|
.name = CURL_BLOCK_OPT_SSLVERIFY,
|
|
|
|
.type = QEMU_OPT_BOOL,
|
|
|
|
.help = "Verify SSL certificate"
|
|
|
|
},
|
2014-08-13 15:44:27 +00:00
|
|
|
{
|
|
|
|
.name = CURL_BLOCK_OPT_TIMEOUT,
|
|
|
|
.type = QEMU_OPT_NUMBER,
|
|
|
|
.help = "Curl timeout"
|
|
|
|
},
|
2014-08-29 15:03:12 +00:00
|
|
|
{
|
|
|
|
.name = CURL_BLOCK_OPT_COOKIE,
|
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
.help = "Pass the cookie or list of cookies with each request"
|
|
|
|
},
|
2017-05-04 14:00:06 +00:00
|
|
|
{
|
|
|
|
.name = CURL_BLOCK_OPT_COOKIE_SECRET,
|
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
.help = "ID of secret used as cookie passed 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 14:19:20 +00: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 13:31:33 +00: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 14:19:20 +00:00
|
|
|
|
2013-09-05 12:22:29 +00:00
|
|
|
static int curl_open(BlockDriverState *bs, QDict *options, int flags,
|
|
|
|
Error **errp)
|
2013-04-10 13:31:33 +00:00
|
|
|
{
|
|
|
|
BDRVCURLState *s = bs->opaque;
|
|
|
|
CURLState *state = NULL;
|
|
|
|
QemuOpts *opts;
|
|
|
|
Error *local_err = NULL;
|
|
|
|
const char *file;
|
2014-08-29 15:03:12 +00:00
|
|
|
const char *cookie;
|
2017-05-04 14:00:06 +00:00
|
|
|
const char *cookie_secret;
|
2013-04-10 13:31:33 +00: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 14:19:20 +00:00
|
|
|
const char *secretid;
|
2017-03-31 12:04:31 +00:00
|
|
|
const char *protocol_delimiter;
|
2017-11-07 22:27:22 +00:00
|
|
|
int ret;
|
2013-04-10 13:31:33 +00:00
|
|
|
|
2018-10-08 15:27:18 +00:00
|
|
|
ret = bdrv_apply_auto_read_only(bs, "curl driver does not support writes",
|
|
|
|
errp);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
2013-06-10 11:38:43 +00:00
|
|
|
}
|
|
|
|
|
2017-11-07 22:27:22 +00:00
|
|
|
if (!libcurl_initialized) {
|
|
|
|
ret = curl_global_init(CURL_GLOBAL_ALL);
|
|
|
|
if (ret) {
|
|
|
|
error_setg(errp, "libcurl initialization failed with %d", ret);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
libcurl_initialized = true;
|
|
|
|
}
|
|
|
|
|
2017-05-15 10:00:55 +00:00
|
|
|
qemu_mutex_init(&s->mutex);
|
2014-01-02 02:49:17 +00:00
|
|
|
opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
|
2013-04-10 13:31:33 +00:00
|
|
|
qemu_opts_absorb_qdict(opts, options, &local_err);
|
2014-01-30 14:07:28 +00:00
|
|
|
if (local_err) {
|
2014-02-17 13:43:57 +00:00
|
|
|
error_propagate(errp, local_err);
|
2013-04-10 13:31:33 +00:00
|
|
|
goto out_noclean;
|
|
|
|
}
|
|
|
|
|
2014-05-14 23:28:41 +00:00
|
|
|
s->readahead_size = qemu_opt_get_size(opts, CURL_BLOCK_OPT_READAHEAD,
|
2019-02-01 19:29:31 +00:00
|
|
|
CURL_BLOCK_OPT_READAHEAD_DEFAULT);
|
2009-07-02 00:16:52 +00:00
|
|
|
if ((s->readahead_size & 0x1ff) != 0) {
|
2014-02-17 13:43:57 +00:00
|
|
|
error_setg(errp, "HTTP_READAHEAD_SIZE %zd is not a multiple of 512",
|
|
|
|
s->readahead_size);
|
2009-07-02 00:16:52 +00:00
|
|
|
goto out_noclean;
|
|
|
|
}
|
|
|
|
|
2014-08-13 15:44:27 +00:00
|
|
|
s->timeout = qemu_opt_get_number(opts, CURL_BLOCK_OPT_TIMEOUT,
|
2019-02-01 19:29:31 +00:00
|
|
|
CURL_BLOCK_OPT_TIMEOUT_DEFAULT);
|
2014-10-26 11:05:27 +00:00
|
|
|
if (s->timeout > CURL_TIMEOUT_MAX) {
|
|
|
|
error_setg(errp, "timeout parameter is too large or negative");
|
|
|
|
goto out_noclean;
|
|
|
|
}
|
2014-08-13 15:44:27 +00:00
|
|
|
|
2019-02-01 19:29:31 +00:00
|
|
|
s->sslverify = qemu_opt_get_bool(opts, CURL_BLOCK_OPT_SSLVERIFY,
|
|
|
|
CURL_BLOCK_OPT_SSLVERIFY_DEFAULT);
|
2014-05-14 23:28:42 +00:00
|
|
|
|
2014-08-29 15:03:12 +00:00
|
|
|
cookie = qemu_opt_get(opts, CURL_BLOCK_OPT_COOKIE);
|
2017-05-04 14:00:06 +00:00
|
|
|
cookie_secret = qemu_opt_get(opts, CURL_BLOCK_OPT_COOKIE_SECRET);
|
|
|
|
|
|
|
|
if (cookie && cookie_secret) {
|
|
|
|
error_setg(errp,
|
|
|
|
"curl driver cannot handle both cookie and cookie secret");
|
|
|
|
goto out_noclean;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cookie_secret) {
|
|
|
|
s->cookie = qcrypto_secret_lookup_as_utf8(cookie_secret, errp);
|
|
|
|
if (!s->cookie) {
|
|
|
|
goto out_noclean;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
s->cookie = g_strdup(cookie);
|
|
|
|
}
|
2014-08-29 15:03:12 +00:00
|
|
|
|
2014-05-14 23:28:41 +00:00
|
|
|
file = qemu_opt_get(opts, CURL_BLOCK_OPT_URL);
|
2013-04-10 13:31:33 +00:00
|
|
|
if (file == NULL) {
|
2014-02-17 13:43:57 +00:00
|
|
|
error_setg(errp, "curl block driver requires an 'url' option");
|
2013-04-10 13:31:33 +00:00
|
|
|
goto out_noclean;
|
|
|
|
}
|
|
|
|
|
2017-03-31 12:04:31 +00:00
|
|
|
if (!strstart(file, bs->drv->protocol_name, &protocol_delimiter) ||
|
|
|
|
!strstart(protocol_delimiter, "://", NULL))
|
|
|
|
{
|
|
|
|
error_setg(errp, "%s curl driver cannot handle the URL '%s' (does not "
|
|
|
|
"start with '%s://')", bs->drv->protocol_name, file,
|
|
|
|
bs->drv->protocol_name);
|
|
|
|
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 14:19:20 +00: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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-12-13 16:27:25 +00:00
|
|
|
trace_curl_open(file);
|
2018-02-03 15:39:35 +00:00
|
|
|
qemu_co_queue_init(&s->free_state_waitq);
|
2014-05-08 14:34:40 +00:00
|
|
|
s->aio_context = bdrv_get_aio_context(bs);
|
2013-04-10 13:31:33 +00:00
|
|
|
s->url = g_strdup(file);
|
2017-05-15 10:00:55 +00:00
|
|
|
qemu_mutex_lock(&s->mutex);
|
2017-05-15 10:00:56 +00:00
|
|
|
state = curl_find_state(s);
|
2017-05-15 10:00:55 +00:00
|
|
|
qemu_mutex_unlock(&s->mutex);
|
2017-05-15 10:00:56 +00:00
|
|
|
if (!state) {
|
2009-05-11 15:41:42 +00:00
|
|
|
goto out_noclean;
|
2017-05-15 10:00:56 +00:00
|
|
|
}
|
2009-05-11 15:41:42 +00:00
|
|
|
|
|
|
|
// Get file size
|
|
|
|
|
2017-05-15 10:00:56 +00:00
|
|
|
if (curl_init_state(s, state) < 0) {
|
|
|
|
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 07:19:21 +00:00
|
|
|
s->accept_range = false;
|
2009-05-11 15:41:42 +00: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 07:19:21 +00:00
|
|
|
curl_easy_setopt(state->curl, CURLOPT_HEADERFUNCTION,
|
|
|
|
curl_header_cb);
|
|
|
|
curl_easy_setopt(state->curl, CURLOPT_HEADERDATA, s);
|
2009-05-11 15:41:42 +00:00
|
|
|
if (curl_easy_perform(state->curl))
|
|
|
|
goto out;
|
2016-07-08 11:18:09 +00:00
|
|
|
if (curl_easy_getinfo(state->curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &d)) {
|
2009-05-11 15:41:42 +00:00
|
|
|
goto out;
|
2016-07-08 11:18:09 +00: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
|
2018-07-12 19:51:20 +00:00
|
|
|
* known and zero if it is really zero-length file. */
|
2016-07-08 11:18:09 +00:00
|
|
|
#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
|
|
|
|
|
2017-05-15 10:00:57 +00:00
|
|
|
s->len = d;
|
2016-07-08 11:18:09 +00: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 07:19:21 +00: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;
|
|
|
|
}
|
2018-12-13 16:27:25 +00:00
|
|
|
trace_curl_open_size(s->len);
|
2009-05-11 15:41:42 +00:00
|
|
|
|
2017-05-15 10:00:55 +00:00
|
|
|
qemu_mutex_lock(&s->mutex);
|
2009-05-11 15:41:42 +00:00
|
|
|
curl_clean_state(state);
|
2017-05-15 10:00:55 +00:00
|
|
|
qemu_mutex_unlock(&s->mutex);
|
2009-05-11 15:41:42 +00:00
|
|
|
curl_easy_cleanup(state->curl);
|
|
|
|
state->curl = NULL;
|
|
|
|
|
2014-05-08 14:34:40 +00:00
|
|
|
curl_attach_aio_context(bs, bdrv_get_aio_context(bs));
|
2009-05-11 15:41:42 +00:00
|
|
|
|
2013-04-10 13:31:33 +00:00
|
|
|
qemu_opts_del(opts);
|
2009-05-11 15:41:42 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
out:
|
2014-03-18 05:59:18 +00:00
|
|
|
error_setg(errp, "CURL: Error opening file: %s", state->errmsg);
|
2009-05-11 15:41:42 +00:00
|
|
|
curl_easy_cleanup(state->curl);
|
|
|
|
state->curl = NULL;
|
|
|
|
out_noclean:
|
2017-05-15 10:00:55 +00:00
|
|
|
qemu_mutex_destroy(&s->mutex);
|
2014-08-29 15:03:12 +00:00
|
|
|
g_free(s->cookie);
|
2013-04-10 13:31:33 +00:00
|
|
|
g_free(s->url);
|
2017-11-07 22:27:23 +00:00
|
|
|
g_free(s->username);
|
|
|
|
g_free(s->proxyusername);
|
|
|
|
g_free(s->proxypassword);
|
2013-04-10 13:31:33 +00:00
|
|
|
qemu_opts_del(opts);
|
2009-05-11 15:41:42 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2017-05-15 10:00:58 +00:00
|
|
|
static void curl_setup_preadv(BlockDriverState *bs, CURLAIOCB *acb)
|
2009-05-11 15:41:42 +00:00
|
|
|
{
|
|
|
|
CURLState *state;
|
2014-04-29 15:03:29 +00:00
|
|
|
int running;
|
2009-05-11 15:41:42 +00:00
|
|
|
|
2017-02-13 13:52:31 +00:00
|
|
|
BDRVCURLState *s = bs->opaque;
|
2009-05-11 15:41:42 +00:00
|
|
|
|
2017-05-15 10:00:57 +00:00
|
|
|
uint64_t start = acb->offset;
|
|
|
|
uint64_t end;
|
2009-05-11 15:41:42 +00:00
|
|
|
|
2017-02-22 18:07:23 +00:00
|
|
|
qemu_mutex_lock(&s->mutex);
|
2017-02-13 13:52:31 +00:00
|
|
|
|
2009-05-11 15:41:42 +00:00
|
|
|
// In case we have the requested data already (e.g. read-ahead),
|
|
|
|
// we can just call the callback and be done.
|
2017-05-15 10:00:58 +00:00
|
|
|
if (curl_find_buf(s, start, acb->bytes, acb)) {
|
|
|
|
goto out;
|
2009-05-11 15:41:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// No cache found, so let's start a new request
|
2017-05-15 10:00:56 +00:00
|
|
|
for (;;) {
|
|
|
|
state = curl_find_state(s);
|
|
|
|
if (state) {
|
|
|
|
break;
|
|
|
|
}
|
2018-02-03 15:39:35 +00:00
|
|
|
qemu_co_queue_wait(&s->free_state_waitq, &s->mutex);
|
2017-05-15 10:00:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (curl_init_state(s, state) < 0) {
|
|
|
|
curl_clean_state(state);
|
2017-05-15 10:00:58 +00:00
|
|
|
acb->ret = -EIO;
|
2017-02-13 13:52:31 +00:00
|
|
|
goto out;
|
2011-09-21 10:55:50 +00:00
|
|
|
}
|
2009-05-11 15:41:42 +00:00
|
|
|
|
|
|
|
acb->start = 0;
|
2017-05-15 10:00:57 +00:00
|
|
|
acb->end = MIN(acb->bytes, s->len - start);
|
2009-05-11 15:41:42 +00:00
|
|
|
|
|
|
|
state->buf_off = 0;
|
2014-06-06 16:25:12 +00:00
|
|
|
g_free(state->orig_buf);
|
2009-05-11 15:41:42 +00:00
|
|
|
state->buf_start = start;
|
2016-10-25 02:54:31 +00:00
|
|
|
state->buf_len = MIN(acb->end + s->readahead_size, s->len - start);
|
|
|
|
end = start + state->buf_len - 1;
|
2014-05-20 11:26:40 +00:00
|
|
|
state->orig_buf = g_try_malloc(state->buf_len);
|
|
|
|
if (state->buf_len && state->orig_buf == NULL) {
|
|
|
|
curl_clean_state(state);
|
2017-05-15 10:00:58 +00:00
|
|
|
acb->ret = -ENOMEM;
|
2017-02-13 13:52:31 +00:00
|
|
|
goto out;
|
2014-05-20 11:26:40 +00:00
|
|
|
}
|
2009-05-11 15:41:42 +00:00
|
|
|
state->acb[0] = acb;
|
|
|
|
|
2017-05-15 10:00:57 +00:00
|
|
|
snprintf(state->range, 127, "%" PRIu64 "-%" PRIu64, start, end);
|
2018-12-13 16:27:25 +00:00
|
|
|
trace_curl_setup_preadv(acb->bytes, start, state->range);
|
2009-05-11 15:41:42 +00:00
|
|
|
curl_easy_setopt(state->curl, CURLOPT_RANGE, state->range);
|
|
|
|
|
2019-09-10 12:41:36 +00:00
|
|
|
if (curl_multi_add_handle(s->multi, state->curl) != CURLM_OK) {
|
|
|
|
state->acb[0] = NULL;
|
|
|
|
acb->ret = -EIO;
|
|
|
|
|
|
|
|
curl_clean_state(state);
|
|
|
|
goto out;
|
|
|
|
}
|
2009-05-11 15:41:42 +00:00
|
|
|
|
2014-04-29 15:03:29 +00:00
|
|
|
/* Tell curl it needs to kick things off */
|
|
|
|
curl_multi_socket_action(s->multi, CURL_SOCKET_TIMEOUT, 0, &running);
|
2017-02-13 13:52:31 +00:00
|
|
|
|
|
|
|
out:
|
2017-02-22 18:07:23 +00:00
|
|
|
qemu_mutex_unlock(&s->mutex);
|
2011-09-21 10:55:50 +00:00
|
|
|
}
|
|
|
|
|
2017-05-15 10:00:58 +00:00
|
|
|
static int coroutine_fn curl_co_preadv(BlockDriverState *bs,
|
|
|
|
uint64_t offset, uint64_t bytes, QEMUIOVector *qiov, int flags)
|
2011-09-21 10:55:50 +00:00
|
|
|
{
|
2017-05-15 10:00:58 +00:00
|
|
|
CURLAIOCB acb = {
|
|
|
|
.co = qemu_coroutine_self(),
|
|
|
|
.ret = -EINPROGRESS,
|
|
|
|
.qiov = qiov,
|
|
|
|
.offset = offset,
|
|
|
|
.bytes = bytes
|
|
|
|
};
|
|
|
|
|
|
|
|
curl_setup_preadv(bs, &acb);
|
|
|
|
while (acb.ret == -EINPROGRESS) {
|
|
|
|
qemu_coroutine_yield();
|
|
|
|
}
|
|
|
|
return acb.ret;
|
2009-05-11 15:41:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void curl_close(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
BDRVCURLState *s = bs->opaque;
|
|
|
|
|
2018-12-13 16:27:25 +00:00
|
|
|
trace_curl_close();
|
2014-05-08 14:34:40 +00:00
|
|
|
curl_detach_aio_context(bs);
|
2017-02-22 18:07:23 +00:00
|
|
|
qemu_mutex_destroy(&s->mutex);
|
2014-01-24 13:56:17 +00:00
|
|
|
|
2014-08-29 15:03:12 +00:00
|
|
|
g_free(s->cookie);
|
2012-09-01 09:06:45 +00:00
|
|
|
g_free(s->url);
|
2017-11-07 22:27:23 +00:00
|
|
|
g_free(s->username);
|
|
|
|
g_free(s->proxyusername);
|
|
|
|
g_free(s->proxypassword);
|
2009-05-11 15:41:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int64_t curl_getlength(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
BDRVCURLState *s = bs->opaque;
|
|
|
|
return s->len;
|
|
|
|
}
|
|
|
|
|
2019-02-01 19:29:32 +00:00
|
|
|
static void curl_refresh_filename(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
BDRVCURLState *s = bs->opaque;
|
|
|
|
|
|
|
|
/* "readahead" and "timeout" do not change the guest-visible data,
|
|
|
|
* so ignore them */
|
|
|
|
if (s->sslverify != CURL_BLOCK_OPT_SSLVERIFY_DEFAULT ||
|
|
|
|
s->cookie || s->username || s->password || s->proxyusername ||
|
|
|
|
s->proxypassword)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), s->url);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-02-01 19:29:25 +00:00
|
|
|
static const char *const curl_strong_runtime_opts[] = {
|
|
|
|
CURL_BLOCK_OPT_URL,
|
|
|
|
CURL_BLOCK_OPT_SSLVERIFY,
|
|
|
|
CURL_BLOCK_OPT_COOKIE,
|
|
|
|
CURL_BLOCK_OPT_COOKIE_SECRET,
|
|
|
|
CURL_BLOCK_OPT_USERNAME,
|
|
|
|
CURL_BLOCK_OPT_PASSWORD_SECRET,
|
|
|
|
CURL_BLOCK_OPT_PROXY_USERNAME,
|
|
|
|
CURL_BLOCK_OPT_PROXY_PASSWORD_SECRET,
|
|
|
|
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2009-05-11 15:41:42 +00:00
|
|
|
static BlockDriver bdrv_http = {
|
2014-05-08 14:34:40 +00: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 15:41:42 +00:00
|
|
|
|
2017-05-15 10:00:58 +00:00
|
|
|
.bdrv_co_preadv = curl_co_preadv,
|
2009-05-11 15:41:42 +00:00
|
|
|
|
2014-05-08 14:34:40 +00:00
|
|
|
.bdrv_detach_aio_context = curl_detach_aio_context,
|
|
|
|
.bdrv_attach_aio_context = curl_attach_aio_context,
|
2019-02-01 19:29:25 +00:00
|
|
|
|
2019-02-01 19:29:32 +00:00
|
|
|
.bdrv_refresh_filename = curl_refresh_filename,
|
2019-02-01 19:29:25 +00:00
|
|
|
.strong_runtime_opts = curl_strong_runtime_opts,
|
2009-05-11 15:41:42 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static BlockDriver bdrv_https = {
|
2014-05-08 14:34:40 +00:00
|
|
|
.format_name = "https",
|
|
|
|
.protocol_name = "https",
|
2009-05-11 15:41:42 +00:00
|
|
|
|
2014-05-08 14:34:40 +00: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 15:41:42 +00:00
|
|
|
|
2017-05-15 10:00:58 +00:00
|
|
|
.bdrv_co_preadv = curl_co_preadv,
|
2014-05-08 14:34:40 +00:00
|
|
|
|
|
|
|
.bdrv_detach_aio_context = curl_detach_aio_context,
|
|
|
|
.bdrv_attach_aio_context = curl_attach_aio_context,
|
2019-02-01 19:29:25 +00:00
|
|
|
|
2019-02-01 19:29:32 +00:00
|
|
|
.bdrv_refresh_filename = curl_refresh_filename,
|
2019-02-01 19:29:25 +00:00
|
|
|
.strong_runtime_opts = curl_strong_runtime_opts,
|
2009-05-11 15:41:42 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static BlockDriver bdrv_ftp = {
|
2014-05-08 14:34:40 +00: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 15:41:42 +00:00
|
|
|
|
2017-05-15 10:00:58 +00:00
|
|
|
.bdrv_co_preadv = curl_co_preadv,
|
2009-05-11 15:41:42 +00:00
|
|
|
|
2014-05-08 14:34:40 +00:00
|
|
|
.bdrv_detach_aio_context = curl_detach_aio_context,
|
|
|
|
.bdrv_attach_aio_context = curl_attach_aio_context,
|
2019-02-01 19:29:25 +00:00
|
|
|
|
2019-02-01 19:29:32 +00:00
|
|
|
.bdrv_refresh_filename = curl_refresh_filename,
|
2019-02-01 19:29:25 +00:00
|
|
|
.strong_runtime_opts = curl_strong_runtime_opts,
|
2009-05-11 15:41:42 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static BlockDriver bdrv_ftps = {
|
2014-05-08 14:34:40 +00:00
|
|
|
.format_name = "ftps",
|
|
|
|
.protocol_name = "ftps",
|
2009-05-11 15:41:42 +00:00
|
|
|
|
2014-05-08 14:34:40 +00: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 15:41:42 +00:00
|
|
|
|
2017-05-15 10:00:58 +00:00
|
|
|
.bdrv_co_preadv = curl_co_preadv,
|
2014-05-08 14:34:40 +00:00
|
|
|
|
|
|
|
.bdrv_detach_aio_context = curl_detach_aio_context,
|
|
|
|
.bdrv_attach_aio_context = curl_attach_aio_context,
|
2019-02-01 19:29:25 +00:00
|
|
|
|
2019-02-01 19:29:32 +00:00
|
|
|
.bdrv_refresh_filename = curl_refresh_filename,
|
2019-02-01 19:29:25 +00:00
|
|
|
.strong_runtime_opts = curl_strong_runtime_opts,
|
2009-05-11 15:41:42 +00: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);
|