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("unable to read input: %s", strerror(errno));
  41     } else if (n != size || feof(f)) {
  42         nasm_fatal("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("unable to write output: %s", strerror(errno));
  51 }
  52
  53 void fwriteint16_t(uint16_t data, FILE * fp)
  54 {
  55     data = cpu_to_le16(data);
  56     nasm_write(&data, 2, fp);
  57 }
  58
  59 void fwriteint32_t(uint32_t data, FILE * fp)
  60 {
  61     data = cpu_to_le32(data);
  62     nasm_write(&data, 4, fp);
  63 }
  64
  65 void fwriteint64_t(uint64_t data, FILE * fp)
  66 {
  67     data = cpu_to_le64(data);
  68     nasm_write(&data, 8, fp);
  69 }
  70
  71 void fwriteaddr(uint64_t data, int size, FILE * fp)
  72 {
  73     data = cpu_to_le64(data);
  74     nasm_write(&data, size, fp);
  75 }
  76
  77 void fwritezero(off_t bytes, FILE *fp)
  78 {
  79     size_t blksize;
  80
  81 #ifdef os_ftruncate
  82     if (bytes >= BUFSIZ && !ferror(fp) && !feof(fp)) {
  83         off_t pos = ftello(fp);
  84         if (pos != (off_t)-1) {
  85             off_t end = pos + bytes;
  86             if (!fflush(fp) && !os_ftruncate(fileno(fp), end)) {
  87                 fseeko(fp, 0, SEEK_END);
  88                 pos = ftello(fp);
  89                 if (pos != (off_t)-1)
  90                     bytes = end - pos; /* This SHOULD be zero */
  91             }
  92         }
  93     }
  94 #endif
  95
  96     while (bytes > 0) {
  97         blksize = (bytes < ZERO_BUF_SIZE) ? bytes : ZERO_BUF_SIZE;
  98
  99         nasm_write(zero_buffer, blksize, fp);
 100         bytes -= blksize;
 101     }
 102 }
 103
 104 #ifdef _WIN32
 105
 106 /*
 107  * On Windows, we want to use _wfopen(), as fopen() has a much smaller limit
 108  * on the path length that it supports.
 109  *
 110  * Previously we tried to prefix the path name with \\?\ in order to
 111  * let the Windows kernel know that we are not limited to PATH_MAX
 112  * characters, but it breaks relative paths among other things, and
 113  * apparently Windows 10 contains a registry option to override this
 114  * limit anyway. One day maybe they will even implement UTF-8 as byte
 115  * characters so we can use the standard file API even on this OS.
 116  */
 117
 118 os_filename os_mangle_filename(const char *filename)
 119 {
 120     mbstate_t ps;
 121     size_t wclen;
 122     wchar_t *buf;
 123     const char *p;
 124
 125     /*
 126      * Note: mbsrtowcs() return (size_t)-1 on error, otherwise
 127      * the length of the string *without* final NUL in wchar_t
 128      * units. Thus we add 1 for the final NUL; the error value
 129      * now becomes 0.
 130      */
 131     memset(&ps, 0, sizeof ps);  /* Begin in the initial state */
 132     p = filename;
 133     wclen = mbsrtowcs(NULL, &p, 0, &ps) + 1;
 134     if (!wclen)
 135         return NULL;
 136
 137     buf = nasm_malloc(wclen * sizeof(wchar_t));
 138
 139     memset(&ps, 0, sizeof ps);  /* Begin in the initial state */
 140     p = filename;
 141     if (mbsrtowcs(buf, &p, wclen, &ps) + 1 != wclen || p) {
 142         nasm_free(buf);
 143         return NULL;
 144     }
 145
 146     return buf;
 147 }
 148
 149 #endif
 150
 151 FILE *nasm_open_read(const char *filename, enum file_flags flags)
 152 {
 153     FILE *f = NULL;
 154     os_filename osfname;
 155
 156     osfname = os_mangle_filename(filename);
 157     if (osfname) {
 158         os_fopenflag fopen_flags[4];
 159         memset(fopen_flags, 0, sizeof fopen_flags);
 160
 161         fopen_flags[0] = 'r';
 162         fopen_flags[1] = (flags & NF_TEXT) ? 't' : 'b';
 163
 164 #if defined(__GLIBC__) || defined(__linux__)
 165         /*
 166          * Try to open this file with memory mapping for speed, unless we are
 167          * going to do it "manually" with nasm_map_file()
 168          */
 169         if (!(flags & NF_FORMAP))
 170             fopen_flags[2] = 'm';
 171 #endif
 172
 173         while (true) {
 174             f = os_fopen(osfname, fopen_flags);
 175             if (f || errno != EINVAL || !fopen_flags[2])
 176                 break;
 177
 178             /* We got EINVAL but with 'm'; try again without 'm' */
 179             fopen_flags[2] = '\0';
 180         }
 181
 182         os_free_filename(osfname);
 183     }
 184
 185     if (!f && (flags & NF_FATAL))
 186         nasm_fatalf(ERR_NOFILE, "unable to open input file: `%s': %s",
 187                     filename, strerror(errno));
 188
 189     return f;
 190 }
 191
 192 FILE *nasm_open_write(const char *filename, enum file_flags flags)
 193 {
 194     FILE *f = NULL;
 195     os_filename osfname;
 196
 197     osfname = os_mangle_filename(filename);
 198     if (osfname) {
 199         os_fopenflag fopen_flags[3];
 200
 201         fopen_flags[0] = 'w';
 202         fopen_flags[1] = (flags & NF_TEXT) ? 't' : 'b';
 203         fopen_flags[2] = '\0';
 204
 205         f = os_fopen(osfname, fopen_flags);
 206         os_free_filename(osfname);
 207     }
 208
 209     if (!f && (flags & NF_FATAL))
 210         nasm_fatalf(ERR_NOFILE, "unable to open output file: `%s': %s",
 211                     filename, strerror(errno));
 212
 213     return f;
 214 }
 215
 216 /* The appropriate "rb" strings for os_fopen() */
 217 static const os_fopenflag fopenflags_rb[3] = { 'r', 'b', 0 };
 218
 219 /*
 220  * Report the existence of a file
 221  */
 222 bool nasm_file_exists(const char *filename)
 223 {
 224 #ifndef os_access
 225     FILE *f;
 226 #endif
 227     os_filename osfname;
 228     bool exists;
 229
 230     osfname = os_mangle_filename(filename);
 231     if (!osfname)
 232         return false;
 233
 234 #ifdef os_access
 235     exists = os_access(osfname, R_OK) == 0;
 236 #else
 237     f = os_fopen(osfname, fopenflags_rb);
 238     exists = f != NULL;
 239     if (f)
 240         fclose(f);
 241 #endif
 242
 243     os_free_filename(osfname);
 244     return exists;
 245 }
 246
 247 /*
 248  * Report the file size of an open file.  This MAY move the file pointer.
 249  */
 250 off_t nasm_file_size(FILE *f)
 251 {
 252     off_t where, end;
 253     os_struct_stat st;
 254
 255     if (!os_fstat(fileno(f), &st) && S_ISREG(st.st_mode))
 256         return st.st_size;
 257
 258     /* Do it the hard way... this tests for seekability */
 259
 260     if (fseeko(f, 0, SEEK_CUR))
 261         goto fail;              /* Not seekable, don't even try */
 262
 263     where = ftello(f);
 264     if (where == (off_t)-1)
 265         goto fail;
 266
 267     if (fseeko(f, 0, SEEK_END))
 268         goto fail;
 269
 270     end = ftello(f);
 271     if (end == (off_t)-1)
 272         goto fail;
 273
 274     /*
 275      * Move the file pointer back. If this fails, this is probably
 276      * not a plain file.
 277      */
 278     if (fseeko(f, where, SEEK_SET))
 279         goto fail;
 280
 281     return end;
 282
 283 fail:
 284     return -1;
 285 }
 286
 287 /*
 288  * Report file size given pathname
 289  */
 290 off_t nasm_file_size_by_path(const char *pathname)
 291 {
 292     os_filename osfname;
 293     off_t len = -1;
 294     os_struct_stat st;
 295     FILE *fp;
 296
 297     osfname = os_mangle_filename(pathname);
 298
 299     if (!os_stat(osfname, &st) && S_ISREG(st.st_mode))
 300         len = st.st_size;
 301
 302     fp = os_fopen(osfname, fopenflags_rb);
 303     if (fp) {
 304         len = nasm_file_size(fp);
 305         fclose(fp);
 306     }
 307
 308     return len;
 309 }
 310
 311 /*
 312  * Report the timestamp on a file, returns true if successful
 313  */
 314 bool nasm_file_time(time_t *t, const char *pathname)
 315 {
 316 #ifdef os_stat
 317     os_filename osfname;
 318     os_struct_stat st;
 319     bool rv = false;
 320
 321     osfname = os_mangle_filename(pathname);
 322     if (!osfname)
 323         return false;
 324
 325     rv = !os_stat(osfname, &st);
 326     *t = st.st_mtime;
 327     os_free_filename(osfname);
 328
 329     return rv;
 330 #else
 331     return false;               /* No idea how to do this on this OS */
 332 #endif
 333 }