/*
 * 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:security.c 1.3 */
/*
 */

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

extern int guinfo();

/*
 *              SYMBOL DEFINITIONS
 */

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

/*
 *              STRUCTURE DEFINITIONS
 */

struct secXfer                  /* Data for construction of security record. */
                {
                        char    reqSystem[MODSTR]; /* requester system name */
                        char    reqUser[MODSTR]; /* requester login name */
                        char    desSystem[MODSTR]; /* destination system name */
                        char    desUser[MODSTR]; /* destination login name */
                        char    desFile[MODSTR]; /* destination file name */
                        char    srcSystem[MODSTR]; /* source system name */
                        char    srcOwner[MODSTR]; /* source file owner */
                        char    srcFile[MODSTR]; /* source file name */
                        char    srcSize[MODSTR];/* source file size in Bytes .*/
                        char    srcMtime[MODSTR]; /* modification date and time of
                                                source file */
                        char    stime[MODSTR]; /* date and time that transfer
                                                        started */
                        char    etime[MODSTR]; /* date and time that transfer
                                                        completed */
                };

struct secRexe                  /* Data for construction of security record. */
                {
                        char    cliSystem[MODSTR]; /* client system name */
                        char    cliUser[MODSTR]; /* client login name */
                        char    serUser[MODSTR]; /* server login name */
                        char    time[MODSTR]; /* date and time that command was
                                                 issued*/
                        char    command[BUFSIZ]; /* command name and options */
                };
/*
 *              LOCAL DATA
 */

static int              Collecting = TRUE; /* ok to collect security inf.*/
static int              LogFile = CLOSED; /* Log file file destriptor. */
static char             LogName[] = SECURITY; /* Name of our log file. */
static char             Record[LOGSIZE]; /* Place to build log records. */
static char             Type[MODSTR]; /* record type */

static struct secXfer   Xfer;   /* security transfer data. */
static struct secRexe   Rexe;   /* security remote execution data. */

/*
 *              LOCAL FUNCTIONS
 */


/*
 * Local Function:      newRec - Initialize new record
 */

STATIC_FUNC void
newRec(type)
char * type;
{
        register struct secXfer *       scptr = &Xfer;
        register struct secRexe *       reptr = &Rexe;

        if EQUALS(type,"xfer"){
           copyText(scptr->reqUser, sizeof(scptr->reqUser), NOTAVAIL);
           copyText(scptr->desSystem, sizeof(scptr->desSystem), NOTAVAIL);
           copyText(scptr->desUser, sizeof(scptr->desUser), NOTAVAIL);
           copyText(scptr->desFile, sizeof(scptr->desFile), NOTAVAIL);
           copyText(scptr->srcSystem, sizeof(scptr->srcSystem), NOTAVAIL);
           copyText(scptr->srcOwner, sizeof(scptr->srcOwner), NOTAVAIL);
           copyText(scptr->srcFile, sizeof(scptr->srcFile), NOTAVAIL);
           copyText(scptr->srcMtime, sizeof(scptr->srcMtime), NOTAVAIL);
           copyText(scptr->stime, sizeof(scptr->stime), NOTAVAIL);
           copyText(scptr->etime, sizeof(scptr->etime), NOTAVAIL);
        }
        else {
           copyText(reptr->cliSystem, sizeof(reptr->cliSystem), NOTAVAIL);
           copyText(reptr->cliUser, sizeof(reptr->cliUser), NOTAVAIL);
           copyText(reptr->serUser, sizeof(reptr->serUser), NOTAVAIL);
           copyText(reptr->time, sizeof(reptr->time), NOTAVAIL);
           copyText(reptr->command, sizeof(reptr->command), NOTAVAIL);
        }
        return;
}

/*
 *              EXTERNAL FUNCTIONS
 */


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

void
scInit (type)
char * type;

{

        if (LogFile == CLOSED) {
                errno = 0;
                LogFile = open(LogName, O_WRONLY | O_APPEND);
                if (errno == ENOENT) {
                        LogFile = creat(LogName, LOGFILEMODE);
                        (void) chmod(LogName, LOGFILEMODE);
                }
                if (LogFile < 0){
                        Collecting = FALSE;
                        return;
                }
        }
        copyText(Type, sizeof(Type), type);
        newRec(Type);
        return;
}

/*
 * Function:    scWrite - write an entry to the log
 *                        initialize the next entry
 */

void
scWrite()

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

        register struct secXfer *       scptr;

        LOGCHECK;
        scptr = &Xfer;                  /* Point to security transfer data. */
        sprintf(Record, format,
                Type, FS,
                scptr->reqSystem, FS,
                scptr->reqUser, FS,
                scptr->desSystem, FS,
                scptr->desUser, FS,
                scptr->desFile, FS,
                scptr->srcSystem, FS,
                scptr->srcOwner, FS,
                scptr->srcFile, FS,
                scptr->srcSize, FS,
                scptr->srcMtime, FS,
                scptr->stime, FS,
                scptr->etime
               );

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

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

/*
 * Function:    scReqsys - log requestor system name
 *
 * Parameters:
 *      reqsys: master machine name
 */

void
scReqsys(reqsys)
char * reqsys;

{
        register struct secXfer *       scptr = &Xfer;

        LOGCHECK;
        copyText(scptr->reqSystem, sizeof(scptr->reqSystem), reqsys);
        return;
}

/*
 * Function:    scRequser - log requestor user name
 *
 * Parameters:
 *      requser: one who issued the command
 */

void
scRequser(requser)
char * requser;

{
        register struct secXfer *       scptr = &Xfer;

        LOGCHECK;
        copyText(scptr->reqUser, sizeof(scptr->reqUser), requser);
        return;
}

/*
 * Function:    scStime - log start transfer time
 *
 */

void
scStime()

{
        register struct secXfer *       scptr = &Xfer;

        LOGCHECK;
        copyText(scptr->stime, sizeof(scptr->stime), timeStamp());
        return;
}

/*
 * Function:    scEtime - log end transfer time
 *
 */

void
scEtime()

{
        register struct secXfer *       scptr = &Xfer;

        LOGCHECK;
        copyText(scptr->etime, sizeof(scptr->etime), timeStamp());
        return;
}

/*
 * Function:    scDest - log destination node, user and file name
 *
 * Parameters:
 *      destsys: system where the dest file is sent to
 *      destuser: user where the dest file is sent to
 *      destfile: name of the dest file
 *
 */

void
scDest(destsys, destuser, destfile)
char * destsys;
char * destuser;
char * destfile;

{
        register struct secXfer *       scptr = &Xfer;

        LOGCHECK;
        copyText(scptr->desSystem, sizeof(scptr->desSystem), destsys);
        copyText(scptr->desUser, sizeof(scptr->desUser), destuser);
        copyText(scptr->desFile, sizeof(scptr->desFile), destfile);
        return;
}

/*
 * Function:    scSrc - log source node, file owner, file name
 *                      modification time and size
 *
 * Parameters:
 *      srcsys: system where the source file is recieved from
 *      srcowner: owner of the source file
 *      srcfile: name of the source file
 *      srcmtime: modification date and time of source file
 *      srcsize: size of the source file
 *
 */

void
scSrc(srcsys, srcowner, srcfile, srcmtime, srcsize)
char * srcsys;
char * srcowner;
char * srcfile;
char * srcmtime;
char * srcsize;

{
        register struct secXfer *       scptr = &Xfer;

        LOGCHECK;
        copyText(scptr->srcSystem, sizeof(scptr->srcSystem), srcsys);
        copyText(scptr->srcOwner, sizeof(scptr->srcOwner), srcowner );
        copyText(scptr->srcFile, sizeof(scptr->srcFile), srcfile);
        copyText(scptr->srcMtime, sizeof(scptr->srcMtime), srcmtime );
        copyText(scptr->srcSize, sizeof(scptr->srcSize), srcsize);
        return;
}

/*
 * Function:    scSize - get size of source file
 *
 * parameter    srcfile: name of the source file
 *
 */

char *
scSize(srcfile)
char * srcfile;

{
        struct stat stbuf;
        static char size[MODSTR];

        LOGCHECKC;
        if (stat(srcfile, &stbuf))
                return(NOTAVAIL);/* fail, set it ""  */
        sprintf(size,"%ld",stbuf.st_size);
        return(size);
}

/*
 * Function:    scOwn - get owner of source file
 *
 * parameter    srcfile: name of the source file
 *
 */

char *
scOwn(srcfile)
char * srcfile;

{
        struct stat stbuf;
        static char user[MODSTR];

        LOGCHECKC;
        if (stat(srcfile, &stbuf))
                return(NOTAVAIL);
        (void) guinfo(stbuf.st_uid,user);
        return(user);
}

/*
 * Function:    scMtime - get modification date and time of source file
 *
 * parameter    srcfile: name of the source file
 *
 */

char *
scMtime(srcfile)
char * srcfile;

{
        struct stat stbuf;
        static char mtime[MODSTR];
        register struct tm *tp;

        LOGCHECKC;
        if (stat(srcfile, &stbuf))
                return(NOTAVAIL);
        tp = localtime(&stbuf.st_mtime);
        (void) sprintf(mtime, "%d/%d-%d:%2.2d", tp->tm_mon + 1,
            tp->tm_mday, tp->tm_hour, tp->tm_min);
        return(mtime);
}

/*
 * Function - scRexe: It is called when uuxqt is running
 *
 * Parameter:
 *      clientsys - Client node name.
 *      clientusr - Client user ID.
 *      serverusr - Server user ID.
 *      cmd - command to be execed by uuxqt
 */

void
scRexe(clientsys,clientusr,serverusr,cmd)
char * clientsys;
char * clientusr;
char * serverusr;
char * cmd;
{
        register struct secRexe *       scptr = &Rexe;


        LOGCHECK;
        copyText(scptr->cliSystem, sizeof(scptr->cliSystem), clientsys);
        copyText(scptr->cliUser, sizeof(scptr->cliUser), clientusr);
        copyText(scptr->serUser, sizeof(scptr->serUser), serverusr);
        copyText(scptr->time, sizeof(scptr->time), timeStamp());
        copyText(scptr->command, sizeof(scptr->command), cmd);
        return;
}

/*
 * Function - scWlog: It is called when the violation is occurred
 *
 */

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

        register struct secRexe *       scptr;

        LOGCHECK;
        scptr = &Rexe;                  /* Point to security remote exec data. */
        sprintf(Record, format,
                Type, FS,
                scptr->cliSystem, FS,
                scptr->cliUser, FS,
                scptr->serUser, FS,
                scptr->time, FS,
                scptr->command
               );

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

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