usr/src/cmd/bnu/security.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22 /*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
  23 /*        All Rights Reserved   */
  24
  25
  26 #ident  "%Z%%M% %I%     %E% SMI"        /* from SVR4 bnu:security.c 1.3 */
  27 /*
  28  */
  29
  30 #include        "uucp.h"
  31 #include        "log.h"
  32
  33 extern int guinfo();
  34
  35 /*
  36  *              SYMBOL DEFINITIONS
  37  */
  38
  39 #define FS              ' '     /* Field seperator for output records. */
  40 #define LOGCHECK        { if (Collecting == FALSE) return; }
  41 #define LOGCHECKC       { if (Collecting == FALSE) return(NOTAVAIL); }
  42
  43 /*
  44  *              STRUCTURE DEFINITIONS
  45  */
  46
  47 struct secXfer                  /* Data for construction of security record. */
  48                 {
  49                         char    reqSystem[MODSTR]; /* requester system name */
  50                         char    reqUser[MODSTR]; /* requester login name */
  51                         char    desSystem[MODSTR]; /* destination system name */
  52                         char    desUser[MODSTR]; /* destination login name */
  53                         char    desFile[MODSTR]; /* destination file name */
  54                         char    srcSystem[MODSTR]; /* source system name */
  55                         char    srcOwner[MODSTR]; /* source file owner */
  56                         char    srcFile[MODSTR]; /* source file name */
  57                         char    srcSize[MODSTR];/* source file size in Bytes .*/
  58                         char    srcMtime[MODSTR]; /* modification date and time of
  59                                                 source file */
  60                         char    stime[MODSTR]; /* date and time that transfer
  61                                                         started */
  62                         char    etime[MODSTR]; /* date and time that transfer
  63                                                         completed */
  64                 };
  65
  66 struct secRexe                  /* Data for construction of security record. */
  67                 {
  68                         char    cliSystem[MODSTR]; /* client system name */
  69                         char    cliUser[MODSTR]; /* client login name */
  70                         char    serUser[MODSTR]; /* server login name */
  71                         char    time[MODSTR]; /* date and time that command was
  72                                                  issued*/
  73                         char    command[BUFSIZ]; /* command name and options */
  74                 };
  75 /*
  76  *              LOCAL DATA
  77  */
  78
  79 static int              Collecting = TRUE; /* ok to collect security inf.*/
  80 static int              LogFile = CLOSED; /* Log file file destriptor. */
  81 static char             LogName[] = SECURITY; /* Name of our log file. */
  82 static char             Record[LOGSIZE]; /* Place to build log records. */
  83 static char             Type[MODSTR]; /* record type */
  84
  85 static struct secXfer   Xfer;   /* security transfer data. */
  86 static struct secRexe   Rexe;   /* security remote execution data. */
  87
  88 /*
  89  *              LOCAL FUNCTIONS
  90  */
  91
  92
  93 /*
  94  * Local Function:      newRec - Initialize new record
  95  */
  96
  97 STATIC_FUNC void
  98 newRec(type)
  99 char * type;
 100 {
 101         register struct secXfer *       scptr = &Xfer;
 102         register struct secRexe *       reptr = &Rexe;
 103
 104         if EQUALS(type,"xfer"){
 105            copyText(scptr->reqUser, sizeof(scptr->reqUser), NOTAVAIL);
 106            copyText(scptr->desSystem, sizeof(scptr->desSystem), NOTAVAIL);
 107            copyText(scptr->desUser, sizeof(scptr->desUser), NOTAVAIL);
 108            copyText(scptr->desFile, sizeof(scptr->desFile), NOTAVAIL);
 109            copyText(scptr->srcSystem, sizeof(scptr->srcSystem), NOTAVAIL);
 110            copyText(scptr->srcOwner, sizeof(scptr->srcOwner), NOTAVAIL);
 111            copyText(scptr->srcFile, sizeof(scptr->srcFile), NOTAVAIL);
 112            copyText(scptr->srcMtime, sizeof(scptr->srcMtime), NOTAVAIL);
 113            copyText(scptr->stime, sizeof(scptr->stime), NOTAVAIL);
 114            copyText(scptr->etime, sizeof(scptr->etime), NOTAVAIL);
 115         }
 116         else {
 117            copyText(reptr->cliSystem, sizeof(reptr->cliSystem), NOTAVAIL);
 118            copyText(reptr->cliUser, sizeof(reptr->cliUser), NOTAVAIL);
 119            copyText(reptr->serUser, sizeof(reptr->serUser), NOTAVAIL);
 120            copyText(reptr->time, sizeof(reptr->time), NOTAVAIL);
 121            copyText(reptr->command, sizeof(reptr->command), NOTAVAIL);
 122         }
 123         return;
 124 }
 125
 126 /*
 127  *              EXTERNAL FUNCTIONS
 128  */
 129
 130
 131 /*
 132  * Function:    scInit - Initialize Security Package
 133  *
 134  * This function allows the security package to initialize its internal
 135  * data structures.  It should be called when uucico starts running on master
 136  * or slave, or uuxqt is invoked.
 137  *
 138  * Parameters:
 139  *
 140  *      type: file transfer or remote exec.
 141  */
 142
 143 void
 144 scInit (type)
 145 char * type;
 146
 147 {
 148
 149         if (LogFile == CLOSED) {
 150                 errno = 0;
 151                 LogFile = open(LogName, O_WRONLY | O_APPEND);
 152                 if (errno == ENOENT) {
 153                         LogFile = creat(LogName, LOGFILEMODE);
 154                         (void) chmod(LogName, LOGFILEMODE);
 155                 }
 156                 if (LogFile < 0){
 157                         Collecting = FALSE;
 158                         return;
 159                 }
 160         }
 161         copyText(Type, sizeof(Type), type);
 162         newRec(Type);
 163         return;
 164 }
 165
 166 /*
 167  * Function:    scWrite - write an entry to the log
 168  *                        initialize the next entry
 169  */
 170
 171 void
 172 scWrite()
 173
 174 {
 175         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)";
 176
 177         register struct secXfer *       scptr;
 178
 179         LOGCHECK;
 180         scptr = &Xfer;                  /* Point to security transfer data. */
 181         sprintf(Record, format,
 182                 Type, FS,
 183                 scptr->reqSystem, FS,
 184                 scptr->reqUser, FS,
 185                 scptr->desSystem, FS,
 186                 scptr->desUser, FS,
 187                 scptr->desFile, FS,
 188                 scptr->srcSystem, FS,
 189                 scptr->srcOwner, FS,
 190                 scptr->srcFile, FS,
 191                 scptr->srcSize, FS,
 192                 scptr->srcMtime, FS,
 193                 scptr->stime, FS,
 194                 scptr->etime
 195                );
 196
 197         /* Terminate the record and write it out. */
 198
 199         (void) strcat(Record, EOR);
 200         writeLog(Record,&LogFile,LogName,&Collecting);
 201         newRec(Type);
 202         return;
 203 }
 204
 205 /*
 206  * Function:    scReqsys - log requestor system name
 207  *
 208  * Parameters:
 209  *      reqsys: master machine name
 210  */
 211
 212 void
 213 scReqsys(reqsys)
 214 char * reqsys;
 215
 216 {
 217         register struct secXfer *       scptr = &Xfer;
 218
 219         LOGCHECK;
 220         copyText(scptr->reqSystem, sizeof(scptr->reqSystem), reqsys);
 221         return;
 222 }
 223
 224 /*
 225  * Function:    scRequser - log requestor user name
 226  *
 227  * Parameters:
 228  *      requser: one who issued the command
 229  */
 230
 231 void
 232 scRequser(requser)
 233 char * requser;
 234
 235 {
 236         register struct secXfer *       scptr = &Xfer;
 237
 238         LOGCHECK;
 239         copyText(scptr->reqUser, sizeof(scptr->reqUser), requser);
 240         return;
 241 }
 242
 243 /*
 244  * Function:    scStime - log start transfer time
 245  *
 246  */
 247
 248 void
 249 scStime()
 250
 251 {
 252         register struct secXfer *       scptr = &Xfer;
 253
 254         LOGCHECK;
 255         copyText(scptr->stime, sizeof(scptr->stime), timeStamp());
 256         return;
 257 }
 258
 259 /*
 260  * Function:    scEtime - log end transfer time
 261  *
 262  */
 263
 264 void
 265 scEtime()
 266
 267 {
 268         register struct secXfer *       scptr = &Xfer;
 269
 270         LOGCHECK;
 271         copyText(scptr->etime, sizeof(scptr->etime), timeStamp());
 272         return;
 273 }
 274
 275 /*
 276  * Function:    scDest - log destination node, user and file name
 277  *
 278  * Parameters:
 279  *      destsys: system where the dest file is sent to
 280  *      destuser: user where the dest file is sent to
 281  *      destfile: name of the dest file
 282  *
 283  */
 284
 285 void
 286 scDest(destsys, destuser, destfile)
 287 char * destsys;
 288 char * destuser;
 289 char * destfile;
 290
 291 {
 292         register struct secXfer *       scptr = &Xfer;
 293
 294         LOGCHECK;
 295         copyText(scptr->desSystem, sizeof(scptr->desSystem), destsys);
 296         copyText(scptr->desUser, sizeof(scptr->desUser), destuser);
 297         copyText(scptr->desFile, sizeof(scptr->desFile), destfile);
 298         return;
 299 }
 300
 301 /*
 302  * Function:    scSrc - log source node, file owner, file name
 303  *                      modification time and size
 304  *
 305  * Parameters:
 306  *      srcsys: system where the source file is recieved from
 307  *      srcowner: owner of the source file
 308  *      srcfile: name of the source file
 309  *      srcmtime: modification date and time of source file
 310  *      srcsize: size of the source file
 311  *
 312  */
 313
 314 void
 315 scSrc(srcsys, srcowner, srcfile, srcmtime, srcsize)
 316 char * srcsys;
 317 char * srcowner;
 318 char * srcfile;
 319 char * srcmtime;
 320 char * srcsize;
 321
 322 {
 323         register struct secXfer *       scptr = &Xfer;
 324
 325         LOGCHECK;
 326         copyText(scptr->srcSystem, sizeof(scptr->srcSystem), srcsys);
 327         copyText(scptr->srcOwner, sizeof(scptr->srcOwner), srcowner );
 328         copyText(scptr->srcFile, sizeof(scptr->srcFile), srcfile);
 329         copyText(scptr->srcMtime, sizeof(scptr->srcMtime), srcmtime );
 330         copyText(scptr->srcSize, sizeof(scptr->srcSize), srcsize);
 331         return;
 332 }
 333
 334 /*
 335  * Function:    scSize - get size of source file
 336  *
 337  * parameter    srcfile: name of the source file
 338  *
 339  */
 340
 341 char *
 342 scSize(srcfile)
 343 char * srcfile;
 344
 345 {
 346         struct stat stbuf;
 347         static char size[MODSTR];
 348
 349         LOGCHECKC;
 350         if (stat(srcfile, &stbuf))
 351                 return(NOTAVAIL);/* fail, set it ""  */
 352         sprintf(size,"%ld",stbuf.st_size);
 353         return(size);
 354 }
 355
 356 /*
 357  * Function:    scOwn - get owner of source file
 358  *
 359  * parameter    srcfile: name of the source file
 360  *
 361  */
 362
 363 char *
 364 scOwn(srcfile)
 365 char * srcfile;
 366
 367 {
 368         struct stat stbuf;
 369         static char user[MODSTR];
 370
 371         LOGCHECKC;
 372         if (stat(srcfile, &stbuf))
 373                 return(NOTAVAIL);
 374         (void) guinfo(stbuf.st_uid,user);
 375         return(user);
 376 }
 377
 378 /*
 379  * Function:    scMtime - get modification date and time of source file
 380  *
 381  * parameter    srcfile: name of the source file
 382  *
 383  */
 384
 385 char *
 386 scMtime(srcfile)
 387 char * srcfile;
 388
 389 {
 390         struct stat stbuf;
 391         static char mtime[MODSTR];
 392         register struct tm *tp;
 393
 394         LOGCHECKC;
 395         if (stat(srcfile, &stbuf))
 396                 return(NOTAVAIL);
 397         tp = localtime(&stbuf.st_mtime);
 398         (void) sprintf(mtime, "%d/%d-%d:%2.2d", tp->tm_mon + 1,
 399             tp->tm_mday, tp->tm_hour, tp->tm_min);
 400         return(mtime);
 401 }
 402
 403 /*
 404  * Function - scRexe: It is called when uuxqt is running
 405  *
 406  * Parameter:
 407  *      clientsys - Client node name.
 408  *      clientusr - Client user ID.
 409  *      serverusr - Server user ID.
 410  *      cmd - command to be execed by uuxqt
 411  */
 412
 413 void
 414 scRexe(clientsys,clientusr,serverusr,cmd)
 415 char * clientsys;
 416 char * clientusr;
 417 char * serverusr;
 418 char * cmd;
 419 {
 420         register struct secRexe *       scptr = &Rexe;
 421
 422
 423         LOGCHECK;
 424         copyText(scptr->cliSystem, sizeof(scptr->cliSystem), clientsys);
 425         copyText(scptr->cliUser, sizeof(scptr->cliUser), clientusr);
 426         copyText(scptr->serUser, sizeof(scptr->serUser), serverusr);
 427         copyText(scptr->time, sizeof(scptr->time), timeStamp());
 428         copyText(scptr->command, sizeof(scptr->command), cmd);
 429         return;
 430 }
 431
 432 /*
 433  * Function - scWlog: It is called when the violation is occurred
 434  *
 435  */
 436
 437 void
 438 scWlog()
 439 {
 440         static char     format[] = "%s%c%s%c%s%c%s%c(%s)%c%s";
 441
 442         register struct secRexe *       scptr;
 443
 444         LOGCHECK;
 445         scptr = &Rexe;                  /* Point to security remote exec data. */
 446         sprintf(Record, format,
 447                 Type, FS,
 448                 scptr->cliSystem, FS,
 449                 scptr->cliUser, FS,
 450                 scptr->serUser, FS,
 451                 scptr->time, FS,
 452                 scptr->command
 453                );
 454
 455         /* Terminate the record and write it out. */
 456
 457         (void) strcat(Record, EOR);
 458         writeLog(Record,&LogFile,LogName,&Collecting);
 459         newRec(Type);
 460         return;
 461 }