Annotation of embedaddon/curl/docs/examples/hiperfifo.c, revision 1.1
1.1 ! misho 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