/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <stdio.h>
#include <sys/types.h>
#include <sys/varargs.h>
#include <bsm/audit.h>
#include <bsm/libbsm.h>
#include <bsm/audit_record.h>

#include "praudit.h"


/*
 * pr_adr_char - pull out characters
 */
int
pr_adr_char(pr_context_t *context, char *cp, int count)
{
        int     err;
        adr_t   *adr = context->audit_adr;
        adrf_t  *adrf = context->audit_adrf;

        if (context->data_mode == FILEMODE) {
                err = adrf_char(adrf, cp, count);
                if (err) {
                        errno = EIO;
                        return (-1);
                } else
                        return (0);
        }

        /* adrm routines don't return error, so check before calling */
        if (!pr_input_remaining(context, (sizeof (char) * count))) {
                errno = EIO;
                return (-1);
        }

        adrm_char(adr, cp, count);
        return (0);
}

/*
 * pr_adr_short - pull out shorts
 */
int
pr_adr_short(pr_context_t *context, short *sp, int count)
{
        int     err;
        adr_t   *adr = context->audit_adr;
        adrf_t  *adrf = context->audit_adrf;

        if (context->data_mode == FILEMODE) {
                err = adrf_short(adrf, sp, count);
                if (err) {
                        errno = EIO;
                        return (-1);
                } else
                        return (0);
        }

        /* adrm routines don't return error, so check before calling */
        if (!pr_input_remaining(context, (sizeof (short) * count))) {
                errno = EIO;
                return (-1);
        }

        adrm_short(adr, sp, count);
        return (0);
}

/*
 * pr_adr_int32 - pull out int32
 */
int
pr_adr_int32(pr_context_t *context, int32_t *lp, int count)
{
        int     err;
        adr_t   *adr = context->audit_adr;
        adrf_t  *adrf = context->audit_adrf;

        if (context->data_mode == FILEMODE) {
                err = adrf_int32(adrf, lp, count);
                if (err) {
                        errno = EIO;
                        return (-1);
                } else
                        return (0);
        }

        /* adrm routines don't return error, so check before calling */
        if (!pr_input_remaining(context, (sizeof (int32_t) * count))) {
                errno = EIO;
                return (-1);
        }

        adrm_int32(adr, lp, count);
        return (0);
}

int
pr_adr_int64(pr_context_t *context, int64_t *lp, int count)
{
        int     err;
        adr_t   *adr = context->audit_adr;
        adrf_t  *adrf = context->audit_adrf;

        if (context->data_mode == FILEMODE) {
                err = adrf_int64(adrf, lp, count);
                if (err) {
                        errno = EIO;
                        return (-1);
                } else
                        return (0);
        }

        /* adrm routines don't return error, so check before calling */
        if (!pr_input_remaining(context, (sizeof (int64_t) * count))) {
                errno = EIO;
                return (-1);
        }

        adrm_int64(adr, lp, count);
        return (0);
}

int
pr_adr_u_int32(pr_context_t *context, uint32_t *cp, int count)
{
        return (pr_adr_int32(context, (int32_t *)cp, count));
}

int
pr_adr_u_char(pr_context_t *context, uchar_t *cp, int count)
{
        return (pr_adr_char(context, (char *)cp, count));
}

int
pr_adr_u_int64(pr_context_t *context, uint64_t *lp, int count)
{
        return (pr_adr_int64(context, (int64_t *)lp, count));
}

int
pr_adr_u_short(pr_context_t *context, ushort_t *sp, int count)
{
        return (pr_adr_short(context, (short *)sp, count));
}

int
pr_putchar(pr_context_t *context, char c)
{
        if (context->data_mode == FILEMODE) {
                (void) putchar(c);
                return (0);
        }
        /* Buffer-based output processing otherwise... */

        /* Need at least room for char + null-byte */
        if (context->outbuf_remain_len < 2) {
                /* no space left */
                errno = ENOSPC;
                return (-1);
        }

        *(context->outbuf_p) = c;
        context->outbuf_p += 1;
        context->outbuf_remain_len -= 1;

        return (0);
}

int
pr_printf(pr_context_t *context, const char *fmt, ...)
{
        int addlen;
        va_list ap;

        va_start(ap, fmt);

        if (context->data_mode == FILEMODE) {
                (void) vprintf(fmt, ap);
                va_end(ap);
                return (0);
        }
        /* Buffer-based output processing otherwise... */

        if (context->outbuf_remain_len < 2) {
                /* no space at all left */
                va_end(ap);
                errno = ENOSPC;
                return (-1);
        }

        /* Attempt to tack on this string */
        addlen = vsnprintf(context->outbuf_p, context->outbuf_remain_len - 1,
            fmt, ap);
        va_end(ap);
        if (addlen < 0) {
                /* output error */
                errno = EPERM;
                return (-1);
        }
        if (addlen >= context->outbuf_remain_len - 1) {
                /* not enough space; bail out */
                errno = ENOSPC;
                return (-1);
        }

        /*
         * vsnprintf was successful; update pointers and counters
         * as needed. If no bytes were written, treat it as a no-op
         * and don't need to update anything.
         */
        if (addlen >= 1) {
                context->outbuf_remain_len -= addlen;
                context->outbuf_p += addlen;
        }

        return (0);
}


/*
 * pr_input_remaining - Check whether size bytes (or more) are remaining in
 * the inbuf.
 * returns      1 - there are enough bytes remaining
 *              0 - not enough bytes left
 */
int
pr_input_remaining(pr_context_t *context, size_t size)
{
        adr_t   *adr = context->audit_adr;

        /* no-op if not doing buf mode */
        if (context->data_mode != BUFMODE)
                return (1);

        if ((adr_count(adr) + size) > context->inbuf_totalsize)
                return (0);
        else
                return (1);
}