Return to leave.c CVS log

Up to [CSRG BSD Unix] / 3BSD / cmd

Annotation of 3BSD/cmd/leave.c, revision 1.1.1.1

1.1       root        1: #include <whoami.h>
                      2: /*
                      3:  * leave - reminds you when you have to leave.
                      4:  * leave prompts for input and goes away if you hit return.
                      5:  * it nags you like a mother hen.
                      6:  */
                      7: char origlogin[20], thislogin[20];
                      8: char *getlogin();
                      9: char *whenleave;
                     10: char *ctime();
                     11: char buff[100];
                     12: 
                     13: main(argc,argv) char **argv; {
                     14:        long when, tod, now, diff, hours, minutes;
                     15:        int *nv;
                     16:        int atoi();
                     17:        int *localtime();
                     18: 
                     19:        if (argc < 2) {
                     20:                printf("When do you have to leave? ");
                     21:                buff[read(0,buff,sizeof buff)] = 0;
                     22:        } else {
                     23:                strcpy(buff,argv[1]);
                     24:        }
                     25:        if (buff[0] == '\n') exit(0);
                     26:        if (buff[0] == '+') {
                     27:                diff = atoi(buff+1);
                     28:                doalarm(diff);
                     29:        }
                     30:        if (buff[0] < '0' || buff[0] > '9') {
                     31:                printf("usage: %s [hhmm]\n",argv[0]);
                     32:                exit(1);
                     33:        }
                     34:        strcpy(origlogin,getlogin());
                     35: 
                     36:        tod = atoi(buff);
                     37:        hours = tod / 100;
                     38:        if (hours > 12) hours -= 12;
                     39:        if (hours == 12) hours = 0;
                     40:        minutes = tod % 100;
                     41: 
                     42:        if (hours < 0 || hours > 12 || minutes < 0 || minutes > 59) {
                     43:                printf("usage: %s [hhmm]\n",argv[0]);
                     44:                exit(1);
                     45:        }
                     46: 
                     47:        setexit();      /* refigure time if killed */
                     48:        time(&now);
                     49:        nv = localtime(&now);
                     50:        when = 60*hours+minutes;
                     51:        if (nv[2] > 12) nv[2] -= 12;    /* do am/pm bit */
                     52:        now = 60*nv[2] + nv[1];
                     53:        diff = when - now;
                     54:        while (diff < 0)
                     55:                diff += 12*60;
                     56:        if (diff > 11*60) printf("That time has already passed!\n");
                     57:        doalarm(diff);
                     58:        exit(0);
                     59: }
                     60: 
                     61: 
                     62: doalarm(nmins) long nmins; {
                     63:        char *msg1, *msg2, *msg3, *msg4;
                     64:        register int i;
                     65:        int slp1, slp2, slp3, slp4;
                     66:        int seconds, gseconds;
                     67:        long daytime;
                     68: 
                     69:        seconds = 60 * nmins;
                     70:        if (seconds <= 0) seconds = 1;
                     71:        gseconds = seconds;
                     72: 
                     73:        msg1 = "You have to leave in 5 minutes";
                     74:        if (seconds <= 60*5) {
                     75:                slp1 = 0;
                     76:        } else {
                     77:                slp1 = seconds - 60*5;
                     78:                seconds = 60*5;
                     79:        }
                     80: 
                     81:        msg2 = "Just one more minute!";
                     82:        if (seconds <= 60) {
                     83:                slp2 = 0;
                     84:        } else {
                     85:                slp2 = seconds - 60;
                     86:                seconds = 60;
                     87:        }
                     88: 
                     89:        msg3 = "Time to leave!";
                     90:        slp3 = seconds;
                     91: 
                     92:        msg4 = "You're going to be late!";
                     93:        slp4 = 60;
                     94: 
                     95:        time(&daytime);
                     96:        daytime += gseconds;
                     97:        whenleave = ctime(&daytime);
                     98:        printf("Alarm set for %s\n",whenleave);
                     99:        if (fork()) exit(0);
                    100:        signal(2,1);
                    101:        signal(3,1);
                    102:        signal(15,1/*nag*/);
                    103: 
                    104:        if (slp1)
                    105:                bother(slp1,msg1);
                    106:        if (slp2)
                    107:                bother(slp2,msg2);
                    108:        bother(slp3,msg3);
                    109:        for (;;) {
                    110:                bother(slp4,msg4);
                    111:        }
                    112: }
                    113: 
                    114: bother(slp,msg) int slp; char *msg; {
                    115: 
                    116:        delay(slp);
                    117:        printf("\7\7\7");
                    118:        printf("%s\n",msg);
                    119: }
                    120: 
                    121: /*
                    122:  * delay is like sleep but does it in 100 sec pieces and
                    123:  * knows what zero means.
                    124:  */
                    125: delay(secs) int secs; {
                    126:        int n;
                    127: 
                    128:        while(secs>0) {
                    129:                n = 100;
                    130:                secs = secs - 100;
                    131:                if (secs < 0) {
                    132:                        n = n + secs;
                    133:                }
                    134:                if (n > 0) sleep(n);
                    135:                strcpy(thislogin,getlogin());
                    136:                if (strcmp(origlogin, thislogin)) exit(0);
                    137:        }
                    138: }
                    139: 
                    140: #ifndef VAX
                    141: char *getlogin() {
                    142: #include <utmp.h>
                    143:        static struct utmp ubuf;
                    144:        int ufd;
                    145: 
                    146:        ufd = open("/etc/utmp",0);
                    147:        seek(ufd, ttyn(0)*sizeof(ubuf), 0);
                    148:        read(ufd, &ubuf, sizeof(ubuf));
                    149:        ubuf.ut_name[8] = 0;
                    150:        return(&ubuf.ut_name);
                    151: }
                    152: #endif

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.