Return to olock.c CVS log

Up to [Research Unix] / researchv8dc / cmd / Mail

Annotation of researchv8dc/cmd/Mail/olock.c, revision 1.1

1.1     ! root        1: #
        !             2: 
        !             3: /*
        !             4:  * A mailing program.
        !             5:  *
        !             6:  * Stuff to do version 7 style locking.
        !             7:  */
        !             8: 
        !             9: #include "rcv.h"
        !            10: #include <sys/stat.h>
        !            11: 
        !            12: static char *SccsId = "@(#)lock.c      2.3 12/17/82";
        !            13: 
        !            14: static int             locked;                 /* To note that we locked it */
        !            15: static         char            lockfile[64];           /* Last locked file */
        !            16: 
        !            17: /*
        !            18:  * Lock the specified mail file by setting the execute bit on mailfile.
        !            19:  * We must, of course, be careful to remove the lock by a call
        !            20:  * to unlock before we stop.  The algorithm used here is to see if
        !            21:  * the lock exists, and if it does, to check its modify time.  If it
        !            22:  * is older than 5 minutes, we assume error and set our own lock.
        !            23:  * Otherwise, we wait for 5 seconds and try again.
        !            24:  */
        !            25: 
        !            26: lock(file)
        !            27: char *file;
        !            28: {
        !            29:        register int f;
        !            30:        struct stat sbuf;
        !            31:        long curtime;
        !            32: 
        !            33:        if (file == NOSTR) {
        !            34:                printf("Locked = %d\n", locked);
        !            35:                return(0);
        !            36:        }
        !            37:        if (locked)
        !            38:                return(0);
        !            39:        strcpy(lockfile, file);
        !            40:        for (;;) {
        !            41:                f = lock1(file);
        !            42:                if (f == 0) {
        !            43:                        locked = 1;
        !            44:                        return(0);
        !            45:                }
        !            46:                if (stat(file, &sbuf) < 0)
        !            47:                        return(0);
        !            48:                time(&curtime);
        !            49:                if (curtime < sbuf.st_ctime + 300) {
        !            50:                        sleep(5);
        !            51:                        continue;
        !            52:                }
        !            53:                unlock();
        !            54:        }
        !            55: }
        !            56: 
        !            57: /*
        !            58:  * Remove the mail lock, and note that we no longer
        !            59:  * have it locked.
        !            60:  */
        !            61: 
        !            62: unlock()
        !            63: {
        !            64:        struct stat sbuf;
        !            65: 
        !            66:        if (stat(lockfile, &sbuf) < 0)
        !            67:                return;
        !            68:        if (chmod(lockfile, sbuf.st_mode & ~01) < 0)
        !            69:                return;
        !            70:        locked = 0;
        !            71: }
        !            72: 
        !            73: /*
        !            74:  * Attempt to set the lock by setting the execute bit.
        !            75:  * If it fails, return -1 else 0
        !            76:  */
        !            77: 
        !            78: lock1(file)
        !            79: char *file;
        !            80: {
        !            81:        struct stat sbuf;
        !            82: 
        !            83:        if (stat(file, &sbuf) < 0)
        !            84:                return(-1);
        !            85:        if (sbuf.st_mode & 01)
        !            86:                return(-1);
        !            87:        if (chmod(file, sbuf.st_mode | 01) < 0)
        !            88:                return(-1);
        !            89:        return(0);
        !            90: }

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