getmsglist(): improve [0879986] a bit
[s-mailx.git] / fio.c
blobbead237264e9781b6f6f16ad04a4c6c48cc84f93
1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
2 *@ File operations.
4 * Copyright (c) 2000-2004 Gunnar Ritter, Freiburg i. Br., Germany.
5 * Copyright (c) 2012 - 2016 Steffen (Daode) Nurpmeso <steffen@sdaoden.eu>.
6 */
7 /*
8 * Copyright (c) 1980, 1993
9 * The Regents of the University of California. All rights reserved.
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 * 3. Neither the name of the University nor the names of its contributors
20 * may be used to endorse or promote products derived from this software
21 * without specific prior written permission.
23 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * SUCH DAMAGE.
35 #undef n_FILE
36 #define n_FILE fio
38 #ifndef HAVE_AMALGAMATION
39 # include "nail.h"
40 #endif
42 /* line is a buffer with the result of fgets(). Returns the first newline or
43 * the last character read */
44 static size_t _length_of_line(char const *line, size_t linesize);
46 /* Read a line, one character at a time */
47 static char * _fgetline_byone(char **line, size_t *linesize, size_t *llen,
48 FILE *fp, int appendnl, size_t n SMALLOC_DEBUG_ARGS);
50 /* Workhorse */
51 static bool_t a_file_lock(int fd, enum n_file_lock_type ft, off_t off, off_t len);
53 static size_t
54 _length_of_line(char const *line, size_t linesize)
56 size_t i;
57 NYD2_ENTER;
59 /* Last character is always '\0' and was added by fgets() */
60 for (--linesize, i = 0; i < linesize; i++)
61 if (line[i] == '\n')
62 break;
63 i = (i < linesize) ? i + 1 : linesize;
64 NYD2_LEAVE;
65 return i;
68 static char *
69 _fgetline_byone(char **line, size_t *linesize, size_t *llen, FILE *fp,
70 int appendnl, size_t n SMALLOC_DEBUG_ARGS)
72 char *rv;
73 int c;
74 NYD2_ENTER;
76 assert(*linesize == 0 || *line != NULL);
77 pstate &= ~PS_READLINE_NL;
79 for (rv = *line;;) {
80 if (*linesize <= LINESIZE || n >= *linesize - 128) {
81 *linesize += ((rv == NULL) ? LINESIZE + n + 1 : 256);
82 *line = rv = (srealloc)(rv, *linesize SMALLOC_DEBUG_ARGSCALL);
84 c = getc(fp);
85 if (c != EOF) {
86 rv[n++] = c;
87 rv[n] = '\0';
88 if (c == '\n') {
89 pstate |= PS_READLINE_NL;
90 break;
92 } else {
93 if (n > 0) {
94 if (appendnl) {
95 rv[n++] = '\n';
96 rv[n] = '\0';
98 break;
99 } else {
100 rv = NULL;
101 goto jleave;
105 if (llen)
106 *llen = n;
107 jleave:
108 NYD2_LEAVE;
109 return rv;
112 static bool_t
113 a_file_lock(int fd, enum n_file_lock_type flt, off_t off, off_t len)
115 struct flock flp;
116 bool_t rv;
117 NYD2_ENTER;
119 memset(&flp, 0, sizeof flp);
121 switch (flt) {
122 default:
123 case FLT_READ: rv = F_RDLCK; break;
124 case FLT_WRITE: rv = F_WRLCK; break;
126 flp.l_type = rv;
127 flp.l_start = off;
128 flp.l_whence = SEEK_SET;
129 flp.l_len = len;
131 if (!(rv = (fcntl(fd, F_SETLK, &flp) != -1)))
132 switch (errno) {
133 case EBADF:
134 case EINVAL:
135 rv = TRUM1;
136 break;
138 NYD2_LEAVE;
139 return rv;
142 FL char *
143 (fgetline)(char **line, size_t *linesize, size_t *cnt, size_t *llen, FILE *fp,
144 int appendnl SMALLOC_DEBUG_ARGS)
146 size_t i_llen, sz;
147 char *rv;
148 NYD2_ENTER;
150 if (cnt == NULL) {
151 /* Without count, we can't determine where the chars returned by fgets()
152 * end if there's no newline. We have to read one character by one */
153 rv = _fgetline_byone(line, linesize, llen, fp, appendnl, 0
154 SMALLOC_DEBUG_ARGSCALL);
155 goto jleave;
158 pstate &= ~PS_READLINE_NL;
160 if ((rv = *line) == NULL || *linesize < LINESIZE)
161 *line = rv = (srealloc)(rv, *linesize = LINESIZE SMALLOC_DEBUG_ARGSCALL);
162 sz = (*linesize <= *cnt) ? *linesize : *cnt + 1;
163 if (sz <= 1 || fgets(rv, sz, fp) == NULL) {
164 /* Leave llen untouched; it is used to determine whether the last line
165 * was \n-terminated in some callers */
166 rv = NULL;
167 goto jleave;
170 i_llen = _length_of_line(rv, sz);
171 *cnt -= i_llen;
172 while (rv[i_llen - 1] != '\n') {
173 *line = rv = (srealloc)(rv, *linesize += 256 SMALLOC_DEBUG_ARGSCALL);
174 sz = *linesize - i_llen;
175 sz = (sz <= *cnt) ? sz : *cnt + 1;
176 if (sz <= 1 || fgets(rv + i_llen, sz, fp) == NULL) {
177 if (appendnl) {
178 rv[i_llen++] = '\n';
179 rv[i_llen] = '\0';
181 break;
183 sz = _length_of_line(rv + i_llen, sz);
184 i_llen += sz;
185 *cnt -= sz;
187 if (llen)
188 *llen = i_llen;
189 jleave:
190 NYD2_LEAVE;
191 return rv;
194 FL int
195 (readline_restart)(FILE *ibuf, char **linebuf, size_t *linesize, size_t n
196 SMALLOC_DEBUG_ARGS)
198 /* TODO readline_restart(): always *appends* LF just to strip it again;
199 * TODO should be configurable just as for fgetline(); ..or whatever..
200 * TODO intwrap */
201 int rv = -1;
202 long sz;
203 NYD2_ENTER;
205 clearerr(ibuf);
207 /* Interrupts will cause trouble if we are inside a stdio call. As this is
208 * only relevant if input is from tty, bypass it by read(), then */
209 if (fileno(ibuf) == 0 && (options & OPT_TTYIN)) {
210 assert(*linesize == 0 || *linebuf != NULL);
211 pstate &= ~PS_READLINE_NL;
212 for (;;) {
213 if (*linesize <= LINESIZE || n >= *linesize - 128) {
214 *linesize += ((*linebuf == NULL) ? LINESIZE + n + 1 : 256);
215 *linebuf = (srealloc)(*linebuf, *linesize SMALLOC_DEBUG_ARGSCALL);
217 jagain:
218 sz = read(0, *linebuf + n, *linesize - n - 1);
219 if (sz > 0) {
220 n += sz;
221 (*linebuf)[n] = '\0';
222 if ((*linebuf)[n - 1] == '\n') {
223 pstate |= PS_READLINE_NL;
224 break;
226 } else {
227 if (sz < 0 && errno == EINTR)
228 goto jagain;
229 /* TODO eh. what is this? that now supposed to be a line?!? */
230 if (n > 0) {
231 if ((*linebuf)[n - 1] != '\n') {
232 (*linebuf)[n++] = '\n';
233 (*linebuf)[n] = '\0';
234 } else
235 pstate |= PS_READLINE_NL;
236 break;
237 } else
238 goto jleave;
241 } else {
242 /* Not reading from standard input or standard input not a terminal. We
243 * read one char at a time as it is the only way to get lines with
244 * embedded NUL characters in standard stdio */
245 if (_fgetline_byone(linebuf, linesize, &n, ibuf, 1, n
246 SMALLOC_DEBUG_ARGSCALL) == NULL)
247 goto jleave;
249 if (n > 0 && (*linebuf)[n - 1] == '\n')
250 (*linebuf)[--n] = '\0';
251 rv = (int)n;
252 jleave:
253 NYD2_LEAVE;
254 return rv;
257 FL void
258 setptr(FILE *ibuf, off_t offset)
260 struct message self;
261 char *cp, *linebuf = NULL;
262 char const *cp2;
263 int c, selfcnt = 0;
264 bool_t maybe, inhead, rfc4155;
265 size_t linesize = 0, filesize, cnt;
266 NYD_ENTER;
268 memset(&self, 0, sizeof self);
269 self.m_flag = MUSED | MNEW | MNEWEST;
270 filesize = mailsize - offset;
271 offset = ftell(mb.mb_otf);
272 maybe = TRU1;
273 rfc4155 = inhead = FAL0;
275 for (;;) {
276 if (fgetline(&linebuf, &linesize, &filesize, &cnt, ibuf, 0) == NULL) {
277 self.m_xsize = self.m_size;
278 self.m_xlines = self.m_lines;
279 self.m_have = HAVE_HEADER | HAVE_BODY;
280 if (selfcnt > 0)
281 message_append(&self);
282 message_append_null();
283 if (linebuf != NULL)
284 free(linebuf);
285 break;
288 #ifdef notdef
289 if (linebuf[0] == '\0')
290 linebuf[0] = '.';
291 #endif
292 /* XXX Convert CRLF to LF; this should be rethought in that
293 * XXX CRLF input should possibly end as CRLF output? */
294 if (cnt >= 2 && linebuf[cnt - 1] == '\n' && linebuf[cnt - 2] == '\r')
295 linebuf[--cnt - 1] = '\n';
296 fwrite(linebuf, sizeof *linebuf, cnt, mb.mb_otf);
297 if (ferror(mb.mb_otf)) {
298 n_perr(_("/tmp"), 0);
299 exit(EXIT_ERR);
301 if (linebuf[cnt - 1] == '\n')
302 linebuf[cnt - 1] = '\0';
303 if (maybe && linebuf[0] == 'F' &&
304 (rfc4155 = is_head(linebuf, cnt, TRU1))) {
305 /* TODO char date[FROM_DATEBUF];
306 * TODO extract_date_from_from_(linebuf, cnt, date);
307 * TODO self.m_time = 10000; */
308 if (rfc4155 == TRUM1) {
309 if (options & OPT_D_V)
310 n_err(_("Invalid MBOX \"From_ line\": %.*s\n"),
311 (int)cnt, linebuf);
312 else if (!(mb.mb_active & MB_FROM__WARNED))
313 n_err(_("MBOX mailbox contains non-conforming From_ line(s)\n"));
314 mb.mb_active |= MB_FROM__WARNED;
316 self.m_xsize = self.m_size;
317 self.m_xlines = self.m_lines;
318 self.m_have = HAVE_HEADER | HAVE_BODY;
319 if (selfcnt++ > 0)
320 message_append(&self);
321 msgCount++;
322 self.m_flag = MUSED | MNEW | MNEWEST;
323 self.m_size = 0;
324 self.m_lines = 0;
325 self.m_block = mailx_blockof(offset);
326 self.m_offset = mailx_offsetof(offset);
327 inhead = TRU1;
328 } else if (linebuf[0] == 0) {
329 inhead = FAL0;
330 } else if (inhead) {
331 for (cp = linebuf, cp2 = "status";; ++cp) {
332 if ((c = *cp2++) == 0) {
333 while (c = *cp++, whitechar(c))
335 if (cp[-1] != ':')
336 break;
337 while ((c = *cp++) != '\0')
338 if (c == 'R')
339 self.m_flag |= MREAD;
340 else if (c == 'O')
341 self.m_flag &= ~MNEW;
342 break;
344 if (*cp != c && *cp != upperconv(c))
345 break;
347 for (cp = linebuf, cp2 = "x-status";; ++cp) {
348 if ((c = *cp2++) == 0) {
349 while ((c = *cp++, whitechar(c)))
351 if (cp[-1] != ':')
352 break;
353 while ((c = *cp++) != '\0')
354 if (c == 'F')
355 self.m_flag |= MFLAGGED;
356 else if (c == 'A')
357 self.m_flag |= MANSWERED;
358 else if (c == 'T')
359 self.m_flag |= MDRAFTED;
360 break;
362 if (*cp != c && *cp != upperconv(c))
363 break;
366 offset += cnt;
367 self.m_size += cnt;
368 ++self.m_lines;
369 maybe = (linebuf[0] == 0);
371 NYD_LEAVE;
374 FL off_t
375 fsize(FILE *iob)
377 struct stat sbuf;
378 off_t rv;
379 NYD_ENTER;
381 rv = (fstat(fileno(iob), &sbuf) == -1) ? 0 : sbuf.st_size;
382 NYD_LEAVE;
383 return rv;
386 FL bool_t
387 n_file_lock(int fd, enum n_file_lock_type flt, off_t off, off_t len,
388 size_t pollmsecs)
390 size_t tries;
391 bool_t didmsg, rv;
392 NYD_ENTER;
394 if(pollmsecs == UIZ_MAX)
395 pollmsecs = FILE_LOCK_MILLIS;
397 UNINIT(rv, 0);
398 for (didmsg = FAL0, tries = 0; tries <= FILE_LOCK_TRIES; ++tries) {
399 rv = a_file_lock(fd, flt, off, len);
401 if (rv == TRUM1) {
402 rv = FAL0;
403 break;
405 if (rv || pollmsecs == 0)
406 break;
407 else {
408 if(!didmsg){
409 n_err(_("Failed to create a file lock, waiting %lu milliseconds "),
410 pollmsecs);
411 didmsg = TRU1;
412 }else
413 n_err(".");
414 n_msleep(pollmsecs, FAL0);
417 if(didmsg)
418 n_err(" %s\n", (rv ? _("ok") : _("failure")));
419 NYD_LEAVE;
420 return rv;
423 /* s-it-mode */