Annotation of embedaddon/sudo/src/utmp.c, revision 1.1.1.1
1.1 misho 1: /*
2: * Copyright (c) 2011 Todd C. Miller <Todd.Miller@courtesan.com>
3: *
4: * Permission to use, copy, modify, and distribute this software for any
5: * purpose with or without fee is hereby granted, provided that the above
6: * copyright notice and this permission notice appear in all copies.
7: *
8: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15: */
16:
17: #include <config.h>
18:
19: #include <sys/types.h>
20: #include <sys/param.h>
21: #include <sys/time.h>
22: #include <sys/wait.h>
23: #include <stdio.h>
24: #ifdef STDC_HEADERS
25: # include <stdlib.h>
26: # include <stddef.h>
27: #else
28: # ifdef HAVE_STDLIB_H
29: # include <stdlib.h>
30: # endif
31: #endif /* STDC_HEADERS */
32: #ifdef HAVE_STRING_H
33: # if defined(HAVE_MEMORY_H) && !defined(STDC_HEADERS)
34: # include <memory.h>
35: # endif
36: # include <string.h>
37: #endif /* HAVE_STRING_H */
38: #ifdef HAVE_STRINGS_H
39: # include <strings.h>
40: #endif /* HAVE_STRINGS_H */
41: #ifdef HAVE_UNISTD_H
42: # include <unistd.h>
43: #endif /* HAVE_UNISTD_H */
44: #if TIME_WITH_SYS_TIME
45: # include <time.h>
46: #endif
47: #ifdef HAVE_UTMPX_H
48: # include <utmpx.h>
49: #else
50: # include <utmp.h>
51: #endif /* HAVE_UTMPX_H */
52: #ifdef HAVE_GETTTYENT
53: # include <ttyent.h>
54: #endif
55: #include <fcntl.h>
56:
57: #include "sudo.h"
58: #include "sudo_exec.h"
59:
60: /*
61: * Simplify handling of utmp vs. utmpx
62: */
63: #if !defined(HAVE_GETUTXID) && defined(HAVE_GETUTID)
64: # define getutxline(u) getutline(u)
65: # define pututxline(u) pututline(u)
66: # define setutxent setutent(u)
67: # define endutxent endutent(u)
68: #endif /* !HAVE_GETUTXID && HAVE_GETUTID */
69:
70: #ifdef HAVE_GETUTXID
71: typedef struct utmpx sudo_utmp_t;
72: #else
73: typedef struct utmp sudo_utmp_t;
74: /* Older systems have ut_name, not us_user */
75: # if !defined(HAVE_STRUCT_UTMP_UT_USER) && !defined(ut_user)
76: # define ut_user ut_name
77: # endif
78: #endif
79:
80: /* HP-UX has __e_termination and __e_exit, others lack the __ */
81: #if defined(HAVE_STRUCT_UTMPX_UT_EXIT_E_TERMINATION) || defined(HAVE_STRUCT_UTMP_UT_EXIT_E_TERMINATION)
82: # undef __e_termination
83: # define __e_termination e_termination
84: # undef __e_exit
85: # define __e_exit e_exit
86: #endif
87:
88: #if defined(HAVE_GETUTXID) || defined(HAVE_GETUTID)
89: /*
90: * Create ut_id from the new ut_line and the old ut_id.
91: */
92: static void
93: utmp_setid(sudo_utmp_t *old, sudo_utmp_t *new)
94: {
95: const char *line = new->ut_line;
96: size_t idlen;
97:
98: /* Skip over "tty" in the id if old entry did too. */
99: if (old != NULL) {
100: if (strncmp(line, "tty", 3) == 0) {
101: idlen = MIN(sizeof(old->ut_id), 3);
102: if (strncmp(old->ut_id, "tty", idlen) != 0)
103: line += 3;
104: }
105: }
106:
107: /* Store as much as will fit, skipping parts of the beginning as needed. */
108: idlen = strlen(line);
109: if (idlen > sizeof(new->ut_id)) {
110: line += idlen - sizeof(new->ut_id);
111: idlen = sizeof(new->ut_id);
112: }
113: strncpy(new->ut_id, line, idlen);
114: }
115: #endif /* HAVE_GETUTXID || HAVE_GETUTID */
116:
117: /*
118: * Store time in utmp structure.
119: */
120: static void
121: utmp_settime(sudo_utmp_t *ut)
122: {
123: struct timeval tv;
124:
125: gettimeofday(&tv, NULL);
126:
127: #if defined(HAVE_STRUCT_UTMP_UT_TV) || defined(HAVE_STRUCT_UTMPX_UT_TV)
128: ut->ut_tv.tv_sec = tv.tv_sec;
129: ut->ut_tv.tv_usec = tv.tv_usec;
130: #else
131: ut->ut_time = tv.tv_sec;
132: #endif
133: }
134:
135: /*
136: * Fill in a utmp entry, using an old entry as a template if there is one.
137: */
138: static void
139: utmp_fill(const char *line, const char *user, sudo_utmp_t *ut_old,
140: sudo_utmp_t *ut_new)
141: {
142: if (ut_old == NULL) {
143: memset(ut_new, 0, sizeof(*ut_new));
144: if (user == NULL) {
145: strncpy(ut_new->ut_user, user_details.username,
146: sizeof(ut_new->ut_user));
147: }
148: } else if (ut_old != ut_new) {
149: memcpy(ut_new, ut_old, sizeof(*ut_new));
150: }
151: if (user != NULL)
152: strncpy(ut_new->ut_user, user, sizeof(ut_new->ut_user));
153: strncpy(ut_new->ut_line, line, sizeof(ut_new->ut_line));
154: #if defined(HAVE_STRUCT_UTMPX_UT_ID) || defined(HAVE_STRUCT_UTMP_UT_ID)
155: utmp_setid(ut_old, ut_new);
156: #endif
157: #if defined(HAVE_STRUCT_UTMPX_UT_PID) || defined(HAVE_STRUCT_UTMP_UT_PID)
158: ut_new->ut_pid = getpid();
159: #endif
160: utmp_settime(ut_new);
161: #if defined(HAVE_STRUCT_UTMPX_UT_TYPE) || defined(HAVE_STRUCT_UTMP_UT_TYPE)
162: ut_new->ut_type = USER_PROCESS;
163: #endif
164: }
165:
166: /*
167: * There are two basic utmp file types:
168: *
169: * POSIX: sequential access with new entries appended to the end.
170: * Manipulated via {get,put}utent()/{get,put}getutxent().
171: *
172: * Legacy: sparse file indexed by ttyslot() * sizeof(struct utmp)
173: */
174: #if defined(HAVE_GETUTXID) || defined(HAVE_GETUTID)
175: int
176: utmp_login(const char *from_line, const char *to_line, int ttyfd,
177: const char *user)
178: {
179: sudo_utmp_t utbuf, *ut_old = NULL;
180: int rval = FALSE;
181:
182: /* Strip off /dev/ prefix from line as needed. */
183: if (strncmp(to_line, _PATH_DEV, sizeof(_PATH_DEV) - 1) == 0)
184: to_line += sizeof(_PATH_DEV) - 1;
185: setutxent();
186: if (from_line != NULL) {
187: if (strncmp(from_line, _PATH_DEV, sizeof(_PATH_DEV) - 1) == 0)
188: from_line += sizeof(_PATH_DEV) - 1;
189:
190: /* Lookup old line. */
191: memset(&utbuf, 0, sizeof(utbuf));
192: strncpy(utbuf.ut_line, from_line, sizeof(utbuf.ut_line));
193: ut_old = getutxline(&utbuf);
194: }
195: utmp_fill(to_line, user, ut_old, &utbuf);
196: if (pututxline(&utbuf) != NULL)
197: rval = TRUE;
198: endutxent();
199:
200: return rval;
201: }
202:
203: int
204: utmp_logout(const char *line, int status)
205: {
206: int rval = FALSE;
207: sudo_utmp_t *ut, utbuf;
208:
209: /* Strip off /dev/ prefix from line as needed. */
210: if (strncmp(line, _PATH_DEV, sizeof(_PATH_DEV) - 1) == 0)
211: line += sizeof(_PATH_DEV) - 1;
212:
213: memset(&utbuf, 0, sizeof(utbuf));
214: strncpy(utbuf.ut_line, line, sizeof(utbuf.ut_line));
215: if ((ut = getutxline(&utbuf)) != NULL) {
216: memset(ut->ut_user, 0, sizeof(ut->ut_user));
217: # if defined(HAVE_STRUCT_UTMPX_UT_TYPE) || defined(HAVE_STRUCT_UTMP_UT_TYPE)
218: ut->ut_type = DEAD_PROCESS;
219: # endif
220: # if defined(HAVE_STRUCT_UTMPX_UT_EXIT) || defined(HAVE_STRUCT_UTMP_UT_EXIT)
221: ut->ut_exit.__e_exit = WEXITSTATUS(status);
222: ut->ut_exit.__e_termination = WIFEXITED(status) ? WEXITSTATUS(status) : 0;
223: # endif
224: utmp_settime(ut);
225: if (pututxline(ut) != NULL)
226: rval = TRUE;
227: }
228: return rval;
229: }
230:
231: #else /* !HAVE_GETUTXID && !HAVE_GETUTID */
232:
233: /*
234: * Find the slot for the specified line (tty name and file descriptor).
235: * Returns a slot suitable for seeking into utmp on success or <= 0 on error.
236: * If getttyent() is available we can use that to compute the slot.
237: */
238: # ifdef HAVE_GETTTYENT
239: static int
240: utmp_slot(const char *line, int ttyfd)
241: {
242: int slot = 1;
243: struct ttyent *tty;
244:
245: setttyent();
246: while ((tty = getttyent()) != NULL) {
247: if (strcmp(line, tty->ty_name) == 0)
248: break;
249: slot++;
250: }
251: endttyent();
252: return tty ? slot : 0;
253: }
254: # else
255: static int
256: utmp_slot(const char *line, int ttyfd)
257: {
258: int sfd, slot;
259:
260: /*
261: * Temporarily point stdin to the tty since ttyslot()
262: * doesn't take an argument.
263: */
264: if ((sfd = dup(STDIN_FILENO)) == -1)
265: error(1, _("unable to save stdin"));
266: if (dup2(ttyfd, STDIN_FILENO) == -1)
267: error(1, _("unable to dup2 stdin"));
268: slot = ttyslot();
269: if (dup2(sfd, STDIN_FILENO) == -1)
270: error(1, _("unable to restore stdin"));
271: close(sfd);
272:
273: return slot;
274: }
275: # endif /* HAVE_GETTTYENT */
276:
277: int
278: utmp_login(const char *from_line, const char *to_line, int ttyfd,
279: const char *user)
280: {
281: sudo_utmp_t utbuf, *ut_old = NULL;
282: int slot, rval = FALSE;
283: FILE *fp;
284:
285: /* Strip off /dev/ prefix from line as needed. */
286: if (strncmp(to_line, _PATH_DEV, sizeof(_PATH_DEV) - 1) == 0)
287: to_line += sizeof(_PATH_DEV) - 1;
288:
289: /* Find slot for new entry. */
290: slot = utmp_slot(to_line, ttyfd);
291: if (slot <= 0)
292: goto done;
293:
294: if ((fp = fopen(_PATH_UTMP, "r+")) == NULL)
295: goto done;
296:
297: if (from_line != NULL) {
298: if (strncmp(from_line, _PATH_DEV, sizeof(_PATH_DEV) - 1) == 0)
299: from_line += sizeof(_PATH_DEV) - 1;
300:
301: /* Lookup old line. */
302: while (fread(&utbuf, sizeof(utbuf), 1, fp) == 1) {
303: # ifdef HAVE_STRUCT_UTMP_UT_ID
304: if (utbuf.ut_type != LOGIN_PROCESS && utbuf.ut_type != USER_PROCESS)
305: continue;
306: # endif
307: if (utbuf.ut_user[0] &&
308: !strncmp(utbuf.ut_line, from_line, sizeof(utbuf.ut_line))) {
309: ut_old = &utbuf;
310: break;
311: }
312: }
313: }
314: utmp_fill(to_line, user, ut_old, &utbuf);
315: if (fseek(fp, slot * (long)sizeof(utbuf), SEEK_SET) == 0) {
316: if (fwrite(&utbuf, sizeof(utbuf), 1, fp) == 1)
317: rval = TRUE;
318: }
319: fclose(fp);
320:
321: done:
322: return rval;
323: }
324:
325: int
326: utmp_logout(const char *line, int status)
327: {
328: sudo_utmp_t utbuf;
329: int rval = FALSE;
330: FILE *fp;
331:
332: if ((fp = fopen(_PATH_UTMP, "r+")) == NULL)
333: return rval;
334:
335: /* Strip off /dev/ prefix from line as needed. */
336: if (strncmp(line, _PATH_DEV, sizeof(_PATH_DEV) - 1) == 0)
337: line += sizeof(_PATH_DEV) - 1;
338:
339: while (fread(&utbuf, sizeof(utbuf), 1, fp) == 1) {
340: if (!strncmp(utbuf.ut_line, line, sizeof(utbuf.ut_line))) {
341: memset(utbuf.ut_user, 0, sizeof(utbuf.ut_user));
342: # if defined(HAVE_STRUCT_UTMP_UT_TYPE)
343: utbuf.ut_type = DEAD_PROCESS;
344: # endif
345: utmp_settime(&utbuf);
346: /* Back up and overwrite record. */
347: if (fseek(fp, 0L - (long)sizeof(utbuf), SEEK_CUR) == 0) {
348: if (fwrite(&utbuf, sizeof(utbuf), 1, fp) == 1)
349: rval = TRUE;
350: }
351: break;
352: }
353: }
354: fclose(fp);
355:
356: return rval;
357: }
358: #endif /* HAVE_GETUTXID || HAVE_GETUTID */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to utmp.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sudo / src