[qemu.git] / block / curl.c

/*
 * QEMU Block driver for CURL images
 *
 * Copyright (c) 2009 Alexander Graf <[email protected]>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#include "qemu-common.h"
#include "block_int.h"
#include <curl/curl.h>

// #define DEBUG
// #define DEBUG_VERBOSE

#ifdef DEBUG_CURL
#define DPRINTF(fmt, ...) do { printf(fmt, ## __VA_ARGS__); } while (0)
#else
#define DPRINTF(fmt, ...) do { } while (0)
#endif

#define CURL_NUM_STATES 8
#define CURL_NUM_ACB    8
#define SECTOR_SIZE     512
#define READ_AHEAD_SIZE (256 * 1024)

#define FIND_RET_NONE   0
#define FIND_RET_OK     1
#define FIND_RET_WAIT   2

struct BDRVCURLState;

typedef struct CURLAIOCB {
    BlockDriverAIOCB common;
    QEMUBH *bh;
    QEMUIOVector *qiov;

    int64_t sector_num;
    int nb_sectors;

    size_t start;
    size_t end;
} CURLAIOCB;

typedef struct CURLState
{
    struct BDRVCURLState *s;
    CURLAIOCB *acb[CURL_NUM_ACB];
    CURL *curl;
    char *orig_buf;
    size_t buf_start;
    size_t buf_off;
    size_t buf_len;
    char range[128];
    char errmsg[CURL_ERROR_SIZE];
    char in_use;
} CURLState;

typedef struct BDRVCURLState {
    CURLM *multi;
    size_t len;
    CURLState states[CURL_NUM_STATES];
    char *url;
    size_t readahead_size;
} BDRVCURLState;

static void curl_clean_state(CURLState *s);
static void curl_multi_do(void *arg);
static int curl_aio_flush(void *opaque);

static int curl_sock_cb(CURL *curl, curl_socket_t fd, int action,
                        void *s, void *sp)
{
    DPRINTF("CURL (AIO): Sock action %d on fd %d\n", action, fd);
    switch (action) {
        case CURL_POLL_IN:
            qemu_aio_set_fd_handler(fd, curl_multi_do, NULL, curl_aio_flush,
                                    NULL, s);
            break;
        case CURL_POLL_OUT:
            qemu_aio_set_fd_handler(fd, NULL, curl_multi_do, curl_aio_flush,
                                    NULL, s);
            break;
        case CURL_POLL_INOUT:
            qemu_aio_set_fd_handler(fd, curl_multi_do, curl_multi_do,
                                    curl_aio_flush, NULL, s);
            break;
        case CURL_POLL_REMOVE:
            qemu_aio_set_fd_handler(fd, NULL, NULL, NULL, NULL, NULL);
            break;
    }

    return 0;
}

static size_t curl_size_cb(void *ptr, size_t size, size_t nmemb, void *opaque)
{
    CURLState *s = ((CURLState*)opaque);
    size_t realsize = size * nmemb;
    size_t fsize;

    if(sscanf(ptr, "Content-Length: %zd", &fsize) == 1) {
        s->s->len = fsize;
    }

    return realsize;
}

static size_t curl_read_cb(void *ptr, size_t size, size_t nmemb, void *opaque)
{
    CURLState *s = ((CURLState*)opaque);
    size_t realsize = size * nmemb;
    int i;

    DPRINTF("CURL: Just reading %zd bytes\n", realsize);

    if (!s || !s->orig_buf)
        goto read_end;

    memcpy(s->orig_buf + s->buf_off, ptr, realsize);
    s->buf_off += realsize;

    for(i=0; i<CURL_NUM_ACB; i++) {
        CURLAIOCB *acb = s->acb[i];

        if (!acb)
            continue;

        if ((s->buf_off >= acb->end)) {
            qemu_iovec_from_buffer(acb->qiov, s->orig_buf + acb->start,
                                   acb->end - acb->start);
            acb->common.cb(acb->common.opaque, 0);
            qemu_aio_release(acb);
            s->acb[i] = NULL;
        }
    }

read_end:
    return realsize;
}

static int curl_find_buf(BDRVCURLState *s, size_t start, size_t len,
                         CURLAIOCB *acb)
{
    int i;
    size_t end = start + len;

    for (i=0; i<CURL_NUM_STATES; i++) {
        CURLState *state = &s->states[i];
        size_t buf_end = (state->buf_start + state->buf_off);
        size_t buf_fend = (state->buf_start + state->buf_len);

        if (!state->orig_buf)
            continue;
        if (!state->buf_off)
            continue;

        // Does the existing buffer cover our section?
        if ((start >= state->buf_start) &&
            (start <= buf_end) &&
            (end >= state->buf_start) &&
            (end <= buf_end))
        {
            char *buf = state->orig_buf + (start - state->buf_start);

            qemu_iovec_from_buffer(acb->qiov, buf, len);
            acb->common.cb(acb->common.opaque, 0);

            return FIND_RET_OK;
        }

        // Wait for unfinished chunks
        if ((start >= state->buf_start) &&
            (start <= buf_fend) &&
            (end >= state->buf_start) &&
            (end <= buf_fend))
        {
            int j;

            acb->start = start - state->buf_start;
            acb->end = acb->start + len;

            for (j=0; j<CURL_NUM_ACB; j++) {
                if (!state->acb[j]) {
                    state->acb[j] = acb;
                    return FIND_RET_WAIT;
                }
            }
        }
    }

    return FIND_RET_NONE;
}

static void curl_multi_do(void *arg)
{
    BDRVCURLState *s = (BDRVCURLState *)arg;
    int running;
    int r;
    int msgs_in_queue;

    if (!s->multi)
        return;

    do {
        r = curl_multi_socket_all(s->multi, &running);
    } while(r == CURLM_CALL_MULTI_PERFORM);

    /* Try to find done transfers, so we can free the easy
     * handle again. */
    do {
        CURLMsg *msg;
        msg = curl_multi_info_read(s->multi, &msgs_in_queue);

        if (!msg)
            break;
        if (msg->msg == CURLMSG_NONE)
            break;

        switch (msg->msg) {
            case CURLMSG_DONE:
            {
                CURLState *state = NULL;
                curl_easy_getinfo(msg->easy_handle, CURLINFO_PRIVATE, (char**)&state);

                /* ACBs for successful messages get completed in curl_read_cb */
                if (msg->data.result != CURLE_OK) {
                    int i;
                    for (i = 0; i < CURL_NUM_ACB; i++) {
                        CURLAIOCB *acb = state->acb[i];

                        if (acb == NULL) {
                            continue;
                        }

                        acb->common.cb(acb->common.opaque, -EIO);
                        qemu_aio_release(acb);
                        state->acb[i] = NULL;
                    }
                }

                curl_clean_state(state);
                break;
            }
            default:
                msgs_in_queue = 0;
                break;
        }
    } while(msgs_in_queue);
}

static CURLState *curl_init_state(BDRVCURLState *s)
{
    CURLState *state = NULL;
    int i, j;

    do {
        for (i=0; i<CURL_NUM_STATES; i++) {
            for (j=0; j<CURL_NUM_ACB; j++)
                if (s->states[i].acb[j])
                    continue;
            if (s->states[i].in_use)
                continue;

            state = &s->states[i];
            state->in_use = 1;
            break;
        }
        if (!state) {
            usleep(100);
            curl_multi_do(s);
        }
    } while(!state);

    if (state->curl)
        goto has_curl;

    state->curl = curl_easy_init();
    if (!state->curl)
        return NULL;
    curl_easy_setopt(state->curl, CURLOPT_URL, s->url);
    curl_easy_setopt(state->curl, CURLOPT_TIMEOUT, 5);
    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);

#ifdef DEBUG_VERBOSE
    curl_easy_setopt(state->curl, CURLOPT_VERBOSE, 1);
#endif

has_curl:

    state->s = s;

    return state;
}

static void curl_clean_state(CURLState *s)
{
    if (s->s->multi)
        curl_multi_remove_handle(s->s->multi, s->curl);
    s->in_use = 0;
}

static int curl_open(BlockDriverState *bs, const char *filename, int flags)
{
    BDRVCURLState *s = bs->opaque;
    CURLState *state = NULL;
    double d;

    #define RA_OPTSTR ":readahead="
    char *file;
    char *ra;
    const char *ra_val;
    int parse_state = 0;

    static int inited = 0;

    file = g_strdup(filename);
    s->readahead_size = READ_AHEAD_SIZE;

    /* Parse a trailing ":readahead=#:" param, if present. */
    ra = file + strlen(file) - 1;
    while (ra >= file) {
        if (parse_state == 0) {
            if (*ra == ':')
                parse_state++;
            else
                break;
        } else if (parse_state == 1) {
            if (*ra > '9' || *ra < '0') {
                char *opt_start = ra - strlen(RA_OPTSTR) + 1;
                if (opt_start > file &&
                    strncmp(opt_start, RA_OPTSTR, strlen(RA_OPTSTR)) == 0) {
                    ra_val = ra + 1;
                    ra -= strlen(RA_OPTSTR) - 1;
                    *ra = '\0';
                    s->readahead_size = atoi(ra_val);
                    break;
                } else {
                    break;
                }
            }
        }
        ra--;
    }

    if ((s->readahead_size & 0x1ff) != 0) {
        fprintf(stderr, "HTTP_READAHEAD_SIZE %zd is not a multiple of 512\n",
                s->readahead_size);
        goto out_noclean;
    }

    if (!inited) {
        curl_global_init(CURL_GLOBAL_ALL);
        inited = 1;
    }

    DPRINTF("CURL: Opening %s\n", file);
    s->url = file;
    state = curl_init_state(s);
    if (!state)
        goto out_noclean;

    // Get file size

    curl_easy_setopt(state->curl, CURLOPT_NOBODY, 1);
    curl_easy_setopt(state->curl, CURLOPT_WRITEFUNCTION, (void *)curl_size_cb);
    if (curl_easy_perform(state->curl))
        goto out;
    curl_easy_getinfo(state->curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &d);
    curl_easy_setopt(state->curl, CURLOPT_WRITEFUNCTION, (void *)curl_read_cb);
    curl_easy_setopt(state->curl, CURLOPT_NOBODY, 0);
    if (d)
        s->len = (size_t)d;
    else if(!s->len)
        goto out;
    DPRINTF("CURL: Size = %zd\n", s->len);

    curl_clean_state(state);
    curl_easy_cleanup(state->curl);
    state->curl = NULL;

    // Now we know the file exists and its size, so let's
    // initialize the multi interface!

    s->multi = curl_multi_init();
    curl_multi_setopt( s->multi, CURLMOPT_SOCKETDATA, s); 
    curl_multi_setopt( s->multi, CURLMOPT_SOCKETFUNCTION, curl_sock_cb ); 
    curl_multi_do(s);

    return 0;

out:
    fprintf(stderr, "CURL: Error opening file: %s\n", state->errmsg);
    curl_easy_cleanup(state->curl);
    state->curl = NULL;
out_noclean:
    g_free(file);
    return -EINVAL;
}

static int curl_aio_flush(void *opaque)
{
    BDRVCURLState *s = opaque;
    int i, j;

    for (i=0; i < CURL_NUM_STATES; i++) {
        for(j=0; j < CURL_NUM_ACB; j++) {
            if (s->states[i].acb[j]) {
                return 1;
            }
        }
    }
    return 0;
}

static void curl_aio_cancel(BlockDriverAIOCB *blockacb)
{
    // Do we have to implement canceling? Seems to work without...
}

static AIOPool curl_aio_pool = {
    .aiocb_size         = sizeof(CURLAIOCB),
    .cancel             = curl_aio_cancel,
};


static void curl_readv_bh_cb(void *p)
{
    CURLState *state;

    CURLAIOCB *acb = p;
    BDRVCURLState *s = acb->common.bs->opaque;

    qemu_bh_delete(acb->bh);
    acb->bh = NULL;

    size_t start = acb->sector_num * SECTOR_SIZE;
    size_t end;

    // In case we have the requested data already (e.g. read-ahead),
    // we can just call the callback and be done.
    switch (curl_find_buf(s, start, acb->nb_sectors * SECTOR_SIZE, acb)) {
        case FIND_RET_OK:
            qemu_aio_release(acb);
            // fall through
        case FIND_RET_WAIT:
            return;
        default:
            break;
    }

    // No cache found, so let's start a new request
    state = curl_init_state(s);
    if (!state) {
        acb->common.cb(acb->common.opaque, -EIO);
        qemu_aio_release(acb);
        return;
    }

    acb->start = 0;
    acb->end = (acb->nb_sectors * SECTOR_SIZE);

    state->buf_off = 0;
    if (state->orig_buf)
        g_free(state->orig_buf);
    state->buf_start = start;
    state->buf_len = acb->end + s->readahead_size;
    end = MIN(start + state->buf_len, s->len) - 1;
    state->orig_buf = g_malloc(state->buf_len);
    state->acb[0] = acb;

    snprintf(state->range, 127, "%zd-%zd", start, end);
    DPRINTF("CURL (AIO): Reading %d at %zd (%s)\n",
            (acb->nb_sectors * SECTOR_SIZE), start, state->range);
    curl_easy_setopt(state->curl, CURLOPT_RANGE, state->range);

    curl_multi_add_handle(s->multi, state->curl);
    curl_multi_do(s);

}

static BlockDriverAIOCB *curl_aio_readv(BlockDriverState *bs,
        int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
        BlockDriverCompletionFunc *cb, void *opaque)
{
    CURLAIOCB *acb;

    acb = qemu_aio_get(&curl_aio_pool, bs, cb, opaque);

    if (!acb) {
        return NULL;
    }

    acb->qiov = qiov;
    acb->sector_num = sector_num;
    acb->nb_sectors = nb_sectors;

    acb->bh = qemu_bh_new(curl_readv_bh_cb, acb);

    if (!acb->bh) {
        DPRINTF("CURL: qemu_bh_new failed\n");
        return NULL;
    }

    qemu_bh_schedule(acb->bh);
    return &acb->common;
}

static void curl_close(BlockDriverState *bs)
{
    BDRVCURLState *s = bs->opaque;
    int i;

    DPRINTF("CURL: Close\n");
    for (i=0; i<CURL_NUM_STATES; i++) {
        if (s->states[i].in_use)
            curl_clean_state(&s->states[i]);
        if (s->states[i].curl) {
            curl_easy_cleanup(s->states[i].curl);
            s->states[i].curl = NULL;
        }
        if (s->states[i].orig_buf) {
            g_free(s->states[i].orig_buf);
            s->states[i].orig_buf = NULL;
        }
    }
    if (s->multi)
        curl_multi_cleanup(s->multi);
    if (s->url)
        free(s->url);
}

static int64_t curl_getlength(BlockDriverState *bs)
{
    BDRVCURLState *s = bs->opaque;
    return s->len;
}

static BlockDriver bdrv_http = {
    .format_name     = "http",
    .protocol_name   = "http",

    .instance_size   = sizeof(BDRVCURLState),
    .bdrv_file_open  = curl_open,
    .bdrv_close      = curl_close,
    .bdrv_getlength  = curl_getlength,

    .bdrv_aio_readv  = curl_aio_readv,
};

static BlockDriver bdrv_https = {
    .format_name     = "https",
    .protocol_name   = "https",

    .instance_size   = sizeof(BDRVCURLState),
    .bdrv_file_open  = curl_open,
    .bdrv_close      = curl_close,
    .bdrv_getlength  = curl_getlength,

    .bdrv_aio_readv  = curl_aio_readv,
};

static BlockDriver bdrv_ftp = {
    .format_name     = "ftp",
    .protocol_name   = "ftp",

    .instance_size   = sizeof(BDRVCURLState),
    .bdrv_file_open  = curl_open,
    .bdrv_close      = curl_close,
    .bdrv_getlength  = curl_getlength,

    .bdrv_aio_readv  = curl_aio_readv,
};

static BlockDriver bdrv_ftps = {
    .format_name     = "ftps",
    .protocol_name   = "ftps",

    .instance_size   = sizeof(BDRVCURLState),
    .bdrv_file_open  = curl_open,
    .bdrv_close      = curl_close,
    .bdrv_getlength  = curl_getlength,

    .bdrv_aio_readv  = curl_aio_readv,
};

static BlockDriver bdrv_tftp = {
    .format_name     = "tftp",
    .protocol_name   = "tftp",

    .instance_size   = sizeof(BDRVCURLState),
    .bdrv_file_open  = curl_open,
    .bdrv_close      = curl_close,
    .bdrv_getlength  = curl_getlength,

    .bdrv_aio_readv  = curl_aio_readv,
};

static void curl_block_init(void)
{
    bdrv_register(&bdrv_http);
    bdrv_register(&bdrv_https);
    bdrv_register(&bdrv_ftp);
    bdrv_register(&bdrv_ftps);
    bdrv_register(&bdrv_tftp);
}

block_init(curl_block_init);
Commit	Line	Data
769ce76d AG	1	/*
	2	* QEMU Block driver for CURL images
	3	*
	4	* Copyright (c) 2009 Alexander Graf <[email protected]>
	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	*/
	24	#include "qemu-common.h"
	25	#include "block_int.h"
	26	#include <curl/curl.h>
	27
	28	// #define DEBUG
	29	// #define DEBUG_VERBOSE
	30
	31	#ifdef DEBUG_CURL
d0f2c4c6	32	#define DPRINTF(fmt, ...) do { printf(fmt, ## __VA_ARGS__); } while (0)
769ce76d	33	#else
d0f2c4c6	34	#define DPRINTF(fmt, ...) do { } while (0)
769ce76d AG	35	#endif
	36
	37	#define CURL_NUM_STATES 8
	38	#define CURL_NUM_ACB 8
	39	#define SECTOR_SIZE 512
	40	#define READ_AHEAD_SIZE (256 * 1024)
	41
	42	#define FIND_RET_NONE 0
	43	#define FIND_RET_OK 1
	44	#define FIND_RET_WAIT 2
	45
	46	struct BDRVCURLState;
	47
	48	typedef struct CURLAIOCB {
	49	BlockDriverAIOCB common;
363c3c85	50	QEMUBH *bh;
769ce76d	51	QEMUIOVector *qiov;
363c3c85 NT	52
	53	int64_t sector_num;
	54	int nb_sectors;
	55
769ce76d AG	56	size_t start;
	57	size_t end;
	58	} CURLAIOCB;
	59
	60	typedef struct CURLState
	61	{
	62	struct BDRVCURLState *s;
	63	CURLAIOCB *acb[CURL_NUM_ACB];
	64	CURL *curl;
	65	char *orig_buf;
	66	size_t buf_start;
	67	size_t buf_off;
	68	size_t buf_len;
	69	char range[128];
	70	char errmsg[CURL_ERROR_SIZE];
	71	char in_use;
	72	} CURLState;
	73
	74	typedef struct BDRVCURLState {
	75	CURLM *multi;
	76	size_t len;
	77	CURLState states[CURL_NUM_STATES];
	78	char *url;
c76f4952	79	size_t readahead_size;
769ce76d AG	80	} BDRVCURLState;
	81
	82	static void curl_clean_state(CURLState *s);
	83	static void curl_multi_do(void *arg);
c84dcdc1	84	static int curl_aio_flush(void *opaque);
769ce76d AG	85
	86	static int curl_sock_cb(CURL *curl, curl_socket_t fd, int action,
	87	void s, void sp)
	88	{
d0f2c4c6	89	DPRINTF("CURL (AIO): Sock action %d on fd %d\n", action, fd);
769ce76d AG	90	switch (action) {
769ce76d AG	91	case CURL_POLL_IN:
c84dcdc1 NT	92	qemu_aio_set_fd_handler(fd, curl_multi_do, NULL, curl_aio_flush,
c84dcdc1 NT	93	NULL, s);
769ce76d AG	94	break;
769ce76d AG	95	case CURL_POLL_OUT:
c84dcdc1 NT	96	qemu_aio_set_fd_handler(fd, NULL, curl_multi_do, curl_aio_flush,
c84dcdc1 NT	97	NULL, s);
769ce76d AG	98	break;
769ce76d AG	99	case CURL_POLL_INOUT:
c84dcdc1 NT	100	qemu_aio_set_fd_handler(fd, curl_multi_do, curl_multi_do,
c84dcdc1 NT	101	curl_aio_flush, NULL, s);
769ce76d AG	102	break;
769ce76d AG	103	case CURL_POLL_REMOVE:
8febfa26	104	qemu_aio_set_fd_handler(fd, NULL, NULL, NULL, NULL, NULL);
769ce76d AG	105	break;
	106	}
	107
	108	return 0;
	109	}
	110
	111	static size_t curl_size_cb(void ptr, size_t size, size_t nmemb, void opaque)
	112	{
	113	CURLState s = ((CURLState)opaque);
	114	size_t realsize = size * nmemb;
0bfcd599	115	size_t fsize;
769ce76d	116
0bfcd599	117	if(sscanf(ptr, "Content-Length: %zd", &fsize) == 1) {
769ce76d	118	s->s->len = fsize;
0bfcd599	119	}
769ce76d AG	120
	121	return realsize;
	122	}
	123
	124	static size_t curl_read_cb(void ptr, size_t size, size_t nmemb, void opaque)
	125	{
	126	CURLState s = ((CURLState)opaque);
	127	size_t realsize = size * nmemb;
	128	int i;
	129
0bfcd599	130	DPRINTF("CURL: Just reading %zd bytes\n", realsize);
769ce76d AG	131
	132	if (!s \|\| !s->orig_buf)
	133	goto read_end;
	134
	135	memcpy(s->orig_buf + s->buf_off, ptr, realsize);
	136	s->buf_off += realsize;
	137
	138	for(i=0; i<CURL_NUM_ACB; i++) {
	139	CURLAIOCB *acb = s->acb[i];
	140
	141	if (!acb)
	142	continue;
	143
	144	if ((s->buf_off >= acb->end)) {
	145	qemu_iovec_from_buffer(acb->qiov, s->orig_buf + acb->start,
	146	acb->end - acb->start);
	147	acb->common.cb(acb->common.opaque, 0);
	148	qemu_aio_release(acb);
	149	s->acb[i] = NULL;
	150	}
	151	}
	152
	153	read_end:
	154	return realsize;
	155	}
	156
	157	static int curl_find_buf(BDRVCURLState *s, size_t start, size_t len,
	158	CURLAIOCB *acb)
	159	{
	160	int i;
	161	size_t end = start + len;
	162
	163	for (i=0; i<CURL_NUM_STATES; i++) {
	164	CURLState *state = &s->states[i];
	165	size_t buf_end = (state->buf_start + state->buf_off);
	166	size_t buf_fend = (state->buf_start + state->buf_len);
	167
	168	if (!state->orig_buf)
	169	continue;
	170	if (!state->buf_off)
	171	continue;
	172
	173	// Does the existing buffer cover our section?
	174	if ((start >= state->buf_start) &&
	175	(start <= buf_end) &&
	176	(end >= state->buf_start) &&
	177	(end <= buf_end))
	178	{
	179	char *buf = state->orig_buf + (start - state->buf_start);
	180
	181	qemu_iovec_from_buffer(acb->qiov, buf, len);
	182	acb->common.cb(acb->common.opaque, 0);
	183
	184	return FIND_RET_OK;
	185	}
	186
	187	// Wait for unfinished chunks
	188	if ((start >= state->buf_start) &&
	189	(start <= buf_fend) &&
	190	(end >= state->buf_start) &&
	191	(end <= buf_fend))
	192	{
	193	int j;
	194
195	acb->start = start - state->buf_start;
196	acb->end = acb->start + len;
197
198	for (j=0; j<CURL_NUM_ACB; j++) {
199	if (!state->acb[j]) {
200	state->acb[j] = acb;
201	return FIND_RET_WAIT;
202	}
203	}
204	}
205	}
206
207	return FIND_RET_NONE;
208	}
209
210	static void curl_multi_do(void *arg)
211	{
212	BDRVCURLState s = (BDRVCURLState )arg;
213	int running;
214	int r;
215	int msgs_in_queue;
216
217	if (!s->multi)
218	return;
219
220	do {
221	r = curl_multi_socket_all(s->multi, &running);
222	} while(r == CURLM_CALL_MULTI_PERFORM);
223
224	/* Try to find done transfers, so we can free the easy
225	* handle again. */
226	do {
227	CURLMsg *msg;
228	msg = curl_multi_info_read(s->multi, &msgs_in_queue);
229
230	if (!msg)
231	break;
232	if (msg->msg == CURLMSG_NONE)
233	break;
234
235	switch (msg->msg) {
236	case CURLMSG_DONE:
237	{
238	CURLState *state = NULL;
239	curl_easy_getinfo(msg->easy_handle, CURLINFO_PRIVATE, (char**)&state);
f785a5ae NT	240
	241	/* ACBs for successful messages get completed in curl_read_cb */
	242	if (msg->data.result != CURLE_OK) {
	243	int i;
	244	for (i = 0; i < CURL_NUM_ACB; i++) {
	245	CURLAIOCB *acb = state->acb[i];
	246
	247	if (acb == NULL) {
	248	continue;
	249	}
	250
	251	acb->common.cb(acb->common.opaque, -EIO);
	252	qemu_aio_release(acb);
	253	state->acb[i] = NULL;
	254	}
	255	}
	256
769ce76d AG	257	curl_clean_state(state);
	258	break;
	259	}
	260	default:
	261	msgs_in_queue = 0;
	262	break;
	263	}
	264	} while(msgs_in_queue);
	265	}
	266
	267	static CURLState curl_init_state(BDRVCURLState s)
	268	{
	269	CURLState *state = NULL;
	270	int i, j;
	271
	272	do {
	273	for (i=0; i<CURL_NUM_STATES; i++) {
	274	for (j=0; j<CURL_NUM_ACB; j++)
	275	if (s->states[i].acb[j])
	276	continue;
	277	if (s->states[i].in_use)
	278	continue;
	279
	280	state = &s->states[i];
	281	state->in_use = 1;
	282	break;
	283	}
	284	if (!state) {
	285	usleep(100);
	286	curl_multi_do(s);
	287	}
	288	} while(!state);
	289
	290	if (state->curl)
	291	goto has_curl;
	292
	293	state->curl = curl_easy_init();
	294	if (!state->curl)
	295	return NULL;
	296	curl_easy_setopt(state->curl, CURLOPT_URL, s->url);
	297	curl_easy_setopt(state->curl, CURLOPT_TIMEOUT, 5);
df3cee1a	298	curl_easy_setopt(state->curl, CURLOPT_WRITEFUNCTION, (void *)curl_read_cb);
769ce76d AG	299	curl_easy_setopt(state->curl, CURLOPT_WRITEDATA, (void *)state);
	300	curl_easy_setopt(state->curl, CURLOPT_PRIVATE, (void *)state);
	301	curl_easy_setopt(state->curl, CURLOPT_AUTOREFERER, 1);
	302	curl_easy_setopt(state->curl, CURLOPT_FOLLOWLOCATION, 1);
	303	curl_easy_setopt(state->curl, CURLOPT_NOSIGNAL, 1);
	304	curl_easy_setopt(state->curl, CURLOPT_ERRORBUFFER, state->errmsg);
f785a5ae NT	305	curl_easy_setopt(state->curl, CURLOPT_FAILONERROR, 1);
f785a5ae NT	306
769ce76d AG	307	#ifdef DEBUG_VERBOSE
	308	curl_easy_setopt(state->curl, CURLOPT_VERBOSE, 1);
	309	#endif
	310
	311	has_curl:
	312
	313	state->s = s;
	314
	315	return state;
	316	}
	317
	318	static void curl_clean_state(CURLState *s)
	319	{
	320	if (s->s->multi)
	321	curl_multi_remove_handle(s->s->multi, s->curl);
	322	s->in_use = 0;
	323	}
	324
	325	static int curl_open(BlockDriverState bs, const char filename, int flags)
	326	{
	327	BDRVCURLState *s = bs->opaque;
	328	CURLState *state = NULL;
	329	double d;
c76f4952 N	330
	331	#define RA_OPTSTR ":readahead="
	332	char *file;
	333	char *ra;
	334	const char *ra_val;
	335	int parse_state = 0;
	336
769ce76d AG	337	static int inited = 0;
769ce76d AG	338
7267c094	339	file = g_strdup(filename);
c76f4952 N	340	s->readahead_size = READ_AHEAD_SIZE;
	341
	342	/* Parse a trailing ":readahead=#:" param, if present. */
	343	ra = file + strlen(file) - 1;
	344	while (ra >= file) {
	345	if (parse_state == 0) {
	346	if (*ra == ':')
	347	parse_state++;
	348	else
	349	break;
	350	} else if (parse_state == 1) {
	351	if (ra > '9' \|\| ra < '0') {
	352	char *opt_start = ra - strlen(RA_OPTSTR) + 1;
	353	if (opt_start > file &&
	354	strncmp(opt_start, RA_OPTSTR, strlen(RA_OPTSTR)) == 0) {
	355	ra_val = ra + 1;
	356	ra -= strlen(RA_OPTSTR) - 1;
	357	*ra = '\0';
	358	s->readahead_size = atoi(ra_val);
	359	break;
	360	} else {
	361	break;
	362	}
	363	}
	364	}
	365	ra--;
	366	}
	367
	368	if ((s->readahead_size & 0x1ff) != 0) {
48a402e6	369	fprintf(stderr, "HTTP_READAHEAD_SIZE %zd is not a multiple of 512\n",
c76f4952 N	370	s->readahead_size);
	371	goto out_noclean;
	372	}
	373
769ce76d AG	374	if (!inited) {
	375	curl_global_init(CURL_GLOBAL_ALL);
	376	inited = 1;
	377	}
	378
d0f2c4c6	379	DPRINTF("CURL: Opening %s\n", file);
c76f4952	380	s->url = file;
769ce76d AG	381	state = curl_init_state(s);
	382	if (!state)
	383	goto out_noclean;
	384
	385	// Get file size
	386
	387	curl_easy_setopt(state->curl, CURLOPT_NOBODY, 1);
df3cee1a	388	curl_easy_setopt(state->curl, CURLOPT_WRITEFUNCTION, (void *)curl_size_cb);
769ce76d AG	389	if (curl_easy_perform(state->curl))
	390	goto out;
	391	curl_easy_getinfo(state->curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &d);
df3cee1a	392	curl_easy_setopt(state->curl, CURLOPT_WRITEFUNCTION, (void *)curl_read_cb);
769ce76d AG	393	curl_easy_setopt(state->curl, CURLOPT_NOBODY, 0);
	394	if (d)
	395	s->len = (size_t)d;
	396	else if(!s->len)
	397	goto out;
0bfcd599	398	DPRINTF("CURL: Size = %zd\n", s->len);
769ce76d AG	399
	400	curl_clean_state(state);
	401	curl_easy_cleanup(state->curl);
	402	state->curl = NULL;
	403
	404	// Now we know the file exists and its size, so let's
	405	// initialize the multi interface!
	406
	407	s->multi = curl_multi_init();
	408	curl_multi_setopt( s->multi, CURLMOPT_SOCKETDATA, s);
	409	curl_multi_setopt( s->multi, CURLMOPT_SOCKETFUNCTION, curl_sock_cb );
	410	curl_multi_do(s);
	411
	412	return 0;
	413
	414	out:
	415	fprintf(stderr, "CURL: Error opening file: %s\n", state->errmsg);
	416	curl_easy_cleanup(state->curl);
	417	state->curl = NULL;
	418	out_noclean:
7267c094	419	g_free(file);
769ce76d AG	420	return -EINVAL;
	421	}
	422
c84dcdc1 NT	423	static int curl_aio_flush(void *opaque)
	424	{
	425	BDRVCURLState *s = opaque;
	426	int i, j;
	427
	428	for (i=0; i < CURL_NUM_STATES; i++) {
	429	for(j=0; j < CURL_NUM_ACB; j++) {
	430	if (s->states[i].acb[j]) {
	431	return 1;
	432	}
	433	}
	434	}
	435	return 0;
	436	}
	437
c16b5a2c CH	438	static void curl_aio_cancel(BlockDriverAIOCB *blockacb)
	439	{
	440	// Do we have to implement canceling? Seems to work without...
	441	}
	442
	443	static AIOPool curl_aio_pool = {
	444	.aiocb_size = sizeof(CURLAIOCB),
	445	.cancel = curl_aio_cancel,
	446	};
	447
363c3c85 NT	448
363c3c85 NT	449	static void curl_readv_bh_cb(void *p)
769ce76d	450	{
769ce76d AG	451	CURLState *state;
769ce76d AG	452
363c3c85 NT	453	CURLAIOCB *acb = p;
363c3c85 NT	454	BDRVCURLState *s = acb->common.bs->opaque;
769ce76d	455
363c3c85 NT	456	qemu_bh_delete(acb->bh);
	457	acb->bh = NULL;
	458
	459	size_t start = acb->sector_num * SECTOR_SIZE;
	460	size_t end;
769ce76d AG	461
	462	// In case we have the requested data already (e.g. read-ahead),
	463	// we can just call the callback and be done.
363c3c85	464	switch (curl_find_buf(s, start, acb->nb_sectors * SECTOR_SIZE, acb)) {
769ce76d AG	465	case FIND_RET_OK:
	466	qemu_aio_release(acb);
	467	// fall through
	468	case FIND_RET_WAIT:
363c3c85	469	return;
769ce76d AG	470	default:
	471	break;
	472	}
	473
	474	// No cache found, so let's start a new request
769ce76d	475	state = curl_init_state(s);
363c3c85 NT	476	if (!state) {
	477	acb->common.cb(acb->common.opaque, -EIO);
	478	qemu_aio_release(acb);
	479	return;
	480	}
769ce76d AG	481
769ce76d AG	482	acb->start = 0;
363c3c85	483	acb->end = (acb->nb_sectors * SECTOR_SIZE);
769ce76d AG	484
	485	state->buf_off = 0;
	486	if (state->orig_buf)
7267c094	487	g_free(state->orig_buf);
769ce76d	488	state->buf_start = start;
c76f4952	489	state->buf_len = acb->end + s->readahead_size;
769ce76d	490	end = MIN(start + state->buf_len, s->len) - 1;
7267c094	491	state->orig_buf = g_malloc(state->buf_len);
769ce76d AG	492	state->acb[0] = acb;
769ce76d AG	493
0bfcd599 BS	494	snprintf(state->range, 127, "%zd-%zd", start, end);
0bfcd599 BS	495	DPRINTF("CURL (AIO): Reading %d at %zd (%s)\n",
363c3c85	496	(acb->nb_sectors * SECTOR_SIZE), start, state->range);
769ce76d AG	497	curl_easy_setopt(state->curl, CURLOPT_RANGE, state->range);
	498
	499	curl_multi_add_handle(s->multi, state->curl);
	500	curl_multi_do(s);
	501
363c3c85 NT	502	}
	503
	504	static BlockDriverAIOCB curl_aio_readv(BlockDriverState bs,
	505	int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
	506	BlockDriverCompletionFunc cb, void opaque)
	507	{
	508	CURLAIOCB *acb;
	509
	510	acb = qemu_aio_get(&curl_aio_pool, bs, cb, opaque);
	511
	512	if (!acb) {
	513	return NULL;
	514	}
	515
	516	acb->qiov = qiov;
	517	acb->sector_num = sector_num;
	518	acb->nb_sectors = nb_sectors;
	519
	520	acb->bh = qemu_bh_new(curl_readv_bh_cb, acb);
	521
	522	if (!acb->bh) {
	523	DPRINTF("CURL: qemu_bh_new failed\n");
	524	return NULL;
	525	}
	526
	527	qemu_bh_schedule(acb->bh);
769ce76d AG	528	return &acb->common;
	529	}
	530
769ce76d AG	531	static void curl_close(BlockDriverState *bs)
	532	{
	533	BDRVCURLState *s = bs->opaque;
	534	int i;
	535
d0f2c4c6	536	DPRINTF("CURL: Close\n");
769ce76d AG	537	for (i=0; i<CURL_NUM_STATES; i++) {
	538	if (s->states[i].in_use)
	539	curl_clean_state(&s->states[i]);
	540	if (s->states[i].curl) {
	541	curl_easy_cleanup(s->states[i].curl);
	542	s->states[i].curl = NULL;
	543	}
	544	if (s->states[i].orig_buf) {
7267c094	545	g_free(s->states[i].orig_buf);
769ce76d AG	546	s->states[i].orig_buf = NULL;
	547	}
	548	}
	549	if (s->multi)
	550	curl_multi_cleanup(s->multi);
	551	if (s->url)
	552	free(s->url);
	553	}
	554
	555	static int64_t curl_getlength(BlockDriverState *bs)
	556	{
	557	BDRVCURLState *s = bs->opaque;
	558	return s->len;
	559	}
	560
	561	static BlockDriver bdrv_http = {
	562	.format_name = "http",
	563	.protocol_name = "http",
	564
	565	.instance_size = sizeof(BDRVCURLState),
66f82cee	566	.bdrv_file_open = curl_open,
769ce76d AG	567	.bdrv_close = curl_close,
	568	.bdrv_getlength = curl_getlength,
	569
769ce76d	570	.bdrv_aio_readv = curl_aio_readv,
769ce76d AG	571	};
	572
	573	static BlockDriver bdrv_https = {
	574	.format_name = "https",
	575	.protocol_name = "https",
	576
	577	.instance_size = sizeof(BDRVCURLState),
66f82cee	578	.bdrv_file_open = curl_open,
769ce76d AG	579	.bdrv_close = curl_close,
	580	.bdrv_getlength = curl_getlength,
	581
769ce76d	582	.bdrv_aio_readv = curl_aio_readv,
769ce76d AG	583	};
	584
	585	static BlockDriver bdrv_ftp = {
	586	.format_name = "ftp",
	587	.protocol_name = "ftp",
	588
	589	.instance_size = sizeof(BDRVCURLState),
66f82cee	590	.bdrv_file_open = curl_open,
769ce76d AG	591	.bdrv_close = curl_close,
	592	.bdrv_getlength = curl_getlength,
	593
769ce76d	594	.bdrv_aio_readv = curl_aio_readv,
769ce76d AG	595	};
	596
	597	static BlockDriver bdrv_ftps = {
	598	.format_name = "ftps",
	599	.protocol_name = "ftps",
	600
	601	.instance_size = sizeof(BDRVCURLState),
66f82cee	602	.bdrv_file_open = curl_open,
769ce76d AG	603	.bdrv_close = curl_close,
	604	.bdrv_getlength = curl_getlength,
	605
769ce76d	606	.bdrv_aio_readv = curl_aio_readv,
769ce76d AG	607	};
	608
	609	static BlockDriver bdrv_tftp = {
	610	.format_name = "tftp",
	611	.protocol_name = "tftp",
	612
	613	.instance_size = sizeof(BDRVCURLState),
66f82cee	614	.bdrv_file_open = curl_open,
769ce76d AG	615	.bdrv_close = curl_close,
	616	.bdrv_getlength = curl_getlength,
	617
769ce76d	618	.bdrv_aio_readv = curl_aio_readv,
769ce76d AG	619	};
	620
	621	static void curl_block_init(void)
	622	{
	623	bdrv_register(&bdrv_http);
	624	bdrv_register(&bdrv_https);
	625	bdrv_register(&bdrv_ftp);
	626	bdrv_register(&bdrv_ftps);
	627	bdrv_register(&bdrv_tftp);
	628	}
	629
	630	block_init(curl_block_init);