This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/*
*/
#include "includes.h"
-#include "dlinklist.h"
+#include "librpc/ndr/libndr.h"
+#include "lib/util/dlinklist.h"
+#include "librpc/gen_ndr/dcerpc.h"
+#include "param/param.h"
#define NDR_BASE_MARSHALL_SIZE 1024
+/* this guid indicates NDR encoding in a protocol tower */
+const struct ndr_syntax_id ndr_transfer_syntax = {
+ { 0x8a885d04, 0x1ceb, 0x11c9, {0x9f, 0xe8}, {0x08,0x00,0x2b,0x10,0x48,0x60} },
+ 2
+};
+
+const struct ndr_syntax_id ndr64_transfer_syntax = {
+ { 0x71710533, 0xbeba, 0x4937, {0x83, 0x19}, {0xb5,0xdb,0xef,0x9c,0xcc,0x36} },
+ 1
+};
+
/*
work out the number of bytes needed to align on a n byte boundary
*/
-size_t ndr_align_size(uint32_t offset, size_t n)
+_PUBLIC_ size_t ndr_align_size(uint32_t offset, size_t n)
{
if ((offset & (n-1)) == 0) return 0;
return n - (offset & (n-1));
/*
initialise a ndr parse structure from a data blob
*/
-struct ndr_pull *ndr_pull_init_blob(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx)
+_PUBLIC_ struct ndr_pull *ndr_pull_init_blob(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx)
{
struct ndr_pull *ndr;
ndr->data = blob->data;
ndr->data_size = blob->length;
+ ndr->iconv_convenience = talloc_reference(ndr, lp_iconv_convenience(global_loadparm));
return ndr;
}
/*
advance by 'size' bytes
*/
-NTSTATUS ndr_pull_advance(struct ndr_pull *ndr, uint32_t size)
+_PUBLIC_ enum ndr_err_code ndr_pull_advance(struct ndr_pull *ndr, uint32_t size)
{
ndr->offset += size;
if (ndr->offset > ndr->data_size) {
"ndr_pull_advance by %u failed",
size);
}
- return NT_STATUS_OK;
+ return NDR_ERR_SUCCESS;
}
/*
set the parse offset to 'ofs'
*/
-static NTSTATUS ndr_pull_set_offset(struct ndr_pull *ndr, uint32_t ofs)
+static enum ndr_err_code ndr_pull_set_offset(struct ndr_pull *ndr, uint32_t ofs)
{
ndr->offset = ofs;
if (ndr->offset > ndr->data_size) {
"ndr_pull_set_offset %u failed",
ofs);
}
- return NT_STATUS_OK;
-}
-
-/* save the offset/size of the current ndr state */
-void ndr_pull_save(struct ndr_pull *ndr, struct ndr_pull_save *save)
-{
- save->offset = ndr->offset;
- save->data_size = ndr->data_size;
-}
-
-/* restore the size/offset of a ndr structure */
-void ndr_pull_restore(struct ndr_pull *ndr, struct ndr_pull_save *save)
-{
- ndr->offset = save->offset;
- ndr->data_size = save->data_size;
+ return NDR_ERR_SUCCESS;
}
-
/* create a ndr_push structure, ready for some marshalling */
-struct ndr_push *ndr_push_init_ctx(TALLOC_CTX *mem_ctx)
+_PUBLIC_ struct ndr_push *ndr_push_init_ctx(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience)
{
struct ndr_push *ndr;
if (!ndr->data) {
return NULL;
}
+ ndr->iconv_convenience = talloc_reference(ndr, iconv_convenience);
return ndr;
}
-
-/* create a ndr_push structure, ready for some marshalling */
-struct ndr_push *ndr_push_init(void)
-{
- return ndr_push_init_ctx(NULL);
-}
-
-/* free a ndr_push structure */
-void ndr_push_free(struct ndr_push *ndr)
-{
- talloc_free(ndr);
-}
-
-
/* return a DATA_BLOB structure for the current ndr_push marshalled data */
-DATA_BLOB ndr_push_blob(struct ndr_push *ndr)
+_PUBLIC_ DATA_BLOB ndr_push_blob(struct ndr_push *ndr)
{
DATA_BLOB blob;
- blob.data = ndr->data;
- blob.length = ndr->offset;
+ blob = data_blob_const(ndr->data, ndr->offset);
if (ndr->alloc_size > ndr->offset) {
ndr->data[ndr->offset] = 0;
}
/*
- expand the available space in the buffer to 'size'
+ expand the available space in the buffer to ndr->offset + extra_size
*/
-NTSTATUS ndr_push_expand(struct ndr_push *ndr, uint32_t size)
+_PUBLIC_ enum ndr_err_code ndr_push_expand(struct ndr_push *ndr, uint32_t extra_size)
{
+ uint32_t size = extra_size + ndr->offset;
+
+ if (size < ndr->offset) {
+ /* extra_size overflowed the offset */
+ return ndr_push_error(ndr, NDR_ERR_BUFSIZE, "Overflow in push_expand to %u",
+ size);
+ }
+
if (ndr->alloc_size > size) {
- return NT_STATUS_OK;
+ return NDR_ERR_SUCCESS;
}
ndr->alloc_size += NDR_BASE_MARSHALL_SIZE;
ndr->alloc_size);
}
- return NT_STATUS_OK;
+ return NDR_ERR_SUCCESS;
}
-void ndr_print_debug_helper(struct ndr_print *ndr, const char *format, ...) _PRINTF_ATTRIBUTE(2,3)
+_PUBLIC_ void ndr_print_debug_helper(struct ndr_print *ndr, const char *format, ...) _PRINTF_ATTRIBUTE(2,3)
{
va_list ap;
char *s = NULL;
va_end(ap);
for (i=0;i<ndr->depth;i++) {
- DEBUG(0,(" "));
+ DEBUGADD(0,(" "));
}
- DEBUG(0,("%s\n", s));
+ DEBUGADD(0,("%s\n", s));
free(s);
}
+_PUBLIC_ void ndr_print_string_helper(struct ndr_print *ndr, const char *format, ...) _PRINTF_ATTRIBUTE(2,3)
+{
+ va_list ap;
+ int i;
+
+ for (i=0;i<ndr->depth;i++) {
+ ndr->private_data = talloc_asprintf_append_buffer(
+ (char *)ndr->private_data, " ");
+ }
+
+ va_start(ap, format);
+ ndr->private_data = talloc_vasprintf_append_buffer((char *)ndr->private_data,
+ format, ap);
+ va_end(ap);
+ ndr->private_data = talloc_asprintf_append_buffer((char *)ndr->private_data,
+ "\n");
+}
+
/*
a useful helper function for printing idl structures via DEBUG()
*/
-void ndr_print_debug(ndr_print_fn_t fn, const char *name, void *ptr)
+_PUBLIC_ void ndr_print_debug(ndr_print_fn_t fn, const char *name, void *ptr)
{
struct ndr_print *ndr;
/*
a useful helper function for printing idl unions via DEBUG()
*/
-void ndr_print_union_debug(ndr_print_fn_t fn, const char *name, uint32_t level, void *ptr)
+_PUBLIC_ void ndr_print_union_debug(ndr_print_fn_t fn, const char *name, uint32_t level, void *ptr)
{
struct ndr_print *ndr;
/*
a useful helper function for printing idl function calls via DEBUG()
*/
-void ndr_print_function_debug(ndr_print_function_t fn, const char *name, int flags, void *ptr)
+_PUBLIC_ void ndr_print_function_debug(ndr_print_function_t fn, const char *name, int flags, void *ptr)
{
struct ndr_print *ndr;
talloc_free(ndr);
}
-void ndr_set_flags(uint32_t *pflags, uint32_t new_flags)
+/*
+ a useful helper function for printing idl structures to a string
+*/
+_PUBLIC_ char *ndr_print_struct_string(TALLOC_CTX *mem_ctx, ndr_print_fn_t fn, const char *name, void *ptr)
+{
+ struct ndr_print *ndr;
+ char *ret = NULL;
+
+ ndr = talloc_zero(mem_ctx, struct ndr_print);
+ if (!ndr) return NULL;
+ ndr->private_data = talloc_strdup(ndr, "");
+ if (!ndr->private_data) {
+ goto failed;
+ }
+ ndr->print = ndr_print_string_helper;
+ ndr->depth = 1;
+ ndr->flags = 0;
+ fn(ndr, name, ptr);
+ ret = talloc_steal(mem_ctx, (char *)ndr->private_data);
+failed:
+ talloc_free(ndr);
+ return ret;
+}
+
+/*
+ a useful helper function for printing idl unions to a string
+*/
+_PUBLIC_ char *ndr_print_union_string(TALLOC_CTX *mem_ctx, ndr_print_fn_t fn, const char *name, uint32_t level, void *ptr)
+{
+ struct ndr_print *ndr;
+ char *ret = NULL;
+
+ ndr = talloc_zero(mem_ctx, struct ndr_print);
+ if (!ndr) return NULL;
+ ndr->private_data = talloc_strdup(ndr, "");
+ if (!ndr->private_data) {
+ goto failed;
+ }
+ ndr->print = ndr_print_string_helper;
+ ndr->depth = 1;
+ ndr->flags = 0;
+ ndr_print_set_switch_value(ndr, ptr, level);
+ fn(ndr, name, ptr);
+ ret = talloc_steal(mem_ctx, (char *)ndr->private_data);
+failed:
+ talloc_free(ndr);
+ return ret;
+}
+
+/*
+ a useful helper function for printing idl function calls to a string
+*/
+_PUBLIC_ char *ndr_print_function_string(TALLOC_CTX *mem_ctx,
+ ndr_print_function_t fn, const char *name,
+ int flags, void *ptr)
+{
+ struct ndr_print *ndr;
+ char *ret = NULL;
+
+ ndr = talloc_zero(mem_ctx, struct ndr_print);
+ if (!ndr) return NULL;
+ ndr->private_data = talloc_strdup(ndr, "");
+ if (!ndr->private_data) {
+ goto failed;
+ }
+ ndr->print = ndr_print_string_helper;
+ ndr->depth = 1;
+ ndr->flags = 0;
+ fn(ndr, name, flags, ptr);
+ ret = talloc_steal(mem_ctx, (char *)ndr->private_data);
+failed:
+ talloc_free(ndr);
+ return ret;
+}
+
+_PUBLIC_ void ndr_set_flags(uint32_t *pflags, uint32_t new_flags)
{
/* the big/little endian flags are inter-dependent */
if (new_flags & LIBNDR_FLAG_LITTLE_ENDIAN) {
if (new_flags & LIBNDR_FLAG_BIGENDIAN) {
(*pflags) &= ~LIBNDR_FLAG_LITTLE_ENDIAN;
}
- (*pflags) |= new_flags;
-}
-
-static NTSTATUS ndr_map_error(enum ndr_err_code err)
-{
- switch (err) {
- case NDR_ERR_BUFSIZE:
- return NT_STATUS_BUFFER_TOO_SMALL;
- case NDR_ERR_TOKEN:
- return NT_STATUS_INTERNAL_ERROR;
- case NDR_ERR_ALLOC:
- return NT_STATUS_NO_MEMORY;
- case NDR_ERR_ARRAY_SIZE:
- return NT_STATUS_ARRAY_BOUNDS_EXCEEDED;
- default:
- break;
+ if (new_flags & LIBNDR_FLAG_REMAINING) {
+ (*pflags) &= ~LIBNDR_ALIGN_FLAGS;
}
-
- /* we should map all error codes to different status codes */
- return NT_STATUS_INVALID_PARAMETER;
+ if (new_flags & LIBNDR_ALIGN_FLAGS) {
+ (*pflags) &= ~LIBNDR_FLAG_REMAINING;
+ }
+ (*pflags) |= new_flags;
}
/*
return and possibly log an NDR error
*/
-NTSTATUS ndr_pull_error(struct ndr_pull *ndr,
- enum ndr_err_code err, const char *format, ...) _PRINTF_ATTRIBUTE(3,4)
+_PUBLIC_ enum ndr_err_code ndr_pull_error(struct ndr_pull *ndr,
+ enum ndr_err_code ndr_err,
+ const char *format, ...) _PRINTF_ATTRIBUTE(3,4)
{
char *s=NULL;
va_list ap;
vasprintf(&s, format, ap);
va_end(ap);
- DEBUG(3,("ndr_pull_error(%u): %s\n", err, s));
+ DEBUG(3,("ndr_pull_error(%u): %s\n", ndr_err, s));
free(s);
- return ndr_map_error(err);
+ return ndr_err;
}
/*
return and possibly log an NDR error
*/
-NTSTATUS ndr_push_error(struct ndr_push *ndr, enum ndr_err_code err, const char *format, ...) _PRINTF_ATTRIBUTE(3,4)
+_PUBLIC_ enum ndr_err_code ndr_push_error(struct ndr_push *ndr,
+ enum ndr_err_code ndr_err,
+ const char *format, ...) _PRINTF_ATTRIBUTE(3,4)
{
char *s=NULL;
va_list ap;
vasprintf(&s, format, ap);
va_end(ap);
- DEBUG(3,("ndr_push_error(%u): %s\n", err, s));
+ DEBUG(3,("ndr_push_error(%u): %s\n", ndr_err, s));
free(s);
- return ndr_map_error(err);
+ return ndr_err;
}
/*
handle subcontext buffers, which in midl land are user-marshalled, but
we use magic in pidl to make them easier to cope with
*/
-NTSTATUS ndr_pull_subcontext_start(struct ndr_pull *ndr,
+_PUBLIC_ enum ndr_err_code ndr_pull_subcontext_start(struct ndr_pull *ndr,
struct ndr_pull **_subndr,
size_t header_size,
ssize_t size_is)
NDR_PULL_NEED_BYTES(ndr, r_content_size);
subndr = talloc_zero(ndr, struct ndr_pull);
- NT_STATUS_HAVE_NO_MEMORY(subndr);
+ NDR_ERR_HAVE_NO_MEMORY(subndr);
subndr->flags = ndr->flags;
subndr->current_mem_ctx = ndr->current_mem_ctx;
subndr->data = ndr->data + ndr->offset;
subndr->offset = 0;
subndr->data_size = r_content_size;
+ subndr->iconv_convenience = talloc_reference(subndr, ndr->iconv_convenience);
*_subndr = subndr;
- return NT_STATUS_OK;
+ return NDR_ERR_SUCCESS;
}
-NTSTATUS ndr_pull_subcontext_end(struct ndr_pull *ndr,
+_PUBLIC_ enum ndr_err_code ndr_pull_subcontext_end(struct ndr_pull *ndr,
struct ndr_pull *subndr,
size_t header_size,
ssize_t size_is)
advance = subndr->offset;
}
NDR_CHECK(ndr_pull_advance(ndr, advance));
- return NT_STATUS_OK;
+ return NDR_ERR_SUCCESS;
}
-NTSTATUS ndr_push_subcontext_start(struct ndr_push *ndr,
+_PUBLIC_ enum ndr_err_code ndr_push_subcontext_start(struct ndr_push *ndr,
struct ndr_push **_subndr,
size_t header_size,
ssize_t size_is)
{
struct ndr_push *subndr;
- subndr = ndr_push_init_ctx(ndr);
- NT_STATUS_HAVE_NO_MEMORY(subndr);
+ subndr = ndr_push_init_ctx(ndr, ndr->iconv_convenience);
+ NDR_ERR_HAVE_NO_MEMORY(subndr);
subndr->flags = ndr->flags;
*_subndr = subndr;
- return NT_STATUS_OK;
+ return NDR_ERR_SUCCESS;
}
/*
push a subcontext header
*/
-NTSTATUS ndr_push_subcontext_end(struct ndr_push *ndr,
+_PUBLIC_ enum ndr_err_code ndr_push_subcontext_end(struct ndr_push *ndr,
struct ndr_push *subndr,
size_t header_size,
ssize_t size_is)
}
NDR_CHECK(ndr_push_bytes(ndr, subndr->data, subndr->offset));
- return NT_STATUS_OK;
+ return NDR_ERR_SUCCESS;
}
/*
store a token in the ndr context, for later retrieval
*/
-NTSTATUS ndr_token_store(TALLOC_CTX *mem_ctx,
+_PUBLIC_ enum ndr_err_code ndr_token_store(TALLOC_CTX *mem_ctx,
struct ndr_token_list **list,
const void *key,
uint32_t value)
{
struct ndr_token_list *tok;
tok = talloc(mem_ctx, struct ndr_token_list);
- if (tok == NULL) {
- return NT_STATUS_NO_MEMORY;
- }
+ NDR_ERR_HAVE_NO_MEMORY(tok);
tok->key = key;
tok->value = value;
DLIST_ADD((*list), tok);
- return NT_STATUS_OK;
+ return NDR_ERR_SUCCESS;
}
/*
retrieve a token from a ndr context, using cmp_fn to match the tokens
*/
-NTSTATUS ndr_token_retrieve_cmp_fn(struct ndr_token_list **list, const void *key, uint32_t *v,
- comparison_fn_t _cmp_fn, BOOL _remove_tok)
+_PUBLIC_ enum ndr_err_code ndr_token_retrieve_cmp_fn(struct ndr_token_list **list, const void *key, uint32_t *v,
+ comparison_fn_t _cmp_fn, bool _remove_tok)
{
struct ndr_token_list *tok;
for (tok=*list;tok;tok=tok->next) {
if (_cmp_fn && _cmp_fn(tok->key,key)==0) goto found;
else if (!_cmp_fn && tok->key == key) goto found;
}
- return ndr_map_error(NDR_ERR_TOKEN);
+ return NDR_ERR_TOKEN;
found:
*v = tok->value;
if (_remove_tok) {
DLIST_REMOVE((*list), tok);
talloc_free(tok);
}
- return NT_STATUS_OK;
+ return NDR_ERR_SUCCESS;
}
/*
retrieve a token from a ndr context
*/
-NTSTATUS ndr_token_retrieve(struct ndr_token_list **list, const void *key, uint32_t *v)
+_PUBLIC_ enum ndr_err_code ndr_token_retrieve(struct ndr_token_list **list, const void *key, uint32_t *v)
{
- return ndr_token_retrieve_cmp_fn(list, key, v, NULL, True);
+ return ndr_token_retrieve_cmp_fn(list, key, v, NULL, true);
}
/*
peek at but don't removed a token from a ndr context
*/
-uint32_t ndr_token_peek(struct ndr_token_list **list, const void *key)
+_PUBLIC_ uint32_t ndr_token_peek(struct ndr_token_list **list, const void *key)
{
- NTSTATUS status;
+ enum ndr_err_code status;
uint32_t v;
- status = ndr_token_retrieve_cmp_fn(list, key, &v, NULL, False);
- if (NT_STATUS_IS_OK(status)) return v;
- return 0;
+
+ status = ndr_token_retrieve_cmp_fn(list, key, &v, NULL, false);
+ if (!NDR_ERR_CODE_IS_SUCCESS(status)) {
+ return 0;
+ }
+
+ return v;
}
/*
pull an array size field and add it to the array_size_list token list
*/
-NTSTATUS ndr_pull_array_size(struct ndr_pull *ndr, const void *p)
+_PUBLIC_ enum ndr_err_code ndr_pull_array_size(struct ndr_pull *ndr, const void *p)
{
uint32_t size;
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &size));
/*
get the stored array size field
*/
-uint32_t ndr_get_array_size(struct ndr_pull *ndr, const void *p)
+_PUBLIC_ uint32_t ndr_get_array_size(struct ndr_pull *ndr, const void *p)
{
return ndr_token_peek(&ndr->array_size_list, p);
}
/*
check the stored array size field
*/
-NTSTATUS ndr_check_array_size(struct ndr_pull *ndr, void *p, uint32_t size)
+_PUBLIC_ enum ndr_err_code ndr_check_array_size(struct ndr_pull *ndr, void *p, uint32_t size)
{
uint32_t stored;
stored = ndr_token_peek(&ndr->array_size_list, p);
"Bad array size - got %u expected %u\n",
stored, size);
}
- return NT_STATUS_OK;
+ return NDR_ERR_SUCCESS;
}
/*
pull an array length field and add it to the array_length_list token list
*/
-NTSTATUS ndr_pull_array_length(struct ndr_pull *ndr, const void *p)
+_PUBLIC_ enum ndr_err_code ndr_pull_array_length(struct ndr_pull *ndr, const void *p)
{
uint32_t length, offset;
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &offset));
/*
get the stored array length field
*/
-uint32_t ndr_get_array_length(struct ndr_pull *ndr, const void *p)
+_PUBLIC_ uint32_t ndr_get_array_length(struct ndr_pull *ndr, const void *p)
{
return ndr_token_peek(&ndr->array_length_list, p);
}
/*
check the stored array length field
*/
-NTSTATUS ndr_check_array_length(struct ndr_pull *ndr, void *p, uint32_t length)
+_PUBLIC_ enum ndr_err_code ndr_check_array_length(struct ndr_pull *ndr, void *p, uint32_t length)
{
uint32_t stored;
stored = ndr_token_peek(&ndr->array_length_list, p);
"Bad array length - got %u expected %u\n",
stored, length);
}
- return NT_STATUS_OK;
+ return NDR_ERR_SUCCESS;
}
/*
store a switch value
*/
-NTSTATUS ndr_push_set_switch_value(struct ndr_push *ndr, const void *p, uint32_t val)
+_PUBLIC_ enum ndr_err_code ndr_push_set_switch_value(struct ndr_push *ndr, const void *p, uint32_t val)
{
return ndr_token_store(ndr, &ndr->switch_list, p, val);
}
-NTSTATUS ndr_pull_set_switch_value(struct ndr_pull *ndr, const void *p, uint32_t val)
+_PUBLIC_ enum ndr_err_code ndr_pull_set_switch_value(struct ndr_pull *ndr, const void *p, uint32_t val)
{
return ndr_token_store(ndr, &ndr->switch_list, p, val);
}
-NTSTATUS ndr_print_set_switch_value(struct ndr_print *ndr, const void *p, uint32_t val)
+_PUBLIC_ enum ndr_err_code ndr_print_set_switch_value(struct ndr_print *ndr, const void *p, uint32_t val)
{
return ndr_token_store(ndr, &ndr->switch_list, p, val);
}
/*
retrieve a switch value
*/
-uint32_t ndr_push_get_switch_value(struct ndr_push *ndr, const void *p)
+_PUBLIC_ uint32_t ndr_push_get_switch_value(struct ndr_push *ndr, const void *p)
{
return ndr_token_peek(&ndr->switch_list, p);
}
-uint32_t ndr_pull_get_switch_value(struct ndr_pull *ndr, const void *p)
+_PUBLIC_ uint32_t ndr_pull_get_switch_value(struct ndr_pull *ndr, const void *p)
{
return ndr_token_peek(&ndr->switch_list, p);
}
-uint32_t ndr_print_get_switch_value(struct ndr_print *ndr, const void *p)
+_PUBLIC_ uint32_t ndr_print_get_switch_value(struct ndr_print *ndr, const void *p)
{
return ndr_token_peek(&ndr->switch_list, p);
}
/*
pull a struct from a blob using NDR
*/
-NTSTATUS ndr_pull_struct_blob(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx, void *p,
+_PUBLIC_ enum ndr_err_code ndr_pull_struct_blob(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx, void *p,
ndr_pull_flags_fn_t fn)
{
struct ndr_pull *ndr;
ndr = ndr_pull_init_blob(blob, mem_ctx);
- if (!ndr) {
- return NT_STATUS_NO_MEMORY;
- }
- return fn(ndr, NDR_SCALARS|NDR_BUFFERS, p);
+ NDR_ERR_HAVE_NO_MEMORY(ndr);
+ NDR_CHECK(fn(ndr, NDR_SCALARS|NDR_BUFFERS, p));
+ return NDR_ERR_SUCCESS;
}
/*
pull a struct from a blob using NDR - failing if all bytes are not consumed
*/
-NTSTATUS ndr_pull_struct_blob_all(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx, void *p,
+_PUBLIC_ enum ndr_err_code ndr_pull_struct_blob_all(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx, void *p,
ndr_pull_flags_fn_t fn)
{
struct ndr_pull *ndr;
- NTSTATUS status;
-
ndr = ndr_pull_init_blob(blob, mem_ctx);
- if (!ndr) {
- return NT_STATUS_NO_MEMORY;
+ NDR_ERR_HAVE_NO_MEMORY(ndr);
+ NDR_CHECK(fn(ndr, NDR_SCALARS|NDR_BUFFERS, p));
+ if (ndr->offset < ndr->data_size) {
+ return ndr_pull_error(ndr, NDR_ERR_UNREAD_BYTES,
+ "not all bytes consumed ofs[%u] size[%u]",
+ ndr->offset, ndr->data_size);
}
- status = fn(ndr, NDR_SCALARS|NDR_BUFFERS, p);
- if (!NT_STATUS_IS_OK(status)) return status;
- if (ndr->offset != ndr->data_size) {
- return NT_STATUS_BUFFER_TOO_SMALL;
- }
- return status;
+ return NDR_ERR_SUCCESS;
}
/*
pull a union from a blob using NDR, given the union discriminator
*/
-NTSTATUS ndr_pull_union_blob(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx, void *p,
+_PUBLIC_ enum ndr_err_code ndr_pull_union_blob(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx, void *p,
uint32_t level, ndr_pull_flags_fn_t fn)
{
struct ndr_pull *ndr;
- NTSTATUS status;
+ ndr = ndr_pull_init_blob(blob, mem_ctx);
+ NDR_ERR_HAVE_NO_MEMORY(ndr);
+ NDR_CHECK(ndr_pull_set_switch_value(ndr, p, level));
+ NDR_CHECK(fn(ndr, NDR_SCALARS|NDR_BUFFERS, p));
+ return NDR_ERR_SUCCESS;
+}
+/*
+ pull a union from a blob using NDR, given the union discriminator,
+ failing if all bytes are not consumed
+*/
+_PUBLIC_ enum ndr_err_code ndr_pull_union_blob_all(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx, void *p,
+ uint32_t level, ndr_pull_flags_fn_t fn)
+{
+ struct ndr_pull *ndr;
ndr = ndr_pull_init_blob(blob, mem_ctx);
- if (!ndr) {
- return NT_STATUS_NO_MEMORY;
+ NDR_ERR_HAVE_NO_MEMORY(ndr);
+ NDR_CHECK(ndr_pull_set_switch_value(ndr, p, level));
+ NDR_CHECK(fn(ndr, NDR_SCALARS|NDR_BUFFERS, p));
+ if (ndr->offset < ndr->data_size) {
+ return ndr_pull_error(ndr, NDR_ERR_UNREAD_BYTES,
+ "not all bytes consumed ofs[%u] size[%u]",
+ ndr->offset, ndr->data_size);
}
- ndr_pull_set_switch_value(ndr, p, level);
- status = fn(ndr, NDR_SCALARS|NDR_BUFFERS, p);
- if (!NT_STATUS_IS_OK(status)) return status;
- if (ndr->offset != ndr->data_size) {
- return NT_STATUS_BUFFER_TOO_SMALL;
- }
- return status;
+ return NDR_ERR_SUCCESS;
}
/*
push a struct to a blob using NDR
*/
-NTSTATUS ndr_push_struct_blob(DATA_BLOB *blob, TALLOC_CTX *mem_ctx, const void *p,
+_PUBLIC_ enum ndr_err_code ndr_push_struct_blob(DATA_BLOB *blob, TALLOC_CTX *mem_ctx, const void *p,
ndr_push_flags_fn_t fn)
{
- NTSTATUS status;
struct ndr_push *ndr;
- ndr = ndr_push_init_ctx(mem_ctx);
- if (!ndr) {
- return NT_STATUS_NO_MEMORY;
- }
- status = fn(ndr, NDR_SCALARS|NDR_BUFFERS, p);
- if (!NT_STATUS_IS_OK(status)) {
- return status;
- }
+ ndr = ndr_push_init_ctx(mem_ctx, lp_iconv_convenience(global_loadparm));
+ NDR_ERR_HAVE_NO_MEMORY(ndr);
+
+ NDR_CHECK(fn(ndr, NDR_SCALARS|NDR_BUFFERS, p));
*blob = ndr_push_blob(ndr);
+ talloc_steal(mem_ctx, blob->data);
+ talloc_free(ndr);
- return NT_STATUS_OK;
+ return NDR_ERR_SUCCESS;
}
/*
push a union to a blob using NDR
*/
-NTSTATUS ndr_push_union_blob(DATA_BLOB *blob, TALLOC_CTX *mem_ctx, void *p,
+_PUBLIC_ enum ndr_err_code ndr_push_union_blob(DATA_BLOB *blob, TALLOC_CTX *mem_ctx, void *p,
uint32_t level, ndr_push_flags_fn_t fn)
{
- NTSTATUS status;
struct ndr_push *ndr;
- ndr = ndr_push_init_ctx(mem_ctx);
- if (!ndr) {
- return NT_STATUS_NO_MEMORY;
- }
- ndr_push_set_switch_value(ndr, p, level);
- status = fn(ndr, NDR_SCALARS|NDR_BUFFERS, p);
- if (!NT_STATUS_IS_OK(status)) {
- return status;
- }
+ ndr = ndr_push_init_ctx(mem_ctx, lp_iconv_convenience(global_loadparm));
+ NDR_ERR_HAVE_NO_MEMORY(ndr);
+
+ NDR_CHECK(ndr_push_set_switch_value(ndr, p, level));
+ NDR_CHECK(fn(ndr, NDR_SCALARS|NDR_BUFFERS, p));
*blob = ndr_push_blob(ndr);
+ talloc_steal(mem_ctx, blob->data);
+ talloc_free(ndr);
- return NT_STATUS_OK;
+ return NDR_ERR_SUCCESS;
}
/*
generic ndr_size_*() handler for structures
*/
-size_t ndr_size_struct(const void *p, int flags, ndr_push_flags_fn_t push)
+_PUBLIC_ size_t ndr_size_struct(const void *p, int flags, ndr_push_flags_fn_t push)
{
struct ndr_push *ndr;
- NTSTATUS status;
+ enum ndr_err_code status;
size_t ret;
/* avoid recursion */
if (flags & LIBNDR_FLAG_NO_NDR_SIZE) return 0;
- ndr = ndr_push_init_ctx(NULL);
+ ndr = ndr_push_init_ctx(NULL, lp_iconv_convenience(global_loadparm));
if (!ndr) return 0;
ndr->flags |= flags | LIBNDR_FLAG_NO_NDR_SIZE;
status = push(ndr, NDR_SCALARS|NDR_BUFFERS, discard_const(p));
- if (!NT_STATUS_IS_OK(status)) {
+ if (!NDR_ERR_CODE_IS_SUCCESS(status)) {
+ talloc_free(ndr);
return 0;
}
ret = ndr->offset;
/*
generic ndr_size_*() handler for unions
*/
-size_t ndr_size_union(const void *p, int flags, uint32_t level, ndr_push_flags_fn_t push)
+_PUBLIC_ size_t ndr_size_union(const void *p, int flags, uint32_t level, ndr_push_flags_fn_t push)
{
struct ndr_push *ndr;
- NTSTATUS status;
+ enum ndr_err_code status;
size_t ret;
/* avoid recursion */
if (flags & LIBNDR_FLAG_NO_NDR_SIZE) return 0;
- ndr = ndr_push_init_ctx(NULL);
+ ndr = ndr_push_init_ctx(NULL, lp_iconv_convenience(global_loadparm));
if (!ndr) return 0;
ndr->flags |= flags | LIBNDR_FLAG_NO_NDR_SIZE;
- ndr_push_set_switch_value(ndr, p, level);
+
+ status = ndr_push_set_switch_value(ndr, p, level);
+ if (!NDR_ERR_CODE_IS_SUCCESS(status)) {
+ talloc_free(ndr);
+ return 0;
+ }
status = push(ndr, NDR_SCALARS|NDR_BUFFERS, p);
- if (!NT_STATUS_IS_OK(status)) {
+ if (!NDR_ERR_CODE_IS_SUCCESS(status)) {
+ talloc_free(ndr);
return 0;
}
ret = ndr->offset;
/*
get the current base for relative pointers for the push
*/
-uint32_t ndr_push_get_relative_base_offset(struct ndr_push *ndr)
+_PUBLIC_ uint32_t ndr_push_get_relative_base_offset(struct ndr_push *ndr)
{
return ndr->relative_base_offset;
}
/*
restore the old base for relative pointers for the push
*/
-void ndr_push_restore_relative_base_offset(struct ndr_push *ndr, uint32_t offset)
+_PUBLIC_ void ndr_push_restore_relative_base_offset(struct ndr_push *ndr, uint32_t offset)
{
ndr->relative_base_offset = offset;
}
setup the current base for relative pointers for the push
called in the NDR_SCALAR stage
*/
-NTSTATUS ndr_push_setup_relative_base_offset1(struct ndr_push *ndr, const void *p, uint32_t offset)
+_PUBLIC_ enum ndr_err_code ndr_push_setup_relative_base_offset1(struct ndr_push *ndr, const void *p, uint32_t offset)
{
ndr->relative_base_offset = offset;
return ndr_token_store(ndr, &ndr->relative_base_list, p, offset);
setup the current base for relative pointers for the push
called in the NDR_BUFFERS stage
*/
-NTSTATUS ndr_push_setup_relative_base_offset2(struct ndr_push *ndr, const void *p)
+_PUBLIC_ enum ndr_err_code ndr_push_setup_relative_base_offset2(struct ndr_push *ndr, const void *p)
{
return ndr_token_retrieve(&ndr->relative_base_list, p, &ndr->relative_base_offset);
}
push a relative object - stage1
this is called during SCALARS processing
*/
-NTSTATUS ndr_push_relative_ptr1(struct ndr_push *ndr, const void *p)
+_PUBLIC_ enum ndr_err_code ndr_push_relative_ptr1(struct ndr_push *ndr, const void *p)
{
if (p == NULL) {
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
- return NT_STATUS_OK;
+ return NDR_ERR_SUCCESS;
}
NDR_CHECK(ndr_push_align(ndr, 4));
NDR_CHECK(ndr_token_store(ndr, &ndr->relative_list, p, ndr->offset));
push a relative object - stage2
this is called during buffers processing
*/
-NTSTATUS ndr_push_relative_ptr2(struct ndr_push *ndr, const void *p)
+_PUBLIC_ enum ndr_err_code ndr_push_relative_ptr2(struct ndr_push *ndr, const void *p)
{
- struct ndr_push_save save;
+ uint32_t save_offset;
uint32_t ptr_offset = 0xFFFFFFFF;
if (p == NULL) {
- return NT_STATUS_OK;
+ return NDR_ERR_SUCCESS;
}
- ndr_push_save(ndr, &save);
+ save_offset = ndr->offset;
NDR_CHECK(ndr_token_retrieve(&ndr->relative_list, p, &ptr_offset));
if (ptr_offset > ndr->offset) {
return ndr_push_error(ndr, NDR_ERR_BUFSIZE,
ptr_offset, ndr->offset);
}
ndr->offset = ptr_offset;
- if (save.offset < ndr->relative_base_offset) {
+ if (save_offset < ndr->relative_base_offset) {
return ndr_push_error(ndr, NDR_ERR_BUFSIZE,
- "ndr_push_relative_ptr2 save.offset(%u) < ndr->relative_base_offset(%u)",
- save.offset, ndr->relative_base_offset);
+ "ndr_push_relative_ptr2 save_offset(%u) < ndr->relative_base_offset(%u)",
+ save_offset, ndr->relative_base_offset);
}
- NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, save.offset - ndr->relative_base_offset));
- ndr_push_restore(ndr, &save);
- return NT_STATUS_OK;
+ NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, save_offset - ndr->relative_base_offset));
+ ndr->offset = save_offset;
+ return NDR_ERR_SUCCESS;
}
/*
get the current base for relative pointers for the pull
*/
-uint32_t ndr_pull_get_relative_base_offset(struct ndr_pull *ndr)
+_PUBLIC_ uint32_t ndr_pull_get_relative_base_offset(struct ndr_pull *ndr)
{
return ndr->relative_base_offset;
}
/*
restore the old base for relative pointers for the pull
*/
-void ndr_pull_restore_relative_base_offset(struct ndr_pull *ndr, uint32_t offset)
+_PUBLIC_ void ndr_pull_restore_relative_base_offset(struct ndr_pull *ndr, uint32_t offset)
{
ndr->relative_base_offset = offset;
}
setup the current base for relative pointers for the pull
called in the NDR_SCALAR stage
*/
-NTSTATUS ndr_pull_setup_relative_base_offset1(struct ndr_pull *ndr, const void *p, uint32_t offset)
+_PUBLIC_ enum ndr_err_code ndr_pull_setup_relative_base_offset1(struct ndr_pull *ndr, const void *p, uint32_t offset)
{
ndr->relative_base_offset = offset;
return ndr_token_store(ndr, &ndr->relative_base_list, p, offset);
setup the current base for relative pointers for the pull
called in the NDR_BUFFERS stage
*/
-NTSTATUS ndr_pull_setup_relative_base_offset2(struct ndr_pull *ndr, const void *p)
+_PUBLIC_ enum ndr_err_code ndr_pull_setup_relative_base_offset2(struct ndr_pull *ndr, const void *p)
{
return ndr_token_retrieve(&ndr->relative_base_list, p, &ndr->relative_base_offset);
}
pull a relative object - stage1
called during SCALARS processing
*/
-NTSTATUS ndr_pull_relative_ptr1(struct ndr_pull *ndr, const void *p, uint32_t rel_offset)
+_PUBLIC_ enum ndr_err_code ndr_pull_relative_ptr1(struct ndr_pull *ndr, const void *p, uint32_t rel_offset)
{
rel_offset += ndr->relative_base_offset;
if (rel_offset > ndr->data_size) {
pull a relative object - stage2
called during BUFFERS processing
*/
-NTSTATUS ndr_pull_relative_ptr2(struct ndr_pull *ndr, const void *p)
+_PUBLIC_ enum ndr_err_code ndr_pull_relative_ptr2(struct ndr_pull *ndr, const void *p)
{
uint32_t rel_offset;
NDR_CHECK(ndr_token_retrieve(&ndr->relative_list, p, &rel_offset));