# 2.11BSD#431 - /usr/src/ucb/finger/lprint.c

##### Functions

    demi_print        X
    lflag_print       X
    lprint            X
    show_text         X
    vputc             X

##### Macros

    LINE_LEN          X
    OFFICE_PHONE_TAG  X
    OFFICE_TAG        X
    TAB_LEN           X
    _PATH_PLAN        X
    _PATH_PROJECT     X

       1: /*
       2:  * Copyright (c) 1989 The Regents of the University of California.
       3:  * All rights reserved.
       4:  *
       5:  * This code is derived from software contributed to Berkeley by
       6:  * Tony Nardo.
       7:  *
       8:  * Redistribution and use in source and binary forms are permitted
       9:  * provided that the above copyright notice and this paragraph are
      10:  * duplicated in all such forms and that any documentation,
      11:  * advertising materials, and other materials related to such
      12:  * distribution and use acknowledge that the software was developed
      13:  * by the University of California, Berkeley.  The name of the
      14:  * University may not be used to endorse or promote products derived
      15:  * from this software without specific prior written permission.
      16:  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
      17:  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
      18:  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
      19:  */
      20:
      21: #ifndef lint
      22: static char sccsid[] = "@(#)lprint.c	5.9 (Berkeley) 2/7/90";
      23: #endif /* not lint */
      24:
      25: #include <sys/types.h>
      26: #include <sys/file.h>
      27: #include <sys/stat.h>
      28: #include <sys/time.h>
      29: #include <tzfile.h>
      30: #include <stdio.h>
      31: #include <ctype.h>
      32: #include "finger.h"
      33: #include "pathnames.h"
      34:
      35: #define LINE_LEN    80
      36: #define TAB_LEN     8       /* 8 spaces between tabs */
      37: #define _PATH_PLAN  ".plan"
      38: #define _PATH_PROJECT   ".project"
      39:
      40: lflag_print()
      41: {
      42:     extern int pplan;
      43:     register PERSON *pn;
      44:
      45:     for (pn = phead;;) {
      46:         lprint(pn);
      47:         if (!pplan) {
      48:             (void)show_text(pn->dir, _PATH_PROJECT, "Project:");
      49:             if (!show_text(pn->dir, _PATH_PLAN, "Plan:"))
      50:                 (void)printf("No Plan.\n");
      51:         }
      52:         if (!(pn = pn->next))
      53:             break;
      54:         putchar('\n');
      55:     }
      56: }
      57:
      58: lprint(pn)
      59:     register PERSON *pn;
      60: {
      61:     extern time_t now;
      62:     register struct tm *delta;
      63:     register WHERE *w;
      64:     register int cpr, len, maxlen;
      65:     int oddfield;
      66:     time_t time();
      67:     char *t, *ctime(), *prphone();
      68:
      69:     /*
      70: 	 * long format --
      71: 	 *	login name
      72: 	 *	real name
      73: 	 *	home directory
      74: 	 *	shell
      75: 	 *	office, office phone, home phone if available
      76: 	 */
      77:     (void)printf("Login: %-15s\t\t\tName: %s\nDirectory: %-25s",
      78:         pn->name, pn->realname, pn->dir);
      79:     (void)printf("\tShell: %-s\n", *pn->shell ? pn->shell : _PATH_BSHELL);
      80:
      81:     /*
      82: 	 * try and print office, office phone, and home phone on one line;
      83: 	 * if that fails, do line filling so it looks nice.
      84: 	 */
      85: #define OFFICE_TAG      "Office"
      86: #define OFFICE_PHONE_TAG    "Office Phone"
      87:     oddfield = 0;
      88:     if (pn->office && pn->officephone &&
      89:         strlen(pn->office) + strlen(pn->officephone) +
      90:         sizeof(OFFICE_TAG) + 2 <= 5 * TAB_LEN) {
      91:         (void)sprintf(tbuf, "%s: %s, %s", OFFICE_TAG, pn->office,
      92:             prphone(pn->officephone));
      93:         oddfield = demi_print(tbuf, oddfield);
      94:     } else {
      95:         if (pn->office) {
      96:             (void)sprintf(tbuf, "%s: %s", OFFICE_TAG, pn->office);
      97:             oddfield = demi_print(tbuf, oddfield);
      98:         }
      99:         if (pn->officephone) {
     100:             (void)sprintf(tbuf, "%s: %s", OFFICE_PHONE_TAG,
     101:                 prphone(pn->officephone));
     102:             oddfield = demi_print(tbuf, oddfield);
     103:         }
     104:     }
     105:     if (pn->homephone) {
     106:         (void)sprintf(tbuf, "%s: %s", "Home Phone",
     107:             prphone(pn->homephone));
     108:         oddfield = demi_print(tbuf, oddfield);
     109:     }
     110:     if (oddfield)
     111:         putchar('\n');
     112:
     113:     /*
     114: 	 * long format con't: * if logged in
     115: 	 *	terminal
     116: 	 *	idle time
     117: 	 *	if messages allowed
     118: 	 *	where logged in from
     119: 	 * if not logged in
     120: 	 *	when last logged in
     121: 	 */
     122:     /* find out longest device name for this user for formatting */
     123:     for (w = pn->whead, maxlen = -1; w != NULL; w = w->next)
     124:         if ((len = strlen(w->tty)) > maxlen)
     125:             maxlen = len;
     126:     /* find rest of entries for user */
     127:     for (w = pn->whead; w != NULL; w = w->next) {
     128:         switch (w->info) {
     129:         case LOGGEDIN:
     130:             cpr = printf("On since %16.16s on %s",
     131:                 ctime(&w->loginat), w->tty);
     132:             /*
     133: 			 * idle time is tough; if have one, print a comma,
     134: 			 * then spaces to pad out the device name, then the
     135: 			 * idle time.  Follow with a comma if a remote login.
     136: 			 */
     137:             delta = gmtime(&w->idletime);
     138:             if (delta->tm_yday || delta->tm_hour || delta->tm_min) {
     139:                 cpr += printf("%-*s idle ",
     140:                     maxlen - strlen(w->tty) + 1, ",");
     141:                 if (delta->tm_yday > 0) {
     142:                     cpr += printf("%d day%s ",
     143:                        delta->tm_yday,
     144:                        delta->tm_yday == 1 ? "" : "s");
     145:                 }
     146:                 cpr += printf("%d:%02d",
     147:                     delta->tm_hour, delta->tm_min);
     148:                 if (*w->host) {
     149:                     putchar(',');
     150:                     ++cpr;
     151:                 }
     152:             }
     153:             if (!w->writable)
     154:                 cpr += printf(" (messages off)");
     155:             break;
     156:         case LASTLOG:
     157:             if (w->loginat == 0) {
     158:                 (void)printf("Never logged in.");
     159:                 break;
     160:             }
     161:             t = ctime(&w->loginat);
     162:             if (now - w->loginat > SECSPERDAY * DAYSPERNYEAR / 2)
     163:                 cpr = printf("Last login %10.10s, %4.4s on %s",
     164:                     t, t + 20, w->tty);
     165:             else
     166:                 cpr = printf("Last login %16.16s on %s",
     167:                     t, w->tty);
     168:             break;
     169:         }
     170:         if (*w->host) {
     171:             if (LINE_LEN < (cpr + 6 + strlen(w->host)))
     172:                 (void)printf("\n   ");
     173:             (void)printf(" from %s", w->host);
     174:         }
     175:         putchar('\n');
     176:     }
     177: }
     178:
     179: demi_print(str, oddfield)
     180:     char *str;
     181:     int oddfield;
     182: {
     183:     static int lenlast;
     184:     int lenthis, maxlen;
     185:
     186:     lenthis = strlen(str);
     187:     if (oddfield) {
     188:         /*
     189: 		 * We left off on an odd number of fields.  If we haven't
     190: 		 * crossed the midpoint of the screen, and we have room for
     191: 		 * the next field, print it on the same line; otherwise,
     192: 		 * print it on a new line.
     193: 		 *
     194: 		 * Note: we insist on having the right hand fields start
     195: 		 * no less than 5 tabs out.
     196: 		 */
     197:         maxlen = 5 * TAB_LEN;
     198:         if (maxlen < lenlast)
     199:             maxlen = lenlast;
     200:         if (((((maxlen / TAB_LEN) + 1) * TAB_LEN) +
     201:             lenthis) <= LINE_LEN) {
     202:             while(lenlast < (4 * TAB_LEN)) {
     203:                 putchar('\t');
     204:                 lenlast += TAB_LEN;
     205:             }
     206:             (void)printf("\t%s\n", str);    /* force one tab */
     207:         } else {
     208:             (void)printf("\n%s", str);  /* go to next line */
     209:             oddfield = !oddfield;   /* this'll be undone below */
     210:         }
     211:     } else
     212:         (void)printf("%s", str);
     213:     oddfield = !oddfield;           /* toggle odd/even marker */
     214:     lenlast = lenthis;
     215:     return(oddfield);
     216: }
     217:
     218: show_text(directory, file_name, header)
     219:     char *directory, *file_name, *header;
     220: {
     221:     register int ch, lastc;
     222:     register FILE *fp;
     223:
     224:     (void)sprintf(tbuf, "%s/%s", directory, file_name);
     225:     if ((fp = fopen(tbuf, "r")) == NULL)
     226:         return(0);
     227:     (void)printf("%s\n", header);
     228:     while ((ch = getc(fp)) != EOF)
     229:         vputc(lastc = ch);
     230:     if (lastc != '\n')
     231:         (void)putchar('\n');
     232:     (void)fclose(fp);
     233:     return(1);
     234: }
     235:
     236: vputc(ch)
     237:     register int ch;
     238: {
     239:     int meta;
     240:
     241:     if (!isascii(ch)) {
     242:         (void)putchar('M');
     243:         (void)putchar('-');
     244:         ch = toascii(ch);
     245:         meta = 1;
     246:     } else
     247:         meta = 0;
     248:     if (isprint(ch) || !meta && (ch == ' ' || ch == '\t' || ch == '\n'))
     249:         (void)putchar(ch);
     250:     else {
     251:         (void)putchar('^');
     252:         (void)putchar(ch == '\177' ? '?' : ch | 0100);
     253:     }
     254: }

#### Defined functions

demi_print defined in line 179; used 4 times

- in line 93-102(3), 108

lflag_print defined in line 40; used 1 times

- in /usr/src/ucb/finger/finger.c line 110

lprint defined in line 58; used 1 times

- in line 46

show_text defined in line 218; used 2 times

- in line 48-49(2)

vputc defined in line 236; used 1 times

- in line 229

#### Defined variables

sccsid defined in line 22; never used

#### Defined macros

LINE_LEN defined in line 35; used 2 times

- in line 171, 201

OFFICE_PHONE_TAG defined in line 86; used 1 times

- in line 100

OFFICE_TAG defined in line 85; used 3 times

- in line 90-96(3)

TAB_LEN defined in line 36; used 6 times

- in line 90, 197-204(5)

_PATH_PLAN defined in line 37; used 1 times

- in line 49

_PATH_PROJECT defined in line 38; used 1 times

- in line 48

Last modified: 1990-03-18 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1484 |