/*
 * 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 (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/*        All Rights Reserved   */


#ident  "%Z%%M% %I%     %E% SMI"        /* from SVR4 bnu:account.c 1.3 */
/*
*/

#include        "uucp.h"
#include        "log.h"
#include <pwd.h>

/*
*               SYMBOL DEFINITIONS
*/

#define FS              ' '     /* Field seperator for output records. */
#define STD             'S'     /* standard service. */
#define LOGCHECK        { if (Collecting == FALSE) return; }

/*
*               STRUCTURE DEFINITIONS
*/

struct acData                   /* Data for construction of account record. */
                {
                        char    uid[MODSTR]; /* user id */
                        char    jobID[MODSTR]; /* C. file */
                        off_t   jobsize;        /* Bytes transferred in a job.*/
                        char    status; /* transaction status */
                        char    service; /* service grade */
                        char    jobgrade[MODSTR]; /* job grade */
                        char    time[MODSTR]; /* date and time the job execed */
                        char    origSystem[MODSTR]; /* originating system's                                                        name */
                        char    origUser[MODSTR]; /* originator's login
                                                           name */
                        char    rmtSystem[MODSTR]; /* system's name of
                                                           first hop */
                        char    rmtUser[MODSTR]; /* user's name of first
                                                           hop */
                        char    device[MODSTR]; /* network medium */
                        char    netid[MODSTR]; /* Network ID in use */
                        char    type[MODSTR]; /* type of transaction */
                        char    path[BUFSIZ]; /* path of the rest of the hops */

                };

/*
*               LOCAL DATA
*/

static int              Collecting = FALSE; /* True if we are collecting
                                             *   data. */
static int              LogFile = CLOSED; /* Log file file destriptor. */
static char             LogName[] = ACCOUNT; /* Name of our log file. */
static char             Record[LOGSIZE]; /* Place to build log records. */

static struct acData    Acct;   /* Accounting data. */

/*
*               LOCAL FUNCTIONS
*/

/* Declarations of functions: */

STATIC_FUNC void        reportJob();

/*
* Local Function:       reportJob - Write Job accounting information to Log
*
* This function writes accounting information about the current job to the log
* file.
*
* Parameters:
*
*       none.
*/

STATIC_FUNC void
reportJob ()

{
        static char     format[] = "%s%c%s%c%ld%c%c%c%c%c%s%c%s%c%s%c(%s)%c%s%c%s%c%s%c%s%c%s%c%s%c";

        register struct acData *        acptr;

        acptr = &Acct;                  /* Point to Acct data. */
        sprintf(Record, format,
                acptr->uid, FS,
                acptr->jobID, FS,
                acptr->jobsize, FS,
                acptr->status, FS,
                acptr->service, FS,
                acptr->jobgrade, FS,
                acptr->origSystem, FS,
                acptr->origUser, FS,
                acptr->time, FS,
                acptr->rmtSystem, FS,
                acptr->rmtUser, FS,
                acptr->device, FS,
                acptr->netid, FS,
                acptr->type, FS,
                acptr->path, FS);

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

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


/*
*               EXTERNAL FUNCTIONS
*/

/*
* Function:     acConnected - Report Connection Completion
*
* Parameters:
*
*       remote -        name of the remote system.
*
*       device -        the type of device being used for communicaitons.
*/

void
acConnected (remote, device)

char *  remote;
char *  device;

{
        register struct acData *        acptr = &Acct;

        LOGCHECK;
        copyText(acptr->rmtSystem, sizeof(acptr->rmtSystem), remote);
        copyText(acptr->device, sizeof(acptr->device), device);
        acptr->service = 'S'; /* default to standard service */
}

/* Function:    acDojob - Found Another Job
*
* acDojob  is called when a new job has been found.
*
* Parameters:
*
*       jobid -         The name of the job that was found.
*
*       system -        Originating system's name.
*
*       user -          Originator's login name.
*/

void
acDojob(jobid, system, user)

char *  jobid;
char *  system;
char *  user;

{
        register struct acData *        acptr = &Acct;

struct passwd *passent;
        LOGCHECK;
        if (strcmp(acptr->jobID,jobid) == 0)
                return;
        if ((*acptr->jobID != NULLCHAR) && (acptr->jobsize != 0)){
                reportJob();
        }
        copyText(acptr->jobID, sizeof(acptr->jobID), jobid);
        copyText(acptr->origSystem, sizeof(acptr->origSystem), system);
        copyText(acptr->origUser, sizeof(acptr->origUser), user);
        copyText(acptr->time, sizeof(acptr->time), timeStamp());
        acptr->jobgrade[0] = jobid[strlen(jobid)-5];
        acptr->jobgrade[1] = NULLCHAR;/* get job grade from jobid */
        acptr->jobsize = 0;
        while ((passent = getpwent()) != NULL){
          if (strcmp(passent->pw_name,user) == 0){
                sprintf(acptr->uid,"%ld",(long) passent->pw_uid);
                break;
          }
        }
}

/* End recording the accounting log */

void
acEnd(status)
char status;
{
        register struct acData *        acptr = &Acct;

        LOGCHECK;
        if (((*acptr->jobID != NULLCHAR) && (acptr->jobsize != 0))
                        || (status == PARTIAL)){
                acptr->status = status;
                reportJob();
        }

}

/* increment job size */

void
acInc()
{
        register struct acData *        acptr = &Acct;

        LOGCHECK;
        acptr->jobsize += getfilesize();
}

/*
* Function:     acInit - Initialize Accounting Package
*
* This function allows the accounting package to initialize its internal
* data structures.  It should be called when uucico starts running on master
* or changes the role from slave to master, or uuxqt is invoked.
*
* Parameters:
*
*       type: file transfer or remote exec.
*/

void
acInit (type)
char * type;

{
        register struct acData *        acptr = &Acct;

        /*
        * 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;
                acptr->service = STD; /* default to standard service */
                acptr->status = COMPLETE; /* default to completed transfer */
                copyText(acptr->jobgrade, sizeof(acptr->jobgrade), NOTAVAIL);
                copyText(acptr->uid, sizeof(acptr->uid), NOTAVAIL);
                copyText(acptr->origSystem, sizeof(acptr->origSystem), NOTAVAIL);
                copyText(acptr->origUser, sizeof(acptr->origUser), NOTAVAIL);
                copyText(acptr->rmtSystem, sizeof(acptr->rmtSystem), NOTAVAIL);
                copyText(acptr->rmtUser, sizeof(acptr->rmtUser), NOTAVAIL);
                copyText(acptr->device, sizeof(acptr->device), NOTAVAIL);
                copyText(acptr->netid, sizeof(acptr->netid), NOTAVAIL);
                copyText(acptr->path, sizeof(acptr->path), NOTAVAIL);
                copyText(acptr->type, sizeof(acptr->type), type);
        }
        else
                Collecting = FALSE;
}

/*
* It is called when uuxqt is running
*
*       jobid - jobid after X. prefix
*       origsys - Originating system's name.
*       origuser - Originator's login name.
*       connsys - local system
*       connuser - login user
*       cmd - command to be execed by uuxqt
*/
void
acRexe(jobid,origsys,origuser,connsys,connuser,cmd)
char * jobid;
char * origsys;
char * origuser;
char * connsys;
char * connuser;
char * cmd;
{
        register struct acData *        acptr = &Acct;

        LOGCHECK;
        copyText(acptr->jobID, sizeof(acptr->jobID), jobid);
        copyText(acptr->origSystem, sizeof(acptr->origSystem), origsys);
        copyText(acptr->origUser, sizeof(acptr->origUser), origuser);
        copyText(acptr->rmtSystem, sizeof(acptr->rmtSystem), connsys);
        copyText(acptr->rmtUser, sizeof(acptr->rmtUser), connuser);
        copyText(acptr->path, sizeof(acptr->path), cmd);
        copyText(acptr->time, sizeof(acptr->time), timeStamp());
}
/*
* It is called when the command to be execed is finished
*
*       cpucycle: cpu time the command is consumed
*/
void
acEndexe(cycle,status)
time_t  cycle;
char status;
{

        register struct acData *        acptr = &Acct;

        LOGCHECK;
        acptr->jobsize = cycle;
        acptr->status = status;
        reportJob();
}
/*
 *      cpucycle()
 *
 *      return cputime(utime+stime) since last time called
 */
time_t
cpucycle()
{
        struct tms      tbuf;
        time_t  rval;
        static time_t   utime,stime;    /* guaranteed 0 first time called */

        times(&tbuf);
        rval = ((tbuf.tms_utime-utime) + (tbuf.tms_stime-stime))*1000/HZ;
        utime = tbuf.tms_utime;
        stime = tbuf.tms_stime;
        return(rval);
}