8322 nl: misleading-indentation

[unleashed/tickless.git] / usr / src / cmd / bnu / perfstat.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 1997 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/*        All Rights Reserved   */


#pragma ident   "%Z%%M% %I%     %E% SMI"
/*
* This module is intended to collect performance statistics about the
* operation of uucico.  All instances of uucico will write their log
* entries to the files who's path is defined by PERFLOG.  Statistics
* will only be collected if PERFLOG exists when uucico starts, it will
* not be created automatically.  This gives the SA an easy way to turn
* statistics collection on or off at run time.  Three types
* of records will be written to the file, and each record will be
* identified by a mnemonic type at the begining of the record.  The record
* types are as follows:
*
*       conn -          Contains statistics about the establishment of
*                       a connection.
*
*       xfer -          Contains statistics about a file transfer.
*
* The intention is to use grep to select the conn and xfer records and put
* them in two Unity data bases.  No attempt will be made to process the
* error records with Unity.
*
* Both the conn and the xfer records will contain a time stamp field.
* This field will be written in case there is a desire to do time of
* day traffic studies.  The time that will be written will be GMT
* to avoid the vagaries of time zone setting for uucico.  The time
* stamp will contain 12 digits of the form YYMMDDhhmmss.  This allows
* proper sorting by time, and the fixed length field type of Unity
* can be used to pick it apart if necessary.  The time stamp is the
* time that the record is written.
*
* Statistics will be collected on the wall clock (real) time to perform
* an action and CPU consumption to perform an action.  These times will
* be written in seconds and fractions of a second to two decimal places.
*
* The conn and xfer records will be written so that they can be processed
* with the following Unity schema (D files).  For those not familiar with
* Unity, the columns are:
*
*       column 1 -      field name
*       column 2 -      field type (t=variable width) and field separator.
*       column 3 -      number of columns to use when printing the field
*                       with uprint.
*       column 4 -      a user friendly field name.
*
* Conn:
*
*       type    t|      4       record type (always conn)
*       ts      t|      12      time stamp
*       procid  t|      5       uucico's process id
*       myname  t|      6       name of the machine where the record is written
*       role    t|      1       M = master, S = slave
*       remote  t|      6       name of remote system
*       device  t|      6       name of device used for connection
*       protocol t|     1       the protocal that is used for communication
*       netid   t|      6       physical network ID
*       real    t|      6       real time to connect
*       user    t|      6       user time to connect
*       sys     t\n     6       system (kernal) time to connect
*
* The timer for connection processing starts immediately after the
* command line processing is complete, and it is stopped after the
* protocol has been selected.
*
* Xfer:
*
*       type    t|      4       record type (always xfer)
*       jobgrade t|     1       job grade ID
*       ts      t|      12      time stamp
*       procid  t|      5       uucico's process id
*       myname  t|      6       name of the machine where the record is written
*       role    t|      1       M = master, S = slave
*       remote  t|      6       name of remote system
*       device  t|      6       name of device used for connection
*       protocol t|     1       the protocal that is used for communication
*       netid   t|      6       physical network ID
*       job     t|      7       name of the job.  (Master only).
*       inqueue t|      6       time in seconds that file was in queue (Master
*                                       only).
*       tat     t|      6       turn around time in sec.  (Master only).
*       bytes   t|      6       size of the file that was transferred
*       flags   t|      3       m = mail to requester on completion,
*                               n = notify remote user, s = write status
*                               file.  (Master only).
*       streal  t|      6       real time to start up transfer (master only).
*       stuser  t|      6
*       stsys   t|      6
*       xfrreal t|      6       real time to transfer file
*       xfruser t|      6
*       xfrsys  t|      6
*       trmreal t|      6       real time to terminate the transfer
*       trmuser t|      6
*       trmsys  t|      6
*       text    t|      12      "PARTIAL FILE" if the data is being transmitted
*                               before breaking the transmission; blank if the 
*                               partial file after the breakpoint or the whole
*                               file is being transmitted completely.
*
* Start up time includes the time for the master to search the queues
* for the next file, for the master and slave to exchange work vectors,
* and time to open files.  It is only recorded on the master.
* Xfer times is the time to transfer the data, close the file, and
* exchange confirmation messages.  Termination time is the time to send
* mail notifications and write status files.  Turn around time is the
* difference between the time that the file was queued and the time that
* the final notification was sent.
*/

#include        "uucp.h"
#include        "log.h"

/*
*               SYMBOL DEFINITIONS
*/

#define FS              '|'     /* Field seperator for output records. */
#define LOGCHECK        {if ((Initialized == FALSE) || \
                                (Collecting == FALSE)) return; }

/* Subscripts for connection time marks: */

#define CT_START        0       /* Start connection establishment. */
#define CT_CONNECTED    1       /* Connection completed. */
#define CT_SIZE         2       /* Number of elements in array. */

/* Subscripts for xfer time marks: */

#define XT_LOOK         0       /* Start looking for a file (master only). */
#define XT_FOUND        1       /* File found (master only). */
#define XT_BEGXFER      2       /* Start of xfer of data. */
#define XT_ENDXFER      3       /* Data xfer complete. */
#define XT_ENDFILE      4       /* Done mailing and notifying. */
#define XT_SIZE         5       /* Number of elements in array. */

/*
*               STRUCTURE DEFINITIONS
*/

typedef struct timeUsed         /* Time consummed between events. */
                {
                        float   tu_real;        /* Real time used. */
                        float   tu_user;        /* User time used. */
                        float   tu_sys;         /* System time used. */
                } TUSED;

typedef struct timeMark         /* Holds times for an event. */
                {
                        int     tm_valid;       /* True if data present. */
                        long    tm_real;        /* Relative wall clock. */
                        struct tms tm_cycles;   /* CPU consumption. */
                } TMARK;

struct connData                 /* Data for construction of conn record. */
                {
                        char    cn_role;        /* Master/slave indicator. */
                        TMARK   cn_times[CT_SIZE]; /* Event data. */
                };

struct xferData                 /* Data for construction of xfer record. */
                {
                        char    xf_role;        /* Master/slave indicator. */
                        char    xf_direction;   /* Send/receive indicator. */
                        time_t  xf_intoque;     /* Time that file was placed
                                                 *   in the queue. (master
                                                 *   only). */
                        long    xf_deque;       /* Time that file was
                                                 *   dequeued. (master only)*/
                        long    xf_filedone;    /* Time that file was
                                                 *   completed. */
                        char    xf_jobname[MODSTR]; /* C. file (master only)*/
                        char    xf_jobgrade[MODSTR]; /* job grade id */
                        off_t   xf_bytes;       /* Bytes transferred. */
                        char    xf_flags[MODSTR]; /* Notification flags. */
                        TMARK   xf_times[XT_SIZE]; /* Event data. */
                };

/*
*               LOCAL DATA
*/

static int              Collecting = FALSE; /* True if we are collecting
                                             *   data. */
static struct connData  Conn = {0};     /* Connection data. */
static char             Device[MODSTR] = ""; /* Type of communication
                                              *    device. */
static int              Initialized = FALSE; /* True if we have been
                                              *   initialized. */
static int              LogFile = CLOSED; /* Log file file destriptor. */
static char             LogName[] = PERFLOG; /* Name of our log file. */
static pid_t            Procid = {0};   /* Our processid. */
static char             Record[LOGSIZE]; /* Place to build log records. */
static char             Remote[MODSTR] = ""; /* Name of the remote system. */
static char             myname[MAXBASENAME+1] = ""; /* Name of the source system
                                                        . */
static char             Protocol[MODSTR]; /* Protocol in use */
static char             Netid[MODSTR] = NOTAVAIL; /* Network ID in use */
static struct xferData  Xfer = {0};     /* Transfer data. */

/* Messages: */

static char     Msg_badopen[] = "failed to open %s.  Errno=%%d\n";
static char     Msg_opening[] = "attempting to open %s\n";
static char     Msg_write[] = "error in writing to %s.  Errno=%%d.\n";

/*
*               LOCAL FUNCTIONS
*/

/* Declarations of functions: */

STATIC_FUNC void        grabTimes();
STATIC_FUNC void        pfloat();
STATIC_FUNC void        reportConn();
STATIC_FUNC void        reportFile();
STATIC_FUNC void        reportTimes();
STATIC_FUNC void        subTimes();


/*
* Local Function:       grabTimes - Get Real and CPU Times
*
* This function uses times(2) to obtain the current real time and CPU
* consumption.  The time mark is also marked as valid.
*
* Parameters:
*
*       markptr -       Address of structure to save times.
*
* Return:
*
*       none.
*/

STATIC_FUNC void
grabTimes (markptr)

register TMARK *        markptr;

{
        markptr->tm_real = times(&markptr->tm_cycles);
        if (markptr->tm_real != FAIL)
                markptr->tm_valid = TRUE;
        return;
}


/*
* Local Function:       pfloat - Print a Floating Number
*
* Format a floating point number for output to the Unity data base.
* If the number is NOTIME, "na" will be displayed instead.
*
* Parameters:
*
*       dest -          The result will be concatenated to this string.
*
*       number -        The number to be formated.
*
*       sep -           Field separator character.
*/

STATIC_FUNC void
pfloat (dest, number, sep)

char *          dest;
double          number;         /* float is promoted to double for args. */
char            sep;

{
        static char     rformat[] = "%c%.2f";
        static char     naformat[] = "%c%s";

        register char * cp;

        cp = dest + strlen(dest);
        if (number == (float) NOTIME)
                sprintf(cp, naformat, sep, NOTAVAIL);
        else
                sprintf(cp, rformat, sep, number);
        return;
}

/*
* Local Function:       reportConn - Write Out Conn Record
*
* This function writes a conn record to the logfile.
*
* Parameters:
*
*       None.
*
* Returns:
*
*       None.
*/

STATIC_FUNC void
reportConn ()

{
        TUSED   contimes;       /* Times to make connection. */
        static char     format[] = "%s%c%s%c%ld%c%s%c%c%c%s%c%s%c%s%c%s";

        sprintf(Record, format,
                "conn", FS,             /* record type. */
                gmt(), FS,              /* current time. */
                (long) Procid, FS,      /* our process id. */
                myname, FS,             /* name of local system */
                Conn.cn_role, FS,       /* slave or master. */
                Remote, FS,             /* name of remote system. */
                Device, FS,             /* device used for communication. */
                Protocol, FS,           /* protocol used for comm. */
                Netid                   /* Network ID */
               );
        subTimes(&contimes, &Conn.cn_times[CT_CONNECTED],
                        &Conn.cn_times[CT_START]);
        reportTimes(Record, &contimes, FS);
        strcat(Record, EOR);
        writeLog(Record,&LogFile,LogName,&Collecting);
        return;
}

/*
* Local Function:       reportFile - Write File Statistics to Log
*
* This function writes statistics about the current file to the log
* file.
*
* Parameters:
*
*       none.
*/

STATIC_FUNC void
reportFile (breakmsg)
char * breakmsg;

{
                                     /* minuend,        subtrahand */
        static int      drvtab[] = {
                                        XT_FOUND,       XT_LOOK, /* startup */
                                        XT_ENDXFER,     XT_BEGXFER, /* xfer */
                                        XT_ENDFILE,     XT_ENDXFER /* term. */
                                   };
        static char     format1[] = "%s%c%s%c%s%c%ld%c%s%c%c%c%s%c%s%c%s%c%s%c%s";
        static char     format2[] = "%c%ld%c%s"; /* Bytes & flags. */

        register struct xferData *      xdptr;
        register TMARK *                tdptr;
        register int                    i;

        TUSED           diff;           /* time difference between events. */
        float           inque;          /* time in queue. */
        int             lastbyte;       /* Offset to last byte in Record. */
        char *          na = NOTAVAIL;  /* String to show data not available*/
        char            role;           /* Current master/slave status. */
        float           tat;            /* Turn around time. */

        xdptr = &Xfer;                  /* Point to Xfer data. */
        role = xdptr->xf_role;
        sprintf(Record, format1,
                "xfer", FS,             /* Record type. */
                (role == MCHAR) ? xdptr->xf_jobgrade : na ,FS, /* job grade */
                gmt(), FS,              /* Current time. */
                (long) Procid, FS,      /* Our process id. */
                myname, FS,             /* name of local system */
                role, FS,               /* master/slave. */
                Remote, FS,             /* remote. */
                Device, FS,             /* communications device. */
                Protocol, FS,           /* protocol used for comm. */
                Netid, FS,                      /* Network ID */
                (role == MCHAR) ? xdptr->xf_jobname : na
               );

        /* Do time in queue and turn around time. */

        if (role == MCHAR)
        {
                inque = (float) (xdptr->xf_deque - xdptr->xf_intoque);
                tat = (float) (xdptr->xf_filedone - xdptr->xf_intoque);
        } else
        {
                inque = (float) NOTIME; /* Not app. if not master. */
                tat = (float) NOTIME;
        }
        pfloat(Record, inque, FS);
        pfloat(Record, tat, FS);

        /*
        * Report bytes transferred and notification flags.
        */

        lastbyte = strlen(Record);
        (void) sprintf(Record+lastbyte, format2,
                        FS, getfilesize(),FS,
                        (role == MCHAR) ? xdptr->xf_flags : na
                      );

        /*
        * Report resource consumption for file startup, file transfer,
        * and file termination.  This means reporting the differences
        * between pairs of elements in the xf_times array of Xfer.  This
        * will be controled by drvtab which contains pairs of subscripts
        * to designate the xf_times elements.
        */

        tdptr = &xdptr->xf_times[0];
        for (i = 0; i < sizeof(drvtab)/(sizeof(int)); i += 2)
        {
                subTimes(&diff, (tdptr + drvtab[i]), (tdptr + drvtab[i+1]));
                reportTimes(Record, &diff, FS);
        }

        /*
        * write file status
        */

        lastbyte = strlen(Record);
        (void) sprintf(Record+lastbyte, "%c%s%c",
                        FS, (*breakmsg == NULLCHAR) ? NOTAVAIL : breakmsg, FS);

        /* Terminate the record and write it out. */

        (void) strcat(Record, EOR);
        writeLog(Record,&LogFile,LogName,&Collecting);
        return;
}

/*
* Local Function:       reportTimes - Print Real, User, and Sys Times
*
* This function is used to convert the real, user, and system times from
* a TUSED structure to Ascii strings.  The results are concatenated to
* the dest string.  If any of the times are NOTIME, they will be reported
* as "na".  The fields will be seperated by the sep character and the
* sep character will be the first character concatenated to the buffer.  No
* seperator character will be placed at the end.  Thus, the output string
* will be of the form:
*
*       |real|user|sys
*
* Parameters:
*
*       dest -          String to receive Ascii times.
*
*       diffptr -       Address of the time data.
*
*       sep -           The field seperator character.
*/

STATIC_FUNC void
reportTimes (dest, diffptr, sep)

register char *         dest;
register TUSED *        diffptr;
char                    sep;

{
        pfloat(dest, diffptr->tu_real, sep);
        pfloat(dest, diffptr->tu_user, sep);
        pfloat(dest, diffptr->tu_sys, sep);
        return;
}

/*
* Local Function:       subTimes - Subtract Times Between Events
*
* This function takes the output from two calls to times(2) in the form
* of two TMARK structures, and determines the amount of time consummed
* for various categories.  The result is stored in the specified
* TUSED structure.
*
* Parameters:
*
*       diff -          Place to store the result of the subtraction.
*       minuend -       The second time event.
*       subtra -        The subtrahend in the subtraction.  This should
*                       be the first of two time events.
*
* On the large scale this function does the following:
*
*       diff = minuend - subtra
*/

STATIC_FUNC void
subTimes (diff, minuend, subtra)

register TUSED *        diff;
register TMARK *        minuend;
register TMARK *        subtra;

{
        register struct tms *   mintms;
        register struct tms *   subtms;

        long    ltemp;          /* Temporary storage for long arith. */
        float   ticks;          /* Clock interrupts per second. */

        if ((minuend->tm_valid != TRUE) || (subtra->tm_valid != TRUE))
        {                               /* If data has not been collected. */
                diff->tu_real = NOTIME;
                diff->tu_user = NOTIME;
                diff->tu_sys = NOTIME;
        } else
        {
                ticks = (float) HZ;     /* HZ defined in <sys/param.h>. */
                mintms = &minuend->tm_cycles;
                subtms = &subtra->tm_cycles;

                /* Calculate real time. */

                ltemp = minuend->tm_real - subtra->tm_real;
                diff->tu_real = ((float) ltemp)/ticks;

                /* Calculate user time. */

                ltemp =   mintms->tms_utime
                        - subtms->tms_utime
                        + mintms->tms_cutime
                        - subtms->tms_cutime;
                diff->tu_user = ((float) ltemp)/ticks;

                /* Calculate user time. */

                ltemp =   mintms->tms_stime
                        - subtms->tms_stime
                        + mintms->tms_cstime
                        - subtms->tms_cstime;
                diff->tu_sys = ((float) ltemp)/ticks;
        }
        return;
}

/*
*               EXTERNAL FUNCTIONS
*/

/*
* Function:     gmt - Generate Current Time String
*
* This function returns the address a string containing the current
* GMT in the form YYMMDDhhmmss.
*
* Parameters:
*
*       none
*
* Return:
*
*       An address of a static character array containing the date.
*/

char *
gmt()

{
        static char     date[] = "YYMMDDhhmmss";

        register struct tm *    td;
        time_t                  now;    /* Current time. */

        now = time((time_t *) 0);
        td = gmtime(&now);
        (void) sprintf(date, "%02d%02d%02d%02d%02d%02d",
                                (td->tm_year % 100),
                                td->tm_mon + 1,
                                td->tm_mday,
                                td->tm_hour,
                                td->tm_min,
                                td->tm_sec
                      );
        return date;
}


/*
* Function:     writeLog - Write String to Log File
*
* After insuring that the log file is open, this function will write
* the specified string to the log file.  If a write error occurs,
* statistics collection will be disabled.
*
* Parameters:
*
*       string - Null terminated string to be written out.
*       logfile - file descripter
*       logname - name of log file.
*       collecting - log enable/disable
*/

void
writeLog (string, logfile, logname, collecting)

char *  string;
int *   logfile;
char *  logname;
int *   collecting;

{
        register int    length;         /* Length of the string. */
        register int    rv;             /* Return value from write. */

        char            errmsg[BUFSIZ]; /* Place for error messages. */

        if (openLog(logfile,logname) != SUCCESS){
                *collecting = FALSE;
                return;
        }
        length = strlen(string);
        do
        {
                rv = write(*logfile, string, (unsigned) length);
        } while ((rv < 0) && (errno == EINTR)); /* Retry if interrupted. */
        if (rv < length)
        {                               /* Error or incomplete output. */
                (void) sprintf(errmsg, Msg_write, logname);
                DEBUG(DB_IMPORTANT, errmsg, errno);

                /* If we had a write error, lets give up on loggine. */

                closeLog(logfile);
                *collecting = FALSE;
        }
        return;
}

/*
* Function:     closeLog - Close the Log File
*
* This function allows uucico to close the log file in preparation for
* forking.
*
* Parameters:
*
*       log file descriptor
*/

void
closeLog (logfile)
int     *logfile;

{
        if (*logfile != CLOSED)
        {
                (void) close(*logfile);
                *logfile = CLOSED;
        }
        return;
}


/*
* Function: copyText - Copy String to Dynamic Memory
*
* This function copies a string to a buffer.  It insures that there is
* no overflow of the buffer and that the result is null terminated.
*
* Parameters:
*
*       tptr -          address of the buffer where the string is to
*                       be stored.
*
*       size -          number of bytes in the buffer.
*
*       string -        string to be saved.
*
* Returns:
*
*       none.
*/

void
copyText (tptr, size, string)

register char * tptr;
register int    size;
char *          string;

{
        (void) strncpy(tptr, string, size);
        *(tptr + size - 1) = NULLCHAR;
        return;
}

/*
* Function:     pfConnected - Report Connection Completion
*
* Uucico uses pfConnected to tell this performance package that a connection
* has been established with the remote system.
*
* Parameters:
*
*       remote -        name of the remote system.
*
*       device -        the type of device being used for communicaitons.
*/

void
pfConnected (remote, device)

char *  remote;
char *  device;

{
        register int            i;
        register TMARK *        tptr;

        LOGCHECK;
        grabTimes(&Conn.cn_times[CT_CONNECTED]);
        copyText(Remote, sizeof(Remote), remote);
        copyText(Device, sizeof(Device), device);
        reportConn();
        tptr = &Conn.cn_times[0];

        /*
        * Mark connection times as invalid.  This is really unnecessary
        * since there should only be one connection per invocation of uucico.
        * We do it for consistency with use of the transfer data.
        */

        for (i = 0; i < CT_SIZE; i++, tptr++)
                tptr->tm_valid = FALSE;
        return;
}


/*
* Function:     pfEndFile - Report End of File
*
* Uucico uses pfEndFile to tell our statistics collection package that
* all processing has been finished on the current file.  PfEndfile should
* be called after all notifications have been done and after the status
* file has been written.  PfEndfile writes out a xfer record for the
* file that just completed.
*
* Parameters:
*
*       none
*/

void
pfEndfile (breakmsg)
char * breakmsg;
{
        register int            i;
        register TMARK *        tdptr;
        register struct xferData *      xptr = &Xfer;

        LOGCHECK;
        grabTimes(&Xfer.xf_times[XT_ENDFILE]);
        Xfer.xf_filedone = time((time_t *) 0);
        reportFile(breakmsg);

        /* Now that we have reported them, mark all times as invalid. */

        copyText(xptr->xf_flags, sizeof(xptr->xf_flags), NOTAVAIL);
        tdptr = &Xfer.xf_times[0];
        for (i = 0; i < XT_SIZE; i++, tdptr++)
                tdptr->tm_valid = FALSE;
        return;
}

/*
* Function:     pfEndXfer - File Transfer Complete
*
* Calling pfEndXfer tells the performance package that a file transfer
* has been completed.  It should be called after the destination site
* closes the file and confirms receipt, but before notifications are done.
*
* Parameters:
*
*       none
*/

void
pfEndXfer ()

{
        LOGCHECK;
        grabTimes(&Xfer.xf_times[XT_ENDXFER]);
        return;
}

/*
* Function:     pfFindFile - Looking for Another File
*
* Uucico uses pfFindFile to announce that it is going to explore the
* queues for another file transfer to do.  PfFindFile is only called
* when uucico is in the role of master.
*
* Parameters:
*
*       none
*/

void
pfFindFile ()

{
        LOGCHECK;
        grabTimes(&Xfer.xf_times[XT_LOOK]);
        return;
}

/*
* Function:     pfFound - Found Another File
*
* PfFound is a counterpart of pfFindFile.  It is called when a new file
* has been found.  Like pfFindFile it is called only by a master uucico.
*
* Parameters:
*
*       jobid -         The name of the job that was found.
*
*       flags -         Options flags that were stored in the queue.
*                       These flags are originally set by uucp.
*
*       intoQue -       The time that the C. file was placed in the queue.
*/

void
pfFound (jobid, flags, intoQue)

char *  jobid;
char *  flags;
time_t  intoQue;

{
        register struct xferData *      xptr = &Xfer;

        LOGCHECK;
        grabTimes(&xptr->xf_times[XT_FOUND]);
        copyText(xptr->xf_jobname, sizeof(xptr->xf_jobname), jobid);
        xptr->xf_jobgrade[0] = jobid[strlen(jobid)-5]; 
        xptr->xf_jobgrade[1] = NULLCHAR;/* get job grade from jobid */
        copyText(xptr->xf_flags, sizeof(xptr->xf_flags), flags);

        /* Save time that file was placed in queue and current time. */

        xptr->xf_intoque = intoQue;
        xptr->xf_deque = time((time_t *) 0);
        return;
}

/*
* Function:     pfInit - Initialize Performance Package
*
* This function allows the performance package to initialize its internal
* data structures.  It should be called one time only when uucico starts
* running.
*
* Parameters:
*
*       none
*/

void
pfInit ()

{
        register struct xferData *      xptr = &Xfer;

        if (Initialized == TRUE)
                return;
        Procid = getpid();
        myName(myname);
        copyText(xptr->xf_flags, sizeof(xptr->xf_flags), NOTAVAIL);

        /*
        * Attempt to open the log file.  If we can't do it, then we
        * won't collect statistics.
        */

        if (openLog(&LogFile,LogName) == SUCCESS)
                Collecting = TRUE;
        else
                Collecting = FALSE;
        Initialized = TRUE;
        return;
}

/*
* Function:     pfStrtConn - Going to Establish Connection
*
* Uucico uses pfStrtConn to announce that it is going to attempt
* to establish a connection.
*
* Parameters:
*
*       role -          An indication of whether uucico is currently
*                       running in master or slave mode.  M = master,
*                       S = slave.
*/

void
pfStrtConn (role)

char    role;
{
        LOGCHECK;
        grabTimes(&Conn.cn_times[CT_START]);
        Conn.cn_role = role;
        return;
}

/*
* Function:     pfStrtXfer - Starting File Transfer
*
* This function should be called just as the first byte of data is
* about to be transferred.
*
* Parameters:
*
*       role -          An indication of whether uucico is currently
*                       running in master or slave mode.  M = master,
*                       S = slave.
*
*       direction -     Direction of file transfer.  S = sending to
*                       remote, R = receiving from remote.
*/

void
pfStrtXfer(role, direction)

char    role;
char    direction;

{
        register struct xferData *      xptr = &Xfer;

        LOGCHECK;
        grabTimes(&xptr->xf_times[XT_BEGXFER]);
        xptr->xf_role = role;
        xptr->xf_direction = direction;
        return;
}

/*
        A protocol which both master and slave sides agree on
*/

void
pfPtcl(str)
char    *str;
{
        strcpy(Protocol,str);
        return;
}

/*
* Function:     openLog  - Open the Log File
*
* If the log file is already open this function immediately returns
* success.  Otherwise, an attempt is made to open the logfile in append
* mode.
*
* Parameters:
*
*       logfile - file descripter
*       logname - name of log file.
*
* Returns:
*
*       SUCCESS -       The log file is open.
*       FAIL -          Unable to open logfile.
*/

int
openLog (logfile,logname)
int     *logfile;
char    *logname;
{
        register int    fd;             /* File descriptor of log file. */

        int             level;          /* Level for debug message. */
        char            msgbuf[BUFSIZ];

        /* See if file already open. */

        if (*logfile != CLOSED)
                return (SUCCESS);

        /* Attempt to open the file. */

        DEBUG(DB_TRACE, Msg_opening, logname);
        do
        {
                fd = open(logname, O_WRONLY | O_APPEND);
        } while ((fd < 0) && (errno == EINTR)); /* Retry if interrupted. */
        if (fd < 0) {   /* Error on open. */
                (void) sprintf(msgbuf, Msg_badopen, logname);
                if (errno == ENOENT)
                        level = DB_DETAIL; /* If the file is not there
                                            *   it will usually mean
                                            *   that the SA doesn't
                                            *   want to collect
                                            *   statisitcs. */
                else
                        level = DB_IMPORTANT;   /* Unexpected error */
                DEBUG(level, msgbuf, errno); /* No log file. */
                return FAIL;
        } else {
                *logfile = fd;
                return SUCCESS;
        }
}

#ifdef BSD4_2
#include <sys/time.h>
#include <sys/times.h>
#include <sys/resource.h>

static clock_t
scale60(tvp)
        register struct timeval *tvp;
{
        return (tvp->tv_sec * 60 + tvp->tv_usec / 16667);
}

clock_t
times(tmsp)
        register struct tms *tmsp;
{
        struct rusage ru;
        struct timeval now;
        static time_t epoch;

        if (getrusage(RUSAGE_SELF, &ru) < 0)
                return (clock_t)(-1);
        tmsp->tms_utime = scale60(&ru.ru_utime);
        tmsp->tms_stime = scale60(&ru.ru_stime);
        if (getrusage(RUSAGE_CHILDREN, &ru) < 0)
                return (clock_t)(-1);
        tmsp->tms_cutime = scale60(&ru.ru_utime);
        tmsp->tms_cstime = scale60(&ru.ru_stime);
        if (gettimeofday(&now, (struct timezone *)0) < 0)
                return (clock_t)(-1);
        if (epoch == 0)
                epoch = now.tv_sec;
        now.tv_sec -= epoch;
        return (scale60(&now));
}
#endif /* BSD4_2 */