Return to gnxseq.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / uucp

Annotation of 43BSDReno/usr.bin/uucp/gnxseq.c, revision 1.1.1.1

1.1       root        1: #ifndef lint
                      2: static char sccsid[] = "@(#)gnxseq.c   5.4 (Berkeley) 6/20/85";
                      3: #endif
                      4: 
                      5: #include "uucp.h"
                      6: #ifdef BSD4_2
                      7: #include <sys/time.h>
                      8: #else sane
                      9: #include <time.h>
                     10: #endif sane
                     11: 
                     12: /*LINTLIBRARY*/
                     13: 
                     14: #ifdef GNXSEQ
                     15: 
                     16: /*
                     17:  *     get next conversation sequence number
                     18:  *
                     19:  *     return - 0 no entry | >0 sequence number
                     20:  */
                     21: 
                     22: gnxseq(rmtname)
                     23: char *rmtname;
                     24: {
                     25:        int count = 0, ct, ret, i;
                     26:        register struct tm *tp;
                     27:        extern struct tm *localtime();
                     28:        time_t clock;
                     29:        register FILE *fp0, *fp1;
                     30:        char buf[BUFSIZ], name[NAMESIZE];
                     31: 
                     32:        if (access(SQFILE, 0) != 0)     /* nothing to do here */
                     33:                return(0);
                     34: 
                     35:        for (i = 0; i < 5; i++) {
                     36:                if ((ret = ulockf(SQLOCK, (time_t)  SQTIME)) == 0)
                     37:                        break;
                     38:                sleep(5);
                     39:        }
                     40:        if (ret != 0) {
                     41:                logent("CAN'T LOCK", SQLOCK);
                     42:                DEBUG(4, "can't lock %s\n", SQLOCK);
                     43:                return(0);
                     44:        }
                     45:        if ((fp0 = fopen(SQFILE, "r")) == NULL)
                     46:                return(0);
                     47:        if ((fp1 = fopen(SQTMP, "w")) == NULL) {
                     48:                fclose(fp0);
                     49:                return(0);
                     50:        }
                     51:        chmod(SQTMP, 0400);
                     52: 
                     53:        while (fgets(buf, BUFSIZ, fp0) != NULL) {
                     54:                ret = sscanf(buf, "%s%d", name, &ct);
                     55:                if (ret < 2)
                     56:                        ct = 0;
                     57:                name[MAXBASENAME] = '\0';
                     58:                if (ct > 9998)
                     59:                        ct = 0;
                     60:                if (strncmp(rmtname, name, MAXBASENAME) != SAME) {
                     61:                        fputs(buf, fp1);
                     62:                        continue;
                     63:                }
                     64: 
                     65:                /*  found name  */
                     66:                count = ++ct;
                     67:                time(&clock);
                     68:                tp = localtime(&clock);
                     69: #ifdef USG
                     70:                fprintf(fp1, "%s %d %d/%d-%2.2d:%2.2d\n", name, ct,
                     71:                  tp->tm_mon + 1, tp->tm_mday, tp->tm_hour,
                     72:                  tp->tm_min);
                     73: #endif
                     74: #ifndef USG
                     75:                fprintf(fp1, "%s %d %d/%d-%02d:%02d\n", name, ct,
                     76:                  tp->tm_mon + 1, tp->tm_mday, tp->tm_hour,
                     77:                  tp->tm_min);
                     78: #endif
                     79:                while (fgets(buf, BUFSIZ, fp0) != NULL)
                     80:                        fputs(buf, fp1);
                     81:        }
                     82:        fclose(fp0);
                     83:        fclose(fp1);
                     84:        if (count == 0) {
                     85:                rmlock(SQLOCK);
                     86:                unlink(SQTMP);
                     87:        }
                     88:        return(count);
                     89: }
                     90: 
                     91: 
                     92: /***
                     93:  *     cmtseq()        commit sequence update
                     94:  *
                     95:  *     return  0  ok | other - link failed
                     96:  */
                     97: 
                     98: cmtseq()
                     99: {
                    100:        register int ret;
                    101: 
                    102:        if ((ret = access(SQTMP, 04)) != 0) {
                    103:                rmlock(SQLOCK);
                    104:                return(0);
                    105:        }
                    106:        unlink(SQFILE);
                    107:        ret = link(SQTMP, SQFILE);
                    108:        unlink(SQTMP);
                    109:        rmlock(SQLOCK);
                    110:        return(ret);
                    111: }
                    112: 
                    113: /***
                    114:  *     ulkseq()        unlock sequence file
                    115:  */
                    116: 
                    117: ulkseq()
                    118: {
                    119:        unlink(SQTMP);
                    120:        rmlock(SQLOCK);
                    121: }
                    122: #endif GNXSEQ

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