commands/grep/file.c

   1 /*      $OpenBSD: file.c,v 1.9 2006/02/09 09:54:46 otto Exp $   */
   2
   3 /*-
   4  * Copyright (c) 1999 James Howard and Dag-Erling Coïdan Smørgrav
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include <sys/param.h>
  30
  31 #include <err.h>
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <unistd.h>
  35
  36 #include "grep.h"
  37
  38 static char      fname[MAXPATHLEN];
  39 #ifndef NOZ
  40 static char     *lnbuf;
  41 static size_t    lnbuflen;
  42 #endif
  43
  44 #define FILE_STDIO      0
  45 #ifndef __minix
  46 #define FILE_MMAP       1
  47 #endif
  48 #define FILE_GZIP       2
  49
  50 struct file {
  51         int      type;
  52         int      noseek;
  53         FILE    *f;
  54         mmf_t   *mmf;
  55 #ifndef NOZ
  56         gzFile  *gzf;
  57 #endif
  58 };
  59
  60 #ifndef NOZ
  61 static char *
  62 gzfgetln(gzFile *f, size_t *len)
  63 {
  64         size_t          n;
  65         int             c;
  66
  67         for (n = 0; ; ++n) {
  68                 c = gzgetc(f);
  69                 if (c == -1) {
  70                         const char *gzerrstr;
  71                         int gzerr;
  72
  73                         if (gzeof(f))
  74                                 break;
  75
  76                         gzerrstr = gzerror(f, &gzerr);
  77                         if (gzerr == Z_ERRNO)
  78                                 err(2, "%s", fname);
  79                         else
  80                                 errx(2, "%s: %s", fname, gzerrstr);
  81                 }
  82                 if (n >= lnbuflen) {
  83                         lnbuflen *= 2;
  84                         lnbuf = grep_realloc(lnbuf, ++lnbuflen);
  85                 }
  86                 if (c == '\n')
  87                         break;
  88                 lnbuf[n] = c;
  89         }
  90
  91         if (gzeof(f) && n == 0)
  92                 return NULL;
  93         *len = n;
  94         return lnbuf;
  95 }
  96 #endif
  97
  98 file_t *
  99 grep_fdopen(int fd, char *mode)
 100 {
 101         file_t *f;
 102
 103         if (fd == STDIN_FILENO)
 104                 snprintf(fname, sizeof fname, "(standard input)");
 105         else
 106                 snprintf(fname, sizeof fname, "(fd %d)", fd);
 107
 108         f = grep_malloc(sizeof *f);
 109
 110 #ifndef NOZ
 111         if (Zflag) {
 112                 f->type = FILE_GZIP;
 113                 f->noseek = lseek(fd, 0L, SEEK_SET) == -1;
 114                 if ((f->gzf = gzdopen(fd, mode)) != NULL)
 115                         return f;
 116         } else
 117 #endif
 118         {
 119                 f->type = FILE_STDIO;
 120                 f->noseek = isatty(fd);
 121                 if ((f->f = fdopen(fd, mode)) != NULL)
 122                         return f;
 123         }
 124
 125         free(f);
 126         return NULL;
 127 }
 128
 129 file_t *
 130 grep_open(char *path, char *mode)
 131 {
 132         file_t *f;
 133
 134         snprintf(fname, sizeof fname, "%s", path);
 135
 136         f = grep_malloc(sizeof *f);
 137         f->noseek = 0;
 138
 139 #ifndef NOZ
 140         if (Zflag) {
 141                 f->type = FILE_GZIP;
 142                 if ((f->gzf = gzopen(fname, mode)) != NULL)
 143                         return f;
 144         } else
 145 #endif
 146         {
 147 #ifdef FILE_MMAP
 148                 /* try mmap first; if it fails, try stdio */
 149                 if ((f->mmf = mmopen(fname, mode)) != NULL) {
 150                         f->type = FILE_MMAP;
 151                         return f;
 152                 }
 153 #endif
 154                 f->type = FILE_STDIO;
 155                 if ((f->f = fopen(path, mode)) != NULL)
 156                         return f;
 157         }
 158
 159         free(f);
 160         return NULL;
 161 }
 162
 163 int
 164 grep_bin_file(file_t *f)
 165 {
 166         if (f->noseek)
 167                 return 0;
 168
 169         switch (f->type) {
 170         case FILE_STDIO:
 171                 return bin_file(f->f);
 172 #ifdef FILE_MMAP
 173         case FILE_MMAP:
 174                 return mmbin_file(f->mmf);
 175 #endif
 176 #ifndef NOZ
 177         case FILE_GZIP:
 178                 return gzbin_file(f->gzf);
 179 #endif
 180         default:
 181                 /* can't happen */
 182                 errx(2, "invalid file type");
 183         }
 184 }
 185
 186 char *
 187 grep_fgetln(file_t *f, size_t *l)
 188 {
 189         switch (f->type) {
 190         case FILE_STDIO:
 191                 return fgetln(f->f, l);
 192 #ifdef FILE_MMAP
 193         case FILE_MMAP:
 194                 return mmfgetln(f->mmf, l);
 195 #endif
 196 #ifndef NOZ
 197         case FILE_GZIP:
 198                 return gzfgetln(f->gzf, l);
 199 #endif
 200         default:
 201                 /* can't happen */
 202                 errx(2, "invalid file type");
 203         }
 204 }
 205
 206 void
 207 grep_close(file_t *f)
 208 {
 209         switch (f->type) {
 210         case FILE_STDIO:
 211                 fclose(f->f);
 212                 break;
 213 #ifdef FILE_MMAP
 214         case FILE_MMAP:
 215                 mmclose(f->mmf);
 216                 break;
 217 #endif
 218 #ifndef NOZ
 219         case FILE_GZIP:
 220                 gzclose(f->gzf);
 221                 break;
 222 #endif
 223         default:
 224                 /* can't happen */
 225                 errx(2, "invalid file type");
 226         }
 227         free(f);
 228 }