1 /* $Header: /src/pub/tcsh/tc.who.c,v 3.44 2005/03/03 23:44:45 kim 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("$Id: tc.who.c,v 3.44 2005/03/03 23:44:45 kim 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 __P((struct who *, struct who *)); 139 #endif 140 static void print_who __P((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 149 /* 150 * Karl Kleinpaste, 26 Jan 1984. 151 * Initialize the dummy tty list for login watch. 152 * This dummy list eliminates boundary conditions 153 * when doing pointer-chase searches. 154 */ 155 void 156 initwatch() 157 { 158 whohead.who_next = &whotail; 159 whotail.who_prev = &whohead; 160 stlast = 1; 161 #ifdef WHODEBUG 162 debugwholist(NULL, NULL); 163 #endif /* WHODEBUG */ 164 } 165 166 void 167 resetwatch() 168 { 169 watch_period = 0; 170 stlast = 0; 171 } 172 173 /* 174 * Karl Kleinpaste, 26 Jan 1984. 175 * Watch /etc/utmp for login/logout changes. 176 */ 177 void 178 watch_login(force) 179 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 #ifdef BSDSIGS 189 sigmask_t omask; 190 #endif /* BSDSIGS */ 191 struct utmp utmp; 192 struct who *wp, *wpnew; 193 struct varent *v; 194 Char **vp = NULL; 195 time_t t, interval = MAILINTVL; 196 struct stat sta; 197 #if defined(HAVE_STRUCT_UTMP_UT_HOST) && defined(_SEQUENT_) 198 char *host, *ut_find_host(); 199 #endif 200 #ifdef WINNT_NATIVE 201 static int ncbs_posted = 0; 202 USE(utmp); 203 USE(utmpfd); 204 USE(sta); 205 USE(wpnew); 206 #endif /* WINNT_NATIVE */ 207 208 /* stop SIGINT, lest our login list get trashed. */ 209 #ifdef BSDSIGS 210 omask = sigblock(sigmask(SIGINT)); 211 #else 212 (void) sighold(SIGINT); 213 #endif 214 215 v = adrof(STRwatch); 216 if ((v == NULL || v->vec == NULL) && !force) { 217 #ifdef BSDSIGS 218 (void) sigsetmask(omask); 219 #else 220 (void) sigrelse(SIGINT); 221 #endif 222 return; /* no names to watch */ 223 } 224 if (!force) { 225 trim(vp = v->vec); 226 if (blklen(vp) % 2) /* odd # args: 1st == # minutes. */ 227 interval = (number(*vp)) ? (getn(*vp++) * 60) : MAILINTVL; 228 } 229 else 230 interval = 0; 231 232 (void) time(&t); 233 #ifdef WINNT_NATIVE 234 /* 235 * Since NCB_ASTATs take time, start em async at least 90 secs 236 * before we are due -amol 6/5/97 237 */ 238 if (!ncbs_posted) { 239 unsigned long tdiff = t - watch_period; 240 if (!watch_period || ((tdiff > 0) && (tdiff > (interval - 90)))) { 241 start_ncbs(vp); 242 ncbs_posted = 1; 243 } 244 } 245 #endif /* WINNT_NATIVE */ 246 if (t - watch_period < interval) { 247 #ifdef BSDSIGS 248 (void) sigsetmask(omask); 249 #else 250 (void) sigrelse(SIGINT); 251 #endif 252 return; /* not long enough yet... */ 253 } 254 watch_period = t; 255 #ifdef WINNT_NATIVE 256 ncbs_posted = 0; 257 #else /* !WINNT_NATIVE */ 258 259 /* 260 * From: Michael Schroeder <mlschroe@immd4.informatik.uni-erlangen.de> 261 * Don't open utmp all the time, stat it first... 262 */ 263 if (stat(TCSH_PATH_UTMP, &sta)) { 264 if (!force) 265 xprintf(CGETS(26, 1, 266 "cannot stat %s. Please \"unset watch\".\n"), 267 TCSH_PATH_UTMP); 268 # ifdef BSDSIGS 269 (void) sigsetmask(omask); 270 # else 271 (void) sigrelse(SIGINT); 272 # endif 273 return; 274 } 275 if (stlast == sta.st_mtime) { 276 # ifdef BSDSIGS 277 (void) sigsetmask(omask); 278 # else 279 (void) sigrelse(SIGINT); 280 # endif 281 return; 282 } 283 stlast = sta.st_mtime; 284 #ifdef HAVE_GETUTENT 285 setutent(); 286 #else 287 if ((utmpfd = open(TCSH_PATH_UTMP, O_RDONLY|O_LARGEFILE)) < 0) { 288 if (!force) 289 xprintf(CGETS(26, 2, 290 "%s cannot be opened. Please \"unset watch\".\n"), 291 TCSH_PATH_UTMP); 292 # ifdef BSDSIGS 293 (void) sigsetmask(omask); 294 # else 295 (void) sigrelse(SIGINT); 296 # endif 297 return; 298 } 299 #endif 300 301 /* 302 * xterm clears the entire utmp entry - mark everyone on the status list 303 * OFFLINE or we won't notice X "logouts" 304 */ 305 for (wp = whohead.who_next; wp->who_next != NULL; wp = wp->who_next) { 306 wp->who_status = OFFLINE; 307 wp->who_time = 0; 308 } 309 310 /* 311 * Read in the utmp file, sort the entries, and update existing entries or 312 * add new entries to the status list. 313 */ 314 #ifdef HAVE_GETUTENT 315 while ((uptr = getutent()) != NULL) { 316 memcpy(&utmp, uptr, sizeof (utmp)); 317 #else 318 while (read(utmpfd, (char *) &utmp, sizeof utmp) == sizeof utmp) { 319 #endif 320 321 # ifdef DEAD_PROCESS 322 # ifndef IRIS4D 323 if (utmp.ut_type != USER_PROCESS) 324 continue; 325 # else 326 /* Why is that? Cause the utmp file is always corrupted??? */ 327 if (utmp.ut_type != USER_PROCESS && utmp.ut_type != DEAD_PROCESS) 328 continue; 329 # endif /* IRIS4D */ 330 # endif /* DEAD_PROCESS */ 331 332 if (utmp.ut_name[0] == '\0' && utmp.ut_line[0] == '\0') 333 continue; /* completely void entry */ 334 # ifdef DEAD_PROCESS 335 if (utmp.ut_type == DEAD_PROCESS && utmp.ut_line[0] == '\0') 336 continue; 337 # endif /* DEAD_PROCESS */ 338 wp = whohead.who_next; 339 while (wp->who_next && (comp = strncmp(wp->who_tty, utmp.ut_line, UTLINLEN)) < 0) 340 wp = wp->who_next;/* find that tty! */ 341 342 if (wp->who_next && comp == 0) { /* found the tty... */ 343 # ifdef DEAD_PROCESS 344 if (utmp.ut_type == DEAD_PROCESS) { 345 wp->who_time = utmp.ut_time; 346 wp->who_status = OFFLINE; 347 } 348 else 349 # endif /* DEAD_PROCESS */ 350 if (utmp.ut_name[0] == '\0') { 351 wp->who_time = utmp.ut_time; 352 wp->who_status = OFFLINE; 353 } 354 else if (strncmp(utmp.ut_name, wp->who_name, UTNAMLEN) == 0) { 355 /* someone is logged in */ 356 wp->who_time = utmp.ut_time; 357 wp->who_status = 0; /* same guy */ 358 } 359 else { 360 (void) strncpy(wp->who_new, utmp.ut_name, UTNAMLEN); 361 # ifdef HAVE_STRUCT_UTMP_UT_HOST 362 # ifdef _SEQUENT_ 363 host = ut_find_host(wp->who_tty); 364 if (host) 365 (void) strncpy(wp->who_host, host, UTHOSTLEN); 366 else 367 wp->who_host[0] = 0; 368 # else 369 (void) strncpy(wp->who_host, utmp.ut_host, UTHOSTLEN); 370 # endif 371 # endif /* HAVE_STRUCT_UTMP_UT_HOST */ 372 wp->who_time = utmp.ut_time; 373 if (wp->who_name[0] == '\0') 374 wp->who_status = ONLINE; 375 else 376 wp->who_status = CHANGED; 377 } 378 } 379 else { /* new tty in utmp */ 380 wpnew = (struct who *) xcalloc(1, sizeof *wpnew); 381 (void) strncpy(wpnew->who_tty, utmp.ut_line, UTLINLEN); 382 # ifdef HAVE_STRUCT_UTMP_UT_HOST 383 # ifdef _SEQUENT_ 384 host = ut_find_host(wpnew->who_tty); 385 if (host) 386 (void) strncpy(wpnew->who_host, host, UTHOSTLEN); 387 else 388 wpnew->who_host[0] = 0; 389 # else 390 (void) strncpy(wpnew->who_host, utmp.ut_host, UTHOSTLEN); 391 # endif 392 # endif /* HAVE_STRUCT_UTMP_UT_HOST */ 393 wpnew->who_time = utmp.ut_time; 394 # ifdef DEAD_PROCESS 395 if (utmp.ut_type == DEAD_PROCESS) 396 wpnew->who_status = OFFLINE; 397 else 398 # endif /* DEAD_PROCESS */ 399 if (utmp.ut_name[0] == '\0') 400 wpnew->who_status = OFFLINE; 401 else { 402 (void) strncpy(wpnew->who_new, utmp.ut_name, UTNAMLEN); 403 wpnew->who_status = ONLINE; 404 } 405 # ifdef WHODEBUG 406 debugwholist(wpnew, wp); 407 # endif /* WHODEBUG */ 408 409 wpnew->who_next = wp; /* link in a new 'who' */ 410 wpnew->who_prev = wp->who_prev; 411 wpnew->who_prev->who_next = wpnew; 412 wp->who_prev = wpnew; /* linked in now */ 413 } 414 } 415 #ifdef HAVE_GETUTENT 416 endutent(); 417 #else 418 (void) close(utmpfd); 419 #endif 420 # if defined(HAVE_STRUCT_UTMP_UT_HOST) && defined(_SEQUENT_) 421 endutent(); 422 # endif 423 #endif /* !WINNT_NATIVE */ 424 425 if (force || vp == NULL) 426 return; 427 428 /* 429 * The state of all logins is now known, so we can search the user's list 430 * of watchables to print the interesting ones. 431 */ 432 for (alldone = 0; !alldone && *vp != NULL && **vp != '\0' && 433 *(vp + 1) != NULL && **(vp + 1) != '\0'; 434 vp += 2) { /* args used in pairs... */ 435 436 if (eq(*vp, STRany) && eq(*(vp + 1), STRany)) 437 alldone = 1; 438 439 for (wp = whohead.who_next; wp->who_next != NULL; wp = wp->who_next) { 440 if (wp->who_status & ANNOUNCE || 441 (!eq(STRany, vp[0]) && 442 !Gmatch(str2short(wp->who_name), vp[0]) && 443 !Gmatch(str2short(wp->who_new), vp[0])) || 444 (!Gmatch(str2short(wp->who_tty), vp[1]) && 445 !eq(STRany, vp[1]))) 446 continue; /* entry doesn't qualify */ 447 /* already printed or not right one to print */ 448 449 450 if (wp->who_time == 0)/* utmp entry was cleared */ 451 wp->who_time = watch_period; 452 453 if ((wp->who_status & OFFLINE) && 454 (wp->who_name[0] != '\0')) { 455 if (!firsttime) 456 print_who(wp); 457 wp->who_name[0] = '\0'; 458 wp->who_status |= ANNOUNCE; 459 continue; 460 } 461 if (wp->who_status & ONLINE) { 462 if (!firsttime) 463 print_who(wp); 464 (void) strcpy(wp->who_name, wp->who_new); 465 wp->who_status |= ANNOUNCE; 466 continue; 467 } 468 if (wp->who_status & CHANGED) { 469 if (!firsttime) 470 print_who(wp); 471 (void) strcpy(wp->who_name, wp->who_new); 472 wp->who_status |= ANNOUNCE; 473 continue; 474 } 475 } 476 } 477 #ifdef BSDSIGS 478 (void) sigsetmask(omask); 479 #else 480 (void) sigrelse(SIGINT); 481 #endif 482 } 483 484 #ifdef WHODEBUG 485 static void 486 debugwholist(new, wp) 487 struct who *new, *wp; 488 { 489 struct who *a; 490 491 a = whohead.who_next; 492 while (a->who_next != NULL) { 493 xprintf("%s/%s -> ", a->who_name, a->who_tty); 494 a = a->who_next; 495 } 496 xprintf("TAIL\n"); 497 if (a != &whotail) { 498 xprintf(CGETS(26, 3, "BUG! last element is not whotail!\n")); 499 abort(); 500 } 501 a = whotail.who_prev; 502 xprintf(CGETS(26, 4, "backward: ")); 503 while (a->who_prev != NULL) { 504 xprintf("%s/%s -> ", a->who_name, a->who_tty); 505 a = a->who_prev; 506 } 507 xprintf("HEAD\n"); 508 if (a != &whohead) { 509 xprintf(CGETS(26, 5, "BUG! first element is not whohead!\n")); 510 abort(); 511 } 512 if (new) 513 xprintf(CGETS(26, 6, "new: %s/%s\n"), new->who_name, new->who_tty); 514 if (wp) 515 xprintf("wp: %s/%s\n", wp->who_name, wp->who_tty); 516 } 517 #endif /* WHODEBUG */ 518 519 520 static void 521 print_who(wp) 522 struct who *wp; 523 { 524 #ifdef HAVE_STRUCT_UTMP_UT_HOST 525 Char *cp = str2short(CGETS(26, 7, "%n has %a %l from %m.")); 526 #else 527 Char *cp = str2short(CGETS(26, 8, "%n has %a %l.")); 528 #endif /* HAVE_STRUCT_UTMP_UT_HOST */ 529 struct varent *vp = adrof(STRwho); 530 Char buf[BUFSIZE]; 531 532 if (vp && vp->vec && vp->vec[0]) 533 cp = vp->vec[0]; 534 535 tprintf(FMT_WHO, buf, cp, BUFSIZE, NULL, wp->who_time, (ptr_t) wp); 536 for (cp = buf; *cp;) 537 xputwchar(*cp++); 538 xputchar('\n'); 539 } /* end print_who */ 540 541 542 const char * 543 who_info(ptr, c, wbuf, wbufsiz) 544 ptr_t ptr; 545 int c; 546 char *wbuf; 547 size_t wbufsiz; 548 { 549 struct who *wp = (struct who *) ptr; 550 #ifdef HAVE_STRUCT_UTMP_UT_HOST 551 char *wb = wbuf; 552 int flg; 553 char *pb; 554 #endif /* HAVE_STRUCT_UTMP_UT_HOST */ 555 556 switch (c) { 557 case 'n': /* user name */ 558 switch (wp->who_status & STMASK) { 559 case ONLINE: 560 case CHANGED: 561 return wp->who_new; 562 case OFFLINE: 563 return wp->who_name; 564 default: 565 break; 566 } 567 break; 568 569 case 'a': 570 switch (wp->who_status & STMASK) { 571 case ONLINE: 572 return CGETS(26, 9, "logged on"); 573 case OFFLINE: 574 return CGETS(26, 10, "logged off"); 575 case CHANGED: 576 xsnprintf(wbuf, wbufsiz, CGETS(26, 11, "replaced %s on"), 577 wp->who_name); 578 return wbuf; 579 default: 580 break; 581 } 582 break; 583 584 #ifdef HAVE_STRUCT_UTMP_UT_HOST 585 case 'm': 586 if (wp->who_host[0] == '\0') 587 return CGETS(26, 12, "local"); 588 else { 589 /* the ':' stuff is for <host>:<display>.<screen> */ 590 for (pb = wp->who_host, 591 flg = isdigit((unsigned char)*pb) ? '\0' : '.'; 592 *pb != '\0' && (*pb != flg || ((pb = strchr(pb, ':')) != 0)); 593 pb++) { 594 if (*pb == ':') 595 flg = '\0'; 596 *wb++ = isupper((unsigned char)*pb) ? 597 tolower((unsigned char)*pb) : *pb; 598 } 599 *wb = '\0'; 600 return wbuf; 601 } 602 603 case 'M': 604 if (wp->who_host[0] == '\0') 605 return CGETS(26, 12, "local"); 606 else { 607 for (pb = wp->who_host; *pb != '\0'; pb++) 608 *wb++ = isupper((unsigned char)*pb) ? 609 tolower((unsigned char)*pb) : *pb; 610 *wb = '\0'; 611 return wbuf; 612 } 613 #endif /* HAVE_STRUCT_UTMP_UT_HOST */ 614 615 case 'l': 616 return wp->who_tty; 617 618 default: 619 wbuf[0] = '%'; 620 wbuf[1] = (char) c; 621 wbuf[2] = '\0'; 622 return wbuf; 623 } 624 return NULL; 625 } 626 627 void 628 /*ARGSUSED*/ 629 dolog(v, c) 630 Char **v; 631 struct command *c; 632 { 633 struct who *wp; 634 struct varent *vp; 635 636 USE(v); 637 USE(c); 638 vp = adrof(STRwatch); /* lint insists vp isn't used unless we */ 639 if (vp == NULL) /* unless we assign it outside the if */ 640 stderror(ERR_NOWATCH); 641 resetwatch(); 642 wp = whohead.who_next; 643 while (wp->who_next != NULL) { 644 wp->who_name[0] = '\0'; 645 wp = wp->who_next; 646 } 647 } 648 649 # ifdef HAVE_STRUCT_UTMP_UT_HOST 650 size_t 651 utmphostsize() 652 { 653 return UTHOSTLEN; 654 } 655 656 char * 657 utmphost() 658 { 659 char *tty = short2str(varval(STRtty)); 660 struct who *wp; 661 char *host = NULL; 662 663 watch_login(1); 664 665 for (wp = whohead.who_next; wp->who_next != NULL; wp = wp->who_next) { 666 if (strcmp(tty, wp->who_tty) == 0) 667 host = wp->who_host; 668 wp->who_name[0] = '\0'; 669 } 670 resetwatch(); 671 return host; 672 } 673 # endif /* HAVE_STRUCT_UTMP_UT_HOST */ 674 675 #ifdef WINNT_NATIVE 676 void add_to_who_list(name, mach_nm) 677 char *name; 678 char *mach_nm; 679 { 680 681 struct who *wp, *wpnew; 682 int comp = -1; 683 684 wp = whohead.who_next; 685 while (wp->who_next && (comp = strncmp(wp->who_tty,mach_nm,UTLINLEN)) < 0) 686 wp = wp->who_next;/* find that tty! */ 687 688 if (wp->who_next && comp == 0) { /* found the tty... */ 689 690 if (*name == '\0') { 691 wp->who_time = 0; 692 wp->who_status = OFFLINE; 693 } 694 else if (strncmp(name, wp->who_name, UTNAMLEN) == 0) { 695 /* someone is logged in */ 696 wp->who_time = 0; 697 wp->who_status = 0; /* same guy */ 698 } 699 else { 700 (void) strncpy(wp->who_new, name, UTNAMLEN); 701 wp->who_time = 0; 702 if (wp->who_name[0] == '\0') 703 wp->who_status = ONLINE; 704 else 705 wp->who_status = CHANGED; 706 } 707 } 708 else { 709 wpnew = (struct who *) xcalloc(1, sizeof *wpnew); 710 (void) strncpy(wpnew->who_tty, mach_nm, UTLINLEN); 711 wpnew->who_time = 0; 712 if (*name == '\0') 713 wpnew->who_status = OFFLINE; 714 else { 715 (void) strncpy(wpnew->who_new, name, UTNAMLEN); 716 wpnew->who_status = ONLINE; 717 } 718 #ifdef WHODEBUG 719 debugwholist(wpnew, wp); 720 #endif /* WHODEBUG */ 721 722 wpnew->who_next = wp; /* link in a new 'who' */ 723 wpnew->who_prev = wp->who_prev; 724 wpnew->who_prev->who_next = wpnew; 725 wp->who_prev = wpnew; /* linked in now */ 726 } 727 } 728 #endif /* WINNT_NATIVE */ 729 #endif /* HAVENOUTMP */ 730