Drop hurd specific dependency on libc0.3 (>= 2.3.2.ds1-12). It is
[sysvinit.git] / src / utmpdump.c
1 /*
2 * utmpdump Simple program to dump UTMP and WTMP files in
3 * raw format, so they can be examined.
4 *
5 * Author: Miquel van Smoorenburg, <miquels@cistron.nl>
6 * Danek Duvall <duvall@alumni.princeton.edu>
7 *
8 * Version: @(#)utmpdump 2.79 12-Sep-2000
9 *
10 * This file is part of the sysvinit suite,
11 * Copyright (C) 1991-2000 Miquel van Smoorenburg.
12 *
13 * Additional Copyright on this file 1998 Danek Duvall.
14 *
15 * This program is free software; you can redistribute it and/or modify
16 * it under the terms of the GNU General Public License as published by
17 * the Free Software Foundation; either version 2 of the License, or
18 * (at your option) any later version.
19 *
20 * This program is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 * GNU General Public License for more details.
24 *
25 * You should have received a copy of the GNU General Public License
26 * along with this program; if not, write to the Free Software
27 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
28 */
29
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <utmp.h>
34 #include <time.h>
35 #include <ctype.h>
36 #include <unistd.h>
37 #include <netinet/in.h>
38 #include <arpa/inet.h>
39 #include "oldutmp.h"
40
41 struct utmp
42 oldtonew(struct oldutmp src)
43 {
44 struct utmp dest;
45
46 memset(&dest, 0, sizeof dest);
47 dest.ut_type = src.ut_type;
48 dest.ut_pid = src.ut_pid;
49 dest.ut_time = src.ut_oldtime;
50 dest.ut_addr = src.ut_oldaddr;
51 strncpy(dest.ut_id, src.ut_id, 4);
52 strncpy(dest.ut_line, src.ut_line, OLD_LINESIZE);
53 strncpy(dest.ut_user, src.ut_user, OLD_NAMESIZE);
54 strncpy(dest.ut_host, src.ut_host, OLD_HOSTSIZE);
55
56 return dest;
57 }
58
59 struct oldutmp
60 newtoold(struct utmp src)
61 {
62 struct oldutmp dest;
63
64 memset(&dest, 0, sizeof dest);
65 dest.ut_type = src.ut_type;
66 dest.ut_pid = src.ut_pid;
67 dest.ut_oldtime = src.ut_time;
68 dest.ut_oldaddr = src.ut_addr;
69 strncpy(dest.ut_id, src.ut_id, 4);
70 strncpy(dest.ut_line, src.ut_line, OLD_LINESIZE);
71 strncpy(dest.ut_user, src.ut_user, OLD_NAMESIZE);
72 strncpy(dest.ut_host, src.ut_host, OLD_HOSTSIZE);
73
74 return dest;
75 }
76
77 char *
78 timetostr(const time_t time)
79 {
80 static char s[29]; /* [Sun Sep 01 00:00:00 1998 PST] */
81
82 if (time != 0)
83 strftime(s, 29, "%a %b %d %T %Y %Z", localtime(&time));
84 else
85 s[0] = '\0';
86
87 return s;
88 }
89
90 time_t
91 strtotime(const char *s_time)
92 {
93 struct tm tm;
94
95 memset(&tm, '\0', sizeof(struct tm));
96
97 if (s_time[0] == ' ' || s_time[0] == '\0')
98 return (time_t)0;
99
100 strptime(s_time, "%a %b %d %T %Y", &tm);
101
102 /* Cheesy way of checking for DST */
103 if (s_time[26] == 'D')
104 tm.tm_isdst = 1;
105
106 return mktime(&tm);
107 }
108
109 #define cleanse(x) xcleanse(x, sizeof(x))
110 void
111 xcleanse(char *s, int len)
112 {
113 for ( ; *s && len-- > 0; s++)
114 if (!isprint(*s) || *s == '[' || *s == ']')
115 *s = '?';
116 }
117
118 void
119 unspace(char *s, int len)
120 {
121 while (*s && *s != ' ' && len--)
122 ++s;
123
124 if (len > 0)
125 *s = '\0';
126 }
127
128 void
129 print_utline(struct utmp ut)
130 {
131 char *addr_string, *time_string;
132 struct in_addr in;
133
134 in.s_addr = ut.ut_addr;
135 addr_string = inet_ntoa(in);
136 time_string = timetostr(ut.ut_time);
137 cleanse(ut.ut_id);
138 cleanse(ut.ut_user);
139 cleanse(ut.ut_line);
140 cleanse(ut.ut_host);
141
142 /* pid id user line host addr time */
143 printf("[%d] [%05d] [%-4.4s] [%-*.*s] [%-*.*s] [%-*.*s] [%-15.15s] [%-28.28s]\n",
144 ut.ut_type, ut.ut_pid, ut.ut_id, 8, UT_NAMESIZE, ut.ut_user,
145 12, UT_LINESIZE, ut.ut_line, 20, UT_HOSTSIZE, ut.ut_host,
146 addr_string, time_string);
147 }
148
149 void
150 dump(FILE *fp, int forever, int oldfmt)
151 {
152 struct utmp ut;
153 struct oldutmp uto;
154
155 if (forever)
156 fseek(fp, -10 * (oldfmt ? sizeof uto : sizeof ut), SEEK_END);
157
158 do {
159 if (oldfmt)
160 while (fread(&uto, sizeof uto, 1, fp) == 1)
161 print_utline(oldtonew(uto));
162 else
163 while (fread(&ut, sizeof ut, 1, fp) == 1)
164 print_utline(ut);
165 if (forever) sleep(1);
166 } while (forever);
167 }
168
169 /* This function won't work properly if there's a ']' or a ' ' in the real
170 * token. Thankfully, this should never happen. */
171 int
172 gettok(char *line, char *dest, int size, int eatspace)
173 {
174 int bpos, epos, eaten;
175 char *t;
176
177 bpos = strchr(line, '[') - line;
178 if (bpos < 0) {
179 fprintf(stderr, "Extraneous newline in file. Exiting.");
180 exit(1);
181 }
182 line += 1 + bpos;
183
184 epos = strchr(line, ']') - line;
185 if (epos < 0) {
186 fprintf(stderr, "Extraneous newline in file. Exiting.");
187 exit(1);
188 }
189 line[epos] = '\0';
190
191 eaten = bpos + epos + 1;
192
193 if (eatspace)
194 if ((t = strchr(line, ' ')))
195 *t = 0;
196
197 strncpy(dest, line, size);
198
199 return eaten + 1;
200 }
201
202 void
203 undump(FILE *fp, int forever, int oldfmt)
204 {
205 struct utmp ut;
206 struct oldutmp uto;
207 char s_addr[16], s_time[29], *linestart, *line;
208 int count = 0;
209
210 line = linestart = malloc(1024 * sizeof *linestart);
211 s_addr[15] = 0;
212 s_time[28] = 0;
213
214 while(fgets(linestart, 1023, fp))
215 {
216 line = linestart;
217 memset(&ut, '\0', sizeof(ut));
218 sscanf(line, "[%hd] [%d] [%4c] ", &ut.ut_type, &ut.ut_pid, ut.ut_id);
219
220 line += 19;
221 line += gettok(line, ut.ut_user, sizeof(ut.ut_user), 1);
222 line += gettok(line, ut.ut_line, sizeof(ut.ut_line), 1);
223 line += gettok(line, ut.ut_host, sizeof(ut.ut_host), 1);
224 line += gettok(line, s_addr, sizeof(s_addr)-1, 1);
225 line += gettok(line, s_time, sizeof(s_time)-1, 0);
226
227 ut.ut_addr = inet_addr(s_addr);
228 ut.ut_time = strtotime(s_time);
229
230 if (oldfmt) {
231 uto = newtoold(ut);
232 fwrite(&uto, sizeof(uto), 1, stdout);
233 } else
234 fwrite(&ut, sizeof(ut), 1, stdout);
235
236 ++count;
237 }
238
239 free(linestart);
240 }
241
242 void
243 usage(int result)
244 {
245 printf("Usage: utmpdump [ -froh ] [ filename ]\n");
246 exit(result);
247 }
248
249 int main(int argc, char **argv)
250 {
251 int c;
252 FILE *fp;
253 int reverse = 0, forever = 0, oldfmt = 0;
254
255 while ((c = getopt(argc, argv, "froh")) != EOF) {
256 switch (c) {
257 case 'r':
258 reverse = 1;
259 break;
260
261 case 'f':
262 forever = 1;
263 break;
264
265 case 'o':
266 oldfmt = 1;
267 break;
268
269 case 'h':
270 usage(0);
271 break;
272
273 default:
274 usage(1);
275 }
276 }
277
278 if (optind < argc) {
279 fprintf(stderr, "Utmp %sdump of %s\n", reverse ? "un" : "", argv[optind]);
280 if ((fp = fopen(argv[optind], "r")) == NULL) {
281 perror("Unable to open file");
282 exit(1);
283 }
284 }
285 else {
286 fprintf(stderr, "Utmp %sdump of stdin\n", reverse ? "un" : "");
287 fp = stdin;
288 }
289
290 if (reverse)
291 undump(fp, forever, oldfmt);
292 else
293 dump(fp, forever, oldfmt);
294
295 fclose(fp);
296
297 return 0;
298 }