bnx: Remove unused code
[dragonfly.git] / contrib / tcsh-6 / tc.who.c
1 /* $Header: /p/tcsh/cvsroot/tcsh/tc.who.c,v 3.51 2006/03/03 22:08:45 amold Exp $ */
2 /*
3  * tc.who.c: Watch logins and logouts...
4  */
5 /*-
6  * Copyright (c) 1980, 1991 The Regents of the University of California.
7  * All rights reserved.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  * 3. 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 #include "sh.h"
34
35 RCSID("$tcsh: tc.who.c,v 3.51 2006/03/03 22:08:45 amold Exp $")
36
37 #include "tc.h"
38
39 #ifndef HAVENOUTMP
40 /*
41  * kfk 26 Jan 1984 - for login watch functions.
42  */
43 #include <ctype.h>
44
45 #ifdef HAVE_UTMPX_H
46 # include <utmpx.h>
47 /* I just redefine a few words here.  Changing every occurrence below
48  * seems like too much of work.  All UTMP functions have equivalent
49  * UTMPX counterparts, so they can be added all here when needed.
50  * Kimmo Suominen, Oct 14 1991
51  */
52 # if defined(__UTMPX_FILE) && !defined(UTMPX_FILE)
53 #  define TCSH_PATH_UTMP __UTMPX_FILE
54 # elif defined(_PATH_UTMPX)
55 #  define TCSH_PATH_UTMP _PATH_UTMPX
56 # elif defined(UTMPX_FILE)
57 #  define TCSH_PATH_UTMP UTMPX_FILE
58 # endif /* __UTMPX_FILE && !UTMPX_FILE */
59 # ifdef TCSH_PATH_UTMP
60 #  define utmp utmpx
61 #  if defined(HAVE_STRUCT_UTMP_UT_TV)
62 #   define ut_time ut_tv.tv_sec
63 #  elif defined(HAVE_STRUCT_UTMP_UT_XTIME)
64 #   define ut_time ut_xtime
65 #  endif
66 #  ifdef HAVE_STRUCT_UTMP_UT_USER
67 #   define ut_name ut_user
68 #  endif
69 #  ifdef HAVE_GETUTENT
70 #   define getutent getutxent
71 #   define setutent setutxent
72 #   define endutent endutxent
73 #  endif /* HAVE_GETUTENT */
74 # else
75 #  ifdef HAVE_UTMP_H
76 #   include <utmp.h>
77 #  endif /* WINNT_NATIVE */
78 # endif /* TCSH_PATH_UTMP */
79 #else /* !HAVE_UTMPX_H */
80 # ifdef HAVE_UTMP_H
81 #  include <utmp.h>
82 # endif /* WINNT_NATIVE */
83 #endif /* HAVE_UTMPX_H */
84
85 #ifndef BROKEN_CC
86 # define UTNAMLEN       sizeof(((struct utmp *) 0)->ut_name)
87 # define UTLINLEN       sizeof(((struct utmp *) 0)->ut_line)
88 # ifdef HAVE_STRUCT_UTMP_UT_HOST
89 #  ifdef _SEQUENT_
90 #   define UTHOSTLEN    100
91 #  else
92 #   define UTHOSTLEN    sizeof(((struct utmp *) 0)->ut_host)
93 #  endif
94 # endif /* HAVE_STRUCT_UTMP_UT_HOST */
95 #else
96 /* give poor cc a little help if it needs it */
97 struct utmp __ut;
98
99 # define UTNAMLEN       sizeof(__ut.ut_name)
100 # define UTLINLEN       sizeof(__ut.ut_line)
101 # ifdef HAVE_STRUCT_UTMP_UT_HOST
102 #  ifdef _SEQUENT_
103 #   define UTHOSTLEN    100
104 #  else
105 #   define UTHOSTLEN    sizeof(__ut.ut_host)
106 #  endif
107 # endif /* HAVE_STRUCT_UTMP_UT_HOST */
108 #endif /* BROKEN_CC */
109
110 #ifndef TCSH_PATH_UTMP
111 # ifdef UTMP_FILE
112 #  define TCSH_PATH_UTMP UTMP_FILE
113 # elif defined(_PATH_UTMP)
114 #  define TCSH_PATH_UTMP _PATH_UTMP
115 # else
116 #  define TCSH_PATH_UTMP "/etc/utmp"
117 # endif /* UTMP_FILE */
118 #endif /* TCSH_PATH_UTMP */
119
120
121 struct who {
122     struct who *who_next;
123     struct who *who_prev;
124     char    who_name[UTNAMLEN + 1];
125     char    who_new[UTNAMLEN + 1];
126     char    who_tty[UTLINLEN + 1];
127 #ifdef HAVE_STRUCT_UTMP_UT_HOST
128     char    who_host[UTHOSTLEN + 1];
129 #endif /* HAVE_STRUCT_UTMP_UT_HOST */
130     time_t  who_time;
131     int     who_status;
132 };
133
134 static struct who whohead, whotail;
135 static time_t watch_period = 0;
136 static time_t stlast = 0;
137 #ifdef WHODEBUG
138 static  void    debugwholist    (struct who *, struct who *);
139 #endif
140 static  void    print_who       (struct who *);
141
142
143 #define ONLINE          01
144 #define OFFLINE         02
145 #define CHANGED         04
146 #define STMASK          07
147 #define ANNOUNCE        010
148 #define CLEARED         020
149
150 /*
151  * Karl Kleinpaste, 26 Jan 1984.
152  * Initialize the dummy tty list for login watch.
153  * This dummy list eliminates boundary conditions
154  * when doing pointer-chase searches.
155  */
156 void
157 initwatch(void)
158 {
159     whohead.who_next = &whotail;
160     whotail.who_prev = &whohead;
161     stlast = 1;
162 #ifdef WHODEBUG
163     debugwholist(NULL, NULL);
164 #endif /* WHODEBUG */
165 }
166
167 void
168 resetwatch(void)
169 {
170     watch_period = 0;
171     stlast = 0;
172 }
173
174 /*
175  * Karl Kleinpaste, 26 Jan 1984.
176  * Watch /etc/utmp for login/logout changes.
177  */
178 void
179 watch_login(int force)
180 {
181     int     comp = -1, alldone;
182     int     firsttime = stlast == 1;
183 #ifdef HAVE_GETUTENT
184     struct utmp *uptr;
185 #else
186     int utmpfd;
187 #endif
188     struct utmp utmp;
189     struct who *wp, *wpnew;
190     struct varent *v;
191     Char  **vp = NULL;
192     time_t  t, interval = MAILINTVL;
193     struct stat sta;
194 #if defined(HAVE_STRUCT_UTMP_UT_HOST) && defined(_SEQUENT_)
195     char   *host, *ut_find_host();
196 #endif
197 #ifdef WINNT_NATIVE
198     static int ncbs_posted = 0;
199     USE(utmp);
200     USE(utmpfd);
201     USE(sta);
202     USE(wpnew);
203 #endif /* WINNT_NATIVE */
204
205     /* stop SIGINT, lest our login list get trashed. */
206     pintr_disabled++;
207     cleanup_push(&pintr_disabled, disabled_cleanup);
208
209     v = adrof(STRwatch);
210     if ((v == NULL || v->vec == NULL) && !force) {
211         cleanup_until(&pintr_disabled);
212         return;                 /* no names to watch */
213     }
214     if (!force) {
215         trim(vp = v->vec);
216         if (blklen(vp) % 2)             /* odd # args: 1st == # minutes. */
217             interval = (number(*vp)) ? (getn(*vp++) * 60) : MAILINTVL;
218     }
219     else
220         interval = 0;
221         
222     (void) time(&t);
223 #ifdef WINNT_NATIVE
224         /*
225          * Since NCB_ASTATs take time, start em async at least 90 secs
226          * before we are due -amol 6/5/97
227          */
228         if (!ncbs_posted) {
229             time_t tdiff = t - watch_period;
230             if (!watch_period || ((tdiff  > 0) && (tdiff > (interval - 90)))) {
231                 start_ncbs(vp);
232                 ncbs_posted = 1;
233             }
234         }
235 #endif /* WINNT_NATIVE */
236     if (t - watch_period < interval) {
237         cleanup_until(&pintr_disabled);
238         return;                 /* not long enough yet... */
239     }
240     watch_period = t;
241 #ifdef WINNT_NATIVE
242     ncbs_posted = 0;
243 #else /* !WINNT_NATIVE */
244
245     /*
246      * From: Michael Schroeder <mlschroe@immd4.informatik.uni-erlangen.de>
247      * Don't open utmp all the time, stat it first...
248      */
249     if (stat(TCSH_PATH_UTMP, &sta)) {
250         if (!force)
251             xprintf(CGETS(26, 1,
252                           "cannot stat %s.  Please \"unset watch\".\n"),
253                     TCSH_PATH_UTMP);
254         cleanup_until(&pintr_disabled);
255         return;
256     }
257     if (stlast == sta.st_mtime) {
258         cleanup_until(&pintr_disabled);
259         return;
260     }
261     stlast = sta.st_mtime;
262 #ifdef HAVE_GETUTENT
263     setutent();
264 #else
265     if ((utmpfd = xopen(TCSH_PATH_UTMP, O_RDONLY|O_LARGEFILE)) < 0) {
266         if (!force)
267             xprintf(CGETS(26, 2,
268                           "%s cannot be opened.  Please \"unset watch\".\n"),
269                     TCSH_PATH_UTMP);
270         cleanup_until(&pintr_disabled);
271         return;
272     }
273     cleanup_push(&utmpfd, open_cleanup);
274 #endif
275
276     /*
277      * xterm clears the entire utmp entry - mark everyone on the status list
278      * OFFLINE or we won't notice X "logouts"
279      */
280     for (wp = whohead.who_next; wp->who_next != NULL; wp = wp->who_next)
281         wp->who_status = OFFLINE | CLEARED;
282
283     /*
284      * Read in the utmp file, sort the entries, and update existing entries or
285      * add new entries to the status list.
286      */
287 #ifdef HAVE_GETUTENT
288     while ((uptr = getutent()) != NULL) {
289         memcpy(&utmp, uptr, sizeof (utmp));
290 #else
291     while (xread(utmpfd, &utmp, sizeof utmp) == sizeof utmp) {
292 #endif
293
294 # ifdef DEAD_PROCESS
295 #  ifndef IRIS4D
296         if (utmp.ut_type != USER_PROCESS)
297             continue;
298 #  else
299         /* Why is that? Cause the utmp file is always corrupted??? */
300         if (utmp.ut_type != USER_PROCESS && utmp.ut_type != DEAD_PROCESS)
301             continue;
302 #  endif /* IRIS4D */
303 # endif /* DEAD_PROCESS */
304
305         if (utmp.ut_name[0] == '\0' && utmp.ut_line[0] == '\0')
306             continue;   /* completely void entry */
307 # ifdef DEAD_PROCESS
308         if (utmp.ut_type == DEAD_PROCESS && utmp.ut_line[0] == '\0')
309             continue;
310 # endif /* DEAD_PROCESS */
311         wp = whohead.who_next;
312         while (wp->who_next && (comp = strncmp(wp->who_tty, utmp.ut_line, UTLINLEN)) < 0)
313             wp = wp->who_next;/* find that tty! */
314
315         if (wp->who_next && comp == 0) {        /* found the tty... */
316             if (utmp.ut_time < wp->who_time)
317                 continue;
318 # ifdef DEAD_PROCESS
319             if (utmp.ut_type == DEAD_PROCESS) {
320                 wp->who_time = utmp.ut_time;
321                 wp->who_status = OFFLINE;
322             }
323             else
324 # endif /* DEAD_PROCESS */
325             if (utmp.ut_name[0] == '\0') {
326                 wp->who_time = utmp.ut_time;
327                 wp->who_status = OFFLINE;
328             }
329             else if (strncmp(utmp.ut_name, wp->who_name, UTNAMLEN) == 0) {
330                 /* someone is logged in */ 
331                 wp->who_time = utmp.ut_time;
332                 wp->who_status = ONLINE | ANNOUNCE;     /* same guy */
333             }
334             else {
335                 (void) strncpy(wp->who_new, utmp.ut_name, UTNAMLEN);
336 # ifdef HAVE_STRUCT_UTMP_UT_HOST
337 #  ifdef _SEQUENT_
338                 host = ut_find_host(wp->who_tty);
339                 if (host)
340                     (void) strncpy(wp->who_host, host, UTHOSTLEN);
341                 else
342                     wp->who_host[0] = 0;
343 #  else
344                 (void) strncpy(wp->who_host, utmp.ut_host, UTHOSTLEN);
345 #  endif
346 # endif /* HAVE_STRUCT_UTMP_UT_HOST */
347                 wp->who_time = utmp.ut_time;
348                 if (wp->who_name[0] == '\0')
349                     wp->who_status = ONLINE;
350                 else
351                     wp->who_status = CHANGED;
352             }
353         }
354         else {          /* new tty in utmp */
355             wpnew = xcalloc(1, sizeof *wpnew);
356             (void) strncpy(wpnew->who_tty, utmp.ut_line, UTLINLEN);
357 # ifdef HAVE_STRUCT_UTMP_UT_HOST
358 #  ifdef _SEQUENT_
359             host = ut_find_host(wpnew->who_tty);
360             if (host)
361                 (void) strncpy(wpnew->who_host, host, UTHOSTLEN);
362             else
363                 wpnew->who_host[0] = 0;
364 #  else
365             (void) strncpy(wpnew->who_host, utmp.ut_host, UTHOSTLEN);
366 #  endif
367 # endif /* HAVE_STRUCT_UTMP_UT_HOST */
368             wpnew->who_time = utmp.ut_time;
369 # ifdef DEAD_PROCESS
370             if (utmp.ut_type == DEAD_PROCESS)
371                 wpnew->who_status = OFFLINE;
372             else
373 # endif /* DEAD_PROCESS */
374             if (utmp.ut_name[0] == '\0')
375                 wpnew->who_status = OFFLINE;
376             else {
377                 (void) strncpy(wpnew->who_new, utmp.ut_name, UTNAMLEN);
378                 wpnew->who_status = ONLINE;
379             }
380 # ifdef WHODEBUG
381             debugwholist(wpnew, wp);
382 # endif /* WHODEBUG */
383
384             wpnew->who_next = wp;       /* link in a new 'who' */
385             wpnew->who_prev = wp->who_prev;
386             wpnew->who_prev->who_next = wpnew;
387             wp->who_prev = wpnew;       /* linked in now */
388         }
389     }
390 #ifdef HAVE_GETUTENT
391     endutent();
392 #else
393     cleanup_until(&utmpfd);
394 #endif
395 # if defined(HAVE_STRUCT_UTMP_UT_HOST) && defined(_SEQUENT_)
396     endutent();
397 # endif
398 #endif /* !WINNT_NATIVE */
399
400     if (force || vp == NULL) {
401         cleanup_until(&pintr_disabled);
402         return;
403     }
404
405     /*
406      * The state of all logins is now known, so we can search the user's list
407      * of watchables to print the interesting ones.
408      */
409     for (alldone = 0; !alldone && *vp != NULL && **vp != '\0' &&
410          *(vp + 1) != NULL && **(vp + 1) != '\0';
411          vp += 2) {             /* args used in pairs... */
412
413         if (eq(*vp, STRany) && eq(*(vp + 1), STRany))
414             alldone = 1;
415
416         for (wp = whohead.who_next; wp->who_next != NULL; wp = wp->who_next) {
417             if (wp->who_status & ANNOUNCE ||
418                 (!eq(STRany, vp[0]) &&
419                  !Gmatch(str2short(wp->who_name), vp[0]) &&
420                  !Gmatch(str2short(wp->who_new),  vp[0])) ||
421                 (!Gmatch(str2short(wp->who_tty),  vp[1]) &&
422                  !eq(STRany, vp[1])))
423                 continue;       /* entry doesn't qualify */
424             /* already printed or not right one to print */
425
426
427             if (wp->who_status & CLEARED) {/* utmp entry was cleared */
428                 wp->who_time = watch_period;
429                 wp->who_status &= ~CLEARED;
430             }
431
432             if ((wp->who_status & OFFLINE) &&
433                 (wp->who_name[0] != '\0')) {
434                 if (!firsttime)
435                     print_who(wp);
436                 wp->who_name[0] = '\0';
437                 wp->who_status |= ANNOUNCE;
438                 continue;
439             }
440             if (wp->who_status & ONLINE) {
441                 if (!firsttime)
442                     print_who(wp);
443                 (void) strcpy(wp->who_name, wp->who_new);
444                 wp->who_status |= ANNOUNCE;
445                 continue;
446             }
447             if (wp->who_status & CHANGED) {
448                 if (!firsttime)
449                     print_who(wp);
450                 (void) strcpy(wp->who_name, wp->who_new);
451                 wp->who_status |= ANNOUNCE;
452                 continue;
453             }
454         }
455     }
456     cleanup_until(&pintr_disabled);
457 }
458
459 #ifdef WHODEBUG
460 static void
461 debugwholist(struct who *new, struct who *wp)
462 {
463     struct who *a;
464
465     a = whohead.who_next;
466     while (a->who_next != NULL) {
467         xprintf("%s/%s -> ", a->who_name, a->who_tty);
468         a = a->who_next;
469     }
470     xprintf("TAIL\n");
471     if (a != &whotail) {
472         xprintf(CGETS(26, 3, "BUG! last element is not whotail!\n"));
473         abort();
474     }
475     a = whotail.who_prev;
476     xprintf(CGETS(26, 4, "backward: "));
477     while (a->who_prev != NULL) {
478         xprintf("%s/%s -> ", a->who_name, a->who_tty);
479         a = a->who_prev;
480     }
481     xprintf("HEAD\n");
482     if (a != &whohead) {
483         xprintf(CGETS(26, 5, "BUG! first element is not whohead!\n"));
484         abort();
485     }
486     if (new)
487         xprintf(CGETS(26, 6, "new: %s/%s\n"), new->who_name, new->who_tty);
488     if (wp)
489         xprintf("wp: %s/%s\n", wp->who_name, wp->who_tty);
490 }
491 #endif /* WHODEBUG */
492
493
494 static void
495 print_who(struct who *wp)
496 {
497 #ifdef HAVE_STRUCT_UTMP_UT_HOST
498     Char   *cp = str2short(CGETS(26, 7, "%n has %a %l from %m."));
499 #else
500     Char   *cp = str2short(CGETS(26, 8, "%n has %a %l."));
501 #endif /* HAVE_STRUCT_UTMP_UT_HOST */
502     struct varent *vp = adrof(STRwho);
503     Char *str;
504
505     if (vp && vp->vec && vp->vec[0])
506         cp = vp->vec[0];
507
508     str = tprintf(FMT_WHO, cp, NULL, wp->who_time, wp);
509     cleanup_push(str, xfree);
510     for (cp = str; *cp;)
511         xputwchar(*cp++);
512     cleanup_until(str);
513     xputchar('\n');
514 } /* end print_who */
515
516
517 char *
518 who_info(ptr_t ptr, int c)
519 {
520     struct who *wp = ptr;
521     char *wbuf;
522 #ifdef HAVE_STRUCT_UTMP_UT_HOST
523     char *wb;
524     int flg;
525     char *pb;
526 #endif /* HAVE_STRUCT_UTMP_UT_HOST */
527
528     switch (c) {
529     case 'n':           /* user name */
530         switch (wp->who_status & STMASK) {
531         case ONLINE:
532         case CHANGED:
533             return strsave(wp->who_new);
534         case OFFLINE:
535             return strsave(wp->who_name);
536         default:
537             break;
538         }
539         break;
540
541     case 'a':
542         switch (wp->who_status & STMASK) {
543         case ONLINE:
544             return strsave(CGETS(26, 9, "logged on"));
545         case OFFLINE:
546             return strsave(CGETS(26, 10, "logged off"));
547         case CHANGED:
548             return xasprintf(CGETS(26, 11, "replaced %s on"), wp->who_name);
549         default:
550             break;
551         }
552         break;
553
554 #ifdef HAVE_STRUCT_UTMP_UT_HOST
555     case 'm':
556         if (wp->who_host[0] == '\0')
557             return strsave(CGETS(26, 12, "local"));
558         else {
559             pb = wp->who_host;
560             wbuf = xmalloc(strlen(pb) + 1);
561             wb = wbuf;
562             /* the ':' stuff is for <host>:<display>.<screen> */
563             for (flg = isdigit((unsigned char)*pb) ? '\0' : '.';
564                  *pb != '\0' && (*pb != flg || ((pb = strchr(pb, ':')) != 0));
565                  pb++) {
566                 if (*pb == ':')
567                     flg = '\0';
568                 *wb++ = isupper((unsigned char)*pb) ?
569                     tolower((unsigned char)*pb) : *pb;
570             }
571             *wb = '\0';
572             return wbuf;
573         }
574
575     case 'M':
576         if (wp->who_host[0] == '\0')
577             return strsave(CGETS(26, 12, "local"));
578         else {
579             pb = wp->who_host;
580             wbuf = xmalloc(strlen(pb) + 1);
581             wb = wbuf;
582             for (; *pb != '\0'; pb++)
583                 *wb++ = isupper((unsigned char)*pb) ?
584                     tolower((unsigned char)*pb) : *pb;
585             *wb = '\0';
586             return wbuf;
587         }
588 #endif /* HAVE_STRUCT_UTMP_UT_HOST */
589
590     case 'l':
591         return strsave(wp->who_tty);
592
593     default:
594         wbuf = xmalloc(3);
595         wbuf[0] = '%';
596         wbuf[1] = (char) c;
597         wbuf[2] = '\0';
598         return wbuf;
599     }
600     return NULL;
601 }
602
603 void
604 /*ARGSUSED*/
605 dolog(Char **v, struct command *c)
606 {
607     struct who *wp;
608     struct varent *vp;
609
610     USE(v);
611     USE(c);
612     vp = adrof(STRwatch);       /* lint insists vp isn't used unless we */
613     if (vp == NULL)             /* unless we assign it outside the if */
614         stderror(ERR_NOWATCH);
615     resetwatch();
616     wp = whohead.who_next;
617     while (wp->who_next != NULL) {
618         wp->who_name[0] = '\0';
619         wp = wp->who_next;
620     }
621 }
622
623 # ifdef HAVE_STRUCT_UTMP_UT_HOST
624 size_t
625 utmphostsize(void)
626 {
627     return UTHOSTLEN;
628 }
629
630 char *
631 utmphost(void)
632 {
633     char *tty = short2str(varval(STRtty));
634     struct who *wp;
635     char *host = NULL;
636
637     watch_login(1);
638     
639     for (wp = whohead.who_next; wp->who_next != NULL; wp = wp->who_next) {
640         if (strcmp(tty, wp->who_tty) == 0)
641             host = wp->who_host;
642         wp->who_name[0] = '\0';
643     }
644     resetwatch();
645     return host;
646 }
647 # endif /* HAVE_STRUCT_UTMP_UT_HOST */
648
649 #ifdef WINNT_NATIVE
650 void add_to_who_list(name, mach_nm)
651     char *name;
652     char *mach_nm;
653 {
654
655     struct who *wp, *wpnew;
656     int comp = -1;
657
658     wp = whohead.who_next;
659     while (wp->who_next && (comp = strncmp(wp->who_tty,mach_nm,UTLINLEN)) < 0)
660         wp = wp->who_next;/* find that tty! */
661
662     if (wp->who_next && comp == 0) {    /* found the tty... */
663
664         if (*name == '\0') {
665             wp->who_time = 0;
666             wp->who_status = OFFLINE;
667         }
668         else if (strncmp(name, wp->who_name, UTNAMLEN) == 0) {
669             /* someone is logged in */ 
670             wp->who_time = 0;
671             wp->who_status = 0; /* same guy */
672         }
673         else {
674             (void) strncpy(wp->who_new, name, UTNAMLEN);
675             wp->who_time = 0;
676             if (wp->who_name[0] == '\0')
677                 wp->who_status = ONLINE;
678             else
679                 wp->who_status = CHANGED;
680         }
681     }
682     else {
683         wpnew = xcalloc(1, sizeof *wpnew);
684         (void) strncpy(wpnew->who_tty, mach_nm, UTLINLEN);
685         wpnew->who_time = 0;
686         if (*name == '\0')
687             wpnew->who_status = OFFLINE;
688         else {
689             (void) strncpy(wpnew->who_new, name, UTNAMLEN);
690             wpnew->who_status = ONLINE;
691         }
692 #ifdef WHODEBUG
693         debugwholist(wpnew, wp);
694 #endif /* WHODEBUG */
695
696         wpnew->who_next = wp;   /* link in a new 'who' */
697         wpnew->who_prev = wp->who_prev;
698         wpnew->who_prev->who_next = wpnew;
699         wp->who_prev = wpnew;   /* linked in now */
700     }
701 }
702 #endif /* WINNT_NATIVE */
703 #endif /* HAVENOUTMP */