libndr/common/ndr_heap.c

/*
 * 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, 2011, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * NDR heap management. The heap is used for temporary storage by
 * both the client and server side library routines.  In order to
 * support the different requirements of the various RPCs, the heap
 * can grow dynamically if required.  We start with a single block
 * and perform sub-allocations from it.  If an RPC requires more space
 * we will continue to add it a block at a time.  This means that we
 * don't hog lots of memory on every call to support the few times
 * that we actually need a lot heap space.
 *
 * Note that there is no individual free function.  Once space has been
 * allocated, it remains allocated until the heap is destroyed.  This
 * shouldn't be an issue because the heap is being filled with data to
 * be marshalled or unmarshalled and we need it all to be there until
 * the point that the entire heap is no longer required.
 */

#include <sys/errno.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <sys/uio.h>

#include <smbsrv/libsmb.h>
#include <smbsrv/libndr.h>
#include <smb/smb_sid.h>

/*
 * Allocate a heap structure and the first heap block.  For many RPC
 * operations this will be the only time we need to malloc memory
 * in this instance of the heap.  The only point of note here is that
 * we put the heap management data in the first block to avoid a
 * second malloc. Make sure that sizeof(ndr_heap_t) is smaller
 * than NDR_HEAP_BLKSZ.
 *
 * Note that the heap management data is at the start of the first block.
 *
 * Returns a pointer to the newly created heap, which is used like an
 * opaque handle with the rest of the heap management interface..
 */
ndr_heap_t *
ndr_heap_create(void)
{
    ndr_heap_t *heap;
    char *base;
    size_t allocsize = sizeof (ndr_heap_t) + NDR_HEAP_BLKSZ;

    if ((heap = malloc(allocsize)) == NULL)
        return (NULL);

    base = (char *)heap;
    bzero(heap, sizeof (ndr_heap_t));

    heap->iovcnt = NDR_HEAP_MAXIOV;
    heap->iov = heap->iovec;
    heap->iov->iov_base = base;
    heap->iov->iov_len = sizeof (ndr_heap_t);
    heap->top = base + allocsize;
    heap->next = base + sizeof (ndr_heap_t);

    return (heap);
}

/*
 * Deallocate all of the memory associated with a heap.  This is the
 * only way to deallocate heap memory, it isn't possible to free the
 * space obtained by individual malloc calls.
 *
 * Note that the first block contains the heap management data, which
 * is deleted last.
 */
void
ndr_heap_destroy(ndr_heap_t *heap)
{
    int i;
    char *p;

    if (heap) {
        for (i = 1; i < NDR_HEAP_MAXIOV; ++i) {
            if ((p = heap->iovec[i].iov_base) != NULL)
                free(p);
        }

        free(heap);
    }
}

/*
 * Allocate space in the specified heap.  All requests are padded, if
 * required, to ensure dword alignment.  If the current iov will be
 * exceeded, we allocate a new block and setup the next iov.  Otherwise
 * all we have to do is move the next pointer and update the current
 * iov length.
 *
 * On success, a pointer to the allocated (dword aligned) area is
 * returned.  Otherwise a null pointer is returned.
 */
void *
ndr_heap_malloc(ndr_heap_t *heap, unsigned size)
{
    char *p;
    int incr_size;

    size += NDR_ALIGN4(size);

    if (heap == NULL || size == 0)
        return (NULL);

    p = heap->next;

    if (p + size > heap->top) {
        if ((heap->iovcnt == 0) || ((--heap->iovcnt) == 0))
            return (NULL);

        incr_size = (size < NDR_HEAP_BLKSZ) ? NDR_HEAP_BLKSZ : size;

        if ((p = (char *)malloc(incr_size)) == NULL)
            return (NULL);

        ++heap->iov;
        heap->iov->iov_base = p;
        heap->iov->iov_len = 0;
        heap->top = p + incr_size;
    }

    heap->next = p + size;
    heap->iov->iov_len += size;
    return ((void *)p);
}

/*
 * Convenience function to do heap strdup.
 */
void *
ndr_heap_strdup(ndr_heap_t *heap, const char *s)
{
    int len;
    void *p;

    if (s == NULL)
        return (NULL);

    /*
     * We don't need to clutter the heap with empty strings.
     */
    if ((len = strlen(s)) == 0)
        return ("");

    if ((p = ndr_heap_malloc(heap, len+1)) != NULL)
        (void) strcpy((char *)p, s);

    return (p);
}

/*
 * Make an ndr_mstring_t from a regular string.
 */
int
ndr_heap_mstring(ndr_heap_t *heap, const char *s, ndr_mstring_t *out)
{
    if (s == NULL || out == NULL)
        return (-1);

    out->length = smb_wcequiv_strlen(s);
    out->allosize = out->length + sizeof (smb_wchar_t);

    if ((out->str = ndr_heap_strdup(heap, s)) == NULL)
        return (-1);

    return (0);
}

/*
 * Our regular string marshalling always creates null terminated strings
 * but some Windows clients and servers are pedantic about the string
 * formats they will accept and require non-null terminated strings.
 * This function can be used to build a wide-char, non-null terminated
 * string in the heap as a varying/conformant array.  We need to do the
 * wide-char conversion here because the marshalling code won't be
 * aware that this is really a string.
 */
void
ndr_heap_mkvcs(ndr_heap_t *heap, char *s, ndr_vcstr_t *vc)
{
    int mlen;

    vc->wclen = smb_wcequiv_strlen(s);
    vc->wcsize = vc->wclen;

    mlen = sizeof (ndr_vcs_t) + vc->wcsize + sizeof (smb_wchar_t);

    vc->vcs = ndr_heap_malloc(heap, mlen);

    if (vc->vcs) {
        vc->vcs->vc_first_is = 0;
        vc->vcs->vc_length_is = vc->wclen / sizeof (smb_wchar_t);
        (void) smb_mbstowcs((smb_wchar_t *)vc->vcs->buffer, s,
            vc->vcs->vc_length_is);
    }
}

void
ndr_heap_mkvcb(ndr_heap_t *heap, uint8_t *data, uint32_t datalen,
    ndr_vcbuf_t *vcbuf)
{
    int mlen;

    if (data == NULL || datalen == 0) {
        bzero(vcbuf, sizeof (ndr_vcbuf_t));
        return;
    }

    vcbuf->len = datalen;
    vcbuf->size = datalen;

    mlen = sizeof (ndr_vcbuf_t) + datalen;

    vcbuf->vcb = ndr_heap_malloc(heap, mlen);

    if (vcbuf->vcb) {
        vcbuf->vcb->vc_first_is = 0;
        vcbuf->vcb->vc_length_is = datalen;
        bcopy(data, vcbuf->vcb->buffer, datalen);
    }
}

/*
 * Duplcate a SID in the heap.
 */
smb_sid_t *
ndr_heap_siddup(ndr_heap_t *heap, smb_sid_t *sid)
{
    smb_sid_t *new_sid;
    unsigned size;

    if (sid == NULL)
        return (NULL);

    size = smb_sid_len(sid);

    if ((new_sid = ndr_heap_malloc(heap, size)) == NULL)
        return (NULL);

    bcopy(sid, new_sid, size);
    return (new_sid);
}

int
ndr_heap_used(ndr_heap_t *heap)
{
    int used = 0;
    int i;

    for (i = 0; i < NDR_HEAP_MAXIOV; ++i)
        used += heap->iovec[i].iov_len;

    return (used);
}

int
ndr_heap_avail(ndr_heap_t *heap)
{
    int avail;
    int count;

    count = (heap->iovcnt == 0) ? 0 : (heap->iovcnt - 1);

    avail = count * NDR_HEAP_BLKSZ;
    avail += (heap->top - heap->next);

    return (avail);
}