[thirdparty/systemd.git] / src / import / curl-util.c

/* SPDX-License-Identifier: LGPL-2.1+ */

#include <fcntl.h>

#include "alloc-util.h"
#include "build.h"
#include "curl-util.h"
#include "fd-util.h"
#include "locale-util.h"
#include "string-util.h"

static void curl_glue_check_finished(CurlGlue *g) {
        CURLMsg *msg;
        int k = 0;

        assert(g);

        msg = curl_multi_info_read(g->curl, &k);
        if (!msg)
                return;

        if (msg->msg != CURLMSG_DONE)
                return;

        if (g->on_finished)
                g->on_finished(g, msg->easy_handle, msg->data.result);
}

static int curl_glue_on_io(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
        CurlGlue *g = userdata;
        int action, k = 0;

        assert(s);
        assert(g);

        if (FLAGS_SET(revents, EPOLLIN | EPOLLOUT))
                action = CURL_POLL_INOUT;
        else if (revents & EPOLLIN)
                action = CURL_POLL_IN;
        else if (revents & EPOLLOUT)
                action = CURL_POLL_OUT;
        else
                action = 0;

        if (curl_multi_socket_action(g->curl, fd, action, &k) != CURLM_OK)
                return log_debug_errno(SYNTHETIC_ERRNO(EINVAL),
                                       "Failed to propagate IO event.");

        curl_glue_check_finished(g);
        return 0;
}

static int curl_glue_socket_callback(CURLM *curl, curl_socket_t s, int action, void *userdata, void *socketp) {
        sd_event_source *io = socketp;
        CurlGlue *g = userdata;
        uint32_t events = 0;
        int r;

        assert(curl);
        assert(g);

        if (action == CURL_POLL_REMOVE) {
                if (io) {
                        sd_event_source_disable_unref(io);

                        hashmap_remove(g->ios, FD_TO_PTR(s));
                }

                return 0;
        }

        r = hashmap_ensure_allocated(&g->ios, &trivial_hash_ops);
        if (r < 0) {
                log_oom();
                return -1;
        }

        if (action == CURL_POLL_IN)
                events = EPOLLIN;
        else if (action == CURL_POLL_OUT)
                events = EPOLLOUT;
        else if (action == CURL_POLL_INOUT)
                events = EPOLLIN|EPOLLOUT;

        if (io) {
                if (sd_event_source_set_io_events(io, events) < 0)
                        return -1;

                if (sd_event_source_set_enabled(io, SD_EVENT_ON) < 0)
                        return -1;
        } else {
                if (sd_event_add_io(g->event, &io, s, events, curl_glue_on_io, g) < 0)
                        return -1;

                if (curl_multi_assign(g->curl, s, io) != CURLM_OK)
                        return -1;

                (void) sd_event_source_set_description(io, "curl-io");

                r = hashmap_put(g->ios, FD_TO_PTR(s), io);
                if (r < 0) {
                        log_oom();
                        sd_event_source_unref(io);
                        return -1;
                }
        }

        return 0;
}

static int curl_glue_on_timer(sd_event_source *s, uint64_t usec, void *userdata) {
        CurlGlue *g = userdata;
        int k = 0;

        assert(s);
        assert(g);

        if (curl_multi_socket_action(g->curl, CURL_SOCKET_TIMEOUT, 0, &k) != CURLM_OK)
                return log_debug_errno(SYNTHETIC_ERRNO(EINVAL),
                                       "Failed to propagate timeout.");

        curl_glue_check_finished(g);
        return 0;
}

static int curl_glue_timer_callback(CURLM *curl, long timeout_ms, void *userdata) {
        CurlGlue *g = userdata;
        usec_t usec;

        assert(curl);
        assert(g);

        if (timeout_ms < 0) {
                if (g->timer) {
                        if (sd_event_source_set_enabled(g->timer, SD_EVENT_OFF) < 0)
                                return -1;
                }

                return 0;
        }

        usec = (usec_t) timeout_ms * USEC_PER_MSEC + USEC_PER_MSEC - 1;

        if (g->timer) {
                if (sd_event_source_set_time_relative(g->timer, usec) < 0)
                        return -1;

                if (sd_event_source_set_enabled(g->timer, SD_EVENT_ONESHOT) < 0)
                        return -1;
        } else {
                if (sd_event_add_time_relative(g->event, &g->timer, clock_boottime_or_monotonic(), usec, 0, curl_glue_on_timer, g) < 0)
                        return -1;

                (void) sd_event_source_set_description(g->timer, "curl-timer");
        }

        return 0;
}

CurlGlue *curl_glue_unref(CurlGlue *g) {
        sd_event_source *io;

        if (!g)
                return NULL;

        if (g->curl)
                curl_multi_cleanup(g->curl);

        while ((io = hashmap_steal_first(g->ios)))
                sd_event_source_unref(io);

        hashmap_free(g->ios);

        sd_event_source_unref(g->timer);
        sd_event_unref(g->event);
        return mfree(g);
}

int curl_glue_new(CurlGlue **glue, sd_event *event) {
        _cleanup_(curl_glue_unrefp) CurlGlue *g = NULL;
        _cleanup_(curl_multi_cleanupp) CURL *c = NULL;
        _cleanup_(sd_event_unrefp) sd_event *e = NULL;
        int r;

        if (event)
                e = sd_event_ref(event);
        else {
                r = sd_event_default(&e);
                if (r < 0)
                        return r;
        }

        c = curl_multi_init();
        if (!c)
                return -ENOMEM;

        g = new(CurlGlue, 1);
        if (!g)
                return -ENOMEM;

        *g = (CurlGlue) {
                .event = TAKE_PTR(e),
                .curl = TAKE_PTR(c),
        };

        if (curl_multi_setopt(g->curl, CURLMOPT_SOCKETDATA, g) != CURLM_OK)
                return -EINVAL;

        if (curl_multi_setopt(g->curl, CURLMOPT_SOCKETFUNCTION, curl_glue_socket_callback) != CURLM_OK)
                return -EINVAL;

        if (curl_multi_setopt(g->curl, CURLMOPT_TIMERDATA, g) != CURLM_OK)
                return -EINVAL;

        if (curl_multi_setopt(g->curl, CURLMOPT_TIMERFUNCTION, curl_glue_timer_callback) != CURLM_OK)
                return -EINVAL;

        *glue = TAKE_PTR(g);

        return 0;
}

int curl_glue_make(CURL **ret, const char *url, void *userdata) {
        _cleanup_(curl_easy_cleanupp) CURL *c = NULL;
        const char *useragent;

        assert(ret);
        assert(url);

        c = curl_easy_init();
        if (!c)
                return -ENOMEM;

        /* curl_easy_setopt(c, CURLOPT_VERBOSE, 1L); */

        if (curl_easy_setopt(c, CURLOPT_URL, url) != CURLE_OK)
                return -EIO;

        if (curl_easy_setopt(c, CURLOPT_PRIVATE, userdata) != CURLE_OK)
                return -EIO;

        useragent = strjoina(program_invocation_short_name, "/" GIT_VERSION);
        if (curl_easy_setopt(c, CURLOPT_USERAGENT, useragent) != CURLE_OK)
                return -EIO;

        if (curl_easy_setopt(c, CURLOPT_FOLLOWLOCATION, 1L) != CURLE_OK)
                return -EIO;

        if (curl_easy_setopt(c, CURLOPT_NOSIGNAL, 1L) != CURLE_OK)
                return -EIO;

        if (curl_easy_setopt(c, CURLOPT_LOW_SPEED_TIME, 60L) != CURLE_OK)
                return -EIO;

        if (curl_easy_setopt(c, CURLOPT_LOW_SPEED_LIMIT, 30L) != CURLE_OK)
                return -EIO;

        *ret = TAKE_PTR(c);
        return 0;
}

int curl_glue_add(CurlGlue *g, CURL *c) {
        assert(g);
        assert(c);

        if (curl_multi_add_handle(g->curl, c) != CURLM_OK)
                return -EIO;

        return 0;
}

void curl_glue_remove_and_free(CurlGlue *g, CURL *c) {
        assert(g);

        if (!c)
                return;

        if (g->curl)
                curl_multi_remove_handle(g->curl, c);

        curl_easy_cleanup(c);
}

struct curl_slist *curl_slist_new(const char *first, ...) {
        struct curl_slist *l;
        va_list ap;

        if (!first)
                return NULL;

        l = curl_slist_append(NULL, first);
        if (!l)
                return NULL;

        va_start(ap, first);

        for (;;) {
                struct curl_slist *n;
                const char *i;

                i = va_arg(ap, const char*);
                if (!i)
                        break;

                n = curl_slist_append(l, i);
                if (!n) {
                        va_end(ap);
                        curl_slist_free_all(l);
                        return NULL;
                }

                l = n;
        }

        va_end(ap);
        return l;
}

int curl_header_strdup(const void *contents, size_t sz, const char *field, char **value) {
        const char *p;
        char *s;

        p = memory_startswith_no_case(contents, sz, field);
        if (!p)
                return 0;

        sz -= p - (const char*) contents;

        if (memchr(p, 0, sz))
                return 0;

        /* Skip over preceding whitespace */
        while (sz > 0 && strchr(WHITESPACE, p[0])) {
                p++;
                sz--;
        }

        /* Truncate trailing whitespace */
        while (sz > 0 && strchr(WHITESPACE, p[sz-1]))
                sz--;

        s = strndup(p, sz);
        if (!s)
                return -ENOMEM;

        *value = s;
        return 1;
}

int curl_parse_http_time(const char *t, usec_t *ret) {
        _cleanup_(freelocalep) locale_t loc = (locale_t) 0;
        const char *e;
        struct tm tm;
        time_t v;

        assert(t);
        assert(ret);

        loc = newlocale(LC_TIME_MASK, "C", (locale_t) 0);
        if (loc == (locale_t) 0)
                return -errno;

        /* RFC822 */
        e = strptime_l(t, "%a, %d %b %Y %H:%M:%S %Z", &tm, loc);
        if (!e || *e != 0)
                /* RFC 850 */
                e = strptime_l(t, "%A, %d-%b-%y %H:%M:%S %Z", &tm, loc);
        if (!e || *e != 0)
                /* ANSI C */
                e = strptime_l(t, "%a %b %d %H:%M:%S %Y", &tm, loc);
        if (!e || *e != 0)
                return -EINVAL;

        v = timegm(&tm);
        if (v == (time_t) -1)
                return -EINVAL;

        *ret = (usec_t) v * USEC_PER_SEC;
        return 0;
}
Commit	Line	Data
53e1b683	1	/* SPDX-License-Identifier: LGPL-2.1+ */
72648326	2
ca78ad1d ZJS	3	#include <fcntl.h>
ca78ad1d ZJS	4
b5efdb8a	5	#include "alloc-util.h"
681bd2c5	6	#include "build.h"
72648326	7	#include "curl-util.h"
3ffd4af2	8	#include "fd-util.h"
e520e0fc	9	#include "locale-util.h"
3ffd4af2	10	#include "string-util.h"
72648326 LP	11
	12	static void curl_glue_check_finished(CurlGlue *g) {
	13	CURLMsg *msg;
	14	int k = 0;
	15
	16	assert(g);
	17
	18	msg = curl_multi_info_read(g->curl, &k);
	19	if (!msg)
	20	return;
	21
	22	if (msg->msg != CURLMSG_DONE)
	23	return;
	24
	25	if (g->on_finished)
	26	g->on_finished(g, msg->easy_handle, msg->data.result);
	27	}
	28
	29	static int curl_glue_on_io(sd_event_source s, int fd, uint32_t revents, void userdata) {
	30	CurlGlue *g = userdata;
d8c72e87	31	int action, k = 0;
72648326 LP	32
	33	assert(s);
	34	assert(g);
	35
d94a24ca	36	if (FLAGS_SET(revents, EPOLLIN \| EPOLLOUT))
72648326 LP	37	action = CURL_POLL_INOUT;
	38	else if (revents & EPOLLIN)
	39	action = CURL_POLL_IN;
	40	else if (revents & EPOLLOUT)
	41	action = CURL_POLL_OUT;
	42	else
	43	action = 0;
	44
d8c72e87	45	if (curl_multi_socket_action(g->curl, fd, action, &k) != CURLM_OK)
baaa35ad ZJS	46	return log_debug_errno(SYNTHETIC_ERRNO(EINVAL),
baaa35ad ZJS	47	"Failed to propagate IO event.");
72648326 LP	48
	49	curl_glue_check_finished(g);
	50	return 0;
	51	}
	52
	53	static int curl_glue_socket_callback(CURLM curl, curl_socket_t s, int action, void userdata, void *socketp) {
d8c72e87	54	sd_event_source *io = socketp;
72648326 LP	55	CurlGlue *g = userdata;
	56	uint32_t events = 0;
	57	int r;
	58
	59	assert(curl);
	60	assert(g);
	61
72648326 LP	62	if (action == CURL_POLL_REMOVE) {
72648326 LP	63	if (io) {
1d3fe304	64	sd_event_source_disable_unref(io);
72648326	65
23e096cc	66	hashmap_remove(g->ios, FD_TO_PTR(s));
72648326 LP	67	}
	68
	69	return 0;
	70	}
	71
	72	r = hashmap_ensure_allocated(&g->ios, &trivial_hash_ops);
	73	if (r < 0) {
	74	log_oom();
	75	return -1;
	76	}
	77
72648326 LP	78	if (action == CURL_POLL_IN)
	79	events = EPOLLIN;
	80	else if (action == CURL_POLL_OUT)
	81	events = EPOLLOUT;
	82	else if (action == CURL_POLL_INOUT)
	83	events = EPOLLIN\|EPOLLOUT;
	84
	85	if (io) {
	86	if (sd_event_source_set_io_events(io, events) < 0)
	87	return -1;
	88
	89	if (sd_event_source_set_enabled(io, SD_EVENT_ON) < 0)
	90	return -1;
	91	} else {
d8c72e87	92	if (sd_event_add_io(g->event, &io, s, events, curl_glue_on_io, g) < 0)
72648326 LP	93	return -1;
72648326 LP	94
d8c72e87	95	if (curl_multi_assign(g->curl, s, io) != CURLM_OK)
72648326 LP	96	return -1;
72648326 LP	97
edfd706d	98	(void) sd_event_source_set_description(io, "curl-io");
72648326	99
23e096cc	100	r = hashmap_put(g->ios, FD_TO_PTR(s), io);
72648326 LP	101	if (r < 0) {
	102	log_oom();
	103	sd_event_source_unref(io);
	104	return -1;
	105	}
72648326 LP	106	}
	107
	108	return 0;
	109	}
	110
	111	static int curl_glue_on_timer(sd_event_source s, uint64_t usec, void userdata) {
	112	CurlGlue *g = userdata;
	113	int k = 0;
	114
	115	assert(s);
	116	assert(g);
	117
baaa35ad ZJS	118	if (curl_multi_socket_action(g->curl, CURL_SOCKET_TIMEOUT, 0, &k) != CURLM_OK)
	119	return log_debug_errno(SYNTHETIC_ERRNO(EINVAL),
	120	"Failed to propagate timeout.");
72648326 LP	121
	122	curl_glue_check_finished(g);
	123	return 0;
	124	}
	125
	126	static int curl_glue_timer_callback(CURLM curl, long timeout_ms, void userdata) {
	127	CurlGlue *g = userdata;
	128	usec_t usec;
	129
	130	assert(curl);
	131	assert(g);
	132
	133	if (timeout_ms < 0) {
	134	if (g->timer) {
	135	if (sd_event_source_set_enabled(g->timer, SD_EVENT_OFF) < 0)
	136	return -1;
	137	}
	138
	139	return 0;
	140	}
	141
39cf0351	142	usec = (usec_t) timeout_ms * USEC_PER_MSEC + USEC_PER_MSEC - 1;
72648326 LP	143
72648326 LP	144	if (g->timer) {
39cf0351	145	if (sd_event_source_set_time_relative(g->timer, usec) < 0)
72648326 LP	146	return -1;
	147
	148	if (sd_event_source_set_enabled(g->timer, SD_EVENT_ONESHOT) < 0)
	149	return -1;
	150	} else {
39cf0351	151	if (sd_event_add_time_relative(g->event, &g->timer, clock_boottime_or_monotonic(), usec, 0, curl_glue_on_timer, g) < 0)
72648326 LP	152	return -1;
72648326 LP	153
edfd706d	154	(void) sd_event_source_set_description(g->timer, "curl-timer");
72648326 LP	155	}
	156
	157	return 0;
	158	}
	159
	160	CurlGlue curl_glue_unref(CurlGlue g) {
	161	sd_event_source *io;
	162
	163	if (!g)
	164	return NULL;
	165
	166	if (g->curl)
	167	curl_multi_cleanup(g->curl);
	168
38cd55b0	169	while ((io = hashmap_steal_first(g->ios)))
72648326	170	sd_event_source_unref(io);
72648326 LP	171
	172	hashmap_free(g->ios);
	173
	174	sd_event_source_unref(g->timer);
	175	sd_event_unref(g->event);
6b430fdb	176	return mfree(g);
72648326 LP	177	}
	178
	179	int curl_glue_new(CurlGlue *glue, sd_event event) {
	180	_cleanup_(curl_glue_unrefp) CurlGlue *g = NULL;
0d94088e YW	181	_cleanup_(curl_multi_cleanupp) CURL *c = NULL;
0d94088e YW	182	_cleanup_(sd_event_unrefp) sd_event *e = NULL;
72648326 LP	183	int r;
72648326 LP	184
72648326	185	if (event)
0d94088e	186	e = sd_event_ref(event);
72648326	187	else {
0d94088e	188	r = sd_event_default(&e);
72648326 LP	189	if (r < 0)
	190	return r;
	191	}
	192
0d94088e YW	193	c = curl_multi_init();
0d94088e YW	194	if (!c)
72648326 LP	195	return -ENOMEM;
72648326 LP	196
0d94088e YW	197	g = new(CurlGlue, 1);
	198	if (!g)
	199	return -ENOMEM;
	200
	201	*g = (CurlGlue) {
	202	.event = TAKE_PTR(e),
	203	.curl = TAKE_PTR(c),
	204	};
	205
72648326 LP	206	if (curl_multi_setopt(g->curl, CURLMOPT_SOCKETDATA, g) != CURLM_OK)
	207	return -EINVAL;
	208
	209	if (curl_multi_setopt(g->curl, CURLMOPT_SOCKETFUNCTION, curl_glue_socket_callback) != CURLM_OK)
	210	return -EINVAL;
	211
	212	if (curl_multi_setopt(g->curl, CURLMOPT_TIMERDATA, g) != CURLM_OK)
	213	return -EINVAL;
	214
	215	if (curl_multi_setopt(g->curl, CURLMOPT_TIMERFUNCTION, curl_glue_timer_callback) != CURLM_OK)
	216	return -EINVAL;
	217
1cc6c93a	218	*glue = TAKE_PTR(g);
72648326 LP	219
	220	return 0;
	221	}
	222
	223	int curl_glue_make(CURL *ret, const char url, void *userdata) {
c3e65800	224	_cleanup_(curl_easy_cleanupp) CURL *c = NULL;
72648326	225	const char *useragent;
72648326 LP	226
	227	assert(ret);
	228	assert(url);
	229
	230	c = curl_easy_init();
	231	if (!c)
	232	return -ENOMEM;
	233
	234	/* curl_easy_setopt(c, CURLOPT_VERBOSE, 1L); */
	235
c3e65800 YW	236	if (curl_easy_setopt(c, CURLOPT_URL, url) != CURLE_OK)
c3e65800 YW	237	return -EIO;
72648326	238
c3e65800 YW	239	if (curl_easy_setopt(c, CURLOPT_PRIVATE, userdata) != CURLE_OK)
c3e65800 YW	240	return -EIO;
72648326	241
681bd2c5	242	useragent = strjoina(program_invocation_short_name, "/" GIT_VERSION);
c3e65800 YW	243	if (curl_easy_setopt(c, CURLOPT_USERAGENT, useragent) != CURLE_OK)
c3e65800 YW	244	return -EIO;
72648326	245
c3e65800 YW	246	if (curl_easy_setopt(c, CURLOPT_FOLLOWLOCATION, 1L) != CURLE_OK)
c3e65800 YW	247	return -EIO;
f85df818 LP	248
	249	if (curl_easy_setopt(c, CURLOPT_NOSIGNAL, 1L) != CURLE_OK)
	250	return -EIO;
72648326	251
d076f9fd LP	252	if (curl_easy_setopt(c, CURLOPT_LOW_SPEED_TIME, 60L) != CURLE_OK)
	253	return -EIO;
	254
	255	if (curl_easy_setopt(c, CURLOPT_LOW_SPEED_LIMIT, 30L) != CURLE_OK)
	256	return -EIO;
	257
67577508	258	*ret = TAKE_PTR(c);
72648326	259	return 0;
72648326 LP	260	}
	261
	262	int curl_glue_add(CurlGlue g, CURL c) {
	263	assert(g);
	264	assert(c);
	265
	266	if (curl_multi_add_handle(g->curl, c) != CURLM_OK)
	267	return -EIO;
	268
	269	return 0;
	270	}
	271
	272	void curl_glue_remove_and_free(CurlGlue g, CURL c) {
	273	assert(g);
	274
	275	if (!c)
	276	return;
	277
	278	if (g->curl)
	279	curl_multi_remove_handle(g->curl, c);
	280
	281	curl_easy_cleanup(c);
	282	}
	283
	284	struct curl_slist curl_slist_new(const char first, ...) {
	285	struct curl_slist *l;
	286	va_list ap;
	287
	288	if (!first)
	289	return NULL;
	290
	291	l = curl_slist_append(NULL, first);
	292	if (!l)
	293	return NULL;
	294
	295	va_start(ap, first);
	296
	297	for (;;) {
	298	struct curl_slist *n;
	299	const char *i;
	300
	301	i = va_arg(ap, const char*);
	302	if (!i)
	303	break;
	304
	305	n = curl_slist_append(l, i);
	306	if (!n) {
	307	va_end(ap);
	308	curl_slist_free_all(l);
	309	return NULL;
	310	}
	311
	312	l = n;
	313	}
	314
	315	va_end(ap);
	316	return l;
	317	}
	318
	319	int curl_header_strdup(const void contents, size_t sz, const char field, char **value) {
d27b725a	320	const char *p;
72648326 LP	321	char *s;
72648326 LP	322
21224070	323	p = memory_startswith_no_case(contents, sz, field);
d27b725a	324	if (!p)
72648326 LP	325	return 0;
72648326 LP	326
d27b725a	327	sz -= p - (const char*) contents;
72648326 LP	328
	329	if (memchr(p, 0, sz))
	330	return 0;
	331
5238e957	332	/* Skip over preceding whitespace */
72648326 LP	333	while (sz > 0 && strchr(WHITESPACE, p[0])) {
	334	p++;
	335	sz--;
	336	}
	337
13e785f7	338	/* Truncate trailing whitespace */
72648326 LP	339	while (sz > 0 && strchr(WHITESPACE, p[sz-1]))
	340	sz--;
	341
	342	s = strndup(p, sz);
	343	if (!s)
	344	return -ENOMEM;
	345
	346	*value = s;
	347	return 1;
	348	}
90199220	349
5fa89b2c	350	int curl_parse_http_time(const char t, usec_t ret) {
e520e0fc	351	_cleanup_(freelocalep) locale_t loc = (locale_t) 0;
0193ad26	352	const char *e;
90199220 LP	353	struct tm tm;
	354	time_t v;
	355
	356	assert(t);
	357	assert(ret);
	358
0193ad26 CR	359	loc = newlocale(LC_TIME_MASK, "C", (locale_t) 0);
	360	if (loc == (locale_t) 0)
	361	return -errno;
	362
	363	/* RFC822 */
	364	e = strptime_l(t, "%a, %d %b %Y %H:%M:%S %Z", &tm, loc);
	365	if (!e \|\| *e != 0)
	366	/* RFC 850 */
	367	e = strptime_l(t, "%A, %d-%b-%y %H:%M:%S %Z", &tm, loc);
	368	if (!e \|\| *e != 0)
	369	/* ANSI C */
	370	e = strptime_l(t, "%a %b %d %H:%M:%S %Y", &tm, loc);
0193ad26 CR	371	if (!e \|\| *e != 0)
0193ad26 CR	372	return -EINVAL;
90199220	373
0193ad26	374	v = timegm(&tm);
90199220 LP	375	if (v == (time_t) -1)
	376	return -EINVAL;
	377
5fa89b2c	378	ret = (usec_t) v USEC_PER_SEC;
90199220 LP	379	return 0;
90199220 LP	380	}