docs/examples/fopen.c

   1 /*****************************************************************************
   2  *
   3  * This example source code introduces a c library buffered I/O interface to
   4  * URL reads it supports fopen(), fread(), fgets(), feof(), fclose(),
   5  * rewind(). Supported functions have identical prototypes to their normal c
   6  * lib namesakes and are preceaded by url_ .
   7  *
   8  * Using this code you can replace your program's fopen() with url_fopen()
   9  * and fread() with url_fread() and it become possible to read remote streams
  10  * instead of (only) local files. Local files (ie those that can be directly
  11  * fopened) will drop back to using the underlying clib implementations
  12  *
  13  * See the main() function at the bottom that shows an app that retrives from a
  14  * specified url using fgets() and fread() and saves as two output files.
  15  *
  16  * Copyright (c) 2003 Simtec Electronics
  17  *
  18  * Re-implemented by Vincent Sanders <vince@kyllikki.org> with extensive
  19  * reference to original curl example code
  20  *
  21  * Redistribution and use in source and binary forms, with or without
  22  * modification, are permitted provided that the following conditions
  23  * are met:
  24  * 1. Redistributions of source code must retain the above copyright
  25  *    notice, this list of conditions and the following disclaimer.
  26  * 2. Redistributions in binary form must reproduce the above copyright
  27  *    notice, this list of conditions and the following disclaimer in the
  28  *    documentation and/or other materials provided with the distribution.
  29  * 3. The name of the author may not be used to endorse or promote products
  30  *    derived from this software without specific prior written permission.
  31  *
  32  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  33  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  34  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  35  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  36  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  37  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  38  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  39  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  40  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  41  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  42  *
  43  * This example requires libcurl 7.9.7 or later.
  44  */
  45
  46 #include <stdio.h>
  47 #include <string.h>
  48 #ifndef WIN32
  49 #  include <sys/time.h>
  50 #endif
  51 #include <stdlib.h>
  52 #include <errno.h>
  53
  54 #include <curl/curl.h>
  55
  56 enum fcurl_type_e {
  57   CFTYPE_NONE=0,
  58   CFTYPE_FILE=1,
  59   CFTYPE_CURL=2
  60 };
  61
  62 struct fcurl_data
  63 {
  64   enum fcurl_type_e type;     /* type of handle */
  65   union {
  66     CURL *curl;
  67     FILE *file;
  68   } handle;                   /* handle */
  69
  70   char *buffer;               /* buffer to store cached data*/
  71   size_t buffer_len;          /* currently allocated buffers length */
  72   size_t buffer_pos;          /* end of data in buffer*/
  73   int still_running;          /* Is background url fetch still in progress */
  74 };
  75
  76 typedef struct fcurl_data URL_FILE;
  77
  78 /* exported functions */
  79 URL_FILE *url_fopen(const char *url,const char *operation);
  80 int url_fclose(URL_FILE *file);
  81 int url_feof(URL_FILE *file);
  82 size_t url_fread(void *ptr, size_t size, size_t nmemb, URL_FILE *file);
  83 char * url_fgets(char *ptr, size_t size, URL_FILE *file);
  84 void url_rewind(URL_FILE *file);
  85
  86 /* we use a global one for convenience */
  87 CURLM *multi_handle;
  88
  89 /* curl calls this routine to get more data */
  90 static size_t write_callback(char *buffer,
  91                              size_t size,
  92                              size_t nitems,
  93                              void *userp)
  94 {
  95   char *newbuff;
  96   size_t rembuff;
  97
  98   URL_FILE *url = (URL_FILE *)userp;
  99   size *= nitems;
 100
 101   rembuff=url->buffer_len - url->buffer_pos; /* remaining space in buffer */
 102
 103   if(size > rembuff) {
 104     /* not enough space in buffer */
 105     newbuff=realloc(url->buffer,url->buffer_len + (size - rembuff));
 106     if(newbuff==NULL) {
 107       fprintf(stderr,"callback buffer grow failed\n");
 108       size=rembuff;
 109     }
 110     else {
 111       /* realloc suceeded increase buffer size*/
 112       url->buffer_len+=size - rembuff;
 113       url->buffer=newbuff;
 114     }
 115   }
 116
 117   memcpy(&url->buffer[url->buffer_pos], buffer, size);
 118   url->buffer_pos += size;
 119
 120   return size;
 121 }
 122
 123 /* use to attempt to fill the read buffer up to requested number of bytes */
 124 static int fill_buffer(URL_FILE *file, size_t want)
 125 {
 126   fd_set fdread;
 127   fd_set fdwrite;
 128   fd_set fdexcep;
 129   struct timeval timeout;
 130   int rc;
 131   CURLMcode mc; /* curl_multi_fdset() return code */
 132
 133   /* only attempt to fill buffer if transactions still running and buffer
 134    * doesnt exceed required size already
 135    */
 136   if((!file->still_running) || (file->buffer_pos > want))
 137     return 0;
 138
 139   /* attempt to fill buffer */
 140   do {
 141     int maxfd = -1;
 142     long curl_timeo = -1;
 143
 144     FD_ZERO(&fdread);
 145     FD_ZERO(&fdwrite);
 146     FD_ZERO(&fdexcep);
 147
 148     /* set a suitable timeout to fail on */
 149     timeout.tv_sec = 60; /* 1 minute */
 150     timeout.tv_usec = 0;
 151
 152     curl_multi_timeout(multi_handle, &curl_timeo);
 153     if(curl_timeo >= 0) {
 154       timeout.tv_sec = curl_timeo / 1000;
 155       if(timeout.tv_sec > 1)
 156         timeout.tv_sec = 1;
 157       else
 158         timeout.tv_usec = (curl_timeo % 1000) * 1000;
 159     }
 160
 161     /* get file descriptors from the transfers */
 162     mc = curl_multi_fdset(multi_handle, &fdread, &fdwrite, &fdexcep, &maxfd);
 163
 164     if(mc != CURLM_OK)
 165     {
 166       fprintf(stderr, "curl_multi_fdset() failed, code %d.\n", mc);
 167       break;
 168     }
 169
 170     /* On success the value of maxfd is guaranteed to be >= -1. We call
 171        select(maxfd + 1, ...); specially in case of (maxfd == -1) there are
 172        no fds ready yet so we call select(0, ...) --or Sleep() on Windows--
 173        to sleep 100ms, which is the minimum suggested value in the
 174        curl_multi_fdset() doc. */
 175
 176     if(maxfd == -1) {
 177 #ifdef _WIN32
 178       Sleep(100);
 179       rc = 0;
 180 #else
 181       /* Portable sleep for platforms other than Windows. */
 182       struct timeval wait = { 0, 100 * 1000 }; /* 100ms */
 183       rc = select(0, NULL, NULL, NULL, &wait);
 184 #endif
 185     }
 186     else {
 187       /* Note that on some platforms 'timeout' may be modified by select().
 188          If you need access to the original value save a copy beforehand. */
 189       rc = select(maxfd+1, &fdread, &fdwrite, &fdexcep, &timeout);
 190     }
 191
 192     switch(rc) {
 193     case -1:
 194       /* select error */
 195       break;
 196
 197     case 0:
 198     default:
 199       /* timeout or readable/writable sockets */
 200       curl_multi_perform(multi_handle, &file->still_running);
 201       break;
 202     }
 203   } while(file->still_running && (file->buffer_pos < want));
 204   return 1;
 205 }
 206
 207 /* use to remove want bytes from the front of a files buffer */
 208 static int use_buffer(URL_FILE *file,int want)
 209 {
 210   /* sort out buffer */
 211   if((file->buffer_pos - want) <=0) {
 212     /* ditch buffer - write will recreate */
 213     if(file->buffer)
 214       free(file->buffer);
 215
 216     file->buffer=NULL;
 217     file->buffer_pos=0;
 218     file->buffer_len=0;
 219   }
 220   else {
 221     /* move rest down make it available for later */
 222     memmove(file->buffer,
 223             &file->buffer[want],
 224             (file->buffer_pos - want));
 225
 226     file->buffer_pos -= want;
 227   }
 228   return 0;
 229 }
 230
 231 URL_FILE *url_fopen(const char *url,const char *operation)
 232 {
 233   /* this code could check for URLs or types in the 'url' and
 234      basicly use the real fopen() for standard files */
 235
 236   URL_FILE *file;
 237   (void)operation;
 238
 239   file = malloc(sizeof(URL_FILE));
 240   if(!file)
 241     return NULL;
 242
 243   memset(file, 0, sizeof(URL_FILE));
 244
 245   if((file->handle.file=fopen(url,operation)))
 246     file->type = CFTYPE_FILE; /* marked as URL */
 247
 248   else {
 249     file->type = CFTYPE_CURL; /* marked as URL */
 250     file->handle.curl = curl_easy_init();
 251
 252     curl_easy_setopt(file->handle.curl, CURLOPT_URL, url);
 253     curl_easy_setopt(file->handle.curl, CURLOPT_WRITEDATA, file);
 254     curl_easy_setopt(file->handle.curl, CURLOPT_VERBOSE, 0L);
 255     curl_easy_setopt(file->handle.curl, CURLOPT_WRITEFUNCTION, write_callback);
 256
 257     if(!multi_handle)
 258       multi_handle = curl_multi_init();
 259
 260     curl_multi_add_handle(multi_handle, file->handle.curl);
 261
 262     /* lets start the fetch */
 263     curl_multi_perform(multi_handle, &file->still_running);
 264
 265     if((file->buffer_pos == 0) && (!file->still_running)) {
 266       /* if still_running is 0 now, we should return NULL */
 267
 268       /* make sure the easy handle is not in the multi handle anymore */
 269       curl_multi_remove_handle(multi_handle, file->handle.curl);
 270
 271       /* cleanup */
 272       curl_easy_cleanup(file->handle.curl);
 273
 274       free(file);
 275
 276       file = NULL;
 277     }
 278   }
 279   return file;
 280 }
 281
 282 int url_fclose(URL_FILE *file)
 283 {
 284   int ret=0;/* default is good return */
 285
 286   switch(file->type) {
 287   case CFTYPE_FILE:
 288     ret=fclose(file->handle.file); /* passthrough */
 289     break;
 290
 291   case CFTYPE_CURL:
 292     /* make sure the easy handle is not in the multi handle anymore */
 293     curl_multi_remove_handle(multi_handle, file->handle.curl);
 294
 295     /* cleanup */
 296     curl_easy_cleanup(file->handle.curl);
 297     break;
 298
 299   default: /* unknown or supported type - oh dear */
 300     ret=EOF;
 301     errno=EBADF;
 302     break;
 303   }
 304
 305   if(file->buffer)
 306     free(file->buffer);/* free any allocated buffer space */
 307
 308   free(file);
 309
 310   return ret;
 311 }
 312
 313 int url_feof(URL_FILE *file)
 314 {
 315   int ret=0;
 316
 317   switch(file->type) {
 318   case CFTYPE_FILE:
 319     ret=feof(file->handle.file);
 320     break;
 321
 322   case CFTYPE_CURL:
 323     if((file->buffer_pos == 0) && (!file->still_running))
 324       ret = 1;
 325     break;
 326
 327   default: /* unknown or supported type - oh dear */
 328     ret=-1;
 329     errno=EBADF;
 330     break;
 331   }
 332   return ret;
 333 }
 334
 335 size_t url_fread(void *ptr, size_t size, size_t nmemb, URL_FILE *file)
 336 {
 337   size_t want;
 338
 339   switch(file->type) {
 340   case CFTYPE_FILE:
 341     want=fread(ptr,size,nmemb,file->handle.file);
 342     break;
 343
 344   case CFTYPE_CURL:
 345     want = nmemb * size;
 346
 347     fill_buffer(file,want);
 348
 349     /* check if theres data in the buffer - if not fill_buffer()
 350      * either errored or EOF */
 351     if(!file->buffer_pos)
 352       return 0;
 353
 354     /* ensure only available data is considered */
 355     if(file->buffer_pos < want)
 356       want = file->buffer_pos;
 357
 358     /* xfer data to caller */
 359     memcpy(ptr, file->buffer, want);
 360
 361     use_buffer(file,want);
 362
 363     want = want / size;     /* number of items */
 364     break;
 365
 366   default: /* unknown or supported type - oh dear */
 367     want=0;
 368     errno=EBADF;
 369     break;
 370
 371   }
 372   return want;
 373 }
 374
 375 char *url_fgets(char *ptr, size_t size, URL_FILE *file)
 376 {
 377   size_t want = size - 1;/* always need to leave room for zero termination */
 378   size_t loop;
 379
 380   switch(file->type) {
 381   case CFTYPE_FILE:
 382     ptr = fgets(ptr,size,file->handle.file);
 383     break;
 384
 385   case CFTYPE_CURL:
 386     fill_buffer(file,want);
 387
 388     /* check if theres data in the buffer - if not fill either errored or
 389      * EOF */
 390     if(!file->buffer_pos)
 391       return NULL;
 392
 393     /* ensure only available data is considered */
 394     if(file->buffer_pos < want)
 395       want = file->buffer_pos;
 396
 397     /*buffer contains data */
 398     /* look for newline or eof */
 399     for(loop=0;loop < want;loop++) {
 400       if(file->buffer[loop] == '\n') {
 401         want=loop+1;/* include newline */
 402         break;
 403       }
 404     }
 405
 406     /* xfer data to caller */
 407     memcpy(ptr, file->buffer, want);
 408     ptr[want]=0;/* allways null terminate */
 409
 410     use_buffer(file,want);
 411
 412     break;
 413
 414   default: /* unknown or supported type - oh dear */
 415     ptr=NULL;
 416     errno=EBADF;
 417     break;
 418   }
 419
 420   return ptr;/*success */
 421 }
 422
 423 void url_rewind(URL_FILE *file)
 424 {
 425   switch(file->type) {
 426   case CFTYPE_FILE:
 427     rewind(file->handle.file); /* passthrough */
 428     break;
 429
 430   case CFTYPE_CURL:
 431     /* halt transaction */
 432     curl_multi_remove_handle(multi_handle, file->handle.curl);
 433
 434     /* restart */
 435     curl_multi_add_handle(multi_handle, file->handle.curl);
 436
 437     /* ditch buffer - write will recreate - resets stream pos*/
 438     if(file->buffer)
 439       free(file->buffer);
 440
 441     file->buffer=NULL;
 442     file->buffer_pos=0;
 443     file->buffer_len=0;
 444
 445     break;
 446
 447   default: /* unknown or supported type - oh dear */
 448     break;
 449   }
 450 }
 451
 452 /* Small main program to retrive from a url using fgets and fread saving the
 453  * output to two test files (note the fgets method will corrupt binary files if
 454  * they contain 0 chars */
 455 int main(int argc, char *argv[])
 456 {
 457   URL_FILE *handle;
 458   FILE *outf;
 459
 460   int nread;
 461   char buffer[256];
 462   const char *url;
 463
 464   if(argc < 2)
 465     url="http://192.168.7.3/testfile";/* default to testurl */
 466   else
 467     url=argv[1];/* use passed url */
 468
 469   /* copy from url line by line with fgets */
 470   outf=fopen("fgets.test","w+");
 471   if(!outf) {
 472     perror("couldn't open fgets output file\n");
 473     return 1;
 474   }
 475
 476   handle = url_fopen(url, "r");
 477   if(!handle) {
 478     printf("couldn't url_fopen() %s\n", url);
 479     fclose(outf);
 480     return 2;
 481   }
 482
 483   while(!url_feof(handle)) {
 484     url_fgets(buffer,sizeof(buffer),handle);
 485     fwrite(buffer,1,strlen(buffer),outf);
 486   }
 487
 488   url_fclose(handle);
 489
 490   fclose(outf);
 491
 492
 493   /* Copy from url with fread */
 494   outf=fopen("fread.test","w+");
 495   if(!outf) {
 496     perror("couldn't open fread output file\n");
 497     return 1;
 498   }
 499
 500   handle = url_fopen("testfile", "r");
 501   if(!handle) {
 502     printf("couldn't url_fopen() testfile\n");
 503     fclose(outf);
 504     return 2;
 505   }
 506
 507   do {
 508     nread = url_fread(buffer, 1,sizeof(buffer), handle);
 509     fwrite(buffer,1,nread,outf);
 510   } while(nread);
 511
 512   url_fclose(handle);
 513
 514   fclose(outf);
 515
 516
 517   /* Test rewind */
 518   outf=fopen("rewind.test","w+");
 519   if(!outf) {
 520     perror("couldn't open fread output file\n");
 521     return 1;
 522   }
 523
 524   handle = url_fopen("testfile", "r");
 525   if(!handle) {
 526     printf("couldn't url_fopen() testfile\n");
 527     fclose(outf);
 528     return 2;
 529   }
 530
 531   nread = url_fread(buffer, 1,sizeof(buffer), handle);
 532   fwrite(buffer,1,nread,outf);
 533   url_rewind(handle);
 534
 535   buffer[0]='\n';
 536   fwrite(buffer,1,1,outf);
 537
 538   nread = url_fread(buffer, 1,sizeof(buffer), handle);
 539   fwrite(buffer,1,nread,outf);
 540
 541
 542   url_fclose(handle);
 543
 544   fclose(outf);
 545
 546
 547   return 0;/* all done */
 548 }