__oop-read-copy.c

   1 /* THIS IS A COPY OF THE FILE WHICH SHOULD BE IN LIBOOP
   2 ** When liboop gets the two tiny bugfixes which are here,
   3 ** this file can and should be eliminated   -iwj 29.4.2010
   4 */
   5
   6 /* read.c, liboop, copyright 2000 Ian jackson
   7
   8    This is free software; you can redistribute it and/or modify it under the
   9    terms of the GNU Lesser General Public License, version 2.1 or later.
  10    See the file COPYING for details. */
  11
  12 #include "oop.h"
  13 #include "oop-read.h"
  14
  15 #include <string.h>
  16 #include <errno.h>
  17 #include <assert.h>
  18 #include <limits.h>
  19
  20 #undef MIN /* for systems that define it */
  21 #define MIN(a,b) ((a)<(b) ? (a) : (b))
  22
  23 static void *on_time(oop_source*, struct timeval, void*);
  24 static void *on_readable(oop_source*, oop_readable*, void*);
  25 static void *on_process(oop_source*, oop_read*, int try_read);
  26
  27 static int set_time_ifbuf(oop_source *oop, oop_read *rd);
  28 static void cancel_time(oop_source *oop, oop_read *rd);
  29
  30 const oop_rd_style OOP_RD_STYLE_GETLINE[]= {{
  31   OOP_RD_DELIM_STRIP,'\n', OOP_RD_NUL_FORBID, OOP_RD_SHORTREC_EOF,
  32 }};
  33 const oop_rd_style OOP_RD_STYLE_BLOCK[]= {{
  34   OOP_RD_DELIM_NONE, 0,    OOP_RD_NUL_PERMIT, OOP_RD_SHORTREC_EOF,
  35 }};
  36 const oop_rd_style OOP_RD_STYLE_IMMED[]= {{
  37   OOP_RD_DELIM_NONE, 0,    OOP_RD_NUL_PERMIT, OOP_RD_SHORTREC_SOONEST,
  38 }};
  39
  40 struct oop_read {
  41   /* set at creation time: */
  42   oop_source *oop;
  43   oop_readable *ra;
  44   char *userbuf;
  45   /* persistent state */
  46   oop_rd_bufctl_op readahead; /* _ENABLE or _DISABLE */
  47   char *allocbuf;
  48   size_t alloc, used, discard;
  49   size_t neednotcheck; /* data we've already searched for delimiter */
  50   int displacedchar; /* >=0, first unused */
  51   /* arguments to oop_rd_read */
  52   oop_rd_style style;
  53   size_t maxrecsz;
  54   oop_rd_call *call_ok, *call_err;
  55   void *data_ok, *data_err;
  56 };
  57
  58 /* Buffer is structured like this if displacedchar>=0 and delim found:
  59  *
  60  *              done stuff,    displaced readahead - read     unused
  61  *              we've called  delimiter| but not yet          buffer
  62  *              back for              || returned             space
  63  *              ddddddddddddddddddddddDOaaaaaaaaaaaaaaaaaaa____________
  64  *              <------- discard ----->
  65  *              <----------------------- used ------------>
  66  *              <------------------------------------- alloc --------->
  67  *
  68  * If displacedchar>=0 then the the first character of readahead has
  69  * been displaced by a nul byte and is stored in displacedchar.  If
  70  * _DELIM_STRIP and the delimiter is found then the nul overwrites the
  71  * delimiter.
  72  *
  73  *               Buffer when full   {this,max}                  may need
  74  * DELIM found?  <-recval->      recdata  buffer required       readahead
  75  *  NONE  n/a    ddddddddddOaaa_ recsz    recdata+1 == recsz+1  maxrecsz
  76  *  KEEP  Yes    dddddddddDOaaa_ recsz    recdata+1 == recsz+1  maxrecsz
  77  *  KEEP  No     ddddddddddOaaa_ recsz    recdata+1 == recsz+1  maxrecsz
  78  *  STRIP Yes    dddddddddd0aaaa recsz+1  recdata   == recsz+1  maxrecsz+1
  79  *  STRIP No     ddddddddddOaaaa recsz    recdata+1 == recsz+1  maxrecsz+1
  80  *
  81  * Key:  d = data to be returned
  82  *       D = delimiter, being returned
  83  *       a = readahead, not to be returned
  84  *       O = readahead character displaced by a nul
  85  *       0 = delimiter replaced by a nul
  86  *       _ = unused
  87  */
  88
  89 static const char *const eventstrings_nl[]= {
  90   "INTERNAL ERROR (_nl _OK) please report",
  91   "End of file",
  92   "Missing newline at end of file",
  93   "Line too long",
  94   "Nul byte",
  95   "Nul byte, in line which is also too long",
  96   "INTERNAL ERROR (_nl _SYSTEM) please report"
  97 };
  98
  99 static const char *const eventstrings_other[]= {
 100   "Record read successfully",
 101   "End of file",
 102   "Incomplete record at end of file",
 103   "Record too long",
 104   "Nul byte",
 105   "Nul byte in record which is also too long",
 106   "System error"
 107 };
 108
 109 oop_read *oop_rd_new(oop_source *oop, oop_readable *ra, char *buf, size_t bufsz) {
 110   oop_read *rd= 0;
 111
 112   assert(buf ? bufsz>=2 : !bufsz);
 113
 114   rd= oop_malloc(sizeof(*rd));  if (!rd) goto x_fail;
 115   rd->oop= oop;
 116   rd->ra= ra;
 117   rd->userbuf= buf;
 118   rd->readahead= OOP_RD_BUFCTL_ENABLE;
 119   rd->allocbuf= 0;
 120   rd->used= 0;
 121   rd->alloc= buf ? bufsz : 0;
 122   rd->discard= 0;
 123   rd->neednotcheck= 0;
 124   rd->displacedchar= -1;
 125   rd->style= *OOP_RD_STYLE_IMMED;
 126
 127   return rd;
 128
 129 x_fail:
 130   oop_free(rd);
 131   return 0;
 132 }
 133
 134 static int set_time_ifbuf(oop_source *oop, oop_read *rd) {
 135   if (rd->used > rd->discard)
 136     return oop->on_time(oop,OOP_TIME_NOW,on_time,rd), 0; /* fixme */
 137   return 0;
 138 }
 139 static void cancel_time(oop_source *oop, oop_read *rd) {
 140   oop->cancel_time(oop,OOP_TIME_NOW,on_time,rd);
 141 }
 142 static int set_read(oop_source *oop, oop_read *rd) {
 143   return rd->ra->on_readable(rd->ra,on_readable,rd), 0; /* fixme */
 144 }
 145 static void cancel_read(oop_source *oop, oop_read *rd) {
 146   rd->ra->on_cancel(rd->ra);
 147 }
 148
 149 int oop_rd_read(oop_read *rd, const oop_rd_style *style, size_t maxrecsz,
 150                 oop_rd_call *ifok, void *data_ok,
 151                 oop_rd_call *iferr, void *data_err) {
 152   oop_source *oop= rd->oop;
 153   int er;
 154
 155   cancel_time(oop,rd);
 156   cancel_read(oop,rd);
 157
 158   if (style->delim_mode == OOP_RD_DELIM_NONE ||
 159       rd->style.delim_mode == OOP_RD_DELIM_NONE ||
 160       style->delim != rd->style.delim)
 161     rd->neednotcheck= 0;
 162
 163   rd->style= *style;
 164   rd->maxrecsz= maxrecsz;
 165   rd->call_ok= ifok; rd->data_ok= data_ok;
 166   rd->call_err= iferr; rd->data_err= data_err;
 167
 168   er= set_read(oop,rd);        if (er) return er;
 169   er= set_time_ifbuf(oop,rd);  if (er) return er;
 170   return 0;
 171 }
 172
 173 void oop_rd_delete(oop_read *rd) {
 174   rd->ra->on_cancel(rd->ra);
 175   oop_free(rd->allocbuf);
 176   oop_free(rd);
 177 }
 178
 179 void oop_rd_cancel(oop_read *rd) {
 180   cancel_time(rd->oop,rd);
 181   cancel_read(rd->oop,rd);
 182 }
 183
 184 const char *oop_rd_errmsg(oop_read *rd, oop_rd_event event, int errnoval,
 185                           const oop_rd_style *style) {
 186   if (event == OOP_RD_SYSTEM)
 187     return strerror(errnoval);
 188   else if (style && style->delim_mode != OOP_RD_DELIM_NONE
 189            && style->delim == '\n')
 190     return eventstrings_nl[event];
 191   else
 192     return eventstrings_other[event];
 193 }
 194
 195 static void *on_readable(oop_source *oop, oop_readable *ra, void *rd_void) {
 196   oop_read *rd= rd_void;
 197
 198   assert(oop == rd->oop);
 199   assert(ra == rd->ra);
 200   return on_process(oop,rd,1);
 201 }
 202
 203 static void *on_time(oop_source *oop, struct timeval when, void *rd_void) {
 204   oop_read *rd= rd_void;
 205
 206   assert(oop == rd->oop);
 207   return on_process(oop,rd,0);
 208 }
 209
 210 static size_t calc_dataspace(oop_read *rd) {
 211   if (rd->style.delim_mode == OOP_RD_DELIM_STRIP) {
 212     return rd->alloc;
 213   } else {
 214     return rd->alloc ? rd->alloc-1 : 0;
 215   }
 216 }
 217
 218 static void *on_process(oop_source *oop, oop_read *rd, int try_read) {
 219   oop_rd_event event;
 220   int evkind; /* 0=none, -1=error, 1=something */
 221   int errnoval, nread, cancelnow;
 222   oop_rd_call *call;
 223   char *buf, *delimp;
 224   const char *errmsg;
 225   size_t maxrecsz; /* like in arg to oop_rd_read, but 0 -> large val */
 226   size_t maxbufreqd; /* maximum buffer we might possibly want to alloc */
 227   size_t readahead; /* max amount of data we might want to readahead */
 228   size_t want; /* amount we want to allocate or data we want to read */
 229   size_t dataspace; /* amount of buffer we can usefully fill with data */
 230   size_t thisrecsz; /* length of the record we've found */
 231   size_t thisrecdata; /* length of data representing the record */
 232   void *call_data;
 233
 234   cancel_time(oop,rd);
 235
 236   if (rd->userbuf) {
 237     buf= rd->userbuf;
 238   } else {
 239     buf= rd->allocbuf;
 240   }
 241
 242   if (rd->discard) {
 243     rd->used -= rd->discard;
 244     if (rd->neednotcheck > rd->discard) {
 245       rd->neednotcheck -= rd->discard;
 246     } else {
 247       rd->neednotcheck= 0;
 248     }
 249     memmove(buf, buf + rd->discard, rd->used);
 250     rd->discard= 0;
 251   }
 252   if (rd->displacedchar >= 0) {
 253     assert(rd->used > 0);
 254     buf[0]= rd->displacedchar;
 255     rd->displacedchar= -1;
 256   }
 257
 258   maxrecsz= rd->maxrecsz ? rd->maxrecsz : INT_MAX / 5 /* allows +20 and *4 */;
 259   maxbufreqd= maxrecsz+1;
 260
 261   if (rd->userbuf && maxbufreqd > rd->alloc) {
 262     maxrecsz -= (maxbufreqd - rd->alloc);
 263     maxbufreqd= rd->alloc;
 264   }
 265
 266   if (rd->style.delim_mode == OOP_RD_DELIM_STRIP) {
 267     readahead= maxrecsz+1;
 268   } else {
 269     readahead= maxrecsz;
 270   }
 271
 272   for (;;) {
 273     evkind= 0;
 274     event= -1;
 275     thisrecdata= thisrecsz= 0;
 276     errnoval= 0;
 277
 278     assert(rd->used <= rd->alloc);
 279     dataspace= calc_dataspace(rd);
 280
 281     if (/* delimiter already in buffer, within max record data ? */
 282         rd->style.delim_mode != OOP_RD_DELIM_NONE &&
 283         (delimp= memchr(buf + rd->neednotcheck, rd->style.delim,
 284                         MIN(rd->used, readahead) - rd->neednotcheck))) {
 285
 286       thisrecsz= (delimp - buf);
 287       thisrecdata= thisrecsz+1;
 288       if (rd->style.delim_mode == OOP_RD_DELIM_KEEP)
 289         thisrecsz= thisrecdata;
 290       event= OOP_RD_OK;
 291       evkind= +1;
 292
 293     } else if (rd->used >= readahead) {
 294
 295       thisrecsz= thisrecdata= maxrecsz;
 296       evkind= +1;
 297
 298       if (rd->style.delim_mode == OOP_RD_DELIM_NONE) {
 299         event= OOP_RD_OK;
 300       } else {
 301         event= OOP_RD_LONG;
 302         if (rd->style.shortrec_mode < OOP_RD_SHORTREC_LONG) {
 303           evkind= -1;
 304           thisrecsz= thisrecdata= 0;
 305         }
 306       }
 307
 308     } else if (/* want to return ASAP, and we have something ? */
 309                rd->style.shortrec_mode == OOP_RD_SHORTREC_SOONEST &&
 310                rd->used > 0 && rd->alloc >= 2) {
 311
 312       thisrecdata= rd->used;
 313       if (thisrecdata == rd->alloc) thisrecdata--;
 314       thisrecsz= thisrecdata;
 315       event= OOP_RD_OK;
 316       evkind= +1;
 317
 318     }
 319
 320     want= 0;
 321     if (evkind && thisrecdata && thisrecsz >= rd->alloc) {
 322       /* Need to make space for the trailing nul */
 323       want= rd->alloc+1;
 324     } else if (!evkind && !rd->userbuf &&
 325                rd->used >= dataspace && rd->alloc < maxbufreqd) {
 326       /* Need to make space to read more data */
 327       want= rd->alloc + 20;
 328       want <<= 2;
 329       want= MIN(want, maxbufreqd);
 330     }
 331
 332     if (want) {
 333       assert(!rd->userbuf);
 334       assert(want <= maxbufreqd);
 335
 336       buf= oop_realloc(rd->allocbuf,want);
 337       if (!buf) {
 338         event= OOP_RD_SYSTEM;
 339         evkind= -1;
 340         errnoval= ENOMEM;
 341         thisrecsz= thisrecdata= 0;
 342         break;
 343       }
 344       rd->allocbuf= buf;
 345       rd->alloc= want;
 346     }
 347
 348     if (evkind) break; /* OK, process it then */
 349
 350     if (!try_read) return OOP_CONTINUE; /* But we weren't told it was ready. */
 351
 352     dataspace= calc_dataspace(rd);
 353     want= MIN(dataspace, readahead);
 354     assert(rd->used < want);
 355
 356     errno= 0;
 357     nread= rd->ra->try_read(rd->ra, buf+rd->used, want-rd->used);
 358     if (errno == EAGAIN) return OOP_CONTINUE;
 359
 360     if (nread > 0) {
 361       rd->neednotcheck= rd->used;
 362       rd->used += nread;
 363       continue;
 364     }
 365
 366     if (nread < 0) { /* read error */
 367
 368       event= OOP_RD_SYSTEM;
 369       evkind= -1;
 370       errnoval= errno;
 371       thisrecsz= thisrecdata= rd->used;
 372       break;
 373
 374     } else {
 375
 376       if (rd->used) {
 377         event= OOP_RD_PARTREC;
 378         evkind= (rd->style.shortrec_mode == OOP_RD_SHORTREC_FORBID) ? -1 : +1;
 379         thisrecsz= thisrecdata= rd->used;
 380       } else {
 381         event= OOP_RD_EOF;
 382         evkind= +1;
 383       }
 384       break;
 385
 386     }
 387   }
 388
 389   /* OK, we have an event of some kind */
 390
 391   /* Nul byte handling */
 392   if (thisrecsz > 0 && rd->style.nul_mode != OOP_RD_NUL_PERMIT) {
 393     size_t checked;
 394     char *nul, *notnul;
 395
 396     for (checked=0;
 397          (nul= memchr(buf+checked,0,thisrecsz-checked));
 398          ) {
 399       if (rd->style.nul_mode == OOP_RD_NUL_FORBID) {
 400         event= OOP_RD_NUL;
 401         evkind= -1;
 402         thisrecdata= thisrecsz= 0;
 403         break;
 404       }
 405       assert(rd->style.nul_mode == OOP_RD_NUL_DISCARD);
 406       for (notnul= nul+1;
 407            notnul < buf+thisrecsz && notnul == '\0';
 408            notnul++);
 409       thisrecsz-= (notnul-nul);
 410       checked= nul-buf;
 411       memmove(nul,notnul,thisrecsz-checked);
 412     }
 413   }
 414
 415   /* Checks that all is well */
 416
 417   assert(evkind);
 418   assert(thisrecsz <= thisrecdata);
 419   assert(!rd->maxrecsz || thisrecsz <= rd->maxrecsz);
 420   assert(thisrecdata <= rd->used);
 421
 422   rd->discard= thisrecdata;
 423
 424   cancelnow= (evkind < 0) || (event == OOP_RD_EOF);
 425
 426   if (!cancelnow) {
 427     errnoval= set_time_ifbuf(oop,rd);
 428     if (errnoval) {
 429       event= OOP_RD_SYSTEM;
 430       evkind= -1;
 431       cancelnow= 1;
 432       thisrecsz= thisrecdata= 0;
 433       rd->discard= 0;
 434     }
 435   }
 436
 437   if (evkind < 0) {
 438     call= rd->call_err;
 439     call_data= rd->data_err;
 440     errmsg= oop_rd_errmsg(rd,event,errnoval,&rd->style);
 441   } else {
 442     call= rd->call_ok;
 443     call_data= rd->data_ok;
 444     errmsg= 0;
 445   }
 446
 447   if (thisrecdata) {
 448     /* We have to fill in a nul byte. */
 449     assert(thisrecsz < rd->alloc);
 450     if (thisrecsz == thisrecdata && thisrecsz < rd->used)
 451       rd->displacedchar= (unsigned char)buf[thisrecdata];
 452     buf[thisrecsz]= 0;
 453   }
 454
 455   if (cancelnow)
 456     oop_rd_cancel(rd);
 457
 458   return
 459     call(oop,rd, event,errmsg,errnoval,
 460          (thisrecdata ? buf : 0), thisrecsz, call_data);
 461 }
 462
 463 oop_read *oop_rd_new_fd(oop_source *oop, int fd, char *buf, size_t bufsz) {
 464   oop_readable *ra;
 465   oop_read *rd;
 466
 467   ra= oop_readable_fd(oop,fd);
 468   if (!ra) return 0;
 469
 470   rd= oop_rd_new(oop,ra,buf,bufsz);
 471   if (!rd) { ra->delete_tidy(ra); return 0; }
 472
 473   return rd;
 474 }
 475
 476 int oop_rd_delete_tidy(oop_read *rd) {
 477   oop_readable *ra= rd->ra;
 478   oop_rd_delete(rd);
 479   return ra->delete_tidy(ra);
 480 }
 481
 482 void oop_rd_delete_kill(oop_read *rd) {
 483   oop_readable *ra= rd->ra;
 484   oop_rd_delete(rd);
 485   ra->delete_kill(ra);
 486 }