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