usr/src/cmd/sendmail/libsm/fseek.c

   1 /*
   2  * Copyright (c) 2000-2001, 2004 Sendmail, Inc. and its suppliers.
   3  *      All rights reserved.
   4  * Copyright (c) 1990, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * This code is derived from software contributed to Berkeley by
   8  * Chris Torek.
   9  *
  10  * By using this file, you agree to the terms and conditions set
  11  * forth in the LICENSE file which can be found at the top level of
  12  * the sendmail distribution.
  13  */
  14
  15 #pragma ident   "%Z%%M% %I%     %E% SMI"
  16
  17 #include <sm/gen.h>
  18 SM_RCSID("@(#)$Id: fseek.c,v 1.47 2005/06/14 23:07:20 ca Exp $")
  19 #include <sys/types.h>
  20 #include <sys/stat.h>
  21 #include <fcntl.h>
  22 #include <stdlib.h>
  23 #include <errno.h>
  24 #include <setjmp.h>
  25 #include <sm/time.h>
  26 #include <sm/signal.h>
  27 #include <sm/io.h>
  28 #include <sm/assert.h>
  29 #include <sm/clock.h>
  30 #include "local.h"
  31
  32 #define POS_ERR (-(off_t)1)
  33
  34 static void     seekalrm __P((int));
  35 static jmp_buf SeekTimeOut;
  36
  37 /*
  38 **  SEEKALRM -- handler when timeout activated for sm_io_seek()
  39 **
  40 **  Returns flow of control to where setjmp(SeekTimeOut) was set.
  41 **
  42 **      Parameters:
  43 **              sig -- unused
  44 **
  45 **      Returns:
  46 **              does not return
  47 **
  48 **      Side Effects:
  49 **              returns flow of control to setjmp(SeekTimeOut).
  50 **
  51 **      NOTE:   THIS CAN BE CALLED FROM A SIGNAL HANDLER.  DO NOT ADD
  52 **              ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE
  53 **              DOING.
  54 */
  55
  56 /* ARGSUSED0 */
  57 static void
  58 seekalrm(sig)
  59         int sig;
  60 {
  61         longjmp(SeekTimeOut, 1);
  62 }
  63
  64 /*
  65 **  SM_IO_SEEK -- position the file pointer
  66 **
  67 **      Parameters:
  68 **              fp -- the file pointer to be seek'd
  69 **              timeout -- time to complete seek (milliseconds)
  70 **              offset -- seek offset based on 'whence'
  71 **              whence -- indicates where seek is relative from.
  72 **                      One of SM_IO_SEEK_{CUR,SET,END}.
  73 **      Returns:
  74 **              Failure: returns -1 (minus 1) and sets errno
  75 **              Success: returns 0 (zero)
  76 */
  77
  78 int
  79 sm_io_seek(fp, timeout, offset, whence)
  80         register SM_FILE_T *fp;
  81         int SM_NONVOLATILE timeout;
  82         long SM_NONVOLATILE offset;
  83         int SM_NONVOLATILE whence;
  84 {
  85         bool havepos;
  86         off_t target, curoff;
  87         size_t n;
  88         struct stat st;
  89         int ret;
  90         SM_EVENT *evt = NULL;
  91         register off_t (*seekfn) __P((SM_FILE_T *, off_t, int));
  92
  93         SM_REQUIRE_ISA(fp, SmFileMagic);
  94
  95         /* make sure stdio is set up */
  96         if (!Sm_IO_DidInit)
  97                 sm_init();
  98
  99         /* Have to be able to seek. */
 100         if ((seekfn = fp->f_seek) == NULL)
 101         {
 102                 errno = ESPIPE;                 /* historic practice */
 103                 return -1;
 104         }
 105
 106         if (timeout == SM_TIME_DEFAULT)
 107                 timeout = fp->f_timeout;
 108         if (timeout == SM_TIME_IMMEDIATE)
 109         {
 110                 /*
 111                 **  Filling the buffer will take time and we are wanted to
 112                 **  return immediately. So...
 113                 */
 114
 115                 errno = EAGAIN;
 116                 return -1;
 117         }
 118
 119 #define SM_SET_ALARM()                                          \
 120         if (timeout != SM_TIME_FOREVER)                         \
 121         {                                                       \
 122                 if (setjmp(SeekTimeOut) != 0)                   \
 123                 {                                               \
 124                         errno = EAGAIN;                         \
 125                         return -1;                              \
 126                 }                                               \
 127                 evt = sm_seteventm(timeout, seekalrm, 0);       \
 128         }
 129
 130         /*
 131         **  Change any SM_IO_SEEK_CUR to SM_IO_SEEK_SET, and check `whence'
 132         **  argument. After this, whence is either SM_IO_SEEK_SET or
 133         **  SM_IO_SEEK_END.
 134         */
 135
 136         switch (whence)
 137         {
 138           case SM_IO_SEEK_CUR:
 139
 140                 /*
 141                 **  In order to seek relative to the current stream offset,
 142                 **  we have to first find the current stream offset a la
 143                 **  ftell (see ftell for details).
 144                 */
 145
 146                 /* may adjust seek offset on append stream */
 147                 sm_flush(fp, (int *) &timeout);
 148                 SM_SET_ALARM();
 149                 if (fp->f_flags & SMOFF)
 150                         curoff = fp->f_lseekoff;
 151                 else
 152                 {
 153                         curoff = (*seekfn)(fp, (off_t) 0, SM_IO_SEEK_CUR);
 154                         if (curoff == -1L)
 155                         {
 156                                 ret = -1;
 157                                 goto clean;
 158                         }
 159                 }
 160                 if (fp->f_flags & SMRD)
 161                 {
 162                         curoff -= fp->f_r;
 163                         if (HASUB(fp))
 164                                 curoff -= fp->f_ur;
 165                 }
 166                 else if (fp->f_flags & SMWR && fp->f_p != NULL)
 167                         curoff += fp->f_p - fp->f_bf.smb_base;
 168
 169                 offset += curoff;
 170                 whence = SM_IO_SEEK_SET;
 171                 havepos = true;
 172                 break;
 173
 174           case SM_IO_SEEK_SET:
 175           case SM_IO_SEEK_END:
 176                 SM_SET_ALARM();
 177                 curoff = 0;             /* XXX just to keep gcc quiet */
 178                 havepos = false;
 179                 break;
 180
 181           default:
 182                 errno = EINVAL;
 183                 return -1;
 184         }
 185
 186         /*
 187         **  Can only optimise if:
 188         **      reading (and not reading-and-writing);
 189         **      not unbuffered; and
 190         **      this is a `regular' Unix file (and hence seekfn==sm_stdseek).
 191         **  We must check SMNBF first, because it is possible to have SMNBF
 192         **  and SMSOPT both set.
 193         */
 194
 195         if (fp->f_bf.smb_base == NULL)
 196                 sm_makebuf(fp);
 197         if (fp->f_flags & (SMWR | SMRW | SMNBF | SMNPT))
 198                 goto dumb;
 199         if ((fp->f_flags & SMOPT) == 0)
 200         {
 201                 if (seekfn != sm_stdseek ||
 202                     fp->f_file < 0 || fstat(fp->f_file, &st) ||
 203                     (st.st_mode & S_IFMT) != S_IFREG)
 204                 {
 205                         fp->f_flags |= SMNPT;
 206                         goto dumb;
 207                 }
 208                 fp->f_blksize = st.st_blksize;
 209                 fp->f_flags |= SMOPT;
 210         }
 211
 212         /*
 213         **  We are reading; we can try to optimise.
 214         **  Figure out where we are going and where we are now.
 215         */
 216
 217         if (whence == SM_IO_SEEK_SET)
 218                 target = offset;
 219         else
 220         {
 221                 if (fstat(fp->f_file, &st))
 222                         goto dumb;
 223                 target = st.st_size + offset;
 224         }
 225
 226         if (!havepos)
 227         {
 228                 if (fp->f_flags & SMOFF)
 229                         curoff = fp->f_lseekoff;
 230                 else
 231                 {
 232                         curoff = (*seekfn)(fp, (off_t) 0, SM_IO_SEEK_CUR);
 233                         if (curoff == POS_ERR)
 234                                 goto dumb;
 235                 }
 236                 curoff -= fp->f_r;
 237                 if (HASUB(fp))
 238                         curoff -= fp->f_ur;
 239         }
 240
 241         /*
 242         **  Compute the number of bytes in the input buffer (pretending
 243         **  that any ungetc() input has been discarded).  Adjust current
 244         **  offset backwards by this count so that it represents the
 245         **  file offset for the first byte in the current input buffer.
 246         */
 247
 248         if (HASUB(fp))
 249         {
 250                 curoff += fp->f_r;      /* kill off ungetc */
 251                 n = fp->f_up - fp->f_bf.smb_base;
 252                 curoff -= n;
 253                 n += fp->f_ur;
 254         }
 255         else
 256         {
 257                 n = fp->f_p - fp->f_bf.smb_base;
 258                 curoff -= n;
 259                 n += fp->f_r;
 260         }
 261
 262         /*
 263         **  If the target offset is within the current buffer,
 264         **  simply adjust the pointers, clear SMFEOF, undo ungetc(),
 265         **  and return.  (If the buffer was modified, we have to
 266         **  skip this; see getln in fget.c.)
 267         */
 268
 269         if (target >= curoff && target < curoff + (off_t) n)
 270         {
 271                 register int o = target - curoff;
 272
 273                 fp->f_p = fp->f_bf.smb_base + o;
 274                 fp->f_r = n - o;
 275                 if (HASUB(fp))
 276                         FREEUB(fp);
 277                 fp->f_flags &= ~SMFEOF;
 278                 ret = 0;
 279                 goto clean;
 280         }
 281
 282         /*
 283         **  The place we want to get to is not within the current buffer,
 284         **  but we can still be kind to the kernel copyout mechanism.
 285         **  By aligning the file offset to a block boundary, we can let
 286         **  the kernel use the VM hardware to map pages instead of
 287         **  copying bytes laboriously.  Using a block boundary also
 288         **  ensures that we only read one block, rather than two.
 289         */
 290
 291         curoff = target & ~(fp->f_blksize - 1);
 292         if ((*seekfn)(fp, curoff, SM_IO_SEEK_SET) == POS_ERR)
 293                 goto dumb;
 294         fp->f_r = 0;
 295         fp->f_p = fp->f_bf.smb_base;
 296         if (HASUB(fp))
 297                 FREEUB(fp);
 298         fp->f_flags &= ~SMFEOF;
 299         n = target - curoff;
 300         if (n)
 301         {
 302                 /* Note: SM_TIME_FOREVER since fn timeout already set */
 303                 if (sm_refill(fp, SM_TIME_FOREVER) || fp->f_r < (int) n)
 304                         goto dumb;
 305                 fp->f_p += n;
 306                 fp->f_r -= n;
 307         }
 308
 309         ret = 0;
 310 clean:
 311         /*  We're back. So undo our timeout and handler */
 312         if (evt != NULL)
 313                 sm_clrevent(evt);
 314         return ret;
 315 dumb:
 316         /*
 317         **  We get here if we cannot optimise the seek ... just
 318         **  do it.  Allow the seek function to change fp->f_bf.smb_base.
 319         */
 320
 321         /* Note: SM_TIME_FOREVER since fn timeout already set */
 322         ret = SM_TIME_FOREVER;
 323         if (sm_flush(fp, &ret) != 0 ||
 324             (*seekfn)(fp, (off_t) offset, whence) == POS_ERR)
 325         {
 326                 ret = -1;
 327                 goto clean;
 328         }
 329
 330         /* success: clear SMFEOF indicator and discard ungetc() data */
 331         if (HASUB(fp))
 332                 FREEUB(fp);
 333         fp->f_p = fp->f_bf.smb_base;
 334         fp->f_r = 0;
 335         fp->f_flags &= ~SMFEOF;
 336         ret = 0;
 337         goto clean;
 338 }