File: | include/stdio.h |
Warning: | line 392, column 6 Access to field '_w' results in a dereference of a null pointer (loaded from variable '_p') |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* $OpenBSD: mail.local.c,v 1.42 2023/06/05 08:07:18 op Exp $ */ | ||||
2 | |||||
3 | /*- | ||||
4 | * Copyright (c) 1996-1998 Theo de Raadt <deraadt@theos.com> | ||||
5 | * Copyright (c) 1996-1998 David Mazieres <dm@lcs.mit.edu> | ||||
6 | * Copyright (c) 1990 The Regents of the University of California. | ||||
7 | * All rights reserved. | ||||
8 | * | ||||
9 | * Redistribution and use in source and binary forms, with or without | ||||
10 | * modification, are permitted provided that the following conditions | ||||
11 | * are met: | ||||
12 | * 1. Redistributions of source code must retain the above copyright | ||||
13 | * notice, this list of conditions and the following disclaimer. | ||||
14 | * 2. Redistributions in binary form must reproduce the above copyright | ||||
15 | * notice, this list of conditions and the following disclaimer in the | ||||
16 | * documentation and/or other materials provided with the distribution. | ||||
17 | * 3. Neither the name of the University nor the names of its contributors | ||||
18 | * may be used to endorse or promote products derived from this software | ||||
19 | * without specific prior written permission. | ||||
20 | * | ||||
21 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||||
22 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||||
23 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||||
24 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||||
25 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||||
26 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||||
27 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||||
28 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||||
29 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||||
30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||||
31 | * SUCH DAMAGE. | ||||
32 | */ | ||||
33 | |||||
34 | #include <sys/types.h> | ||||
35 | #include <sys/stat.h> | ||||
36 | #include <sys/socket.h> | ||||
37 | #include <sys/wait.h> | ||||
38 | #include <netinet/in.h> | ||||
39 | #include <sysexits.h> | ||||
40 | #include <syslog.h> | ||||
41 | #include <fcntl.h> | ||||
42 | #include <netdb.h> | ||||
43 | #include <pwd.h> | ||||
44 | #include <time.h> | ||||
45 | #include <unistd.h> | ||||
46 | #include <limits.h> | ||||
47 | #include <errno(*__errno()).h> | ||||
48 | #include <stdio.h> | ||||
49 | #include <stdlib.h> | ||||
50 | #include <string.h> | ||||
51 | #include <signal.h> | ||||
52 | #include "pathnames.h" | ||||
53 | #include "mail.local.h" | ||||
54 | |||||
55 | int | ||||
56 | main(int argc, char *argv[]) | ||||
57 | { | ||||
58 | struct passwd *pw; | ||||
59 | int ch, fd, eval, lockfile=1; | ||||
60 | uid_t uid; | ||||
61 | char *from; | ||||
62 | |||||
63 | openlog("mail.local", LOG_PERROR0x20, LOG_MAIL(2<<3)); | ||||
64 | |||||
65 | from = NULL((void *)0); | ||||
66 | while ((ch = getopt(argc, argv, "lLdf:r:")) != -1) | ||||
| |||||
67 | switch (ch) { | ||||
68 | case 'd': /* backward compatible */ | ||||
69 | break; | ||||
70 | case 'f': | ||||
71 | case 'r': /* backward compatible */ | ||||
72 | if (from) | ||||
73 | merr(EX_USAGE64, "multiple -f options"); | ||||
74 | from = optarg; | ||||
75 | break; | ||||
76 | case 'l': | ||||
77 | lockfile=1; | ||||
78 | break; | ||||
79 | case 'L': | ||||
80 | lockfile=0; | ||||
81 | break; | ||||
82 | default: | ||||
83 | usage(); | ||||
84 | } | ||||
85 | argc -= optind; | ||||
86 | argv += optind; | ||||
87 | |||||
88 | if (!*argv) | ||||
89 | usage(); | ||||
90 | |||||
91 | /* | ||||
92 | * If from not specified, use the name from getlogin() if the | ||||
93 | * uid matches, otherwise, use the name from the password file | ||||
94 | * corresponding to the uid. | ||||
95 | */ | ||||
96 | uid = getuid(); | ||||
97 | if (!from
| ||||
98 | !(pw = getpwnam(from)) || pw->pw_uid != uid)) | ||||
99 | from = (pw = getpwuid(uid)) ? pw->pw_name : "???"; | ||||
100 | |||||
101 | fd = storemail(from); | ||||
102 | for (eval = 0; *argv; ++argv) { | ||||
103 | if ((ch = deliver(fd, *argv, lockfile)) != 0) | ||||
104 | eval = ch; | ||||
105 | } | ||||
106 | exit(eval); | ||||
107 | } | ||||
108 | |||||
109 | int | ||||
110 | storemail(char *from) | ||||
111 | { | ||||
112 | FILE *fp = NULL((void *)0); | ||||
113 | time_t tval; | ||||
114 | int fd, eline = 1; | ||||
115 | char *tbuf, *line = NULL((void *)0); | ||||
116 | size_t linesize = 0; | ||||
117 | ssize_t linelen; | ||||
118 | |||||
119 | if ((tbuf = strdup(_PATH_LOCTMP"/tmp/local.XXXXXXXXXX")) == NULL((void *)0)) | ||||
120 | merr(EX_OSERR71, "unable to allocate memory"); | ||||
121 | if ((fd = mkstemp(tbuf)) == -1 || !(fp = fdopen(fd, "w+"))) | ||||
122 | merr(EX_OSERR71, "unable to open temporary file"); | ||||
123 | (void)unlink(tbuf); | ||||
124 | free(tbuf); | ||||
125 | |||||
126 | (void)time(&tval); | ||||
127 | (void)fprintf(fp, "From %s %s", from, ctime(&tval)); | ||||
128 | |||||
129 | while ((linelen = getline(&line, &linesize, stdin(&__sF[0]))) != -1) { | ||||
130 | if (line[linelen - 1] == '\n') | ||||
131 | line[linelen - 1] = '\0'; | ||||
132 | if (line[0] == '\0') | ||||
133 | eline = 1; | ||||
134 | else { | ||||
135 | if (eline && !strncmp(line, "From ", 5)) | ||||
136 | (void)putc('>', fp)(!__isthreaded ? __sputc('>', fp) : (putc)('>', fp)); | ||||
137 | eline = 0; | ||||
138 | } | ||||
139 | (void)fprintf(fp, "%s\n", line); | ||||
140 | if (ferror(fp)(!__isthreaded ? (((fp)->_flags & 0x0040) != 0) : (ferror )(fp))) | ||||
141 | break; | ||||
142 | } | ||||
143 | free(line); | ||||
144 | |||||
145 | /* Output a newline; note, empty messages are allowed. */ | ||||
146 | (void)putc('\n', fp)(!__isthreaded ? __sputc('\n', fp) : (putc)('\n', fp)); | ||||
147 | (void)fflush(fp); | ||||
148 | if (ferror(fp)(!__isthreaded ? (((fp)->_flags & 0x0040) != 0) : (ferror )(fp))) | ||||
149 | merr(EX_OSERR71, "temporary file write error"); | ||||
150 | return(fd); | ||||
151 | } | ||||
152 | |||||
153 | int | ||||
154 | deliver(int fd, char *name, int lockfile) | ||||
155 | { | ||||
156 | struct stat sb, fsb; | ||||
157 | struct passwd *pw; | ||||
158 | int mbfd=-1, lfd=-1, rval=EX_OSERR71; | ||||
159 | char biffmsg[100], buf[8*1024], path[PATH_MAX1024]; | ||||
160 | off_t curoff; | ||||
161 | size_t off; | ||||
162 | ssize_t nr, nw; | ||||
163 | |||||
164 | /* | ||||
165 | * Disallow delivery to unknown names -- special mailboxes can be | ||||
166 | * handled in the sendmail aliases file. | ||||
167 | */ | ||||
168 | if (!(pw = getpwnam(name))) { | ||||
169 | mwarn("unknown name: %s", name); | ||||
170 | return(EX_NOUSER67); | ||||
171 | } | ||||
172 | |||||
173 | (void)snprintf(path, sizeof path, "%s/%s", _PATH_MAILDIR"/var/mail", name); | ||||
174 | |||||
175 | if (lockfile) { | ||||
176 | lfd = lockspool(name, pw); | ||||
177 | if (lfd == -1) | ||||
178 | return(EX_OSERR71); | ||||
179 | } | ||||
180 | |||||
181 | /* after this point, always exit via bad to remove lockfile */ | ||||
182 | retry: | ||||
183 | if (lstat(path, &sb)) { | ||||
184 | if (errno(*__errno()) != ENOENT2) { | ||||
185 | mwarn("%s: %s", path, strerror(errno(*__errno()))); | ||||
186 | goto bad; | ||||
187 | } | ||||
188 | if ((mbfd = open(path, O_APPEND0x0008|O_CREAT0x0200|O_EXCL0x0800|O_WRONLY0x0001|O_EXLOCK0x0020, | ||||
189 | S_IRUSR0000400|S_IWUSR0000200)) == -1) { | ||||
190 | if (errno(*__errno()) == EEXIST17) { | ||||
191 | /* file appeared since lstat */ | ||||
192 | goto retry; | ||||
193 | } else { | ||||
194 | mwarn("%s: %s", path, strerror(errno(*__errno()))); | ||||
195 | rval = EX_CANTCREAT73; | ||||
196 | goto bad; | ||||
197 | } | ||||
198 | } | ||||
199 | /* | ||||
200 | * Set the owner and group. Historically, binmail repeated | ||||
201 | * this at each mail delivery. We no longer do this, assuming | ||||
202 | * that if the ownership or permissions were changed there | ||||
203 | * was a reason for doing so. | ||||
204 | */ | ||||
205 | if (fchown(mbfd, pw->pw_uid, pw->pw_gid) == -1) { | ||||
206 | mwarn("chown %u:%u: %s", pw->pw_uid, pw->pw_gid, name); | ||||
207 | goto bad; | ||||
208 | } | ||||
209 | } else { | ||||
210 | if (sb.st_nlink != 1 || !S_ISREG(sb.st_mode)((sb.st_mode & 0170000) == 0100000)) { | ||||
211 | mwarn("%s: linked or special file", path); | ||||
212 | goto bad; | ||||
213 | } | ||||
214 | if ((mbfd = open(path, O_APPEND0x0008|O_WRONLY0x0001|O_EXLOCK0x0020, | ||||
215 | S_IRUSR0000400|S_IWUSR0000200)) == -1) { | ||||
216 | mwarn("%s: %s", path, strerror(errno(*__errno()))); | ||||
217 | goto bad; | ||||
218 | } | ||||
219 | if (fstat(mbfd, &fsb) == -1) { | ||||
220 | /* relating error to path may be bad style */ | ||||
221 | mwarn("%s: %s", path, strerror(errno(*__errno()))); | ||||
222 | goto bad; | ||||
223 | } | ||||
224 | if (sb.st_dev != fsb.st_dev || sb.st_ino != fsb.st_ino) { | ||||
225 | mwarn("%s: changed after open", path); | ||||
226 | goto bad; | ||||
227 | } | ||||
228 | /* paranoia? */ | ||||
229 | if (fsb.st_nlink != 1 || !S_ISREG(fsb.st_mode)((fsb.st_mode & 0170000) == 0100000)) { | ||||
230 | mwarn("%s: linked or special file", path); | ||||
231 | rval = EX_CANTCREAT73; | ||||
232 | goto bad; | ||||
233 | } | ||||
234 | } | ||||
235 | |||||
236 | curoff = lseek(mbfd, 0, SEEK_END2); | ||||
237 | (void)snprintf(biffmsg, sizeof biffmsg, "%s@%lld\n", name, | ||||
238 | (long long)curoff); | ||||
239 | if (lseek(fd, 0, SEEK_SET0) == (off_t)-1) { | ||||
240 | mwarn("temporary file: %s", strerror(errno(*__errno()))); | ||||
241 | goto bad; | ||||
242 | } | ||||
243 | |||||
244 | while ((nr = read(fd, buf, sizeof(buf))) > 0) | ||||
245 | for (off = 0; off < nr; off += nw) | ||||
246 | if ((nw = write(mbfd, buf + off, nr - off)) == -1) { | ||||
247 | mwarn("%s: %s", path, strerror(errno(*__errno()))); | ||||
248 | (void)ftruncate(mbfd, curoff); | ||||
249 | goto bad; | ||||
250 | } | ||||
251 | |||||
252 | if (nr == 0) { | ||||
253 | rval = 0; | ||||
254 | } else { | ||||
255 | (void)ftruncate(mbfd, curoff); | ||||
256 | mwarn("temporary file: %s", strerror(errno(*__errno()))); | ||||
257 | } | ||||
258 | |||||
259 | bad: | ||||
260 | if (lfd != -1) | ||||
261 | unlockspool(); | ||||
262 | |||||
263 | if (mbfd != -1) { | ||||
264 | (void)fsync(mbfd); /* Don't wait for update. */ | ||||
265 | (void)close(mbfd); /* Implicit unlock. */ | ||||
266 | } | ||||
267 | |||||
268 | if (!rval) | ||||
269 | notifybiff(biffmsg); | ||||
270 | return(rval); | ||||
271 | } | ||||
272 | |||||
273 | void | ||||
274 | notifybiff(char *msg) | ||||
275 | { | ||||
276 | static struct addrinfo *res0; | ||||
277 | struct addrinfo hints, *res; | ||||
278 | static int f = -1; | ||||
279 | size_t len; | ||||
280 | int error; | ||||
281 | |||||
282 | if (res0 == NULL((void *)0)) { | ||||
283 | memset(&hints, 0, sizeof(hints)); | ||||
284 | hints.ai_family = PF_UNSPEC0; | ||||
285 | hints.ai_socktype = SOCK_DGRAM2; | ||||
286 | |||||
287 | error = getaddrinfo("localhost", "biff", &hints, &res0); | ||||
288 | if (error) { | ||||
289 | /* Be silent if biff service not available. */ | ||||
290 | if (error != EAI_SERVICE-8) { | ||||
291 | mwarn("localhost: %s", gai_strerror(error)); | ||||
292 | } | ||||
293 | return; | ||||
294 | } | ||||
295 | } | ||||
296 | |||||
297 | if (f == -1) { | ||||
298 | for (res = res0; res != NULL((void *)0); res = res->ai_next) { | ||||
299 | f = socket(res->ai_family, res->ai_socktype, | ||||
300 | res->ai_protocol); | ||||
301 | if (f != -1) | ||||
302 | break; | ||||
303 | } | ||||
304 | } | ||||
305 | if (f == -1) { | ||||
306 | mwarn("socket: %s", strerror(errno(*__errno()))); | ||||
307 | return; | ||||
308 | } | ||||
309 | |||||
310 | len = strlen(msg) + 1; /* XXX */ | ||||
311 | if (sendto(f, msg, len, 0, res->ai_addr, res->ai_addrlen) != len) | ||||
312 | mwarn("sendto biff: %s", strerror(errno(*__errno()))); | ||||
313 | } | ||||
314 | |||||
315 | static int lockfd = -1; | ||||
316 | static pid_t lockpid = -1; | ||||
317 | |||||
318 | int | ||||
319 | lockspool(const char *name, struct passwd *pw) | ||||
320 | { | ||||
321 | int pfd[2]; | ||||
322 | char ch; | ||||
323 | |||||
324 | if (geteuid() == 0) | ||||
325 | return getlock(name, pw); | ||||
326 | |||||
327 | /* If not privileged, open pipe to lockspool(1) instead */ | ||||
328 | if (pipe2(pfd, O_CLOEXEC0x10000) == -1) { | ||||
329 | merr(EX_OSERR71, "pipe: %s", strerror(errno(*__errno()))); | ||||
330 | return -1; | ||||
331 | } | ||||
332 | |||||
333 | signal(SIGPIPE13, SIG_IGN(void (*)(int))1); | ||||
334 | switch ((lockpid = fork())) { | ||||
335 | case -1: | ||||
336 | merr(EX_OSERR71, "fork: %s", strerror(errno(*__errno()))); | ||||
337 | return -1; | ||||
338 | case 0: | ||||
339 | /* child */ | ||||
340 | close(pfd[0]); | ||||
341 | dup2(pfd[1], STDOUT_FILENO1); | ||||
342 | execl(_PATH_LOCKSPOOL"/usr/libexec/lockspool", "lockspool", (char *)NULL((void *)0)); | ||||
343 | merr(EX_OSERR71, "execl: lockspool: %s", strerror(errno(*__errno()))); | ||||
344 | /* NOTREACHED */ | ||||
345 | break; | ||||
346 | default: | ||||
347 | /* parent */ | ||||
348 | close(pfd[1]); | ||||
349 | lockfd = pfd[0]; | ||||
350 | break; | ||||
351 | } | ||||
352 | |||||
353 | if (read(lockfd, &ch, 1) != 1 || ch != '1') { | ||||
354 | unlockspool(); | ||||
355 | merr(EX_OSERR71, "lockspool: unable to get lock"); | ||||
356 | } | ||||
357 | |||||
358 | return lockfd; | ||||
359 | } | ||||
360 | |||||
361 | void | ||||
362 | unlockspool(void) | ||||
363 | { | ||||
364 | if (lockpid != -1) { | ||||
365 | waitpid(lockpid, NULL((void *)0), 0); | ||||
366 | lockpid = -1; | ||||
367 | } else { | ||||
368 | rellock(); | ||||
369 | } | ||||
370 | close(lockfd); | ||||
371 | lockfd = -1; | ||||
372 | } | ||||
373 | |||||
374 | void | ||||
375 | usage(void) | ||||
376 | { | ||||
377 | merr(EX_USAGE64, "usage: mail.local [-Ll] [-f from] user ..."); | ||||
378 | } |
1 | /* $OpenBSD: stdio.h,v 1.55 2022/01/05 20:57:27 millert Exp $ */ | |||
2 | /* $NetBSD: stdio.h,v 1.18 1996/04/25 18:29:21 jtc Exp $ */ | |||
3 | ||||
4 | /*- | |||
5 | * Copyright (c) 1990 The Regents of the University of California. | |||
6 | * All rights reserved. | |||
7 | * | |||
8 | * This code is derived from software contributed to Berkeley by | |||
9 | * Chris Torek. | |||
10 | * | |||
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. | |||
22 | * | |||
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. | |||
34 | * | |||
35 | * @(#)stdio.h 5.17 (Berkeley) 6/3/91 | |||
36 | */ | |||
37 | ||||
38 | #ifndef _STDIO_H_ | |||
39 | #define _STDIO_H_ | |||
40 | ||||
41 | #include <sys/cdefs.h> | |||
42 | #include <sys/_null.h> | |||
43 | #include <sys/_types.h> | |||
44 | ||||
45 | #if __BSD_VISIBLE1 || __POSIX_VISIBLE200809 || __XPG_VISIBLE700 | |||
46 | #include <sys/types.h> /* XXX should be removed */ | |||
47 | #endif | |||
48 | ||||
49 | #ifndef _SIZE_T_DEFINED_ | |||
50 | #define _SIZE_T_DEFINED_ | |||
51 | typedef __size_t size_t; | |||
52 | #endif | |||
53 | ||||
54 | #ifndef _OFF_T_DEFINED_ | |||
55 | #define _OFF_T_DEFINED_ | |||
56 | typedef __off_t off_t; | |||
57 | #endif | |||
58 | ||||
59 | #define _FSTDIO /* Define for new stdio with functions. */ | |||
60 | ||||
61 | typedef off_t fpos_t; /* stdio file position type */ | |||
62 | ||||
63 | /* | |||
64 | * NB: to fit things in six character monocase externals, the stdio | |||
65 | * code uses the prefix `__s' for stdio objects, typically followed | |||
66 | * by a three-character attempt at a mnemonic. | |||
67 | */ | |||
68 | ||||
69 | /* stdio buffers */ | |||
70 | struct __sbuf { | |||
71 | unsigned char *_base; | |||
72 | int _size; | |||
73 | }; | |||
74 | ||||
75 | /* | |||
76 | * stdio state variables. | |||
77 | * | |||
78 | * The following always hold: | |||
79 | * | |||
80 | * if (_flags&(__SLBF|__SWR)) == (__SLBF|__SWR), | |||
81 | * _lbfsize is -_bf._size, else _lbfsize is 0 | |||
82 | * if _flags&__SRD, _w is 0 | |||
83 | * if _flags&__SWR, _r is 0 | |||
84 | * | |||
85 | * This ensures that the getc and putc macros (or inline functions) never | |||
86 | * try to write or read from a file that is in `read' or `write' mode. | |||
87 | * (Moreover, they can, and do, automatically switch from read mode to | |||
88 | * write mode, and back, on "r+" and "w+" files.) | |||
89 | * | |||
90 | * _lbfsize is used only to make the inline line-buffered output stream | |||
91 | * code as compact as possible. | |||
92 | * | |||
93 | * _ub, _up, and _ur are used when ungetc() pushes back more characters | |||
94 | * than fit in the current _bf, or when ungetc() pushes back a character | |||
95 | * that does not match the previous one in _bf. When this happens, | |||
96 | * _ub._base becomes non-nil (i.e., a stream has ungetc() data iff | |||
97 | * _ub._base!=NULL) and _up and _ur save the current values of _p and _r. | |||
98 | */ | |||
99 | typedef struct __sFILE { | |||
100 | unsigned char *_p; /* current position in (some) buffer */ | |||
101 | int _r; /* read space left for getc() */ | |||
102 | int _w; /* write space left for putc() */ | |||
103 | short _flags; /* flags, below; this FILE is free if 0 */ | |||
104 | short _file; /* fileno, if Unix descriptor, else -1 */ | |||
105 | struct __sbuf _bf; /* the buffer (at least 1 byte, if !NULL) */ | |||
106 | int _lbfsize; /* 0 or -_bf._size, for inline putc */ | |||
107 | ||||
108 | /* operations */ | |||
109 | void *_cookie; /* cookie passed to io functions */ | |||
110 | int (*_close)(void *); | |||
111 | int (*_read)(void *, char *, int); | |||
112 | fpos_t (*_seek)(void *, fpos_t, int); | |||
113 | int (*_write)(void *, const char *, int); | |||
114 | ||||
115 | /* extension data, to avoid further ABI breakage */ | |||
116 | struct __sbuf _ext; | |||
117 | /* data for long sequences of ungetc() */ | |||
118 | unsigned char *_up; /* saved _p when _p is doing ungetc data */ | |||
119 | int _ur; /* saved _r when _r is counting ungetc data */ | |||
120 | ||||
121 | /* tricks to meet minimum requirements even when malloc() fails */ | |||
122 | unsigned char _ubuf[3]; /* guarantee an ungetc() buffer */ | |||
123 | unsigned char _nbuf[1]; /* guarantee a getc() buffer */ | |||
124 | ||||
125 | /* separate buffer for fgetln() when line crosses buffer boundary */ | |||
126 | struct __sbuf _lb; /* buffer for fgetln() */ | |||
127 | ||||
128 | /* Unix stdio files get aligned to block boundaries on fseek() */ | |||
129 | int _blksize; /* stat.st_blksize (may be != _bf._size) */ | |||
130 | fpos_t _offset; /* current lseek offset */ | |||
131 | } FILE; | |||
132 | ||||
133 | __BEGIN_DECLS | |||
134 | extern FILE __sF[]; | |||
135 | __END_DECLS | |||
136 | ||||
137 | #define __SLBF0x0001 0x0001 /* line buffered */ | |||
138 | #define __SNBF0x0002 0x0002 /* unbuffered */ | |||
139 | #define __SRD0x0004 0x0004 /* OK to read */ | |||
140 | #define __SWR0x0008 0x0008 /* OK to write */ | |||
141 | /* RD and WR are never simultaneously asserted */ | |||
142 | #define __SRW0x0010 0x0010 /* open for reading & writing */ | |||
143 | #define __SEOF0x0020 0x0020 /* found EOF */ | |||
144 | #define __SERR0x0040 0x0040 /* found error */ | |||
145 | #define __SMBF0x0080 0x0080 /* _buf is from malloc */ | |||
146 | #define __SAPP0x0100 0x0100 /* fdopen()ed in append mode */ | |||
147 | #define __SSTR0x0200 0x0200 /* this is an sprintf/snprintf string */ | |||
148 | #define __SOPT0x0400 0x0400 /* do fseek() optimisation */ | |||
149 | #define __SNPT0x0800 0x0800 /* do not do fseek() optimisation */ | |||
150 | #define __SOFF0x1000 0x1000 /* set iff _offset is in fact correct */ | |||
151 | #define __SMOD0x2000 0x2000 /* true => fgetln modified _p text */ | |||
152 | #define __SALC0x4000 0x4000 /* allocate string space dynamically */ | |||
153 | #define __SIGN0x8000 0x8000 /* ignore this file in _fwalk */ | |||
154 | ||||
155 | /* | |||
156 | * The following three definitions are for ANSI C, which took them | |||
157 | * from System V, which brilliantly took internal interface macros and | |||
158 | * made them official arguments to setvbuf(), without renaming them. | |||
159 | * Hence, these ugly _IOxxx names are *supposed* to appear in user code. | |||
160 | * | |||
161 | * Although numbered as their counterparts above, the implementation | |||
162 | * does not rely on this. | |||
163 | */ | |||
164 | #define _IOFBF0 0 /* setvbuf should set fully buffered */ | |||
165 | #define _IOLBF1 1 /* setvbuf should set line buffered */ | |||
166 | #define _IONBF2 2 /* setvbuf should set unbuffered */ | |||
167 | ||||
168 | #define BUFSIZ1024 1024 /* size of buffer used by setbuf */ | |||
169 | ||||
170 | #define EOF(-1) (-1) | |||
171 | ||||
172 | /* | |||
173 | * FOPEN_MAX is a minimum maximum, and should be the number of descriptors | |||
174 | * that the kernel can provide without allocation of a resource that can | |||
175 | * fail without the process sleeping. Do not use this for anything. | |||
176 | */ | |||
177 | #define FOPEN_MAX20 20 /* must be <= OPEN_MAX <sys/syslimits.h> */ | |||
178 | #define FILENAME_MAX1024 1024 /* must be <= PATH_MAX <sys/syslimits.h> */ | |||
179 | ||||
180 | /* System V/ANSI C; this is the wrong way to do this, do *not* use these. */ | |||
181 | #if __BSD_VISIBLE1 || __XPG_VISIBLE700 | |||
182 | #define P_tmpdir"/tmp/" "/tmp/" | |||
183 | #endif | |||
184 | #define L_tmpnam1024 1024 /* XXX must be == PATH_MAX */ | |||
185 | #define TMP_MAX0x7fffffff 0x7fffffff /* more, but don't overflow int */ | |||
186 | ||||
187 | #ifndef SEEK_SET0 | |||
188 | #define SEEK_SET0 0 /* set file offset to offset */ | |||
189 | #endif | |||
190 | #ifndef SEEK_CUR1 | |||
191 | #define SEEK_CUR1 1 /* set file offset to current plus offset */ | |||
192 | #endif | |||
193 | #ifndef SEEK_END2 | |||
194 | #define SEEK_END2 2 /* set file offset to EOF plus offset */ | |||
195 | #endif | |||
196 | ||||
197 | #define stdin(&__sF[0]) (&__sF[0]) | |||
198 | #define stdout(&__sF[1]) (&__sF[1]) | |||
199 | #define stderr(&__sF[2]) (&__sF[2]) | |||
200 | ||||
201 | /* | |||
202 | * Functions defined in ANSI C standard. | |||
203 | */ | |||
204 | __BEGIN_DECLS | |||
205 | void clearerr(FILE *)(!__isthreaded ? ((void)((FILE *)->_flags &= ~(0x0040| 0x0020))) : (clearerr)(FILE *)); | |||
206 | #if __POSIX_VISIBLE200809 >= 200809 | |||
207 | int dprintf(int, const char * __restrict, ...) | |||
208 | __attribute__((__format__ (printf, 2, 3))) | |||
209 | __attribute__((__nonnull__ (2))); | |||
210 | #endif | |||
211 | int fclose(FILE *); | |||
212 | int feof(FILE *)(!__isthreaded ? (((FILE *)->_flags & 0x0020) != 0) : ( feof)(FILE *)); | |||
213 | int ferror(FILE *)(!__isthreaded ? (((FILE *)->_flags & 0x0040) != 0) : ( ferror)(FILE *)); | |||
214 | int fflush(FILE *); | |||
215 | int fgetc(FILE *); | |||
216 | int fgetpos(FILE *, fpos_t *); | |||
217 | char *fgets(char *, int, FILE *) | |||
218 | __attribute__((__bounded__ (__string__,1,2))); | |||
219 | FILE *fopen(const char *, const char *); | |||
220 | int fprintf(FILE *, const char *, ...); | |||
221 | int fputc(int, FILE *); | |||
222 | int fputs(const char *, FILE *); | |||
223 | size_t fread(void *, size_t, size_t, FILE *) | |||
224 | __attribute__((__bounded__ (__size__,1,3,2))); | |||
225 | FILE *freopen(const char *, const char *, FILE *); | |||
226 | int fscanf(FILE *, const char *, ...); | |||
227 | int fseek(FILE *, long, int); | |||
228 | int fseeko(FILE *, off_t, int); | |||
229 | int fsetpos(FILE *, const fpos_t *); | |||
230 | long ftell(FILE *); | |||
231 | off_t ftello(FILE *); | |||
232 | size_t fwrite(const void *, size_t, size_t, FILE *) | |||
233 | __attribute__((__bounded__ (__size__,1,3,2))); | |||
234 | int getc(FILE *)(!__isthreaded ? (--(FILE *)->_r < 0 ? __srget(FILE *) : (int)(*(FILE *)->_p++)) : (getc)(FILE *)); | |||
235 | int getchar(void); | |||
236 | #if __POSIX_VISIBLE200809 >= 200809 | |||
237 | ssize_t getdelim(char ** __restrict, size_t * __restrict, int, | |||
238 | FILE * __restrict); | |||
239 | ssize_t getline(char ** __restrict, size_t * __restrict, | |||
240 | FILE * __restrict); | |||
241 | #endif | |||
242 | #if __BSD_VISIBLE1 && !defined(__SYS_ERRLIST) | |||
243 | #define __SYS_ERRLIST | |||
244 | ||||
245 | extern int sys_nerr; /* perror(3) external variables */ | |||
246 | extern char *sys_errlist[]; | |||
247 | #endif | |||
248 | void perror(const char *); | |||
249 | int printf(const char *, ...); | |||
250 | int putc(int, FILE *)(!__isthreaded ? __sputc(int, FILE *) : (putc)(int, FILE *)); | |||
251 | int putchar(int)(!__isthreaded ? __sputc(int, (&__sF[1])) : (putc)(int, ( &__sF[1]))); | |||
252 | int puts(const char *); | |||
253 | int remove(const char *); | |||
254 | int rename(const char *, const char *); | |||
255 | #if __POSIX_VISIBLE200809 >= 200809 | |||
256 | int renameat(int, const char *, int, const char *); | |||
257 | #endif | |||
258 | void rewind(FILE *); | |||
259 | int scanf(const char *, ...); | |||
260 | void setbuf(FILE *, char *); | |||
261 | int setvbuf(FILE *, char *, int, size_t); | |||
262 | int sprintf(char *, const char *, ...); | |||
263 | int sscanf(const char *, const char *, ...); | |||
264 | FILE *tmpfile(void); | |||
265 | char *tmpnam(char *); | |||
266 | int ungetc(int, FILE *); | |||
267 | int vfprintf(FILE *, const char *, __va_list); | |||
268 | int vprintf(const char *, __va_list); | |||
269 | int vsprintf(char *, const char *, __va_list); | |||
270 | #if __POSIX_VISIBLE200809 >= 200809 | |||
271 | int vdprintf(int, const char * __restrict, __va_list) | |||
272 | __attribute__((__format__ (printf, 2, 0))) | |||
273 | __attribute__((__nonnull__ (2))); | |||
274 | #endif | |||
275 | ||||
276 | #if __ISO_C_VISIBLE2011 >= 1999 || __XPG_VISIBLE700 >= 500 || __BSD_VISIBLE1 | |||
277 | int snprintf(char *, size_t, const char *, ...) | |||
278 | __attribute__((__format__ (printf, 3, 4))) | |||
279 | __attribute__((__nonnull__ (3))) | |||
280 | __attribute__((__bounded__ (__string__,1,2))); | |||
281 | int vsnprintf(char *, size_t, const char *, __va_list) | |||
282 | __attribute__((__format__ (printf, 3, 0))) | |||
283 | __attribute__((__nonnull__ (3))) | |||
284 | __attribute__((__bounded__(__string__,1,2))); | |||
285 | #endif /* __ISO_C_VISIBLE >= 1999 || __XPG_VISIBLE >= 500 || __BSD_VISIBLE */ | |||
286 | ||||
287 | #if __ISO_C_VISIBLE2011 >= 1999 || __BSD_VISIBLE1 | |||
288 | int vfscanf(FILE *, const char *, __va_list) | |||
289 | __attribute__((__format__ (scanf, 2, 0))) | |||
290 | __attribute__((__nonnull__ (2))); | |||
291 | int vscanf(const char *, __va_list) | |||
292 | __attribute__((__format__ (scanf, 1, 0))) | |||
293 | __attribute__((__nonnull__ (1))); | |||
294 | int vsscanf(const char *, const char *, __va_list) | |||
295 | __attribute__((__format__ (scanf, 2, 0))) | |||
296 | __attribute__((__nonnull__ (2))); | |||
297 | #endif /* __ISO_C_VISIBLE >= 1999 || __BSD_VISIBLE */ | |||
298 | ||||
299 | __END_DECLS | |||
300 | ||||
301 | ||||
302 | /* | |||
303 | * Functions defined in POSIX 1003.1. | |||
304 | */ | |||
305 | #if __BSD_VISIBLE1 || __POSIX_VISIBLE200809 || __XPG_VISIBLE700 | |||
306 | #define L_ctermid1024 1024 /* size for ctermid(); PATH_MAX */ | |||
307 | ||||
308 | __BEGIN_DECLS | |||
309 | char *ctermid(char *); | |||
310 | FILE *fdopen(int, const char *); | |||
311 | int fileno(FILE *)(!__isthreaded ? ((FILE *)->_file) : (fileno)(FILE *)); | |||
312 | ||||
313 | #if __POSIX_VISIBLE200809 >= 199209 | |||
314 | int pclose(FILE *); | |||
315 | FILE *popen(const char *, const char *); | |||
316 | #endif | |||
317 | ||||
318 | #if __POSIX_VISIBLE200809 >= 199506 | |||
319 | void flockfile(FILE *); | |||
320 | int ftrylockfile(FILE *); | |||
321 | void funlockfile(FILE *); | |||
322 | ||||
323 | /* | |||
324 | * These are normally used through macros as defined below, but POSIX | |||
325 | * requires functions as well. | |||
326 | */ | |||
327 | int getc_unlocked(FILE *)(--(FILE *)->_r < 0 ? __srget(FILE *) : (int)(*(FILE *) ->_p++)); | |||
328 | int getchar_unlocked(void); | |||
329 | int putc_unlocked(int, FILE *)__sputc(int, FILE *); | |||
330 | int putchar_unlocked(int)__sputc(int, (&__sF[1])); | |||
331 | #endif /* __POSIX_VISIBLE >= 199506 */ | |||
332 | ||||
333 | #if __POSIX_VISIBLE200809 >= 200809 | |||
334 | FILE *fmemopen(void *, size_t, const char *); | |||
335 | FILE *open_memstream(char **, size_t *); | |||
336 | #endif /* __POSIX_VISIBLE >= 200809 */ | |||
337 | ||||
338 | #if __XPG_VISIBLE700 | |||
339 | char *tempnam(const char *, const char *); | |||
340 | #endif | |||
341 | __END_DECLS | |||
342 | ||||
343 | #endif /* __BSD_VISIBLE || __POSIX_VISIBLE || __XPG_VISIBLE */ | |||
344 | ||||
345 | /* | |||
346 | * Routines that are purely local. | |||
347 | */ | |||
348 | #if __BSD_VISIBLE1 | |||
349 | __BEGIN_DECLS | |||
350 | int asprintf(char **, const char *, ...) | |||
351 | __attribute__((__format__ (printf, 2, 3))) | |||
352 | __attribute__((__nonnull__ (2))); | |||
353 | char *fgetln(FILE *, size_t *); | |||
354 | int fpurge(FILE *); | |||
355 | int getw(FILE *); | |||
356 | int putw(int, FILE *); | |||
357 | void setbuffer(FILE *, char *, int); | |||
358 | int setlinebuf(FILE *); | |||
359 | int vasprintf(char **, const char *, __va_list) | |||
360 | __attribute__((__format__ (printf, 2, 0))) | |||
361 | __attribute__((__nonnull__ (2))); | |||
362 | __END_DECLS | |||
363 | ||||
364 | /* | |||
365 | * Stdio function-access interface. | |||
366 | */ | |||
367 | __BEGIN_DECLS | |||
368 | FILE *funopen(const void *, | |||
369 | int (*)(void *, char *, int), | |||
370 | int (*)(void *, const char *, int), | |||
371 | off_t (*)(void *, off_t, int), | |||
372 | int (*)(void *)); | |||
373 | __END_DECLS | |||
374 | #define fropen(cookie, fn)funopen(cookie, fn, 0, 0, 0) funopen(cookie, fn, 0, 0, 0) | |||
375 | #define fwopen(cookie, fn)funopen(cookie, 0, fn, 0, 0) funopen(cookie, 0, fn, 0, 0) | |||
376 | #endif /* __BSD_VISIBLE */ | |||
377 | ||||
378 | /* | |||
379 | * Functions internal to the implementation. | |||
380 | */ | |||
381 | __BEGIN_DECLS | |||
382 | int __srget(FILE *); | |||
383 | int __swbuf(int, FILE *); | |||
384 | __END_DECLS | |||
385 | ||||
386 | /* | |||
387 | * The __sfoo macros are here so that we can | |||
388 | * define function versions in the C library. | |||
389 | */ | |||
390 | #define __sgetc(p)(--(p)->_r < 0 ? __srget(p) : (int)(*(p)->_p++)) (--(p)->_r < 0 ? __srget(p) : (int)(*(p)->_p++)) | |||
391 | static __inline int __sputc(int _c, FILE *_p) { | |||
392 | if (--_p->_w >= 0 || (_p->_w >= _p->_lbfsize && (char)_c != '\n')) | |||
| ||||
393 | return (*_p->_p++ = _c); | |||
394 | else | |||
395 | return (__swbuf(_c, _p)); | |||
396 | } | |||
397 | ||||
398 | #define __sfeof(p)(((p)->_flags & 0x0020) != 0) (((p)->_flags & __SEOF0x0020) != 0) | |||
399 | #define __sferror(p)(((p)->_flags & 0x0040) != 0) (((p)->_flags & __SERR0x0040) != 0) | |||
400 | #define __sclearerr(p)((void)((p)->_flags &= ~(0x0040|0x0020))) ((void)((p)->_flags &= ~(__SERR0x0040|__SEOF0x0020))) | |||
401 | #define __sfileno(p)((p)->_file) ((p)->_file) | |||
402 | ||||
403 | extern int __isthreaded; | |||
404 | ||||
405 | #define feof(p)(!__isthreaded ? (((p)->_flags & 0x0020) != 0) : (feof )(p)) (!__isthreaded ? __sfeof(p)(((p)->_flags & 0x0020) != 0) : (feof)(p)) | |||
406 | #define ferror(p)(!__isthreaded ? (((p)->_flags & 0x0040) != 0) : (ferror )(p)) (!__isthreaded ? __sferror(p)(((p)->_flags & 0x0040) != 0) : (ferror)(p)) | |||
407 | #define clearerr(p)(!__isthreaded ? ((void)((p)->_flags &= ~(0x0040|0x0020 ))) : (clearerr)(p)) (!__isthreaded ? __sclearerr(p)((void)((p)->_flags &= ~(0x0040|0x0020))) : (clearerr)(p)) | |||
408 | ||||
409 | #if __POSIX_VISIBLE200809 | |||
410 | #define fileno(p)(!__isthreaded ? ((p)->_file) : (fileno)(p)) (!__isthreaded ? __sfileno(p)((p)->_file) : (fileno)(p)) | |||
411 | #endif | |||
412 | ||||
413 | #define getc(fp)(!__isthreaded ? (--(fp)->_r < 0 ? __srget(fp) : (int)( *(fp)->_p++)) : (getc)(fp)) (!__isthreaded ? __sgetc(fp)(--(fp)->_r < 0 ? __srget(fp) : (int)(*(fp)->_p++)) : (getc)(fp)) | |||
414 | ||||
415 | #if __BSD_VISIBLE1 | |||
416 | /* | |||
417 | * The macro implementations of putc and putc_unlocked are not | |||
418 | * fully POSIX compliant; they do not set errno on failure | |||
419 | */ | |||
420 | #define putc(x, fp)(!__isthreaded ? __sputc(x, fp) : (putc)(x, fp)) (!__isthreaded ? __sputc(x, fp) : (putc)(x, fp)) | |||
421 | #endif /* __BSD_VISIBLE */ | |||
422 | ||||
423 | #if __POSIX_VISIBLE200809 >= 199506 | |||
424 | #define getc_unlocked(fp)(--(fp)->_r < 0 ? __srget(fp) : (int)(*(fp)->_p++)) __sgetc(fp)(--(fp)->_r < 0 ? __srget(fp) : (int)(*(fp)->_p++)) | |||
425 | /* | |||
426 | * The macro implementations of putc and putc_unlocked are not | |||
427 | * fully POSIX compliant; they do not set errno on failure | |||
428 | */ | |||
429 | #if __BSD_VISIBLE1 | |||
430 | #define putc_unlocked(x, fp)__sputc(x, fp) __sputc(x, fp) | |||
431 | #endif /* __BSD_VISIBLE */ | |||
432 | #endif /* __POSIX_VISIBLE >= 199506 */ | |||
433 | ||||
434 | #define getchar()(!__isthreaded ? (--((&__sF[0]))->_r < 0 ? __srget( (&__sF[0])) : (int)(*((&__sF[0]))->_p++)) : (getc) ((&__sF[0]))) getc(stdin)(!__isthreaded ? (--((&__sF[0]))->_r < 0 ? __srget( (&__sF[0])) : (int)(*((&__sF[0]))->_p++)) : (getc) ((&__sF[0]))) | |||
435 | #define putchar(x)(!__isthreaded ? __sputc(x, (&__sF[1])) : (putc)(x, (& __sF[1]))) putc(x, stdout)(!__isthreaded ? __sputc(x, (&__sF[1])) : (putc)(x, (& __sF[1]))) | |||
436 | #define getchar_unlocked()(--((&__sF[0]))->_r < 0 ? __srget((&__sF[0])) : (int)(*((&__sF[0]))->_p++)) getc_unlocked(stdin)(--((&__sF[0]))->_r < 0 ? __srget((&__sF[0])) : (int)(*((&__sF[0]))->_p++)) | |||
437 | #define putchar_unlocked(c)__sputc(c, (&__sF[1])) putc_unlocked(c, stdout)__sputc(c, (&__sF[1])) | |||
438 | ||||
439 | #endif /* _STDIO_H_ */ |