OpenSolaris_b135/cmd/bnu/security.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 (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;
}