/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * nfs log - read buffer file and print structs in user-readable form
 */

#define _REENTRANT

#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <strings.h>
#include <time.h>
#include <fcntl.h>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/param.h>
#include <sys/utsname.h>
#include <errno.h>
#include <time.h>
#include <limits.h>
#include <libintl.h>
#include <pwd.h>
#include <netdb.h>
#include <syslog.h>
#include <rpc/rpc.h>
#include <netconfig.h>
#include <netdir.h>
#include <nfs/nfs_sec.h>
#include <nfs/export.h>
#include <rpc/auth.h>
#include <rpc/svc.h>
#include <rpc/xdr.h>
#include <rpc/clnt.h>
#include <nfs/nfs.h>
#include <nfs/nfs_log.h>
#include "fhtab.h"
#include "nfslogd.h"

static char     empty_name[4] = "-";

static char ftype3_names[NF3FIFO + 1][20] = {
        "\"none\"", "\"file\"", "\"dir\"", "\"blk device\"",
        "\"chr device\"", "\"link\"", "\"socket\"", "\"fifo\""
};

#define NFSL_FTYPE3(ftype)                                              \
        ((((ftype) >= 0) && ((ftype) <= NF3FIFO)) ?                     \
        ftype3_names[ftype] : empty_name)

static char createmode3_names[EXCLUSIVE + 1][20] = {
        "\"unchecked", "\"guarded\"", "\"exclusive\""
};

#define NFSL_CREATEMODE3(createmode)                                    \
        ((((createmode) >= 0) && ((createmode) <= EXCLUSIVE)) ?         \
        createmode3_names[createmode] : empty_name)

static char     auth_flavor_name[RPCSEC_GSS + 1][20] = {
        "\"auth_null\"", "\"auth_unix\"", "\"auth_short\"", "\"auth_des\"",
        "\"auth_kerb\"", "\"none\"", "\"rpcsec_gss\""
};

#define NFSL_AUTH_FLAVOR_PRINT(auth_flavor)                             \
        (((auth_flavor) <= RPCSEC_GSS) ?                                \
        auth_flavor_name[auth_flavor] : empty_name)

#define NFSL_ERR_CNT            31      /* Actual err numbers */

/*
 * Two arrays - one short ints containing err codes, the other the strings
 * (merged codes for both v2 and v3
 */
static char     nfsl_status_name[NFSL_ERR_CNT][30] = {
        "\"ok\"", "\"perm\"", "\"noent\"", "\"io\"",
        "\"nxio\"", "\"access\"", "\"exist\"", "\"xdev\"",
        "\"nodev\"", "\"notdir\"", "\"isdir\"", "\"inval\"",
        "\"fbig\"", "\"nospc\"", "\"rofs\"", "\"mlink\"",
        "\"notsupp\"", "\"nametoolong\"", "\"notempty\"", "\"dquot\"",
        "\"stale\"", "\"remote\"", "\"wflush\"", "\"badhandle\"",
        "\"not_sync\"", "\"bad_cookie\"", "\"notsupp\"", "\"toosmall\"",
        "\"serverfault\"", "\"badtype\"", "\"jukebox\"",
};

static short    nfsl_status[NFSL_ERR_CNT] = {
        0, 1, 2, 5, 6, 13, 17, 18,
        19, 20, 21, 22, 27, 28, 30, 31,
        45, 63, 66, 69, 70, 71, 99, 10001,
        10002, 10003, 10004, 10005, 10006, 10007, 10008
};

/* list of open elf files */
static struct nfsl_log_file     *elf_file_list = NULL;

/* Imported functions */
extern void bcopy(const void *s1, void *s2, size_t n);

/* Static functions */
static void nfsl_log_file_free(struct nfsl_log_file *elfrec);
static void nfsl_log_file_add(struct nfsl_log_file *elfrec,
        struct nfsl_log_file **elf_listp);
static struct nfsl_log_file *nfsl_log_file_find(struct nfsl_log_file *elfrec,
        struct nfsl_log_file *elf_list);
static struct nfsl_log_file *nfsl_log_file_del(struct nfsl_log_file *elfrec,
        struct nfsl_log_file **elf_listp);

static char *nfsl_get_time(time_t tt);
static char *nfsl_get_date(time_t tt);
static char *nfsl_get_date_nq(time_t tt);
static int nfsl_write_elfbuf(struct nfsl_log_file *elfrec);
static void nfsl_ipaddr_print(struct nfsl_log_file *, struct netbuf *);
static void nfsl_elf_record_header_print(struct nfsl_log_file *,
                nfslog_record_header *, char *, char *,
                struct nfsl_proc_disp *, char *);
static void nfsl_elf_buffer_header_print(struct nfsl_log_file *,
                nfslog_buffer_header *);
static struct nfsl_proc_disp *nfsl_find_elf_dispatch(
                nfslog_request_record *, char **);
static void nfsl_elf_rpc_print(struct nfsl_log_file *,
                nfslog_request_record *, struct nfsl_proc_disp *,
                char *, char *, char *);
static void nfslog_size3_print(struct nfsl_log_file *, set_size3 *);

static void nfslog_null_args(struct nfsl_log_file *, caddr_t *);
static void nfslog_null_res(struct nfsl_log_file *, caddr_t *);


/*
 * NFS VERSION 2
 */

/* Functions for elf print of the arguments */
static void nfslog_fhandle_print(struct nfsl_log_file *, fhandle_t *);
static void nfslog_diropargs_print(struct nfsl_log_file *, nfslog_diropargs *);
static void nfslog_setattrargs_print(struct nfsl_log_file *,
        nfslog_setattrargs *);
static void nfslog_sattr_print(struct nfsl_log_file *,
        nfslog_sattr *);
static void nfslog_nfsreadargs_print(struct nfsl_log_file *,
        nfslog_nfsreadargs *);
static void nfslog_writeargs_print(struct nfsl_log_file *,
        nfslog_writeargs *);
static void nfslog_writeresult_print(struct nfsl_log_file *,
        nfslog_writeresult *, bool_t);
static void nfslog_creatargs_print(struct nfsl_log_file *,
        nfslog_createargs *);
static void nfslog_rddirargs_print(struct nfsl_log_file *, nfslog_rddirargs *);
static void nfslog_linkargs_print(struct nfsl_log_file *, nfslog_linkargs *);
static void nfslog_rnmargs_print(struct nfsl_log_file *, nfslog_rnmargs *);
static void nfslog_symlinkargs_print(struct nfsl_log_file *,
        nfslog_symlinkargs *);

static void nfslog_sharefsargs_print(struct nfsl_log_file *,
        nfslog_sharefsargs *);
static void nfslog_getfhargs_print(struct nfsl_log_file *,
        nfslog_getfhargs *);

/* Functions for elf print of the response */
static void nfslog_nfsstat_print(struct nfsl_log_file *, enum nfsstat *,
        bool_t);
static void nfslog_diropres_print(struct nfsl_log_file *, nfslog_diropres *,
        bool_t);
static void nfslog_rdlnres_print(struct nfsl_log_file *, nfslog_rdlnres *,
        bool_t);
static void nfslog_rdresult_print(struct nfsl_log_file *,
        nfslog_rdresult *, bool_t);
static void nfslog_rddirres_print(struct nfsl_log_file *, nfslog_rddirres *,
        bool_t);

/*
 * NFS VERSION 3
 */

/* Functions for elf print of the arguments */
static void nfslog_fh3_print(struct nfsl_log_file *, nfs_fh3 *);
static void nfslog_diropargs3_print(struct nfsl_log_file *,
        nfslog_diropargs3 *);
static void nfslog_SETATTR3args_print(struct nfsl_log_file *,
        nfslog_SETATTR3args *);
static void nfslog_READ3args_print(struct nfsl_log_file *, nfslog_READ3args *);
static void nfslog_WRITE3args_print(struct nfsl_log_file *,
        nfslog_WRITE3args *);
static void nfslog_CREATE3args_print(struct nfsl_log_file *,
        nfslog_CREATE3args *);
static void nfslog_MKDIR3args_print(struct nfsl_log_file *,
        nfslog_MKDIR3args *);
static void nfslog_SYMLINK3args_print(struct nfsl_log_file *,
        nfslog_SYMLINK3args *);
static void nfslog_MKNOD3args_print(struct nfsl_log_file *,
        nfslog_MKNOD3args *);
static void nfslog_REMOVE3args_print(struct nfsl_log_file *,
        nfslog_REMOVE3args *);
static void nfslog_RMDIR3args_print(struct nfsl_log_file *,
        nfslog_RMDIR3args *);
static void nfslog_RENAME3args_print(struct nfsl_log_file *,
        nfslog_RENAME3args *);
static void nfslog_LINK3args_print(struct nfsl_log_file *,
        nfslog_LINK3args *);
static void nfslog_COMMIT3args_print(struct nfsl_log_file *,
        nfslog_COMMIT3args *);
static void nfslog_READDIRPLUS3args_print(struct nfsl_log_file *,
        nfslog_READDIRPLUS3args *);

/* Functions for elf print of the response */
static void nfslog_nfsstat3_print(struct nfsl_log_file *,
        nfsstat3 *, bool_t);
static void nfslog_LOOKUP3res_print(struct nfsl_log_file *,
        nfslog_LOOKUP3res *, bool_t);
static void nfslog_READLINK3res_print(struct nfsl_log_file *,
        nfslog_READLINK3res *, bool_t);
static void nfslog_READ3res_print(struct nfsl_log_file *,
        nfslog_READ3res *, bool_t);
static void nfslog_WRITE3res_print(struct nfsl_log_file *,
        nfslog_WRITE3res *, bool_t);
static void nfslog_CREATE3res_print(struct nfsl_log_file *,
        nfslog_CREATE3res *, bool_t);
static void nfslog_MKDIR3res_print(struct nfsl_log_file *,
        nfslog_MKDIR3res *, bool_t);
static void nfslog_SYMLINK3res_print(struct nfsl_log_file *,
        nfslog_SYMLINK3res *, bool_t);
static void nfslog_MKNOD3res_print(struct nfsl_log_file *,
        nfslog_MKNOD3res *, bool_t);
static void nfslog_READDIRPLUS3res_print(struct nfsl_log_file *,
        nfslog_READDIRPLUS3res *, bool_t);

extern int debug;
static bool_t nfsl_print_fh = FALSE;            /* print file handles? */

#define DFLT_BUFFERSIZE         8192
#define DFLT_OVFSIZE            3072    /* Maximum logged or buffered size */

static char hostname[MAXHOSTNAMELEN];   /* name of host */


/*
 * Define the actions taken per prog/vers/proc:
 *
 * In some cases, the nl types are the same as the nfs types and a simple
 * bcopy should suffice. Rather that define tens of identical procedures,
 * simply define these to bcopy. Similarly this takes care of different
 * procs that use same parameter struct.
 */

static struct nfsl_proc_disp nfsl_elf_proc_v2[] = {
        /*
         * NFS VERSION 2
         */

        /* RFS_NULL = 0 */
        {nfslog_null_args, nfslog_null_res, "\"null\""},

        /* RFS_GETATTR = 1 */
        {nfslog_fhandle_print, nfslog_nfsstat_print, "\"getattr\""},

        /* RFS_SETATTR = 2 */
        {nfslog_setattrargs_print, nfslog_nfsstat_print, "\"setattr\""},

        /* RFS_ROOT = 3 *** NO LONGER SUPPORTED *** */
        {nfslog_null_args, nfslog_null_res, "\"root\""},

        /* RFS_LOOKUP = 4 */
        {nfslog_diropargs_print, nfslog_diropres_print, "\"lookup\""},

        /* RFS_READLINK = 5 */
        {nfslog_fhandle_print, nfslog_rdlnres_print, "\"readlink\""},

        /* RFS_READ = 6 */
        {nfslog_nfsreadargs_print, nfslog_rdresult_print, "\"read\""},

        /* RFS_WRITECACHE = 7 *** NO LONGER SUPPORTED *** */
        {nfslog_null_args, nfslog_null_res, "\"writecache\""},

        /* RFS_WRITE = 8 */
        {nfslog_writeargs_print, nfslog_writeresult_print, "\"write\""},

        /* RFS_CREATE = 9 */
        {nfslog_creatargs_print, nfslog_diropres_print, "\"create\""},

        /* RFS_REMOVE = 10 */
        {nfslog_diropargs_print, nfslog_nfsstat_print, "\"remove\""},

        /* RFS_RENAME = 11 */
        {nfslog_rnmargs_print, nfslog_nfsstat_print, "\"rename\""},

        /* RFS_LINK = 12 */
        {nfslog_linkargs_print, nfslog_nfsstat_print, "\"link\""},

        /* RFS_SYMLINK = 13 */
        {nfslog_symlinkargs_print, nfslog_nfsstat_print, "\"symlink\""},

        /* RFS_MKDIR = 14 */
        {nfslog_creatargs_print, nfslog_diropres_print, "\"mkdir\""},

        /* RFS_RMDIR = 15 */
        {nfslog_diropargs_print, nfslog_nfsstat_print, "\"rmdir\""},

        /* RFS_READDIR = 16 */
        {nfslog_rddirargs_print, nfslog_rddirres_print, "\"readdir\""},

        /* RFS_STATFS = 17 */
        {nfslog_fhandle_print, nfslog_nfsstat_print, "\"statfs\""},
};


/*
 * NFS VERSION 3
 */

static struct nfsl_proc_disp nfsl_elf_proc_v3[] = {

        /* NFSPROC3_NULL = 0 */
        {nfslog_null_args, nfslog_null_res, "\"null\""},

        /* NFSPROC3_GETATTR = 1 */
        {nfslog_fh3_print, nfslog_nfsstat3_print, "\"getattr\""},

        /* NFSPROC3_SETATTR = 2 */
        {nfslog_SETATTR3args_print, nfslog_nfsstat3_print, "\"setattr\""},

        /* NFSPROC3_LOOKUP = 3 */
        {nfslog_diropargs3_print, nfslog_LOOKUP3res_print, "\"lookup\""},

        /* NFSPROC3_ACCESS = 4 */
        {nfslog_fh3_print, nfslog_nfsstat3_print, "\"access\""},

        /* NFSPROC3_READLINK = 5 */
        {nfslog_fh3_print, nfslog_READLINK3res_print, "\"readlink\""},

        /* NFSPROC3_READ = 6 */
        {nfslog_READ3args_print, nfslog_READ3res_print, "\"read\""},

        /* NFSPROC3_WRITE = 7 */
        {nfslog_WRITE3args_print, nfslog_WRITE3res_print, "\"write\""},

        /* NFSPROC3_CREATE = 8 */
        {nfslog_CREATE3args_print, nfslog_CREATE3res_print, "\"create\""},

        /* NFSPROC3_MKDIR = 9 */
        {nfslog_MKDIR3args_print, nfslog_MKDIR3res_print, "\"mkdir\""},

        /* NFSPROC3_SYMLINK = 10 */
        {nfslog_SYMLINK3args_print, nfslog_SYMLINK3res_print, "\"symlink\""},

        /* NFSPROC3_MKNOD = 11 */
        {nfslog_MKNOD3args_print, nfslog_MKNOD3res_print, "\"mknod\""},

        /* NFSPROC3_REMOVE = 12 */
        {nfslog_REMOVE3args_print, nfslog_nfsstat3_print, "\"remove\""},

        /* NFSPROC3_RMDIR = 13 */
        {nfslog_RMDIR3args_print, nfslog_nfsstat3_print, "\"rmdir\""},

        /* NFSPROC3_RENAME = 14 */
        {nfslog_RENAME3args_print, nfslog_nfsstat3_print, "\"rename\""},

        /* NFSPROC3_LINK = 15 */
        {nfslog_LINK3args_print, nfslog_nfsstat3_print, "\"link\""},

        /* NFSPROC3_READDIR = 16 */
        {nfslog_fh3_print, nfslog_nfsstat3_print, "\"readdir\""},

        /* NFSPROC3_READDIRPLUS = 17 */
        {nfslog_READDIRPLUS3args_print, nfslog_READDIRPLUS3res_print,
                "\"readdirplus\""},

        /* NFSPROC3_FSSTAT = 18 */
        {nfslog_fh3_print, nfslog_nfsstat3_print, "\"fsstat\""},

        /* NFSPROC3_FSINFO = 19 */
        {nfslog_fh3_print, nfslog_nfsstat3_print, "\"fsinfo\""},

        /* NFSPROC3_PATHCONF = 20 */
        {nfslog_fh3_print, nfslog_nfsstat3_print, "\"pathconf\""},

        /* NFSPROC3_COMMIT = 21 */
        {nfslog_COMMIT3args_print, nfslog_nfsstat3_print, "\"commit\""},
};

/*
 * NFSLOG VERSION 1
 */

static struct nfsl_proc_disp nfsl_log_elf_proc_v1[] = {

        /* NFSLOG_NULL = 0 */
        {nfslog_null_args, nfslog_null_res, "\"null\""},

        /* NFSLOG_SHARE = 1 */
        {nfslog_sharefsargs_print, nfslog_nfsstat_print, "\"log_share\""},

        /* NFSLOG_UNSHARE = 2 */
        {nfslog_sharefsargs_print, nfslog_nfsstat_print, "\"log_unshare\""},

        /* NFSLOG_LOOKUP = 3 */
        {nfslog_diropargs3_print, nfslog_LOOKUP3res_print, "\"lookup\""},

        /* NFSLOG_GETFH = 4 */
        {nfslog_getfhargs_print, nfslog_nfsstat_print, "\"log_getfh\""},
};

static struct nfsl_vers_disp nfsl_elf_vers_disptable[] = {
        {sizeof (nfsl_elf_proc_v2) / sizeof (nfsl_elf_proc_v2[0]),
            nfsl_elf_proc_v2},
        {sizeof (nfsl_elf_proc_v3) / sizeof (nfsl_elf_proc_v3[0]),
            nfsl_elf_proc_v3},
};

static struct nfsl_vers_disp nfsl_log_elf_vers_disptable[] = {
        {sizeof (nfsl_log_elf_proc_v1) / sizeof (nfsl_log_elf_proc_v1[0]),
            nfsl_log_elf_proc_v1},
};

static struct nfsl_prog_disp nfsl_elf_dispatch_table[] = {
        {NFS_PROGRAM,
            NFS_VERSMIN,
            sizeof (nfsl_elf_vers_disptable) /
                sizeof (nfsl_elf_vers_disptable[0]),
            nfsl_elf_vers_disptable, "nfs"},
        {NFSLOG_PROGRAM,
            NFSLOG_VERSMIN,
            sizeof (nfsl_log_elf_vers_disptable) /
                sizeof (nfsl_log_elf_vers_disptable[0]),
            nfsl_log_elf_vers_disptable, "nfslog"},
};

static int      nfsl_elf_dispatch_table_arglen =
                        sizeof (nfsl_elf_dispatch_table) /
                        sizeof (nfsl_elf_dispatch_table[0]);

static char *
nfslog_get_status(short status)
{
        int     low, mid, high;
        short   errstat;

        /* Usually status is 0... */
        if (status == 0)
                return (nfsl_status_name[0]);

        low = 0;
        high = NFSL_ERR_CNT;
        mid = NFSL_ERR_CNT / 2;
        /* binary search for status string */
        while (((errstat = nfsl_status[mid]) != status) && (low < mid) &&
                (mid < high)) {
                if (errstat > status) { /* search bottom half */
                        high = mid;
                } else {                /* search upper half */
                        low = mid;
                }
                mid = low + ((high - low) / 2);
        }
        if (errstat == status) {        /* found it */
                return (nfsl_status_name[mid]);
        }
        return (NULL);
}

/* nfsl_get_time - return string with time formatted as hh:mm:ss */
static char *
nfsl_get_time(time_t tt)
{
        static char     timestr[20];
        static time_t   lasttime;
        struct tm       tmst;

        if (tt == lasttime)
                return (timestr);
        if (localtime_r(&tt, &tmst) == NULL) {
                return (empty_name);
        }
        (void) sprintf(timestr, "%02d:%02d:%02d",
                tmst.tm_hour, tmst.tm_min, tmst.tm_sec);
        lasttime = tt;
        return (timestr);
}

/* nfsl_get_date - return date string formatted as "yyyy-mm-dd hh:mm:ss" */
static char *
nfsl_get_date(time_t tt)
{
        static char     timestr[30];
        static time_t   lasttime;
        struct tm       tmst;

        if (tt == lasttime)
                return (timestr);
        if (localtime_r(&tt, &tmst) == NULL) {
                return (empty_name);
        }
        (void) sprintf(timestr, "\"%04d-%02d-%02d %02d:%02d:%02d\"",
                tmst.tm_year + 1900, tmst.tm_mon + 1, tmst.tm_mday,
                tmst.tm_hour, tmst.tm_min, tmst.tm_sec);
        lasttime = tt;
        return (timestr);
}

/*
 * nfsl_get_date_nq - return date string formatted as yyyy-mm-dd hh:mm:ss
 * (no quotes)
 */
static char *
nfsl_get_date_nq(time_t tt)
{
        static char     timestr[30];
        static time_t   lasttime;
        struct tm       tmst;

        if (tt == lasttime)
                return (timestr);
        if (localtime_r(&tt, &tmst) == NULL) {
                return (empty_name);
        }
        (void) sprintf(timestr, "%04d-%02d-%02d %02d:%02d:%02d",
                tmst.tm_year + 1900, tmst.tm_mon + 1, tmst.tm_mday,
                tmst.tm_hour, tmst.tm_min, tmst.tm_sec);
        return (timestr);
}

/* write log buffer out to file */
static int
nfsl_write_elfbuf(struct nfsl_log_file *elfrec)
{
        int     rc;
        char    *elfbuf = elfrec->buf;
        int     elfbufoffset = elfrec->bufoffset;

        if (debug > 1)
                (void) printf("nfsl_write_elfbuf: bufoffset %d\n",
                        elfbufoffset);
        if (elfbufoffset <= 0)
                return (0);
        elfbuf[elfbufoffset] = '\0';
        if ((rc = fputs(elfbuf, elfrec->fp)) < 0) {
                syslog(LOG_ERR, gettext("Write to %s failed: %s\n"),
                        elfrec->path, strerror(errno));
                return (-1);
        }
        if (rc != elfbufoffset) {
                syslog(LOG_ERR, gettext("Write %d bytes to %s returned %d\n"),
                        elfbufoffset, elfrec->path, rc);
                return (-1);
        }
        elfrec->bufoffset = 0;
        return (0);
}

/*ARGSUSED*/
static void
nfslog_null_args(struct nfsl_log_file *elfrec, caddr_t *nfsl_args)
{
}

/*ARGSUSED*/
static void
nfslog_null_res(struct nfsl_log_file *elfrec, caddr_t *nfsl_res)
{
}

static void
nfslog_fh3_print(struct nfsl_log_file *elfrec, nfs_fh3 *fh3)
{
        if (!nfsl_print_fh)
                return;
        if (fh3->fh3_length == sizeof (fhandle_t)) {
                nfslog_fhandle_print(elfrec, (fhandle_t *)&fh3->fh3_u.data);
        } else {
                nfslog_opaque_print_buf(fh3->fh3_u.data, fh3->fh3_length,
                        elfrec->buf, &elfrec->bufoffset,
                        DFLT_BUFFERSIZE + DFLT_OVFSIZE);
        }
}

/*
 * NFS VERSION 2
 */


/* Functions that elf print the arguments */

static void
nfslog_fhandle_print(struct nfsl_log_file *elfrec, fhandle_t *args)
{
        if (!nfsl_print_fh)
                return;
        nfslog_opaque_print_buf(args, sizeof (*args),
                        elfrec->buf, &elfrec->bufoffset,
                        DFLT_BUFFERSIZE + DFLT_OVFSIZE);
}

static void
nfslog_diropargs_print(struct nfsl_log_file *elfrec, nfslog_diropargs *args)
{
        char    *elfbuf = elfrec->buf;
        int     elfbufoffset = elfrec->bufoffset;

        if (nfsl_print_fh) {
                nfslog_fhandle_print(elfrec, &args->da_fhandle);
                elfbufoffset = elfrec->bufoffset;
                if (args->da_name != NULL) {
                        elfbufoffset += sprintf(&elfbuf[elfbufoffset],
                                " \"%s\"", args->da_name);
                } else {
                        elfbufoffset += sprintf(&elfbuf[elfbufoffset], " %s",
                                empty_name);
                }
        }
        elfrec->bufoffset = elfbufoffset;
}

static void
nfslog_sattr_print(struct nfsl_log_file *elfrec, nfslog_sattr *args)
{
        char    *elfbuf = elfrec->buf;
        int     elfbufoffset = elfrec->bufoffset;

/* BEGIN CSTYLED */
        if (args->sa_mode != (uint32_t)-1) {
                elfbufoffset += sprintf(&elfbuf[elfbufoffset],
                        " \"mode=0%o\"", args->sa_mode);
        }
        if (args->sa_uid != (uint32_t)-1) {
                elfbufoffset += sprintf(&elfbuf[elfbufoffset],
                        " \"uid=0x%x\"", args->sa_uid);
        }
        if (args->sa_gid != (uint32_t)-1) {
                elfbufoffset += sprintf(&elfbuf[elfbufoffset],
                        " \"gid=0x%x\"", args->sa_gid);
        }
        if (args->sa_size != (uint32_t)-1) {
                elfbufoffset += sprintf(&elfbuf[elfbufoffset],
                        " \"size=0x%x\"", args->sa_size);
        }
        if (args->sa_atime.tv_sec != (uint32_t)-1) {
                elfbufoffset += sprintf(&elfbuf[elfbufoffset],
                        " \"atime=%s\"",
                    nfsl_get_date_nq((time_t)args->sa_atime.tv_sec));
        }
        if (args->sa_mtime.tv_sec != (uint32_t)-1) {
                elfbufoffset += sprintf(&elfbuf[elfbufoffset],
                        " \"mtime=%s\"",
                    nfsl_get_date_nq((time_t)args->sa_mtime.tv_sec));
        }
/* END CSTYLED */
        elfrec->bufoffset = elfbufoffset;
}

static void
nfslog_setattrargs_print(struct nfsl_log_file *elfrec, nfslog_setattrargs *args)
{
        nfslog_fhandle_print(elfrec, &args->saa_fh);
        nfslog_sattr_print(elfrec, &args->saa_sa);
}

static void
nfslog_nfsreadargs_print(struct nfsl_log_file *elfrec,
        nfslog_nfsreadargs *args)
{
        char    *elfbuf = elfrec->buf;
        int     elfbufoffset;

        nfslog_fhandle_print(elfrec, &args->ra_fhandle);
        elfbufoffset = elfrec->bufoffset;
        elfbufoffset += sprintf(&elfbuf[elfbufoffset], " 0x%x",
                args->ra_offset);
        elfbufoffset += sprintf(&elfbuf[elfbufoffset], " 0x%x",
                args->ra_count);
        elfbufoffset += sprintf(&elfbuf[elfbufoffset], " 0x%x",
                args->ra_totcount);
        elfrec->bufoffset = elfbufoffset;
}

static void
nfslog_writeargs_print(struct nfsl_log_file *elfrec, nfslog_writeargs *args)
{
        char    *elfbuf = elfrec->buf;
        int     elfbufoffset = elfrec->bufoffset;

        nfslog_fhandle_print(elfrec, &args->waargs_fhandle);
        elfbufoffset = elfrec->bufoffset;
        elfbufoffset += sprintf(&elfbuf[elfbufoffset], " 0x%x",
                args->waargs_begoff);
        elfbufoffset += sprintf(&elfbuf[elfbufoffset], " 0x%x",
                args->waargs_offset);
        elfbufoffset += sprintf(&elfbuf[elfbufoffset], " 0x%x",
                args->waargs_totcount);
        elfrec->bufoffset += sprintf(&elfrec->buf[elfrec->bufoffset], " 0x%x",
                args->waargs_count);
}

static void
nfslog_writeresult_print(struct nfsl_log_file *elfrec, nfslog_writeresult *res,
        bool_t print_status)
{
        char    *elfbuf = elfrec->buf;
        int     elfbufoffset = elfrec->bufoffset;

        if (print_status) {
                nfslog_nfsstat_print(elfrec, &res->wr_status, print_status);
        } else if (res->wr_status == NFS_OK) {
                elfbufoffset += sprintf(&elfbuf[elfbufoffset], " 0x%x",
                        res->nfslog_writeresult_u.wr_size);
                elfrec->bufoffset = elfbufoffset;
        }
}

static void
nfslog_creatargs_print(struct nfsl_log_file *elfrec, nfslog_createargs *args)
{
        nfslog_diropargs_print(elfrec, &args->ca_da);
        nfslog_sattr_print(elfrec, &args->ca_sa);
}


static void
nfslog_rddirargs_print(struct nfsl_log_file *elfrec, nfslog_rddirargs *args)
{
        char    *elfbuf = elfrec->buf;
        int     elfbufoffset;

        nfslog_fhandle_print(elfrec, &args->rda_fh);
        elfbufoffset = elfrec->bufoffset;
        elfbufoffset += sprintf(&elfbuf[elfbufoffset], " 0x%x",
                args->rda_offset);
        elfbufoffset += sprintf(&elfbuf[elfbufoffset], " 0x%x",
                args->rda_count);
        elfrec->bufoffset = elfbufoffset;
}

static void
nfslog_rnmargs_print(struct nfsl_log_file *elfrec, nfslog_rnmargs *args)
{
        nfslog_diropargs_print(elfrec, &args->rna_from);
        nfslog_diropargs_print(elfrec, &args->rna_to);
}

static void
nfslog_linkargs_print(struct nfsl_log_file *elfrec, nfslog_linkargs *args)
{
        nfslog_fhandle_print(elfrec, &args->la_from);
        nfslog_diropargs_print(elfrec, &args->la_to);
}

static void
nfslog_symlinkargs_print(struct nfsl_log_file *elfrec, nfslog_symlinkargs *args)
{
        char    *elfbuf = elfrec->buf;
        int     elfbufoffset;

        nfslog_diropargs_print(elfrec, &args->sla_from);
        elfbufoffset = elfrec->bufoffset;
        elfbufoffset += sprintf(&elfbuf[elfbufoffset], " \"%s\"",
                args->sla_tnm);
        elfrec->bufoffset = elfbufoffset;
        nfslog_sattr_print(elfrec, &args->sla_sa);
}

/*
 * SHARE/UNSHARE fs log args copy
 */
static void
nfslog_sharefsargs_print(struct nfsl_log_file *elfrec,
        nfslog_sharefsargs *args)
{
        unsigned int    elfbufoffset;
        char            *elfbuf = elfrec->buf;

        nfslog_fhandle_print(elfrec, &args->sh_fh_buf);

        elfbufoffset = elfrec->bufoffset;
        elfbufoffset += sprintf(&elfbuf[elfbufoffset], " 0x%x",
                args->sh_flags);
        elfbufoffset += sprintf(&elfbuf[elfbufoffset], " 0x%x",
                args->sh_anon);
        if (nfsl_print_fh) {
                if (args->sh_path != NULL) {
                        elfbufoffset += sprintf(&elfbuf[elfbufoffset],
                                " \"%s\"", args->sh_path);
                } else {
                        elfbufoffset += sprintf(&elfbuf[elfbufoffset], " %s",
                                empty_name);
                }
        }
        elfrec->bufoffset = elfbufoffset;
}

static void
nfslog_getfhargs_print(struct nfsl_log_file *elfrec,
        nfslog_getfhargs *args)
{
        unsigned int    elfbufoffset;
        char            *elfbuf = elfrec->buf;

        nfslog_fhandle_print(elfrec, &args->gfh_fh_buf);

        elfbufoffset = elfrec->bufoffset;
        if (nfsl_print_fh) {
                if (args->gfh_path != NULL) {
                        elfbufoffset += sprintf(&elfbuf[elfbufoffset],
                                " \"%s\"", args->gfh_path);
                } else {
                        elfbufoffset += sprintf(&elfbuf[elfbufoffset], " %s",
                                empty_name);
                }
        }
        elfrec->bufoffset = elfbufoffset;
}

static void
nfslog_nfsstat_print(struct nfsl_log_file *elfrec, enum nfsstat *res,
        bool_t print_status)
{
        if (print_status) {
                char    *statp = nfslog_get_status((short)(*res));

                if (statp != NULL)
                        elfrec->bufoffset +=
                                sprintf(&elfrec->buf[elfrec->bufoffset], " %s",
                                                statp);
                else
                        elfrec->bufoffset +=
                                sprintf(&elfrec->buf[elfrec->bufoffset], " %5d",
                                                *res);
        }
}

static void
nfslog_diropres_print(struct nfsl_log_file *elfrec, nfslog_diropres *res,
        bool_t print_status)
{
        if (print_status) {
                nfslog_nfsstat_print(elfrec, &res->dr_status, print_status);
        } else if (res->dr_status == NFS_OK) {
                nfslog_fhandle_print(elfrec,
                        &res->nfslog_diropres_u.dr_ok.drok_fhandle);
        }
}

static void
nfslog_rdlnres_print(struct nfsl_log_file *elfrec, nfslog_rdlnres *res,
        bool_t print_status)
{
        if (print_status) {
                nfslog_nfsstat_print(elfrec, &res->rl_status, print_status);
        } else if (res->rl_status == NFS_OK) {
                elfrec->bufoffset += sprintf(&elfrec->buf[elfrec->bufoffset],
                        " \"%s\"", res->nfslog_rdlnres_u.rl_ok);
        }
}

static void
nfslog_rdresult_print(struct nfsl_log_file *elfrec, nfslog_rdresult *res,
        bool_t print_status)
{
        if (print_status) {
                nfslog_nfsstat_print(elfrec, &res->r_status, print_status);
        } else if (res->r_status == NFS_OK) {
                elfrec->bufoffset += sprintf(&elfrec->buf[elfrec->bufoffset],
                        " 0x%x", res->nfslog_rdresult_u.r_ok.filesize);
                elfrec->bufoffset += sprintf(&elfrec->buf[elfrec->bufoffset],
                        " 0x%x", res->nfslog_rdresult_u.r_ok.rrok_count);
        }
}

static void
nfslog_rddirres_print(struct nfsl_log_file *elfrec, nfslog_rddirres *res,
        bool_t print_status)
{
        if (print_status) {
                nfslog_nfsstat_print(elfrec, &res->rd_status, print_status);
        } else if (res->rd_status == NFS_OK) {
                char    *elfbuf = elfrec->buf;
                int     elfbufoffset = elfrec->bufoffset;

                elfbufoffset += sprintf(&elfbuf[elfbufoffset], " 0x%x",
                        res->nfslog_rddirres_u.rd_ok.rdok_offset);
                elfbufoffset += sprintf(&elfbuf[elfbufoffset], " 0x%x",
                        res->nfslog_rddirres_u.rd_ok.rdok_size);
                elfbufoffset += sprintf(&elfbuf[elfbufoffset], " 0x%x",
                        res->nfslog_rddirres_u.rd_ok.rdok_eof);
                elfrec->bufoffset = elfbufoffset;
        }
}

/*
 * NFS VERSION 3
 */

static void
nfslog_diropargs3_print(struct nfsl_log_file *elfrec,
        nfslog_diropargs3 *args)
{
        if (nfsl_print_fh) {
                nfslog_fh3_print(elfrec, &args->dir);
                elfrec->bufoffset += sprintf(&elfrec->buf[elfrec->bufoffset],
                        " \"%s\"", args->name);
        }
}

static void
nfslog_size3_print(struct nfsl_log_file *elfrec, set_size3 *args)
{
        char    *elfbuf = elfrec->buf;
        int     elfbufoffset = elfrec->bufoffset;

        if (args->set_it) {
                elfbufoffset += sprintf(&elfbuf[elfbufoffset],
                /* CSTYLED */
                        " \"size=0x%llx\"", args->size);
        }
        elfrec->bufoffset = elfbufoffset;
}

static void
nfslog_SETATTR3args_print(struct nfsl_log_file *elfrec,
        nfslog_SETATTR3args *args)
{
        nfslog_fh3_print(elfrec, &args->object);
        nfslog_size3_print(elfrec, &args->size);
}

static void
nfslog_READ3args_print(struct nfsl_log_file *elfrec, nfslog_READ3args *args)
{
        nfslog_fh3_print(elfrec, &args->file);
        elfrec->bufoffset += sprintf(&elfrec->buf[elfrec->bufoffset], " 0x%llx",
                args->offset);
        elfrec->bufoffset += sprintf(&elfrec->buf[elfrec->bufoffset], " 0x%x",
                args->count);
}

static void
nfslog_WRITE3args_print(struct nfsl_log_file *elfrec,
        nfslog_WRITE3args *args)
{
        char    *elfbuf = elfrec->buf;
        int     elfbufoffset;

        nfslog_fh3_print(elfrec, &args->file);
        elfbufoffset = elfrec->bufoffset;
        elfbufoffset += sprintf(&elfbuf[elfbufoffset], " 0x%llx",
                args->offset);
        elfbufoffset += sprintf(&elfbuf[elfbufoffset], " 0x%x",
                args->count);
        elfbufoffset += sprintf(&elfbuf[elfbufoffset], " 0x%x",
                args->stable);
        elfrec->bufoffset = elfbufoffset;
}

static void
nfslog_CREATE3args_print(struct nfsl_log_file *elfrec,
        nfslog_CREATE3args *args)
{
        nfslog_diropargs3_print(elfrec, &args->where);
        elfrec->bufoffset += sprintf(&elfrec->buf[elfrec->bufoffset], " %s",
                NFSL_CREATEMODE3(args->how.mode));
        if (args->how.mode != EXCLUSIVE) {
                nfslog_size3_print(elfrec,
                        &args->how.nfslog_createhow3_u.size);
        }
}

static void
nfslog_MKDIR3args_print(struct nfsl_log_file *elfrec,
        nfslog_MKDIR3args *args)
{
        nfslog_diropargs3_print(elfrec, &args->where);
}

static void
nfslog_SYMLINK3args_print(struct nfsl_log_file *elfrec,
        nfslog_SYMLINK3args *args)
{
        nfslog_diropargs3_print(elfrec, &args->where);
        elfrec->bufoffset += sprintf(&elfrec->buf[elfrec->bufoffset],
                " \"%s\"", args->symlink_data);
}

static void
nfslog_MKNOD3args_print(struct nfsl_log_file *elfrec,
        nfslog_MKNOD3args *args)
{
        nfslog_diropargs3_print(elfrec, &args->where);
        elfrec->bufoffset += sprintf(&elfrec->buf[elfrec->bufoffset], " %s",
                NFSL_FTYPE3(args->type));
}

static void
nfslog_REMOVE3args_print(struct nfsl_log_file *elfrec,
        nfslog_REMOVE3args *args)
{
        nfslog_diropargs3_print(elfrec, &args->object);
}

static void
nfslog_RMDIR3args_print(struct nfsl_log_file *elfrec,
        nfslog_RMDIR3args *args)
{
        nfslog_diropargs3_print(elfrec, &args->object);
}

static void
nfslog_RENAME3args_print(struct nfsl_log_file *elfrec,
        nfslog_RENAME3args *args)
{
        nfslog_diropargs3_print(elfrec, &args->from);
        nfslog_diropargs3_print(elfrec, &args->to);
}

static void
nfslog_LINK3args_print(struct nfsl_log_file *elfrec, nfslog_LINK3args *args)
{
        nfslog_fh3_print(elfrec, &args->file);
        nfslog_diropargs3_print(elfrec, &args->link);
}

static void
nfslog_READDIRPLUS3args_print(struct nfsl_log_file *elfrec,
        nfslog_READDIRPLUS3args *args)
{
        nfslog_fh3_print(elfrec, &args->dir);
        elfrec->bufoffset += sprintf(&elfrec->buf[elfrec->bufoffset], " 0x%x",
                args->dircount);
        elfrec->bufoffset += sprintf(&elfrec->buf[elfrec->bufoffset], " 0x%x",
                args->maxcount);
}

static void
nfslog_COMMIT3args_print(struct nfsl_log_file *elfrec,
        nfslog_COMMIT3args *args)
{
        nfslog_fh3_print(elfrec, &args->file);
        elfrec->bufoffset += sprintf(&elfrec->buf[elfrec->bufoffset], " 0x%llx",
                args->offset);
        elfrec->bufoffset += sprintf(&elfrec->buf[elfrec->bufoffset], " 0x%x",
                args->count);
}

static void
nfslog_nfsstat3_print(struct nfsl_log_file *elfrec, enum nfsstat3 *res,
        bool_t print_status)
{
        if (print_status) {
                char    *statp = nfslog_get_status((short)(*res));

                if (statp != NULL)
                        elfrec->bufoffset +=
                                sprintf(&elfrec->buf[elfrec->bufoffset], " %s",
                                        statp);
                else
                        elfrec->bufoffset +=
                                sprintf(&elfrec->buf[elfrec->bufoffset], " %5d",
                                        *res);
        }
}

static void
nfslog_LOOKUP3res_print(struct nfsl_log_file *elfrec,
        nfslog_LOOKUP3res *res, bool_t print_status)
{
        if (print_status) {
                nfslog_nfsstat3_print(elfrec, &res->status, print_status);
        } else if (res->status == NFS3_OK) {
                nfslog_fh3_print(elfrec, &res->nfslog_LOOKUP3res_u.object);
        }
}

static void
nfslog_READLINK3res_print(struct nfsl_log_file *elfrec,
        nfslog_READLINK3res *res, bool_t print_status)
{
        if (print_status) {
                nfslog_nfsstat3_print(elfrec, &res->status, print_status);
        } else if (res->status == NFS3_OK) {
                elfrec->bufoffset += sprintf(&elfrec->buf[elfrec->bufoffset],
                        " %s", res->nfslog_READLINK3res_u.data);
        }
}

static void
nfslog_READ3res_print(struct nfsl_log_file *elfrec, nfslog_READ3res *res,
        bool_t print_status)
{
        if (print_status) {
                nfslog_nfsstat3_print(elfrec, &res->status, print_status);
        } else if (res->status == NFS3_OK) {
                char    *elfbuf = elfrec->buf;
                int     elfbufoffset = elfrec->bufoffset;

                elfbufoffset += sprintf(&elfbuf[elfbufoffset], " 0x%llx",
                        res->nfslog_READ3res_u.ok.filesize);
                elfbufoffset += sprintf(&elfbuf[elfbufoffset], " 0x%x",
                        res->nfslog_READ3res_u.ok.count);
                elfbufoffset += sprintf(&elfbuf[elfbufoffset], " 0x%x",
                        res->nfslog_READ3res_u.ok.eof);
                elfbufoffset += sprintf(&elfbuf[elfbufoffset], " 0x%x",
                        res->nfslog_READ3res_u.ok.size);
                elfrec->bufoffset = elfbufoffset;
        }
}

static void
nfslog_WRITE3res_print(struct nfsl_log_file *elfrec, nfslog_WRITE3res *res,
        bool_t print_status)
{
        if (print_status) {
                nfslog_nfsstat3_print(elfrec, &res->status, print_status);
        } else if (res->status == NFS3_OK) {
                char    *elfbuf = elfrec->buf;
                int     elfbufoffset = elfrec->bufoffset;

                elfbufoffset += sprintf(&elfbuf[elfbufoffset], " 0x%llx",
                        res->nfslog_WRITE3res_u.ok.filesize);
                elfbufoffset += sprintf(&elfbuf[elfbufoffset],
                        " 0x%x", res->nfslog_WRITE3res_u.ok.count);
                elfbufoffset += sprintf(&elfrec->buf[elfbufoffset],
                        " 0x%x", res->nfslog_WRITE3res_u.ok.committed);
                elfrec->bufoffset = elfbufoffset;
        }
}

static void
nfslog_CREATE3res_print(struct nfsl_log_file *elfrec, nfslog_CREATE3res *res,
        bool_t print_status)
{
        if (print_status) {
                nfslog_nfsstat3_print(elfrec, &res->status, print_status);
        } else if (res->status == NFS3_OK) {
                if (res->nfslog_CREATE3res_u.ok.obj.handle_follows) {
                        nfslog_fh3_print(elfrec,
                                &res->nfslog_CREATE3res_u.ok.obj.handle);
                }
        }
}

static void
nfslog_MKDIR3res_print(struct nfsl_log_file *elfrec, nfslog_MKDIR3res *res,
        bool_t print_status)
{
        if (print_status) {
                nfslog_nfsstat3_print(elfrec, &res->status, print_status);
        } else if (res->status == NFS3_OK) {
                if (res->nfslog_MKDIR3res_u.obj.handle_follows) {
                        nfslog_fh3_print(elfrec,
                                &res->nfslog_MKDIR3res_u.obj.handle);
                }
        }
}

static void
nfslog_SYMLINK3res_print(struct nfsl_log_file *elfrec, nfslog_SYMLINK3res *res,
        bool_t print_status)
{
        if (print_status) {
                nfslog_nfsstat3_print(elfrec, &res->status, print_status);
        } else if (res->status == NFS3_OK) {
                if (res->nfslog_SYMLINK3res_u.obj.handle_follows) {
                        nfslog_fh3_print(elfrec,
                                &res->nfslog_SYMLINK3res_u.obj.handle);
                }
        }
}

static void
nfslog_MKNOD3res_print(struct nfsl_log_file *elfrec, nfslog_MKNOD3res *res,
        bool_t print_status)
{
        if (print_status) {
                nfslog_nfsstat3_print(elfrec, &res->status, print_status);
        } else if (res->status == NFS3_OK) {
                if (res->nfslog_MKNOD3res_u.obj.handle_follows) {
                        nfslog_fh3_print(elfrec,
                                &res->nfslog_MKNOD3res_u.obj.handle);
                }
        }
}

static void
nfslog_READDIRPLUS3res_print(struct nfsl_log_file *elfrec,
        nfslog_READDIRPLUS3res *res, bool_t print_status)
{
        if (print_status) {
                nfslog_nfsstat3_print(elfrec, &res->status, print_status);
        }
}

/*
 * **** End of table functions for logging specific procs ****
 *
 * Hereafter are the general logging management and dispatcher.
 */


/*
 * nfsl_ipaddr_print - extracts sender ip address from transport struct
 * and prints it in legible form.
 */
static void
nfsl_ipaddr_print(struct nfsl_log_file *elfrec, struct netbuf *ptr)
{
        struct hostent  *hp;
        extern char     *inet_ntop();
        int             size, sin_family, error;
        char            *elfbuf = elfrec->buf;
        char            *addrp;
        int             elfbufoffset = elfrec->bufoffset;

        if (ptr->len == 0) {
                elfbufoffset += sprintf(&elfbuf[elfbufoffset], " %s",
                        empty_name);
                elfbufoffset += sprintf(&elfbuf[elfbufoffset], " %s",
                        empty_name);
                elfrec->bufoffset = elfbufoffset;
                return;
        }
        elfbufoffset += sprintf(&elfbuf[elfbufoffset], " ");
        /* LINTED */
        sin_family = ((struct sockaddr_in *)ptr->buf)->sin_family;
        switch (sin_family) {
        case (AF_INET):
                /* LINTED */
                addrp = (char *)&((struct sockaddr_in *)ptr->buf)->sin_addr;
                size = sizeof (struct in_addr);
                break;
        case (AF_INET6):
                /* LINTED */
                addrp = (char *)&((struct sockaddr_in6 *)ptr->buf)->sin6_addr;
                size = sizeof (struct in6_addr);
                break;
        default:
                /* unknown protocol: print address in hex form */
                for (size = ptr->len, addrp = ptr->buf; size > 0; size--) {
                        elfbufoffset += sprintf(&elfbuf[elfbufoffset], "%02x",
                                *addrp);
                }
                elfbufoffset += sprintf(&elfbuf[elfbufoffset], " %s",
                        empty_name);
                elfrec->bufoffset = elfbufoffset;
                return;
        }
        if (inet_ntop(sin_family, addrp, &elfbuf[elfbufoffset],
                (size_t)(DFLT_BUFFERSIZE + DFLT_OVFSIZE - elfbufoffset))
                    == NULL) {
                /* Not enough space to print - should never happen */
                elfbuf[elfrec->bufoffset] = '\0';       /* just in case */
                return;
        }
        /* inet_ntop copied address into elfbuf, so update offset */
        elfbufoffset += strlen(&elfbuf[elfbufoffset]);
        /* get host name and log it as well */
        hp = getipnodebyaddr(addrp, size, sin_family, &error);
        if (hp != NULL) {
                elfbufoffset += sprintf(&elfbuf[elfbufoffset], " \"%s\"",
                        hp->h_name);
        } else {
                elfbufoffset += sprintf(&elfbuf[elfbufoffset], " %s",
                        empty_name);
        }
        elfrec->bufoffset = elfbufoffset;
}

static void
nfsl_elf_record_header_print(struct nfsl_log_file *elfrec,
        nfslog_record_header *lhp, char *principal_name, char *tag,
        struct nfsl_proc_disp *disp, char *progname)
{
        struct passwd   *pwp = NULL;
        char    *elfbuf = elfrec->buf;
        int     elfbufoffset = elfrec->bufoffset;

        /*
         * Fields: time bytes tag rpc-program rpc-version rpc-procedure
         *         auth-flavor s-user-name s-uid uid u-name gid net-id
         *   c-ip c-dns s-dns status rpcarg-path <arguments> <response>
         */
        elfbufoffset += sprintf(&elfbuf[elfbufoffset], "%s",
                nfsl_get_time((time_t)lhp->rh_timestamp.tv_sec));
        elfbufoffset += sprintf(&elfbuf[elfbufoffset], " 0x%x",
                lhp->rh_reclen);
        if ((tag != NULL) && (tag[0] != '\0')) {
                elfbufoffset += sprintf(&elfbuf[elfbufoffset], " \"%s\"", tag);
        } else {
                elfbufoffset += sprintf(&elfbuf[elfbufoffset], " %s",
                                        empty_name);
        }
        elfbufoffset += sprintf(&elfbuf[elfbufoffset], " %s 0x%x %s",
                                progname, lhp->rh_version, disp->procname);
        elfbufoffset += sprintf(&elfbuf[elfbufoffset], " %s",
                NFSL_AUTH_FLAVOR_PRINT(lhp->rh_auth_flavor));
        if ((principal_name != NULL) && (principal_name[0] != '\0')) {
                elfbufoffset += sprintf(&elfbuf[elfbufoffset], " \"%s\"",
                        principal_name);
                if ((pwp = getpwnam(principal_name)) != NULL) {
                        elfbufoffset += sprintf(&elfbuf[elfbufoffset],
                                " 0x%lx", pwp->pw_uid);
                } else {
                        elfbufoffset += sprintf(&elfbuf[elfbufoffset],
                                " %s", empty_name);
                }
        } else {
                elfbufoffset += sprintf(&elfbuf[elfbufoffset], " %s",
                        empty_name);
                elfbufoffset += sprintf(&elfbuf[elfbufoffset], " %s",
                        empty_name);
        }
        elfbufoffset += sprintf(&elfbuf[elfbufoffset], " 0x%lx", lhp->rh_uid);
        if (((pwp = getpwuid(lhp->rh_uid)) != NULL) && (pwp->pw_name != NULL)) {
                elfbufoffset += sprintf(&elfbuf[elfbufoffset], " \"%s\"",
                        pwp->pw_name);
        } else {
                elfbufoffset += sprintf(&elfbuf[elfbufoffset], " %s",
                        empty_name);
        }
        elfbufoffset += sprintf(&elfbuf[elfbufoffset], " 0x%lx", lhp->rh_gid);
        elfrec->bufoffset = elfbufoffset;
}

static void
nfsl_elf_buffer_header_print(struct nfsl_log_file *elfrec,
        nfslog_buffer_header *bufhdr)
{
        int     rc;
        struct utsname  name;
        char    *elfbuf = elfrec->buf;
        int     elfbufoffset = elfrec->bufoffset;

        rc = uname(&name);
        elfbufoffset += sprintf(&elfbuf[elfbufoffset],
                "#Version %d.0\n#Software \"%s\"\n",
                bufhdr->bh_version, ((rc >= 0) ? name.sysname : empty_name));
        elfbufoffset += sprintf(&elfbuf[elfbufoffset], "#Date %s\n",
                nfsl_get_date((time_t)bufhdr->bh_timestamp.tv_sec));
        elfbufoffset += sprintf(&elfbuf[elfbufoffset], "#Remark %s\n",
                empty_name);
        elfbufoffset += sprintf(&elfbuf[elfbufoffset],
                "#Fields: time bytes tag");
        elfbufoffset += sprintf(&elfbuf[elfbufoffset],
                " rpc-program rpc-version rpc-procedure");
        elfbufoffset += sprintf(&elfbuf[elfbufoffset],
                " auth-flavor s-user-name s-uid uid u-name gid net-id c-ip");
        elfbufoffset += sprintf(&elfbuf[elfbufoffset],
                " c-dns s-dns status rpcarg-path");
        elfbufoffset += sprintf(&elfbuf[elfbufoffset],
                " rpc-arguments... rpc-response...\n");
        elfrec->bufoffset = elfbufoffset;
}

/*
 * nfsl_find_elf_dispatch - get the dispatch struct for this request
 */
static struct nfsl_proc_disp *
nfsl_find_elf_dispatch(nfslog_request_record *logrec, char **prognamep)
{
        nfslog_record_header    *logrechdr = &logrec->re_header;
        struct nfsl_prog_disp   *progtable;     /* prog struct */
        struct nfsl_vers_disp   *verstable;     /* version struct */
        int                     i, vers;

        /* Find prog element - search because can't use prog as array index */
        for (i = 0; (i < nfsl_elf_dispatch_table_arglen) &&
            (logrechdr->rh_prognum != nfsl_elf_dispatch_table[i].nfsl_dis_prog);
                i++);
        if (i >= nfsl_elf_dispatch_table_arglen) {      /* program not logged */
                /* not an error */
                return (NULL);
        }
        progtable = &nfsl_elf_dispatch_table[i];
        /* Find vers element - no validity check - if here it's valid vers */
        vers = logrechdr->rh_version - progtable->nfsl_dis_versmin;
        verstable = &progtable->nfsl_dis_vers_table[vers];
        /* Find proc element - no validity check - if here it's valid proc */
        *prognamep = progtable->progname;
        return (&verstable->nfsl_dis_proc_table[logrechdr->rh_procnum]);
}

/*
 * nfsl_elf_rpc_print - Print the record buffer.
 */
static void
nfsl_elf_rpc_print(struct nfsl_log_file *elfrec,
        nfslog_request_record *logrec, struct nfsl_proc_disp *disp,
        char *progname, char *path1, char *path2)
{
        if (debug > 1) {
                (void) printf("%s %d %s", progname,
                        logrec->re_header.rh_version, disp->procname);
                (void) printf(": '%s', '%s'\n",
                        ((path1 != NULL) ? path1 : empty_name),
                        ((path2 != NULL) ? path2 : empty_name));
        }
        /*
         * XXXX programs using this file to get a usable record should
         * take "record" struct.
         */
        /*
         * Print the variable fields:
         *      principal name
         *      netid
         *      ip address
         *      rpc args
         *      rpc res
         * Use the displacements calculated earlier...
         */

        /*
         * Fields: time bytes tag rpc-program rpc-version rpc-procedure
         *         auth-flavor s-user-name s-uid uid u-name gid net-id c-ip
         *       c-dns s-dns status rpcarg-path <arguments> <response>
         */
        nfsl_elf_record_header_print(elfrec, &logrec->re_header,
                        logrec->re_principal_name, logrec->re_tag,
                        disp, progname);
        if ((logrec->re_netid != NULL) && (logrec->re_netid[0] != '\0')) {
                elfrec->bufoffset += sprintf(&elfrec->buf[elfrec->bufoffset],
                        " \"%s\"", logrec->re_netid);
        } else {
                elfrec->bufoffset += sprintf(&elfrec->buf[elfrec->bufoffset],
                        " %s", empty_name);
        }
        nfsl_ipaddr_print(elfrec, &logrec->re_ipaddr);
        elfrec->bufoffset += sprintf(&elfrec->buf[elfrec->bufoffset],
                " \"%s\"", hostname);
        /* Next is return status */
        (*disp->nfsl_dis_res)(elfrec, logrec->re_rpc_res, TRUE);
        /* Next is argpath */
        if (path1 != NULL) {
                elfrec->bufoffset += sprintf(&elfrec->buf[elfrec->bufoffset],
                        " \"%s\"", path1);
        } else {
                elfrec->bufoffset += sprintf(&elfrec->buf[elfrec->bufoffset],
                        " %s", empty_name);
        }
        /*
         * path2 is non-empty for rename/link type operations. If it is non-
         * empty print it here as it's a part of the args
         */
        if (path2 != NULL) {
                elfrec->bufoffset += sprintf(&elfrec->buf[elfrec->bufoffset],
                        " \"%s\"", path2);
        }
        /* Next print formatted rpc args */
        (*disp->nfsl_dis_args)(elfrec, logrec->re_rpc_arg);
        /* Next print formatted rpc res (minus status) */
        (*disp->nfsl_dis_res)(elfrec, logrec->re_rpc_res, FALSE);
        elfrec->bufoffset += sprintf(&elfrec->buf[elfrec->bufoffset], "\n");
}

/*
 * nfsl_log_file_add - add a new record to the list
 */
static void
nfsl_log_file_add(struct nfsl_log_file *elfrec,
        struct nfsl_log_file **elf_listp)
{
        elfrec->next = *elf_listp;
        elfrec->prev = NULL;
        if (*elf_listp != NULL) {
                (*elf_listp)->prev = elfrec;
        }
        *elf_listp = elfrec;
}

/*
 * nfsl_log_file_find - finds a record in the list, given a cookie (== elfrec)
 * Returns the record.
 */
static struct nfsl_log_file *
nfsl_log_file_find(struct nfsl_log_file *elfrec,
        struct nfsl_log_file *elf_list)
{
        struct nfsl_log_file    *rec;

        for (rec = elf_list; (rec != NULL) && (rec != elfrec);
                rec = rec->next);
        return (rec);
}

/*
 * nfsl_log_file_del - delete a record from the list, does not free rec.
 * Returns the deleted record.
 */
static struct nfsl_log_file *
nfsl_log_file_del(struct nfsl_log_file *elfrec,
        struct nfsl_log_file **elf_listp)
{
        struct nfsl_log_file    *rec;

        if ((rec = nfsl_log_file_find(elfrec, *elf_listp)) == NULL) {
                return (NULL);
        }
        if (rec->prev != NULL) {
                rec->prev->next = rec->next;
        } else {
                *elf_listp = rec->next;
        }
        if (rec->next != NULL) {
                rec->next->prev = rec->prev;
        }
        return (rec);
}

/*
 * nfsl_log_file_free - frees a record
 */
static void
nfsl_log_file_free(struct nfsl_log_file *elfrec)
{
        if (elfrec == NULL)
                return;
        if (elfrec->path != NULL)
                free(elfrec->path);
        if (elfrec->buf != NULL)
                free(elfrec->buf);
        free(elfrec);
}

/*
 * Exported Functions
 */

/*
 * nfslog_open_elf_file - open the output elf file and mallocs needed buffers
 * Returns a pointer to the nfsl_log_file on success, NULL on error.
 *
 * *error contains the last error encountered on this object, It can
 * be used to avoid reporting the same error endlessly, by comparing
 * the current error to the last error. It is reset to the current error
 * code on return.
 */
void *
nfslog_open_elf_file(char *elfpath, nfslog_buffer_header *bufhdr, int *error)
{
        struct nfsl_log_file *elfrec;
        struct stat stat_buf;
        int preverror = *error;

        if ((elfrec = malloc(sizeof (*elfrec))) == NULL) {
                *error = errno;
                if (*error != preverror) {
                        syslog(LOG_ERR, gettext("nfslog_open_elf_file: %s"),
                                strerror(*error));
                }
                return (NULL);
        }
        bzero(elfrec, sizeof (*elfrec));

        elfrec->buf = (char *)malloc(DFLT_BUFFERSIZE + DFLT_OVFSIZE);
        if (elfrec->buf == NULL) {
                *error = errno;
                if (*error != preverror) {
                        syslog(LOG_ERR, gettext("nfslog_open_elf_file: %s"),
                                strerror(*error));
                }
                nfsl_log_file_free(elfrec);
                return (NULL);
        }

        if ((elfrec->path = strdup(elfpath)) == NULL) {
                *error = errno;
                if (*error != preverror) {
                        syslog(LOG_ERR, gettext("nfslog_open_elf_file: %s"),
                                strerror(*error));
                }
                nfsl_log_file_free(elfrec);
                return (NULL);
        }

        if ((elfrec->fp = fopen(elfpath, "a")) == NULL) {
                *error = errno;
                if (*error != preverror) {
                        syslog(LOG_ERR, gettext("Cannot open '%s': %s"),
                                elfpath, strerror(*error));
                }
                nfsl_log_file_free(elfrec);
                return (NULL);
        }

        if (stat(elfpath, &stat_buf) == -1) {
                *error = errno;
                if (*error != preverror) {
                        syslog(LOG_ERR, gettext("Cannot stat '%s': %s"),
                                elfpath, strerror(*error));
                }
                (void) fclose(elfrec->fp);
                nfsl_log_file_free(elfrec);
                return (NULL);
        }

        nfsl_log_file_add(elfrec, &elf_file_list);

        if (stat_buf.st_size == 0) {
                /*
                 * Print header unto logfile
                 */
                nfsl_elf_buffer_header_print(elfrec, bufhdr);
        }

        if (hostname[0] == '\0') {
                (void) gethostname(hostname, MAXHOSTNAMELEN);
        }

        return (elfrec);
}

/*
 * nfslog_close_elf_file - close elffile and write out last buffer
 */
void
nfslog_close_elf_file(void **elfcookie)
{
        struct nfsl_log_file    *elfrec;

        if ((*elfcookie == NULL) || ((elfrec = nfsl_log_file_del(
            *elfcookie, &elf_file_list)) == NULL)) {
                *elfcookie = NULL;
                return;
        }
        if (elfrec->fp != NULL) {
                /* Write the last output buffer to disk */
                (void) nfsl_write_elfbuf(elfrec);
                (void) fclose(elfrec->fp);
        }
        nfsl_log_file_free(elfrec);
        *elfcookie = NULL;
}

/*
 * nfslog_process_elf_rec - processes the record in the buffer and outputs
 *      to the elf log.
 * Return 0 for success, errno else.
 */
int
nfslog_process_elf_rec(void *elfcookie, nfslog_request_record *logrec,
        char *path1, char *path2)
{
        struct nfsl_log_file    *elfrec;
        struct nfsl_proc_disp   *disp;
        char                    *progname;

        if ((elfrec = nfsl_log_file_find(elfcookie, elf_file_list)) == NULL) {
                return (EINVAL);
        }
        /* Make sure there is room */
        if (elfrec->bufoffset > DFLT_BUFFERSIZE) {
                if (nfsl_write_elfbuf(elfrec) < 0) {
                        return (errno);
                }
        }
        if ((disp = nfsl_find_elf_dispatch(logrec, &progname)) != NULL) {
                nfsl_elf_rpc_print(elfrec, logrec, disp, progname,
                        path1, path2);
        }
        return (0);
}