1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
2 *@ File I/O, including resource file loading etc.
4 * Copyright (c) 2000-2004 Gunnar Ritter, Freiburg i. Br., Germany.
5 * Copyright (c) 2012 - 2015 Steffen (Daode) Nurpmeso <sdaoden@users.sf.net>.
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
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
38 #ifndef HAVE_AMALGAMATION
45 # include <sys/socket.h>
49 # include <netinet/in.h>
51 # ifdef HAVE_ARPA_INET_H
52 # include <arpa/inet.h>
61 # include <openssl/err.h>
62 # include <openssl/rand.h>
63 # include <openssl/ssl.h>
64 # include <openssl/x509v3.h>
65 # include <openssl/x509.h>
73 FILE *s_file
; /* File we were in. */
74 void *s_cond
; /* Saved state of conditional stack */
75 int s_loading
; /* Loading .mailrc, etc. */
79 struct shvar_stack
*shs_next
;
80 char const *shs_value
; /* Remaining value to expand */
81 size_t shs_len
; /* gth of .shs_dat this level */
82 char const *shs_dat
; /* Result data of this level */
85 /* Slots in ::message */
86 static size_t _message_space
;
88 /* XXX Our Popen() main() takes void, temporary global data store */
90 static enum file_lock_type _dotlock_flt
;
91 static int _dotlock_fd
;
92 struct dotlock_info
* _dotlock_dip
;
96 static struct fio_stack _fio_stack
[FIO_STACK_SIZE
];
97 static size_t _fio_stack_size
;
98 static FILE * _fio_input
;
100 /* Locate the user's mailbox file (where new, unread mail is queued) */
101 static void _findmail(char *buf
, size_t bufsize
, char const *user
,
104 /* Perform shell variable expansion */
105 static char * _shvar_exp(char const *name
);
106 static char * __shvar_exp(struct shvar_stack
*shsp
);
108 /* Perform shell meta character expansion TODO obsolete (INSECURE!) */
109 static char * _globname(char const *name
, enum fexp_mode fexpm
);
111 /* line is a buffer with the result of fgets(). Returns the first newline or
112 * the last character read */
113 static size_t _length_of_line(char const *line
, size_t linesize
);
115 /* Read a line, one character at a time */
116 static char * _fgetline_byone(char **line
, size_t *linesize
, size_t *llen
,
117 FILE *fp
, int appendnl
, size_t n SMALLOC_DEBUG_ARGS
);
119 /* Take the data out of the passed ghost file and toss it into a dynamically
120 * allocated message structure */
121 static void makemessage(void);
123 static enum okay
get_header(struct message
*mp
);
126 static bool_t
_file_lock(int fd
, enum file_lock_type ft
,
127 off_t off
, off_t len
);
129 /* main() of fork(2)ed dot file locker */
131 static int _dotlock_main(void);
134 /* Write to socket fd, restarting on EINTR, unless anything is written */
136 static long xwrite(int fd
, char const *data
, size_t sz
);
139 /* `source' and `source_if' */
140 static bool_t
_source_file(char const *file
, bool_t silent_error
);
143 _findmail(char *buf
, size_t bufsize
, char const *user
, bool_t force
)
148 if (!strcmp(user
, myname
) && !force
&& (cp
= ok_vlook(folder
)) != NULL
) {
149 switch (which_protocol(cp
)) {
151 if (strcmp(cp
, protbase(cp
)))
153 snprintf(buf
, bufsize
, "%s/INBOX", cp
);
160 if (force
|| (cp
= ok_vlook(MAIL
)) == NULL
)
161 snprintf(buf
, bufsize
, "%s/%s", MAILSPOOL
, user
);
164 n_strlcpy(buf
, cp
, bufsize
);
170 _shvar_exp(char const *name
)
172 struct shvar_stack top
;
176 memset(&top
, 0, sizeof top
);
177 top
.shs_value
= name
;
178 rv
= __shvar_exp(&top
);
185 __shvar_exp(struct shvar_stack
*shsp
)
187 struct shvar_stack next
, *np
, *tmp
;
189 char lc
, c
, *cp
, *rv
;
193 if (*(vp
= shsp
->shs_value
) != '$') {
194 union {bool_t hadbs
; char c
;} u
= {FAL0
};
197 for (lc
= '\0', i
= 0; ((c
= *vp
) != '\0'); ++i
, ++vp
) {
198 if (c
== '$' && lc
!= '\\')
200 lc
= (lc
== '\\') ? (u
.hadbs
= TRU1
, '\0') : c
;
205 shsp
->shs_dat
= cp
= savestrbuf(shsp
->shs_dat
, i
);
207 for (lc
= '\0', rv
= cp
; (u
.c
= *cp
++) != '\0';) {
208 if (u
.c
!= '\\' || lc
== '\\')
210 lc
= (lc
== '\\') ? '\0' : u
.c
;
214 shsp
->shs_len
= PTR2SIZE(rv
- shsp
->shs_dat
);
217 if ((lc
= (*++vp
== '{')))
221 for (i
= 0; (c
= *vp
) != '\0'; ++i
, ++vp
)
222 if (!alnumchar(c
) && c
!= '_')
227 n_err(_("Variable name misses closing \"}\": \"%s\"\n"),
229 shsp
->shs_len
= strlen(shsp
->shs_value
);
230 shsp
->shs_dat
= shsp
->shs_value
;
237 if ((cp
= vok_vlook(savestrbuf(shsp
->shs_dat
, i
))) != NULL
)
238 shsp
->shs_len
= strlen(shsp
->shs_dat
= cp
);
243 /* That level made the great and completed encoding. Build result */
245 for (i
= 0, np
= shsp
, shsp
= NULL
; np
!= NULL
;) {
253 cp
= rv
= salloc(i
+1);
254 while (shsp
!= NULL
) {
256 shsp
= shsp
->shs_next
;
257 memcpy(cp
, np
->shs_dat
, np
->shs_len
);
266 memset(&next
, 0, sizeof next
);
267 next
.shs_next
= shsp
;
269 rv
= __shvar_exp(&next
);
274 _globname(char const *name
, enum fexp_mode fexpm
)
283 /* Mac OS X Snow Leopard and Linux don't init fields on error, causing
284 * SIGSEGV in wordfree(3); so let's just always zero it ourselfs */
285 memset(&we
, 0, sizeof we
);
287 /* Some systems (notably Open UNIX 8.0.0) fork a shell for wordexp()
288 * and wait, which will fail if our SIGCHLD handler is active */
290 sigaddset(&nset
, SIGCHLD
);
291 sigprocmask(SIG_BLOCK
, &nset
, NULL
);
293 # define WRDE_NOCMD 0
295 i
= wordexp(name
, &we
, WRDE_NOCMD
);
296 sigprocmask(SIG_UNBLOCK
, &nset
, NULL
);
303 if (!(fexpm
& FEXP_SILENT
))
304 n_err(_("\"%s\": Command substitution not allowed\n"), name
);
308 if (!(fexpm
& FEXP_SILENT
))
309 n_err(_("\"%s\": Expansion buffer overflow\n"), name
);
314 if (!(fexpm
& FEXP_SILENT
))
315 n_err(_("Syntax error in \"%s\"\n"), name
);
319 switch (we
.we_wordc
) {
321 cp
= savestr(we
.we_wordv
[0]);
324 if (!(fexpm
& FEXP_SILENT
))
325 n_err(_("\"%s\": No match\n"), name
);
328 if (fexpm
& FEXP_MULTIOK
) {
331 for (l
= 0, j
= 0; j
< we
.we_wordc
; ++j
)
332 l
+= strlen(we
.we_wordv
[j
]) + 1;
335 for (l
= 0, j
= 0; j
< we
.we_wordc
; ++j
) {
336 size_t x
= strlen(we
.we_wordv
[j
]);
337 memcpy(cp
+ l
, we
.we_wordv
[j
], x
);
342 } else if (!(fexpm
& FEXP_SILENT
))
343 n_err(_("\"%s\": Ambiguous\n"), name
);
351 #else /* HAVE_WORDEXP */
353 char xname
[PATH_MAX
], cmdbuf
[PATH_MAX
], /* also used for files */
355 int pivec
[2], pid
, l
, waits
;
358 if (pipe(pivec
) < 0) {
359 n_perr(_("pipe"), 0);
362 snprintf(cmdbuf
, sizeof cmdbuf
, "echo %s", name
);
363 if ((shellp
= ok_vlook(SHELL
)) == NULL
)
364 shellp
= UNCONST(XSHELL
);
365 pid
= start_command(shellp
, NULL
, -1, pivec
[1], "-c", cmdbuf
, NULL
, NULL
);
374 l
= read(pivec
[0], xname
, sizeof xname
);
378 n_perr(_("read"), 0);
383 if (!wait_child(pid
, &waits
) && WTERMSIG(waits
) != SIGPIPE
) {
384 if (!(fexpm
& FEXP_SILENT
))
385 n_err(_("\"%s\": Expansion failed\n"), name
);
389 if (!(fexpm
& FEXP_SILENT
))
390 n_err(_("\"%s\": No match\n"), name
);
393 if (l
== sizeof xname
) {
394 if (!(fexpm
& FEXP_SILENT
))
395 n_err(_("\"%s\": Expansion buffer overflow\n"), name
);
399 for (cp
= xname
+ l
- 1; *cp
== '\n' && cp
> xname
; --cp
)
402 if (!(fexpm
& FEXP_MULTIOK
) && strchr(xname
, ' ') != NULL
&&
403 stat(xname
, &sbuf
) < 0) {
404 if (!(fexpm
& FEXP_SILENT
))
405 n_err(_("\"%s\": Ambiguous\n"), name
);
413 #endif /* !HAVE_WORDEXP */
417 _length_of_line(char const *line
, size_t linesize
)
422 /* Last character is always '\0' and was added by fgets() */
423 for (--linesize
, i
= 0; i
< linesize
; i
++)
426 i
= (i
< linesize
) ? i
+ 1 : linesize
;
432 _fgetline_byone(char **line
, size_t *linesize
, size_t *llen
, FILE *fp
,
433 int appendnl
, size_t n SMALLOC_DEBUG_ARGS
)
439 assert(*linesize
== 0 || *line
!= NULL
);
441 if (*linesize
<= LINESIZE
|| n
>= *linesize
- 128) {
442 *linesize
+= ((rv
== NULL
) ? LINESIZE
+ n
+ 1 : 256);
443 *line
= rv
= (srealloc
)(rv
, *linesize SMALLOC_DEBUG_ARGSCALL
);
476 message_append(NULL
);
478 message
[msgCount
].m_size
= 0;
479 message
[msgCount
].m_lines
= 0;
484 get_header(struct message
*mp
)
490 switch (mb
.mb_type
) {
497 rv
= pop3_header(mp
);
503 rv
= imap_header(mp
);
516 _file_lock(int fd
, enum file_lock_type flt
, off_t off
, off_t len
)
522 memset(&flp
, 0, sizeof flp
);
526 case FLT_READ
: rv
= F_RDLCK
; break;
527 case FLT_WRITE
: rv
= F_WRLCK
; break;
531 flp
.l_whence
= SEEK_SET
;
534 rv
= (fcntl(fd
, F_SETLK
, &flp
) != -1);
543 struct dotlock_info di
;
544 struct stat stb
, fdstb
;
546 enum dotlock_state dls
;
549 enum file_lock_type flt
;
552 /* Ignore SIGPIPE, we'll see EPIPE and "fall through" */
553 safe_signal(SIGPIPE
, SIG_IGN
);
555 /* Get the arguments "passed to us" */
563 dls
= DLS_CANT_CHDIR
| DLS_ABANDON
;
565 if ((cp
= strrchr(di
.di_file_name
, '/')) != NULL
) {
566 char const *fname
= cp
+ 1;
568 while (PTRCMP(cp
- 1, >, di
.di_file_name
) && cp
[-1] == '/')
570 cp
= savestrbuf(di
.di_file_name
, PTR2SIZE(cp
- di
.di_file_name
));
574 di
.di_file_name
= fname
;
577 /* So we're here, but then again the file can be a symbolic link!
578 * This is however only true if we do not have realpath(3) available since
579 * that'll have resolved the path already otherwise; nonetheless, let
580 * readlink(2) be a precondition for dotlocking and keep this code */
581 if (lstat(cp
= di
.di_file_name
, &stb
) == -1)
583 if (S_ISLNK(stb
.st_mode
)) {
584 /* Use salloc() and hope we stay in builtin buffer.. */
589 for (x
= NULL
, i
= PATH_MAX
;; i
+= PATH_MAX
) {
591 sr
= readlink(cp
, x
, i
);
593 dls
= DLS_FISHY
| DLS_ABANDON
;
596 if (UICMP(z
, sr
, <, i
)) {
606 dls
= DLS_FISHY
| DLS_ABANDON
;
608 /* Bail out if the file has changed its identity in the meanwhile */
609 if (fstat(fd
, &fdstb
) == -1 ||
610 fdstb
.st_dev
!= stb
.st_dev
|| fdstb
.st_ino
!= stb
.st_ino
||
611 fdstb
.st_uid
!= stb
.st_uid
|| fdstb
.st_gid
!= stb
.st_gid
||
612 fdstb
.st_mode
!= stb
.st_mode
)
615 /* Be aware, even if the error is false! */
617 int i
= snprintf(name
, sizeof name
, "%s.lock", di
.di_file_name
);
618 if (i
< 0 || UICMP(z
, NAME_MAX
, <=, (uiz_t
)i
+ 1 +1)) {
619 dls
= DLS_NAMETOOLONG
| DLS_ABANDON
;
622 # ifdef HAVE_PATHCONF
624 /* fd is a file, not portable to use for _PC_NAME_MAX */
627 if ((pc
= pathconf(".", _PC_NAME_MAX
)) == -1 || pc
<= (long)i
+ 1 +1) {
628 dls
= DLS_NAMETOOLONG
| DLS_ABANDON
;
633 di
.di_lock_name
= name
;
636 /* We are in the directory of the mailbox for which we have to create
637 * a dotlock file for. We don't know wether we have realpath(3) available,
638 * and manually resolving the path is due especially given that S-nail
639 * supports the special "%:" syntax to warp any file into a "system
640 * mailbox"; there may also be multiple system mailbox directories...
641 * So what we do is that we fstat(2) the mailbox and check its UID and
642 * GID against that of our own process: if any of those mismatch we must
643 * either assume a directory we are not allowed to write in, or that we run
644 * via -u/$USER/%USER as someone else, in which case we favour our
645 * privilege-separated dotlock process */
646 assert(cp
!= NULL
); /* Ugly: avoid a useless var and reuse that one */
647 if (access(".", W_OK
)) {
648 /* This may however also indicate a read-only filesystem, which is not
649 * really an error from our point of view since the mailbox will degrade
650 * to a readonly one for which no dotlock is needed, then, and errors
651 * may arise only due to actions which require box modifications */
652 if (errno
== EROFS
) {
653 dls
= DLS_ROFS
| DLS_ABANDON
;
658 if (cp
== NULL
|| stb
.st_uid
!= user_id
|| stb
.st_gid
!= group_id
) {
660 char const *args
[13];
662 snprintf(itoabuf
, sizeof itoabuf
, "%" PRIuZ
, di
.di_pollmsecs
);
664 args
[ 1] = (flt
== FLT_READ
? "rdotlock" : "wdotlock");
665 args
[ 2] = "mailbox"; args
[ 3] = di
.di_file_name
;
666 args
[ 4] = "name"; args
[ 5] = di
.di_lock_name
;
667 args
[ 6] = "hostname"; args
[ 7] = di
.di_hostname
;
668 args
[ 8] = "randstr"; args
[ 9] = di
.di_randstr
;
669 args
[10] = "pollmsecs"; args
[11] = itoabuf
;
671 execv(LIBEXECDIR
"/" UAGENT
"-privsep", UNCONST(args
));
674 write(STDOUT_FILENO
, &dls
, sizeof dls
);
675 /* But fall through and try it with normal privileges! */
678 /* So let's try and call it ourselfs! Note that we don't block signals just
679 * like our privsep child does, the user will anyway be able to remove his
680 * file again, and if we're in -u/$USER mode then we are allowed to access
681 * the user's box: shall we leave behind a stale dotlock then at least we
682 * start a friendly human conversation. Since we cannot handle SIGKILL and
683 * SIGSTOP malicious things could happen whatever we do */
684 safe_signal(SIGHUP
, SIG_IGN
);
685 safe_signal(SIGINT
, SIG_IGN
);
686 safe_signal(SIGQUIT
, SIG_IGN
);
687 safe_signal(SIGTERM
, SIG_IGN
);
690 dls
= _dotlock_create(&di
);
693 /* Finally: notify our parent about the actual lock state.. */
695 write(STDOUT_FILENO
, &dls
, sizeof dls
);
696 close(STDOUT_FILENO
);
698 /* ..then eventually wait until we shall remove the lock again, which will
699 * be notified via the read returning */
700 if (dls
== DLS_NONE
) {
701 read(STDIN_FILENO
, &dls
, sizeof dls
);
708 #endif /* HAVE_DOTLOCK */
712 xwrite(int fd
, char const *data
, size_t sz
)
719 if ((wo
= write(fd
, data
+ wt
, sz
- wt
)) < 0) {
732 #endif /* HAVE_SOCKETS */
735 _source_file(char const *file
, bool_t silent_error
)
741 if ((cp
= fexpand(file
, FEXP_LOCAL
)) == NULL
)
743 if ((fi
= Fopen(cp
, "r")) == NULL
) {
744 if (!silent_error
|| (options
& OPT_D_V
))
749 if (temporary_localopts_store
!= NULL
) {
750 n_err(_("Before v15 you cannot `source' from within macros, sorry\n"));
753 if (_fio_stack_size
>= NELEM(_fio_stack
)) {
754 n_err(_("Too many `source' recursions\n"));
761 _fio_stack
[_fio_stack_size
].s_file
= _fio_input
;
762 _fio_stack
[_fio_stack_size
].s_cond
= condstack_release();
763 _fio_stack
[_fio_stack_size
].s_loading
= !!(pstate
& PS_LOADING
);
765 pstate
&= ~PS_LOADING
;
766 pstate
|= PS_SOURCING
;
774 (fgetline
)(char **line
, size_t *linesize
, size_t *cnt
, size_t *llen
, FILE *fp
,
775 int appendnl SMALLOC_DEBUG_ARGS
)
782 /* Without count, we can't determine where the chars returned by fgets()
783 * end if there's no newline. We have to read one character by one */
784 rv
= _fgetline_byone(line
, linesize
, llen
, fp
, appendnl
, 0
785 SMALLOC_DEBUG_ARGSCALL
);
789 if ((rv
= *line
) == NULL
|| *linesize
< LINESIZE
)
790 *line
= rv
= (srealloc
)(rv
, *linesize
= LINESIZE SMALLOC_DEBUG_ARGSCALL
);
791 sz
= (*linesize
<= *cnt
) ? *linesize
: *cnt
+ 1;
792 if (sz
<= 1 || fgets(rv
, sz
, fp
) == NULL
) {
793 /* Leave llen untouched; it is used to determine whether the last line
794 * was \n-terminated in some callers */
799 i_llen
= _length_of_line(rv
, sz
);
801 while (rv
[i_llen
- 1] != '\n') {
802 *line
= rv
= (srealloc
)(rv
, *linesize
+= 256 SMALLOC_DEBUG_ARGSCALL
);
803 sz
= *linesize
- i_llen
;
804 sz
= (sz
<= *cnt
) ? sz
: *cnt
+ 1;
805 if (sz
<= 1 || fgets(rv
+ i_llen
, sz
, fp
) == NULL
) {
812 sz
= _length_of_line(rv
+ i_llen
, sz
);
824 (readline_restart
)(FILE *ibuf
, char **linebuf
, size_t *linesize
, size_t n
827 /* TODO readline_restart(): always *appends* LF just to strip it again;
828 * TODO should be configurable just as for fgetline(); ..or whatever.. */
835 /* Interrupts will cause trouble if we are inside a stdio call. As this is
836 * only relevant if input is from tty, bypass it by read(), then */
837 if (fileno(ibuf
) == 0 && (options
& OPT_TTYIN
)) {
838 assert(*linesize
== 0 || *linebuf
!= NULL
);
840 if (*linesize
<= LINESIZE
|| n
>= *linesize
- 128) {
841 *linesize
+= ((*linebuf
== NULL
) ? LINESIZE
+ n
+ 1 : 256);
842 *linebuf
= (srealloc
)(*linebuf
, *linesize SMALLOC_DEBUG_ARGSCALL
);
845 sz
= read(0, *linebuf
+ n
, *linesize
- n
- 1);
848 (*linebuf
)[n
] = '\0';
849 if (n
> 0 && (*linebuf
)[n
- 1] == '\n')
852 if (sz
< 0 && errno
== EINTR
)
855 if ((*linebuf
)[n
- 1] != '\n') {
856 (*linebuf
)[n
++] = '\n';
857 (*linebuf
)[n
] = '\0';
865 /* Not reading from standard input or standard input not a terminal. We
866 * read one char at a time as it is the only way to get lines with
867 * embedded NUL characters in standard stdio */
868 if (_fgetline_byone(linebuf
, linesize
, &n
, ibuf
, 1, n
869 SMALLOC_DEBUG_ARGSCALL
) == NULL
)
872 if (n
> 0 && (*linebuf
)[n
- 1] == '\n')
873 (*linebuf
)[--n
] = '\0';
881 (readline_input
)(char const *prompt
, bool_t nl_escape
, char **linebuf
,
882 size_t *linesize
, char const *string SMALLOC_DEBUG_ARGS
)
884 /* TODO readline: linebuf pool! */
885 FILE *ifile
= (_fio_input
!= NULL
) ? _fio_input
: stdin
;
886 bool_t doprompt
, dotty
;
890 doprompt
= (!(pstate
& PS_SOURCING
) && (options
& OPT_INTERACTIVE
));
891 dotty
= (doprompt
&& !ok_blook(line_editor_disable
));
894 else if (prompt
== NULL
)
895 prompt
= getprompt();
897 /* Ensure stdout is flushed first anyway */
898 if (!dotty
&& prompt
== NULL
)
901 for (nold
= n
= 0;;) {
903 assert(ifile
== stdin
);
904 if (string
!= NULL
&& (n
= (int)strlen(string
)) > 0) {
908 *linesize
= (size_t)n
+ LINESIZE
+1;
909 *linebuf
= (srealloc
)(*linebuf
, *linesize SMALLOC_DEBUG_ARGSCALL
);
910 memcpy(*linebuf
, string
, (size_t)n
+1);
913 /* TODO if nold>0, don't redisplay the entire line!
914 * TODO needs complete redesign ... */
915 n
= (tty_readline
)(prompt
, linebuf
, linesize
, n
916 SMALLOC_DEBUG_ARGSCALL
);
918 if (prompt
!= NULL
) {
920 fputs(prompt
, stdout
);
923 n
= (readline_restart
)(ifile
, linebuf
, linesize
, n
924 SMALLOC_DEBUG_ARGSCALL
);
926 if (n
> 0 && nold
> 0) {
928 char const *cp
= *linebuf
+ nold
;
930 while (blankspacechar(*cp
) && nold
+ i
< n
)
933 memmove(*linebuf
+ nold
, cp
, n
- nold
- i
);
935 (*linebuf
)[n
] = '\0';
943 * An unquoted <backslash> at the end of a command line shall
944 * be discarded and the next line shall continue the command */
945 if (!nl_escape
|| n
== 0 || (*linebuf
)[n
- 1] != '\\')
947 (*linebuf
)[nold
= --n
] = '\0';
948 if (prompt
!= NULL
&& *prompt
!= '\0')
949 prompt
= ".. "; /* XXX PS2 .. */
952 if (n
>= 0 && (options
& OPT_D_VV
))
953 n_err(_("%s %d bytes <%.*s>\n"),
954 ((pstate
& PS_LOADING
) ? "LOAD"
955 : (pstate
& PS_SOURCING
) ? "SOURCE" : "READ"),
962 n_input_cp_addhist(char const *prompt
, char const *string
, bool_t isgabby
)
964 /* FIXME n_input_cp_addhist(): leaks on sigjmp without linepool */
966 char *linebuf
= NULL
, *rv
= NULL
;
970 n
= readline_input(prompt
, FAL0
, &linebuf
, &linesize
, string
);
971 if (n
> 0 && *(rv
= savestrbuf(linebuf
, (size_t)n
+ 1)) != '\0' &&
972 (options
& OPT_INTERACTIVE
))
973 tty_addhist(rv
, isgabby
);
982 setptr(FILE *ibuf
, off_t offset
)
985 char *cp
, *linebuf
= NULL
;
987 int c
, maybe
= 1, inhead
= 0, selfcnt
= 0;
988 size_t linesize
= 0, filesize
, cnt
;
991 memset(&self
, 0, sizeof self
);
992 self
.m_flag
= MUSED
| MNEW
| MNEWEST
;
993 filesize
= mailsize
- offset
;
994 offset
= ftell(mb
.mb_otf
);
997 if (fgetline(&linebuf
, &linesize
, &filesize
, &cnt
, ibuf
, 0) == NULL
) {
998 self
.m_xsize
= self
.m_size
;
999 self
.m_xlines
= self
.m_lines
;
1000 self
.m_have
= HAVE_HEADER
| HAVE_BODY
;
1002 message_append(&self
);
1010 if (linebuf
[0] == '\0')
1013 /* XXX Convert CRLF to LF; this should be rethought in that
1014 * XXX CRLF input should possibly end as CRLF output? */
1015 if (cnt
>= 2 && linebuf
[cnt
- 1] == '\n' && linebuf
[cnt
- 2] == '\r')
1016 linebuf
[--cnt
- 1] = '\n';
1017 fwrite(linebuf
, sizeof *linebuf
, cnt
, mb
.mb_otf
);
1018 if (ferror(mb
.mb_otf
)) {
1019 n_perr(_("/tmp"), 0);
1022 if (linebuf
[cnt
- 1] == '\n')
1023 linebuf
[cnt
- 1] = '\0';
1024 if (maybe
&& linebuf
[0] == 'F' && is_head(linebuf
, cnt
, FAL0
)) {
1025 /* TODO char date[FROM_DATEBUF];
1026 * TODO extract_date_from_from_(linebuf, cnt, date);
1027 * TODO self.m_time = 10000; */
1028 self
.m_xsize
= self
.m_size
;
1029 self
.m_xlines
= self
.m_lines
;
1030 self
.m_have
= HAVE_HEADER
| HAVE_BODY
;
1032 message_append(&self
);
1034 self
.m_flag
= MUSED
| MNEW
| MNEWEST
;
1037 self
.m_block
= mailx_blockof(offset
);
1038 self
.m_offset
= mailx_offsetof(offset
);
1040 } else if (linebuf
[0] == 0) {
1042 } else if (inhead
) {
1043 for (cp
= linebuf
, cp2
= "status";; ++cp
) {
1044 if ((c
= *cp2
++) == 0) {
1045 while (c
= *cp
++, whitechar(c
))
1049 while ((c
= *cp
++) != '\0')
1051 self
.m_flag
|= MREAD
;
1053 self
.m_flag
&= ~MNEW
;
1056 if (*cp
!= c
&& *cp
!= upperconv(c
))
1059 for (cp
= linebuf
, cp2
= "x-status";; ++cp
) {
1060 if ((c
= *cp2
++) == 0) {
1061 while ((c
= *cp
++, whitechar(c
)))
1065 while ((c
= *cp
++) != '\0')
1067 self
.m_flag
|= MFLAGGED
;
1069 self
.m_flag
|= MANSWERED
;
1071 self
.m_flag
|= MDRAFTED
;
1074 if (*cp
!= c
&& *cp
!= upperconv(c
))
1081 maybe
= linebuf
[0] == 0;
1087 putline(FILE *obuf
, char *linebuf
, size_t cnt
)
1092 fwrite(linebuf
, sizeof *linebuf
, cnt
, obuf
);
1095 rv
= (int)(cnt
+ 1);
1101 setinput(struct mailbox
*mp
, struct message
*m
, enum needspec need
)
1104 enum okay ok
= STOP
;
1109 ok
= (m
->m_have
& HAVE_HEADER
) ? OKAY
: get_header(m
);
1112 ok
= (m
->m_have
& HAVE_BODY
) ? OKAY
: get_body(m
);
1122 if (fseek(mp
->mb_itf
, (long)mailx_positionof(m
->m_block
, m
->m_offset
),
1124 n_perr(_("fseek"), 0);
1125 n_panic(_("temporary file seek"));
1137 if (message
!= NULL
) {
1147 message_append(struct message
*mp
)
1150 if (UICMP(z
, msgCount
+ 1, >=, _message_space
)) {
1151 /* XXX remove _message_space magics (or use s_Vector) */
1152 _message_space
= (_message_space
>= 128 && _message_space
<= 1000000)
1153 ? _message_space
<< 1 : _message_space
+ 64;
1154 message
= srealloc(message
, _message_space
* sizeof *message
);
1158 message
[msgCount
- 1] = *mp
;
1160 memset(message
+ msgCount
- 1, 0, sizeof *message
);
1166 message_match(struct message
*mp
, struct search_expr
const *sep
,
1167 bool_t with_headers
)
1170 size_t *linesize
, cnt
;
1175 if ((fp
= Ftmp(NULL
, "mpmatch", OF_RDWR
| OF_UNLINK
| OF_REGISTER
, 0600)) ==
1179 if (sendmp(mp
, fp
, NULL
, NULL
, SEND_TOSRCH
, NULL
) < 0)
1184 line
= &termios_state
.ts_linebuf
; /* XXX line pool */
1185 linesize
= &termios_state
.ts_linesize
; /* XXX line pool */
1188 while (fgetline(line
, linesize
, &cnt
, NULL
, fp
, 0))
1192 while (fgetline(line
, linesize
, &cnt
, NULL
, fp
, 0)) {
1194 if (sep
->ss_sexpr
== NULL
) {
1195 if (regexec(&sep
->ss_regex
, *line
, 0,NULL
, 0) == REG_NOMATCH
)
1199 if (!substr(*line
, sep
->ss_sexpr
))
1213 setdot(struct message
*mp
)
1218 pstate
&= ~PS_DID_PRINT_DOT
;
1221 uncollapse1(dot
, 0);
1227 rm(char const *name
)
1233 if (stat(name
, &sb
) < 0)
1235 else if (!S_ISREG(sb
.st_mode
))
1250 rv
= (fstat(fileno(iob
), &sbuf
) < 0) ? 0 : sbuf
.st_size
;
1256 fexpand(char const *name
, enum fexp_mode fexpm
)
1258 char cbuf
[PATH_MAX
];
1264 /* The order of evaluation is "%" and "#" expand into constants.
1265 * "&" can expand into "+". "+" can expand into shell meta characters.
1266 * Shell meta characters expand into constants.
1267 * This way, we make no recursive expansion */
1268 if ((fexpm
& FEXP_NSHORTCUT
) || (res
= shortcut_expand(name
)) == NULL
)
1269 res
= UNCONST(name
);
1271 if (fexpm
& FEXP_SHELL
) {
1279 if (res
[1] == ':' && res
[2] != '\0') {
1283 _findmail(cbuf
, sizeof cbuf
, (res
[1] != '\0' ? res
+ 1 : myname
),
1284 (res
[1] != '\0' || (options
& OPT_u_FLAG
)));
1290 if (prevfile
[0] == '\0') {
1291 n_err(_("No previous file\n"));
1298 if (res
[1] == '\0') {
1299 if ((res
= ok_vlook(MBOX
)) == NULL
)
1300 res
= UNCONST("~/mbox"); /* XXX no magics (POSIX though) */
1301 else if (res
[0] != '&' || res
[1] != '\0')
1307 if (res
[0] == '@' && which_protocol(mailname
) == PROTO_IMAP
) {
1308 res
= str_concat_csvl(&s
, protbase(mailname
), "/", res
+ 1, NULL
)->s
;
1312 if (res
[0] == '+' && getfold(cbuf
, sizeof cbuf
)) {
1313 size_t i
= strlen(cbuf
);
1315 res
= str_concat_csvl(&s
, cbuf
,
1316 ((i
> 0 && cbuf
[i
- 1] == '/') ? "" : "/"), res
+ 1, NULL
)->s
;
1319 if (res
[0] == '%' && res
[1] == ':') {
1325 /* Catch the most common shell meta character */
1327 if (res
[0] == '~' && (res
[1] == '/' || res
[1] == '\0')) {
1328 res
= str_concat_csvl(&s
, homedir
, res
+ 1, NULL
)->s
;
1331 if (anyof(res
, "|&;<>{}()[]*?$`'\"\\"))
1332 switch (which_protocol(res
)) {
1335 res
= (fexpm
& FEXP_NSHELL
) ? _shvar_exp(res
) : _globname(res
, fexpm
);
1342 if (fexpm
& FEXP_LOCAL
)
1343 switch (which_protocol(res
)) {
1348 n_err(_("Not a local file or directory: \"%s\"\n"), name
);
1356 return UNCONST(res
);
1360 fexpand_nshell_quote(char const *name
)
1366 for (i
= j
= 0; (c
= name
[i
]) != '\0'; ++i
)
1371 rv
= savestrbuf(name
, i
);
1373 rv
= salloc(i
+ j
+1);
1374 for (i
= j
= 0; (c
= name
[i
]) != '\0'; ++i
) {
1386 var_folder_updated(char const *name
, char **store
)
1389 char *folder
, *unres
= NULL
, *res
= NULL
;
1392 if ((folder
= UNCONST(name
)) == NULL
)
1395 /* Expand the *folder*; skip %: prefix for simplicity of use */
1396 /* XXX This *only* works because we do NOT
1397 * XXX update environment variables via the "set" mechanism */
1398 if (folder
[0] == '%' && folder
[1] == ':')
1400 if ((folder
= fexpand(folder
, FEXP_FULL
)) == NULL
) /* XXX error? */
1403 switch (which_protocol(folder
)) {
1405 n_err(_("*folder* cannot be set to a flat, readonly POP3 account\n"));
1409 /* Simply assign what we have, even including `%:' prefix */
1414 /* Further expansion desired */
1418 /* All non-absolute paths are relative to our home directory */
1419 if (*folder
!= '/') {
1420 size_t l1
= strlen(homedir
), l2
= strlen(folder
);
1421 unres
= ac_alloc(l1
+ l2
+ 1 +1);
1422 memcpy(unres
, homedir
, l1
);
1424 memcpy(unres
+ l1
+ 1, folder
, l2
);
1425 unres
[l1
+ 1 + l2
] = '\0';
1429 /* Since lex.c:_update_mailname() uses realpath(3) if available to
1430 * avoid that we loose track of our currently open folder in case we
1431 * chdir away, but still checks the leading path portion against
1432 * getfold() to be able to abbreviate to the +FOLDER syntax if
1433 * possible, we need to realpath(3) the folder, too */
1434 #ifdef HAVE_REALPATH
1435 res
= ac_alloc(PATH_MAX
+1);
1436 if (realpath(folder
, res
) == NULL
)
1437 n_err(_("Can't canonicalize \"%s\"\n"), folder
);
1443 *store
= sstrdup(folder
);
1455 getfold(char *name
, size_t size
)
1460 if ((folder
= ok_vlook(folder
)) != NULL
)
1461 n_strlcpy(name
, folder
, size
);
1463 return (folder
!= NULL
);
1467 getdeadletter(void) /* XXX should that be in auxlily.c? */
1472 if ((cp
= ok_vlook(DEAD
)) == NULL
|| (cp
= fexpand(cp
, FEXP_LOCAL
)) == NULL
)
1473 cp
= fexpand("~/dead.letter", FEXP_LOCAL
| FEXP_SHELL
);
1474 else if (*cp
!= '/') {
1475 size_t sz
= strlen(cp
) + 2 +1;
1476 char *buf
= ac_alloc(sz
);
1478 snprintf(buf
, sz
, "~/%s", cp
);
1479 cp
= fexpand(buf
, FEXP_LOCAL
| FEXP_SHELL
);
1484 cp
= "dead.letter"; /* XXX magic -> nail.h (POSIX thing though) */
1490 get_body(struct message
*mp
)
1496 switch (mb
.mb_type
) {
1522 file_lock(int fd
, enum file_lock_type flt
, off_t off
, off_t len
,
1529 for (tries
= 0; tries
<= FILE_LOCK_TRIES
; ++tries
)
1530 if ((rv
= _file_lock(fd
, flt
, off
, len
)) || pollmsecs
== 0)
1533 sleep(1); /* TODO pollmsecs -> use finer grain */
1539 dot_lock(char const *fname
, int fd
, enum file_lock_type flt
,
1540 off_t off
, off_t len
, size_t pollmsecs
)
1544 # define _DOMSG() n_err(_("Creating dotlock for \"%s\" "), fname)
1546 # define _DOMSG() n_err(_("Trying to lock file \"%s\" "), fname)
1551 struct dotlock_info di
;
1552 enum dotlock_state dls
;
1553 char const *emsg
= NULL
;
1555 int UNINIT(serrno
, 0);
1556 union {size_t tries
; int (*ptf
)(void); char const *sh
; ssize_t r
;} u
;
1557 bool_t flocked
, didmsg
= FAL0
;
1561 if (options
& OPT_D_VV
) {
1567 for (u
.tries
= 0; !_file_lock(fd
, flt
, off
, len
);)
1568 switch ((serrno
= errno
)) {
1572 if (pollmsecs
> 0 && ++u
.tries
< FILE_LOCK_TRIES
) {
1577 sleep(1); /* TODO pollmsecs -> use finer grain */
1586 #ifndef HAVE_DOTLOCK
1588 if (didmsg
== TRUM1
)
1598 /* Create control-pipe for our dot file locker process, which will remove
1599 * the lock and terminate once the pipe is closed, for whatever reason */
1600 if (pipe_cloexec(cpipe
) == -1) {
1602 emsg
= N_(" Can't create file lock control pipe\n");
1606 /* And the locker process itself; it'll be a (rather cheap) thread only
1607 * unless the lock has to be placed in the system spool and we have our
1608 * privilege-separated dotlock program available, in which case that will be
1609 * executed and do "it" with changed group-id */
1610 di
.di_file_name
= fname
;
1611 di
.di_pollmsecs
= pollmsecs
;
1612 /* Initialize some more stuff; query the two strings in the parent in order
1613 * to cache the result of the former and anyway minimalize child page-ins.
1614 * Especially uname(3) may hang for multiple seconds when it is called the
1616 di
.di_hostname
= nodename(FAL0
);
1617 di
.di_randstr
= getrandstring(16);
1622 u
.ptf
= &_dotlock_main
;
1623 rv
= Popen((char*)-1, "W", u
.sh
, NULL
, cpipe
[1]);
1629 emsg
= N_(" Can't create file lock process\n");
1633 /* Let's check wether we were able to create the dotlock file */
1635 u
.r
= read(cpipe
[0], &dls
, sizeof dls
);
1636 if (UICMP(z
, u
.r
, !=, sizeof dls
)) {
1637 serrno
= (u
.r
!= -1) ? EAGAIN
: errno
;
1638 dls
= DLS_DUNNO
| DLS_ABANDON
;
1642 if (dls
== DLS_NONE
|| (dls
& DLS_ABANDON
))
1645 switch (dls
& ~DLS_ABANDON
) {
1648 case DLS_CANT_CHDIR
:
1649 if (options
& OPT_D_V
)
1650 emsg
= N_(" Can't change to directory! Please check permissions\n");
1653 case DLS_NAMETOOLONG
:
1654 emsg
= N_("Resulting dotlock filename would be too long\n");
1658 assert(dls
& DLS_ABANDON
);
1659 if (options
& OPT_D_V
)
1660 emsg
= N_(" Read-only filesystem, not creating lock file\n");
1664 if (options
& OPT_D_V
)
1665 emsg
= N_(" Can't create a lock file! Please check permissions\n"
1666 " (Maybe setting *dotlock-ignore-error* variable helps.)\n");
1670 if (options
& OPT_D_V
)
1671 emsg
= N_(" Can't find privilege-separated file lock program\n");
1674 case DLS_PRIVFAILED
:
1675 emsg
= N_(" Privilege-separated file lock program can't change "
1680 emsg
= N_(" It seems there is a stale dotlock file?\n"
1681 " Please remove the lock file manually, then retry\n");
1685 emsg
= N_(" Fishy! Is someone trying to \"steal\" foreign files?\n"
1686 " Please check the mailbox file etc. manually, then retry\n");
1687 serrno
= EAGAIN
; /* ? Hack to ignore *dotlock-ignore-error* xxx */
1691 emsg
= N_(" Unspecified dotlock file control process error.\n"
1692 " Like broken I/O pipe; this one is unlikely to happen\n");
1693 if (serrno
!= EAGAIN
)
1709 if (didmsg
== TRUM1
)
1716 if (dls
& DLS_ABANDON
) {
1724 if (didmsg
== TRUM1
)
1727 if (flocked
&& (serrno
== EROFS
||
1728 (serrno
!= EAGAIN
&& serrno
!= EEXIST
&&
1729 ok_blook(dotlock_ignore_error
))))
1743 #endif /* HAVE_DOTLOCK */
1749 sclose(struct sock
*sp
)
1756 /* TODO NOTE: we MUST NOT close the descriptor 0 here...
1757 * TODO of course this should be handled in a VMAILFS->open() .s_fd=-1,
1758 * TODO but unfortunately it isn't yet */
1762 if (sp
->s_onclose
!= NULL
)
1764 if (sp
->s_wbuf
!= NULL
)
1766 # ifdef HAVE_OPENSSL
1767 if (sp
->s_use_ssl
) {
1768 void *s_ssl
= sp
->s_ssl
;
1772 while (!SSL_shutdown(s_ssl
)) /* XXX proper error handling;signals! */
1784 swrite(struct sock
*sp
, char const *data
)
1789 rv
= swrite1(sp
, data
, strlen(data
), 0);
1795 swrite1(struct sock
*sp
, char const *data
, int sz
, int use_buffer
)
1797 enum okay rv
= STOP
;
1801 if (use_buffer
> 0) {
1804 if (sp
->s_wbuf
== NULL
) {
1805 sp
->s_wbufsize
= 4096;
1806 sp
->s_wbuf
= smalloc(sp
->s_wbufsize
);
1809 while (sp
->s_wbufpos
+ sz
> sp
->s_wbufsize
) {
1810 di
= sp
->s_wbufsize
- sp
->s_wbufpos
;
1812 if (sp
->s_wbufpos
> 0) {
1813 memcpy(sp
->s_wbuf
+ sp
->s_wbufpos
, data
, di
);
1814 rv
= swrite1(sp
, sp
->s_wbuf
, sp
->s_wbufsize
, -1);
1816 rv
= swrite1(sp
, data
, sp
->s_wbufsize
, -1);
1822 if (sz
== sp
->s_wbufsize
) {
1823 rv
= swrite1(sp
, data
, sp
->s_wbufsize
, -1);
1827 memcpy(sp
->s_wbuf
+ sp
->s_wbufpos
, data
, sz
);
1828 sp
->s_wbufpos
+= sz
;
1832 } else if (use_buffer
== 0 && sp
->s_wbuf
!= NULL
&& sp
->s_wbufpos
> 0) {
1835 if ((rv
= swrite1(sp
, sp
->s_wbuf
, x
, -1)) != OKAY
)
1843 # ifdef HAVE_OPENSSL
1844 if (sp
->s_use_ssl
) {
1846 x
= SSL_write(sp
->s_ssl
, data
, sz
);
1848 switch (SSL_get_error(sp
->s_ssl
, x
)) {
1849 case SSL_ERROR_WANT_READ
:
1850 case SSL_ERROR_WANT_WRITE
:
1857 x
= xwrite(sp
->s_fd
, data
, sz
);
1861 snprintf(o
, sizeof o
, "%s write error",
1862 (sp
->s_desc
? sp
->s_desc
: "socket"));
1863 # ifdef HAVE_OPENSSL
1865 ssl_gen_err("%s", o
);
1880 static sigjmp_buf __sopen_actjmp
; /* TODO someday, we won't need it no more */
1881 static int __sopen_sig
; /* TODO someday, we won't need it no more */
1883 __sopen_onsig(int sig
) /* TODO someday, we won't need it no more */
1885 NYD_X
; /* Signal handler */
1886 if (__sopen_sig
< 0) {
1887 /* Of course the following doesn't belong into a signal handler XXX */
1890 if (__sopen_sig
== -1) {
1892 _("\nInterrupting it could turn the (GNU/Linux+) DNS resolver "
1894 " Wait until it's done, or do terminate the program\n"));
1896 } else if ((i
= j
= ABS(__sopen_sig
)) + 15 < scrnwidth
) {
1900 fputs("___( o)", stderr
);
1901 putc((i
& 1) ? '=' : '>', stderr
);
1909 siglongjmp(__sopen_actjmp
, 1);
1914 sopen(struct sock
*sp
, struct url
*urlp
) /* TODO sighandling; refactor */
1916 # ifdef HAVE_SO_SNDTIMEO
1919 # ifdef HAVE_SO_LINGER
1922 # ifdef HAVE_GETADDRINFO
1923 char hbuf
[NI_MAXHOST
];
1924 struct addrinfo hints
, *res0
= NULL
, *res
;
1926 struct sockaddr_in servaddr
;
1927 struct in_addr
**pptr
;
1931 sighandler_type
volatile ohup
, oint
;
1932 char const * volatile serv
;
1933 int volatile sofd
= -1, errval
;
1938 /* Connect timeouts after 30 seconds XXX configurable */
1939 # ifdef HAVE_SO_SNDTIMEO
1943 serv
= (urlp
->url_port
!= NULL
) ? urlp
->url_port
: urlp
->url_proto
;
1945 if (options
& OPT_VERB
)
1946 n_err(_("Resolving host \"%s:%s\" ... "),
1947 urlp
->url_host
.s
, serv
);
1949 /* Signal handling (in respect to __sopen_sig dealing) is heavy, but no
1950 * healing until v15.0 and i want to end up with that functionality */
1953 ohup
= safe_signal(SIGHUP
, &__sopen_onsig
);
1954 oint
= safe_signal(SIGINT
, &__sopen_onsig
);
1955 if (sigsetjmp(__sopen_actjmp
, 0)) {
1958 (__sopen_sig
== SIGHUP
? _("Hangup") : _("Interrupted")));
1967 # ifdef HAVE_GETADDRINFO
1969 memset(&hints
, 0, sizeof hints
);
1970 hints
.ai_socktype
= SOCK_STREAM
;
1972 errval
= getaddrinfo(urlp
->url_host
.s
, serv
, &hints
, &res0
);
1973 if (__sopen_sig
!= -1) {
1974 __sopen_sig
= SIGINT
;
1981 if (options
& OPT_VERB
)
1982 n_err(_("failed\n"));
1983 n_err(_("Lookup of \"%s:%s\" failed: %s\n"),
1984 urlp
->url_host
.s
, serv
, gai_strerror(errval
));
1986 /* Error seems to depend on how "smart" the /etc/service code is: is it
1987 * "able" to state wether the service as such is NONAME or does it only
1988 * check for the given ai_socktype.. */
1989 if (errval
== EAI_NONAME
|| errval
== EAI_SERVICE
) {
1990 if (serv
== urlp
->url_proto
&&
1991 (serv
= url_servbyname(urlp
, NULL
)) != NULL
) {
1992 n_err(_(" Trying standard protocol port \"%s\"\n"
1993 " If that succeeds consider including the port in the URL!\n"),
1997 if (serv
!= urlp
->url_port
)
1998 n_err(_(" Including a port number in the URL may "
1999 "circumvent this problem\n"));
2005 if (options
& OPT_VERB
)
2008 for (res
= res0
; res
!= NULL
&& sofd
< 0; res
= res
->ai_next
) {
2009 if (options
& OPT_VERB
) {
2010 if (getnameinfo(res
->ai_addr
, res
->ai_addrlen
, hbuf
, sizeof hbuf
,
2011 NULL
, 0, NI_NUMERICHOST
))
2012 memcpy(hbuf
, "unknown host", sizeof("unknown host"));
2013 n_err(_("%sConnecting to \"%s:%s\" ..."),
2014 (res
== res0
? "" : "\n"), hbuf
, serv
);
2017 sofd
= socket(res
->ai_family
, res
->ai_socktype
, res
->ai_protocol
);
2019 # ifdef HAVE_SO_SNDTIMEO
2020 (void)setsockopt(sofd
, SOL_SOCKET
, SO_SNDTIMEO
, &tv
, sizeof tv
);
2022 if (connect(sofd
, res
->ai_addr
, res
->ai_addrlen
)) {
2036 # else /* HAVE_GETADDRINFO */
2037 if (serv
== urlp
->url_proto
) {
2038 if ((ep
= getservbyname(UNCONST(serv
), "tcp")) != NULL
)
2039 urlp
->url_portno
= ep
->s_port
;
2041 if (options
& OPT_VERB
)
2042 n_err(_("failed\n"));
2043 if ((serv
= url_servbyname(urlp
, &urlp
->url_portno
)) != NULL
)
2044 n_err(_(" Unknown service: \"%s\"\n"
2045 " Trying standard protocol port \"%s\"\n"
2046 " If that succeeds consider including the port in the URL!\n"),
2047 urlp
->url_proto
, serv
);
2049 n_err(_(" Unknown service: \"%s\"\n"
2050 " Including a port in the URL may circumvent this problem\n"),
2052 assert(sofd
== -1 && errval
== 0);
2059 hp
= gethostbyname(urlp
->url_host
.s
);
2060 if (__sopen_sig
!= -1) {
2061 __sopen_sig
= SIGINT
;
2069 if (options
& OPT_VERB
)
2070 n_err(_("failed\n"));
2072 case HOST_NOT_FOUND
: emsg
= N_("host not found"); break;
2074 case TRY_AGAIN
: emsg
= N_("(maybe) try again later"); break;
2075 case NO_RECOVERY
: emsg
= N_("non-recoverable server error"); break;
2076 case NO_DATA
: emsg
= N_("valid name without IP address"); break;
2078 n_err(_("Lookup of \"%s:%s\" failed: %s\n"),
2079 urlp
->url_host
.s
, serv
, V_(emsg
));
2081 } else if (options
& OPT_VERB
)
2084 pptr
= (struct in_addr
**)hp
->h_addr_list
;
2085 if ((sofd
= socket(AF_INET
, SOCK_STREAM
, 0)) == -1) {
2086 n_perr(_("could not create socket"), 0);
2087 assert(sofd
== -1 && errval
== 0);
2091 memset(&servaddr
, 0, sizeof servaddr
);
2092 servaddr
.sin_family
= AF_INET
;
2093 servaddr
.sin_port
= htons(urlp
->url_portno
);
2094 memcpy(&servaddr
.sin_addr
, *pptr
, sizeof(struct in_addr
));
2095 if (options
& OPT_VERB
)
2096 n_err(_("%sConnecting to \"%s:%d\" ... "),
2097 "", inet_ntoa(**pptr
), (int)urlp
->url_portno
);
2098 # ifdef HAVE_SO_SNDTIMEO
2099 (void)setsockopt(sofd
, SOL_SOCKET
, SO_SNDTIMEO
, &tv
, sizeof tv
);
2101 if (connect(sofd
, (struct sockaddr
*)&servaddr
, sizeof servaddr
)) {
2107 # endif /* !HAVE_GETADDRINFO */
2110 safe_signal(SIGINT
, oint
);
2111 safe_signal(SIGHUP
, ohup
);
2117 n_perr(_("Could not connect"), 0);
2122 if (options
& OPT_VERB
)
2123 n_err(_("connected.\n"));
2125 /* And the regular timeouts XXX configurable */
2126 # ifdef HAVE_SO_SNDTIMEO
2129 (void)setsockopt(sofd
, SOL_SOCKET
, SO_SNDTIMEO
, &tv
, sizeof tv
);
2130 (void)setsockopt(sofd
, SOL_SOCKET
, SO_RCVTIMEO
, &tv
, sizeof tv
);
2132 # ifdef HAVE_SO_LINGER
2135 (void)setsockopt(sofd
, SOL_SOCKET
, SO_LINGER
, &li
, sizeof li
);
2138 memset(sp
, 0, sizeof *sp
);
2141 /* SSL/TLS upgrade? */
2143 if (urlp
->url_needs_tls
) {
2145 ohup
= safe_signal(SIGHUP
, &__sopen_onsig
);
2146 oint
= safe_signal(SIGINT
, &__sopen_onsig
);
2147 if (sigsetjmp(__sopen_actjmp
, 0)) {
2148 n_err(_("%s during SSL/TLS handshake\n"),
2149 (__sopen_sig
== SIGHUP
? _("Hangup") : _("Interrupted")));
2154 if (ssl_open(urlp
, sp
) != OKAY
) {
2161 safe_signal(SIGINT
, oint
);
2162 safe_signal(SIGHUP
, ohup
);
2165 # endif /* HAVE_SSL */
2168 /* May need to bounce the signal to the lex.c trampoline (or wherever) */
2169 if (__sopen_sig
!= 0) {
2172 sigaddset(&cset
, __sopen_sig
);
2173 sigprocmask(SIG_UNBLOCK
, &cset
, NULL
);
2174 n_raise(__sopen_sig
);
2181 (sgetline
)(char **line
, size_t *linesize
, size_t *linelen
, struct sock
*sp
2193 if (sp
->s_rsz
< 0) {
2200 if (lp_base
== NULL
|| PTRCMP(lp
, >, lp_base
+ lsize
- 128)) {
2201 size_t diff
= PTR2SIZE(lp
- lp_base
);
2202 *linesize
= (lsize
+= 256); /* XXX magic */
2203 *line
= lp_base
= (srealloc
)(lp_base
, lsize SMALLOC_DEBUG_ARGSCALL
);
2204 lp
= lp_base
+ diff
;
2207 if (sp
->s_rbufptr
== NULL
||
2208 PTRCMP(sp
->s_rbufptr
, >=, sp
->s_rbuf
+ sp
->s_rsz
)) {
2209 # ifdef HAVE_OPENSSL
2210 if (sp
->s_use_ssl
) {
2212 sp
->s_rsz
= SSL_read(sp
->s_ssl
, sp
->s_rbuf
, sizeof sp
->s_rbuf
);
2213 if (sp
->s_rsz
<= 0) {
2214 if (sp
->s_rsz
< 0) {
2216 switch(SSL_get_error(sp
->s_ssl
, sp
->s_rsz
)) {
2217 case SSL_ERROR_WANT_READ
:
2218 case SSL_ERROR_WANT_WRITE
:
2221 snprintf(o
, sizeof o
, "%s",
2222 (sp
->s_desc
? sp
->s_desc
: "socket"));
2223 ssl_gen_err("%s", o
);
2231 sp
->s_rsz
= read(sp
->s_fd
, sp
->s_rbuf
, sizeof sp
->s_rbuf
);
2232 if (sp
->s_rsz
<= 0) {
2233 if (sp
->s_rsz
< 0) {
2237 snprintf(o
, sizeof o
, "%s",
2238 (sp
->s_desc
? sp
->s_desc
: "socket"));
2244 sp
->s_rbufptr
= sp
->s_rbuf
;
2246 } while ((*lp
++ = *sp
->s_rbufptr
++) != '\n');
2248 lsize
= PTR2SIZE(lp
- lp_base
);
2257 #endif /* HAVE_SOCKETS */
2260 load(char const *name
)
2267 if (name
== NULL
|| *name
== '\0' || (in
= Fopen(name
, "r")) == NULL
)
2272 pstate
|= PS_IN_LOAD
;
2273 /* commands() may sreset(), copy over file name */
2275 n
.s
= ac_alloc(n
.l
+1);
2276 memcpy(n
.s
, name
, n
.l
+1);
2278 cond
= condstack_release();
2280 n_err(_("Stopped loading \"%s\" due to errors "
2281 "(enable *debug* for trace)\n"), n
.s
);
2282 condstack_take(cond
);
2285 pstate
&= ~PS_IN_LOAD
;
2298 rv
= _source_file(*(char**)v
, FAL0
) ? 0 : 1;
2304 c_source_if(void *v
) /* XXX obsolete?, support file tests in `if' etc.! */
2309 rv
= _source_file(*(char**)v
, TRU1
) ? 0 : 1;
2321 if (_fio_stack_size
== 0) {
2322 n_err(_("`source' stack over-pop\n"));
2323 pstate
&= ~PS_SOURCING
;
2330 if (!condstack_take(_fio_stack
[_fio_stack_size
].s_cond
))
2331 n_err(_("Unmatched \"if\"\n"));
2332 if (_fio_stack
[_fio_stack_size
].s_loading
)
2333 pstate
|= PS_LOADING
;
2335 pstate
&= ~PS_LOADING
;
2336 _fio_input
= _fio_stack
[_fio_stack_size
].s_file
;
2337 if (_fio_stack_size
== 0) {
2338 if (pstate
& PS_LOADING
)
2339 pstate
|= PS_SOURCING
;
2341 pstate
&= ~PS_SOURCING
;