Return to leave.c CVS log

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

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

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

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