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
36void 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
46void 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
53void fwriteint16_t(uint16_t data, FILE * fp)
54{
55 data = cpu_to_le16(data);
56 nasm_write(&data, 2, fp);
57}
58
59void fwriteint32_t(uint32_t data, FILE * fp)
60{
61 data = cpu_to_le32(data);
62 nasm_write(&data, 4, fp);
63}
64
65void fwriteint64_t(uint64_t data, FILE * fp)
66{
67 data = cpu_to_le64(data);
68 nasm_write(&data, 8, fp);
69}
70
71void fwriteaddr(uint64_t data, int size, FILE * fp)
72{
73 data = cpu_to_le64(data);
74 nasm_write(&data, size, fp);
75}
76
77void fwritezero(off_t bytes, FILE *fp)
78{
79 size_t blksize;
80
81#ifdef nasm_ftruncate
82 if (bytes >= BUFSIZ && !ferror(fp) && !feof(fp)) {
83 off_t pos = ftello(fp);
84 if (pos >= 0) {
85 pos += bytes;
86 if (!fflush(fp) &&
87 !nasm_ftruncate(fileno(fp), pos) &&
88 !fseeko(fp, pos, SEEK_SET))
89 return;
90 }
91 }
92#endif
93
94 while (bytes > 0) {
95 blksize = (bytes < ZERO_BUF_SIZE) ? bytes : ZERO_BUF_SIZE;
96
97 nasm_write(zero_buffer, blksize, fp);
98 bytes -= blksize;
99 }
100}
101
102FILE *nasm_open_read(const char *filename, enum file_flags flags)
103{
104 FILE *f = NULL;
105 bool again = true;
106
107#ifdef __GLIBC__
108 /*
109 * Try to open this file with memory mapping for speed, unless we are
110 * going to do it "manually" with nasm_map_file()
111 */
112 if (!(flags & NF_FORMAP)) {
113 f = fopen(filename, (flags & NF_TEXT) ? "rtm" : "rbm");
114 again = (!f) && (errno == EINVAL); /* Not supported, try without m */
115 }
116#endif
117
118 if (again)
119 f = fopen(filename, (flags & NF_TEXT) ? "rt" : "rb");
120
121 if (!f && (flags & NF_FATAL))
122 nasm_fatal(ERR_NOFILE, "unable to open input file: `%s': %s",
123 filename, strerror(errno));
124
125 return f;
126}
127
128FILE *nasm_open_write(const char *filename, enum file_flags flags)
129{
130 FILE *f;
131
132 f = fopen(filename, (flags & NF_TEXT) ? "wt" : "wb");
133
134 if (!f && (flags & NF_FATAL))
135 nasm_fatal(ERR_NOFILE, "unable to open output file: `%s': %s",
136 filename, strerror(errno));
137
138 return f;
139}
140
141/*
142 * Report the existence of a file
143 */
144bool nasm_file_exists(const char *filename)
145{
146#if defined(HAVE_FACCESSAT) && defined(AT_EACCESS)
147 return faccessat(AT_FDCWD, filename, R_OK, AT_EACCESS) == 0;
148#elif defined(HAVE_ACCESS)
149 return access(filename, R_OK) == 0;
150#else
151 FILE *f;
152
153 f = fopen(filename, "rb");
154 if (f) {
155 fclose(f);
156 return true;
157 } else {
158 return false;
159 }
160#endif
161}
162
163/*
164 * Report file size. This MAY move the file pointer.
165 */
166off_t nasm_file_size(FILE *f)
167{
168#ifdef HAVE__FILELENGTHI64
169 return _filelengthi64(fileno(f));
170#elif defined(nasm_fstat)
171 nasm_struct_stat st;
172
173 if (nasm_fstat(fileno(f), &st))
174 return (off_t)-1;
175
176 return st.st_size;
177#else
178 if (fseeko(f, 0, SEEK_END))
179 return (off_t)-1;
180
181 return ftello(f);
182#endif
183}
184
185/*
186 * Report file size given pathname
187 */
188off_t nasm_file_size_by_path(const char *pathname)
189{
190#ifdef nasm_stat
191 nasm_struct_stat st;
192
193 if (nasm_stat(pathname, &st))
194 return (off_t)-1;
195
196 return st.st_size;
197#else
198 FILE *fp;
199 off_t len;
200
201 fp = nasm_open_read(pathname, NF_BINARY);
202 if (!fp)
203 return (off_t)-1;
204
205 len = nasm_file_size(fp);
206 fclose(fp);
207
208 return len;
209#endif
210}
211
212/*
213 * Report the timestamp on a file, returns true if successful
214 */
215bool nasm_file_time(time_t *t, const char *pathname)
216{
217#ifdef nasm_stat
218 nasm_struct_stat st;
219
220 if (nasm_stat(pathname, &st))
221 return false;
222
223 *t = st.st_mtime;
224 return true;
225#else
226 return false; /* No idea how to do this on this OS */
227#endif
228}
229