/*
 * 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 (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include <stdlib.h>
#include <strings.h>
#include <rpc/xdr.h>
#include <errno.h>
#include <syslog.h>
#include <smbsrv/libsmb.h>
#include <smbsrv/smb_xdr.h>
#include <smbsrv/smb_door.h>


/*
 * Generic XDR encoder.
 *
 * Returns a malloc'd, encoded buffer upon success.
 * Otherwise, returns NULL.
 */
char *
smb_common_encode(void *data, xdrproc_t proc, size_t *rsize)
{
        XDR     xdrs;
        char    *buf;
        size_t  len;

        if (proc == NULL || data == NULL || rsize == NULL) {
                syslog(LOG_ERR, "smb_common_encode: invalid parameter");
                return (NULL);
        }

        len = xdr_sizeof(proc, data);

        if ((buf = malloc(len)) == NULL) {
                syslog(LOG_ERR, "smb_common_encode: %m");
                *rsize = 0;
                return (NULL);
        }

        xdrmem_create(&xdrs, buf, len, XDR_ENCODE);
        *rsize = len;

        if (!proc(&xdrs, data)) {
                syslog(LOG_DEBUG, "smb_common_encode: encode error");
                free(buf);
                buf = NULL;
                *rsize = 0;
        }

        xdr_destroy(&xdrs);
        return (buf);
}

/*
 * Generic XDR decoder.  Ensure that data is non-null and bzero'd.
 */
int
smb_common_decode(char *buf, size_t len, xdrproc_t proc, void *data)
{
        XDR xdrs;
        int rc = 0;

        if (data == NULL)
                return (-1);

        xdrmem_create(&xdrs, buf, len, XDR_DECODE);
        if (!proc(&xdrs, data))
                rc = -1;

        xdr_destroy(&xdrs);
        return (rc);
}

char *
smb_string_encode(char *s, size_t *rsize)
{
        smb_string_t    obj;
        XDR             xdrs;
        char            *buf = NULL;
        size_t          len;

        if ((obj.buf = s) == NULL) {
                syslog(LOG_DEBUG, "smb_string_encode: invalid param");
                goto smb_string_encode_failed;
        }

        len = xdr_sizeof(smb_string_xdr, &obj);
        if ((buf = calloc(len, 1)) == NULL) {
                syslog(LOG_DEBUG, "smb_string_encode: %m");
                goto smb_string_encode_failed;
        }

        xdrmem_create(&xdrs, buf, len, XDR_ENCODE);

        if (!smb_string_xdr(&xdrs, &obj)) {
                syslog(LOG_DEBUG, "smb_string_encode: encode failed");
                xdr_destroy(&xdrs);
                free(buf);
                goto smb_string_encode_failed;
        }

        xdr_destroy(&xdrs);
        if (rsize)
                *rsize = len;
        return (buf);

smb_string_encode_failed:
        if (rsize)
                *rsize = 0;
        return (NULL);
}

int
smb_string_decode(smb_string_t *obj, char *buf, size_t buflen)
{
        XDR xdrs;
        int rc = 0;

        xdrmem_create(&xdrs, (const caddr_t)buf, buflen, XDR_DECODE);

        bzero(obj, sizeof (smb_string_t));
        if (!smb_string_xdr(&xdrs, obj))
                rc = -1;

        xdr_destroy(&xdrs);
        return (rc);
}

/*
 * Encode an lsa_account_t into a buffer.
 */
int
lsa_account_encode(lsa_account_t *acct, uint8_t *buf, uint32_t buflen)
{
        XDR xdrs;
        int rc = 0;

        xdrmem_create(&xdrs, (const caddr_t)buf, buflen, XDR_ENCODE);

        if (!lsa_account_xdr(&xdrs, acct))
                rc = -1;

        xdr_destroy(&xdrs);
        return (rc);
}

/*
 * Decode an XDR buffer into an lsa_account_t.
 */
int
lsa_account_decode(lsa_account_t *acct, uint8_t *buf, uint32_t buflen)
{
        XDR xdrs;
        int rc = 0;

        xdrmem_create(&xdrs, (const caddr_t)buf, buflen, XDR_DECODE);

        bzero(acct, sizeof (lsa_account_t));
        if (!lsa_account_xdr(&xdrs, acct))
                rc = -1;

        xdr_destroy(&xdrs);
        return (rc);
}

bool_t
lsa_account_xdr(XDR *xdrs, lsa_account_t *objp)
{
        if (!xdr_uint16_t(xdrs, &objp->a_sidtype))
                return (FALSE);
        if (!xdr_uint32_t(xdrs, &objp->a_status))
                return (FALSE);
        if (!xdr_vector(xdrs, (char *)objp->a_domain, MAXNAMELEN,
            sizeof (char), (xdrproc_t)xdr_char))
                return (FALSE);
        if (!xdr_vector(xdrs, (char *)objp->a_name, MAXNAMELEN,
            sizeof (char), (xdrproc_t)xdr_char))
                return (FALSE);
        if (!xdr_vector(xdrs, (char *)objp->a_sid, SMB_SID_STRSZ,
            sizeof (char), (xdrproc_t)xdr_char))
                return (FALSE);
        return (TRUE);
}