]>
Commit | Line | Data |
---|---|---|
f9ddad59 TT |
1 | /* |
2 | * logsave.c --- A program which saves the output of a program until | |
3 | * /var/log is mounted. | |
4 | * | |
5 | * Copyright (C) 2003 Theodore Ts'o. | |
6 | * | |
7 | * %Begin-Header% | |
8 | * This file may be redistributed under the terms of the GNU Public | |
9 | * License. | |
10 | * %End-Header% | |
11 | */ | |
12 | ||
13 | #include <stdio.h> | |
14 | #include <stdlib.h> | |
15 | #include <unistd.h> | |
16 | #include <string.h> | |
17 | #include <sys/types.h> | |
18 | #include <sys/wait.h> | |
19 | #include <fcntl.h> | |
20 | #include <time.h> | |
21 | #include <errno.h> | |
62653d99 TT |
22 | #ifdef HAVE_SIGNAL_H |
23 | #include <signal.h> | |
24 | #endif | |
f9ddad59 TT |
25 | #ifdef HAVE_GETOPT_H |
26 | #include <getopt.h> | |
27 | #else | |
28 | extern char *optarg; | |
29 | extern int optind; | |
30 | #endif | |
31 | ||
32 | int outfd = -1; | |
33 | int outbufsize = 0; | |
34 | void *outbuf = 0; | |
35 | int verbose = 0; | |
bc34d6be TT |
36 | int do_skip = 0; |
37 | int skip_mode = 0; | |
62653d99 | 38 | pid_t child_pid = -1; |
f9ddad59 TT |
39 | |
40 | static void usage(char *progname) | |
41 | { | |
42 | printf("Usage: %s [-v] [-d dir] logfile program\n", progname); | |
43 | exit(1); | |
44 | } | |
45 | ||
bc34d6be TT |
46 | #define SEND_LOG 0x01 |
47 | #define SEND_CONSOLE 0x02 | |
48 | #define SEND_BOTH 0x03 | |
49 | ||
50 | static void send_output(const char *buffer, int c, int flag) | |
f9ddad59 TT |
51 | { |
52 | char *n; | |
53 | ||
54 | if (c == 0) | |
55 | c = strlen(buffer); | |
56 | ||
bc34d6be TT |
57 | if (flag & SEND_CONSOLE) |
58 | write(1, buffer, c); | |
59 | if (!(flag & SEND_LOG)) | |
60 | return; | |
f9ddad59 TT |
61 | if (outfd > 0) |
62 | write(outfd, buffer, c); | |
63 | else { | |
64 | n = realloc(outbuf, outbufsize + c); | |
65 | if (n) { | |
66 | outbuf = n; | |
67 | memcpy(((char *)outbuf)+outbufsize, buffer, c); | |
68 | outbufsize += c; | |
69 | } | |
70 | } | |
71 | } | |
72 | ||
bc34d6be | 73 | static int do_read(int fd) |
f9ddad59 TT |
74 | { |
75 | int c; | |
bc34d6be | 76 | char buffer[4096], *cp, *sep; |
f9ddad59 | 77 | |
bc34d6be TT |
78 | c = read(fd, buffer, sizeof(buffer)-1); |
79 | if (c <= 0) | |
80 | return c; | |
81 | if (do_skip) { | |
82 | send_output(buffer, c, SEND_CONSOLE); | |
83 | buffer[c] = 0; | |
84 | cp = buffer; | |
85 | while (*cp) { | |
86 | if (skip_mode) { | |
87 | cp = strchr(cp, '\002'); | |
88 | if (!cp) | |
89 | return 0; | |
90 | cp++; | |
91 | skip_mode = 0; | |
92 | continue; | |
93 | } | |
94 | sep = strchr(cp, '\001'); | |
95 | if (sep) | |
96 | *sep = 0; | |
97 | send_output(cp, 0, SEND_LOG); | |
98 | if (sep) { | |
99 | cp = sep + 1; | |
100 | skip_mode = 1; | |
101 | } else | |
102 | break; | |
103 | } | |
104 | } else | |
105 | send_output(buffer, c, SEND_BOTH); | |
106 | return c; | |
f9ddad59 TT |
107 | } |
108 | ||
62653d99 TT |
109 | static void signal_term(int sig) |
110 | { | |
111 | if (child_pid > 0) | |
112 | kill(child_pid, sig); | |
113 | } | |
114 | ||
f9ddad59 TT |
115 | static int run_program(char **argv) |
116 | { | |
117 | int fds[2]; | |
f9ddad59 TT |
118 | int status, rc, pid; |
119 | char buffer[80]; | |
62653d99 TT |
120 | #ifdef HAVE_SIGNAL_H |
121 | struct sigaction sa; | |
122 | #endif | |
f9ddad59 TT |
123 | |
124 | if (pipe(fds) < 0) { | |
125 | perror("pipe"); | |
126 | exit(1); | |
127 | } | |
128 | ||
62653d99 TT |
129 | #ifdef HAVE_SIGNAL_H |
130 | memset(&sa, 0, sizeof(struct sigaction)); | |
131 | sa.sa_handler = signal_term; | |
132 | sigaction(SIGINT, &sa, 0); | |
133 | sigaction(SIGTERM, &sa, 0); | |
134 | #ifdef SA_RESTART | |
135 | sa.sa_flags = SA_RESTART; | |
136 | #endif | |
137 | #endif | |
138 | ||
f9ddad59 TT |
139 | pid = fork(); |
140 | if (pid < 0) { | |
141 | perror("vfork"); | |
142 | exit(1); | |
143 | } | |
144 | if (pid == 0) { | |
145 | dup2(fds[1],1); /* fds[1] replaces stdout */ | |
146 | dup2(fds[1],2); /* fds[1] replaces stderr */ | |
147 | close(fds[0]); /* don't need this here */ | |
148 | ||
149 | execvp(argv[0], argv); | |
150 | perror(argv[0]); | |
151 | exit(1); | |
152 | } | |
62653d99 | 153 | child_pid = pid; |
f9ddad59 TT |
154 | close(fds[1]); |
155 | ||
156 | while (!(waitpid(pid, &status, WNOHANG ))) { | |
157 | do_read(fds[0]); | |
158 | } | |
62653d99 | 159 | child_pid = -1; |
f9ddad59 TT |
160 | do_read(fds[0]); |
161 | close(fds[0]); | |
162 | ||
163 | if ( WIFEXITED(status) ) { | |
164 | rc = WEXITSTATUS(status); | |
165 | if (rc) { | |
bc34d6be | 166 | send_output(argv[0], 0, SEND_BOTH); |
5bec5740 | 167 | sprintf(buffer, " died with exit status %d\n", rc); |
bc34d6be | 168 | send_output(buffer, 0, SEND_BOTH); |
f9ddad59 TT |
169 | } |
170 | } else { | |
171 | if (WIFSIGNALED(status)) { | |
bc34d6be | 172 | send_output(argv[0], 0, SEND_BOTH); |
5bec5740 | 173 | sprintf(buffer, "died with signal %d\n", |
f9ddad59 | 174 | WTERMSIG(status)); |
bc34d6be | 175 | send_output(buffer, 0, SEND_BOTH); |
f9ddad59 TT |
176 | rc = 1; |
177 | } | |
178 | rc = 0; | |
179 | } | |
180 | return rc; | |
181 | } | |
182 | ||
183 | static int copy_from_stdin(void) | |
184 | { | |
bc34d6be | 185 | int c, bad_read = 0; |
f9ddad59 TT |
186 | |
187 | while (1) { | |
bc34d6be | 188 | c = do_read(0); |
f9ddad59 TT |
189 | if ((c == 0 ) || |
190 | ((c < 0) && ((errno == EAGAIN) || (errno == EINTR)))) { | |
191 | if (bad_read++ > 3) | |
192 | break; | |
193 | continue; | |
194 | } | |
195 | if (c < 0) { | |
196 | perror("read"); | |
197 | exit(1); | |
198 | } | |
f9ddad59 TT |
199 | bad_read = 0; |
200 | } | |
201 | return 0; | |
202 | } | |
203 | ||
204 | ||
205 | ||
206 | int main(int argc, char **argv) | |
207 | { | |
208 | int c, pid, rc; | |
bc34d6be | 209 | char *outfn, **cpp; |
f9ddad59 | 210 | int openflags = O_CREAT|O_WRONLY|O_TRUNC; |
bc34d6be TT |
211 | int send_flag = SEND_LOG; |
212 | int do_stdin; | |
213 | time_t t; | |
f9ddad59 | 214 | |
bc34d6be | 215 | while ((c = getopt(argc, argv, "+asv")) != EOF) { |
f9ddad59 TT |
216 | switch (c) { |
217 | case 'a': | |
218 | openflags &= ~O_TRUNC; | |
219 | openflags |= O_APPEND; | |
220 | break; | |
bc34d6be TT |
221 | case 's': |
222 | do_skip = 1; | |
223 | break; | |
f9ddad59 TT |
224 | case 'v': |
225 | verbose++; | |
bc34d6be | 226 | send_flag |= SEND_CONSOLE; |
f9ddad59 TT |
227 | break; |
228 | } | |
229 | } | |
230 | if (optind == argc || optind+1 == argc) | |
231 | usage(argv[0]); | |
232 | outfn = argv[optind]; | |
233 | optind++; | |
234 | argv += optind; | |
235 | argc -= optind; | |
236 | ||
bc34d6be TT |
237 | outfd = open(outfn, openflags, 0644); |
238 | do_stdin = !strcmp(argv[0], "-"); | |
239 | ||
240 | send_output("Log of ", 0, send_flag); | |
241 | if (do_stdin) | |
242 | send_output("stdin", 0, send_flag); | |
243 | else { | |
244 | for (cpp = argv; *cpp; cpp++) { | |
245 | send_output(*cpp, 0, send_flag); | |
246 | send_output(" ", 0, send_flag); | |
247 | } | |
248 | } | |
249 | send_output("\n", 0, send_flag); | |
250 | t = time(0); | |
251 | send_output(ctime(&t), 0, send_flag); | |
252 | send_output("\n", 0, send_flag); | |
f9ddad59 | 253 | |
bc34d6be | 254 | if (do_stdin) |
f9ddad59 | 255 | rc = copy_from_stdin(); |
bc34d6be TT |
256 | else |
257 | rc = run_program(argv); | |
f9ddad59 | 258 | |
bc34d6be TT |
259 | send_output("\n", 0, send_flag); |
260 | t = time(0); | |
261 | send_output(ctime(&t), 0, send_flag); | |
262 | send_output("----------------\n", 0, send_flag); | |
263 | ||
f9ddad59 TT |
264 | if (outbuf) { |
265 | pid = fork(); | |
266 | if (pid < 0) { | |
267 | perror("fork"); | |
268 | exit(1); | |
269 | } | |
270 | if (pid) { | |
271 | if (verbose) | |
272 | printf("Backgrounding to save %s later\n", | |
273 | outfn); | |
274 | exit(rc); | |
275 | } | |
5bec5740 | 276 | setsid(); /* To avoid getting killed by init */ |
f9ddad59 | 277 | while (outfd < 0) { |
bc34d6be | 278 | outfd = open(outfn, openflags, 0644); |
f9ddad59 TT |
279 | sleep(1); |
280 | } | |
281 | write(outfd, outbuf, outbufsize); | |
282 | free(outbuf); | |
283 | } | |
284 | close(outfd); | |
285 | ||
286 | exit(rc); | |
287 | } |