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 /*
23  * Copyright (c) 1999 by Sun Microsystems, Inc.
24  * All rights reserved.
25  */
26 
27 #pragma ident	"%Z%%M%	%I%	%E% SMI"
28 
29 #include <stdio.h>
30 #include <errno.h>
31 #include <malloc.h>
32 #include <strings.h>
33 #include <stddef.h>
34 #include <search.h>
35 #include <syslog.h>
36 #include <libintl.h>
37 #include <unistd.h>
38 #include <rpc/rpc.h>
39 #include <netconfig.h>
40 #include <netdir.h>
41 #include <nfs/nfs_sec.h>
42 #include <nfs/export.h>
43 #include <rpc/auth.h>
44 #include <rpc/svc.h>
45 #include <rpc/xdr.h>
46 #include <rpc/clnt.h>
47 #include <nfs/nfs.h>
48 #include <nfs/nfs_log.h>
49 #include <assert.h>
50 #include "fhtab.h"
51 #include "nfslogd.h"
52 
53 /*
54  * How long should an entry stay in the list before being forced
55  * out and a trans log entry printed
56  */
57 #define	TRANS_ENTRY_TIMEOUT	60
58 
59 extern char *addrtoname(void *);
60 
61 struct transentry {
62 	struct transentry *next;
63 	struct transentry *prev;
64 	timestruc32_t	starttime;	/* when did transaction start? */
65 	timestruc32_t	lastupdate;	/* last operation for this entry */
66 #define	TRANS_OPER_READ		1
67 #define	TRANS_OPER_WRITE	2
68 #define	TRANS_OPER_SETATTR	3
69 #define	TRANS_OPER_REMOVE	4
70 #define	TRANS_OPER_MKDIR	5
71 #define	TRANS_OPER_CREATE	6
72 #define	TRANS_OPER_RMDIR	7
73 #define	TRANS_OPER_RENAME	8
74 #define	TRANS_OPER_MKNOD	9
75 #define	TRANS_OPER_LINK		10
76 #define	TRANS_OPER_SYMLINK	11
77 	uchar_t		optype;		/* read, write, ...? */
78 #define	TRANS_DATATYPE_NA		/* not applicable data type */
79 #define	TRANS_DATATYPE_ASCII	0	/* transfer done as ascii */
80 #define	TRANS_DATATYPE_BINARY	1	/* transfer done as binary */
81 	uchar_t		datatype;
82 /*
83  * Action taken by server before transfer was made -- noaction,
84  * compressed, tar or uncompressed.
85  */
86 #define	TRANS_OPTION_NOACTION	0
87 	uchar_t		transoption;
88 	char		*pathname;
89 	struct netbuf	*pnb;
90 	uid_t		uid;
91 	int		nfsvers;
92 	char		*netid;
93 	char		*principal_name;
94 	uint64_t	totalbytes;	/* total operated upon in history */
95 	union {
96 		fhandle_t fh;
97 		nfs_fh3 fh3;
98 	} fh_u;
99 };
100 
101 struct nfslog_trans_file {
102 	struct nfslog_trans_file	*next;	/* next file in list */
103 	struct nfslog_trans_file	*prev;	/* next file in list */
104 	int	refcnt;		/* number of references to this struct */
105 	char	*path;		/* pathname of file */
106 	FILE	*fp;		/* file pointer */
107 	/* timestamp of the last transaction processed for this file */
108 	timestruc32_t	lasttrans_timestamp;
109 	/* 'current' time that last trans was processed */
110 	time_t		last_trans_read;
111 	uint32_t trans_to_log;	/* transactions that are to be logged */
112 	uint32_t trans_output_type;
113 	struct transentry *te_list_v3_read;
114 	struct transentry *te_list_v3_write;
115 	struct transentry *te_list_v2_read;
116 	struct transentry *te_list_v2_write;
117 };
118 
119 static struct nfslog_trans_file *trans_file_head = NULL;
120 
121 static void nfslog_print_trans_logentry(struct transentry *,
122 	struct nfslog_trans_file *);
123 
124 
125 static struct netbuf *
netbufdup(struct netbuf * pnb)126 netbufdup(struct netbuf *pnb)
127 {
128 	struct netbuf *pnewnb;
129 	uint32_t	size;
130 
131 	size = offsetof(struct netbuf, buf);
132 	size += pnb->len;
133 
134 	if ((pnewnb = (struct netbuf *)malloc(sizeof (*pnewnb))) == NULL)
135 		return (NULL);
136 	if ((pnewnb->buf = malloc(pnb->len)) == NULL) {
137 		free(pnewnb);
138 		return (NULL);
139 	}
140 
141 	pnewnb->maxlen = pnb->maxlen;
142 	pnewnb->len = pnb->len;
143 	bcopy(pnb->buf, pnewnb->buf, pnb->len);
144 	return (pnewnb);
145 }
146 
147 static void
freenetbuf(struct netbuf * pnb)148 freenetbuf(struct netbuf *pnb)
149 {
150 	free(pnb->buf);
151 	free(pnb);
152 }
153 
154 static struct transentry *
create_te()155 create_te()
156 {
157 	struct transentry *pte;
158 
159 	if ((pte = (struct transentry *)calloc(1, sizeof (*pte))) == NULL) {
160 		/* failure message or action */
161 		return (NULL);
162 	}
163 
164 	pte->next = pte->prev = NULL;
165 
166 	return (pte);
167 }
168 
169 static struct transentry *
insert_te(struct transentry * te_list,struct transentry * entry)170 insert_te(
171 	struct transentry *te_list,
172 	struct transentry *entry)
173 {
174 	struct transentry *pte;
175 
176 	/*
177 	 * First check for any non-filehandle comparisons that may be needed.
178 	 */
179 	switch (entry->optype) {
180 	case TRANS_OPER_REMOVE:
181 	case TRANS_OPER_RENAME:
182 		for (pte = te_list->next; pte != te_list; pte = pte->next) {
183 			/* if path names match, then return */
184 			if (strcmp(pte->pathname, entry->pathname) == 0) {
185 				return (pte);
186 			}
187 		}
188 		return (NULL);
189 	default:
190 		break;
191 	}
192 
193 	for (pte = te_list->next; pte != te_list; pte = pte->next) {
194 		/* If the file handles match, then we have a hit */
195 		if (entry->nfsvers == NFS_VERSION) {
196 			if (bcmp(&(pte->fh_u.fh), &(entry->fh_u.fh),
197 				sizeof (fhandle_t)) == 0) {
198 				switch (entry->optype) {
199 				case TRANS_OPER_READ:
200 				case TRANS_OPER_WRITE:
201 					if (pte->uid ==	entry->uid) {
202 						return (pte);
203 					}
204 					break;
205 				default:
206 					return (pte);
207 				}
208 			}
209 		} else {
210 			if (pte->fh_u.fh3.fh3_length ==
211 				entry->fh_u.fh3.fh3_length &&
212 				bcmp(pte->fh_u.fh3.fh3_u.data,
213 					entry->fh_u.fh3.fh3_u.data,
214 					pte->fh_u.fh3.fh3_length) == 0)
215 				switch (entry->optype) {
216 				case TRANS_OPER_READ:
217 				case TRANS_OPER_WRITE:
218 					if (pte->uid ==	entry->uid) {
219 						return (pte);
220 					}
221 					break;
222 				default:
223 					return (pte);
224 				}
225 		}
226 	}
227 	/*
228 	 * XXX - should compare more of the information to make sure
229 	 * it is a match.
230 	 */
231 
232 	/*
233 	 * other operation types do not generate an entry for
234 	 * further analysis
235 	 */
236 	switch (entry->optype) {
237 	case TRANS_OPER_READ:
238 	case TRANS_OPER_WRITE:
239 		break;
240 	default:
241 		return (NULL);
242 	}
243 
244 	insque(entry, te_list);
245 
246 	return (NULL); /* NULL signifies insertion and no record found */
247 }
248 
249 static void
remove_te(struct transentry * pte)250 remove_te(struct transentry *pte)
251 {
252 	if (pte->next)
253 		remque(pte);
254 
255 	if (pte->principal_name) free(pte->principal_name);
256 	if (pte->pathname) free(pte->pathname);
257 	if (pte->pnb) freenetbuf(pte->pnb);
258 	if (pte->netid) free(pte->netid);
259 
260 	free(pte);
261 }
262 
263 /*
264  * nfslog_trans_file_free - frees a record
265  */
266 static void
nfslog_trans_file_free(struct nfslog_trans_file * transrec)267 nfslog_trans_file_free(struct nfslog_trans_file *transrec)
268 {
269 	if (transrec == NULL)
270 		return;
271 	if (transrec->path != NULL) {
272 		if (debug)
273 			(void) printf("freeing transpath '%s'\n",
274 				transrec->path);
275 		free(transrec->path);
276 	}
277 	free(transrec);
278 }
279 
280 /*
281  * On success returns a pointer to the trans_file that matches
282  * 'path', 'output_type' and 'transtolog'.  The reference count for this
283  * object is incremented as well.
284  * Returns NULL if it is not in the list.
285  */
286 static struct nfslog_trans_file *
nfslog_trans_file_find(char * path,uint32_t output_type,uint32_t transtolog)287 nfslog_trans_file_find(
288 	char *path,
289 	uint32_t output_type,
290 	uint32_t transtolog)
291 {
292 	struct nfslog_trans_file *tfp;
293 
294 	for (tfp = trans_file_head; tfp != NULL; tfp = tfp->next) {
295 		if ((strcmp(path, tfp->path) == 0) &&
296 		    (output_type == tfp->trans_output_type) &&
297 		    (transtolog == tfp->trans_to_log)) {
298 			if (debug)
299 				(void) printf("Found transfile '%s'\n", path);
300 			(tfp->refcnt)++;
301 			return (tfp);
302 		}
303 	}
304 	return (NULL);
305 }
306 
307 
308 /*
309  * nfslog_close_trans_file - decrements the reference count on
310  * this object. On last reference it closes transfile and
311  * frees resources
312  */
313 static void
nfslog_close_trans_file(struct nfslog_trans_file * tf)314 nfslog_close_trans_file(struct nfslog_trans_file *tf)
315 {
316 	assert(tf != NULL);
317 	assert(tf->refcnt > 0);
318 	if (tf->refcnt > 1) {
319 		(tf->refcnt)--;
320 		return;
321 	}
322 
323 	if (tf->fp != NULL) {
324 		(void) fsync(fileno(tf->fp));
325 		(void) fclose(tf->fp);
326 	}
327 
328 	/*
329 	 * Disconnect from list
330 	 */
331 	tf->prev->next = tf->next;
332 	if (tf->next != NULL)
333 		tf->next->prev = tf->prev;
334 
335 	/*
336 	 * Adjust the head of the list if appropriate
337 	 */
338 	if (tf == trans_file_head)
339 		trans_file_head = tf->next;
340 
341 	nfslog_trans_file_free(tf);
342 }
343 
344 /*
345  * nfslog_open_trans_file - open the output trans file and mallocs.
346  * The object is then inserted at the beginning of the global
347  * transfile list.
348  *	Returns 0 for success, error else.
349  *
350  * *error contains the last error encountered on this object. It can
351  * be used to avoid reporting the same error endlessly, by comparing
352  * the current error to the last error. It is reset to the current error
353  * code on return.
354  */
355 void *
nfslog_open_trans_file(char * transpath,uint32_t output_type,uint32_t transtolog,int * error)356 nfslog_open_trans_file(
357 	char *transpath,
358 	uint32_t output_type,
359 	uint32_t transtolog,
360 	int *error)
361 {
362 	int			preverror = *error;
363 	struct nfslog_trans_file	*transrec;
364 
365 	transrec = nfslog_trans_file_find(transpath, output_type, transtolog);
366 	if (transrec != NULL)
367 		return (transrec);
368 
369 	if ((transrec = malloc(sizeof (*transrec))) == NULL) {
370 		*error = errno;
371 		if (*error != preverror) {
372 			syslog(LOG_ERR, gettext("nfslog_open_trans_file: %s"),
373 				strerror(*error));
374 		}
375 		return (NULL);
376 	}
377 	bzero(transrec, sizeof (*transrec));
378 
379 	if ((transrec->path = strdup(transpath)) == NULL) {
380 		*error = errno;
381 		if (*error != preverror) {
382 			syslog(LOG_ERR, gettext("nfslog_open_trans_file: %s"),
383 				strerror(*error));
384 		}
385 		nfslog_trans_file_free(transrec);
386 		return (NULL);
387 	}
388 
389 	if ((transrec->fp = fopen(transpath, "a")) == NULL) {
390 		*error = errno;
391 		if (*error != preverror) {
392 			syslog(LOG_ERR, gettext("Cannot open '%s': %s"),
393 				transpath, strerror(*error));
394 		}
395 		nfslog_trans_file_free(transrec);
396 		return (NULL);
397 	}
398 
399 	transrec->te_list_v3_read =
400 		(struct transentry *)malloc(sizeof (struct transentry));
401 	transrec->te_list_v3_write =
402 		(struct transentry *)malloc(sizeof (struct transentry));
403 	transrec->te_list_v2_read =
404 		(struct transentry *)malloc(sizeof (struct transentry));
405 	transrec->te_list_v2_write =
406 		(struct transentry *)malloc(sizeof (struct transentry));
407 
408 	if (transrec->te_list_v3_read == NULL ||
409 		transrec->te_list_v3_write == NULL ||
410 		transrec->te_list_v2_read == NULL ||
411 		transrec->te_list_v2_write == NULL) {
412 		if (transrec->te_list_v3_read)
413 			free(transrec->te_list_v3_read);
414 		if (transrec->te_list_v3_write)
415 			free(transrec->te_list_v3_write);
416 		if (transrec->te_list_v2_read)
417 			free(transrec->te_list_v2_read);
418 		if (transrec->te_list_v2_write)
419 			free(transrec->te_list_v2_write);
420 		nfslog_close_trans_file(transrec);
421 		return (NULL);
422 	}
423 
424 	transrec->te_list_v3_read->next =
425 		transrec->te_list_v3_read->prev = transrec->te_list_v3_read;
426 	transrec->te_list_v3_write->next =
427 		transrec->te_list_v3_write->prev = transrec->te_list_v3_write;
428 	transrec->te_list_v2_read->next =
429 		transrec->te_list_v2_read->prev = transrec->te_list_v2_read;
430 	transrec->te_list_v2_write->next =
431 		transrec->te_list_v2_write->prev = transrec->te_list_v2_write;
432 
433 	/*
434 	 * Indicate what transaction types to log
435 	 */
436 	transrec->trans_to_log = transtolog;
437 
438 	/*
439 	 * Indicate whether to print 'full' or 'basic' version
440 	 * of the transactions
441 	 */
442 	transrec->trans_output_type = output_type;
443 
444 	/*
445 	 * Insert at the beginning of the list.
446 	 */
447 	transrec->next = trans_file_head;
448 	if (trans_file_head != NULL)
449 		trans_file_head->prev = transrec;
450 	trans_file_head = transrec->prev = transrec;
451 
452 	transrec->refcnt = 1;
453 
454 	transrec->lasttrans_timestamp.tv_sec = 0;
455 	transrec->lasttrans_timestamp.tv_nsec = 0;
456 	transrec->last_trans_read = time(0);
457 
458 	if (debug)
459 		(void) printf("New transfile '%s'\n", transrec->path);
460 
461 	return (transrec);
462 }
463 
464 void
nfslog_process_trans_timeout(struct nfslog_trans_file * tf,uint32_t force_flush)465 nfslog_process_trans_timeout(
466 	struct nfslog_trans_file *tf,
467 	uint32_t force_flush)
468 {
469 	struct transentry *pte;
470 	time_t cur_time = time(0);
471 
472 	/*
473 	 * If we have not seen a transaction on this file for
474 	 * a long time, then we need to flush everything out since
475 	 * we may not be getting anything else in for awhile.
476 	 */
477 	if (difftime(cur_time, tf->last_trans_read) >
478 		(2 * MAX(TRANS_ENTRY_TIMEOUT, idle_time)))
479 		force_flush = TRUE;
480 
481 restart1:
482 	for (pte = tf->te_list_v3_read->next;
483 		pte != tf->te_list_v3_read;
484 		pte = pte->next) {
485 		if (force_flush == TRUE ||
486 			(difftime(tf->lasttrans_timestamp.tv_sec,
487 				pte->lastupdate.tv_sec) >
488 			MAX(TRANS_ENTRY_TIMEOUT, idle_time))) {
489 			nfslog_print_trans_logentry(pte, tf);
490 			remove_te(pte);
491 			goto restart1;
492 		}
493 	}
494 restart2:
495 	for (pte = tf->te_list_v3_write->next;
496 		pte != tf->te_list_v3_write;
497 		pte = pte->next) {
498 		if (force_flush == TRUE ||
499 			(difftime(tf->lasttrans_timestamp.tv_sec,
500 				pte->lastupdate.tv_sec) >
501 			MAX(TRANS_ENTRY_TIMEOUT, idle_time))) {
502 			nfslog_print_trans_logentry(pte, tf);
503 			remove_te(pte);
504 			goto restart2;
505 		}
506 	}
507 restart3:
508 	for (pte = tf->te_list_v2_read->next;
509 		pte != tf->te_list_v2_read;
510 		pte = pte->next) {
511 		if (force_flush == TRUE ||
512 			(difftime(tf->lasttrans_timestamp.tv_sec,
513 				pte->lastupdate.tv_sec) >
514 			MAX(TRANS_ENTRY_TIMEOUT, idle_time))) {
515 			nfslog_print_trans_logentry(pte, tf);
516 			remove_te(pte);
517 			goto restart3;
518 		}
519 	}
520 restart4:
521 	for (pte = tf->te_list_v2_write->next;
522 		pte != tf->te_list_v2_write;
523 		pte = pte->next) {
524 		if (force_flush == TRUE ||
525 			(difftime(tf->lasttrans_timestamp.tv_sec,
526 				pte->lastupdate.tv_sec) >
527 			MAX(TRANS_ENTRY_TIMEOUT, idle_time))) {
528 			nfslog_print_trans_logentry(pte, tf);
529 			remove_te(pte);
530 			goto restart4;
531 		}
532 	}
533 
534 	(void) fflush(tf->fp);
535 }
536 
537 /*
538  * Flushes outstanding transactions to disk, and closes
539  * the transaction log.
540  */
541 void
nfslog_close_transactions(void ** transcookie)542 nfslog_close_transactions(void **transcookie)
543 {
544 	assert(*transcookie != NULL);
545 	nfslog_process_trans_timeout(
546 		(struct nfslog_trans_file *)(*transcookie), TRUE);
547 	nfslog_close_trans_file((struct nfslog_trans_file *)(*transcookie));
548 	*transcookie = NULL;
549 }
550 
551 static struct transentry *
trans_read(nfslog_request_record * logrec,struct nfslog_trans_file * tf,char * fhpath,char * path1)552 trans_read(
553 	nfslog_request_record *logrec,
554 	struct nfslog_trans_file *tf,
555 	char *fhpath,
556 	char *path1)
557 {
558 	struct transentry *newte;
559 	struct transentry *pte = NULL;
560 	/* LINTED */
561 	nfslog_nfsreadargs *args = (nfslog_nfsreadargs *)logrec->re_rpc_arg;
562 	/* LINTED */
563 	nfslog_rdresult *res = (nfslog_rdresult *)logrec->re_rpc_res;
564 
565 	if (res->r_status != NFS_OK)
566 		return (NULL);
567 
568 	if ((newte = create_te()) == NULL)
569 		return (NULL);
570 
571 	if (!path1) {
572 		newte->pathname = nfslog_get_path(&args->ra_fhandle,
573 			NULL, fhpath, "trans_read");
574 	} else {
575 		newte->pathname = strdup(path1);
576 	}
577 
578 	/* prep the struct for insertion */
579 	newte->starttime = logrec->re_header.rh_timestamp;
580 	newte->lastupdate = logrec->re_header.rh_timestamp;
581 	newte->optype = TRANS_OPER_READ;
582 	newte->datatype = TRANS_DATATYPE_BINARY;
583 	newte->transoption = TRANS_OPTION_NOACTION;
584 	newte->pnb = netbufdup(&(logrec->re_ipaddr));
585 	newte->uid = logrec->re_header.rh_uid;
586 	newte->nfsvers = NFS_VERSION;
587 	newte->netid = strdup(logrec->re_netid);
588 	if (logrec->re_principal_name)
589 		newte->principal_name = strdup(logrec->re_principal_name);
590 	else
591 		newte->principal_name = NULL;
592 	newte->totalbytes = res->nfslog_rdresult_u.r_ok.rrok_count;
593 	newte->fh_u.fh = *(NFSLOG_GET_FHANDLE2(&args->ra_fhandle));
594 
595 	if (res->nfslog_rdresult_u.r_ok.rrok_count <
596 		res->nfslog_rdresult_u.r_ok.filesize) {
597 		if (pte = insert_te(tf->te_list_v2_read, newte)) {
598 			/* free this since entry was found (not inserted) */
599 			remove_te(newte);
600 
601 			pte->totalbytes +=
602 				res->nfslog_rdresult_u.r_ok.rrok_count;
603 
604 			if (pte->lastupdate.tv_sec <=
605 				logrec->re_header.rh_timestamp.tv_sec)
606 				pte->lastupdate =
607 					logrec->re_header.rh_timestamp;
608 
609 			if (pte->totalbytes <
610 				res->nfslog_rdresult_u.r_ok.filesize) {
611 				pte = NULL; /* prevent printing of log entry */
612 			}
613 		}
614 	} else {
615 		pte = newte; /* print a log record - complete file read */
616 	}
617 
618 	return (pte);
619 }
620 
621 static struct transentry *
trans_write(nfslog_request_record * logrec,struct nfslog_trans_file * tf,char * fhpath,char * path1)622 trans_write(
623 	nfslog_request_record *logrec,
624 	struct nfslog_trans_file *tf,
625 	char *fhpath,
626 	char *path1)
627 {
628 	struct transentry *newte;
629 	struct transentry *pte = NULL;
630 	/* LINTED */
631 	nfslog_writeargs *args = (nfslog_writeargs *)logrec->re_rpc_arg;
632 	/* LINTED */
633 	nfslog_writeresult *res = (nfslog_writeresult *)logrec->re_rpc_res;
634 
635 	if (res->wr_status != NFS_OK)
636 		return (NULL);
637 
638 	if ((newte = create_te()) == NULL)
639 		return (NULL);
640 
641 	if (!path1) {
642 		newte->pathname = nfslog_get_path(&args->waargs_fhandle,
643 			NULL, fhpath, "trans_write");
644 	} else {
645 		newte->pathname = strdup(path1);
646 	}
647 
648 	newte->starttime = logrec->re_header.rh_timestamp;
649 	newte->lastupdate = logrec->re_header.rh_timestamp;
650 	newte->optype = TRANS_OPER_WRITE;
651 	newte->datatype = TRANS_DATATYPE_BINARY;
652 	newte->transoption = TRANS_OPTION_NOACTION;
653 	newte->pnb = netbufdup(&(logrec->re_ipaddr));
654 	newte->uid = logrec->re_header.rh_uid;
655 	newte->nfsvers = NFS_VERSION;
656 	newte->netid = strdup(logrec->re_netid);
657 	if (logrec->re_principal_name)
658 		newte->principal_name = strdup(logrec->re_principal_name);
659 	else
660 		newte->principal_name = NULL;
661 	newte->totalbytes = args->waargs_totcount;
662 	newte->fh_u.fh = *(NFSLOG_GET_FHANDLE2(&args->waargs_fhandle));
663 
664 	if (pte = insert_te(tf->te_list_v2_write, newte)) {
665 		/*
666 		 * if the write would have increased the total byte count
667 		 * over the filesize, then generate a log entry and remove
668 		 * the write record and insert the new one.
669 		 */
670 		if (pte->totalbytes + args->waargs_totcount >
671 			res->nfslog_writeresult_u.wr_size) {
672 			nfslog_print_trans_logentry(pte, tf);
673 			remove_te(pte);
674 			(void) insert_te(tf->te_list_v2_write, newte);
675 			pte = NULL;
676 		} else {
677 			/* free this since entry was found (not inserted) */
678 			remove_te(newte);
679 
680 			pte->totalbytes += args->waargs_totcount;
681 
682 			if (pte->lastupdate.tv_sec <=
683 				logrec->re_header.rh_timestamp.tv_sec) {
684 				pte->lastupdate =
685 					logrec->re_header.rh_timestamp;
686 			}
687 			pte = NULL; /* prevent printing of log entry */
688 		}
689 	}
690 	return (pte);
691 }
692 
693 static struct transentry *
trans_setattr(nfslog_request_record * logrec,struct nfslog_trans_file * tf,char * fhpath,char * path1)694 trans_setattr(
695 	nfslog_request_record *logrec,
696 	struct nfslog_trans_file *tf,
697 	char *fhpath,
698 	char *path1)
699 {
700 	struct transentry *newte;
701 	struct transentry *pte = NULL;
702 	/* LINTED */
703 	nfslog_setattrargs *args = (nfslog_setattrargs *)logrec->re_rpc_arg;
704 	/* LINTED */
705 	nfsstat *res = (nfsstat *)logrec->re_rpc_res;
706 
707 	if (*res != NFS_OK)
708 		return (NULL);
709 
710 	if (args->saa_sa.sa_size == (uint32_t)-1)
711 		return (NULL);
712 	/*
713 	 * should check the size of the file to see if it
714 	 * is being truncated below current eof.  if so
715 	 * a record should be generated.... XXX
716 	 */
717 	if (args->saa_sa.sa_size != 0)
718 		return (NULL);
719 
720 	if ((newte = create_te()) == NULL)
721 		return (NULL);
722 
723 	if (!path1) {
724 		newte->pathname  = nfslog_get_path(&args->saa_fh, NULL,
725 			fhpath,	"trans_setattr2");
726 	} else {
727 		newte->pathname = strdup(path1);
728 	}
729 
730 	newte->starttime = logrec->re_header.rh_timestamp;
731 	newte->lastupdate = logrec->re_header.rh_timestamp;
732 	newte->optype = TRANS_OPER_SETATTR;
733 	newte->datatype = TRANS_DATATYPE_BINARY;
734 	newte->transoption = TRANS_OPTION_NOACTION;
735 	newte->pnb = netbufdup(&(logrec->re_ipaddr));
736 	newte->uid = logrec->re_header.rh_uid;
737 	newte->nfsvers = NFS_VERSION;
738 	newte->netid = strdup(logrec->re_netid);
739 	if (logrec->re_principal_name)
740 		newte->principal_name = strdup(logrec->re_principal_name);
741 	else
742 		newte->principal_name = NULL;
743 	newte->totalbytes = 0;
744 	newte->fh_u.fh = *(NFSLOG_GET_FHANDLE2(&args->saa_fh));
745 
746 	if (pte = insert_te(tf->te_list_v2_write, newte)) {
747 		nfslog_print_trans_logentry(pte, tf);
748 		remove_te(pte);
749 	}
750 	if (pte = insert_te(tf->te_list_v2_read, newte)) {
751 		nfslog_print_trans_logentry(pte, tf);
752 		remove_te(pte);
753 	}
754 
755 	return (newte);
756 }
757 
758 static struct transentry *
trans_create(nfslog_request_record * logrec,struct nfslog_trans_file * tf,char * fhpath,char * path1)759 trans_create(
760 	nfslog_request_record *logrec,
761 	struct nfslog_trans_file *tf,
762 	char *fhpath,
763 	char *path1)
764 {
765 	struct transentry *newte;
766 	struct transentry *pte = NULL;
767 	/* LINTED */
768 	nfslog_createargs *args = (nfslog_createargs *)logrec->re_rpc_arg;
769 	/* LINTED */
770 	nfslog_diropres *res = (nfslog_diropres *)logrec->re_rpc_res;
771 
772 	if (res->dr_status != NFS_OK)
773 		return (NULL);
774 
775 	if ((newte = create_te()) == NULL)
776 		return (NULL);
777 
778 	if (!path1) {
779 		newte->pathname =
780 			nfslog_get_path(&args->ca_da.da_fhandle,
781 				args->ca_da.da_name,
782 				fhpath, "trans_create2");
783 	} else {
784 		newte->pathname = strdup(path1);
785 	}
786 
787 	newte->starttime = logrec->re_header.rh_timestamp;
788 	newte->lastupdate = logrec->re_header.rh_timestamp;
789 	newte->optype = TRANS_OPER_CREATE;
790 	newte->datatype = TRANS_DATATYPE_BINARY;
791 	newte->transoption = TRANS_OPTION_NOACTION;
792 	newte->pnb = netbufdup(&(logrec->re_ipaddr));
793 	newte->uid = logrec->re_header.rh_uid;
794 	newte->nfsvers = NFS_VERSION;
795 	newte->netid = strdup(logrec->re_netid);
796 	if (logrec->re_principal_name)
797 		newte->principal_name = strdup(logrec->re_principal_name);
798 	else
799 		newte->principal_name = NULL;
800 
801 	if (args->ca_sa.sa_size == (uint32_t)-1)
802 		newte->totalbytes = 0;
803 	else
804 		newte->totalbytes = args->ca_sa.sa_size;
805 
806 	newte->fh_u.fh = *(NFSLOG_GET_FHANDLE2(
807 		&res->nfslog_diropres_u.dr_ok.drok_fhandle));
808 
809 	/*
810 	 * if the file is being truncated on create, we need to flush
811 	 * any outstanding read/write transactions
812 	 */
813 	if (args->ca_sa.sa_size != (uint32_t)-1) {
814 		if (pte = insert_te(tf->te_list_v2_write, newte)) {
815 			nfslog_print_trans_logentry(pte, tf);
816 			remove_te(pte);
817 		}
818 		if (pte = insert_te(tf->te_list_v2_read, newte)) {
819 			nfslog_print_trans_logentry(pte, tf);
820 			remove_te(pte);
821 		}
822 	}
823 
824 	return (newte);
825 }
826 
827 static struct transentry *
trans_remove(nfslog_request_record * logrec,struct nfslog_trans_file * tf,char * fhpath,char * path1)828 trans_remove(
829 	nfslog_request_record *logrec,
830 	struct nfslog_trans_file *tf,
831 	char *fhpath,
832 	char *path1)
833 {
834 	struct transentry *newte;
835 	struct transentry *pte = NULL;
836 	/* LINTED */
837 	nfslog_diropargs *args = (nfslog_diropargs *)logrec->re_rpc_arg;
838 	/* LINTED */
839 	nfsstat *res = (nfsstat *)logrec->re_rpc_res;
840 
841 	if (*res != NFS_OK)
842 		return (NULL);
843 
844 	if ((newte = create_te()) == NULL)
845 		return (NULL);
846 
847 	if (!path1) {
848 		char *name = args->da_name;
849 		fhandle_t *dfh = &args->da_fhandle;
850 		newte->pathname = nfslog_get_path(dfh, name,
851 			fhpath, "trans_remove2");
852 	} else {
853 		newte->pathname = strdup(path1);
854 	}
855 
856 	newte->starttime = logrec->re_header.rh_timestamp;
857 	newte->lastupdate = logrec->re_header.rh_timestamp;
858 	newte->optype = TRANS_OPER_REMOVE;
859 	newte->datatype = TRANS_DATATYPE_BINARY;
860 	newte->transoption = TRANS_OPTION_NOACTION;
861 	newte->pnb = netbufdup(&(logrec->re_ipaddr));
862 	newte->uid = logrec->re_header.rh_uid;
863 	newte->nfsvers = NFS_VERSION;
864 	newte->netid = strdup(logrec->re_netid);
865 	if (logrec->re_principal_name)
866 		newte->principal_name = strdup(logrec->re_principal_name);
867 	else
868 		newte->principal_name = NULL;
869 	newte->totalbytes = 0;
870 	newte->fh_u.fh = *(NFSLOG_GET_FHANDLE2(&args->da_fhandle));
871 
872 	if (pte = insert_te(tf->te_list_v2_write, newte)) {
873 		nfslog_print_trans_logentry(pte, tf);
874 		remove_te(pte);
875 	}
876 	if (pte = insert_te(tf->te_list_v2_read, newte)) {
877 		nfslog_print_trans_logentry(pte, tf);
878 		remove_te(pte);
879 	}
880 	if (pte = insert_te(tf->te_list_v3_write, newte)) {
881 		nfslog_print_trans_logentry(pte, tf);
882 		remove_te(pte);
883 	}
884 	if (pte = insert_te(tf->te_list_v3_read, newte)) {
885 		nfslog_print_trans_logentry(pte, tf);
886 		remove_te(pte);
887 	}
888 
889 	return (newte);
890 }
891 
892 static struct transentry *
trans_mkdir(nfslog_request_record * logrec,char * fhpath,char * path1)893 trans_mkdir(
894 	nfslog_request_record *logrec,
895 	char *fhpath,
896 	char *path1)
897 {
898 	struct transentry *newte;
899 	/* LINTED */
900 	nfslog_createargs *args = (nfslog_createargs *)logrec->re_rpc_arg;
901 	/* LINTED */
902 	nfslog_diropres *res = (nfslog_diropres *)logrec->re_rpc_res;
903 
904 	if (res->dr_status != NFS_OK)
905 		return (NULL);
906 
907 	if ((newte = create_te()) == NULL)
908 		return (NULL);
909 
910 	if (!path1) {
911 		nfslog_diropargs *dargs = &args->ca_da;
912 		char *name = dargs->da_name;
913 		fhandle_t *dfh = &dargs->da_fhandle;
914 		newte->pathname = nfslog_get_path(dfh, name,
915 			fhpath, "trans_mkdir2");
916 	} else {
917 		newte->pathname = strdup(path1);
918 	}
919 
920 	newte->starttime = logrec->re_header.rh_timestamp;
921 	newte->lastupdate = logrec->re_header.rh_timestamp;
922 	newte->optype = TRANS_OPER_MKDIR;
923 	newte->datatype = TRANS_DATATYPE_BINARY;
924 	newte->transoption = TRANS_OPTION_NOACTION;
925 	newte->pnb = netbufdup(&(logrec->re_ipaddr));
926 	newte->uid = logrec->re_header.rh_uid;
927 	newte->nfsvers = NFS_VERSION;
928 	newte->netid = strdup(logrec->re_netid);
929 	if (logrec->re_principal_name)
930 		newte->principal_name = strdup(logrec->re_principal_name);
931 	else
932 		newte->principal_name = NULL;
933 	newte->totalbytes = 0;
934 	newte->fh_u.fh = *(NFSLOG_GET_FHANDLE2(&args->ca_da.da_fhandle));
935 
936 	return (newte);
937 }
938 
939 static struct transentry *
trans_rmdir(nfslog_request_record * logrec,char * fhpath,char * path1)940 trans_rmdir(
941 	nfslog_request_record *logrec,
942 	char *fhpath,
943 	char *path1)
944 {
945 	struct transentry *newte;
946 	/* LINTED */
947 	nfslog_diropargs *args = (nfslog_diropargs *)logrec->re_rpc_arg;
948 	/* LINTED */
949 	nfsstat *res = (nfsstat *)logrec->re_rpc_res;
950 
951 	if (*res != NFS_OK)
952 		return (NULL);
953 
954 	if ((newte = create_te()) == NULL)
955 		return (NULL);
956 
957 	if (!path1) {
958 		char *name = args->da_name;
959 		fhandle_t *dfh = &args->da_fhandle;
960 		newte->pathname = nfslog_get_path(dfh, name,
961 			fhpath, "trans_rmdir2");
962 	} else {
963 		newte->pathname = strdup(path1);
964 	}
965 
966 	newte->starttime = logrec->re_header.rh_timestamp;
967 	newte->lastupdate = logrec->re_header.rh_timestamp;
968 	newte->optype = TRANS_OPER_RMDIR;
969 	newte->datatype = TRANS_DATATYPE_BINARY;
970 	newte->transoption = TRANS_OPTION_NOACTION;
971 	newte->pnb = netbufdup(&(logrec->re_ipaddr));
972 	newte->uid = logrec->re_header.rh_uid;
973 	newte->nfsvers = NFS_VERSION;
974 	newte->netid = strdup(logrec->re_netid);
975 	if (logrec->re_principal_name)
976 		newte->principal_name = strdup(logrec->re_principal_name);
977 	else
978 		newte->principal_name = NULL;
979 	newte->totalbytes = 0;
980 	newte->fh_u.fh = *(NFSLOG_GET_FHANDLE2(&args->da_fhandle));
981 
982 	return (newte);
983 }
984 
985 static struct transentry *
trans_rename(nfslog_request_record * logrec,struct nfslog_trans_file * tf,char * fhpath,char * path1,char * path2)986 trans_rename(
987 	nfslog_request_record *logrec,
988 	struct nfslog_trans_file *tf,
989 	char *fhpath,
990 	char *path1,
991 	char *path2)
992 {
993 	struct transentry *newte;
994 	struct transentry *pte = NULL;
995 	/* LINTED */
996 	nfslog_rnmargs *args = (nfslog_rnmargs *)logrec->re_rpc_arg;
997 	/* LINTED */
998 	nfsstat *res = (nfsstat *)logrec->re_rpc_res;
999 	char *tpath1 = NULL;
1000 	char *tpath2 = NULL;
1001 
1002 	if (*res != NFS_OK)
1003 		return (NULL);
1004 
1005 	if ((newte = create_te()) == NULL)
1006 		return (NULL);
1007 
1008 	if (!path1) {
1009 		char *from_name, *to_name;
1010 		fhandle_t *from_dfh, *to_dfh;
1011 
1012 		from_name = args->rna_from.da_name;
1013 		from_dfh = &args->rna_from.da_fhandle;
1014 		to_name = args->rna_to.da_name;
1015 		to_dfh = &args->rna_to.da_fhandle;
1016 
1017 		path1 = tpath1 = nfslog_get_path(from_dfh, from_name,
1018 			fhpath,	"trans_rename from");
1019 		path2 = tpath2 = nfslog_get_path(to_dfh, to_name,
1020 			fhpath, "trans_rename to");
1021 	}
1022 
1023 	newte->pathname = path1; /* no need to strdup here */
1024 	newte->starttime = logrec->re_header.rh_timestamp;
1025 	newte->lastupdate = logrec->re_header.rh_timestamp;
1026 	newte->optype = TRANS_OPER_RENAME;
1027 	newte->datatype = TRANS_DATATYPE_BINARY;
1028 	newte->transoption = TRANS_OPTION_NOACTION;
1029 	newte->pnb = netbufdup(&(logrec->re_ipaddr));
1030 	newte->uid = logrec->re_header.rh_uid;
1031 	newte->nfsvers = NFS_VERSION;
1032 	newte->netid = strdup(logrec->re_netid);
1033 	if (logrec->re_principal_name)
1034 		newte->principal_name = strdup(logrec->re_principal_name);
1035 	else
1036 		newte->principal_name = NULL;
1037 	newte->totalbytes = 0;
1038 	newte->fh_u.fh = *(NFSLOG_GET_FHANDLE2(&args->rna_from.da_fhandle));
1039 
1040 	/* switch path names for the file for renames */
1041 	if (pte = insert_te(tf->te_list_v2_write, newte)) {
1042 		free(pte->pathname);
1043 		pte->pathname = strdup(path2);
1044 	}
1045 	if (pte = insert_te(tf->te_list_v2_read, newte)) {
1046 		free(pte->pathname);
1047 		pte->pathname = strdup(path2);
1048 	}
1049 	if (pte = insert_te(tf->te_list_v3_write, newte)) {
1050 		free(pte->pathname);
1051 		pte->pathname = strdup(path2);
1052 	}
1053 	if (pte = insert_te(tf->te_list_v3_read, newte)) {
1054 		free(pte->pathname);
1055 		pte->pathname = strdup(path2);
1056 	}
1057 
1058 	newte->pathname = (char *)malloc(strlen(path1) + strlen(path2) + 3);
1059 	/* check for NULL malloc */
1060 	(void) sprintf(newte->pathname, "%s->%s", path1, path2);
1061 
1062 	if (tpath1) {
1063 		free(tpath1);
1064 		free(tpath2);
1065 	}
1066 
1067 	return (newte);
1068 }
1069 
1070 static struct transentry *
trans_link(nfslog_request_record * logrec,char * fhpath,char * path1,char * path2)1071 trans_link(
1072 	nfslog_request_record *logrec,
1073 	char *fhpath,
1074 	char *path1,
1075 	char *path2)
1076 {
1077 	struct transentry *newte;
1078 	/* LINTED */
1079 	nfslog_linkargs *args = (nfslog_linkargs *)logrec->re_rpc_arg;
1080 	/* LINTED */
1081 	nfsstat *res = (nfsstat *)logrec->re_rpc_res;
1082 	char *tpath1 = NULL;
1083 	char *tpath2 = NULL;
1084 
1085 	if (*res != NFS_OK)
1086 		return (NULL);
1087 
1088 	if ((newte = create_te()) == NULL)
1089 		return (NULL);
1090 
1091 	if (!path1) {
1092 		fhandle_t *fh = &args->la_from;
1093 		char *name = args->la_to.da_name;
1094 		fhandle_t *dfh = &args->la_to.da_fhandle;
1095 
1096 		path1 = tpath1 = nfslog_get_path(fh, NULL,
1097 			fhpath, "trans_link from");
1098 		path2 = tpath2 = nfslog_get_path(dfh, name,
1099 			fhpath, "trans_link to");
1100 	}
1101 
1102 	newte->starttime = logrec->re_header.rh_timestamp;
1103 	newte->lastupdate = logrec->re_header.rh_timestamp;
1104 	newte->optype = TRANS_OPER_LINK;
1105 	newte->datatype = TRANS_DATATYPE_BINARY;
1106 	newte->transoption = TRANS_OPTION_NOACTION;
1107 	newte->pnb = netbufdup(&(logrec->re_ipaddr));
1108 	newte->uid = logrec->re_header.rh_uid;
1109 	newte->nfsvers = NFS_VERSION;
1110 	newte->netid = strdup(logrec->re_netid);
1111 	if (logrec->re_principal_name)
1112 		newte->principal_name = strdup(logrec->re_principal_name);
1113 	else
1114 		newte->principal_name = NULL;
1115 	newte->totalbytes = 0;
1116 	newte->fh_u.fh = *(NFSLOG_GET_FHANDLE2(&args->la_from));
1117 
1118 	newte->pathname = (char *)malloc(strlen(path1) + strlen(path2) + 3);
1119 	/* check for NULL malloc */
1120 	(void) sprintf(newte->pathname, "%s->%s", path1, path2);
1121 
1122 	if (tpath1) {
1123 		free(tpath1);
1124 		free(tpath2);
1125 	}
1126 
1127 	return (newte);
1128 }
1129 
1130 static struct transentry *
trans_symlink(nfslog_request_record * logrec,char * fhpath,char * path1)1131 trans_symlink(
1132 	nfslog_request_record *logrec,
1133 	char *fhpath,
1134 	char *path1)
1135 {
1136 	struct transentry *newte;
1137 	/* LINTED */
1138 	nfslog_symlinkargs *args = (nfslog_symlinkargs *)logrec->re_rpc_arg;
1139 	/* LINTED */
1140 	nfsstat *res = (nfsstat *)logrec->re_rpc_res;
1141 	char *tpath1 = NULL;
1142 
1143 	if (*res != NFS_OK)
1144 		return (NULL);
1145 
1146 	if ((newte = create_te()) == NULL)
1147 		return (NULL);
1148 
1149 	if (!path1) {
1150 		char *name = args->sla_from.da_name;
1151 		fhandle_t *dfh = &args->sla_from.da_fhandle;
1152 
1153 		path1 = tpath1 = nfslog_get_path(dfh, name,
1154 			fhpath, "trans_symlink");
1155 	}
1156 
1157 	newte->starttime = logrec->re_header.rh_timestamp;
1158 	newte->lastupdate = logrec->re_header.rh_timestamp;
1159 	newte->optype = TRANS_OPER_SYMLINK;
1160 	newte->datatype = TRANS_DATATYPE_BINARY;
1161 	newte->transoption = TRANS_OPTION_NOACTION;
1162 	newte->pnb = netbufdup(&(logrec->re_ipaddr));
1163 	newte->uid = logrec->re_header.rh_uid;
1164 	newte->nfsvers = NFS_VERSION;
1165 	newte->netid = strdup(logrec->re_netid);
1166 	if (logrec->re_principal_name)
1167 		newte->principal_name = strdup(logrec->re_principal_name);
1168 	else
1169 		newte->principal_name = NULL;
1170 	newte->totalbytes = 0;
1171 	newte->fh_u.fh = *(NFSLOG_GET_FHANDLE2(&args->sla_from.da_fhandle));
1172 
1173 	newte->pathname = (char *)malloc(strlen(path1) +
1174 		strlen(args->sla_tnm) + 3);
1175 	(void) sprintf(newte->pathname, "%s->%s", path1, args->sla_tnm);
1176 
1177 	if (tpath1)
1178 		free(tpath1);
1179 
1180 	return (newte);
1181 }
1182 
1183 static struct transentry *
trans_read3(nfslog_request_record * logrec,struct nfslog_trans_file * tf,char * fhpath,char * path1)1184 trans_read3(
1185 	nfslog_request_record *logrec,
1186 	struct nfslog_trans_file *tf,
1187 	char *fhpath,
1188 	char *path1)
1189 {
1190 	struct transentry *newte;
1191 	struct transentry *pte = NULL;
1192 	/* LINTED */
1193 	nfslog_READ3args *args = (nfslog_READ3args *)logrec->re_rpc_arg;
1194 	/* LINTED */
1195 	nfslog_READ3res *res = (nfslog_READ3res *)logrec->re_rpc_res;
1196 
1197 	if (res->status != NFS3_OK)
1198 		return (NULL);
1199 
1200 	if ((newte = create_te()) == NULL)
1201 		return (NULL);
1202 
1203 	if (!path1) {
1204 		fhandle_t *fh = NFSLOG_GET_FHANDLE3(&args->file);
1205 		newte->pathname = nfslog_get_path(fh, NULL,
1206 			fhpath, "trans_read3");
1207 	} else {
1208 		newte->pathname = strdup(path1);
1209 	}
1210 
1211 	/* prep the struct for insertion */
1212 	newte->starttime = logrec->re_header.rh_timestamp;
1213 	newte->lastupdate = logrec->re_header.rh_timestamp;
1214 	newte->optype = TRANS_OPER_READ;
1215 	newte->datatype = TRANS_DATATYPE_BINARY;
1216 	newte->transoption = TRANS_OPTION_NOACTION;
1217 	newte->pnb = netbufdup(&(logrec->re_ipaddr));
1218 	newte->uid = logrec->re_header.rh_uid;
1219 	newte->nfsvers = NFS_V3;
1220 	newte->netid = strdup(logrec->re_netid);
1221 	if (logrec->re_principal_name)
1222 		newte->principal_name = strdup(logrec->re_principal_name);
1223 	else
1224 		newte->principal_name = NULL;
1225 	newte->totalbytes = res->nfslog_READ3res_u.ok.count;
1226 	newte->fh_u.fh3 = args->file;
1227 
1228 	if (res->nfslog_READ3res_u.ok.count <
1229 		res->nfslog_READ3res_u.ok.filesize) {
1230 		if (pte = insert_te(tf->te_list_v3_read, newte)) {
1231 			/* free this since entry was found (not inserted) */
1232 			remove_te(newte);
1233 
1234 			pte->totalbytes += res->nfslog_READ3res_u.ok.count;
1235 
1236 			if (pte->lastupdate.tv_sec <=
1237 				logrec->re_header.rh_timestamp.tv_sec)
1238 				pte->lastupdate =
1239 					logrec->re_header.rh_timestamp;
1240 
1241 			if (pte->totalbytes <
1242 				res->nfslog_READ3res_u.ok.filesize) {
1243 				pte = NULL; /* prevent printing of log entry */
1244 			}
1245 		}
1246 	} else {
1247 		pte = newte; /* print a log record - complete file read */
1248 	}
1249 
1250 	return (pte);
1251 }
1252 
1253 static struct transentry *
trans_write3(nfslog_request_record * logrec,struct nfslog_trans_file * tf,char * fhpath,char * path1)1254 trans_write3(
1255 	nfslog_request_record *logrec,
1256 	struct nfslog_trans_file *tf,
1257 	char *fhpath,
1258 	char *path1)
1259 {
1260 	struct transentry *newte;
1261 	struct transentry *pte = NULL;
1262 	/* LINTED */
1263 	nfslog_WRITE3args *args = (nfslog_WRITE3args *)logrec->re_rpc_arg;
1264 	/* LINTED */
1265 	nfslog_WRITE3res *res = (nfslog_WRITE3res *)logrec->re_rpc_res;
1266 
1267 	if (res->status != NFS3_OK)
1268 		return (NULL);
1269 
1270 	if ((newte = create_te()) == NULL)
1271 		return (NULL);
1272 
1273 	if (!path1) {
1274 		fhandle_t *fh = NFSLOG_GET_FHANDLE3(&args->file);
1275 		newte->pathname = nfslog_get_path(fh, NULL,
1276 			fhpath, "trans_write3");
1277 	} else {
1278 		newte->pathname = strdup(path1);
1279 	}
1280 
1281 	newte->starttime = logrec->re_header.rh_timestamp;
1282 	newte->lastupdate = logrec->re_header.rh_timestamp;
1283 	newte->optype = TRANS_OPER_WRITE;
1284 	newte->datatype = TRANS_DATATYPE_BINARY;
1285 	newte->transoption = TRANS_OPTION_NOACTION;
1286 	newte->pnb = netbufdup(&(logrec->re_ipaddr));
1287 	newte->uid = logrec->re_header.rh_uid;
1288 	newte->nfsvers = NFS_V3;
1289 	newte->netid = strdup(logrec->re_netid);
1290 	if (logrec->re_principal_name)
1291 		newte->principal_name = strdup(logrec->re_principal_name);
1292 	else
1293 		newte->principal_name = NULL;
1294 	newte->totalbytes = res->nfslog_WRITE3res_u.ok.count;
1295 	newte->fh_u.fh3 = args->file;
1296 
1297 	if (pte = insert_te(tf->te_list_v3_write, newte)) {
1298 		/*
1299 		 * if the write would have increased the total byte count
1300 		 * over the filesize, then generate a log entry and remove
1301 		 * the write record and insert the new one.
1302 		 */
1303 		if (pte->totalbytes + res->nfslog_WRITE3res_u.ok.count >
1304 			res->nfslog_WRITE3res_u.ok.filesize) {
1305 			nfslog_print_trans_logentry(pte, tf);
1306 			remove_te(pte);
1307 			(void) insert_te(tf->te_list_v3_write, newte);
1308 			pte = NULL;
1309 		} else {
1310 			/* free this since entry was found (not inserted) */
1311 			remove_te(newte);
1312 
1313 			pte->totalbytes += res->nfslog_WRITE3res_u.ok.count;
1314 
1315 			if (pte->lastupdate.tv_sec <=
1316 				logrec->re_header.rh_timestamp.tv_sec) {
1317 				pte->lastupdate =
1318 					logrec->re_header.rh_timestamp;
1319 			}
1320 			pte = NULL; /* prevent printing of log entry */
1321 		}
1322 	}
1323 	return (pte);
1324 }
1325 
1326 static struct transentry *
trans_setattr3(nfslog_request_record * logrec,struct nfslog_trans_file * tf,char * fhpath,char * path1)1327 trans_setattr3(
1328 	nfslog_request_record *logrec,
1329 	struct nfslog_trans_file *tf,
1330 	char *fhpath,
1331 	char *path1)
1332 {
1333 	struct transentry *newte;
1334 	struct transentry *pte = NULL;
1335 	/* LINTED */
1336 	nfslog_SETATTR3args *args = (nfslog_SETATTR3args *)logrec->re_rpc_arg;
1337 	/* LINTED */
1338 	nfsstat3 *res = (nfsstat3 *)logrec->re_rpc_res;
1339 
1340 	if (*res != NFS3_OK)
1341 		return (NULL);
1342 
1343 	if (!args->size.set_it)
1344 		return (NULL);
1345 	/*
1346 	 * should check the size of the file to see if it
1347 	 * is being truncated below current eof.  if so
1348 	 * a record should be generated.... XXX
1349 	 */
1350 	if (args->size.size != 0)
1351 		return (NULL);
1352 
1353 	if ((newte = create_te()) == NULL)
1354 		return (NULL);
1355 
1356 	if (!path1) {
1357 		fhandle_t *fh = NFSLOG_GET_FHANDLE3(&args->object);
1358 		newte->pathname = nfslog_get_path(fh, NULL,
1359 			fhpath, "trans_setattr3");
1360 	} else {
1361 		newte->pathname = strdup(path1);
1362 	}
1363 
1364 	newte->starttime = logrec->re_header.rh_timestamp;
1365 	newte->lastupdate = logrec->re_header.rh_timestamp;
1366 	newte->optype = TRANS_OPER_SETATTR;
1367 	newte->datatype = TRANS_DATATYPE_BINARY;
1368 	newte->transoption = TRANS_OPTION_NOACTION;
1369 	newte->pnb = netbufdup(&(logrec->re_ipaddr));
1370 	newte->uid = logrec->re_header.rh_uid;
1371 	newte->nfsvers = NFS_V3;
1372 	newte->netid = strdup(logrec->re_netid);
1373 	if (logrec->re_principal_name)
1374 		newte->principal_name = strdup(logrec->re_principal_name);
1375 	else
1376 		newte->principal_name = NULL;
1377 	newte->totalbytes = 0;
1378 	newte->fh_u.fh3 = args->object;
1379 
1380 	if (pte = insert_te(tf->te_list_v3_write, newte)) {
1381 		nfslog_print_trans_logentry(pte, tf);
1382 		remove_te(pte);
1383 	}
1384 	if (pte = insert_te(tf->te_list_v3_read, newte)) {
1385 		nfslog_print_trans_logentry(pte, tf);
1386 		remove_te(pte);
1387 	}
1388 
1389 	return (newte);
1390 }
1391 
1392 static struct transentry *
trans_create3(nfslog_request_record * logrec,struct nfslog_trans_file * tf,char * fhpath,char * path1)1393 trans_create3(
1394 	nfslog_request_record *logrec,
1395 	struct nfslog_trans_file *tf,
1396 	char *fhpath,
1397 	char *path1)
1398 {
1399 	struct transentry *newte;
1400 	struct transentry *pte = NULL;
1401 	/* LINTED */
1402 	nfslog_CREATE3args *args = (nfslog_CREATE3args *)logrec->re_rpc_arg;
1403 	/* LINTED */
1404 	nfslog_CREATE3res *res = (nfslog_CREATE3res *)logrec->re_rpc_res;
1405 
1406 	if (res->status != NFS3_OK)
1407 		return (NULL);
1408 
1409 	if ((newte = create_te()) == NULL)
1410 		return (NULL);
1411 
1412 	if (!path1) {
1413 		newte->pathname =
1414 			nfslog_get_path(NFSLOG_GET_FHANDLE3(&args->where.dir),
1415 				args->where.name,
1416 				fhpath, "trans_create3");
1417 	} else {
1418 		newte->pathname = strdup(path1);
1419 	}
1420 
1421 	newte->starttime = logrec->re_header.rh_timestamp;
1422 	newte->lastupdate = logrec->re_header.rh_timestamp;
1423 	newte->optype = TRANS_OPER_CREATE;
1424 	newte->datatype = TRANS_DATATYPE_BINARY;
1425 	newte->transoption = TRANS_OPTION_NOACTION;
1426 	newte->pnb = netbufdup(&(logrec->re_ipaddr));
1427 	newte->uid = logrec->re_header.rh_uid;
1428 	newte->nfsvers = NFS_V3;
1429 	newte->netid = strdup(logrec->re_netid);
1430 	if (logrec->re_principal_name)
1431 		newte->principal_name = strdup(logrec->re_principal_name);
1432 	else
1433 		newte->principal_name = NULL;
1434 
1435 	if (!args->how.nfslog_createhow3_u.size.set_it)
1436 		newte->totalbytes = 0;
1437 	else
1438 		newte->totalbytes =
1439 			args->how.nfslog_createhow3_u.size.size;
1440 
1441 	newte->fh_u.fh3 = args->where.dir;
1442 
1443 	if (args->how.nfslog_createhow3_u.size.set_it) {
1444 		if (pte = insert_te(tf->te_list_v3_write, newte)) {
1445 			nfslog_print_trans_logentry(pte, tf);
1446 			remove_te(pte);
1447 		}
1448 		if (pte = insert_te(tf->te_list_v3_read, newte)) {
1449 			nfslog_print_trans_logentry(pte, tf);
1450 			remove_te(pte);
1451 		}
1452 	}
1453 
1454 	return (newte);
1455 }
1456 
1457 static struct transentry *
trans_remove3(nfslog_request_record * logrec,struct nfslog_trans_file * tf,char * fhpath,char * path1)1458 trans_remove3(
1459 	nfslog_request_record *logrec,
1460 	struct nfslog_trans_file *tf,
1461 	char *fhpath,
1462 	char *path1)
1463 {
1464 	struct transentry *newte;
1465 	struct transentry *pte = NULL;
1466 	/* LINTED */
1467 	nfslog_REMOVE3args *args = (nfslog_REMOVE3args *)logrec->re_rpc_arg;
1468 	/* LINTED */
1469 	nfsstat3 *res = (nfsstat3 *)logrec->re_rpc_res;
1470 
1471 	if (*res != NFS3_OK)
1472 		return (NULL);
1473 
1474 	if ((newte = create_te()) == NULL)
1475 		return (NULL);
1476 
1477 	if (!path1) {
1478 		newte->pathname =
1479 			nfslog_get_path(NFSLOG_GET_FHANDLE3(&args->object.dir),
1480 				args->object.name,
1481 				fhpath, "trans_remove3");
1482 	} else {
1483 		newte->pathname = strdup(path1);
1484 	}
1485 
1486 	newte->starttime = logrec->re_header.rh_timestamp;
1487 	newte->lastupdate = logrec->re_header.rh_timestamp;
1488 	newte->optype = TRANS_OPER_REMOVE;
1489 	newte->datatype = TRANS_DATATYPE_BINARY;
1490 	newte->transoption = TRANS_OPTION_NOACTION;
1491 	newte->pnb = netbufdup(&(logrec->re_ipaddr));
1492 	newte->uid = logrec->re_header.rh_uid;
1493 	newte->nfsvers = NFS_V3;
1494 	newte->netid = strdup(logrec->re_netid);
1495 	if (logrec->re_principal_name)
1496 		newte->principal_name = strdup(logrec->re_principal_name);
1497 	else
1498 		newte->principal_name = NULL;
1499 	newte->totalbytes = 0;
1500 	newte->fh_u.fh3 = args->object.dir;
1501 
1502 	if (pte = insert_te(tf->te_list_v3_write, newte)) {
1503 		nfslog_print_trans_logentry(pte, tf);
1504 		remove_te(pte);
1505 	}
1506 	if (pte = insert_te(tf->te_list_v3_read, newte)) {
1507 		nfslog_print_trans_logentry(pte, tf);
1508 		remove_te(pte);
1509 	}
1510 	if (pte = insert_te(tf->te_list_v2_write, newte)) {
1511 		nfslog_print_trans_logentry(pte, tf);
1512 		remove_te(pte);
1513 	}
1514 	if (pte = insert_te(tf->te_list_v2_read, newte)) {
1515 		nfslog_print_trans_logentry(pte, tf);
1516 		remove_te(pte);
1517 	}
1518 
1519 	return (newte);
1520 }
1521 
1522 static struct transentry *
trans_mkdir3(nfslog_request_record * logrec,char * fhpath,char * path1)1523 trans_mkdir3(
1524 	nfslog_request_record *logrec,
1525 	char *fhpath,
1526 	char *path1)
1527 {
1528 	struct transentry *newte;
1529 	/* LINTED */
1530 	nfslog_MKDIR3args *args = (nfslog_MKDIR3args *)logrec->re_rpc_arg;
1531 	/* LINTED */
1532 	nfslog_MKDIR3res *res = (nfslog_MKDIR3res *)logrec->re_rpc_res;
1533 
1534 	if (res->status != NFS3_OK)
1535 		return (NULL);
1536 
1537 	if ((newte = create_te()) == NULL)
1538 		return (NULL);
1539 
1540 	if (!path1) {
1541 		newte->pathname =
1542 			nfslog_get_path(NFSLOG_GET_FHANDLE3(&args->where.dir),
1543 				args->where.name,
1544 				fhpath, "trans_mkdir3");
1545 	} else {
1546 		newte->pathname = strdup(path1);
1547 	}
1548 
1549 	newte->starttime = logrec->re_header.rh_timestamp;
1550 	newte->lastupdate = logrec->re_header.rh_timestamp;
1551 	newte->optype = TRANS_OPER_MKDIR;
1552 	newte->datatype = TRANS_DATATYPE_BINARY;
1553 	newte->transoption = TRANS_OPTION_NOACTION;
1554 	newte->pnb = netbufdup(&(logrec->re_ipaddr));
1555 	newte->uid = logrec->re_header.rh_uid;
1556 	newte->nfsvers = NFS_V3;
1557 	newte->netid = strdup(logrec->re_netid);
1558 	if (logrec->re_principal_name)
1559 		newte->principal_name = strdup(logrec->re_principal_name);
1560 	else
1561 		newte->principal_name = NULL;
1562 	newte->totalbytes = 0;
1563 	newte->fh_u.fh3 = args->where.dir;
1564 
1565 	return (newte);
1566 }
1567 
1568 static struct transentry *
trans_rmdir3(nfslog_request_record * logrec,char * fhpath,char * path1)1569 trans_rmdir3(
1570 	nfslog_request_record *logrec,
1571 	char *fhpath,
1572 	char *path1)
1573 {
1574 	struct transentry *newte;
1575 	/* LINTED */
1576 	nfslog_RMDIR3args *args = (nfslog_RMDIR3args *)logrec->re_rpc_arg;
1577 	/* LINTED */
1578 	nfsstat3 *res = (nfsstat3 *)logrec->re_rpc_res;
1579 
1580 	if (*res != NFS3_OK)
1581 		return (NULL);
1582 
1583 	if ((newte = create_te()) == NULL)
1584 		return (NULL);
1585 
1586 	if (!path1) {
1587 		newte->pathname =
1588 			nfslog_get_path(NFSLOG_GET_FHANDLE3(&args->object.dir),
1589 				args->object.name,
1590 				fhpath, "trans_rmdir3");
1591 	} else {
1592 		newte->pathname = strdup(path1);
1593 	}
1594 
1595 	newte->starttime = logrec->re_header.rh_timestamp;
1596 	newte->lastupdate = logrec->re_header.rh_timestamp;
1597 	newte->optype = TRANS_OPER_RMDIR;
1598 	newte->datatype = TRANS_DATATYPE_BINARY;
1599 	newte->transoption = TRANS_OPTION_NOACTION;
1600 	newte->pnb = netbufdup(&(logrec->re_ipaddr));
1601 	newte->uid = logrec->re_header.rh_uid;
1602 	newte->nfsvers = NFS_V3;
1603 	newte->netid = strdup(logrec->re_netid);
1604 	if (logrec->re_principal_name)
1605 		newte->principal_name = strdup(logrec->re_principal_name);
1606 	else
1607 		newte->principal_name = NULL;
1608 	newte->totalbytes = 0;
1609 	newte->fh_u.fh3 = args->object.dir;
1610 
1611 	return (newte);
1612 }
1613 
1614 static struct transentry *
trans_rename3(nfslog_request_record * logrec,struct nfslog_trans_file * tf,char * fhpath,char * path1,char * path2)1615 trans_rename3(
1616 	nfslog_request_record *logrec,
1617 	struct nfslog_trans_file *tf,
1618 	char *fhpath,
1619 	char *path1,
1620 	char *path2)
1621 {
1622 	struct transentry *newte;
1623 	struct transentry *pte = NULL;
1624 	/* LINTED */
1625 	nfslog_RENAME3args *args = (nfslog_RENAME3args *)logrec->re_rpc_arg;
1626 	/* LINTED */
1627 	nfsstat3 *res = (nfsstat3 *)logrec->re_rpc_res;
1628 	char *tpath1 = NULL;
1629 	char *tpath2 = NULL;
1630 
1631 	if (*res != NFS3_OK)
1632 		return (NULL);
1633 
1634 	if ((newte = create_te()) == NULL)
1635 		return (NULL);
1636 
1637 	if (!path1) {
1638 		path1 = tpath1 =
1639 			nfslog_get_path(NFSLOG_GET_FHANDLE3(&args->from.dir),
1640 				args->from.name, fhpath, "trans_rename3 from");
1641 		path2 = tpath2 =
1642 			nfslog_get_path(NFSLOG_GET_FHANDLE3(&args->to.dir),
1643 				args->to.name, fhpath, "trans_rename3 to");
1644 	}
1645 
1646 	newte->pathname = path1; /* no need to strdup here */
1647 	newte->starttime = logrec->re_header.rh_timestamp;
1648 	newte->lastupdate = logrec->re_header.rh_timestamp;
1649 	newte->optype = TRANS_OPER_RENAME;
1650 	newte->datatype = TRANS_DATATYPE_BINARY;
1651 	newte->transoption = TRANS_OPTION_NOACTION;
1652 	newte->pnb = netbufdup(&(logrec->re_ipaddr));
1653 	newte->uid = logrec->re_header.rh_uid;
1654 	newte->nfsvers = NFS_V3;
1655 	newte->netid = strdup(logrec->re_netid);
1656 	if (logrec->re_principal_name)
1657 		newte->principal_name = strdup(logrec->re_principal_name);
1658 	else
1659 		newte->principal_name = NULL;
1660 	newte->totalbytes = 0;
1661 	newte->fh_u.fh3 = args->from.dir;
1662 
1663 	/* switch path names for the file for renames */
1664 	if (pte = insert_te(tf->te_list_v3_write, newte)) {
1665 		free(pte->pathname);
1666 		pte->pathname = strdup(path2);
1667 	}
1668 	if (pte = insert_te(tf->te_list_v3_read, newte)) {
1669 		free(pte->pathname);
1670 		pte->pathname = strdup(path2);
1671 	}
1672 	if (pte = insert_te(tf->te_list_v2_write, newte)) {
1673 		free(pte->pathname);
1674 		pte->pathname = strdup(path2);
1675 	}
1676 	if (pte = insert_te(tf->te_list_v2_read, newte)) {
1677 		free(pte->pathname);
1678 		pte->pathname = strdup(path2);
1679 	}
1680 
1681 	newte->pathname = (char *)malloc(strlen(path1) + strlen(path2) + 3);
1682 	/* check for NULL malloc */
1683 	(void) sprintf(newte->pathname, "%s->%s", path1, path2);
1684 
1685 	if (tpath1) {
1686 		free(tpath1);
1687 		free(tpath2);
1688 	}
1689 
1690 	return (newte);
1691 }
1692 
1693 static struct transentry *
trans_mknod3(nfslog_request_record * logrec,char * fhpath,char * path1)1694 trans_mknod3(
1695 	nfslog_request_record *logrec,
1696 	char *fhpath,
1697 	char *path1)
1698 {
1699 	struct transentry *newte;
1700 	/* LINTED */
1701 	nfslog_MKNOD3args *args = (nfslog_MKNOD3args *)logrec->re_rpc_arg;
1702 	/* LINTED */
1703 	nfslog_MKNOD3res *res = (nfslog_MKNOD3res *)logrec->re_rpc_res;
1704 
1705 	if (res->status != NFS3_OK)
1706 		return (NULL);
1707 
1708 	if ((newte = create_te()) == NULL)
1709 		return (NULL);
1710 
1711 	if (!path1) {
1712 		newte->pathname =
1713 			nfslog_get_path(NFSLOG_GET_FHANDLE3(&args->where.dir),
1714 				args->where.name,
1715 				fhpath, "trans_mknod3");
1716 	} else {
1717 		newte->pathname = strdup(path1);
1718 	}
1719 
1720 	newte->starttime = logrec->re_header.rh_timestamp;
1721 	newte->lastupdate = logrec->re_header.rh_timestamp;
1722 	newte->optype = TRANS_OPER_MKNOD;
1723 	newte->datatype = TRANS_DATATYPE_BINARY;
1724 	newte->transoption = TRANS_OPTION_NOACTION;
1725 	newte->pnb = netbufdup(&(logrec->re_ipaddr));
1726 	newte->uid = logrec->re_header.rh_uid;
1727 	newte->nfsvers = NFS_V3;
1728 	newte->netid = strdup(logrec->re_netid);
1729 	if (logrec->re_principal_name)
1730 		newte->principal_name = strdup(logrec->re_principal_name);
1731 	else
1732 		newte->principal_name = NULL;
1733 
1734 	newte->totalbytes = 0;
1735 	newte->fh_u.fh3 = args->where.dir;
1736 
1737 	return (newte);
1738 }
1739 
1740 static struct transentry *
trans_link3(nfslog_request_record * logrec,char * fhpath,char * path1,char * path2)1741 trans_link3(
1742 	nfslog_request_record *logrec,
1743 	char *fhpath,
1744 	char *path1,
1745 	char *path2)
1746 {
1747 	struct transentry *newte;
1748 	/* LINTED */
1749 	nfslog_LINK3args *args = (nfslog_LINK3args *)logrec->re_rpc_arg;
1750 	/* LINTED */
1751 	nfsstat3 *res = (nfsstat3 *)logrec->re_rpc_res;
1752 
1753 	char *tpath1 = NULL;
1754 	char *tpath2 = NULL;
1755 
1756 	if (*res != NFS3_OK)
1757 		return (NULL);
1758 
1759 	if ((newte = create_te()) == NULL)
1760 		return (NULL);
1761 
1762 	if (!path1) {
1763 		tpath1 = nfslog_get_path(NFSLOG_GET_FHANDLE3(&args->file),
1764 			NULL, fhpath, "trans_link3 from");
1765 		tpath2 = nfslog_get_path(NFSLOG_GET_FHANDLE3(&args->link.dir),
1766 			args->link.name, fhpath, "trans_link3 to");
1767 		path1 = tpath1;
1768 		path2 = tpath2;
1769 	}
1770 
1771 	newte->starttime = logrec->re_header.rh_timestamp;
1772 	newte->lastupdate = logrec->re_header.rh_timestamp;
1773 	newte->optype = TRANS_OPER_LINK;
1774 	newte->datatype = TRANS_DATATYPE_BINARY;
1775 	newte->transoption = TRANS_OPTION_NOACTION;
1776 	newte->pnb = netbufdup(&(logrec->re_ipaddr));
1777 	newte->uid = logrec->re_header.rh_uid;
1778 	newte->nfsvers = NFS_V3;
1779 	newte->netid = strdup(logrec->re_netid);
1780 	if (logrec->re_principal_name)
1781 		newte->principal_name = strdup(logrec->re_principal_name);
1782 	else
1783 		newte->principal_name = NULL;
1784 	newte->totalbytes = 0;
1785 	newte->fh_u.fh3 = args->file;
1786 
1787 	newte->pathname = (char *)malloc(strlen(path1) + strlen(path2) + 3);
1788 	/* check for NULL malloc */
1789 	(void) sprintf(newte->pathname, "%s->%s", path1, path2);
1790 
1791 	if (tpath1) {
1792 		free(tpath1);
1793 		free(tpath2);
1794 	}
1795 
1796 	return (newte);
1797 }
1798 
1799 static struct transentry *
trans_symlink3(nfslog_request_record * logrec,char * fhpath,char * path1)1800 trans_symlink3(
1801 	nfslog_request_record *logrec,
1802 	char *fhpath,
1803 	char *path1)
1804 {
1805 	struct transentry *newte;
1806 	/* LINTED */
1807 	nfslog_SYMLINK3args *args = (nfslog_SYMLINK3args *)logrec->re_rpc_arg;
1808 	/* LINTED */
1809 	nfslog_SYMLINK3res *res = (nfslog_SYMLINK3res *)logrec->re_rpc_res;
1810 	char *name;
1811 
1812 	if (res->status != NFS3_OK)
1813 		return (NULL);
1814 
1815 	if ((newte = create_te()) == NULL)
1816 		return (NULL);
1817 
1818 	if (path1) {
1819 		name = strdup(path1);
1820 	} else {
1821 		name = nfslog_get_path(NFSLOG_GET_FHANDLE3(&args->where.dir),
1822 			args->where.name, fhpath, "trans_symlink3");
1823 	}
1824 
1825 	newte->starttime = logrec->re_header.rh_timestamp;
1826 	newte->lastupdate = logrec->re_header.rh_timestamp;
1827 	newte->optype = TRANS_OPER_SYMLINK;
1828 	newte->datatype = TRANS_DATATYPE_BINARY;
1829 	newte->transoption = TRANS_OPTION_NOACTION;
1830 	newte->pnb = netbufdup(&(logrec->re_ipaddr));
1831 	newte->uid = logrec->re_header.rh_uid;
1832 	newte->nfsvers = NFS_V3;
1833 	newte->netid = strdup(logrec->re_netid);
1834 	if (logrec->re_principal_name)
1835 		newte->principal_name = strdup(logrec->re_principal_name);
1836 	else
1837 		newte->principal_name = NULL;
1838 	newte->totalbytes = 0;
1839 	newte->fh_u.fh3 = args->where.dir;
1840 
1841 	newte->pathname = (char *)malloc(strlen(name) +
1842 		strlen(args->symlink_data) + 3);
1843 	/* check for NULL malloc */
1844 	(void) sprintf(newte->pathname, "%s->%s", name, args->symlink_data);
1845 
1846 	free(name);
1847 
1848 	return (newte);
1849 }
1850 
1851 /*
1852  * nfslog_process_trans_rec - processes the record in the buffer and outputs
1853  *	to the trans log.
1854  * Return 0 for success, errno else.
1855  */
1856 int
nfslog_process_trans_rec(void * transcookie,nfslog_request_record * logrec,char * fhpath,char * path1,char * path2)1857 nfslog_process_trans_rec(void *transcookie, nfslog_request_record *logrec,
1858 	char *fhpath, char *path1, char *path2)
1859 {
1860 	struct transentry	*pte = NULL;
1861 	struct nfslog_trans_file *tf = (struct nfslog_trans_file *)transcookie;
1862 
1863 	/* ignore programs other than nfs */
1864 	if (logrec->re_header.rh_prognum != NFS_PROGRAM)
1865 		return (0);
1866 
1867 	/* update the timestamp for use later in the timeout sequences */
1868 	if (tf->lasttrans_timestamp.tv_sec <
1869 		logrec->re_header.rh_timestamp.tv_sec)
1870 		tf->lasttrans_timestamp =
1871 			logrec->re_header.rh_timestamp;
1872 
1873 	/* current time of this processing */
1874 	tf->last_trans_read = time(0);
1875 
1876 	/* ignore anything that is not a read or write */
1877 	switch (logrec->re_header.rh_version) {
1878 	case NFS_VERSION:
1879 		switch (logrec->re_header.rh_procnum) {
1880 		case RFS_READ:
1881 			if (tf->trans_to_log & TRANSTOLOG_OPER_READ)
1882 				pte = trans_read(logrec, tf, fhpath, path1);
1883 			break;
1884 		case RFS_WRITE:
1885 			if (tf->trans_to_log & TRANSTOLOG_OPER_WRITE)
1886 				pte = trans_write(logrec, tf, fhpath, path1);
1887 			break;
1888 		case RFS_SETATTR:
1889 			if (tf->trans_to_log & TRANSTOLOG_OPER_SETATTR)
1890 				pte = trans_setattr(logrec, tf,
1891 					fhpath, path1);
1892 			break;
1893 		case RFS_REMOVE:
1894 			if (tf->trans_to_log & TRANSTOLOG_OPER_REMOVE)
1895 				pte = trans_remove(logrec, tf,	fhpath, path1);
1896 			break;
1897 		case RFS_MKDIR:
1898 			if (tf->trans_to_log & TRANSTOLOG_OPER_MKDIR)
1899 				pte = trans_mkdir(logrec, fhpath, path1);
1900 			break;
1901 		case RFS_RMDIR:
1902 			if (tf->trans_to_log & TRANSTOLOG_OPER_RMDIR)
1903 				pte = trans_rmdir(logrec, fhpath, path1);
1904 			break;
1905 		case RFS_CREATE:
1906 			if (tf->trans_to_log & TRANSTOLOG_OPER_CREATE)
1907 				pte = trans_create(logrec, tf, fhpath, path1);
1908 			break;
1909 		case RFS_RENAME:
1910 			if (tf->trans_to_log & TRANSTOLOG_OPER_RENAME)
1911 				pte = trans_rename(logrec, tf,
1912 					fhpath, path1, path2);
1913 			break;
1914 		case RFS_LINK:
1915 			if (tf->trans_to_log & TRANSTOLOG_OPER_LINK)
1916 				pte = trans_link(logrec, fhpath, path1, path2);
1917 			break;
1918 		case RFS_SYMLINK:
1919 			if (tf->trans_to_log & TRANSTOLOG_OPER_SYMLINK)
1920 				pte = trans_symlink(logrec, fhpath, path1);
1921 			break;
1922 		default:
1923 			break;
1924 		}
1925 		break;
1926 	case NFS_V3:
1927 		switch (logrec->re_header.rh_procnum) {
1928 		case NFSPROC3_READ:
1929 			if (tf->trans_to_log & TRANSTOLOG_OPER_READ)
1930 				pte = trans_read3(logrec, tf, fhpath, path1);
1931 			break;
1932 		case NFSPROC3_WRITE:
1933 			if (tf->trans_to_log & TRANSTOLOG_OPER_WRITE)
1934 				pte = trans_write3(logrec, tf, fhpath, path1);
1935 			break;
1936 		case NFSPROC3_SETATTR:
1937 			if (tf->trans_to_log & TRANSTOLOG_OPER_SETATTR)
1938 				pte = trans_setattr3(logrec, tf,
1939 					fhpath, path1);
1940 			break;
1941 		case NFSPROC3_REMOVE:
1942 			if (tf->trans_to_log & TRANSTOLOG_OPER_REMOVE)
1943 				pte = trans_remove3(logrec, tf,
1944 					fhpath, path1);
1945 			break;
1946 		case NFSPROC3_MKDIR:
1947 			if (tf->trans_to_log & TRANSTOLOG_OPER_MKDIR)
1948 				pte = trans_mkdir3(logrec, fhpath, path1);
1949 			break;
1950 		case NFSPROC3_RMDIR:
1951 			if (tf->trans_to_log & TRANSTOLOG_OPER_RMDIR)
1952 				pte = trans_rmdir3(logrec, fhpath, path1);
1953 			break;
1954 		case NFSPROC3_CREATE:
1955 			if (tf->trans_to_log & TRANSTOLOG_OPER_CREATE)
1956 				pte = trans_create3(logrec, tf,
1957 					fhpath, path1);
1958 			break;
1959 		case NFSPROC3_RENAME:
1960 			if (tf->trans_to_log & TRANSTOLOG_OPER_RENAME)
1961 				pte = trans_rename3(logrec, tf,
1962 					fhpath, path1, path2);
1963 			break;
1964 		case NFSPROC3_MKNOD:
1965 			if (tf->trans_to_log & TRANSTOLOG_OPER_MKNOD)
1966 				pte = trans_mknod3(logrec, fhpath, path1);
1967 			break;
1968 		case NFSPROC3_LINK:
1969 			if (tf->trans_to_log & TRANSTOLOG_OPER_LINK)
1970 				pte = trans_link3(logrec,
1971 					fhpath, path1, path2);
1972 			break;
1973 		case NFSPROC3_SYMLINK:
1974 			if (tf->trans_to_log & TRANSTOLOG_OPER_SYMLINK)
1975 				pte = trans_symlink3(logrec, fhpath, path1);
1976 			break;
1977 		default:
1978 			break;
1979 		}
1980 		break;
1981 	default:
1982 		break;
1983 	}
1984 
1985 	if (pte != NULL) {
1986 		nfslog_print_trans_logentry(pte, tf);
1987 		remove_te(pte);
1988 	}
1989 
1990 	return (0);
1991 }
1992 
1993 static void
nfslog_print_trans_logentry(struct transentry * pte,struct nfslog_trans_file * tf)1994 nfslog_print_trans_logentry(struct transentry *pte,
1995 	struct nfslog_trans_file *tf)
1996 {
1997 	char *remotehost;
1998 	char datatype;
1999 	char transoption;
2000 	char *optype;
2001 	char *prin;
2002 	int prinid;
2003 	char nfs_ident[32];
2004 
2005 	remotehost = addrtoname(pte->pnb->buf);
2006 
2007 	datatype = (pte->datatype == TRANS_DATATYPE_BINARY ? 'b' : 'a');
2008 	transoption = (pte->transoption == TRANS_OPTION_NOACTION ? '_' : '?');
2009 
2010 	if (tf->trans_output_type == TRANSLOG_BASIC) {
2011 		(void) strcpy(nfs_ident, "nfs");
2012 	} else {
2013 		(void) strcpy(nfs_ident,
2014 			(pte->nfsvers == NFS_V3 ? "nfs3-" : "nfs-"));
2015 		(void) strcat(nfs_ident, pte->netid);
2016 	}
2017 
2018 	switch (pte->optype) {
2019 	case TRANS_OPER_READ:
2020 		optype = (tf->trans_output_type == TRANSLOG_EXTENDED ?
2021 			"read" : "o");
2022 		break;
2023 	case TRANS_OPER_WRITE:
2024 		optype = (tf->trans_output_type == TRANSLOG_EXTENDED ?
2025 			"write" : "i");
2026 		break;
2027 	case TRANS_OPER_REMOVE:
2028 		optype = (tf->trans_output_type == TRANSLOG_EXTENDED ?
2029 			"remove" : "?");
2030 		break;
2031 	case TRANS_OPER_MKDIR:
2032 		optype = (tf->trans_output_type == TRANSLOG_EXTENDED ?
2033 			"mkdir" : "?");
2034 		break;
2035 	case TRANS_OPER_CREATE:
2036 		optype = (tf->trans_output_type == TRANSLOG_EXTENDED ?
2037 			"create" : "?");
2038 		break;
2039 	case TRANS_OPER_RMDIR:
2040 		optype = (tf->trans_output_type == TRANSLOG_EXTENDED ?
2041 			"rmdir" : "?");
2042 		break;
2043 	case TRANS_OPER_SETATTR:
2044 		optype = (tf->trans_output_type == TRANSLOG_EXTENDED ?
2045 			"setattr" : "?");
2046 		break;
2047 	case TRANS_OPER_RENAME:
2048 		optype = (tf->trans_output_type == TRANSLOG_EXTENDED ?
2049 			"rename" : "?");
2050 		break;
2051 	case TRANS_OPER_MKNOD:
2052 		optype = (tf->trans_output_type == TRANSLOG_EXTENDED ?
2053 			"mknod" : "?");
2054 		break;
2055 	case TRANS_OPER_LINK:
2056 		optype = (tf->trans_output_type == TRANSLOG_EXTENDED ?
2057 			"link" : "?");
2058 		break;
2059 	case TRANS_OPER_SYMLINK:
2060 		optype = (tf->trans_output_type == TRANSLOG_EXTENDED ?
2061 			"symlink" : "?");
2062 		break;
2063 	default:
2064 		optype = "?";
2065 		break;
2066 	}
2067 	if (strcmp(pte->principal_name, "") == 0) {
2068 		prinid = 0;
2069 		prin = "*";
2070 	} else {
2071 		prinid = 1;
2072 		prin = pte->principal_name;
2073 	}
2074 	(void) fprintf(tf->fp,
2075 		"%.24s %d %s %d %s %c %c %s %c %ld %s %d %s\n",
2076 		ctime((time_t *)&pte->starttime.tv_sec),
2077 		pte->lastupdate.tv_sec - pte->starttime.tv_sec,
2078 		remotehost,
2079 		(uint32_t)pte->totalbytes,
2080 		pte->pathname,
2081 		datatype,
2082 		transoption,
2083 		optype,
2084 		'r', /* anonymous == 'a', guest == 'g', real == 'r'), */
2085 		pte->uid,
2086 		nfs_ident,
2087 		/* authenticated - fill in kerb/security? */
2088 		prinid,
2089 		/* authenticated ? authuser : "*" */
2090 		prin);
2091 }
2092