In xl_list_tx_init_90xB()
[dragonfly.git] / libexec / rpc.rusersd / rusers_proc.c
1 /*-
2  * Copyright (c) 1993, John Brezak
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *      This product includes software developed by the University of
16  *      California, Berkeley and its contributors.
17  * 4. 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  * $FreeBSD: src/libexec/rpc.rusersd/rusers_proc.c,v 1.10 1999/08/28 00:09:56 peter Exp $
34  * $DragonFly: src/libexec/rpc.rusersd/rusers_proc.c,v 1.3 2004/02/13 03:49:48 dillon Exp $
35  */
36
37 #ifdef DEBUG
38 #include <errno.h>
39 #endif
40 #include <stdio.h>
41 #include <string.h>
42 #include <sys/param.h>
43 #include <sys/stat.h>
44 #include <syslog.h>
45 #include <utmp.h>
46 #ifdef XIDLE
47 #include <setjmp.h>
48 #include <X11/Xlib.h>
49 #include <X11/extensions/xidle.h>
50 #endif
51 #define utmp rutmp
52 #include <rpcsvc/rnusers.h>
53 #undef utmp
54
55 #define IGNOREUSER      "sleeper"
56
57 #ifdef OSF
58 #define _PATH_UTMP UTMP_FILE
59 #endif
60
61 #ifndef _PATH_UTMP
62 #define _PATH_UTMP "/etc/utmp"
63 #endif
64
65 #ifndef _PATH_DEV
66 #define _PATH_DEV "/dev"
67 #endif
68
69 #ifndef UT_LINESIZE
70 #define UT_LINESIZE sizeof(((struct utmp *)0)->ut_line)
71 #endif
72 #ifndef UT_NAMESIZE
73 #define UT_NAMESIZE sizeof(((struct utmp *)0)->ut_name)
74 #endif
75 #ifndef UT_HOSTSIZE
76 #define UT_HOSTSIZE sizeof(((struct utmp *)0)->ut_host)
77 #endif
78
79 typedef char ut_line_t[UT_LINESIZE+1];
80 typedef char ut_name_t[UT_NAMESIZE+1];
81 typedef char ut_host_t[UT_HOSTSIZE+1];
82
83 utmpidle utmp_idle[MAXUSERS];
84 rutmp old_utmp[MAXUSERS];
85 ut_line_t line[MAXUSERS];
86 ut_name_t name[MAXUSERS];
87 ut_host_t host[MAXUSERS];
88
89 extern int from_inetd;
90
91 FILE *ufp;
92
93 #ifdef XIDLE
94 Display *dpy;
95
96 static jmp_buf openAbort;
97
98 static void
99 abortOpen ()
100 {
101     longjmp (openAbort, 1);
102 }
103
104 XqueryIdle(char *display)
105 {
106         int first_event, first_error;
107         Time IdleTime;
108
109         (void) signal (SIGALRM, abortOpen);
110         (void) alarm ((unsigned) 10);
111         if (!setjmp (openAbort)) {
112                 if (!(dpy= XOpenDisplay(display))) {
113                         syslog(LOG_ERR, "Cannot open display %s", display);
114                         return(-1);
115                 }
116                 if (XidleQueryExtension(dpy, &first_event, &first_error)) {
117                         if (!XGetIdleTime(dpy, &IdleTime)) {
118                                 syslog(LOG_ERR, "%s: unable to get idle time", display);
119                                 return(-1);
120                         }
121                 }
122                 else {
123                         syslog(LOG_ERR, "%s: Xidle extension not loaded", display);
124                         return(-1);
125                 }
126                 XCloseDisplay(dpy);
127         }
128         else {
129                 syslog(LOG_ERR, "%s: server grabbed for over 10 seconds", display);
130                 return(-1);
131         }
132         (void) signal (SIGALRM, SIG_DFL);
133         (void) alarm ((unsigned) 0);
134
135         IdleTime /= 1000;
136         return((IdleTime + 30) / 60);
137 }
138 #endif
139
140 static u_int
141 getidle(char *tty, char *display)
142 {
143         struct stat st;
144         char devname[PATH_MAX];
145         time_t now;
146         u_long idle;
147
148         /*
149          * If this is an X terminal or console, then try the
150          * XIdle extension
151          */
152 #ifdef XIDLE
153         if (display && *display && (idle = XqueryIdle(display)) >= 0)
154                 return(idle);
155 #endif
156         idle = 0;
157         if (*tty == 'X') {
158                 u_long kbd_idle, mouse_idle;
159 #if !defined(__DragonFly__) && !defined(__FreeBSD__)
160                 kbd_idle = getidle("kbd", NULL);
161 #else
162                 kbd_idle = getidle("vga", NULL);
163 #endif
164                 mouse_idle = getidle("mouse", NULL);
165                 idle = (kbd_idle < mouse_idle)?kbd_idle:mouse_idle;
166         }
167         else {
168                 sprintf(devname, "%s/%s", _PATH_DEV, tty);
169                 if (stat(devname, &st) < 0) {
170 #ifdef DEBUG
171                         printf("%s: %s\n", devname, strerror(errno));
172 #endif
173                         return(-1);
174                 }
175                 time(&now);
176 #ifdef DEBUG
177                 printf("%s: now=%d atime=%d\n", devname, now,
178                        st.st_atime);
179 #endif
180                 idle = now - st.st_atime;
181                 idle = (idle + 30) / 60; /* secs->mins */
182         }
183         if (idle < 0) idle = 0;
184
185         return(idle);
186 }
187
188 static utmpidlearr *
189 do_names_2(int all)
190 {
191         static utmpidlearr ut;
192         struct utmp usr;
193         int nusers = 0;
194
195         bzero((char *)&ut, sizeof(ut));
196         ut.utmpidlearr_val = &utmp_idle[0];
197
198         ufp = fopen(_PATH_UTMP, "r");
199         if (!ufp) {
200                 syslog(LOG_ERR, "%m");
201                 return(&ut);
202         }
203
204         /* only entries with both name and line fields */
205         while (fread((char *)&usr, sizeof(usr), 1, ufp) == 1 &&
206                nusers < MAXUSERS)
207                 if (*usr.ut_name && *usr.ut_line &&
208                     strncmp(usr.ut_name, IGNOREUSER,
209                             sizeof(usr.ut_name))
210 #ifdef OSF
211                     && usr.ut_type == USER_PROCESS
212 #endif
213                     ) {
214                         utmp_idle[nusers].ui_utmp.ut_time =
215                                 usr.ut_time;
216                         utmp_idle[nusers].ui_idle =
217                                 getidle(usr.ut_line, usr.ut_host);
218                         utmp_idle[nusers].ui_utmp.ut_line = line[nusers];
219                         strncpy(line[nusers], usr.ut_line, UT_LINESIZE);
220                         utmp_idle[nusers].ui_utmp.ut_name = name[nusers];
221                         strncpy(name[nusers], usr.ut_name, UT_NAMESIZE);
222                         utmp_idle[nusers].ui_utmp.ut_host = host[nusers];
223                         strncpy(host[nusers], usr.ut_host, UT_HOSTSIZE);
224
225                         /* Make sure entries are NUL terminated */
226                         line[nusers][UT_LINESIZE] =
227                         name[nusers][UT_NAMESIZE] =
228                         host[nusers][UT_HOSTSIZE] = '\0';
229                         nusers++;
230                 }
231
232         ut.utmpidlearr_len = nusers;
233         fclose(ufp);
234         return(&ut);
235 }
236
237 int *
238 rusers_num()
239 {
240         static int num_users = 0;
241         struct utmp usr;
242
243         ufp = fopen(_PATH_UTMP, "r");
244         if (!ufp) {
245                 syslog(LOG_ERR, "%m");
246                 return(NULL);
247         }
248
249         /* only entries with both name and line fields */
250         while (fread((char *)&usr, sizeof(usr), 1, ufp) == 1)
251                 if (*usr.ut_name && *usr.ut_line &&
252                     strncmp(usr.ut_name, IGNOREUSER,
253                             sizeof(usr.ut_name))
254 #ifdef OSF
255                     && usr.ut_type == USER_PROCESS
256 #endif
257                     ) {
258                         num_users++;
259                 }
260
261         fclose(ufp);
262         return(&num_users);
263 }
264
265 static utmparr *
266 do_names_1(int all)
267 {
268         utmpidlearr *utidle;
269         static utmparr ut;
270         int i;
271
272         bzero((char *)&ut, sizeof(ut));
273
274         utidle = do_names_2(all);
275         if (utidle) {
276                 ut.utmparr_len = utidle->utmpidlearr_len;
277                 ut.utmparr_val = &old_utmp[0];
278                 for (i = 0; i < ut.utmparr_len; i++)
279                         bcopy(&utmp_idle[i].ui_utmp, &old_utmp[i],
280                               sizeof(old_utmp[0]));
281
282         }
283
284         return(&ut);
285 }
286
287 utmpidlearr *
288 rusersproc_names_2_svc(argp, rqstp)
289         void                    *argp;
290         struct svc_req          *rqstp;
291 {
292         return(do_names_2(0));
293 }
294
295 utmpidlearr *
296 rusersproc_allnames_2_svc(argp, rqstp)
297         void                    *argp;
298         struct svc_req          *rqstp;
299 {
300         return(do_names_2(1));
301 }
302
303 utmparr *
304 rusersproc_names_1_svc(argp, rqstp)
305         void                    *argp;
306         struct svc_req          *rqstp;
307 {
308         return(do_names_1(0));
309 }
310
311 utmparr *
312 rusersproc_allnames_1_svc(argp, rqstp)
313         void                    *argp;
314         struct svc_req          *rqstp;
315 {
316         return(do_names_1(1));
317 }
318
319 void
320 rusers_service(rqstp, transp)
321         struct svc_req *rqstp;
322         SVCXPRT *transp;
323 {
324         union {
325                 int fill;
326         } argument;
327         char *result;
328         bool_t (*xdr_argument)(), (*xdr_result)();
329         char *(*local)();
330
331         switch (rqstp->rq_proc) {
332         case NULLPROC:
333                 (void)svc_sendreply(transp, xdr_void, (char *)NULL);
334                 goto leave;
335
336         case RUSERSPROC_NUM:
337                 xdr_argument = xdr_void;
338                 xdr_result = xdr_int;
339                 local = (char *(*)()) rusers_num;
340                 break;
341
342         case RUSERSPROC_NAMES:
343                 xdr_argument = xdr_void;
344                 xdr_result = xdr_utmpidlearr;
345                 switch (rqstp->rq_vers) {
346                 case RUSERSVERS_ORIG:
347                         local = (char *(*)()) rusersproc_names_1_svc;
348                         break;
349                 case RUSERSVERS_IDLE:
350                         local = (char *(*)()) rusersproc_names_2_svc;
351                         break;
352                 default:
353                         svcerr_progvers(transp, RUSERSVERS_ORIG, RUSERSVERS_IDLE);
354                         goto leave;
355                         /*NOTREACHED*/
356                 }
357                 break;
358
359         case RUSERSPROC_ALLNAMES:
360                 xdr_argument = xdr_void;
361                 xdr_result = xdr_utmpidlearr;
362                 switch (rqstp->rq_vers) {
363                 case RUSERSVERS_ORIG:
364                         local = (char *(*)()) rusersproc_allnames_1_svc;
365                         break;
366                 case RUSERSVERS_IDLE:
367                         local = (char *(*)()) rusersproc_allnames_2_svc;
368                         break;
369                 default:
370                         svcerr_progvers(transp, RUSERSVERS_ORIG, RUSERSVERS_IDLE);
371                         goto leave;
372                         /*NOTREACHED*/
373                 }
374                 break;
375
376         default:
377                 svcerr_noproc(transp);
378                 goto leave;
379         }
380         bzero((char *)&argument, sizeof(argument));
381         if (!svc_getargs(transp, xdr_argument, (caddr_t)&argument)) {
382                 svcerr_decode(transp);
383                 goto leave;
384         }
385         result = (*local)(&argument, rqstp);
386         if (result != NULL && !svc_sendreply(transp, xdr_result, result)) {
387                 svcerr_systemerr(transp);
388         }
389         if (!svc_freeargs(transp, xdr_argument, (caddr_t)&argument)) {
390                 syslog(LOG_ERR, "unable to free arguments");
391                 exit(1);
392         }
393 leave:
394         if (from_inetd)
395                 exit(0);
396 }