nasmlib/file.c

   1 /* ----------------------------------------------------------------------- *
   2  *
   3  *   Copyright 1996-2017 The NASM Authors - All Rights Reserved
   4  *   See the file AUTHORS included with the NASM distribution for
   5  *   the specific copyright holders.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following
   9  *   conditions are met:
  10  *
  11  *   * Redistributions of source code must retain the above copyright
  12  *     notice, this list of conditions and the following disclaimer.
  13  *   * Redistributions in binary form must reproduce the above
  14  *     copyright notice, this list of conditions and the following
  15  *     disclaimer in the documentation and/or other materials provided
  16  *     with the distribution.
  17  *
  18  *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
  19  *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  20  *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  21  *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  22  *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  23  *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24  *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  25  *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  26  *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  29  *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  30  *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  *
  32  * ----------------------------------------------------------------------- */
  33
  34 #include "file.h"
  35
  36 void nasm_read(void *ptr, size_t size, FILE *f)
  37 {
  38     size_t n = fread(ptr, 1, size, f);
  39     if (ferror(f)) {
  40         nasm_fatal(0, "unable to read input: %s", strerror(errno));
  41     } else if (n != size || feof(f)) {
  42         nasm_fatal(0, "fatal short read on input");
  43     }
  44 }
  45
  46 void nasm_write(const void *ptr, size_t size, FILE *f)
  47 {
  48     size_t n = fwrite(ptr, 1, size, f);
  49     if (n != size || ferror(f) || feof(f))
  50         nasm_fatal(0, "unable to write output: %s", strerror(errno));
  51 }
  52
  53 #ifdef WORDS_LITTLEENDIAN
  54
  55 void fwriteint16_t(uint16_t data, FILE * fp)
  56 {
  57     nasm_write(&data, 2, fp);
  58 }
  59
  60 void fwriteint32_t(uint32_t data, FILE * fp)
  61 {
  62     nasm_write(&data, 4, fp);
  63 }
  64
  65 void fwriteint64_t(uint64_t data, FILE * fp)
  66 {
  67     nasm_write(&data, 8, fp);
  68 }
  69
  70 void fwriteaddr(uint64_t data, int size, FILE * fp)
  71 {
  72     nasm_write(&data, size, fp);
  73 }
  74
  75 #else /* not WORDS_LITTLEENDIAN */
  76
  77 void fwriteint16_t(uint16_t data, FILE * fp)
  78 {
  79     char buffer[2], *p = buffer;
  80     WRITESHORT(p, data);
  81     nasm_write(buffer, 2, fp);
  82 }
  83
  84 void fwriteint32_t(uint32_t data, FILE * fp)
  85 {
  86     char buffer[4], *p = buffer;
  87     WRITELONG(p, data);
  88     nasm_write(buffer, 4, fp);
  89 }
  90
  91 void fwriteint64_t(uint64_t data, FILE * fp)
  92 {
  93     char buffer[8], *p = buffer;
  94     WRITEDLONG(p, data);
  95     nasm_write(buffer, 8, fp);
  96 }
  97
  98 void fwriteaddr(uint64_t data, int size, FILE * fp)
  99 {
 100     char buffer[8], *p = buffer;
 101     WRITEADDR(p, data, size);
 102     nasm_write(buffer, size, fp);
 103 }
 104
 105 #endif
 106
 107
 108 void fwritezero(off_t bytes, FILE *fp)
 109 {
 110     size_t blksize;
 111
 112 #ifdef nasm_ftruncate
 113     if (bytes >= BUFSIZ && !ferror(fp) && !feof(fp)) {
 114         off_t pos = ftello(fp);
 115         if (pos >= 0) {
 116             pos += bytes;
 117             if (!fflush(fp) &&
 118                 !nasm_ftruncate(fileno(fp), pos) &&
 119                 !fseeko(fp, pos, SEEK_SET))
 120                     return;
 121         }
 122     }
 123 #endif
 124
 125     while (bytes > 0) {
 126         blksize = (bytes < ZERO_BUF_SIZE) ? bytes : ZERO_BUF_SIZE;
 127
 128         nasm_write(zero_buffer, blksize, fp);
 129         bytes -= blksize;
 130     }
 131 }
 132
 133 FILE *nasm_open_read(const char *filename, enum file_flags flags)
 134 {
 135     FILE *f = NULL;
 136     bool again = true;
 137
 138 #ifdef __GLIBC__
 139     /*
 140      * Try to open this file with memory mapping for speed, unless we are
 141      * going to do it "manually" with nasm_map_file()
 142      */
 143     if (!(flags & NF_FORMAP)) {
 144         f = fopen(filename, (flags & NF_TEXT) ? "rtm" : "rbm");
 145         again = (!f) && (errno == EINVAL); /* Not supported, try without m */
 146     }
 147 #endif
 148
 149     if (again)
 150         f = fopen(filename, (flags & NF_TEXT) ? "rt" : "rb");
 151
 152     if (!f && (flags & NF_FATAL))
 153         nasm_fatal(ERR_NOFILE, "unable to open input file: `%s': %s",
 154                    filename, strerror(errno));
 155
 156     return f;
 157 }
 158
 159 FILE *nasm_open_write(const char *filename, enum file_flags flags)
 160 {
 161     FILE *f;
 162
 163     f = fopen(filename, (flags & NF_TEXT) ? "wt" : "wb");
 164
 165     if (!f && (flags & NF_FATAL))
 166         nasm_fatal(ERR_NOFILE, "unable to open output file: `%s': %s",
 167                    filename, strerror(errno));
 168
 169     return f;
 170 }
 171
 172 /*
 173  * Report the existence of a file
 174  */
 175 bool nasm_file_exists(const char *filename)
 176 {
 177 #if defined(HAVE_FACCESSAT) && defined(AT_EACCESS)
 178     return faccessat(AT_FDCWD, filename, R_OK, AT_EACCESS) == 0;
 179 #elif defined(HAVE_ACCESS)
 180     return access(filename, R_OK) == 0;
 181 #else
 182     FILE *f;
 183
 184     f = fopen(filename, "rb");
 185     if (f) {
 186         fclose(f);
 187         return true;
 188     } else {
 189         return false;
 190     }
 191 #endif
 192 }
 193
 194 /*
 195  * Report file size.  This MAY move the file pointer.
 196  */
 197 off_t nasm_file_size(FILE *f)
 198 {
 199 #ifdef HAVE__FILELENGTHI64
 200     return _filelengthi64(fileno(f));
 201 #elif defined(nasm_fstat)
 202     nasm_struct_stat st;
 203
 204     if (nasm_fstat(fileno(f), &st))
 205         return (off_t)-1;
 206
 207     return st.st_size;
 208 #else
 209     if (fseeko(f, 0, SEEK_END))
 210         return (off_t)-1;
 211
 212     return ftello(f);
 213 #endif
 214 }
 215
 216 /*
 217  * Report file size given pathname
 218  */
 219 off_t nasm_file_size_by_path(const char *pathname)
 220 {
 221 #ifdef nasm_stat
 222     nasm_struct_stat st;
 223
 224     if (nasm_stat(pathname, &st))
 225         return (off_t)-1;
 226
 227     return st.st_size;
 228 #else
 229     FILE *fp;
 230     off_t len;
 231
 232     fp = nasm_open_read(pathname, NF_BINARY);
 233     if (!fp)
 234         return (off_t)-1;
 235
 236     len = nasm_file_size(fp);
 237     fclose(fp);
 238
 239     return len;
 240 #endif
 241 }
 242
 243 /*
 244  * Report the timestamp on a file, returns true if successful
 245  */
 246 bool nasm_file_time(time_t *t, const char *pathname)
 247 {
 248 #ifdef nasm_stat
 249     nasm_struct_stat st;
 250
 251     if (nasm_stat(pathname, &st))
 252         return false;
 253
 254     *t = st.st_mtime;
 255     return true;
 256 #else
 257     return false;               /* No idea how to do this on this OS */
 258 #endif
 259 }