fio.c

   1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
   2  *@ File operations.
   3  *
   4  * Copyright (c) 2000-2004 Gunnar Ritter, Freiburg i. Br., Germany.
   5  * Copyright (c) 2012 - 2016 Steffen (Daode) Nurpmeso <steffen@sdaoden.eu>.
   6  */
   7 /*
   8  * Copyright (c) 1980, 1993
   9  *      The Regents of the University of California.  All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. Neither the name of the University nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35 #undef n_FILE
  36 #define n_FILE fio
  37
  38 #ifndef HAVE_AMALGAMATION
  39 # include "nail.h"
  40 #endif
  41
  42 /* line is a buffer with the result of fgets(). Returns the first newline or
  43  * the last character read */
  44 static size_t     _length_of_line(char const *line, size_t linesize);
  45
  46 /* Read a line, one character at a time */
  47 static char *     _fgetline_byone(char **line, size_t *linesize, size_t *llen,
  48                      FILE *fp, int appendnl, size_t n n_MEMORY_DEBUG_ARGS);
  49
  50 /* Workhorse */
  51 static bool_t a_file_lock(int fd, enum n_file_lock_type ft, off_t off, off_t len);
  52
  53 static size_t
  54 _length_of_line(char const *line, size_t linesize)
  55 {
  56    size_t i;
  57    NYD2_ENTER;
  58
  59    /* Last character is always '\0' and was added by fgets() */
  60    for (--linesize, i = 0; i < linesize; i++)
  61       if (line[i] == '\n')
  62          break;
  63    i = (i < linesize) ? i + 1 : linesize;
  64    NYD2_LEAVE;
  65    return i;
  66 }
  67
  68 static char *
  69 _fgetline_byone(char **line, size_t *linesize, size_t *llen, FILE *fp,
  70    int appendnl, size_t n n_MEMORY_DEBUG_ARGS)
  71 {
  72    char *rv;
  73    int c;
  74    NYD2_ENTER;
  75
  76    assert(*linesize == 0 || *line != NULL);
  77    pstate &= ~PS_READLINE_NL;
  78
  79    for (rv = *line;;) {
  80       if (*linesize <= LINESIZE || n >= *linesize - 128) {
  81          *linesize += ((rv == NULL) ? LINESIZE + n + 1 : 256);
  82          *line = rv = (n_realloc)(rv, *linesize n_MEMORY_DEBUG_ARGSCALL);
  83       }
  84       c = getc(fp);
  85       if (c != EOF) {
  86          rv[n++] = c;
  87          rv[n] = '\0';
  88          if (c == '\n') {
  89             pstate |= PS_READLINE_NL;
  90             break;
  91          }
  92       } else {
  93          if (n > 0) {
  94             if (appendnl) {
  95                rv[n++] = '\n';
  96                rv[n] = '\0';
  97             }
  98             break;
  99          } else {
 100             rv = NULL;
 101             goto jleave;
 102          }
 103       }
 104    }
 105    if (llen)
 106       *llen = n;
 107 jleave:
 108    NYD2_LEAVE;
 109    return rv;
 110 }
 111
 112 static bool_t
 113 a_file_lock(int fd, enum n_file_lock_type flt, off_t off, off_t len)
 114 {
 115    struct flock flp;
 116    bool_t rv;
 117    NYD2_ENTER;
 118
 119    memset(&flp, 0, sizeof flp);
 120
 121    switch (flt) {
 122    default:
 123    case FLT_READ:    rv = F_RDLCK;  break;
 124    case FLT_WRITE:   rv = F_WRLCK;  break;
 125    }
 126    flp.l_type = rv;
 127    flp.l_start = off;
 128    flp.l_whence = SEEK_SET;
 129    flp.l_len = len;
 130
 131    if (!(rv = (fcntl(fd, F_SETLK, &flp) != -1)))
 132       switch (errno) {
 133       case EBADF:
 134       case EINVAL:
 135          rv = TRUM1;
 136          break;
 137       }
 138    NYD2_LEAVE;
 139    return rv;
 140 }
 141
 142 FL char *
 143 (fgetline)(char **line, size_t *linesize, size_t *cnt, size_t *llen, FILE *fp,
 144    int appendnl n_MEMORY_DEBUG_ARGS)
 145 {
 146    size_t i_llen, sz;
 147    char *rv;
 148    NYD2_ENTER;
 149
 150    if (cnt == NULL) {
 151       /* Without count, we can't determine where the chars returned by fgets()
 152        * end if there's no newline.  We have to read one character by one */
 153       rv = _fgetline_byone(line, linesize, llen, fp, appendnl, 0
 154             n_MEMORY_DEBUG_ARGSCALL);
 155       goto jleave;
 156    }
 157
 158    pstate &= ~PS_READLINE_NL;
 159
 160    if ((rv = *line) == NULL || *linesize < LINESIZE)
 161       *line = rv = (n_realloc)(rv, *linesize = LINESIZE
 162             n_MEMORY_DEBUG_ARGSCALL);
 163    sz = (*linesize <= *cnt) ? *linesize : *cnt + 1;
 164    if (sz <= 1 || fgets(rv, sz, fp) == NULL) {
 165       /* Leave llen untouched; it is used to determine whether the last line
 166        * was \n-terminated in some callers */
 167       rv = NULL;
 168       goto jleave;
 169    }
 170
 171    i_llen = _length_of_line(rv, sz);
 172    *cnt -= i_llen;
 173    while (rv[i_llen - 1] != '\n') {
 174       *line = rv = (n_realloc)(rv, *linesize += 256 n_MEMORY_DEBUG_ARGSCALL);
 175       sz = *linesize - i_llen;
 176       sz = (sz <= *cnt) ? sz : *cnt + 1;
 177       if (sz <= 1 || fgets(rv + i_llen, sz, fp) == NULL) {
 178          if (appendnl) {
 179             rv[i_llen++] = '\n';
 180             rv[i_llen] = '\0';
 181          }
 182          break;
 183       }
 184       sz = _length_of_line(rv + i_llen, sz);
 185       i_llen += sz;
 186       *cnt -= sz;
 187    }
 188    if (llen)
 189       *llen = i_llen;
 190 jleave:
 191    NYD2_LEAVE;
 192    return rv;
 193 }
 194
 195 FL int
 196 (readline_restart)(FILE *ibuf, char **linebuf, size_t *linesize, size_t n
 197    n_MEMORY_DEBUG_ARGS)
 198 {
 199    /* TODO readline_restart(): always *appends* LF just to strip it again;
 200     * TODO should be configurable just as for fgetline(); ..or whatever..
 201     * TODO intwrap */
 202    int rv = -1;
 203    long sz;
 204    NYD2_ENTER;
 205
 206    clearerr(ibuf);
 207
 208    /* Interrupts will cause trouble if we are inside a stdio call. As this is
 209     * only relevant if input is from tty, bypass it by read(), then */
 210    if ((options & OPT_TTYIN) && fileno(ibuf) == 0) {
 211       assert(*linesize == 0 || *linebuf != NULL);
 212       pstate &= ~PS_READLINE_NL;
 213       for (;;) {
 214          if (*linesize <= LINESIZE || n >= *linesize - 128) {
 215             *linesize += ((*linebuf == NULL) ? LINESIZE + n + 1 : 256);
 216             *linebuf = (n_realloc)(*linebuf, *linesize n_MEMORY_DEBUG_ARGSCALL);
 217          }
 218 jagain:
 219          sz = read(0, *linebuf + n, *linesize - n - 1);
 220          if (sz > 0) {
 221             n += sz;
 222             (*linebuf)[n] = '\0';
 223             if ((*linebuf)[n - 1] == '\n') {
 224                pstate |= PS_READLINE_NL;
 225                break;
 226             }
 227          } else {
 228             if (sz < 0 && errno == EINTR)
 229                goto jagain;
 230             /* TODO eh.  what is this?  that now supposed to be a line?!? */
 231             if (n > 0) {
 232                if ((*linebuf)[n - 1] != '\n') {
 233                   (*linebuf)[n++] = '\n';
 234                   (*linebuf)[n] = '\0';
 235                } else
 236                   pstate |= PS_READLINE_NL;
 237                break;
 238             } else
 239                goto jleave;
 240          }
 241       }
 242    } else {
 243       /* Not reading from standard input or standard input not a terminal. We
 244        * read one char at a time as it is the only way to get lines with
 245        * embedded NUL characters in standard stdio */
 246       if (_fgetline_byone(linebuf, linesize, &n, ibuf, 1, n
 247             n_MEMORY_DEBUG_ARGSCALL) == NULL)
 248          goto jleave;
 249    }
 250    if (n > 0 && (*linebuf)[n - 1] == '\n')
 251       (*linebuf)[--n] = '\0';
 252    rv = (int)n;
 253 jleave:
 254    NYD2_LEAVE;
 255    return rv;
 256 }
 257
 258 FL void
 259 setptr(FILE *ibuf, off_t offset)
 260 {
 261    struct message self;
 262    char *cp, *linebuf = NULL;
 263    char const *cp2;
 264    int c, selfcnt = 0;
 265    bool_t maybe, inhead, rfc4155;
 266    size_t linesize = 0, filesize, cnt;
 267    NYD_ENTER;
 268
 269    memset(&self, 0, sizeof self);
 270    self.m_flag = MUSED | MNEW | MNEWEST;
 271    filesize = mailsize - offset;
 272    offset = ftell(mb.mb_otf);
 273    maybe = TRU1;
 274    rfc4155 = inhead = FAL0;
 275
 276    for (;;) {
 277       if (fgetline(&linebuf, &linesize, &filesize, &cnt, ibuf, 0) == NULL) {
 278          self.m_xsize = self.m_size;
 279          self.m_xlines = self.m_lines;
 280          self.m_content_info = CI_HAVE_HEADER | CI_HAVE_BODY;
 281          if (selfcnt > 0)
 282             message_append(&self);
 283          message_append_null();
 284          if (linebuf != NULL)
 285             free(linebuf);
 286          break;
 287       }
 288
 289 #ifdef notdef
 290       if (linebuf[0] == '\0')
 291          linebuf[0] = '.';
 292 #endif
 293       /* XXX Convert CRLF to LF; this should be rethought in that
 294        * XXX CRLF input should possibly end as CRLF output? */
 295       if (cnt >= 2 && linebuf[cnt - 1] == '\n' && linebuf[cnt - 2] == '\r')
 296          linebuf[--cnt - 1] = '\n';
 297       fwrite(linebuf, sizeof *linebuf, cnt, mb.mb_otf);
 298       if (ferror(mb.mb_otf)) {
 299          n_perr(_("/tmp"), 0);
 300          exit(EXIT_ERR);
 301       }
 302       if (linebuf[cnt - 1] == '\n')
 303          linebuf[cnt - 1] = '\0';
 304       if (maybe && linebuf[0] == 'F' &&
 305             (rfc4155 = is_head(linebuf, cnt, TRU1))) {
 306          /* TODO char date[FROM_DATEBUF];
 307           * TODO extract_date_from_from_(linebuf, cnt, date);
 308           * TODO self.m_time = 10000; */
 309          if (rfc4155 == TRUM1) {
 310             if (options & OPT_D_V)
 311                n_err(_("Invalid MBOX \"From_ line\": %.*s\n"),
 312                   (int)cnt, linebuf);
 313             else if (!(mb.mb_active & MB_FROM__WARNED))
 314                n_err(_("MBOX mailbox contains non-conforming From_ line(s)\n"));
 315             mb.mb_active |= MB_FROM__WARNED;
 316          }
 317          self.m_xsize = self.m_size;
 318          self.m_xlines = self.m_lines;
 319          self.m_content_info = CI_HAVE_HEADER | CI_HAVE_BODY;
 320          if (selfcnt++ > 0)
 321             message_append(&self);
 322          msgCount++;
 323          self.m_flag = MUSED | MNEW | MNEWEST;
 324          self.m_size = 0;
 325          self.m_lines = 0;
 326          self.m_block = mailx_blockof(offset);
 327          self.m_offset = mailx_offsetof(offset);
 328          inhead = TRU1;
 329       } else if (linebuf[0] == 0) {
 330          inhead = FAL0;
 331       } else if (inhead) {
 332          for (cp = linebuf, cp2 = "status";; ++cp) {
 333             if ((c = *cp2++) == 0) {
 334                while (c = *cp++, whitechar(c))
 335                   ;
 336                if (cp[-1] != ':')
 337                   break;
 338                while ((c = *cp++) != '\0')
 339                   if (c == 'R')
 340                      self.m_flag |= MREAD;
 341                   else if (c == 'O')
 342                      self.m_flag &= ~MNEW;
 343                break;
 344             }
 345             if (*cp != c && *cp != upperconv(c))
 346                break;
 347          }
 348          for (cp = linebuf, cp2 = "x-status";; ++cp) {
 349             if ((c = *cp2++) == 0) {
 350                while ((c = *cp++, whitechar(c)))
 351                   ;
 352                if (cp[-1] != ':')
 353                   break;
 354                while ((c = *cp++) != '\0')
 355                   if (c == 'F')
 356                      self.m_flag |= MFLAGGED;
 357                   else if (c == 'A')
 358                      self.m_flag |= MANSWERED;
 359                   else if (c == 'T')
 360                      self.m_flag |= MDRAFTED;
 361                break;
 362             }
 363             if (*cp != c && *cp != upperconv(c))
 364                break;
 365          }
 366       }
 367       offset += cnt;
 368       self.m_size += cnt;
 369       ++self.m_lines;
 370       maybe = (linebuf[0] == 0);
 371    }
 372    NYD_LEAVE;
 373 }
 374
 375 FL off_t
 376 fsize(FILE *iob)
 377 {
 378    struct stat sbuf;
 379    off_t rv;
 380    NYD_ENTER;
 381
 382    rv = (fstat(fileno(iob), &sbuf) == -1) ? 0 : sbuf.st_size;
 383    NYD_LEAVE;
 384    return rv;
 385 }
 386
 387 FL bool_t
 388 n_file_lock(int fd, enum n_file_lock_type flt, off_t off, off_t len,
 389    size_t pollmsecs)
 390 {
 391    size_t tries;
 392    bool_t didmsg, rv;
 393    NYD_ENTER;
 394
 395    if(pollmsecs == UIZ_MAX)
 396       pollmsecs = FILE_LOCK_MILLIS;
 397
 398    n_UNINIT(rv, 0);
 399    for (didmsg = FAL0, tries = 0; tries <= FILE_LOCK_TRIES; ++tries) {
 400       rv = a_file_lock(fd, flt, off, len);
 401
 402       if (rv == TRUM1) {
 403          rv = FAL0;
 404          break;
 405       }
 406       if (rv || pollmsecs == 0)
 407          break;
 408       else {
 409          if(!didmsg){
 410             n_err(_("Failed to create a file lock, waiting %lu milliseconds "),
 411                pollmsecs);
 412             didmsg = TRU1;
 413          }else
 414             n_err(".");
 415          n_msleep(pollmsecs, FAL0);
 416       }
 417    }
 418    if(didmsg)
 419       n_err(" %s\n", (rv ? _("ok") : _("failure")));
 420    NYD_LEAVE;
 421    return rv;
 422 }
 423
 424 /* s-it-mode */