Return to logent.c CVS log

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

Annotation of researchv8dc/cmd/uucp/logent.c, revision 1.1

1.1     ! root        1: /*     /sccs/src/cmd/uucp/s.logent.c
        !             2:        logent.c        1.2     8/30/84 17:37:31
        !             3: */
        !             4: #include "uucp.h"
        !             5: VERSION(@(#)logent.c   1.2);
        !             6: 
        !             7: static FILE    *_Lf = NULL;
        !             8: static int     _Sf = -1;
        !             9: 
        !            10: /*
        !            11:  * Make log entry
        !            12:  *     text    -> ptr to text string
        !            13:  *     status  -> ptr to status string
        !            14:  * Returns:
        !            15:  *     none
        !            16:  */
        !            17: void
        !            18: logent(text, status)
        !            19: register char  *text, *status;
        !            20: {
        !            21:        static  char    logfile[MAXFULLNAME];
        !            22: 
        !            23:        if (*Rmtname == NULLCHAR) /* ignore logging if Rmtname is not yet set */
        !            24:                return;
        !            25:        if (Nstat.t_pid == 0)
        !            26:                Nstat.t_pid = getpid();
        !            27: 
        !            28:        if (_Lf != NULL
        !            29:           && strncmp(Rmtname, BASENAME(logfile, '/'), SYSNSIZE) != 0) {
        !            30:                fclose(_Lf);
        !            31:                _Lf = NULL;
        !            32:        }
        !            33: 
        !            34:        if (_Lf == NULL) {
        !            35:                sprintf(logfile, "%s/%s", Logfile, Rmtname);
        !            36:                _Lf = fopen(logfile, "a");
        !            37:                (void) chmod(logfile, 0644);
        !            38:                if (_Lf == NULL)
        !            39:                        return;
        !            40:                setbuf(_Lf, CNULL);
        !            41:        }
        !            42:        (void) fseek(_Lf, 0L, 2);
        !            43:        (void) fprintf(_Lf, "%s %s %s ", User, Rmtname, Jobid);
        !            44:        (void) fprintf(_Lf, "(%s,%d,%d) ", timeStamp(), Nstat.t_pid, Seqn);
        !            45:        (void) fprintf(_Lf, "%s (%s)\n", status, text);
        !            46:        return;
        !            47: }
        !            48: 
        !            49: 
        !            50: /*
        !            51:  * Make entry for a conversation (uucico only)
        !            52:  *     text    -> pointer to message string
        !            53:  * Returns:
        !            54:  *     none
        !            55:  */
        !            56: void
        !            57: syslog(text)
        !            58: register char  *text;
        !            59: {
        !            60:        int     sbuflen;
        !            61:        char    sysbuf[BUFSIZ];
        !            62: 
        !            63:        (void) sprintf(sysbuf, "%s!%s %s (%s) (%c,%d,%d) [%s] %s\n",
        !            64:                Rmtname, User, Role == SLAVE ? "S" : "M", timeStamp(),
        !            65:                Pchar, getpid(), Seqn, Dc, text);
        !            66:        sbuflen = strlen(sysbuf);
        !            67:        if (_Sf < 0) {
        !            68:                errno = 0;
        !            69:                _Sf = open(SYSLOG, 1);
        !            70:                if (errno == ENOENT) {
        !            71:                        _Sf = creat(SYSLOG, 0644);
        !            72:                        (void) chmod(SYSLOG, 0644);
        !            73:                }
        !            74:                if (_Sf < 0)
        !            75:                        return;
        !            76:        }
        !            77:        (void) lseek(_Sf, 0L, 2);
        !            78:        (void) write(_Sf, sysbuf, sbuflen);
        !            79:        return;
        !            80: }
        !            81: 
        !            82: 
        !            83: /*
        !            84:  * Close log files before a fork
        !            85:  */
        !            86: void
        !            87: closelog()
        !            88: {
        !            89:        if (_Sf >= 0) {
        !            90:                (void) close(_Sf);
        !            91:                _Sf = -1;
        !            92:        }
        !            93:        if (_Lf) {
        !            94:                (void) fclose(_Lf);
        !            95:                _Lf = NULL;
        !            96:        }
        !            97: }
        !            98: 
        !            99: /*
        !           100:  *     millitick()
        !           101:  *
        !           102:  *     return msec since last time called
        !           103:  */
        !           104: #ifdef ATTSV
        !           105: time_t
        !           106: millitick()
        !           107: {
        !           108:        struct tms      tbuf;
        !           109:        time_t  now, rval;
        !           110:        static time_t   past;   /* guaranteed 0 first time called */
        !           111: 
        !           112:        if (past == 0) {
        !           113:                past = times(&tbuf);
        !           114:                rval = 0;
        !           115:        } else {
        !           116:                rval = ((now = times(&tbuf)) - past) * 1000 / HZ;
        !           117:                past = now;
        !           118:        }
        !           119:        return(rval);
        !           120: }
        !           121: 
        !           122: #else !ATTSV
        !           123: time_t
        !           124: millitick()
        !           125: {
        !           126:        struct timeb    tbuf;
        !           127:        static struct timeb     tbuf1;
        !           128:        static past;            /* guaranteed 0 first time called */
        !           129:        time_t  rval;
        !           130: 
        !           131:        if (past == 0) {
        !           132:                past++;
        !           133:                rval = 0;
        !           134:                ftime(&tbuf1);
        !           135:        } else {
        !           136:                ftime(&tbuf);
        !           137:                rval = (tbuf.time - tbuf1.time) * 1000
        !           138:                        + tbuf.millitm - tbuf1.millitm;
        !           139:                tbuf1 = tbuf;
        !           140:        }
        !           141:        return(rval);
        !           142: }
        !           143: #endif ATTSV

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