1 /* read-file.c -- read file contents into a string
2 Copyright (C) 2006, 2009-2021 Free Software Foundation, Inc.
3 Written by Simon Josefsson and Bruno Haible.
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 3, or (at your option)
8 any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, see <https://www.gnu.org/licenses/>. */
17
18 #include <config.h>
19
20 #include "read-file.h"
21
22 /* Get fstat. */
23 #include <sys/stat.h>
24
25 /* Get ftello. */
26 #include <stdio.h>
27
28 /* Get PTRDIFF_MAX. */
29 #include <stdint.h>
30
31 /* Get malloc, realloc, free. */
32 #include <stdlib.h>
33
34 /* Get explicit_bzero, memcpy. */
35 #include <string.h>
36
37 /* Get errno. */
38 #include <errno.h>
39
40 /* Read a STREAM and return a newly allocated string with the content,
41 and set *LENGTH to the length of the string. The string is
42 zero-terminated, but the terminating zero byte is not counted in
43 *LENGTH. On errors, *LENGTH is undefined, errno preserves the
44 values set by system functions (if any), and NULL is returned.
45
46 If the RF_SENSITIVE flag is set in FLAGS:
47 - You should control the buffering of STREAM using 'setvbuf'. Either
48 clear the buffer of STREAM after closing it, or disable buffering of
49 STREAM before calling this function.
50 - The memory buffer internally allocated will be cleared upon failure. */
51 char *
52 fread_file (FILE *stream, int flags, size_t *length)
53 {
54 char *buf = NULL;
55 size_t alloc = BUFSIZ;
56
57 /* For a regular file, allocate a buffer that has exactly the right
58 size. This avoids the need to do dynamic reallocations later. */
59 {
60 struct stat st;
61
62 if (fstat (fileno (stream), &st) >= 0 && S_ISREG (st.st_mode))
63 {
64 off_t pos = ftello (stream);
65
66 if (pos >= 0 && pos < st.st_size)
67 {
68 off_t alloc_off = st.st_size - pos;
69
70 /* '1' below, accounts for the trailing NUL. */
71 if (PTRDIFF_MAX - 1 < alloc_off)
72 {
73 errno = ENOMEM;
74 return NULL;
75 }
76
77 alloc = alloc_off + 1;
78 }
79 }
80 }
81
82 if (!(buf = malloc (alloc)))
83 return NULL; /* errno is ENOMEM. */
84
85 {
86 size_t size = 0; /* number of bytes read so far */
87 int save_errno;
88
89 for (;;)
90 {
91 /* This reads 1 more than the size of a regular file
92 so that we get eof immediately. */
93 size_t requested = alloc - size;
94 size_t count = fread (buf + size, 1, requested, stream);
95 size += count;
96
97 if (count != requested)
98 {
99 save_errno = errno;
100 if (ferror (stream))
101 break;
102
103 /* Shrink the allocated memory if possible. */
104 if (size < alloc - 1)
105 {
106 if (flags & RF_SENSITIVE)
107 {
108 char *smaller_buf = malloc (size + 1);
109 if (smaller_buf == NULL)
110 explicit_bzero (buf + size, alloc - size);
111 else
112 {
113 memcpy (smaller_buf, buf, size);
114 explicit_bzero (buf, alloc);
115 free (buf);
116 buf = smaller_buf;
117 }
118 }
119 else
120 {
121 char *smaller_buf = realloc (buf, size + 1);
122 if (smaller_buf != NULL)
123 buf = smaller_buf;
124 }
125 }
126
127 buf[size] = '\0';
128 *length = size;
129 return buf;
130 }
131
132 {
133 char *new_buf;
134 size_t save_alloc = alloc;
135
136 if (alloc == PTRDIFF_MAX)
137 {
138 save_errno = ENOMEM;
139 break;
140 }
141
142 if (alloc < PTRDIFF_MAX - alloc / 2)
143 alloc = alloc + alloc / 2;
144 else
145 alloc = PTRDIFF_MAX;
146
147 if (flags & RF_SENSITIVE)
148 {
149 new_buf = malloc (alloc);
150 if (!new_buf)
151 {
152 /* BUF should be cleared below after the loop. */
153 save_errno = errno;
154 break;
155 }
156 memcpy (new_buf, buf, save_alloc);
157 explicit_bzero (buf, save_alloc);
158 free (buf);
159 }
160 else if (!(new_buf = realloc (buf, alloc)))
161 {
162 save_errno = errno;
163 break;
164 }
165
166 buf = new_buf;
167 }
168 }
169
170 if (flags & RF_SENSITIVE)
171 explicit_bzero (buf, alloc);
172
173 free (buf);
174 errno = save_errno;
175 return NULL;
176 }
177 }
178
179 /* Open and read the contents of FILENAME, and return a newly
180 allocated string with the content, and set *LENGTH to the length of
181 the string. The string is zero-terminated, but the terminating
182 zero byte is not counted in *LENGTH. On errors, *LENGTH is
183 undefined, errno preserves the values set by system functions (if
184 any), and NULL is returned.
185
186 If the RF_BINARY flag is set in FLAGS, the file is opened in binary
187 mode. If the RF_SENSITIVE flag is set in FLAGS, the memory buffer
188 internally allocated will be cleared upon failure. */
189 char *
190 read_file (const char *filename, int flags, size_t *length)
191 {
192 const char *mode = (flags & RF_BINARY) ? "rbe" : "re";
193 FILE *stream = fopen (filename, mode);
194 char *out;
195
196 if (!stream)
197 return NULL;
198
199 if (flags & RF_SENSITIVE)
200 setvbuf (stream, NULL, _IONBF, 0);
201
202 out = fread_file (stream, flags, length);
203
204 if (fclose (stream) != 0)
205 {
206 if (out)
207 {
208 if (flags & RF_SENSITIVE)
209 explicit_bzero (out, *length);
210 free (out);
211 }
212 return NULL;
213 }
214
215 return out;
216 }