]>
Commit | Line | Data |
---|---|---|
769ce76d AG |
1 | /* |
2 | * QEMU Block driver for CURL images | |
3 | * | |
4 | * Copyright (c) 2009 Alexander Graf <agraf@suse.de> | |
5 | * | |
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy | |
7 | * of this software and associated documentation files (the "Software"), to deal | |
8 | * in the Software without restriction, including without limitation the rights | |
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
10 | * copies of the Software, and to permit persons to whom the Software is | |
11 | * furnished to do so, subject to the following conditions: | |
12 | * | |
13 | * The above copyright notice and this permission notice shall be included in | |
14 | * all copies or substantial portions of the Software. | |
15 | * | |
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
19 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
22 | * THE SOFTWARE. | |
23 | */ | |
452fcdbc | 24 | |
80c71a24 | 25 | #include "qemu/osdep.h" |
da34e65c | 26 | #include "qapi/error.h" |
796a060b | 27 | #include "qemu/error-report.h" |
0b8fa32f | 28 | #include "qemu/module.h" |
922a01a0 | 29 | #include "qemu/option.h" |
e2c1c34f | 30 | #include "block/block-io.h" |
737e150e | 31 | #include "block/block_int.h" |
452fcdbc | 32 | #include "qapi/qmp/qdict.h" |
d49b6836 | 33 | #include "qapi/qmp/qstring.h" |
1bff9606 | 34 | #include "crypto/secret.h" |
769ce76d | 35 | #include <curl/curl.h> |
f348b6d1 | 36 | #include "qemu/cutils.h" |
ed2a66de | 37 | #include "trace.h" |
769ce76d | 38 | |
769ce76d AG |
39 | // #define DEBUG_VERBOSE |
40 | ||
e7b8d9d0 AJ |
41 | /* CURL 7.85.0 switches to a string based API for specifying |
42 | * the desired protocols. | |
43 | */ | |
44 | #if LIBCURL_VERSION_NUM >= 0x075500 | |
45 | #define PROTOCOLS "HTTP,HTTPS,FTP,FTPS" | |
46 | #else | |
fb6d1bbd | 47 | #define PROTOCOLS (CURLPROTO_HTTP | CURLPROTO_HTTPS | \ |
23dce387 | 48 | CURLPROTO_FTP | CURLPROTO_FTPS) |
e7b8d9d0 | 49 | #endif |
fb6d1bbd | 50 | |
769ce76d AG |
51 | #define CURL_NUM_STATES 8 |
52 | #define CURL_NUM_ACB 8 | |
f76faeda | 53 | #define CURL_TIMEOUT_MAX 10000 |
769ce76d | 54 | |
e3542c67 MB |
55 | #define CURL_BLOCK_OPT_URL "url" |
56 | #define CURL_BLOCK_OPT_READAHEAD "readahead" | |
97a3ea57 | 57 | #define CURL_BLOCK_OPT_SSLVERIFY "sslverify" |
212aefaa | 58 | #define CURL_BLOCK_OPT_TIMEOUT "timeout" |
a94f83d9 | 59 | #define CURL_BLOCK_OPT_COOKIE "cookie" |
327c8ebd | 60 | #define CURL_BLOCK_OPT_COOKIE_SECRET "cookie-secret" |
1bff9606 DB |
61 | #define CURL_BLOCK_OPT_USERNAME "username" |
62 | #define CURL_BLOCK_OPT_PASSWORD_SECRET "password-secret" | |
63 | #define CURL_BLOCK_OPT_PROXY_USERNAME "proxy-username" | |
64 | #define CURL_BLOCK_OPT_PROXY_PASSWORD_SECRET "proxy-password-secret" | |
e3542c67 | 65 | |
712b64e8 HR |
66 | #define CURL_BLOCK_OPT_READAHEAD_DEFAULT (256 * 1024) |
67 | #define CURL_BLOCK_OPT_SSLVERIFY_DEFAULT true | |
68 | #define CURL_BLOCK_OPT_TIMEOUT_DEFAULT 5 | |
69 | ||
769ce76d | 70 | struct BDRVCURLState; |
04878616 | 71 | struct CURLState; |
769ce76d | 72 | |
2d25964d JC |
73 | static bool libcurl_initialized; |
74 | ||
769ce76d | 75 | typedef struct CURLAIOCB { |
28256d82 | 76 | Coroutine *co; |
769ce76d | 77 | QEMUIOVector *qiov; |
363c3c85 | 78 | |
2125e5ea PB |
79 | uint64_t offset; |
80 | uint64_t bytes; | |
28256d82 | 81 | int ret; |
363c3c85 | 82 | |
769ce76d AG |
83 | size_t start; |
84 | size_t end; | |
85 | } CURLAIOCB; | |
86 | ||
ff5ca166 HR |
87 | typedef struct CURLSocket { |
88 | int fd; | |
3663dca4 | 89 | struct BDRVCURLState *s; |
ff5ca166 HR |
90 | } CURLSocket; |
91 | ||
769ce76d AG |
92 | typedef struct CURLState |
93 | { | |
94 | struct BDRVCURLState *s; | |
95 | CURLAIOCB *acb[CURL_NUM_ACB]; | |
96 | CURL *curl; | |
97 | char *orig_buf; | |
2125e5ea | 98 | uint64_t buf_start; |
769ce76d AG |
99 | size_t buf_off; |
100 | size_t buf_len; | |
101 | char range[128]; | |
102 | char errmsg[CURL_ERROR_SIZE]; | |
103 | char in_use; | |
104 | } CURLState; | |
105 | ||
106 | typedef struct BDRVCURLState { | |
107 | CURLM *multi; | |
031fd1be | 108 | QEMUTimer timer; |
2125e5ea | 109 | uint64_t len; |
769ce76d | 110 | CURLState states[CURL_NUM_STATES]; |
0f418a20 | 111 | GHashTable *sockets; /* GINT_TO_POINTER(fd) -> socket */ |
769ce76d | 112 | char *url; |
c76f4952 | 113 | size_t readahead_size; |
97a3ea57 | 114 | bool sslverify; |
f76faeda | 115 | uint64_t timeout; |
a94f83d9 | 116 | char *cookie; |
3494d650 | 117 | bool accept_range; |
63f0f45f | 118 | AioContext *aio_context; |
ba3186c4 | 119 | QemuMutex mutex; |
709f2132 | 120 | CoQueue free_state_waitq; |
1bff9606 DB |
121 | char *username; |
122 | char *password; | |
123 | char *proxyusername; | |
124 | char *proxypassword; | |
769ce76d AG |
125 | } BDRVCURLState; |
126 | ||
127 | static void curl_clean_state(CURLState *s); | |
128 | static void curl_multi_do(void *arg); | |
129 | ||
0f418a20 HR |
130 | static gboolean curl_drop_socket(void *key, void *value, void *opaque) |
131 | { | |
132 | CURLSocket *socket = value; | |
133 | BDRVCURLState *s = socket->s; | |
134 | ||
60f782b6 | 135 | aio_set_fd_handler(s->aio_context, socket->fd, |
826cc324 | 136 | NULL, NULL, NULL, NULL, NULL); |
0f418a20 HR |
137 | return true; |
138 | } | |
139 | ||
140 | static void curl_drop_all_sockets(GHashTable *sockets) | |
141 | { | |
142 | g_hash_table_foreach_remove(sockets, curl_drop_socket, NULL); | |
143 | } | |
144 | ||
34db05e7 | 145 | /* Called from curl_multi_do_locked, with s->mutex held. */ |
031fd1be PM |
146 | static int curl_timer_cb(CURLM *multi, long timeout_ms, void *opaque) |
147 | { | |
148 | BDRVCURLState *s = opaque; | |
149 | ||
ed2a66de | 150 | trace_curl_timer_cb(timeout_ms); |
031fd1be PM |
151 | if (timeout_ms == -1) { |
152 | timer_del(&s->timer); | |
153 | } else { | |
154 | int64_t timeout_ns = (int64_t)timeout_ms * 1000 * 1000; | |
155 | timer_mod(&s->timer, | |
156 | qemu_clock_get_ns(QEMU_CLOCK_REALTIME) + timeout_ns); | |
157 | } | |
158 | return 0; | |
159 | } | |
031fd1be | 160 | |
34db05e7 | 161 | /* Called from curl_multi_do_locked, with s->mutex held. */ |
769ce76d | 162 | static int curl_sock_cb(CURL *curl, curl_socket_t fd, int action, |
63f0f45f | 163 | void *userp, void *sp) |
769ce76d | 164 | { |
63f0f45f | 165 | BDRVCURLState *s; |
838ef602 | 166 | CURLState *state = NULL; |
ff5ca166 HR |
167 | CURLSocket *socket; |
168 | ||
838ef602 | 169 | curl_easy_getinfo(curl, CURLINFO_PRIVATE, (char **)&state); |
63f0f45f | 170 | s = state->s; |
838ef602 | 171 | |
0f418a20 | 172 | socket = g_hash_table_lookup(s->sockets, GINT_TO_POINTER(fd)); |
ff5ca166 HR |
173 | if (!socket) { |
174 | socket = g_new0(CURLSocket, 1); | |
175 | socket->fd = fd; | |
3663dca4 | 176 | socket->s = s; |
0f418a20 | 177 | g_hash_table_insert(s->sockets, GINT_TO_POINTER(fd), socket); |
ff5ca166 | 178 | } |
ff5ca166 | 179 | |
ed2a66de | 180 | trace_curl_sock_cb(action, (int)fd); |
769ce76d AG |
181 | switch (action) { |
182 | case CURL_POLL_IN: | |
60f782b6 | 183 | aio_set_fd_handler(s->aio_context, fd, |
826cc324 | 184 | curl_multi_do, NULL, NULL, NULL, socket); |
769ce76d AG |
185 | break; |
186 | case CURL_POLL_OUT: | |
60f782b6 | 187 | aio_set_fd_handler(s->aio_context, fd, |
826cc324 | 188 | NULL, curl_multi_do, NULL, NULL, socket); |
769ce76d AG |
189 | break; |
190 | case CURL_POLL_INOUT: | |
60f782b6 | 191 | aio_set_fd_handler(s->aio_context, fd, |
826cc324 SH |
192 | curl_multi_do, curl_multi_do, |
193 | NULL, NULL, socket); | |
769ce76d AG |
194 | break; |
195 | case CURL_POLL_REMOVE: | |
60f782b6 | 196 | aio_set_fd_handler(s->aio_context, fd, |
826cc324 | 197 | NULL, NULL, NULL, NULL, NULL); |
769ce76d AG |
198 | break; |
199 | } | |
200 | ||
007f339b | 201 | if (action == CURL_POLL_REMOVE) { |
0f418a20 | 202 | g_hash_table_remove(s->sockets, GINT_TO_POINTER(fd)); |
007f339b HR |
203 | } |
204 | ||
769ce76d AG |
205 | return 0; |
206 | } | |
207 | ||
34db05e7 | 208 | /* Called from curl_multi_do_locked, with s->mutex held. */ |
3494d650 | 209 | static size_t curl_header_cb(void *ptr, size_t size, size_t nmemb, void *opaque) |
769ce76d | 210 | { |
3494d650 | 211 | BDRVCURLState *s = opaque; |
769ce76d | 212 | size_t realsize = size * nmemb; |
7788a319 DE |
213 | const char *header = (char *)ptr; |
214 | const char *end = header + realsize; | |
69032253 | 215 | const char *accept_ranges = "accept-ranges:"; |
7788a319 | 216 | const char *bytes = "bytes"; |
769ce76d | 217 | |
7788a319 | 218 | if (realsize >= strlen(accept_ranges) |
69032253 DE |
219 | && g_ascii_strncasecmp(header, accept_ranges, |
220 | strlen(accept_ranges)) == 0) { | |
7788a319 DE |
221 | |
222 | char *p = strchr(header, ':') + 1; | |
223 | ||
224 | /* Skip whitespace between the header name and value. */ | |
225 | while (p < end && *p && g_ascii_isspace(*p)) { | |
226 | p++; | |
227 | } | |
228 | ||
229 | if (end - p >= strlen(bytes) | |
230 | && strncmp(p, bytes, strlen(bytes)) == 0) { | |
231 | ||
232 | /* Check that there is nothing but whitespace after the value. */ | |
233 | p += strlen(bytes); | |
234 | while (p < end && *p && g_ascii_isspace(*p)) { | |
235 | p++; | |
236 | } | |
237 | ||
238 | if (p == end || !*p) { | |
239 | s->accept_range = true; | |
240 | } | |
241 | } | |
0bfcd599 | 242 | } |
769ce76d AG |
243 | |
244 | return realsize; | |
245 | } | |
246 | ||
34db05e7 | 247 | /* Called from curl_multi_do_locked, with s->mutex held. */ |
769ce76d AG |
248 | static size_t curl_read_cb(void *ptr, size_t size, size_t nmemb, void *opaque) |
249 | { | |
250 | CURLState *s = ((CURLState*)opaque); | |
251 | size_t realsize = size * nmemb; | |
769ce76d | 252 | |
ed2a66de | 253 | trace_curl_read_cb(realsize); |
769ce76d | 254 | |
4e767657 HR |
255 | if (!s || !s->orig_buf) { |
256 | goto read_end; | |
257 | } | |
769ce76d | 258 | |
6d4b9e55 FZ |
259 | if (s->buf_off >= s->buf_len) { |
260 | /* buffer full, read nothing */ | |
4e767657 | 261 | goto read_end; |
6d4b9e55 FZ |
262 | } |
263 | realsize = MIN(realsize, s->buf_len - s->buf_off); | |
769ce76d AG |
264 | memcpy(s->orig_buf + s->buf_off, ptr, realsize); |
265 | s->buf_off += realsize; | |
266 | ||
4e767657 HR |
267 | read_end: |
268 | /* curl will error out if we do not return this value */ | |
269 | return size * nmemb; | |
769ce76d AG |
270 | } |
271 | ||
456af346 | 272 | /* Called with s->mutex held. */ |
28256d82 PB |
273 | static bool curl_find_buf(BDRVCURLState *s, uint64_t start, uint64_t len, |
274 | CURLAIOCB *acb) | |
769ce76d AG |
275 | { |
276 | int i; | |
2125e5ea PB |
277 | uint64_t end = start + len; |
278 | uint64_t clamped_end = MIN(end, s->len); | |
279 | uint64_t clamped_len = clamped_end - start; | |
769ce76d AG |
280 | |
281 | for (i=0; i<CURL_NUM_STATES; i++) { | |
282 | CURLState *state = &s->states[i]; | |
2125e5ea PB |
283 | uint64_t buf_end = (state->buf_start + state->buf_off); |
284 | uint64_t buf_fend = (state->buf_start + state->buf_len); | |
769ce76d AG |
285 | |
286 | if (!state->orig_buf) | |
287 | continue; | |
288 | if (!state->buf_off) | |
289 | continue; | |
290 | ||
291 | // Does the existing buffer cover our section? | |
292 | if ((start >= state->buf_start) && | |
293 | (start <= buf_end) && | |
4e504535 HR |
294 | (clamped_end >= state->buf_start) && |
295 | (clamped_end <= buf_end)) | |
769ce76d AG |
296 | { |
297 | char *buf = state->orig_buf + (start - state->buf_start); | |
298 | ||
4e504535 HR |
299 | qemu_iovec_from_buf(acb->qiov, 0, buf, clamped_len); |
300 | if (clamped_len < len) { | |
301 | qemu_iovec_memset(acb->qiov, clamped_len, 0, len - clamped_len); | |
302 | } | |
28256d82 PB |
303 | acb->ret = 0; |
304 | return true; | |
769ce76d AG |
305 | } |
306 | ||
307 | // Wait for unfinished chunks | |
b7079df4 MB |
308 | if (state->in_use && |
309 | (start >= state->buf_start) && | |
769ce76d | 310 | (start <= buf_fend) && |
4e504535 HR |
311 | (clamped_end >= state->buf_start) && |
312 | (clamped_end <= buf_fend)) | |
769ce76d AG |
313 | { |
314 | int j; | |
315 | ||
316 | acb->start = start - state->buf_start; | |
4e504535 | 317 | acb->end = acb->start + clamped_len; |
769ce76d AG |
318 | |
319 | for (j=0; j<CURL_NUM_ACB; j++) { | |
320 | if (!state->acb[j]) { | |
321 | state->acb[j] = acb; | |
28256d82 | 322 | return true; |
769ce76d AG |
323 | } |
324 | } | |
325 | } | |
326 | } | |
327 | ||
28256d82 | 328 | return false; |
769ce76d AG |
329 | } |
330 | ||
ba3186c4 | 331 | /* Called with s->mutex held. */ |
838ef602 | 332 | static void curl_multi_check_completion(BDRVCURLState *s) |
769ce76d | 333 | { |
769ce76d AG |
334 | int msgs_in_queue; |
335 | ||
769ce76d AG |
336 | /* Try to find done transfers, so we can free the easy |
337 | * handle again. */ | |
1f2cead3 | 338 | for (;;) { |
769ce76d AG |
339 | CURLMsg *msg; |
340 | msg = curl_multi_info_read(s->multi, &msgs_in_queue); | |
341 | ||
1f2cead3 | 342 | /* Quit when there are no more completions */ |
769ce76d AG |
343 | if (!msg) |
344 | break; | |
769ce76d | 345 | |
1f2cead3 | 346 | if (msg->msg == CURLMSG_DONE) { |
bfb23b48 | 347 | int i; |
1f2cead3 | 348 | CURLState *state = NULL; |
bfb23b48 HR |
349 | bool error = msg->data.result != CURLE_OK; |
350 | ||
1f2cead3 MB |
351 | curl_easy_getinfo(msg->easy_handle, CURLINFO_PRIVATE, |
352 | (char **)&state); | |
353 | ||
bfb23b48 | 354 | if (error) { |
796a060b RJ |
355 | static int errcount = 100; |
356 | ||
357 | /* Don't lose the original error message from curl, since | |
358 | * it contains extra data. | |
359 | */ | |
360 | if (errcount > 0) { | |
361 | error_report("curl: %s", state->errmsg); | |
362 | if (--errcount == 0) { | |
363 | error_report("curl: further errors suppressed"); | |
364 | } | |
365 | } | |
bfb23b48 | 366 | } |
796a060b | 367 | |
bfb23b48 HR |
368 | for (i = 0; i < CURL_NUM_ACB; i++) { |
369 | CURLAIOCB *acb = state->acb[i]; | |
1f2cead3 | 370 | |
bfb23b48 HR |
371 | if (acb == NULL) { |
372 | continue; | |
373 | } | |
374 | ||
375 | if (!error) { | |
376 | /* Assert that we have read all data */ | |
377 | assert(state->buf_off >= acb->end); | |
378 | ||
379 | qemu_iovec_from_buf(acb->qiov, 0, | |
380 | state->orig_buf + acb->start, | |
381 | acb->end - acb->start); | |
f785a5ae | 382 | |
bfb23b48 HR |
383 | if (acb->end - acb->start < acb->bytes) { |
384 | size_t offset = acb->end - acb->start; | |
385 | qemu_iovec_memset(acb->qiov, offset, 0, | |
386 | acb->bytes - offset); | |
387 | } | |
1f2cead3 | 388 | } |
bfb23b48 HR |
389 | |
390 | acb->ret = error ? -EIO : 0; | |
391 | state->acb[i] = NULL; | |
392 | qemu_mutex_unlock(&s->mutex); | |
393 | aio_co_wake(acb->co); | |
394 | qemu_mutex_lock(&s->mutex); | |
769ce76d | 395 | } |
1f2cead3 MB |
396 | |
397 | curl_clean_state(state); | |
398 | break; | |
769ce76d | 399 | } |
1f2cead3 | 400 | } |
769ce76d AG |
401 | } |
402 | ||
ba3186c4 | 403 | /* Called with s->mutex held. */ |
9abaf9fc | 404 | static void curl_multi_do_locked(CURLSocket *socket) |
031fd1be | 405 | { |
3663dca4 | 406 | BDRVCURLState *s = socket->s; |
031fd1be PM |
407 | int running; |
408 | int r; | |
409 | ||
9abaf9fc | 410 | if (!s->multi) { |
031fd1be PM |
411 | return; |
412 | } | |
413 | ||
9abaf9fc HR |
414 | do { |
415 | r = curl_multi_socket_action(s->multi, socket->fd, 0, &running); | |
416 | } while (r == CURLM_CALL_MULTI_PERFORM); | |
838ef602 MB |
417 | } |
418 | ||
9d456654 PB |
419 | static void curl_multi_do(void *arg) |
420 | { | |
9dbad87d | 421 | CURLSocket *socket = arg; |
3663dca4 | 422 | BDRVCURLState *s = socket->s; |
9d456654 | 423 | |
9dbad87d HR |
424 | qemu_mutex_lock(&s->mutex); |
425 | curl_multi_do_locked(socket); | |
426 | curl_multi_check_completion(s); | |
427 | qemu_mutex_unlock(&s->mutex); | |
031fd1be PM |
428 | } |
429 | ||
430 | static void curl_multi_timeout_do(void *arg) | |
431 | { | |
031fd1be PM |
432 | BDRVCURLState *s = (BDRVCURLState *)arg; |
433 | int running; | |
434 | ||
435 | if (!s->multi) { | |
436 | return; | |
437 | } | |
438 | ||
ba3186c4 | 439 | qemu_mutex_lock(&s->mutex); |
031fd1be PM |
440 | curl_multi_socket_action(s->multi, CURL_SOCKET_TIMEOUT, 0, &running); |
441 | ||
838ef602 | 442 | curl_multi_check_completion(s); |
ba3186c4 | 443 | qemu_mutex_unlock(&s->mutex); |
031fd1be PM |
444 | } |
445 | ||
456af346 | 446 | /* Called with s->mutex held. */ |
3ce6a729 | 447 | static CURLState *curl_find_state(BDRVCURLState *s) |
769ce76d AG |
448 | { |
449 | CURLState *state = NULL; | |
3ce6a729 | 450 | int i; |
769ce76d | 451 | |
3ce6a729 PB |
452 | for (i = 0; i < CURL_NUM_STATES; i++) { |
453 | if (!s->states[i].in_use) { | |
769ce76d AG |
454 | state = &s->states[i]; |
455 | state->in_use = 1; | |
456 | break; | |
457 | } | |
3ce6a729 PB |
458 | } |
459 | return state; | |
460 | } | |
769ce76d | 461 | |
3ce6a729 PB |
462 | static int curl_init_state(BDRVCURLState *s, CURLState *state) |
463 | { | |
9e550b32 MB |
464 | if (!state->curl) { |
465 | state->curl = curl_easy_init(); | |
466 | if (!state->curl) { | |
3ce6a729 | 467 | return -EIO; |
9e550b32 | 468 | } |
b0ea6c98 PM |
469 | if (curl_easy_setopt(state->curl, CURLOPT_URL, s->url) || |
470 | curl_easy_setopt(state->curl, CURLOPT_SSL_VERIFYPEER, | |
471 | (long) s->sslverify) || | |
472 | curl_easy_setopt(state->curl, CURLOPT_SSL_VERIFYHOST, | |
473 | s->sslverify ? 2L : 0L)) { | |
474 | goto err; | |
475 | } | |
a94f83d9 | 476 | if (s->cookie) { |
b0ea6c98 PM |
477 | if (curl_easy_setopt(state->curl, CURLOPT_COOKIE, s->cookie)) { |
478 | goto err; | |
479 | } | |
480 | } | |
481 | if (curl_easy_setopt(state->curl, CURLOPT_TIMEOUT, (long)s->timeout) || | |
482 | curl_easy_setopt(state->curl, CURLOPT_WRITEFUNCTION, | |
483 | (void *)curl_read_cb) || | |
484 | curl_easy_setopt(state->curl, CURLOPT_WRITEDATA, (void *)state) || | |
485 | curl_easy_setopt(state->curl, CURLOPT_PRIVATE, (void *)state) || | |
486 | curl_easy_setopt(state->curl, CURLOPT_AUTOREFERER, 1) || | |
487 | curl_easy_setopt(state->curl, CURLOPT_FOLLOWLOCATION, 1) || | |
488 | curl_easy_setopt(state->curl, CURLOPT_NOSIGNAL, 1) || | |
489 | curl_easy_setopt(state->curl, CURLOPT_ERRORBUFFER, state->errmsg) || | |
490 | curl_easy_setopt(state->curl, CURLOPT_FAILONERROR, 1)) { | |
491 | goto err; | |
a94f83d9 | 492 | } |
1bff9606 | 493 | if (s->username) { |
b0ea6c98 PM |
494 | if (curl_easy_setopt(state->curl, CURLOPT_USERNAME, s->username)) { |
495 | goto err; | |
496 | } | |
1bff9606 DB |
497 | } |
498 | if (s->password) { | |
b0ea6c98 PM |
499 | if (curl_easy_setopt(state->curl, CURLOPT_PASSWORD, s->password)) { |
500 | goto err; | |
501 | } | |
1bff9606 DB |
502 | } |
503 | if (s->proxyusername) { | |
b0ea6c98 PM |
504 | if (curl_easy_setopt(state->curl, |
505 | CURLOPT_PROXYUSERNAME, s->proxyusername)) { | |
506 | goto err; | |
507 | } | |
1bff9606 DB |
508 | } |
509 | if (s->proxypassword) { | |
b0ea6c98 PM |
510 | if (curl_easy_setopt(state->curl, |
511 | CURLOPT_PROXYPASSWORD, s->proxypassword)) { | |
512 | goto err; | |
513 | } | |
1bff9606 DB |
514 | } |
515 | ||
9e550b32 MB |
516 | /* Restrict supported protocols to avoid security issues in the more |
517 | * obscure protocols. For example, do not allow POP3/SMTP/IMAP see | |
518 | * CVE-2013-0249. | |
519 | * | |
e7b8d9d0 AJ |
520 | * Restricting protocols is only supported from 7.19.4 upwards. Note: |
521 | * version 7.85.0 deprecates CURLOPT_*PROTOCOLS in favour of a string | |
522 | * based CURLOPT_*PROTOCOLS_STR API. | |
9e550b32 | 523 | */ |
e7b8d9d0 AJ |
524 | #if LIBCURL_VERSION_NUM >= 0x075500 |
525 | if (curl_easy_setopt(state->curl, | |
526 | CURLOPT_PROTOCOLS_STR, PROTOCOLS) || | |
527 | curl_easy_setopt(state->curl, | |
528 | CURLOPT_REDIR_PROTOCOLS_STR, PROTOCOLS)) { | |
529 | goto err; | |
530 | } | |
531 | #elif LIBCURL_VERSION_NUM >= 0x071304 | |
b0ea6c98 PM |
532 | if (curl_easy_setopt(state->curl, CURLOPT_PROTOCOLS, PROTOCOLS) || |
533 | curl_easy_setopt(state->curl, CURLOPT_REDIR_PROTOCOLS, PROTOCOLS)) { | |
534 | goto err; | |
535 | } | |
8a8f5840 | 536 | #endif |
fb6d1bbd | 537 | |
769ce76d | 538 | #ifdef DEBUG_VERBOSE |
b0ea6c98 PM |
539 | if (curl_easy_setopt(state->curl, CURLOPT_VERBOSE, 1)) { |
540 | goto err; | |
541 | } | |
769ce76d | 542 | #endif |
9e550b32 | 543 | } |
769ce76d AG |
544 | |
545 | state->s = s; | |
546 | ||
3ce6a729 | 547 | return 0; |
b0ea6c98 PM |
548 | |
549 | err: | |
550 | curl_easy_cleanup(state->curl); | |
551 | state->curl = NULL; | |
552 | return -EIO; | |
769ce76d AG |
553 | } |
554 | ||
456af346 | 555 | /* Called with s->mutex held. */ |
769ce76d AG |
556 | static void curl_clean_state(CURLState *s) |
557 | { | |
675a7756 PB |
558 | int j; |
559 | for (j = 0; j < CURL_NUM_ACB; j++) { | |
560 | assert(!s->acb[j]); | |
561 | } | |
562 | ||
769ce76d AG |
563 | if (s->s->multi) |
564 | curl_multi_remove_handle(s->s->multi, s->curl); | |
ff5ca166 | 565 | |
769ce76d | 566 | s->in_use = 0; |
2bb5c936 | 567 | |
709f2132 | 568 | qemu_co_enter_next(&s->s->free_state_waitq, &s->s->mutex); |
769ce76d AG |
569 | } |
570 | ||
8e6d58cd KW |
571 | static void curl_parse_filename(const char *filename, QDict *options, |
572 | Error **errp) | |
769ce76d | 573 | { |
46f5ac20 | 574 | qdict_put_str(options, CURL_BLOCK_OPT_URL, filename); |
8e6d58cd KW |
575 | } |
576 | ||
63f0f45f SH |
577 | static void curl_detach_aio_context(BlockDriverState *bs) |
578 | { | |
579 | BDRVCURLState *s = bs->opaque; | |
580 | int i; | |
581 | ||
f5056b70 | 582 | WITH_QEMU_LOCK_GUARD(&s->mutex) { |
0f418a20 | 583 | curl_drop_all_sockets(s->sockets); |
f5056b70 GQ |
584 | for (i = 0; i < CURL_NUM_STATES; i++) { |
585 | if (s->states[i].in_use) { | |
586 | curl_clean_state(&s->states[i]); | |
587 | } | |
588 | if (s->states[i].curl) { | |
589 | curl_easy_cleanup(s->states[i].curl); | |
590 | s->states[i].curl = NULL; | |
591 | } | |
592 | g_free(s->states[i].orig_buf); | |
593 | s->states[i].orig_buf = NULL; | |
63f0f45f | 594 | } |
f5056b70 GQ |
595 | if (s->multi) { |
596 | curl_multi_cleanup(s->multi); | |
597 | s->multi = NULL; | |
63f0f45f | 598 | } |
63f0f45f SH |
599 | } |
600 | ||
601 | timer_del(&s->timer); | |
602 | } | |
603 | ||
604 | static void curl_attach_aio_context(BlockDriverState *bs, | |
605 | AioContext *new_context) | |
606 | { | |
607 | BDRVCURLState *s = bs->opaque; | |
608 | ||
609 | aio_timer_init(new_context, &s->timer, | |
610 | QEMU_CLOCK_REALTIME, SCALE_NS, | |
611 | curl_multi_timeout_do, s); | |
612 | ||
613 | assert(!s->multi); | |
614 | s->multi = curl_multi_init(); | |
615 | s->aio_context = new_context; | |
616 | curl_multi_setopt(s->multi, CURLMOPT_SOCKETFUNCTION, curl_sock_cb); | |
63f0f45f SH |
617 | curl_multi_setopt(s->multi, CURLMOPT_TIMERDATA, s); |
618 | curl_multi_setopt(s->multi, CURLMOPT_TIMERFUNCTION, curl_timer_cb); | |
63f0f45f SH |
619 | } |
620 | ||
8e6d58cd KW |
621 | static QemuOptsList runtime_opts = { |
622 | .name = "curl", | |
623 | .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head), | |
624 | .desc = { | |
625 | { | |
e3542c67 | 626 | .name = CURL_BLOCK_OPT_URL, |
8e6d58cd KW |
627 | .type = QEMU_OPT_STRING, |
628 | .help = "URL to open", | |
629 | }, | |
630 | { | |
e3542c67 | 631 | .name = CURL_BLOCK_OPT_READAHEAD, |
8e6d58cd KW |
632 | .type = QEMU_OPT_SIZE, |
633 | .help = "Readahead size", | |
634 | }, | |
97a3ea57 MB |
635 | { |
636 | .name = CURL_BLOCK_OPT_SSLVERIFY, | |
637 | .type = QEMU_OPT_BOOL, | |
638 | .help = "Verify SSL certificate" | |
639 | }, | |
212aefaa DHB |
640 | { |
641 | .name = CURL_BLOCK_OPT_TIMEOUT, | |
642 | .type = QEMU_OPT_NUMBER, | |
643 | .help = "Curl timeout" | |
644 | }, | |
a94f83d9 RJ |
645 | { |
646 | .name = CURL_BLOCK_OPT_COOKIE, | |
647 | .type = QEMU_OPT_STRING, | |
648 | .help = "Pass the cookie or list of cookies with each request" | |
649 | }, | |
327c8ebd PK |
650 | { |
651 | .name = CURL_BLOCK_OPT_COOKIE_SECRET, | |
652 | .type = QEMU_OPT_STRING, | |
653 | .help = "ID of secret used as cookie passed with each request" | |
654 | }, | |
1bff9606 DB |
655 | { |
656 | .name = CURL_BLOCK_OPT_USERNAME, | |
657 | .type = QEMU_OPT_STRING, | |
658 | .help = "Username for HTTP auth" | |
659 | }, | |
660 | { | |
661 | .name = CURL_BLOCK_OPT_PASSWORD_SECRET, | |
662 | .type = QEMU_OPT_STRING, | |
663 | .help = "ID of secret used as password for HTTP auth", | |
664 | }, | |
665 | { | |
666 | .name = CURL_BLOCK_OPT_PROXY_USERNAME, | |
667 | .type = QEMU_OPT_STRING, | |
668 | .help = "Username for HTTP proxy auth" | |
669 | }, | |
670 | { | |
671 | .name = CURL_BLOCK_OPT_PROXY_PASSWORD_SECRET, | |
672 | .type = QEMU_OPT_STRING, | |
673 | .help = "ID of secret used as password for HTTP proxy auth", | |
674 | }, | |
8e6d58cd KW |
675 | { /* end of list */ } |
676 | }, | |
677 | }; | |
678 | ||
1bff9606 | 679 | |
015a1036 HR |
680 | static int curl_open(BlockDriverState *bs, QDict *options, int flags, |
681 | Error **errp) | |
8e6d58cd KW |
682 | { |
683 | BDRVCURLState *s = bs->opaque; | |
684 | CURLState *state = NULL; | |
685 | QemuOpts *opts; | |
8e6d58cd | 686 | const char *file; |
a94f83d9 | 687 | const char *cookie; |
327c8ebd | 688 | const char *cookie_secret; |
e7b8d9d0 AJ |
689 | /* CURL >= 7.55.0 uses curl_off_t for content length instead of a double */ |
690 | #if LIBCURL_VERSION_NUM >= 0x073700 | |
691 | curl_off_t cl; | |
692 | #else | |
693 | double cl; | |
694 | #endif | |
1bff9606 | 695 | const char *secretid; |
34634ca2 | 696 | const char *protocol_delimiter; |
2d25964d | 697 | int ret; |
8e6d58cd | 698 | |
6ceef36a KW |
699 | ret = bdrv_apply_auto_read_only(bs, "curl driver does not support writes", |
700 | errp); | |
701 | if (ret < 0) { | |
702 | return ret; | |
a7cea2ba RJ |
703 | } |
704 | ||
2d25964d JC |
705 | if (!libcurl_initialized) { |
706 | ret = curl_global_init(CURL_GLOBAL_ALL); | |
707 | if (ret) { | |
708 | error_setg(errp, "libcurl initialization failed with %d", ret); | |
709 | return -EIO; | |
710 | } | |
711 | libcurl_initialized = true; | |
712 | } | |
713 | ||
456af346 | 714 | qemu_mutex_init(&s->mutex); |
87ea75d5 | 715 | opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort); |
668f62ec | 716 | if (!qemu_opts_absorb_qdict(opts, options, errp)) { |
8e6d58cd KW |
717 | goto out_noclean; |
718 | } | |
719 | ||
e3542c67 | 720 | s->readahead_size = qemu_opt_get_size(opts, CURL_BLOCK_OPT_READAHEAD, |
712b64e8 | 721 | CURL_BLOCK_OPT_READAHEAD_DEFAULT); |
c76f4952 | 722 | if ((s->readahead_size & 0x1ff) != 0) { |
2a94fee3 PB |
723 | error_setg(errp, "HTTP_READAHEAD_SIZE %zd is not a multiple of 512", |
724 | s->readahead_size); | |
c76f4952 N |
725 | goto out_noclean; |
726 | } | |
727 | ||
212aefaa | 728 | s->timeout = qemu_opt_get_number(opts, CURL_BLOCK_OPT_TIMEOUT, |
712b64e8 | 729 | CURL_BLOCK_OPT_TIMEOUT_DEFAULT); |
f76faeda RJ |
730 | if (s->timeout > CURL_TIMEOUT_MAX) { |
731 | error_setg(errp, "timeout parameter is too large or negative"); | |
732 | goto out_noclean; | |
733 | } | |
212aefaa | 734 | |
712b64e8 HR |
735 | s->sslverify = qemu_opt_get_bool(opts, CURL_BLOCK_OPT_SSLVERIFY, |
736 | CURL_BLOCK_OPT_SSLVERIFY_DEFAULT); | |
97a3ea57 | 737 | |
a94f83d9 | 738 | cookie = qemu_opt_get(opts, CURL_BLOCK_OPT_COOKIE); |
327c8ebd PK |
739 | cookie_secret = qemu_opt_get(opts, CURL_BLOCK_OPT_COOKIE_SECRET); |
740 | ||
741 | if (cookie && cookie_secret) { | |
742 | error_setg(errp, | |
743 | "curl driver cannot handle both cookie and cookie secret"); | |
744 | goto out_noclean; | |
745 | } | |
746 | ||
747 | if (cookie_secret) { | |
748 | s->cookie = qcrypto_secret_lookup_as_utf8(cookie_secret, errp); | |
749 | if (!s->cookie) { | |
750 | goto out_noclean; | |
751 | } | |
752 | } else { | |
753 | s->cookie = g_strdup(cookie); | |
754 | } | |
a94f83d9 | 755 | |
e3542c67 | 756 | file = qemu_opt_get(opts, CURL_BLOCK_OPT_URL); |
8e6d58cd | 757 | if (file == NULL) { |
2a94fee3 | 758 | error_setg(errp, "curl block driver requires an 'url' option"); |
8e6d58cd KW |
759 | goto out_noclean; |
760 | } | |
761 | ||
34634ca2 HR |
762 | if (!strstart(file, bs->drv->protocol_name, &protocol_delimiter) || |
763 | !strstart(protocol_delimiter, "://", NULL)) | |
764 | { | |
765 | error_setg(errp, "%s curl driver cannot handle the URL '%s' (does not " | |
766 | "start with '%s://')", bs->drv->protocol_name, file, | |
767 | bs->drv->protocol_name); | |
768 | goto out_noclean; | |
769 | } | |
770 | ||
1bff9606 DB |
771 | s->username = g_strdup(qemu_opt_get(opts, CURL_BLOCK_OPT_USERNAME)); |
772 | secretid = qemu_opt_get(opts, CURL_BLOCK_OPT_PASSWORD_SECRET); | |
773 | ||
774 | if (secretid) { | |
775 | s->password = qcrypto_secret_lookup_as_utf8(secretid, errp); | |
776 | if (!s->password) { | |
777 | goto out_noclean; | |
778 | } | |
779 | } | |
780 | ||
781 | s->proxyusername = g_strdup( | |
782 | qemu_opt_get(opts, CURL_BLOCK_OPT_PROXY_USERNAME)); | |
783 | secretid = qemu_opt_get(opts, CURL_BLOCK_OPT_PROXY_PASSWORD_SECRET); | |
784 | if (secretid) { | |
785 | s->proxypassword = qcrypto_secret_lookup_as_utf8(secretid, errp); | |
786 | if (!s->proxypassword) { | |
787 | goto out_noclean; | |
788 | } | |
789 | } | |
790 | ||
ed2a66de | 791 | trace_curl_open(file); |
709f2132 | 792 | qemu_co_queue_init(&s->free_state_waitq); |
63f0f45f | 793 | s->aio_context = bdrv_get_aio_context(bs); |
8e6d58cd | 794 | s->url = g_strdup(file); |
0f418a20 | 795 | s->sockets = g_hash_table_new_full(NULL, NULL, NULL, g_free); |
456af346 | 796 | qemu_mutex_lock(&s->mutex); |
3ce6a729 | 797 | state = curl_find_state(s); |
456af346 | 798 | qemu_mutex_unlock(&s->mutex); |
3ce6a729 | 799 | if (!state) { |
769ce76d | 800 | goto out_noclean; |
3ce6a729 | 801 | } |
769ce76d AG |
802 | |
803 | // Get file size | |
804 | ||
3ce6a729 | 805 | if (curl_init_state(s, state) < 0) { |
2ea7dfcd PM |
806 | pstrcpy(state->errmsg, CURL_ERROR_SIZE, |
807 | "curl library initialization failed."); | |
3ce6a729 PB |
808 | goto out; |
809 | } | |
810 | ||
3494d650 | 811 | s->accept_range = false; |
b0ea6c98 PM |
812 | if (curl_easy_setopt(state->curl, CURLOPT_NOBODY, 1) || |
813 | curl_easy_setopt(state->curl, CURLOPT_HEADERFUNCTION, curl_header_cb) || | |
814 | curl_easy_setopt(state->curl, CURLOPT_HEADERDATA, s)) { | |
815 | pstrcpy(state->errmsg, CURL_ERROR_SIZE, | |
816 | "curl library initialization failed."); | |
817 | goto out; | |
818 | } | |
769ce76d AG |
819 | if (curl_easy_perform(state->curl)) |
820 | goto out; | |
e7b8d9d0 AJ |
821 | /* CURL 7.55.0 deprecates CURLINFO_CONTENT_LENGTH_DOWNLOAD in favour of |
822 | * the *_T version which returns a more sensible type for content length. | |
823 | */ | |
824 | #if LIBCURL_VERSION_NUM >= 0x073700 | |
825 | if (curl_easy_getinfo(state->curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD_T, &cl)) { | |
826 | goto out; | |
827 | } | |
828 | #else | |
829 | if (curl_easy_getinfo(state->curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &cl)) { | |
769ce76d | 830 | goto out; |
a41c4578 | 831 | } |
e7b8d9d0 | 832 | #endif |
a41c4578 TG |
833 | /* Prior CURL 7.19.4 return value of 0 could mean that the file size is not |
834 | * know or the size is zero. From 7.19.4 CURL returns -1 if size is not | |
50d6a8a3 | 835 | * known and zero if it is really zero-length file. */ |
a41c4578 | 836 | #if LIBCURL_VERSION_NUM >= 0x071304 |
e7b8d9d0 | 837 | if (cl < 0) { |
a41c4578 TG |
838 | pstrcpy(state->errmsg, CURL_ERROR_SIZE, |
839 | "Server didn't report file size."); | |
840 | goto out; | |
841 | } | |
842 | #else | |
e7b8d9d0 | 843 | if (cl <= 0) { |
a41c4578 TG |
844 | pstrcpy(state->errmsg, CURL_ERROR_SIZE, |
845 | "Unknown file size or zero-length file."); | |
846 | goto out; | |
847 | } | |
848 | #endif | |
849 | ||
e7b8d9d0 | 850 | s->len = cl; |
a41c4578 | 851 | |
3494d650 FZ |
852 | if ((!strncasecmp(s->url, "http://", strlen("http://")) |
853 | || !strncasecmp(s->url, "https://", strlen("https://"))) | |
854 | && !s->accept_range) { | |
855 | pstrcpy(state->errmsg, CURL_ERROR_SIZE, | |
856 | "Server does not support 'range' (byte ranges)."); | |
857 | goto out; | |
858 | } | |
ed2a66de | 859 | trace_curl_open_size(s->len); |
769ce76d | 860 | |
456af346 | 861 | qemu_mutex_lock(&s->mutex); |
769ce76d | 862 | curl_clean_state(state); |
456af346 | 863 | qemu_mutex_unlock(&s->mutex); |
769ce76d AG |
864 | curl_easy_cleanup(state->curl); |
865 | state->curl = NULL; | |
866 | ||
63f0f45f | 867 | curl_attach_aio_context(bs, bdrv_get_aio_context(bs)); |
769ce76d | 868 | |
8e6d58cd | 869 | qemu_opts_del(opts); |
769ce76d AG |
870 | return 0; |
871 | ||
872 | out: | |
acd7fdc6 | 873 | error_setg(errp, "CURL: Error opening file: %s", state->errmsg); |
769ce76d AG |
874 | curl_easy_cleanup(state->curl); |
875 | state->curl = NULL; | |
876 | out_noclean: | |
456af346 | 877 | qemu_mutex_destroy(&s->mutex); |
a94f83d9 | 878 | g_free(s->cookie); |
8e6d58cd | 879 | g_free(s->url); |
996922de JC |
880 | g_free(s->username); |
881 | g_free(s->proxyusername); | |
882 | g_free(s->proxypassword); | |
1e84cf79 HC |
883 | if (s->sockets) { |
884 | curl_drop_all_sockets(s->sockets); | |
885 | g_hash_table_destroy(s->sockets); | |
886 | } | |
8e6d58cd | 887 | qemu_opts_del(opts); |
769ce76d AG |
888 | return -EINVAL; |
889 | } | |
890 | ||
9bae2aca | 891 | static void coroutine_fn curl_setup_preadv(BlockDriverState *bs, CURLAIOCB *acb) |
769ce76d | 892 | { |
769ce76d | 893 | CURLState *state; |
b69cdef8 | 894 | int running; |
769ce76d | 895 | |
1919631e | 896 | BDRVCURLState *s = bs->opaque; |
769ce76d | 897 | |
2125e5ea PB |
898 | uint64_t start = acb->offset; |
899 | uint64_t end; | |
769ce76d | 900 | |
ba3186c4 | 901 | qemu_mutex_lock(&s->mutex); |
1919631e | 902 | |
769ce76d AG |
903 | // In case we have the requested data already (e.g. read-ahead), |
904 | // we can just call the callback and be done. | |
28256d82 PB |
905 | if (curl_find_buf(s, start, acb->bytes, acb)) { |
906 | goto out; | |
769ce76d AG |
907 | } |
908 | ||
909 | // No cache found, so let's start a new request | |
3ce6a729 PB |
910 | for (;;) { |
911 | state = curl_find_state(s); | |
912 | if (state) { | |
913 | break; | |
914 | } | |
709f2132 | 915 | qemu_co_queue_wait(&s->free_state_waitq, &s->mutex); |
3ce6a729 PB |
916 | } |
917 | ||
918 | if (curl_init_state(s, state) < 0) { | |
919 | curl_clean_state(state); | |
28256d82 | 920 | acb->ret = -EIO; |
1919631e | 921 | goto out; |
363c3c85 | 922 | } |
769ce76d AG |
923 | |
924 | acb->start = 0; | |
2125e5ea | 925 | acb->end = MIN(acb->bytes, s->len - start); |
769ce76d AG |
926 | |
927 | state->buf_off = 0; | |
f7047c2d | 928 | g_free(state->orig_buf); |
769ce76d | 929 | state->buf_start = start; |
4e504535 HR |
930 | state->buf_len = MIN(acb->end + s->readahead_size, s->len - start); |
931 | end = start + state->buf_len - 1; | |
8dc7a772 KW |
932 | state->orig_buf = g_try_malloc(state->buf_len); |
933 | if (state->buf_len && state->orig_buf == NULL) { | |
934 | curl_clean_state(state); | |
28256d82 | 935 | acb->ret = -ENOMEM; |
1919631e | 936 | goto out; |
8dc7a772 | 937 | } |
769ce76d AG |
938 | state->acb[0] = acb; |
939 | ||
2125e5ea | 940 | snprintf(state->range, 127, "%" PRIu64 "-%" PRIu64, start, end); |
ed2a66de | 941 | trace_curl_setup_preadv(acb->bytes, start, state->range); |
b0ea6c98 PM |
942 | if (curl_easy_setopt(state->curl, CURLOPT_RANGE, state->range) || |
943 | curl_multi_add_handle(s->multi, state->curl) != CURLM_OK) { | |
c34dc07f HR |
944 | state->acb[0] = NULL; |
945 | acb->ret = -EIO; | |
946 | ||
947 | curl_clean_state(state); | |
948 | goto out; | |
949 | } | |
769ce76d | 950 | |
b69cdef8 MB |
951 | /* Tell curl it needs to kick things off */ |
952 | curl_multi_socket_action(s->multi, CURL_SOCKET_TIMEOUT, 0, &running); | |
1919631e PB |
953 | |
954 | out: | |
ba3186c4 | 955 | qemu_mutex_unlock(&s->mutex); |
363c3c85 NT |
956 | } |
957 | ||
28256d82 | 958 | static int coroutine_fn curl_co_preadv(BlockDriverState *bs, |
f7ef38dd VSO |
959 | int64_t offset, int64_t bytes, QEMUIOVector *qiov, |
960 | BdrvRequestFlags flags) | |
363c3c85 | 961 | { |
28256d82 PB |
962 | CURLAIOCB acb = { |
963 | .co = qemu_coroutine_self(), | |
964 | .ret = -EINPROGRESS, | |
965 | .qiov = qiov, | |
966 | .offset = offset, | |
967 | .bytes = bytes | |
968 | }; | |
969 | ||
970 | curl_setup_preadv(bs, &acb); | |
971 | while (acb.ret == -EINPROGRESS) { | |
972 | qemu_coroutine_yield(); | |
973 | } | |
974 | return acb.ret; | |
769ce76d AG |
975 | } |
976 | ||
769ce76d AG |
977 | static void curl_close(BlockDriverState *bs) |
978 | { | |
979 | BDRVCURLState *s = bs->opaque; | |
769ce76d | 980 | |
ed2a66de | 981 | trace_curl_close(); |
63f0f45f | 982 | curl_detach_aio_context(bs); |
ba3186c4 | 983 | qemu_mutex_destroy(&s->mutex); |
031fd1be | 984 | |
0f418a20 | 985 | g_hash_table_destroy(s->sockets); |
a94f83d9 | 986 | g_free(s->cookie); |
45724d6d | 987 | g_free(s->url); |
996922de JC |
988 | g_free(s->username); |
989 | g_free(s->proxyusername); | |
990 | g_free(s->proxypassword); | |
769ce76d AG |
991 | } |
992 | ||
c86422c5 | 993 | static int64_t coroutine_fn curl_co_getlength(BlockDriverState *bs) |
769ce76d AG |
994 | { |
995 | BDRVCURLState *s = bs->opaque; | |
996 | return s->len; | |
997 | } | |
998 | ||
937c007b HR |
999 | static void curl_refresh_filename(BlockDriverState *bs) |
1000 | { | |
1001 | BDRVCURLState *s = bs->opaque; | |
1002 | ||
1003 | /* "readahead" and "timeout" do not change the guest-visible data, | |
1004 | * so ignore them */ | |
1005 | if (s->sslverify != CURL_BLOCK_OPT_SSLVERIFY_DEFAULT || | |
1006 | s->cookie || s->username || s->password || s->proxyusername || | |
1007 | s->proxypassword) | |
1008 | { | |
1009 | return; | |
1010 | } | |
1011 | ||
1012 | pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), s->url); | |
1013 | } | |
1014 | ||
1015 | ||
2654267c HR |
1016 | static const char *const curl_strong_runtime_opts[] = { |
1017 | CURL_BLOCK_OPT_URL, | |
1018 | CURL_BLOCK_OPT_SSLVERIFY, | |
1019 | CURL_BLOCK_OPT_COOKIE, | |
1020 | CURL_BLOCK_OPT_COOKIE_SECRET, | |
1021 | CURL_BLOCK_OPT_USERNAME, | |
1022 | CURL_BLOCK_OPT_PASSWORD_SECRET, | |
1023 | CURL_BLOCK_OPT_PROXY_USERNAME, | |
1024 | CURL_BLOCK_OPT_PROXY_PASSWORD_SECRET, | |
1025 | ||
1026 | NULL | |
1027 | }; | |
1028 | ||
769ce76d | 1029 | static BlockDriver bdrv_http = { |
63f0f45f SH |
1030 | .format_name = "http", |
1031 | .protocol_name = "http", | |
1032 | ||
1033 | .instance_size = sizeof(BDRVCURLState), | |
1034 | .bdrv_parse_filename = curl_parse_filename, | |
1035 | .bdrv_file_open = curl_open, | |
1036 | .bdrv_close = curl_close, | |
c86422c5 | 1037 | .bdrv_co_getlength = curl_co_getlength, |
769ce76d | 1038 | |
28256d82 | 1039 | .bdrv_co_preadv = curl_co_preadv, |
769ce76d | 1040 | |
63f0f45f SH |
1041 | .bdrv_detach_aio_context = curl_detach_aio_context, |
1042 | .bdrv_attach_aio_context = curl_attach_aio_context, | |
2654267c | 1043 | |
937c007b | 1044 | .bdrv_refresh_filename = curl_refresh_filename, |
2654267c | 1045 | .strong_runtime_opts = curl_strong_runtime_opts, |
769ce76d AG |
1046 | }; |
1047 | ||
1048 | static BlockDriver bdrv_https = { | |
63f0f45f SH |
1049 | .format_name = "https", |
1050 | .protocol_name = "https", | |
769ce76d | 1051 | |
63f0f45f SH |
1052 | .instance_size = sizeof(BDRVCURLState), |
1053 | .bdrv_parse_filename = curl_parse_filename, | |
1054 | .bdrv_file_open = curl_open, | |
1055 | .bdrv_close = curl_close, | |
c86422c5 | 1056 | .bdrv_co_getlength = curl_co_getlength, |
769ce76d | 1057 | |
28256d82 | 1058 | .bdrv_co_preadv = curl_co_preadv, |
63f0f45f SH |
1059 | |
1060 | .bdrv_detach_aio_context = curl_detach_aio_context, | |
1061 | .bdrv_attach_aio_context = curl_attach_aio_context, | |
2654267c | 1062 | |
937c007b | 1063 | .bdrv_refresh_filename = curl_refresh_filename, |
2654267c | 1064 | .strong_runtime_opts = curl_strong_runtime_opts, |
769ce76d AG |
1065 | }; |
1066 | ||
1067 | static BlockDriver bdrv_ftp = { | |
63f0f45f SH |
1068 | .format_name = "ftp", |
1069 | .protocol_name = "ftp", | |
1070 | ||
1071 | .instance_size = sizeof(BDRVCURLState), | |
1072 | .bdrv_parse_filename = curl_parse_filename, | |
1073 | .bdrv_file_open = curl_open, | |
1074 | .bdrv_close = curl_close, | |
c86422c5 | 1075 | .bdrv_co_getlength = curl_co_getlength, |
769ce76d | 1076 | |
28256d82 | 1077 | .bdrv_co_preadv = curl_co_preadv, |
769ce76d | 1078 | |
63f0f45f SH |
1079 | .bdrv_detach_aio_context = curl_detach_aio_context, |
1080 | .bdrv_attach_aio_context = curl_attach_aio_context, | |
2654267c | 1081 | |
937c007b | 1082 | .bdrv_refresh_filename = curl_refresh_filename, |
2654267c | 1083 | .strong_runtime_opts = curl_strong_runtime_opts, |
769ce76d AG |
1084 | }; |
1085 | ||
1086 | static BlockDriver bdrv_ftps = { | |
63f0f45f SH |
1087 | .format_name = "ftps", |
1088 | .protocol_name = "ftps", | |
769ce76d | 1089 | |
63f0f45f SH |
1090 | .instance_size = sizeof(BDRVCURLState), |
1091 | .bdrv_parse_filename = curl_parse_filename, | |
1092 | .bdrv_file_open = curl_open, | |
1093 | .bdrv_close = curl_close, | |
c86422c5 | 1094 | .bdrv_co_getlength = curl_co_getlength, |
769ce76d | 1095 | |
28256d82 | 1096 | .bdrv_co_preadv = curl_co_preadv, |
63f0f45f SH |
1097 | |
1098 | .bdrv_detach_aio_context = curl_detach_aio_context, | |
1099 | .bdrv_attach_aio_context = curl_attach_aio_context, | |
2654267c | 1100 | |
937c007b | 1101 | .bdrv_refresh_filename = curl_refresh_filename, |
2654267c | 1102 | .strong_runtime_opts = curl_strong_runtime_opts, |
769ce76d AG |
1103 | }; |
1104 | ||
769ce76d AG |
1105 | static void curl_block_init(void) |
1106 | { | |
1107 | bdrv_register(&bdrv_http); | |
1108 | bdrv_register(&bdrv_https); | |
1109 | bdrv_register(&bdrv_ftp); | |
1110 | bdrv_register(&bdrv_ftps); | |
769ce76d AG |
1111 | } |
1112 | ||
1113 | block_init(curl_block_init); |