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