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 33extern 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 47struct 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 66struct 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 79static int Collecting = TRUE; /* ok to collect security inf.*/ 80static int LogFile = CLOSED; /* Log file file destriptor. */ 81static char LogName[] = SECURITY; /* Name of our log file. */ 82static char Record[LOGSIZE]; /* Place to build log records. */ 83static char Type[MODSTR]; /* record type */ 84 85static struct secXfer Xfer; /* security transfer data. */ 86static 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 97STATIC_FUNC void 98newRec(type) 99char * 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 143void 144scInit (type) 145char * 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 171void 172scWrite() 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 212void 213scReqsys(reqsys) 214char * 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 231void 232scRequser(requser) 233char * 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 248void 249scStime() 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 264void 265scEtime() 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 285void 286scDest(destsys, destuser, destfile) 287char * destsys; 288char * destuser; 289char * 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 314void 315scSrc(srcsys, srcowner, srcfile, srcmtime, srcsize) 316char * srcsys; 317char * srcowner; 318char * srcfile; 319char * srcmtime; 320char * 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 341char * 342scSize(srcfile) 343char * 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 363char * 364scOwn(srcfile) 365char * 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 385char * 386scMtime(srcfile) 387char * 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 413void 414scRexe(clientsys,clientusr,serverusr,cmd) 415char * clientsys; 416char * clientusr; 417char * serverusr; 418char * 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 437void 438scWlog() 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} 462