Line | Branch | Exec | Source |
---|---|---|---|
1 | #include "feature.h" | ||
2 | #include <errno.h> | ||
3 | #include <stdint.h> | ||
4 | #include <stdio.h> | ||
5 | #include <stdlib.h> | ||
6 | #include <string.h> | ||
7 | #include <sys/mman.h> | ||
8 | #include <sys/stat.h> | ||
9 | #include <unistd.h> | ||
10 | #include "load-save.h" | ||
11 | #include "block.h" | ||
12 | #include "convert.h" | ||
13 | #include "encoding.h" | ||
14 | #include "options.h" | ||
15 | #include "util/debug.h" | ||
16 | #include "util/fd.h" | ||
17 | #include "util/list.h" | ||
18 | #include "util/log.h" | ||
19 | #include "util/path.h" | ||
20 | #include "util/str-util.h" | ||
21 | #include "util/time-util.h" | ||
22 | #include "util/xadvise.h" | ||
23 | #include "util/xreadwrite.h" | ||
24 | |||
25 | 34 | static bool decode_and_add_blocks(Buffer *buffer, const unsigned char *buf, size_t size, bool utf8_bom) | |
26 | { | ||
27 | 34 | EncodingType bom_type = detect_encoding_from_bom(buf, size); | |
28 |
3/4✓ Branch 0 (3→4) taken 26 times.
✓ Branch 1 (3→11) taken 8 times.
✗ Branch 2 (4→5) not taken.
✓ Branch 3 (4→17) taken 26 times.
|
34 | if (!buffer->encoding && bom_type != UNKNOWN_ENCODING) { |
29 | ✗ | const char *enc = encoding_from_type(bom_type); | |
30 | ✗ | if (!conversion_supported_by_iconv(enc, "UTF-8")) { | |
31 | // TODO: Use error_msg() and return false here? | ||
32 | ✗ | LOG_NOTICE("file has %s BOM, but conversion unsupported", enc); | |
33 | ✗ | enc = encoding_from_type(UTF8); | |
34 | } | ||
35 | ✗ | buffer_set_encoding(buffer, enc, utf8_bom); | |
36 | } | ||
37 | |||
38 | // Skip BOM only if it matches the specified file encoding | ||
39 |
1/4✗ Branch 0 (11→12) not taken.
✓ Branch 1 (11→17) taken 8 times.
✗ Branch 2 (13→14) not taken.
✗ Branch 3 (13→17) not taken.
|
8 | if (bom_type != UNKNOWN_ENCODING && bom_type == lookup_encoding(buffer->encoding)) { |
40 | ✗ | const ByteOrderMark *bom = get_bom_for_encoding(bom_type); | |
41 | ✗ | if (bom) { | |
42 | ✗ | const size_t bom_len = bom->len; | |
43 | ✗ | buf += bom_len; | |
44 | ✗ | size -= bom_len; | |
45 | ✗ | buffer->bom = true; | |
46 | } | ||
47 | } | ||
48 | |||
49 |
2/2✓ Branch 0 (17→18) taken 26 times.
✓ Branch 1 (17→20) taken 8 times.
|
34 | if (!buffer->encoding) { |
50 | 26 | buffer->encoding = encoding_from_type(UTF8); | |
51 | 26 | buffer->bom = utf8_bom; | |
52 | } | ||
53 | |||
54 | 34 | return file_decoder_read(buffer, buf, size); | |
55 | } | ||
56 | |||
57 | 34 | static void fixup_blocks(Buffer *buffer) | |
58 | { | ||
59 |
2/2✓ Branch 0 (2→3) taken 6 times.
✓ Branch 1 (2→6) taken 28 times.
|
34 | if (list_empty(&buffer->blocks)) { |
60 | 6 | Block *blk = block_new(1); | |
61 | 6 | list_insert_before(&blk->node, &buffer->blocks); | |
62 | 6 | return; | |
63 | } | ||
64 | |||
65 | 28 | Block *lastblk = BLOCK(buffer->blocks.prev); | |
66 | 28 | BUG_ON(!lastblk); | |
67 | 28 | size_t n = lastblk->size; | |
68 |
2/4✓ Branch 0 (8→9) taken 28 times.
✗ Branch 1 (8→12) not taken.
✗ Branch 2 (9→10) not taken.
✓ Branch 3 (9→12) taken 28 times.
|
28 | if (n && lastblk->data[n - 1] != '\n') { |
69 | // Incomplete lines are not allowed because they're special | ||
70 | // cases and cause lots of trouble | ||
71 | ✗ | block_grow(lastblk, n + 1); | |
72 | ✗ | lastblk->data[n] = '\n'; | |
73 | ✗ | lastblk->size++; | |
74 | ✗ | lastblk->nl++; | |
75 | ✗ | buffer->nl++; | |
76 | } | ||
77 | } | ||
78 | |||
79 | 48 | static bool update_file_info(FileInfo *info, const struct stat *st) | |
80 | { | ||
81 | 48 | *info = (FileInfo) { | |
82 | 48 | .size = st->st_size, | |
83 | 48 | .mode = st->st_mode, | |
84 | 48 | .gid = st->st_gid, | |
85 | 48 | .uid = st->st_uid, | |
86 | 48 | .dev = st->st_dev, | |
87 | 48 | .ino = st->st_ino, | |
88 | 48 | .mtime = *get_stat_mtime(st), | |
89 | }; | ||
90 | 48 | return true; | |
91 | } | ||
92 | |||
93 | 21 | static bool buffer_stat(FileInfo *info, const char *filename) | |
94 | { | ||
95 | 21 | struct stat st; | |
96 |
2/4✓ Branch 0 (3→4) taken 21 times.
✗ Branch 1 (3→7) not taken.
✗ Branch 2 (5→6) not taken.
✓ Branch 3 (5→7) taken 21 times.
|
21 | return !stat(filename, &st) && update_file_info(info, &st); |
97 | } | ||
98 | |||
99 | 27 | static bool buffer_fstat(FileInfo *info, int fd) | |
100 | { | ||
101 | 27 | struct stat st; | |
102 |
2/4✓ Branch 0 (3→4) taken 27 times.
✗ Branch 1 (3→7) not taken.
✗ Branch 2 (5→6) not taken.
✓ Branch 3 (5→7) taken 27 times.
|
27 | return !fstat(fd, &st) && update_file_info(info, &st); |
103 | } | ||
104 | |||
105 | 34 | bool read_blocks(Buffer *buffer, int fd, bool utf8_bom) | |
106 | { | ||
107 | 34 | const size_t map_size = 64 * 1024; | |
108 | 34 | size_t size = buffer->file.size; | |
109 | 34 | unsigned char *buf = NULL; | |
110 | 34 | bool mapped = false; | |
111 | 34 | bool ret = false; | |
112 | |||
113 |
2/2✓ Branch 0 (2→3) taken 1 times.
✓ Branch 1 (2→7) taken 33 times.
|
34 | if (size >= map_size) { |
114 | // NOTE: size must be greater than 0 | ||
115 | 1 | buf = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0); | |
116 |
1/2✓ Branch 0 (4→5) taken 1 times.
✗ Branch 1 (4→7) not taken.
|
1 | if (buf != MAP_FAILED) { |
117 | 1 | advise_sequential(buf, size); | |
118 | 1 | mapped = true; | |
119 | 1 | goto decode; | |
120 | } | ||
121 | 33 | buf = NULL; | |
122 | } | ||
123 | |||
124 |
2/2✓ Branch 0 (7→8) taken 25 times.
✓ Branch 1 (7→14) taken 8 times.
|
33 | if (likely(size > 0)) { |
125 | 25 | buf = malloc(size); | |
126 |
1/2✗ Branch 0 (8→9) not taken.
✓ Branch 1 (8→10) taken 25 times.
|
25 | if (unlikely(!buf)) { |
127 | ✗ | goto error; | |
128 | } | ||
129 | 25 | ssize_t rc = xread_all(fd, buf, size); | |
130 |
1/2✗ Branch 0 (11→12) not taken.
✓ Branch 1 (11→13) taken 25 times.
|
25 | if (unlikely(rc < 0)) { |
131 | ✗ | goto error; | |
132 | } | ||
133 | 25 | size = rc; | |
134 | } else { | ||
135 | // st_size is zero for some files in /proc | ||
136 | 8 | size_t alloc = map_size; | |
137 | 8 | BUG_ON(!IS_POWER_OF_2(alloc)); | |
138 | 8 | buf = malloc(alloc); | |
139 |
1/2✗ Branch 0 (14→15) not taken.
✓ Branch 1 (14→17) taken 8 times.
|
8 | if (unlikely(!buf)) { |
140 | ✗ | goto error; | |
141 | } | ||
142 | size_t pos = 0; | ||
143 | 10 | while (1) { | |
144 | 10 | ssize_t rc = xread_all(fd, buf + pos, alloc - pos); | |
145 |
1/2✗ Branch 0 (18→19) not taken.
✓ Branch 1 (18→20) taken 10 times.
|
10 | if (rc < 0) { |
146 | ✗ | goto error; | |
147 | } | ||
148 |
2/2✓ Branch 0 (20→21) taken 2 times.
✓ Branch 1 (20→26) taken 8 times.
|
10 | if (rc == 0) { |
149 | break; | ||
150 | } | ||
151 | 2 | pos += rc; | |
152 |
1/2✓ Branch 0 (21→16) taken 2 times.
✗ Branch 1 (21→22) not taken.
|
2 | if (pos == alloc) { |
153 | ✗ | size_t new_alloc = alloc << 1; | |
154 | ✗ | if (unlikely(alloc >= new_alloc)) { | |
155 | ✗ | errno = EOVERFLOW; | |
156 | ✗ | goto error; | |
157 | } | ||
158 | ✗ | alloc = new_alloc; | |
159 | ✗ | char *new_buf = realloc(buf, alloc); | |
160 | ✗ | if (unlikely(!new_buf)) { | |
161 | ✗ | goto error; | |
162 | } | ||
163 | buf = new_buf; | ||
164 | } | ||
165 | } | ||
166 | size = pos; | ||
167 | } | ||
168 | |||
169 | 34 | decode: | |
170 | 34 | ret = decode_and_add_blocks(buffer, buf, size, utf8_bom); | |
171 | |||
172 | 34 | error: | |
173 |
2/2✓ Branch 0 (27→28) taken 1 times.
✓ Branch 1 (27→29) taken 33 times.
|
34 | if (mapped) { |
174 | 1 | munmap(buf, size); | |
175 | } else { | ||
176 | 33 | free(buf); | |
177 | } | ||
178 | |||
179 |
1/2✓ Branch 0 (30→31) taken 34 times.
✗ Branch 1 (30→32) not taken.
|
34 | if (ret) { |
180 | 34 | fixup_blocks(buffer); | |
181 | } | ||
182 | |||
183 | 34 | return ret; | |
184 | } | ||
185 | |||
186 | // Convert size in bytes to size in MiB (rounded up, for any remainder) | ||
187 | 98 | static uintmax_t filesize_in_mib(uintmax_t nbytes) | |
188 | { | ||
189 | 98 | return (nbytes >> 20) + !!(nbytes & 0xFFFFF); | |
190 | } | ||
191 | |||
192 | 24 | UNITTEST { | |
193 | 24 | const uintmax_t seven_mib = 7UL << 20; | |
194 | // NOLINTBEGIN(bugprone-assert-side-effect) | ||
195 | 24 | BUG_ON(filesize_in_mib(seven_mib) != 7); | |
196 | 24 | BUG_ON(filesize_in_mib(seven_mib - 1) != 7); | |
197 | 24 | BUG_ON(filesize_in_mib(seven_mib + 1) != 8); | |
198 | // NOLINTEND(bugprone-assert-side-effect) | ||
199 | 24 | } | |
200 | |||
201 | 27 | bool load_buffer ( | |
202 | Buffer *buffer, | ||
203 | const char *filename, | ||
204 | const GlobalOptions *gopts, | ||
205 | ErrorBuffer *ebuf, | ||
206 | bool must_exist | ||
207 | ) { | ||
208 | 27 | BUG_ON(buffer->abs_filename); | |
209 | 27 | BUG_ON(!list_empty(&buffer->blocks)); | |
210 | |||
211 | 27 | int fd = xopen(filename, O_RDONLY | O_CLOEXEC, 0); | |
212 |
1/2✗ Branch 0 (7→8) not taken.
✓ Branch 1 (7→19) taken 27 times.
|
27 | if (fd < 0) { |
213 | ✗ | if (errno != ENOENT) { | |
214 | ✗ | return error_msg(ebuf, "Error opening %s: %s", filename, strerror(errno)); | |
215 | } | ||
216 | ✗ | if (must_exist) { | |
217 | ✗ | return error_msg(ebuf, "File %s does not exist", filename); | |
218 | } | ||
219 | ✗ | if (!buffer->encoding) { | |
220 | ✗ | buffer->encoding = encoding_from_type(UTF8); | |
221 | ✗ | buffer->bom = gopts->utf8_bom; | |
222 | } | ||
223 | ✗ | Block *blk = block_new(1); | |
224 | ✗ | list_insert_before(&blk->node, &buffer->blocks); | |
225 | ✗ | return true; | |
226 | } | ||
227 | |||
228 | 27 | FileInfo *info = &buffer->file; | |
229 |
1/2✗ Branch 0 (20→21) not taken.
✓ Branch 1 (20→24) taken 27 times.
|
27 | if (!buffer_fstat(info, fd)) { |
230 | ✗ | error_msg(ebuf, "fstat failed on %s: %s", filename, strerror(errno)); | |
231 | ✗ | goto error; | |
232 | } | ||
233 |
2/2✓ Branch 0 (24→25) taken 1 times.
✓ Branch 1 (24→27) taken 26 times.
|
27 | if (!S_ISREG(info->mode)) { |
234 | 1 | error_msg(ebuf, "Not a regular file %s", filename); | |
235 | 1 | goto error; | |
236 | } | ||
237 | |||
238 | 26 | off_t size = info->size; | |
239 |
1/2✗ Branch 0 (27→28) not taken.
✓ Branch 1 (27→30) taken 26 times.
|
26 | if (unlikely(size < 0)) { |
240 | ✗ | error_msg(ebuf, "Invalid file size: %jd", (intmax_t)size); | |
241 | ✗ | goto error; | |
242 | } | ||
243 | |||
244 | 26 | unsigned int limit_mib = gopts->filesize_limit; | |
245 |
1/2✓ Branch 0 (30→31) taken 26 times.
✗ Branch 1 (30→34) not taken.
|
26 | if (limit_mib > 0) { |
246 | 26 | uintmax_t size_mib = filesize_in_mib(size); | |
247 |
1/2✗ Branch 0 (31→32) not taken.
✓ Branch 1 (31→34) taken 26 times.
|
26 | if (unlikely(size_mib > limit_mib)) { |
248 | ✗ | error_msg ( | |
249 | ebuf, | ||
250 | "File size (%juMiB) exceeds 'filesize-limit' option (%uMiB): %s", | ||
251 | size_mib, limit_mib, filename | ||
252 | ); | ||
253 | ✗ | goto error; | |
254 | } | ||
255 | } | ||
256 | |||
257 |
1/2✗ Branch 0 (35→36) not taken.
✓ Branch 1 (35→39) taken 26 times.
|
26 | if (!read_blocks(buffer, fd, gopts->utf8_bom)) { |
258 | ✗ | error_msg(ebuf, "Error reading %s: %s", filename, strerror(errno)); | |
259 | ✗ | goto error; | |
260 | } | ||
261 | |||
262 | 26 | BUG_ON(!buffer->encoding); | |
263 | 26 | xclose(fd); | |
264 | 26 | return true; | |
265 | |||
266 | 1 | error: | |
267 | 1 | xclose(fd); | |
268 | 1 | return false; | |
269 | } | ||
270 | |||
271 | 21 | static bool write_buffer(const Buffer *buffer, const FileSaveContext *ctx, int fd) | |
272 | { | ||
273 | 21 | ErrorBuffer *ebuf = ctx->ebuf; | |
274 | 21 | FileEncoder enc = file_encoder(ctx->encoding, ctx->crlf, fd); | |
275 | 21 | size_t size = 0; | |
276 | |||
277 |
1/2✗ Branch 0 (3→4) not taken.
✓ Branch 1 (3→12) taken 21 times.
|
21 | if (unlikely(ctx->write_bom)) { |
278 | ✗ | const EncodingType type = lookup_encoding(ctx->encoding); | |
279 | ✗ | const ByteOrderMark *bom = get_bom_for_encoding(type); | |
280 | ✗ | if (bom->len && xwrite_all(fd, bom->bytes, bom->len) < 0) { | |
281 | ✗ | file_encoder_free(&enc); | |
282 | ✗ | return error_msg_errno(ebuf, "write"); | |
283 | } | ||
284 | ✗ | size += bom->len; | |
285 | } | ||
286 | |||
287 | 21 | const Block *blk; | |
288 |
2/2✓ Branch 0 (18→13) taken 21 times.
✓ Branch 1 (18→19) taken 21 times.
|
42 | block_for_each(blk, &buffer->blocks) { |
289 | 21 | ssize_t rc = file_encoder_write(&enc, blk->data, blk->size); | |
290 |
1/2✗ Branch 0 (14→15) not taken.
✓ Branch 1 (14→17) taken 21 times.
|
21 | if (rc < 0) { |
291 | ✗ | file_encoder_free(&enc); | |
292 | ✗ | return error_msg_errno(ebuf, "write"); | |
293 | } | ||
294 | 21 | size += rc; | |
295 | } | ||
296 | |||
297 | 21 | size_t nr_errors = file_encoder_get_nr_errors(&enc); | |
298 | 21 | file_encoder_free(&enc); | |
299 |
1/2✗ Branch 0 (21→22) not taken.
✓ Branch 1 (21→25) taken 21 times.
|
21 | if (nr_errors > 0) { |
300 | // Any real error hides this message | ||
301 | ✗ | error_msg ( | |
302 | ebuf, | ||
303 | "Warning: %zu non-reversible character conversion%s; file saved", | ||
304 | nr_errors, | ||
305 | (nr_errors > 1) ? "s" : "" | ||
306 | ); | ||
307 | } | ||
308 | |||
309 | // Need to truncate if writing to existing file | ||
310 |
1/2✗ Branch 0 (26→27) not taken.
✓ Branch 1 (26→28) taken 21 times.
|
21 | if (xftruncate(fd, size)) { |
311 | ✗ | return error_msg_errno(ebuf, "ftruncate"); | |
312 | } | ||
313 | |||
314 | return true; | ||
315 | } | ||
316 | |||
317 | 21 | static int xmkstemp_cloexec(char *path_template) | |
318 | { | ||
319 | 21 | int fd; | |
320 | #if HAVE_MKOSTEMP | ||
321 | 42 | do { | |
322 | 21 | fd = mkostemp(path_template, O_CLOEXEC); | |
323 |
1/4✗ Branch 0 (4→5) not taken.
✓ Branch 1 (4→6) taken 21 times.
✗ Branch 2 (5→3) not taken.
✗ Branch 3 (5→6) not taken.
|
21 | } while (unlikely(fd == -1 && errno == EINTR)); |
324 | 21 | return fd; | |
325 | #endif | ||
326 | |||
327 | do { | ||
328 | fd = mkstemp(path_template); | ||
329 | } while (unlikely(fd == -1 && errno == EINTR)); | ||
330 | |||
331 | if (fd == -1) { | ||
332 | return fd; | ||
333 | } | ||
334 | |||
335 | if (unlikely(!fd_set_cloexec(fd, true))) { | ||
336 | int e = errno; | ||
337 | xclose(fd); | ||
338 | errno = e; | ||
339 | return -1; | ||
340 | } | ||
341 | |||
342 | return fd; | ||
343 | } | ||
344 | |||
345 | 21 | static int tmp_file ( | |
346 | const char *filename, | ||
347 | const FileInfo *info, | ||
348 | mode_t new_file_mode, | ||
349 | char *buf, | ||
350 | size_t buflen | ||
351 | ) { | ||
352 |
1/2✓ Branch 0 (2→3) taken 21 times.
✗ Branch 1 (2→23) not taken.
|
21 | if (str_has_prefix(filename, "/tmp/")) { |
353 | // Don't use temporary file when saving file in /tmp because crontab | ||
354 | // command doesn't like the file to be replaced | ||
355 | return -1; | ||
356 | } | ||
357 | |||
358 | 21 | const char *base = path_basename(filename); | |
359 | 21 | const StringView dir = path_slice_dirname(filename); | |
360 | 21 | const int dlen = (int)dir.length; | |
361 | 21 | int n = snprintf(buf, buflen, "%.*s/.tmp.%s.XXXXXX", dlen, dir.data, base); | |
362 |
2/4✓ Branch 0 (3→4) taken 21 times.
✗ Branch 1 (3→5) not taken.
✗ Branch 2 (4→5) not taken.
✓ Branch 3 (4→6) taken 21 times.
|
21 | if (unlikely(n <= 0 || n >= buflen)) { |
363 | ✗ | buf[0] = '\0'; | |
364 | ✗ | return -1; | |
365 | } | ||
366 | |||
367 | 21 | int fd = xmkstemp_cloexec(buf); | |
368 |
1/2✗ Branch 0 (7→8) not taken.
✓ Branch 1 (7→9) taken 21 times.
|
21 | if (fd == -1) { |
369 | // No write permission to the directory? | ||
370 | ✗ | buf[0] = '\0'; | |
371 | ✗ | return -1; | |
372 | } | ||
373 | |||
374 |
2/2✓ Branch 0 (9→10) taken 19 times.
✓ Branch 1 (9→15) taken 2 times.
|
21 | if (!info->mode) { |
375 | // New file | ||
376 |
1/2✗ Branch 0 (11→12) not taken.
✓ Branch 1 (11→14) taken 19 times.
|
19 | if (xfchmod(fd, new_file_mode) != 0) { |
377 | ✗ | LOG_WARNING("failed to set file mode: %s", strerror(errno)); | |
378 | } | ||
379 | 19 | return fd; | |
380 | } | ||
381 | |||
382 | // Preserve ownership and mode of the original file if possible | ||
383 |
1/2✗ Branch 0 (16→17) not taken.
✓ Branch 1 (16→19) taken 2 times.
|
2 | if (xfchown(fd, info->uid, info->gid) != 0) { |
384 | ✗ | LOG_WARNING("failed to preserve file ownership: %s", strerror(errno)); | |
385 | } | ||
386 |
1/2✗ Branch 0 (20→21) not taken.
✓ Branch 1 (20→23) taken 2 times.
|
2 | if (xfchmod(fd, info->mode) != 0) { |
387 | ✗ | LOG_WARNING("failed to preserve file mode: %s", strerror(errno)); | |
388 | } | ||
389 | |||
390 | return fd; | ||
391 | } | ||
392 | |||
393 | 21 | bool save_buffer(Buffer *buffer, const char *filename, const FileSaveContext *ctx) | |
394 | { | ||
395 | 21 | ErrorBuffer *ebuf = ctx->ebuf; | |
396 | 21 | BUG_ON(!ebuf); | |
397 | 21 | BUG_ON(!ctx->encoding); | |
398 | 21 | char tmp[8192]; | |
399 | 21 | tmp[0] = '\0'; | |
400 | 21 | int fd = -1; | |
401 | |||
402 |
1/2✗ Branch 0 (6→7) not taken.
✓ Branch 1 (6→8) taken 21 times.
|
21 | if (ctx->hardlinks) { |
403 | ✗ | LOG_INFO("target file has hard links; writing in-place"); | |
404 | } else { | ||
405 | // Try to use temporary file (safer) | ||
406 | 21 | fd = tmp_file(filename, &buffer->file, ctx->new_file_mode, tmp, sizeof(tmp)); | |
407 | } | ||
408 | |||
409 |
1/2✗ Branch 0 (9→10) not taken.
✓ Branch 1 (9→15) taken 21 times.
|
21 | if (fd < 0) { |
410 | // Overwrite the original file directly (if it exists). | ||
411 | // Ownership is preserved automatically if the file exists. | ||
412 | ✗ | mode_t mode = buffer->file.mode; | |
413 | ✗ | if (mode == 0) { | |
414 | // New file | ||
415 | ✗ | mode = ctx->new_file_mode; | |
416 | } | ||
417 | ✗ | fd = xopen(filename, O_CREAT | O_TRUNC | O_WRONLY | O_CLOEXEC, mode); | |
418 | ✗ | if (fd < 0) { | |
419 | ✗ | return error_msg_errno(ebuf, "open"); | |
420 | } | ||
421 | } | ||
422 | |||
423 |
1/2✗ Branch 0 (16→17) not taken.
✓ Branch 1 (16→18) taken 21 times.
|
21 | if (!write_buffer(buffer, ctx, fd)) { |
424 | ✗ | goto error; | |
425 | } | ||
426 | |||
427 |
1/4✗ Branch 0 (18→19) not taken.
✓ Branch 1 (18→23) taken 21 times.
✗ Branch 2 (20→21) not taken.
✗ Branch 3 (20→23) not taken.
|
21 | if (buffer->options.fsync && xfsync(fd) != 0) { |
428 | ✗ | error_msg_errno(ebuf, "fsync"); | |
429 | ✗ | goto error; | |
430 | } | ||
431 | |||
432 | 21 | int r = xclose(fd); | |
433 | 21 | fd = -1; | |
434 |
1/2✗ Branch 0 (24→25) not taken.
✓ Branch 1 (24→27) taken 21 times.
|
21 | if (r != 0) { |
435 | ✗ | error_msg_errno(ebuf, "close"); | |
436 | ✗ | goto error; | |
437 | } | ||
438 | |||
439 |
2/4✓ Branch 0 (27→28) taken 21 times.
✗ Branch 1 (27→32) not taken.
✗ Branch 2 (29→30) not taken.
✓ Branch 3 (29→32) taken 21 times.
|
21 | if (tmp[0] && rename(tmp, filename)) { |
440 | ✗ | error_msg_errno(ebuf, "rename"); | |
441 | ✗ | goto error; | |
442 | } | ||
443 | |||
444 | 21 | buffer_stat(&buffer->file, filename); | |
445 | 21 | return true; | |
446 | |||
447 | ✗ | error: | |
448 | ✗ | xclose(fd); | |
449 | ✗ | if (tmp[0]) { | |
450 | ✗ | unlink(tmp); | |
451 | } else { | ||
452 | // Not using temporary file, therefore mtime may have changed. | ||
453 | // Update stat to avoid "File has been modified by someone else" | ||
454 | // error later when saving the file again. | ||
455 | ✗ | buffer_stat(&buffer->file, filename); | |
456 | } | ||
457 | return false; | ||
458 | } | ||
459 |