1: /***************************************************************************
2: * _ _ ____ _
3: * Project ___| | | | _ \| |
4: * / __| | | | |_) | |
5: * | (__| |_| | _ <| |___
6: * \___|\___/|_| \_\_____|
7: *
8: * Copyright (C) 1998 - 2019, Daniel Stenberg, <daniel@haxx.se>, et al.
9: *
10: * This software is licensed as described in the file COPYING, which
11: * you should have received as part of this distribution. The terms
12: * are also available at https://curl.haxx.se/docs/copyright.html.
13: *
14: * You may opt to use, copy, modify, merge, publish, distribute and/or sell
15: * copies of the Software, and permit persons to whom the Software is
16: * furnished to do so, under the terms of the COPYING file.
17: *
18: * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19: * KIND, either express or implied.
20: *
21: ***************************************************************************/
22: /* <DESC>
23: * multi socket API usage with libevent 2
24: * </DESC>
25: */
26: /* Example application source code using the multi socket interface to
27: download many files at once.
28:
29: Written by Jeff Pohlmeyer
30:
31: Requires libevent version 2 and a (POSIX?) system that has mkfifo().
32:
33: This is an adaptation of libcurl's "hipev.c" and libevent's "event-test.c"
34: sample programs.
35:
36: When running, the program creates the named pipe "hiper.fifo"
37:
38: Whenever there is input into the fifo, the program reads the input as a list
39: of URL's and creates some new easy handles to fetch each URL via the
40: curl_multi "hiper" API.
41:
42:
43: Thus, you can try a single URL:
44: % echo http://www.yahoo.com > hiper.fifo
45:
46: Or a whole bunch of them:
47: % cat my-url-list > hiper.fifo
48:
49: The fifo buffer is handled almost instantly, so you can even add more URL's
50: while the previous requests are still being downloaded.
51:
52: Note:
53: For the sake of simplicity, URL length is limited to 1023 char's !
54:
55: This is purely a demo app, all retrieved data is simply discarded by the write
56: callback.
57:
58: */
59:
60: #include <stdio.h>
61: #include <string.h>
62: #include <stdlib.h>
63: #include <sys/time.h>
64: #include <time.h>
65: #include <unistd.h>
66: #include <sys/poll.h>
67: #include <curl/curl.h>
68: #include <event2/event.h>
69: #include <event2/event_struct.h>
70: #include <fcntl.h>
71: #include <sys/stat.h>
72: #include <errno.h>
73: #include <sys/cdefs.h>
74:
75: #define MSG_OUT stdout /* Send info to stdout, change to stderr if you want */
76:
77:
78: /* Global information, common to all connections */
79: typedef struct _GlobalInfo
80: {
81: struct event_base *evbase;
82: struct event fifo_event;
83: struct event timer_event;
84: CURLM *multi;
85: int still_running;
86: FILE *input;
87: int stopped;
88: } GlobalInfo;
89:
90:
91: /* Information associated with a specific easy handle */
92: typedef struct _ConnInfo
93: {
94: CURL *easy;
95: char *url;
96: GlobalInfo *global;
97: char error[CURL_ERROR_SIZE];
98: } ConnInfo;
99:
100:
101: /* Information associated with a specific socket */
102: typedef struct _SockInfo
103: {
104: curl_socket_t sockfd;
105: CURL *easy;
106: int action;
107: long timeout;
108: struct event ev;
109: GlobalInfo *global;
110: } SockInfo;
111:
112: #define mycase(code) \
113: case code: s = __STRING(code)
114:
115: /* Die if we get a bad CURLMcode somewhere */
116: static void mcode_or_die(const char *where, CURLMcode code)
117: {
118: if(CURLM_OK != code) {
119: const char *s;
120: switch(code) {
121: mycase(CURLM_BAD_HANDLE); break;
122: mycase(CURLM_BAD_EASY_HANDLE); break;
123: mycase(CURLM_OUT_OF_MEMORY); break;
124: mycase(CURLM_INTERNAL_ERROR); break;
125: mycase(CURLM_UNKNOWN_OPTION); break;
126: mycase(CURLM_LAST); break;
127: default: s = "CURLM_unknown"; break;
128: mycase(CURLM_BAD_SOCKET);
129: fprintf(MSG_OUT, "ERROR: %s returns %s\n", where, s);
130: /* ignore this error */
131: return;
132: }
133: fprintf(MSG_OUT, "ERROR: %s returns %s\n", where, s);
134: exit(code);
135: }
136: }
137:
138:
139: /* Update the event timer after curl_multi library calls */
140: static int multi_timer_cb(CURLM *multi, long timeout_ms, GlobalInfo *g)
141: {
142: struct timeval timeout;
143: (void)multi;
144:
145: timeout.tv_sec = timeout_ms/1000;
146: timeout.tv_usec = (timeout_ms%1000)*1000;
147: fprintf(MSG_OUT, "multi_timer_cb: Setting timeout to %ld ms\n", timeout_ms);
148:
149: /*
150: * if timeout_ms is -1, just delete the timer
151: *
152: * For all other values of timeout_ms, this should set or *update* the timer
153: * to the new value
154: */
155: if(timeout_ms == -1)
156: evtimer_del(&g->timer_event);
157: else /* includes timeout zero */
158: evtimer_add(&g->timer_event, &timeout);
159: return 0;
160: }
161:
162:
163: /* Check for completed transfers, and remove their easy handles */
164: static void check_multi_info(GlobalInfo *g)
165: {
166: char *eff_url;
167: CURLMsg *msg;
168: int msgs_left;
169: ConnInfo *conn;
170: CURL *easy;
171: CURLcode res;
172:
173: fprintf(MSG_OUT, "REMAINING: %d\n", g->still_running);
174: while((msg = curl_multi_info_read(g->multi, &msgs_left))) {
175: if(msg->msg == CURLMSG_DONE) {
176: easy = msg->easy_handle;
177: res = msg->data.result;
178: curl_easy_getinfo(easy, CURLINFO_PRIVATE, &conn);
179: curl_easy_getinfo(easy, CURLINFO_EFFECTIVE_URL, &eff_url);
180: fprintf(MSG_OUT, "DONE: %s => (%d) %s\n", eff_url, res, conn->error);
181: curl_multi_remove_handle(g->multi, easy);
182: free(conn->url);
183: curl_easy_cleanup(easy);
184: free(conn);
185: }
186: }
187: if(g->still_running == 0 && g->stopped)
188: event_base_loopbreak(g->evbase);
189: }
190:
191:
192:
193: /* Called by libevent when we get action on a multi socket */
194: static void event_cb(int fd, short kind, void *userp)
195: {
196: GlobalInfo *g = (GlobalInfo*) userp;
197: CURLMcode rc;
198:
199: int action =
200: ((kind & EV_READ) ? CURL_CSELECT_IN : 0) |
201: ((kind & EV_WRITE) ? CURL_CSELECT_OUT : 0);
202:
203: rc = curl_multi_socket_action(g->multi, fd, action, &g->still_running);
204: mcode_or_die("event_cb: curl_multi_socket_action", rc);
205:
206: check_multi_info(g);
207: if(g->still_running <= 0) {
208: fprintf(MSG_OUT, "last transfer done, kill timeout\n");
209: if(evtimer_pending(&g->timer_event, NULL)) {
210: evtimer_del(&g->timer_event);
211: }
212: }
213: }
214:
215:
216:
217: /* Called by libevent when our timeout expires */
218: static void timer_cb(int fd, short kind, void *userp)
219: {
220: GlobalInfo *g = (GlobalInfo *)userp;
221: CURLMcode rc;
222: (void)fd;
223: (void)kind;
224:
225: rc = curl_multi_socket_action(g->multi,
226: CURL_SOCKET_TIMEOUT, 0, &g->still_running);
227: mcode_or_die("timer_cb: curl_multi_socket_action", rc);
228: check_multi_info(g);
229: }
230:
231:
232:
233: /* Clean up the SockInfo structure */
234: static void remsock(SockInfo *f)
235: {
236: if(f) {
237: event_del(&f->ev);
238: free(f);
239: }
240: }
241:
242:
243:
244: /* Assign information to a SockInfo structure */
245: static void setsock(SockInfo *f, curl_socket_t s, CURL *e, int act,
246: GlobalInfo *g)
247: {
248: int kind =
249: ((act & CURL_POLL_IN) ? EV_READ : 0) |
250: ((act & CURL_POLL_OUT) ? EV_WRITE : 0) | EV_PERSIST;
251:
252: f->sockfd = s;
253: f->action = act;
254: f->easy = e;
255: event_del(&f->ev);
256: event_assign(&f->ev, g->evbase, f->sockfd, kind, event_cb, g);
257: event_add(&f->ev, NULL);
258: }
259:
260:
261:
262: /* Initialize a new SockInfo structure */
263: static void addsock(curl_socket_t s, CURL *easy, int action, GlobalInfo *g)
264: {
265: SockInfo *fdp = calloc(sizeof(SockInfo), 1);
266:
267: fdp->global = g;
268: setsock(fdp, s, easy, action, g);
269: curl_multi_assign(g->multi, s, fdp);
270: }
271:
272: /* CURLMOPT_SOCKETFUNCTION */
273: static int sock_cb(CURL *e, curl_socket_t s, int what, void *cbp, void *sockp)
274: {
275: GlobalInfo *g = (GlobalInfo*) cbp;
276: SockInfo *fdp = (SockInfo*) sockp;
277: const char *whatstr[]={ "none", "IN", "OUT", "INOUT", "REMOVE" };
278:
279: fprintf(MSG_OUT,
280: "socket callback: s=%d e=%p what=%s ", s, e, whatstr[what]);
281: if(what == CURL_POLL_REMOVE) {
282: fprintf(MSG_OUT, "\n");
283: remsock(fdp);
284: }
285: else {
286: if(!fdp) {
287: fprintf(MSG_OUT, "Adding data: %s\n", whatstr[what]);
288: addsock(s, e, what, g);
289: }
290: else {
291: fprintf(MSG_OUT,
292: "Changing action from %s to %s\n",
293: whatstr[fdp->action], whatstr[what]);
294: setsock(fdp, s, e, what, g);
295: }
296: }
297: return 0;
298: }
299:
300:
301:
302: /* CURLOPT_WRITEFUNCTION */
303: static size_t write_cb(void *ptr, size_t size, size_t nmemb, void *data)
304: {
305: (void)ptr;
306: (void)data;
307: return size * nmemb;
308: }
309:
310:
311: /* CURLOPT_PROGRESSFUNCTION */
312: static int prog_cb(void *p, double dltotal, double dlnow, double ult,
313: double uln)
314: {
315: ConnInfo *conn = (ConnInfo *)p;
316: (void)ult;
317: (void)uln;
318:
319: fprintf(MSG_OUT, "Progress: %s (%g/%g)\n", conn->url, dlnow, dltotal);
320: return 0;
321: }
322:
323:
324: /* Create a new easy handle, and add it to the global curl_multi */
325: static void new_conn(char *url, GlobalInfo *g)
326: {
327: ConnInfo *conn;
328: CURLMcode rc;
329:
330: conn = calloc(1, sizeof(ConnInfo));
331: conn->error[0]='\0';
332:
333: conn->easy = curl_easy_init();
334: if(!conn->easy) {
335: fprintf(MSG_OUT, "curl_easy_init() failed, exiting!\n");
336: exit(2);
337: }
338: conn->global = g;
339: conn->url = strdup(url);
340: curl_easy_setopt(conn->easy, CURLOPT_URL, conn->url);
341: curl_easy_setopt(conn->easy, CURLOPT_WRITEFUNCTION, write_cb);
342: curl_easy_setopt(conn->easy, CURLOPT_WRITEDATA, conn);
343: curl_easy_setopt(conn->easy, CURLOPT_VERBOSE, 1L);
344: curl_easy_setopt(conn->easy, CURLOPT_ERRORBUFFER, conn->error);
345: curl_easy_setopt(conn->easy, CURLOPT_PRIVATE, conn);
346: curl_easy_setopt(conn->easy, CURLOPT_NOPROGRESS, 0L);
347: curl_easy_setopt(conn->easy, CURLOPT_PROGRESSFUNCTION, prog_cb);
348: curl_easy_setopt(conn->easy, CURLOPT_PROGRESSDATA, conn);
349: curl_easy_setopt(conn->easy, CURLOPT_FOLLOWLOCATION, 1L);
350: fprintf(MSG_OUT,
351: "Adding easy %p to multi %p (%s)\n", conn->easy, g->multi, url);
352: rc = curl_multi_add_handle(g->multi, conn->easy);
353: mcode_or_die("new_conn: curl_multi_add_handle", rc);
354:
355: /* note that the add_handle() will set a time-out to trigger very soon so
356: that the necessary socket_action() call will be called by this app */
357: }
358:
359: /* This gets called whenever data is received from the fifo */
360: static void fifo_cb(int fd, short event, void *arg)
361: {
362: char s[1024];
363: long int rv = 0;
364: int n = 0;
365: GlobalInfo *g = (GlobalInfo *)arg;
366: (void)fd;
367: (void)event;
368:
369: do {
370: s[0]='\0';
371: rv = fscanf(g->input, "%1023s%n", s, &n);
372: s[n]='\0';
373: if(n && s[0]) {
374: if(!strcmp(s, "stop")) {
375: g->stopped = 1;
376: if(g->still_running == 0)
377: event_base_loopbreak(g->evbase);
378: }
379: else
380: new_conn(s, arg); /* if we read a URL, go get it! */
381: }
382: else
383: break;
384: } while(rv != EOF);
385: }
386:
387: /* Create a named pipe and tell libevent to monitor it */
388: static const char *fifo = "hiper.fifo";
389: static int init_fifo(GlobalInfo *g)
390: {
391: struct stat st;
392: curl_socket_t sockfd;
393:
394: fprintf(MSG_OUT, "Creating named pipe \"%s\"\n", fifo);
395: if(lstat (fifo, &st) == 0) {
396: if((st.st_mode & S_IFMT) == S_IFREG) {
397: errno = EEXIST;
398: perror("lstat");
399: exit(1);
400: }
401: }
402: unlink(fifo);
403: if(mkfifo (fifo, 0600) == -1) {
404: perror("mkfifo");
405: exit(1);
406: }
407: sockfd = open(fifo, O_RDWR | O_NONBLOCK, 0);
408: if(sockfd == -1) {
409: perror("open");
410: exit(1);
411: }
412: g->input = fdopen(sockfd, "r");
413:
414: fprintf(MSG_OUT, "Now, pipe some URL's into > %s\n", fifo);
415: event_assign(&g->fifo_event, g->evbase, sockfd, EV_READ|EV_PERSIST,
416: fifo_cb, g);
417: event_add(&g->fifo_event, NULL);
418: return (0);
419: }
420:
421: static void clean_fifo(GlobalInfo *g)
422: {
423: event_del(&g->fifo_event);
424: fclose(g->input);
425: unlink(fifo);
426: }
427:
428: int main(int argc, char **argv)
429: {
430: GlobalInfo g;
431: (void)argc;
432: (void)argv;
433:
434: memset(&g, 0, sizeof(GlobalInfo));
435: g.evbase = event_base_new();
436: init_fifo(&g);
437: g.multi = curl_multi_init();
438: evtimer_assign(&g.timer_event, g.evbase, timer_cb, &g);
439:
440: /* setup the generic multi interface options we want */
441: curl_multi_setopt(g.multi, CURLMOPT_SOCKETFUNCTION, sock_cb);
442: curl_multi_setopt(g.multi, CURLMOPT_SOCKETDATA, &g);
443: curl_multi_setopt(g.multi, CURLMOPT_TIMERFUNCTION, multi_timer_cb);
444: curl_multi_setopt(g.multi, CURLMOPT_TIMERDATA, &g);
445:
446: /* we don't call any curl_multi_socket*() function yet as we have no handles
447: added! */
448:
449: event_base_dispatch(g.evbase);
450:
451: /* this, of course, won't get called since only way to stop this program is
452: via ctrl-C, but it is here to show how cleanup /would/ be done. */
453: clean_fifo(&g);
454: event_del(&g.timer_event);
455: event_base_free(g.evbase);
456: curl_multi_cleanup(g.multi);
457: return 0;
458: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to hiperfifo.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / docs / examples