diff options
Diffstat (limited to 'source3/rpc_parse/parse_misc.c')
| -rw-r--r-- | source3/rpc_parse/parse_misc.c | 1834 |
1 files changed, 1834 insertions, 0 deletions
diff --git a/source3/rpc_parse/parse_misc.c b/source3/rpc_parse/parse_misc.c new file mode 100644 index 0000000000..cf989c8b5e --- /dev/null +++ b/source3/rpc_parse/parse_misc.c @@ -0,0 +1,1834 @@ +/* + * Unix SMB/CIFS implementation. + * RPC Pipe client / server routines + * Copyright (C) Andrew Tridgell 1992-1997, + * Copyright (C) Luke Kenneth Casson Leighton 1996-1997, + * Copyright (C) Paul Ashton 1997. + * Copyright (C) Gerald (Jerry) Carter 2005 + * + * 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 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * 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, see <http://www.gnu.org/licenses/>. + */ + +#include "includes.h" + +#undef DBGC_CLASS +#define DBGC_CLASS DBGC_RPC_PARSE + +/******************************************************************* + Reads or writes a UTIME type. +********************************************************************/ + +static bool smb_io_utime(const char *desc, UTIME *t, prs_struct *ps, int depth) +{ + if (t == NULL) + return False; + + prs_debug(ps, depth, desc, "smb_io_utime"); + depth++; + + if(!prs_align(ps)) + return False; + + if(!prs_uint32 ("time", ps, depth, &t->time)) + return False; + + return True; +} + +/******************************************************************* + Reads or writes an NTTIME structure. +********************************************************************/ + +bool smb_io_time(const char *desc, NTTIME *nttime, prs_struct *ps, int depth) +{ + uint32 low, high; + if (nttime == NULL) + return False; + + prs_debug(ps, depth, desc, "smb_io_time"); + depth++; + + if(!prs_align(ps)) + return False; + + if (MARSHALLING(ps)) { + low = *nttime & 0xFFFFFFFF; + high = *nttime >> 32; + } + + if(!prs_uint32("low ", ps, depth, &low)) /* low part */ + return False; + if(!prs_uint32("high", ps, depth, &high)) /* high part */ + return False; + + if (UNMARSHALLING(ps)) { + *nttime = (((uint64_t)high << 32) + low); + } + + return True; +} + +/******************************************************************* + Reads or writes an NTTIME structure. +********************************************************************/ + +bool smb_io_nttime(const char *desc, prs_struct *ps, int depth, NTTIME *nttime) +{ + return smb_io_time( desc, nttime, ps, depth ); +} + +/******************************************************************* + Gets an enumeration handle from an ENUM_HND structure. +********************************************************************/ + +uint32 get_enum_hnd(ENUM_HND *enh) +{ + return (enh && enh->ptr_hnd != 0) ? enh->handle : 0; +} + +/******************************************************************* + Inits an ENUM_HND structure. +********************************************************************/ + +void init_enum_hnd(ENUM_HND *enh, uint32 hnd) +{ + DEBUG(5,("smb_io_enum_hnd\n")); + + enh->ptr_hnd = (hnd != 0) ? 1 : 0; + enh->handle = hnd; +} + +/******************************************************************* + Reads or writes an ENUM_HND structure. +********************************************************************/ + +bool smb_io_enum_hnd(const char *desc, ENUM_HND *hnd, prs_struct *ps, int depth) +{ + if (hnd == NULL) + return False; + + prs_debug(ps, depth, desc, "smb_io_enum_hnd"); + depth++; + + if(!prs_align(ps)) + return False; + + if(!prs_uint32("ptr_hnd", ps, depth, &hnd->ptr_hnd)) /* pointer */ + return False; + + if (hnd->ptr_hnd != 0) { + if(!prs_uint32("handle ", ps, depth, &hnd->handle )) /* enum handle */ + return False; + } + + return True; +} + +/******************************************************************* + Reads or writes a DOM_SID structure. +********************************************************************/ + +bool smb_io_dom_sid(const char *desc, DOM_SID *sid, prs_struct *ps, int depth) +{ + int i; + + if (sid == NULL) + return False; + + prs_debug(ps, depth, desc, "smb_io_dom_sid"); + depth++; + + if(!prs_uint8 ("sid_rev_num", ps, depth, &sid->sid_rev_num)) + return False; + + if(!prs_uint8 ("num_auths ", ps, depth, &sid->num_auths)) + return False; + + for (i = 0; i < 6; i++) + { + fstring tmp; + slprintf(tmp, sizeof(tmp) - 1, "id_auth[%d] ", i); + if(!prs_uint8 (tmp, ps, depth, &sid->id_auth[i])) + return False; + } + + /* oops! XXXX should really issue a warning here... */ + if (sid->num_auths > MAXSUBAUTHS) + sid->num_auths = MAXSUBAUTHS; + + if(!prs_uint32s(False, "sub_auths ", ps, depth, sid->sub_auths, sid->num_auths)) + return False; + + return True; +} + +/******************************************************************* + Inits a DOM_SID2 structure. +********************************************************************/ + +void init_dom_sid2(DOM_SID2 *sid2, const DOM_SID *sid) +{ + sid2->sid = *sid; + sid2->num_auths = sid2->sid.num_auths; +} + +/******************************************************************* + Reads or writes a DOM_SID2 structure. +********************************************************************/ + +bool smb_io_dom_sid2_p(const char *desc, prs_struct *ps, int depth, DOM_SID2 **sid2) +{ + uint32 data_p; + + /* caputure the pointer value to stream */ + + data_p = *sid2 ? 0xf000baaa : 0; + + if ( !prs_uint32("dom_sid2_p", ps, depth, &data_p )) + return False; + + /* we're done if there is no data */ + + if ( !data_p ) + return True; + + if (UNMARSHALLING(ps)) { + if ( !(*sid2 = PRS_ALLOC_MEM(ps, DOM_SID2, 1)) ) + return False; + } + + return True; +} +/******************************************************************* + Reads or writes a DOM_SID2 structure. +********************************************************************/ + +bool smb_io_dom_sid2(const char *desc, DOM_SID2 *sid, prs_struct *ps, int depth) +{ + if (sid == NULL) + return False; + + prs_debug(ps, depth, desc, "smb_io_dom_sid2"); + depth++; + + if(!prs_align(ps)) + return False; + + if(!prs_uint32("num_auths", ps, depth, &sid->num_auths)) + return False; + + if(!smb_io_dom_sid("sid", &sid->sid, ps, depth)) + return False; + + return True; +} + +/******************************************************************* + Reads or writes a struct GUID +********************************************************************/ + +bool smb_io_uuid(const char *desc, struct GUID *uuid, + prs_struct *ps, int depth) +{ + if (uuid == NULL) + return False; + + prs_debug(ps, depth, desc, "smb_io_uuid"); + depth++; + + if(!prs_uint32 ("data ", ps, depth, &uuid->time_low)) + return False; + if(!prs_uint16 ("data ", ps, depth, &uuid->time_mid)) + return False; + if(!prs_uint16 ("data ", ps, depth, &uuid->time_hi_and_version)) + return False; + + if(!prs_uint8s (False, "data ", ps, depth, uuid->clock_seq, sizeof(uuid->clock_seq))) + return False; + if(!prs_uint8s (False, "data ", ps, depth, uuid->node, sizeof(uuid->node))) + return False; + + return True; +} + +/******************************************************************* +creates a STRHDR structure. +********************************************************************/ + +void init_str_hdr(STRHDR *hdr, int max_len, int len, uint32 buffer) +{ + hdr->str_max_len = max_len; + hdr->str_str_len = len; + hdr->buffer = buffer; +} + +/******************************************************************* + Reads or writes a STRHDR structure. +********************************************************************/ + +bool smb_io_strhdr(const char *desc, STRHDR *hdr, prs_struct *ps, int depth) +{ + if (hdr == NULL) + return False; + + prs_debug(ps, depth, desc, "smb_io_strhdr"); + depth++; + + if(!prs_align(ps)) + return False; + + if(!prs_uint16("str_str_len", ps, depth, &hdr->str_str_len)) + return False; + if(!prs_uint16("str_max_len", ps, depth, &hdr->str_max_len)) + return False; + if(!prs_uint32("buffer ", ps, depth, &hdr->buffer)) + return False; + + return True; +} + +/******************************************************************* + Inits a UNIHDR structure. +********************************************************************/ + +void init_uni_hdr(UNIHDR *hdr, UNISTR2 *str2) +{ + hdr->uni_str_len = 2 * (str2->uni_str_len); + hdr->uni_max_len = 2 * (str2->uni_max_len); + hdr->buffer = (str2->uni_str_len != 0) ? 1 : 0; +} + +/******************************************************************* + Reads or writes a UNIHDR structure. +********************************************************************/ + +bool smb_io_unihdr(const char *desc, UNIHDR *hdr, prs_struct *ps, int depth) +{ + if (hdr == NULL) + return False; + + prs_debug(ps, depth, desc, "smb_io_unihdr"); + depth++; + + if(!prs_align(ps)) + return False; + + if(!prs_uint16("uni_str_len", ps, depth, &hdr->uni_str_len)) + return False; + if(!prs_uint16("uni_max_len", ps, depth, &hdr->uni_max_len)) + return False; + if(!prs_uint32("buffer ", ps, depth, &hdr->buffer)) + return False; + + return True; +} + +/******************************************************************* + Inits a BUFHDR structure. +********************************************************************/ + +void init_buf_hdr(BUFHDR *hdr, int max_len, int len) +{ + hdr->buf_max_len = max_len; + hdr->buf_len = len; +} + +/******************************************************************* + prs_uint16 wrapper. Call this and it sets up a pointer to where the + uint16 should be stored, or gets the size if reading. + ********************************************************************/ + +bool smb_io_hdrbuf_pre(const char *desc, BUFHDR *hdr, prs_struct *ps, int depth, uint32 *offset) +{ + (*offset) = prs_offset(ps); + if (ps->io) { + + /* reading. */ + + if(!smb_io_hdrbuf(desc, hdr, ps, depth)) + return False; + + } else { + + /* writing. */ + + if(!prs_set_offset(ps, prs_offset(ps) + (sizeof(uint32) * 2))) + return False; + } + + return True; +} + +/******************************************************************* + smb_io_hdrbuf wrapper. Call this and it retrospectively stores the size. + Does nothing on reading, as that is already handled by ...._pre() + ********************************************************************/ + +bool smb_io_hdrbuf_post(const char *desc, BUFHDR *hdr, prs_struct *ps, int depth, + uint32 ptr_hdrbuf, uint32 max_len, uint32 len) +{ + if (!ps->io) { + /* writing: go back and do a retrospective job. i hate this */ + + uint32 old_offset = prs_offset(ps); + + init_buf_hdr(hdr, max_len, len); + if(!prs_set_offset(ps, ptr_hdrbuf)) + return False; + if(!smb_io_hdrbuf(desc, hdr, ps, depth)) + return False; + + if(!prs_set_offset(ps, old_offset)) + return False; + } + + return True; +} + +/******************************************************************* + Reads or writes a BUFHDR structure. +********************************************************************/ + +bool smb_io_hdrbuf(const char *desc, BUFHDR *hdr, prs_struct *ps, int depth) +{ + if (hdr == NULL) + return False; + + prs_debug(ps, depth, desc, "smb_io_hdrbuf"); + depth++; + + if(!prs_align(ps)) + return False; + + if(!prs_uint32("buf_max_len", ps, depth, &hdr->buf_max_len)) + return False; + if(!prs_uint32("buf_len ", ps, depth, &hdr->buf_len)) + return False; + + return True; +} + +/******************************************************************* + Inits a UNISTR structure. +********************************************************************/ + +void init_unistr(UNISTR *str, const char *buf) +{ + size_t len; + + if (buf == NULL) { + str->buffer = NULL; + return; + } + + len = rpcstr_push_talloc(talloc_tos(), &str->buffer, buf); + if (len == (size_t)-1) { + str->buffer = NULL; + } +} + +/******************************************************************* +reads or writes a UNISTR structure. +XXXX NOTE: UNISTR structures NEED to be null-terminated. +********************************************************************/ + +bool smb_io_unistr(const char *desc, UNISTR *uni, prs_struct *ps, int depth) +{ + if (uni == NULL) + return False; + + prs_debug(ps, depth, desc, "smb_io_unistr"); + depth++; + + if(!prs_unistr("unistr", ps, depth, uni)) + return False; + + return True; +} + +/******************************************************************* + Allocate the RPC_DATA_BLOB memory. +********************************************************************/ + +static void create_rpc_blob(RPC_DATA_BLOB *str, size_t len) +{ + if (len) { + str->buffer = (uint8 *)TALLOC_ZERO(talloc_tos(), len); + if (str->buffer == NULL) + smb_panic("create_rpc_blob: talloc fail"); + str->buf_len = len; + } else { + str->buffer = NULL; + str->buf_len = 0; + } +} + +/******************************************************************* + Inits a RPC_DATA_BLOB structure from a uint32 +********************************************************************/ + +void init_rpc_blob_uint32(RPC_DATA_BLOB *str, uint32 val) +{ + ZERO_STRUCTP(str); + + /* set up string lengths. */ + create_rpc_blob(str, sizeof(uint32)); + SIVAL(str->buffer, 0, val); +} + +/******************************************************************* + Inits a RPC_DATA_BLOB structure. +********************************************************************/ + +void init_rpc_blob_str(RPC_DATA_BLOB *str, const char *buf, int len) +{ + ZERO_STRUCTP(str); + + /* set up string lengths. */ + if (len) { + create_rpc_blob(str, len*2); + rpcstr_push(str->buffer, buf, (size_t)str->buf_len, STR_TERMINATE); + } +} + +/******************************************************************* + Inits a RPC_DATA_BLOB structure from a hex string. +********************************************************************/ + +void init_rpc_blob_hex(RPC_DATA_BLOB *str, const char *buf) +{ + ZERO_STRUCTP(str); + if (buf && *buf) { + size_t len = strlen(buf); + create_rpc_blob(str, len); + str->buf_len = strhex_to_str((char *)str->buffer, str->buf_len, + buf, len); + } +} + +/******************************************************************* + Inits a RPC_DATA_BLOB structure. +********************************************************************/ + +void init_rpc_blob_bytes(RPC_DATA_BLOB *str, uint8 *buf, size_t len) +{ + ZERO_STRUCTP(str); + + /* max buffer size (allocated size) */ + if (buf != NULL && len) { + create_rpc_blob(str, len); + memcpy(str->buffer, buf, len); + } + str->buf_len = len; +} + +/******************************************************************* +reads or writes a BUFFER5 structure. +the buf_len member tells you how large the buffer is. +********************************************************************/ +bool smb_io_buffer5(const char *desc, BUFFER5 *buf5, prs_struct *ps, int depth) +{ + prs_debug(ps, depth, desc, "smb_io_buffer5"); + depth++; + + if (buf5 == NULL) return False; + + if(!prs_align(ps)) + return False; + if(!prs_uint32("buf_len", ps, depth, &buf5->buf_len)) + return False; + + if(buf5->buf_len) { + if(!prs_buffer5(True, "buffer" , ps, depth, buf5)) + return False; + } + + return True; +} + +/******************************************************************* + Inits a REGVAL_BUFFER structure. +********************************************************************/ + +void init_regval_buffer(REGVAL_BUFFER *str, const uint8 *buf, size_t len) +{ + ZERO_STRUCTP(str); + + /* max buffer size (allocated size) */ + str->buf_max_len = len; + str->offset = 0; + str->buf_len = buf != NULL ? len : 0; + + if (buf != NULL) { + SMB_ASSERT(str->buf_max_len >= str->buf_len); + str->buffer = (uint16 *)TALLOC_ZERO(talloc_tos(), + str->buf_max_len); + if (str->buffer == NULL) + smb_panic("init_regval_buffer: talloc fail"); + memcpy(str->buffer, buf, str->buf_len); + } +} + +/******************************************************************* + Reads or writes a REGVAL_BUFFER structure. + the uni_max_len member tells you how large the buffer is. + the uni_str_len member tells you how much of the buffer is really used. +********************************************************************/ + +bool smb_io_regval_buffer(const char *desc, prs_struct *ps, int depth, REGVAL_BUFFER *buf2) +{ + + prs_debug(ps, depth, desc, "smb_io_regval_buffer"); + depth++; + + if(!prs_align(ps)) + return False; + + if(!prs_uint32("buf_max_len", ps, depth, &buf2->buf_max_len)) + return False; + if(!prs_uint32("offset ", ps, depth, &buf2->offset)) + return False; + if(!prs_uint32("buf_len ", ps, depth, &buf2->buf_len)) + return False; + + /* buffer advanced by indicated length of string + NOT by searching for null-termination */ + + if(!prs_regval_buffer(True, "buffer ", ps, depth, buf2)) + return False; + + return True; +} + +/******************************************************************* +creates a UNISTR2 structure: sets up the buffer, too +********************************************************************/ + +void init_buf_unistr2(UNISTR2 *str, uint32 *ptr, const char *buf) +{ + if (buf != NULL) { + *ptr = 1; + init_unistr2(str, buf, UNI_STR_TERMINATE); + } else { + *ptr = 0; + init_unistr2(str, NULL, UNI_FLAGS_NONE); + + } +} + +/******************************************************************* + Copies a UNISTR2 structure. +********************************************************************/ + +void copy_unistr2(UNISTR2 *str, const UNISTR2 *from) +{ + if (from->buffer == NULL) { + ZERO_STRUCTP(str); + return; + } + + SMB_ASSERT(from->uni_max_len >= from->uni_str_len); + + str->uni_max_len = from->uni_max_len; + str->offset = from->offset; + str->uni_str_len = from->uni_str_len; + + /* the string buffer is allocated to the maximum size + (the the length of the source string) to prevent + reallocation of memory. */ + if (str->buffer == NULL) { + if (str->uni_max_len) { + str->buffer = (uint16 *)TALLOC_ZERO_ARRAY(talloc_tos(), uint16, str->uni_max_len); + if ((str->buffer == NULL)) { + smb_panic("copy_unistr2: talloc fail"); + return; + } + /* copy the string */ + memcpy(str->buffer, from->buffer, str->uni_max_len*sizeof(uint16)); + } else { + str->buffer = NULL; + } + } +} + +/******************************************************************* + Creates a STRING2 structure. +********************************************************************/ + +void init_string2(STRING2 *str, const char *buf, size_t max_len, size_t str_len) +{ + /* set up string lengths. */ + SMB_ASSERT(max_len >= str_len); + + /* Ensure buf is valid if str_len was set. Coverity check. */ + if (str_len && !buf) { + return; + } + + str->str_max_len = max_len; + str->offset = 0; + str->str_str_len = str_len; + + /* store the string */ + if(str_len != 0) { + str->buffer = (uint8 *)TALLOC_ZERO(talloc_tos(), + str->str_max_len); + if (str->buffer == NULL) + smb_panic("init_string2: malloc fail"); + memcpy(str->buffer, buf, str_len); + } +} + +/******************************************************************* + Reads or writes a STRING2 structure. + XXXX NOTE: STRING2 structures need NOT be null-terminated. + the str_str_len member tells you how long the string is; + the str_max_len member tells you how large the buffer is. +********************************************************************/ + +bool smb_io_string2(const char *desc, STRING2 *str2, uint32 buffer, prs_struct *ps, int depth) +{ + if (str2 == NULL) + return False; + + if (buffer) { + + prs_debug(ps, depth, desc, "smb_io_string2"); + depth++; + + if(!prs_align(ps)) + return False; + + if(!prs_uint32("str_max_len", ps, depth, &str2->str_max_len)) + return False; + if(!prs_uint32("offset ", ps, depth, &str2->offset)) + return False; + if(!prs_uint32("str_str_len", ps, depth, &str2->str_str_len)) + return False; + + /* buffer advanced by indicated length of string + NOT by searching for null-termination */ + if(!prs_string2(True, "buffer ", ps, depth, str2)) + return False; + + } else { + + prs_debug(ps, depth, desc, "smb_io_string2 - NULL"); + depth++; + memset((char *)str2, '\0', sizeof(*str2)); + + } + + return True; +} + +/******************************************************************* + Inits a UNISTR2 structure. +********************************************************************/ + +void init_unistr2(UNISTR2 *str, const char *buf, enum unistr2_term_codes flags) +{ + size_t len = 0; + uint32 num_chars = 0; + + if (buf) { + /* We always null terminate the copy. */ + len = strlen(buf) + 1; + if ( flags == UNI_STR_DBLTERMINATE ) + len++; + } + + if (buf == NULL || len == 0) { + /* no buffer -- nothing to do */ + str->uni_max_len = 0; + str->offset = 0; + str->uni_str_len = 0; + + return; + } + + + str->buffer = TALLOC_ZERO_ARRAY(talloc_tos(), uint16, len); + if (str->buffer == NULL) { + smb_panic("init_unistr2: malloc fail"); + return; + } + + /* Ensure len is the length in *bytes* */ + len *= sizeof(uint16); + + /* + * The UNISTR2 must be initialized !!! + * jfm, 7/7/2001. + */ + if (buf) { + rpcstr_push((char *)str->buffer, buf, len, STR_TERMINATE); + num_chars = strlen_w(str->buffer); + if (flags == UNI_STR_TERMINATE || flags == UNI_MAXLEN_TERMINATE) { + num_chars++; + } + if ( flags == UNI_STR_DBLTERMINATE ) + num_chars += 2; + } + + str->uni_max_len = num_chars; + str->offset = 0; + str->uni_str_len = num_chars; + if ( num_chars && ((flags == UNI_MAXLEN_TERMINATE) || (flags == UNI_BROKEN_NON_NULL)) ) + str->uni_max_len++; +} + +/******************************************************************* + Inits a UNISTR4 structure. +********************************************************************/ + +void init_unistr4(UNISTR4 *uni4, const char *buf, enum unistr2_term_codes flags) +{ + uni4->string = TALLOC_P( talloc_tos(), UNISTR2 ); + if (!uni4->string) { + smb_panic("init_unistr4: talloc fail"); + return; + } + init_unistr2( uni4->string, buf, flags ); + + uni4->length = 2 * (uni4->string->uni_str_len); + uni4->size = 2 * (uni4->string->uni_max_len); +} + +void init_unistr4_w( TALLOC_CTX *ctx, UNISTR4 *uni4, const smb_ucs2_t *buf ) +{ + uni4->string = TALLOC_P( ctx, UNISTR2 ); + if (!uni4->string) { + smb_panic("init_unistr4_w: talloc fail"); + return; + } + init_unistr2_w( ctx, uni4->string, buf ); + + uni4->length = 2 * (uni4->string->uni_str_len); + uni4->size = 2 * (uni4->string->uni_max_len); +} + +/** + * Inits a UNISTR2 structure. + * @param ctx talloc context to allocate string on + * @param str pointer to string to create + * @param buf UCS2 null-terminated buffer to init from +*/ + +void init_unistr2_w(TALLOC_CTX *ctx, UNISTR2 *str, const smb_ucs2_t *buf) +{ + uint32 len = buf ? strlen_w(buf) : 0; + + ZERO_STRUCTP(str); + + /* set up string lengths. */ + str->uni_max_len = len; + str->offset = 0; + str->uni_str_len = len; + + if (len + 1) { + str->buffer = TALLOC_ZERO_ARRAY(ctx, uint16, len + 1); + if (str->buffer == NULL) { + smb_panic("init_unistr2_w: talloc fail"); + return; + } + } else { + str->buffer = NULL; + } + + /* + * don't move this test above ! The UNISTR2 must be initialized !!! + * jfm, 7/7/2001. + */ + if (buf==NULL) + return; + + /* Yes, this is a strncpy( foo, bar, strlen(bar)) - but as + long as the buffer above is talloc()ed correctly then this + is the correct thing to do */ + if (len+1) { + strncpy_w(str->buffer, buf, len + 1); + } +} + +/******************************************************************* + Inits a UNISTR2 structure from a UNISTR +********************************************************************/ + +void init_unistr2_from_unistr(TALLOC_CTX *ctx, UNISTR2 *to, const UNISTR *from) +{ + uint32 i; + + /* the destination UNISTR2 should never be NULL. + if it is it is a programming error */ + + /* if the source UNISTR is NULL, then zero out + the destination string and return */ + ZERO_STRUCTP (to); + if ((from == NULL) || (from->buffer == NULL)) + return; + + /* get the length; UNISTR must be NULL terminated */ + i = 0; + while ((from->buffer)[i]!='\0') + i++; + i++; /* one more to catch the terminating NULL */ + /* is this necessary -- jerry? I need to think */ + + /* set up string lengths; uni_max_len is set to i+1 + because we need to account for the final NULL termination */ + to->uni_max_len = i; + to->offset = 0; + to->uni_str_len = i; + + /* allocate the space and copy the string buffer */ + if (i) { + to->buffer = TALLOC_ZERO_ARRAY(ctx, uint16, i); + if (to->buffer == NULL) + smb_panic("init_unistr2_from_unistr: talloc fail"); + memcpy(to->buffer, from->buffer, i*sizeof(uint16)); + } else { + to->buffer = NULL; + } + return; +} + +/******************************************************************* + Inits a UNISTR2 structure from a DATA_BLOB. + The length of the data_blob must count the bytes of the buffer. + Copies the blob data. +********************************************************************/ + +void init_unistr2_from_datablob(UNISTR2 *str, DATA_BLOB *blob) +{ + /* Allocs the unistring */ + init_unistr2(str, NULL, UNI_FLAGS_NONE); + + /* Sets the values */ + str->uni_str_len = blob->length / sizeof(uint16); + str->uni_max_len = str->uni_str_len; + str->offset = 0; + if (blob->length) { + str->buffer = (uint16 *) memdup(blob->data, blob->length); + } else { + str->buffer = NULL; + } + if ((str->buffer == NULL) && (blob->length > 0)) { + smb_panic("init_unistr2_from_datablob: malloc fail"); + } +} + +/******************************************************************* + UNISTR2* are a little different in that the pointer and the UNISTR2 + are not necessarily read/written back to back. So we break it up + into 2 separate functions. + See SPOOL_USER_1 in include/rpc_spoolss.h for an example. +********************************************************************/ + +bool prs_io_unistr2_p(const char *desc, prs_struct *ps, int depth, UNISTR2 **uni2) +{ + uint32 data_p; + + /* caputure the pointer value to stream */ + + data_p = *uni2 ? 0xf000baaa : 0; + + if ( !prs_uint32("ptr", ps, depth, &data_p )) + return False; + + /* we're done if there is no data */ + + if ( !data_p ) + return True; + + if (UNMARSHALLING(ps)) { + if ( !(*uni2 = PRS_ALLOC_MEM(ps, UNISTR2, 1)) ) + return False; + } + + return True; +} + +/******************************************************************* + now read/write the actual UNISTR2. Memory for the UNISTR2 (but + not UNISTR2.buffer) has been allocated previously by prs_unistr2_p() +********************************************************************/ + +bool prs_io_unistr2(const char *desc, prs_struct *ps, int depth, UNISTR2 *uni2 ) +{ + /* just return true if there is no pointer to deal with. + the memory must have been previously allocated on unmarshalling + by prs_unistr2_p() */ + + if ( !uni2 ) + return True; + + /* just pass off to smb_io_unstr2() passing the uni2 address as + the pointer (like you would expect) */ + + return smb_io_unistr2( desc, uni2, uni2 ? 1 : 0, ps, depth ); +} + +/******************************************************************* + Reads or writes a UNISTR2 structure. + XXXX NOTE: UNISTR2 structures need NOT be null-terminated. + the uni_str_len member tells you how long the string is; + the uni_max_len member tells you how large the buffer is. +********************************************************************/ + +bool smb_io_unistr2(const char *desc, UNISTR2 *uni2, uint32 buffer, prs_struct *ps, int depth) +{ + if (uni2 == NULL) + return False; + + if (buffer) { + + prs_debug(ps, depth, desc, "smb_io_unistr2"); + depth++; + + if(!prs_align(ps)) + return False; + + if(!prs_uint32("uni_max_len", ps, depth, &uni2->uni_max_len)) + return False; + if(!prs_uint32("offset ", ps, depth, &uni2->offset)) + return False; + if(!prs_uint32("uni_str_len", ps, depth, &uni2->uni_str_len)) + return False; + + /* buffer advanced by indicated length of string + NOT by searching for null-termination */ + if(!prs_unistr2(True, "buffer ", ps, depth, uni2)) + return False; + + } else { + + prs_debug(ps, depth, desc, "smb_io_unistr2 - NULL"); + depth++; + memset((char *)uni2, '\0', sizeof(*uni2)); + + } + + return True; +} + +/******************************************************************* + now read/write UNISTR4 +********************************************************************/ + +bool prs_unistr4(const char *desc, prs_struct *ps, int depth, UNISTR4 *uni4) +{ + void *ptr; + prs_debug(ps, depth, desc, "prs_unistr4"); + depth++; + + if ( !prs_uint16("length", ps, depth, &uni4->length )) + return False; + if ( !prs_uint16("size", ps, depth, &uni4->size )) + return False; + + ptr = uni4->string; + + if ( !prs_pointer( desc, ps, depth, &ptr, sizeof(UNISTR2), (PRS_POINTER_CAST)prs_io_unistr2 ) ) + return False; + + uni4->string = (UNISTR2 *)ptr; + + return True; +} + +/******************************************************************* + now read/write UNISTR4 header +********************************************************************/ + +bool prs_unistr4_hdr(const char *desc, prs_struct *ps, int depth, UNISTR4 *uni4) +{ + prs_debug(ps, depth, desc, "prs_unistr4_hdr"); + depth++; + + if ( !prs_uint16("length", ps, depth, &uni4->length) ) + return False; + if ( !prs_uint16("size", ps, depth, &uni4->size) ) + return False; + if ( !prs_io_unistr2_p(desc, ps, depth, &uni4->string) ) + return False; + + return True; +} + +/******************************************************************* + now read/write UNISTR4 string +********************************************************************/ + +bool prs_unistr4_str(const char *desc, prs_struct *ps, int depth, UNISTR4 *uni4) +{ + prs_debug(ps, depth, desc, "prs_unistr4_str"); + depth++; + + if ( !prs_io_unistr2(desc, ps, depth, uni4->string) ) + return False; + + return True; +} + +/******************************************************************* + Reads or writes a UNISTR4_ARRAY structure. +********************************************************************/ + +bool prs_unistr4_array(const char *desc, prs_struct *ps, int depth, UNISTR4_ARRAY *array ) +{ + unsigned int i; + + prs_debug(ps, depth, desc, "prs_unistr4_array"); + depth++; + + if(!prs_uint32("count", ps, depth, &array->count)) + return False; + + if (UNMARSHALLING(ps)) { + if (array->count) { + if ( !(array->strings = TALLOC_ZERO_ARRAY( talloc_tos(), UNISTR4, array->count)) ) + return False; + } else { + array->strings = NULL; + } + } + + /* write the headers and then the actual string buffer */ + + for ( i=0; i<array->count; i++ ) { + if ( !prs_unistr4_hdr( "string", ps, depth, &array->strings[i]) ) + return False; + } + + for (i=0;i<array->count;i++) { + if ( !prs_unistr4_str("string", ps, depth, &array->strings[i]) ) + return False; + } + + return True; +} + +/******************************************************************** + initialise a UNISTR_ARRAY from a char** +********************************************************************/ + +bool init_unistr4_array( UNISTR4_ARRAY *array, uint32 count, const char **strings ) +{ + unsigned int i; + + array->count = count; + + /* allocate memory for the array of UNISTR4 objects */ + + if (array->count) { + if ( !(array->strings = TALLOC_ZERO_ARRAY(talloc_tos(), UNISTR4, count )) ) + return False; + } else { + array->strings = NULL; + } + + for ( i=0; i<count; i++ ) + init_unistr4( &array->strings[i], strings[i], UNI_STR_TERMINATE ); + + return True; +} + +/******************************************************************* + Inits a DOM_RID structure. +********************************************************************/ + +void init_dom_rid(DOM_RID *prid, uint32 rid, uint16 type, uint32 idx) +{ + prid->type = type; + prid->rid = rid; + prid->rid_idx = idx; +} + +/******************************************************************* + Reads or writes a DOM_RID structure. +********************************************************************/ + +bool smb_io_dom_rid(const char *desc, DOM_RID *rid, prs_struct *ps, int depth) +{ + if (rid == NULL) + return False; + + prs_debug(ps, depth, desc, "smb_io_dom_rid"); + depth++; + + if(!prs_align(ps)) + return False; + + if(!prs_uint16("type ", ps, depth, &rid->type)) + return False; + if(!prs_align(ps)) + return False; + if(!prs_uint32("rid ", ps, depth, &rid->rid)) + return False; + if(!prs_uint32("rid_idx", ps, depth, &rid->rid_idx)) + return False; + + return True; +} + +/******************************************************************* + Reads or writes a DOM_RID2 structure. +********************************************************************/ + +bool smb_io_dom_rid2(const char *desc, DOM_RID2 *rid, prs_struct *ps, int depth) +{ + if (rid == NULL) + return False; + + prs_debug(ps, depth, desc, "smb_io_dom_rid2"); + depth++; + + if(!prs_align(ps)) + return False; + + if(!prs_uint16("type ", ps, depth, &rid->type)) + return False; + if(!prs_align(ps)) + return False; + if(!prs_uint32("rid ", ps, depth, &rid->rid)) + return False; + if(!prs_uint32("rid_idx", ps, depth, &rid->rid_idx)) + return False; + if(!prs_uint32("unknown", ps, depth, &rid->unknown)) + return False; + + return True; +} + + +/******************************************************************* +creates a DOM_RID3 structure. +********************************************************************/ + +void init_dom_rid3(DOM_RID3 *rid3, uint32 rid, uint8 type) +{ + rid3->rid = rid; + rid3->type1 = type; + rid3->ptr_type = 0x1; /* non-zero, basically. */ + rid3->type2 = 0x1; + rid3->unk = type; +} + +/******************************************************************* +reads or writes a DOM_RID3 structure. +********************************************************************/ + +bool smb_io_dom_rid3(const char *desc, DOM_RID3 *rid3, prs_struct *ps, int depth) +{ + if (rid3 == NULL) + return False; + + prs_debug(ps, depth, desc, "smb_io_dom_rid3"); + depth++; + + if(!prs_align(ps)) + return False; + + if(!prs_uint32("rid ", ps, depth, &rid3->rid)) + return False; + if(!prs_uint32("type1 ", ps, depth, &rid3->type1)) + return False; + if(!prs_uint32("ptr_type", ps, depth, &rid3->ptr_type)) + return False; + if(!prs_uint32("type2 ", ps, depth, &rid3->type2)) + return False; + if(!prs_uint32("unk ", ps, depth, &rid3->unk)) + return False; + + return True; +} + +/******************************************************************* + Inits a DOM_RID4 structure. +********************************************************************/ + +void init_dom_rid4(DOM_RID4 *rid4, uint16 unknown, uint16 attr, uint32 rid) +{ + rid4->unknown = unknown; + rid4->attr = attr; + rid4->rid = rid; +} + +/******************************************************************* + Inits a DOM_CLNT_SRV structure. +********************************************************************/ + +void init_clnt_srv(DOM_CLNT_SRV *logcln, const char *logon_srv, + const char *comp_name) +{ + DEBUG(5,("init_clnt_srv: %d\n", __LINE__)); + + if (logon_srv != NULL) { + logcln->undoc_buffer = 1; + init_unistr2(&logcln->uni_logon_srv, logon_srv, UNI_STR_TERMINATE); + } else { + logcln->undoc_buffer = 0; + } + + if (comp_name != NULL) { + logcln->undoc_buffer2 = 1; + init_unistr2(&logcln->uni_comp_name, comp_name, UNI_STR_TERMINATE); + } else { + logcln->undoc_buffer2 = 0; + } +} + +/******************************************************************* + Inits or writes a DOM_CLNT_SRV structure. +********************************************************************/ + +bool smb_io_clnt_srv(const char *desc, DOM_CLNT_SRV *logcln, prs_struct *ps, int depth) +{ + if (logcln == NULL) + return False; + + prs_debug(ps, depth, desc, "smb_io_clnt_srv"); + depth++; + + if(!prs_align(ps)) + return False; + + if(!prs_uint32("undoc_buffer ", ps, depth, &logcln->undoc_buffer)) + return False; + + if (logcln->undoc_buffer != 0) { + if(!smb_io_unistr2("unistr2", &logcln->uni_logon_srv, logcln->undoc_buffer, ps, depth)) + return False; + } + + if(!prs_align(ps)) + return False; + + if(!prs_uint32("undoc_buffer2", ps, depth, &logcln->undoc_buffer2)) + return False; + + if (logcln->undoc_buffer2 != 0) { + if(!smb_io_unistr2("unistr2", &logcln->uni_comp_name, logcln->undoc_buffer2, ps, depth)) + return False; + } + + return True; +} + +/******************************************************************* + Inits a DOM_LOG_INFO structure. +********************************************************************/ + +void init_log_info(DOM_LOG_INFO *loginfo, const char *logon_srv, const char *acct_name, + uint16 sec_chan, const char *comp_name) +{ + DEBUG(5,("make_log_info %d\n", __LINE__)); + + loginfo->undoc_buffer = 1; + + init_unistr2(&loginfo->uni_logon_srv, logon_srv, UNI_STR_TERMINATE); + init_unistr2(&loginfo->uni_acct_name, acct_name, UNI_STR_TERMINATE); + + loginfo->sec_chan = sec_chan; + + init_unistr2(&loginfo->uni_comp_name, comp_name, UNI_STR_TERMINATE); +} + +/******************************************************************* + Reads or writes a DOM_LOG_INFO structure. +********************************************************************/ + +bool smb_io_log_info(const char *desc, DOM_LOG_INFO *loginfo, prs_struct *ps, int depth) +{ + if (loginfo == NULL) + return False; + + prs_debug(ps, depth, desc, "smb_io_log_info"); + depth++; + + if(!prs_align(ps)) + return False; + + if(!prs_uint32("undoc_buffer", ps, depth, &loginfo->undoc_buffer)) + return False; + + if(!smb_io_unistr2("unistr2", &loginfo->uni_logon_srv, True, ps, depth)) + return False; + if(!smb_io_unistr2("unistr2", &loginfo->uni_acct_name, True, ps, depth)) + return False; + + if(!prs_uint16("sec_chan", ps, depth, &loginfo->sec_chan)) + return False; + + if(!smb_io_unistr2("unistr2", &loginfo->uni_comp_name, True, ps, depth)) + return False; + + return True; +} + +/******************************************************************* + Reads or writes a DOM_CHAL structure. +********************************************************************/ + +bool smb_io_chal(const char *desc, DOM_CHAL *chal, prs_struct *ps, int depth) +{ + if (chal == NULL) + return False; + + prs_debug(ps, depth, desc, "smb_io_chal"); + depth++; + + if(!prs_uint8s (False, "data", ps, depth, chal->data, 8)) + return False; + + return True; +} + +/******************************************************************* + Reads or writes a DOM_CRED structure. +********************************************************************/ + +bool smb_io_cred(const char *desc, DOM_CRED *cred, prs_struct *ps, int depth) +{ + if (cred == NULL) + return False; + + prs_debug(ps, depth, desc, "smb_io_cred"); + depth++; + + if(!prs_align(ps)) + return False; + + if(!smb_io_chal ("", &cred->challenge, ps, depth)) + return False; + + if(!smb_io_utime("", &cred->timestamp, ps, depth)) + return False; + + return True; +} + +/******************************************************************* + Inits a DOM_CLNT_INFO2 structure. +********************************************************************/ + +void init_clnt_info2(DOM_CLNT_INFO2 *clnt, + const char *logon_srv, const char *comp_name, + const DOM_CRED *clnt_cred) +{ + DEBUG(5,("make_clnt_info: %d\n", __LINE__)); + + init_clnt_srv(&clnt->login, logon_srv, comp_name); + + if (clnt_cred != NULL) { + clnt->ptr_cred = 1; + memcpy(&clnt->cred, clnt_cred, sizeof(clnt->cred)); + } else { + clnt->ptr_cred = 0; + } +} + +/******************************************************************* + Reads or writes a DOM_CLNT_INFO2 structure. +********************************************************************/ + +bool smb_io_clnt_info2(const char *desc, DOM_CLNT_INFO2 *clnt, prs_struct *ps, int depth) +{ + if (clnt == NULL) + return False; + + prs_debug(ps, depth, desc, "smb_io_clnt_info2"); + depth++; + + if(!prs_align(ps)) + return False; + + if(!smb_io_clnt_srv("", &clnt->login, ps, depth)) + return False; + + if(!prs_align(ps)) + return False; + + if(!prs_uint32("ptr_cred", ps, depth, &clnt->ptr_cred)) + return False; + if(!smb_io_cred("", &clnt->cred, ps, depth)) + return False; + + return True; +} + +/******************************************************************* + Inits a DOM_CLNT_INFO structure. +********************************************************************/ + +void init_clnt_info(DOM_CLNT_INFO *clnt, + const char *logon_srv, const char *acct_name, + uint16 sec_chan, const char *comp_name, + const DOM_CRED *cred) +{ + DEBUG(5,("make_clnt_info\n")); + + init_log_info(&clnt->login, logon_srv, acct_name, sec_chan, comp_name); + memcpy(&clnt->cred, cred, sizeof(clnt->cred)); +} + +/******************************************************************* + Reads or writes a DOM_CLNT_INFO structure. +********************************************************************/ + +bool smb_io_clnt_info(const char *desc, DOM_CLNT_INFO *clnt, prs_struct *ps, int depth) +{ + if (clnt == NULL) + return False; + + prs_debug(ps, depth, desc, "smb_io_clnt_info"); + depth++; + + if(!prs_align(ps)) + return False; + + if(!smb_io_log_info("", &clnt->login, ps, depth)) + return False; + if(!smb_io_cred("", &clnt->cred, ps, depth)) + return False; + + return True; +} + +/******************************************************************* + Inits a DOM_LOGON_ID structure. +********************************************************************/ + +void init_logon_id(DOM_LOGON_ID *logonid, uint32 log_id_low, uint32 log_id_high) +{ + DEBUG(5,("make_logon_id: %d\n", __LINE__)); + + logonid->low = log_id_low; + logonid->high = log_id_high; +} + +/******************************************************************* + Reads or writes a DOM_LOGON_ID structure. +********************************************************************/ + +bool smb_io_logon_id(const char *desc, DOM_LOGON_ID *logonid, prs_struct *ps, int depth) +{ + if (logonid == NULL) + return False; + + prs_debug(ps, depth, desc, "smb_io_logon_id"); + depth++; + + if(!prs_align(ps)) + return False; + + if(!prs_uint32("low ", ps, depth, &logonid->low )) + return False; + if(!prs_uint32("high", ps, depth, &logonid->high)) + return False; + + return True; +} + +/******************************************************************* + Inits an OWF_INFO structure. +********************************************************************/ + +void init_owf_info(OWF_INFO *hash, const uint8 data[16]) +{ + DEBUG(5,("init_owf_info: %d\n", __LINE__)); + + if (data != NULL) + memcpy(hash->data, data, sizeof(hash->data)); + else + memset((char *)hash->data, '\0', sizeof(hash->data)); +} + +/******************************************************************* + Reads or writes an OWF_INFO structure. +********************************************************************/ + +bool smb_io_owf_info(const char *desc, OWF_INFO *hash, prs_struct *ps, int depth) +{ + if (hash == NULL) + return False; + + prs_debug(ps, depth, desc, "smb_io_owf_info"); + depth++; + + if(!prs_align(ps)) + return False; + + if(!prs_uint8s (False, "data", ps, depth, hash->data, 16)) + return False; + + return True; +} + +/******************************************************************* + Reads or writes a DOM_GID structure. +********************************************************************/ + +bool smb_io_gid(const char *desc, DOM_GID *gid, prs_struct *ps, int depth) +{ + if (gid == NULL) + return False; + + prs_debug(ps, depth, desc, "smb_io_gid"); + depth++; + + if(!prs_align(ps)) + return False; + + if(!prs_uint32("g_rid", ps, depth, &gid->g_rid)) + return False; + if(!prs_uint32("attr ", ps, depth, &gid->attr)) + return False; + + return True; +} + +/******************************************************************* + Reads or writes an POLICY_HND structure. +********************************************************************/ + +bool smb_io_pol_hnd(const char *desc, POLICY_HND *pol, prs_struct *ps, int depth) +{ + if (pol == NULL) + return False; + + prs_debug(ps, depth, desc, "smb_io_pol_hnd"); + depth++; + + if(!prs_align(ps)) + return False; + + if(UNMARSHALLING(ps)) + ZERO_STRUCTP(pol); + + if (!prs_uint32("handle_type", ps, depth, &pol->handle_type)) + return False; + if (!smb_io_uuid("uuid", (struct GUID*)&pol->uuid, ps, depth)) + return False; + + return True; +} + +/******************************************************************* + Create a UNISTR3. +********************************************************************/ + +void init_unistr3(UNISTR3 *str, const char *buf) +{ + if (buf == NULL) { + str->uni_str_len=0; + str->str.buffer = NULL; + return; + } + + str->uni_str_len = strlen(buf) + 1; + + if (str->uni_str_len) { + str->str.buffer = TALLOC_ZERO_ARRAY(talloc_tos(), uint16, str->uni_str_len); + if (str->str.buffer == NULL) + smb_panic("init_unistr3: malloc fail"); + + rpcstr_push((char *)str->str.buffer, buf, str->uni_str_len * sizeof(uint16), STR_TERMINATE); + } else { + str->str.buffer = NULL; + } +} + +/******************************************************************* + Reads or writes a UNISTR3 structure. +********************************************************************/ + +bool smb_io_unistr3(const char *desc, UNISTR3 *name, prs_struct *ps, int depth) +{ + if (name == NULL) + return False; + + prs_debug(ps, depth, desc, "smb_io_unistr3"); + depth++; + + if(!prs_align(ps)) + return False; + + if(!prs_uint32("uni_str_len", ps, depth, &name->uni_str_len)) + return False; + + /* we're done if there is no string */ + + if ( name->uni_str_len == 0 ) + return True; + + /* don't know if len is specified by uni_str_len member... */ + /* assume unicode string is unicode-null-terminated, instead */ + + if(!prs_unistr3(True, "unistr", name, ps, depth)) + return False; + + return True; +} + +/******************************************************************* + Stream a uint64_struct + ********************************************************************/ +bool prs_uint64(const char *name, prs_struct *ps, int depth, uint64 *data64) +{ + if (UNMARSHALLING(ps)) { + uint32 high, low; + + if (!prs_uint32(name, ps, depth+1, &low)) + return False; + + if (!prs_uint32(name, ps, depth+1, &high)) + return False; + + *data64 = ((uint64_t)high << 32) + low; + + return True; + } else { + uint32 high = (*data64) >> 32, low = (*data64) & 0xFFFFFFFF; + return prs_uint32(name, ps, depth+1, &low) && + prs_uint32(name, ps, depth+1, &high); + } +} + +/******************************************************************* +reads or writes a BUFHDR2 structure. +********************************************************************/ +bool smb_io_bufhdr2(const char *desc, BUFHDR2 *hdr, prs_struct *ps, int depth) +{ + prs_debug(ps, depth, desc, "smb_io_bufhdr2"); + depth++; + + if (!prs_align(ps)) + return False; + if (!prs_uint32("info_level", ps, depth, &(hdr->info_level))) + return False; + if (!prs_uint32("length ", ps, depth, &(hdr->length ))) + return False; + if (!prs_uint32("buffer ", ps, depth, &(hdr->buffer ))) + return False; + + return True; +} + +/******************************************************************* +reads or writes a BUFHDR4 structure. +********************************************************************/ +bool smb_io_bufhdr4(const char *desc, BUFHDR4 *hdr, prs_struct *ps, int depth) +{ + prs_debug(ps, depth, desc, "smb_io_bufhdr4"); + depth++; + + if (!prs_align(ps)) + return False; + if (!prs_uint32("size", ps, depth, &hdr->size)) + return False; + if (!prs_uint32("buffer", ps, depth, &hdr->buffer)) + return False; + + return True; +} + +/******************************************************************* +reads or writes a RPC_DATA_BLOB structure. +********************************************************************/ + +bool smb_io_rpc_blob(const char *desc, RPC_DATA_BLOB *blob, prs_struct *ps, int depth) +{ + prs_debug(ps, depth, desc, "smb_io_rpc_blob"); + depth++; + + if (!prs_align(ps)) + return False; + if ( !prs_uint32("buf_len", ps, depth, &blob->buf_len) ) + return False; + + if ( blob->buf_len == 0 ) + return True; + + if (UNMARSHALLING(ps)) { + blob->buffer = PRS_ALLOC_MEM(ps, uint8, blob->buf_len); + if (!blob->buffer) { + return False; + } + } + + if ( !prs_uint8s(True, "buffer", ps, depth, blob->buffer, blob->buf_len) ) + return False; + + return True; +} + +/******************************************************************* +creates a UNIHDR structure. +********************************************************************/ + +bool make_uni_hdr(UNIHDR *hdr, int len) +{ + if (hdr == NULL) + { + return False; + } + hdr->uni_str_len = 2 * len; + hdr->uni_max_len = 2 * len; + hdr->buffer = len != 0 ? 1 : 0; + + return True; +} + +/******************************************************************* +creates a BUFHDR2 structure. +********************************************************************/ +bool make_bufhdr2(BUFHDR2 *hdr, uint32 info_level, uint32 length, uint32 buffer) +{ + hdr->info_level = info_level; + hdr->length = length; + hdr->buffer = buffer; + + return True; +} + +/******************************************************************* +return the length of a UNISTR string. +********************************************************************/ + +uint32 str_len_uni(UNISTR *source) +{ + uint32 i=0; + + if (!source->buffer) + return 0; + + while (source->buffer[i]) + i++; + + return i; +} + +/******************************************************************* + Verifies policy handle +********************************************************************/ + +bool policy_handle_is_valid(const POLICY_HND *hnd) +{ + POLICY_HND zero_pol; + + ZERO_STRUCT(zero_pol); + return ((memcmp(&zero_pol, hnd, sizeof(POLICY_HND)) == 0) ? false : true ); +} |