Statistics
| Branch: | Revision:

root / block / curl.c @ 60beb341

History | View | Annotate | Download (18.5 kB)

1 769ce76d Alexander Graf
/*
2 769ce76d Alexander Graf
 * QEMU Block driver for CURL images
3 769ce76d Alexander Graf
 *
4 769ce76d Alexander Graf
 * Copyright (c) 2009 Alexander Graf <agraf@suse.de>
5 769ce76d Alexander Graf
 *
6 769ce76d Alexander Graf
 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 769ce76d Alexander Graf
 * of this software and associated documentation files (the "Software"), to deal
8 769ce76d Alexander Graf
 * in the Software without restriction, including without limitation the rights
9 769ce76d Alexander Graf
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 769ce76d Alexander Graf
 * copies of the Software, and to permit persons to whom the Software is
11 769ce76d Alexander Graf
 * furnished to do so, subject to the following conditions:
12 769ce76d Alexander Graf
 *
13 769ce76d Alexander Graf
 * The above copyright notice and this permission notice shall be included in
14 769ce76d Alexander Graf
 * all copies or substantial portions of the Software.
15 769ce76d Alexander Graf
 *
16 769ce76d Alexander Graf
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 769ce76d Alexander Graf
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 769ce76d Alexander Graf
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 769ce76d Alexander Graf
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 769ce76d Alexander Graf
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 769ce76d Alexander Graf
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 769ce76d Alexander Graf
 * THE SOFTWARE.
23 769ce76d Alexander Graf
 */
24 769ce76d Alexander Graf
#include "qemu-common.h"
25 737e150e Paolo Bonzini
#include "block/block_int.h"
26 769ce76d Alexander Graf
#include <curl/curl.h>
27 769ce76d Alexander Graf
28 769ce76d Alexander Graf
// #define DEBUG
29 769ce76d Alexander Graf
// #define DEBUG_VERBOSE
30 769ce76d Alexander Graf
31 769ce76d Alexander Graf
#ifdef DEBUG_CURL
32 d0f2c4c6 malc
#define DPRINTF(fmt, ...) do { printf(fmt, ## __VA_ARGS__); } while (0)
33 769ce76d Alexander Graf
#else
34 d0f2c4c6 malc
#define DPRINTF(fmt, ...) do { } while (0)
35 769ce76d Alexander Graf
#endif
36 769ce76d Alexander Graf
37 fb6d1bbd Stefan Hajnoczi
#define PROTOCOLS (CURLPROTO_HTTP | CURLPROTO_HTTPS | \
38 fb6d1bbd Stefan Hajnoczi
                   CURLPROTO_FTP | CURLPROTO_FTPS | \
39 fb6d1bbd Stefan Hajnoczi
                   CURLPROTO_TFTP)
40 fb6d1bbd Stefan Hajnoczi
41 769ce76d Alexander Graf
#define CURL_NUM_STATES 8
42 769ce76d Alexander Graf
#define CURL_NUM_ACB    8
43 769ce76d Alexander Graf
#define SECTOR_SIZE     512
44 769ce76d Alexander Graf
#define READ_AHEAD_SIZE (256 * 1024)
45 769ce76d Alexander Graf
46 769ce76d Alexander Graf
#define FIND_RET_NONE   0
47 769ce76d Alexander Graf
#define FIND_RET_OK     1
48 769ce76d Alexander Graf
#define FIND_RET_WAIT   2
49 769ce76d Alexander Graf
50 769ce76d Alexander Graf
struct BDRVCURLState;
51 769ce76d Alexander Graf
52 769ce76d Alexander Graf
typedef struct CURLAIOCB {
53 769ce76d Alexander Graf
    BlockDriverAIOCB common;
54 363c3c85 Nick Thomas
    QEMUBH *bh;
55 769ce76d Alexander Graf
    QEMUIOVector *qiov;
56 363c3c85 Nick Thomas
57 363c3c85 Nick Thomas
    int64_t sector_num;
58 363c3c85 Nick Thomas
    int nb_sectors;
59 363c3c85 Nick Thomas
60 769ce76d Alexander Graf
    size_t start;
61 769ce76d Alexander Graf
    size_t end;
62 769ce76d Alexander Graf
} CURLAIOCB;
63 769ce76d Alexander Graf
64 769ce76d Alexander Graf
typedef struct CURLState
65 769ce76d Alexander Graf
{
66 769ce76d Alexander Graf
    struct BDRVCURLState *s;
67 769ce76d Alexander Graf
    CURLAIOCB *acb[CURL_NUM_ACB];
68 769ce76d Alexander Graf
    CURL *curl;
69 769ce76d Alexander Graf
    char *orig_buf;
70 769ce76d Alexander Graf
    size_t buf_start;
71 769ce76d Alexander Graf
    size_t buf_off;
72 769ce76d Alexander Graf
    size_t buf_len;
73 769ce76d Alexander Graf
    char range[128];
74 769ce76d Alexander Graf
    char errmsg[CURL_ERROR_SIZE];
75 769ce76d Alexander Graf
    char in_use;
76 769ce76d Alexander Graf
} CURLState;
77 769ce76d Alexander Graf
78 769ce76d Alexander Graf
typedef struct BDRVCURLState {
79 769ce76d Alexander Graf
    CURLM *multi;
80 769ce76d Alexander Graf
    size_t len;
81 769ce76d Alexander Graf
    CURLState states[CURL_NUM_STATES];
82 769ce76d Alexander Graf
    char *url;
83 c76f4952 Nolan
    size_t readahead_size;
84 769ce76d Alexander Graf
} BDRVCURLState;
85 769ce76d Alexander Graf
86 769ce76d Alexander Graf
static void curl_clean_state(CURLState *s);
87 769ce76d Alexander Graf
static void curl_multi_do(void *arg);
88 c84dcdc1 Nick Thomas
static int curl_aio_flush(void *opaque);
89 769ce76d Alexander Graf
90 769ce76d Alexander Graf
static int curl_sock_cb(CURL *curl, curl_socket_t fd, int action,
91 769ce76d Alexander Graf
                        void *s, void *sp)
92 769ce76d Alexander Graf
{
93 d0f2c4c6 malc
    DPRINTF("CURL (AIO): Sock action %d on fd %d\n", action, fd);
94 769ce76d Alexander Graf
    switch (action) {
95 769ce76d Alexander Graf
        case CURL_POLL_IN:
96 bafbd6a1 Paolo Bonzini
            qemu_aio_set_fd_handler(fd, curl_multi_do, NULL, curl_aio_flush, s);
97 769ce76d Alexander Graf
            break;
98 769ce76d Alexander Graf
        case CURL_POLL_OUT:
99 bafbd6a1 Paolo Bonzini
            qemu_aio_set_fd_handler(fd, NULL, curl_multi_do, curl_aio_flush, s);
100 769ce76d Alexander Graf
            break;
101 769ce76d Alexander Graf
        case CURL_POLL_INOUT:
102 c84dcdc1 Nick Thomas
            qemu_aio_set_fd_handler(fd, curl_multi_do, curl_multi_do,
103 bafbd6a1 Paolo Bonzini
                                    curl_aio_flush, s);
104 769ce76d Alexander Graf
            break;
105 769ce76d Alexander Graf
        case CURL_POLL_REMOVE:
106 bafbd6a1 Paolo Bonzini
            qemu_aio_set_fd_handler(fd, NULL, NULL, NULL, NULL);
107 769ce76d Alexander Graf
            break;
108 769ce76d Alexander Graf
    }
109 769ce76d Alexander Graf
110 769ce76d Alexander Graf
    return 0;
111 769ce76d Alexander Graf
}
112 769ce76d Alexander Graf
113 769ce76d Alexander Graf
static size_t curl_size_cb(void *ptr, size_t size, size_t nmemb, void *opaque)
114 769ce76d Alexander Graf
{
115 769ce76d Alexander Graf
    CURLState *s = ((CURLState*)opaque);
116 769ce76d Alexander Graf
    size_t realsize = size * nmemb;
117 0bfcd599 Blue Swirl
    size_t fsize;
118 769ce76d Alexander Graf
119 0bfcd599 Blue Swirl
    if(sscanf(ptr, "Content-Length: %zd", &fsize) == 1) {
120 769ce76d Alexander Graf
        s->s->len = fsize;
121 0bfcd599 Blue Swirl
    }
122 769ce76d Alexander Graf
123 769ce76d Alexander Graf
    return realsize;
124 769ce76d Alexander Graf
}
125 769ce76d Alexander Graf
126 769ce76d Alexander Graf
static size_t curl_read_cb(void *ptr, size_t size, size_t nmemb, void *opaque)
127 769ce76d Alexander Graf
{
128 769ce76d Alexander Graf
    CURLState *s = ((CURLState*)opaque);
129 769ce76d Alexander Graf
    size_t realsize = size * nmemb;
130 769ce76d Alexander Graf
    int i;
131 769ce76d Alexander Graf
132 0bfcd599 Blue Swirl
    DPRINTF("CURL: Just reading %zd bytes\n", realsize);
133 769ce76d Alexander Graf
134 769ce76d Alexander Graf
    if (!s || !s->orig_buf)
135 769ce76d Alexander Graf
        goto read_end;
136 769ce76d Alexander Graf
137 769ce76d Alexander Graf
    memcpy(s->orig_buf + s->buf_off, ptr, realsize);
138 769ce76d Alexander Graf
    s->buf_off += realsize;
139 769ce76d Alexander Graf
140 769ce76d Alexander Graf
    for(i=0; i<CURL_NUM_ACB; i++) {
141 769ce76d Alexander Graf
        CURLAIOCB *acb = s->acb[i];
142 769ce76d Alexander Graf
143 769ce76d Alexander Graf
        if (!acb)
144 769ce76d Alexander Graf
            continue;
145 769ce76d Alexander Graf
146 769ce76d Alexander Graf
        if ((s->buf_off >= acb->end)) {
147 03396148 Michael Tokarev
            qemu_iovec_from_buf(acb->qiov, 0, s->orig_buf + acb->start,
148 03396148 Michael Tokarev
                                acb->end - acb->start);
149 769ce76d Alexander Graf
            acb->common.cb(acb->common.opaque, 0);
150 769ce76d Alexander Graf
            qemu_aio_release(acb);
151 769ce76d Alexander Graf
            s->acb[i] = NULL;
152 769ce76d Alexander Graf
        }
153 769ce76d Alexander Graf
    }
154 769ce76d Alexander Graf
155 769ce76d Alexander Graf
read_end:
156 769ce76d Alexander Graf
    return realsize;
157 769ce76d Alexander Graf
}
158 769ce76d Alexander Graf
159 769ce76d Alexander Graf
static int curl_find_buf(BDRVCURLState *s, size_t start, size_t len,
160 769ce76d Alexander Graf
                         CURLAIOCB *acb)
161 769ce76d Alexander Graf
{
162 769ce76d Alexander Graf
    int i;
163 769ce76d Alexander Graf
    size_t end = start + len;
164 769ce76d Alexander Graf
165 769ce76d Alexander Graf
    for (i=0; i<CURL_NUM_STATES; i++) {
166 769ce76d Alexander Graf
        CURLState *state = &s->states[i];
167 769ce76d Alexander Graf
        size_t buf_end = (state->buf_start + state->buf_off);
168 769ce76d Alexander Graf
        size_t buf_fend = (state->buf_start + state->buf_len);
169 769ce76d Alexander Graf
170 769ce76d Alexander Graf
        if (!state->orig_buf)
171 769ce76d Alexander Graf
            continue;
172 769ce76d Alexander Graf
        if (!state->buf_off)
173 769ce76d Alexander Graf
            continue;
174 769ce76d Alexander Graf
175 769ce76d Alexander Graf
        // Does the existing buffer cover our section?
176 769ce76d Alexander Graf
        if ((start >= state->buf_start) &&
177 769ce76d Alexander Graf
            (start <= buf_end) &&
178 769ce76d Alexander Graf
            (end >= state->buf_start) &&
179 769ce76d Alexander Graf
            (end <= buf_end))
180 769ce76d Alexander Graf
        {
181 769ce76d Alexander Graf
            char *buf = state->orig_buf + (start - state->buf_start);
182 769ce76d Alexander Graf
183 03396148 Michael Tokarev
            qemu_iovec_from_buf(acb->qiov, 0, buf, len);
184 769ce76d Alexander Graf
            acb->common.cb(acb->common.opaque, 0);
185 769ce76d Alexander Graf
186 769ce76d Alexander Graf
            return FIND_RET_OK;
187 769ce76d Alexander Graf
        }
188 769ce76d Alexander Graf
189 769ce76d Alexander Graf
        // Wait for unfinished chunks
190 769ce76d Alexander Graf
        if ((start >= state->buf_start) &&
191 769ce76d Alexander Graf
            (start <= buf_fend) &&
192 769ce76d Alexander Graf
            (end >= state->buf_start) &&
193 769ce76d Alexander Graf
            (end <= buf_fend))
194 769ce76d Alexander Graf
        {
195 769ce76d Alexander Graf
            int j;
196 769ce76d Alexander Graf
197 769ce76d Alexander Graf
            acb->start = start - state->buf_start;
198 769ce76d Alexander Graf
            acb->end = acb->start + len;
199 769ce76d Alexander Graf
200 769ce76d Alexander Graf
            for (j=0; j<CURL_NUM_ACB; j++) {
201 769ce76d Alexander Graf
                if (!state->acb[j]) {
202 769ce76d Alexander Graf
                    state->acb[j] = acb;
203 769ce76d Alexander Graf
                    return FIND_RET_WAIT;
204 769ce76d Alexander Graf
                }
205 769ce76d Alexander Graf
            }
206 769ce76d Alexander Graf
        }
207 769ce76d Alexander Graf
    }
208 769ce76d Alexander Graf
209 769ce76d Alexander Graf
    return FIND_RET_NONE;
210 769ce76d Alexander Graf
}
211 769ce76d Alexander Graf
212 769ce76d Alexander Graf
static void curl_multi_do(void *arg)
213 769ce76d Alexander Graf
{
214 769ce76d Alexander Graf
    BDRVCURLState *s = (BDRVCURLState *)arg;
215 769ce76d Alexander Graf
    int running;
216 769ce76d Alexander Graf
    int r;
217 769ce76d Alexander Graf
    int msgs_in_queue;
218 769ce76d Alexander Graf
219 769ce76d Alexander Graf
    if (!s->multi)
220 769ce76d Alexander Graf
        return;
221 769ce76d Alexander Graf
222 769ce76d Alexander Graf
    do {
223 769ce76d Alexander Graf
        r = curl_multi_socket_all(s->multi, &running);
224 769ce76d Alexander Graf
    } while(r == CURLM_CALL_MULTI_PERFORM);
225 769ce76d Alexander Graf
226 769ce76d Alexander Graf
    /* Try to find done transfers, so we can free the easy
227 769ce76d Alexander Graf
     * handle again. */
228 769ce76d Alexander Graf
    do {
229 769ce76d Alexander Graf
        CURLMsg *msg;
230 769ce76d Alexander Graf
        msg = curl_multi_info_read(s->multi, &msgs_in_queue);
231 769ce76d Alexander Graf
232 769ce76d Alexander Graf
        if (!msg)
233 769ce76d Alexander Graf
            break;
234 769ce76d Alexander Graf
        if (msg->msg == CURLMSG_NONE)
235 769ce76d Alexander Graf
            break;
236 769ce76d Alexander Graf
237 769ce76d Alexander Graf
        switch (msg->msg) {
238 769ce76d Alexander Graf
            case CURLMSG_DONE:
239 769ce76d Alexander Graf
            {
240 769ce76d Alexander Graf
                CURLState *state = NULL;
241 769ce76d Alexander Graf
                curl_easy_getinfo(msg->easy_handle, CURLINFO_PRIVATE, (char**)&state);
242 f785a5ae Nicholas Thomas
243 f785a5ae Nicholas Thomas
                /* ACBs for successful messages get completed in curl_read_cb */
244 f785a5ae Nicholas Thomas
                if (msg->data.result != CURLE_OK) {
245 f785a5ae Nicholas Thomas
                    int i;
246 f785a5ae Nicholas Thomas
                    for (i = 0; i < CURL_NUM_ACB; i++) {
247 f785a5ae Nicholas Thomas
                        CURLAIOCB *acb = state->acb[i];
248 f785a5ae Nicholas Thomas
249 f785a5ae Nicholas Thomas
                        if (acb == NULL) {
250 f785a5ae Nicholas Thomas
                            continue;
251 f785a5ae Nicholas Thomas
                        }
252 f785a5ae Nicholas Thomas
253 f785a5ae Nicholas Thomas
                        acb->common.cb(acb->common.opaque, -EIO);
254 f785a5ae Nicholas Thomas
                        qemu_aio_release(acb);
255 f785a5ae Nicholas Thomas
                        state->acb[i] = NULL;
256 f785a5ae Nicholas Thomas
                    }
257 f785a5ae Nicholas Thomas
                }
258 f785a5ae Nicholas Thomas
259 769ce76d Alexander Graf
                curl_clean_state(state);
260 769ce76d Alexander Graf
                break;
261 769ce76d Alexander Graf
            }
262 769ce76d Alexander Graf
            default:
263 769ce76d Alexander Graf
                msgs_in_queue = 0;
264 769ce76d Alexander Graf
                break;
265 769ce76d Alexander Graf
        }
266 769ce76d Alexander Graf
    } while(msgs_in_queue);
267 769ce76d Alexander Graf
}
268 769ce76d Alexander Graf
269 769ce76d Alexander Graf
static CURLState *curl_init_state(BDRVCURLState *s)
270 769ce76d Alexander Graf
{
271 769ce76d Alexander Graf
    CURLState *state = NULL;
272 769ce76d Alexander Graf
    int i, j;
273 769ce76d Alexander Graf
274 769ce76d Alexander Graf
    do {
275 769ce76d Alexander Graf
        for (i=0; i<CURL_NUM_STATES; i++) {
276 769ce76d Alexander Graf
            for (j=0; j<CURL_NUM_ACB; j++)
277 769ce76d Alexander Graf
                if (s->states[i].acb[j])
278 769ce76d Alexander Graf
                    continue;
279 769ce76d Alexander Graf
            if (s->states[i].in_use)
280 769ce76d Alexander Graf
                continue;
281 769ce76d Alexander Graf
282 769ce76d Alexander Graf
            state = &s->states[i];
283 769ce76d Alexander Graf
            state->in_use = 1;
284 769ce76d Alexander Graf
            break;
285 769ce76d Alexander Graf
        }
286 769ce76d Alexander Graf
        if (!state) {
287 fb7c8e8a Stefan Weil
            g_usleep(100);
288 769ce76d Alexander Graf
            curl_multi_do(s);
289 769ce76d Alexander Graf
        }
290 769ce76d Alexander Graf
    } while(!state);
291 769ce76d Alexander Graf
292 769ce76d Alexander Graf
    if (state->curl)
293 769ce76d Alexander Graf
        goto has_curl;
294 769ce76d Alexander Graf
295 769ce76d Alexander Graf
    state->curl = curl_easy_init();
296 769ce76d Alexander Graf
    if (!state->curl)
297 769ce76d Alexander Graf
        return NULL;
298 769ce76d Alexander Graf
    curl_easy_setopt(state->curl, CURLOPT_URL, s->url);
299 769ce76d Alexander Graf
    curl_easy_setopt(state->curl, CURLOPT_TIMEOUT, 5);
300 df3cee1a Blue Swirl
    curl_easy_setopt(state->curl, CURLOPT_WRITEFUNCTION, (void *)curl_read_cb);
301 769ce76d Alexander Graf
    curl_easy_setopt(state->curl, CURLOPT_WRITEDATA, (void *)state);
302 769ce76d Alexander Graf
    curl_easy_setopt(state->curl, CURLOPT_PRIVATE, (void *)state);
303 769ce76d Alexander Graf
    curl_easy_setopt(state->curl, CURLOPT_AUTOREFERER, 1);
304 769ce76d Alexander Graf
    curl_easy_setopt(state->curl, CURLOPT_FOLLOWLOCATION, 1);
305 769ce76d Alexander Graf
    curl_easy_setopt(state->curl, CURLOPT_NOSIGNAL, 1);
306 769ce76d Alexander Graf
    curl_easy_setopt(state->curl, CURLOPT_ERRORBUFFER, state->errmsg);
307 f785a5ae Nicholas Thomas
    curl_easy_setopt(state->curl, CURLOPT_FAILONERROR, 1);
308 f785a5ae Nicholas Thomas
309 fb6d1bbd Stefan Hajnoczi
    /* Restrict supported protocols to avoid security issues in the more
310 fb6d1bbd Stefan Hajnoczi
     * obscure protocols.  For example, do not allow POP3/SMTP/IMAP see
311 fb6d1bbd Stefan Hajnoczi
     * CVE-2013-0249.
312 8a8f5840 Stefan Hajnoczi
     *
313 8a8f5840 Stefan Hajnoczi
     * Restricting protocols is only supported from 7.19.4 upwards.
314 fb6d1bbd Stefan Hajnoczi
     */
315 8a8f5840 Stefan Hajnoczi
#if LIBCURL_VERSION_NUM >= 0x071304
316 fb6d1bbd Stefan Hajnoczi
    curl_easy_setopt(state->curl, CURLOPT_PROTOCOLS, PROTOCOLS);
317 fb6d1bbd Stefan Hajnoczi
    curl_easy_setopt(state->curl, CURLOPT_REDIR_PROTOCOLS, PROTOCOLS);
318 8a8f5840 Stefan Hajnoczi
#endif
319 fb6d1bbd Stefan Hajnoczi
320 769ce76d Alexander Graf
#ifdef DEBUG_VERBOSE
321 769ce76d Alexander Graf
    curl_easy_setopt(state->curl, CURLOPT_VERBOSE, 1);
322 769ce76d Alexander Graf
#endif
323 769ce76d Alexander Graf
324 769ce76d Alexander Graf
has_curl:
325 769ce76d Alexander Graf
326 769ce76d Alexander Graf
    state->s = s;
327 769ce76d Alexander Graf
328 769ce76d Alexander Graf
    return state;
329 769ce76d Alexander Graf
}
330 769ce76d Alexander Graf
331 769ce76d Alexander Graf
static void curl_clean_state(CURLState *s)
332 769ce76d Alexander Graf
{
333 769ce76d Alexander Graf
    if (s->s->multi)
334 769ce76d Alexander Graf
        curl_multi_remove_handle(s->s->multi, s->curl);
335 769ce76d Alexander Graf
    s->in_use = 0;
336 769ce76d Alexander Graf
}
337 769ce76d Alexander Graf
338 8e6d58cd Kevin Wolf
static void curl_parse_filename(const char *filename, QDict *options,
339 8e6d58cd Kevin Wolf
                                Error **errp)
340 769ce76d Alexander Graf
{
341 c76f4952 Nolan
342 c76f4952 Nolan
    #define RA_OPTSTR ":readahead="
343 c76f4952 Nolan
    char *file;
344 c76f4952 Nolan
    char *ra;
345 c76f4952 Nolan
    const char *ra_val;
346 c76f4952 Nolan
    int parse_state = 0;
347 c76f4952 Nolan
348 7267c094 Anthony Liguori
    file = g_strdup(filename);
349 c76f4952 Nolan
350 c76f4952 Nolan
    /* Parse a trailing ":readahead=#:" param, if present. */
351 c76f4952 Nolan
    ra = file + strlen(file) - 1;
352 c76f4952 Nolan
    while (ra >= file) {
353 c76f4952 Nolan
        if (parse_state == 0) {
354 8e6d58cd Kevin Wolf
            if (*ra == ':') {
355 c76f4952 Nolan
                parse_state++;
356 8e6d58cd Kevin Wolf
            } else {
357 c76f4952 Nolan
                break;
358 8e6d58cd Kevin Wolf
            }
359 c76f4952 Nolan
        } else if (parse_state == 1) {
360 c76f4952 Nolan
            if (*ra > '9' || *ra < '0') {
361 c76f4952 Nolan
                char *opt_start = ra - strlen(RA_OPTSTR) + 1;
362 c76f4952 Nolan
                if (opt_start > file &&
363 c76f4952 Nolan
                    strncmp(opt_start, RA_OPTSTR, strlen(RA_OPTSTR)) == 0) {
364 c76f4952 Nolan
                    ra_val = ra + 1;
365 c76f4952 Nolan
                    ra -= strlen(RA_OPTSTR) - 1;
366 c76f4952 Nolan
                    *ra = '\0';
367 8e6d58cd Kevin Wolf
                    qdict_put(options, "readahead", qstring_from_str(ra_val));
368 c76f4952 Nolan
                }
369 8e6d58cd Kevin Wolf
                break;
370 c76f4952 Nolan
            }
371 c76f4952 Nolan
        }
372 c76f4952 Nolan
        ra--;
373 c76f4952 Nolan
    }
374 c76f4952 Nolan
375 8e6d58cd Kevin Wolf
    qdict_put(options, "url", qstring_from_str(file));
376 8e6d58cd Kevin Wolf
377 8e6d58cd Kevin Wolf
    g_free(file);
378 8e6d58cd Kevin Wolf
}
379 8e6d58cd Kevin Wolf
380 8e6d58cd Kevin Wolf
static QemuOptsList runtime_opts = {
381 8e6d58cd Kevin Wolf
    .name = "curl",
382 8e6d58cd Kevin Wolf
    .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
383 8e6d58cd Kevin Wolf
    .desc = {
384 8e6d58cd Kevin Wolf
        {
385 8e6d58cd Kevin Wolf
            .name = "url",
386 8e6d58cd Kevin Wolf
            .type = QEMU_OPT_STRING,
387 8e6d58cd Kevin Wolf
            .help = "URL to open",
388 8e6d58cd Kevin Wolf
        },
389 8e6d58cd Kevin Wolf
        {
390 8e6d58cd Kevin Wolf
            .name = "readahead",
391 8e6d58cd Kevin Wolf
            .type = QEMU_OPT_SIZE,
392 8e6d58cd Kevin Wolf
            .help = "Readahead size",
393 8e6d58cd Kevin Wolf
        },
394 8e6d58cd Kevin Wolf
        { /* end of list */ }
395 8e6d58cd Kevin Wolf
    },
396 8e6d58cd Kevin Wolf
};
397 8e6d58cd Kevin Wolf
398 8e6d58cd Kevin Wolf
static int curl_open(BlockDriverState *bs, const char *dummy,
399 8e6d58cd Kevin Wolf
                     QDict *options, int flags)
400 8e6d58cd Kevin Wolf
{
401 8e6d58cd Kevin Wolf
    BDRVCURLState *s = bs->opaque;
402 8e6d58cd Kevin Wolf
    CURLState *state = NULL;
403 8e6d58cd Kevin Wolf
    QemuOpts *opts;
404 8e6d58cd Kevin Wolf
    Error *local_err = NULL;
405 8e6d58cd Kevin Wolf
    const char *file;
406 8e6d58cd Kevin Wolf
    double d;
407 8e6d58cd Kevin Wolf
408 8e6d58cd Kevin Wolf
    static int inited = 0;
409 8e6d58cd Kevin Wolf
410 8e6d58cd Kevin Wolf
    opts = qemu_opts_create_nofail(&runtime_opts);
411 8e6d58cd Kevin Wolf
    qemu_opts_absorb_qdict(opts, options, &local_err);
412 8e6d58cd Kevin Wolf
    if (error_is_set(&local_err)) {
413 8e6d58cd Kevin Wolf
        qerror_report_err(local_err);
414 8e6d58cd Kevin Wolf
        error_free(local_err);
415 8e6d58cd Kevin Wolf
        goto out_noclean;
416 8e6d58cd Kevin Wolf
    }
417 8e6d58cd Kevin Wolf
418 8e6d58cd Kevin Wolf
    s->readahead_size = qemu_opt_get_size(opts, "readahead", READ_AHEAD_SIZE);
419 c76f4952 Nolan
    if ((s->readahead_size & 0x1ff) != 0) {
420 48a402e6 malc
        fprintf(stderr, "HTTP_READAHEAD_SIZE %zd is not a multiple of 512\n",
421 c76f4952 Nolan
                s->readahead_size);
422 c76f4952 Nolan
        goto out_noclean;
423 c76f4952 Nolan
    }
424 c76f4952 Nolan
425 8e6d58cd Kevin Wolf
    file = qemu_opt_get(opts, "url");
426 8e6d58cd Kevin Wolf
    if (file == NULL) {
427 8e6d58cd Kevin Wolf
        qerror_report(ERROR_CLASS_GENERIC_ERROR, "curl block driver requires "
428 8e6d58cd Kevin Wolf
                      "an 'url' option");
429 8e6d58cd Kevin Wolf
        goto out_noclean;
430 8e6d58cd Kevin Wolf
    }
431 8e6d58cd Kevin Wolf
432 769ce76d Alexander Graf
    if (!inited) {
433 769ce76d Alexander Graf
        curl_global_init(CURL_GLOBAL_ALL);
434 769ce76d Alexander Graf
        inited = 1;
435 769ce76d Alexander Graf
    }
436 769ce76d Alexander Graf
437 d0f2c4c6 malc
    DPRINTF("CURL: Opening %s\n", file);
438 8e6d58cd Kevin Wolf
    s->url = g_strdup(file);
439 769ce76d Alexander Graf
    state = curl_init_state(s);
440 769ce76d Alexander Graf
    if (!state)
441 769ce76d Alexander Graf
        goto out_noclean;
442 769ce76d Alexander Graf
443 769ce76d Alexander Graf
    // Get file size
444 769ce76d Alexander Graf
445 769ce76d Alexander Graf
    curl_easy_setopt(state->curl, CURLOPT_NOBODY, 1);
446 df3cee1a Blue Swirl
    curl_easy_setopt(state->curl, CURLOPT_WRITEFUNCTION, (void *)curl_size_cb);
447 769ce76d Alexander Graf
    if (curl_easy_perform(state->curl))
448 769ce76d Alexander Graf
        goto out;
449 769ce76d Alexander Graf
    curl_easy_getinfo(state->curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &d);
450 df3cee1a Blue Swirl
    curl_easy_setopt(state->curl, CURLOPT_WRITEFUNCTION, (void *)curl_read_cb);
451 769ce76d Alexander Graf
    curl_easy_setopt(state->curl, CURLOPT_NOBODY, 0);
452 769ce76d Alexander Graf
    if (d)
453 769ce76d Alexander Graf
        s->len = (size_t)d;
454 769ce76d Alexander Graf
    else if(!s->len)
455 769ce76d Alexander Graf
        goto out;
456 0bfcd599 Blue Swirl
    DPRINTF("CURL: Size = %zd\n", s->len);
457 769ce76d Alexander Graf
458 769ce76d Alexander Graf
    curl_clean_state(state);
459 769ce76d Alexander Graf
    curl_easy_cleanup(state->curl);
460 769ce76d Alexander Graf
    state->curl = NULL;
461 769ce76d Alexander Graf
462 769ce76d Alexander Graf
    // Now we know the file exists and its size, so let's
463 769ce76d Alexander Graf
    // initialize the multi interface!
464 769ce76d Alexander Graf
465 769ce76d Alexander Graf
    s->multi = curl_multi_init();
466 769ce76d Alexander Graf
    curl_multi_setopt( s->multi, CURLMOPT_SOCKETDATA, s); 
467 769ce76d Alexander Graf
    curl_multi_setopt( s->multi, CURLMOPT_SOCKETFUNCTION, curl_sock_cb ); 
468 769ce76d Alexander Graf
    curl_multi_do(s);
469 769ce76d Alexander Graf
470 8e6d58cd Kevin Wolf
    qemu_opts_del(opts);
471 769ce76d Alexander Graf
    return 0;
472 769ce76d Alexander Graf
473 769ce76d Alexander Graf
out:
474 769ce76d Alexander Graf
    fprintf(stderr, "CURL: Error opening file: %s\n", state->errmsg);
475 769ce76d Alexander Graf
    curl_easy_cleanup(state->curl);
476 769ce76d Alexander Graf
    state->curl = NULL;
477 769ce76d Alexander Graf
out_noclean:
478 8e6d58cd Kevin Wolf
    g_free(s->url);
479 8e6d58cd Kevin Wolf
    qemu_opts_del(opts);
480 769ce76d Alexander Graf
    return -EINVAL;
481 769ce76d Alexander Graf
}
482 769ce76d Alexander Graf
483 c84dcdc1 Nick Thomas
static int curl_aio_flush(void *opaque)
484 c84dcdc1 Nick Thomas
{
485 c84dcdc1 Nick Thomas
    BDRVCURLState *s = opaque;
486 c84dcdc1 Nick Thomas
    int i, j;
487 c84dcdc1 Nick Thomas
488 c84dcdc1 Nick Thomas
    for (i=0; i < CURL_NUM_STATES; i++) {
489 c84dcdc1 Nick Thomas
        for(j=0; j < CURL_NUM_ACB; j++) {
490 c84dcdc1 Nick Thomas
            if (s->states[i].acb[j]) {
491 c84dcdc1 Nick Thomas
                return 1;
492 c84dcdc1 Nick Thomas
            }
493 c84dcdc1 Nick Thomas
        }
494 c84dcdc1 Nick Thomas
    }
495 c84dcdc1 Nick Thomas
    return 0;
496 c84dcdc1 Nick Thomas
}
497 c84dcdc1 Nick Thomas
498 c16b5a2c Christoph Hellwig
static void curl_aio_cancel(BlockDriverAIOCB *blockacb)
499 c16b5a2c Christoph Hellwig
{
500 c16b5a2c Christoph Hellwig
    // Do we have to implement canceling? Seems to work without...
501 c16b5a2c Christoph Hellwig
}
502 c16b5a2c Christoph Hellwig
503 d7331bed Stefan Hajnoczi
static const AIOCBInfo curl_aiocb_info = {
504 c16b5a2c Christoph Hellwig
    .aiocb_size         = sizeof(CURLAIOCB),
505 c16b5a2c Christoph Hellwig
    .cancel             = curl_aio_cancel,
506 c16b5a2c Christoph Hellwig
};
507 c16b5a2c Christoph Hellwig
508 363c3c85 Nick Thomas
509 363c3c85 Nick Thomas
static void curl_readv_bh_cb(void *p)
510 769ce76d Alexander Graf
{
511 769ce76d Alexander Graf
    CURLState *state;
512 769ce76d Alexander Graf
513 363c3c85 Nick Thomas
    CURLAIOCB *acb = p;
514 363c3c85 Nick Thomas
    BDRVCURLState *s = acb->common.bs->opaque;
515 769ce76d Alexander Graf
516 363c3c85 Nick Thomas
    qemu_bh_delete(acb->bh);
517 363c3c85 Nick Thomas
    acb->bh = NULL;
518 363c3c85 Nick Thomas
519 363c3c85 Nick Thomas
    size_t start = acb->sector_num * SECTOR_SIZE;
520 363c3c85 Nick Thomas
    size_t end;
521 769ce76d Alexander Graf
522 769ce76d Alexander Graf
    // In case we have the requested data already (e.g. read-ahead),
523 769ce76d Alexander Graf
    // we can just call the callback and be done.
524 363c3c85 Nick Thomas
    switch (curl_find_buf(s, start, acb->nb_sectors * SECTOR_SIZE, acb)) {
525 769ce76d Alexander Graf
        case FIND_RET_OK:
526 769ce76d Alexander Graf
            qemu_aio_release(acb);
527 769ce76d Alexander Graf
            // fall through
528 769ce76d Alexander Graf
        case FIND_RET_WAIT:
529 363c3c85 Nick Thomas
            return;
530 769ce76d Alexander Graf
        default:
531 769ce76d Alexander Graf
            break;
532 769ce76d Alexander Graf
    }
533 769ce76d Alexander Graf
534 769ce76d Alexander Graf
    // No cache found, so let's start a new request
535 769ce76d Alexander Graf
    state = curl_init_state(s);
536 363c3c85 Nick Thomas
    if (!state) {
537 363c3c85 Nick Thomas
        acb->common.cb(acb->common.opaque, -EIO);
538 363c3c85 Nick Thomas
        qemu_aio_release(acb);
539 363c3c85 Nick Thomas
        return;
540 363c3c85 Nick Thomas
    }
541 769ce76d Alexander Graf
542 769ce76d Alexander Graf
    acb->start = 0;
543 363c3c85 Nick Thomas
    acb->end = (acb->nb_sectors * SECTOR_SIZE);
544 769ce76d Alexander Graf
545 769ce76d Alexander Graf
    state->buf_off = 0;
546 769ce76d Alexander Graf
    if (state->orig_buf)
547 7267c094 Anthony Liguori
        g_free(state->orig_buf);
548 769ce76d Alexander Graf
    state->buf_start = start;
549 c76f4952 Nolan
    state->buf_len = acb->end + s->readahead_size;
550 769ce76d Alexander Graf
    end = MIN(start + state->buf_len, s->len) - 1;
551 7267c094 Anthony Liguori
    state->orig_buf = g_malloc(state->buf_len);
552 769ce76d Alexander Graf
    state->acb[0] = acb;
553 769ce76d Alexander Graf
554 0bfcd599 Blue Swirl
    snprintf(state->range, 127, "%zd-%zd", start, end);
555 0bfcd599 Blue Swirl
    DPRINTF("CURL (AIO): Reading %d at %zd (%s)\n",
556 363c3c85 Nick Thomas
            (acb->nb_sectors * SECTOR_SIZE), start, state->range);
557 769ce76d Alexander Graf
    curl_easy_setopt(state->curl, CURLOPT_RANGE, state->range);
558 769ce76d Alexander Graf
559 769ce76d Alexander Graf
    curl_multi_add_handle(s->multi, state->curl);
560 769ce76d Alexander Graf
    curl_multi_do(s);
561 769ce76d Alexander Graf
562 363c3c85 Nick Thomas
}
563 363c3c85 Nick Thomas
564 363c3c85 Nick Thomas
static BlockDriverAIOCB *curl_aio_readv(BlockDriverState *bs,
565 363c3c85 Nick Thomas
        int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
566 363c3c85 Nick Thomas
        BlockDriverCompletionFunc *cb, void *opaque)
567 363c3c85 Nick Thomas
{
568 363c3c85 Nick Thomas
    CURLAIOCB *acb;
569 363c3c85 Nick Thomas
570 d7331bed Stefan Hajnoczi
    acb = qemu_aio_get(&curl_aiocb_info, bs, cb, opaque);
571 363c3c85 Nick Thomas
572 363c3c85 Nick Thomas
    acb->qiov = qiov;
573 363c3c85 Nick Thomas
    acb->sector_num = sector_num;
574 363c3c85 Nick Thomas
    acb->nb_sectors = nb_sectors;
575 363c3c85 Nick Thomas
576 363c3c85 Nick Thomas
    acb->bh = qemu_bh_new(curl_readv_bh_cb, acb);
577 363c3c85 Nick Thomas
578 363c3c85 Nick Thomas
    if (!acb->bh) {
579 363c3c85 Nick Thomas
        DPRINTF("CURL: qemu_bh_new failed\n");
580 363c3c85 Nick Thomas
        return NULL;
581 363c3c85 Nick Thomas
    }
582 363c3c85 Nick Thomas
583 363c3c85 Nick Thomas
    qemu_bh_schedule(acb->bh);
584 769ce76d Alexander Graf
    return &acb->common;
585 769ce76d Alexander Graf
}
586 769ce76d Alexander Graf
587 769ce76d Alexander Graf
static void curl_close(BlockDriverState *bs)
588 769ce76d Alexander Graf
{
589 769ce76d Alexander Graf
    BDRVCURLState *s = bs->opaque;
590 769ce76d Alexander Graf
    int i;
591 769ce76d Alexander Graf
592 d0f2c4c6 malc
    DPRINTF("CURL: Close\n");
593 769ce76d Alexander Graf
    for (i=0; i<CURL_NUM_STATES; i++) {
594 769ce76d Alexander Graf
        if (s->states[i].in_use)
595 769ce76d Alexander Graf
            curl_clean_state(&s->states[i]);
596 769ce76d Alexander Graf
        if (s->states[i].curl) {
597 769ce76d Alexander Graf
            curl_easy_cleanup(s->states[i].curl);
598 769ce76d Alexander Graf
            s->states[i].curl = NULL;
599 769ce76d Alexander Graf
        }
600 769ce76d Alexander Graf
        if (s->states[i].orig_buf) {
601 7267c094 Anthony Liguori
            g_free(s->states[i].orig_buf);
602 769ce76d Alexander Graf
            s->states[i].orig_buf = NULL;
603 769ce76d Alexander Graf
        }
604 769ce76d Alexander Graf
    }
605 769ce76d Alexander Graf
    if (s->multi)
606 769ce76d Alexander Graf
        curl_multi_cleanup(s->multi);
607 45724d6d Stefan Weil
    g_free(s->url);
608 769ce76d Alexander Graf
}
609 769ce76d Alexander Graf
610 769ce76d Alexander Graf
static int64_t curl_getlength(BlockDriverState *bs)
611 769ce76d Alexander Graf
{
612 769ce76d Alexander Graf
    BDRVCURLState *s = bs->opaque;
613 769ce76d Alexander Graf
    return s->len;
614 769ce76d Alexander Graf
}
615 769ce76d Alexander Graf
616 769ce76d Alexander Graf
static BlockDriver bdrv_http = {
617 8e6d58cd Kevin Wolf
    .format_name            = "http",
618 8e6d58cd Kevin Wolf
    .protocol_name          = "http",
619 769ce76d Alexander Graf
620 8e6d58cd Kevin Wolf
    .instance_size          = sizeof(BDRVCURLState),
621 8e6d58cd Kevin Wolf
    .bdrv_parse_filename    = curl_parse_filename,
622 8e6d58cd Kevin Wolf
    .bdrv_file_open         = curl_open,
623 8e6d58cd Kevin Wolf
    .bdrv_close             = curl_close,
624 8e6d58cd Kevin Wolf
    .bdrv_getlength         = curl_getlength,
625 769ce76d Alexander Graf
626 8e6d58cd Kevin Wolf
    .bdrv_aio_readv         = curl_aio_readv,
627 769ce76d Alexander Graf
};
628 769ce76d Alexander Graf
629 769ce76d Alexander Graf
static BlockDriver bdrv_https = {
630 8e6d58cd Kevin Wolf
    .format_name            = "https",
631 8e6d58cd Kevin Wolf
    .protocol_name          = "https",
632 769ce76d Alexander Graf
633 8e6d58cd Kevin Wolf
    .instance_size          = sizeof(BDRVCURLState),
634 8e6d58cd Kevin Wolf
    .bdrv_parse_filename    = curl_parse_filename,
635 8e6d58cd Kevin Wolf
    .bdrv_file_open         = curl_open,
636 8e6d58cd Kevin Wolf
    .bdrv_close             = curl_close,
637 8e6d58cd Kevin Wolf
    .bdrv_getlength         = curl_getlength,
638 769ce76d Alexander Graf
639 8e6d58cd Kevin Wolf
    .bdrv_aio_readv         = curl_aio_readv,
640 769ce76d Alexander Graf
};
641 769ce76d Alexander Graf
642 769ce76d Alexander Graf
static BlockDriver bdrv_ftp = {
643 8e6d58cd Kevin Wolf
    .format_name            = "ftp",
644 8e6d58cd Kevin Wolf
    .protocol_name          = "ftp",
645 769ce76d Alexander Graf
646 8e6d58cd Kevin Wolf
    .instance_size          = sizeof(BDRVCURLState),
647 8e6d58cd Kevin Wolf
    .bdrv_parse_filename    = curl_parse_filename,
648 8e6d58cd Kevin Wolf
    .bdrv_file_open         = curl_open,
649 8e6d58cd Kevin Wolf
    .bdrv_close             = curl_close,
650 8e6d58cd Kevin Wolf
    .bdrv_getlength         = curl_getlength,
651 769ce76d Alexander Graf
652 8e6d58cd Kevin Wolf
    .bdrv_aio_readv         = curl_aio_readv,
653 769ce76d Alexander Graf
};
654 769ce76d Alexander Graf
655 769ce76d Alexander Graf
static BlockDriver bdrv_ftps = {
656 8e6d58cd Kevin Wolf
    .format_name            = "ftps",
657 8e6d58cd Kevin Wolf
    .protocol_name          = "ftps",
658 769ce76d Alexander Graf
659 8e6d58cd Kevin Wolf
    .instance_size          = sizeof(BDRVCURLState),
660 8e6d58cd Kevin Wolf
    .bdrv_parse_filename    = curl_parse_filename,
661 8e6d58cd Kevin Wolf
    .bdrv_file_open         = curl_open,
662 8e6d58cd Kevin Wolf
    .bdrv_close             = curl_close,
663 8e6d58cd Kevin Wolf
    .bdrv_getlength         = curl_getlength,
664 769ce76d Alexander Graf
665 8e6d58cd Kevin Wolf
    .bdrv_aio_readv         = curl_aio_readv,
666 769ce76d Alexander Graf
};
667 769ce76d Alexander Graf
668 769ce76d Alexander Graf
static BlockDriver bdrv_tftp = {
669 8e6d58cd Kevin Wolf
    .format_name            = "tftp",
670 8e6d58cd Kevin Wolf
    .protocol_name          = "tftp",
671 769ce76d Alexander Graf
672 8e6d58cd Kevin Wolf
    .instance_size          = sizeof(BDRVCURLState),
673 8e6d58cd Kevin Wolf
    .bdrv_parse_filename    = curl_parse_filename,
674 8e6d58cd Kevin Wolf
    .bdrv_file_open         = curl_open,
675 8e6d58cd Kevin Wolf
    .bdrv_close             = curl_close,
676 8e6d58cd Kevin Wolf
    .bdrv_getlength         = curl_getlength,
677 769ce76d Alexander Graf
678 8e6d58cd Kevin Wolf
    .bdrv_aio_readv         = curl_aio_readv,
679 769ce76d Alexander Graf
};
680 769ce76d Alexander Graf
681 769ce76d Alexander Graf
static void curl_block_init(void)
682 769ce76d Alexander Graf
{
683 769ce76d Alexander Graf
    bdrv_register(&bdrv_http);
684 769ce76d Alexander Graf
    bdrv_register(&bdrv_https);
685 769ce76d Alexander Graf
    bdrv_register(&bdrv_ftp);
686 769ce76d Alexander Graf
    bdrv_register(&bdrv_ftps);
687 769ce76d Alexander Graf
    bdrv_register(&bdrv_tftp);
688 769ce76d Alexander Graf
}
689 769ce76d Alexander Graf
690 769ce76d Alexander Graf
block_init(curl_block_init);