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