void init_rpc_blob_str(RPC_DATA_BLOB *str, const char *buf, int len)
{
ZERO_STRUCTP(str);
/* set up string lengths. */
str->buf_len = create_rpc_blob(str, len*2);
rpcstr_push(str->buffer, buf, (size_t)str->buf_len, STR_TERMINATE);
}
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++;
} else {
/* no buffer -- nothing to do */
str->uni_max_len = 0;
str->offset = 0;
str->uni_str_len = 0;
return;
}
str->buffer = TALLOC_ZERO_ARRAY(get_talloc_ctx(), uint16, len);
if (str->buffer == NULL) {
smb_panic("init_unistr2: malloc fail\n");
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++;
}
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;
str->str.buffer = TALLOC_ZERO_ARRAY(get_talloc_ctx(), uint16, str->uni_str_len);
if (str->str.buffer == NULL)
smb_panic("init_unistr3: malloc fail\n");
rpcstr_push((char *)str->str.buffer, buf, str->uni_str_len * sizeof(uint16), STR_TERMINATE);
}
void init_unistr(UNISTR *str, const char *buf)
{
size_t len;
if (buf == NULL) {
str->buffer = NULL;
return;
}
len = strlen(buf) + 1;
str->buffer = TALLOC_ZERO_ARRAY(get_talloc_ctx(), uint16, len);
if (str->buffer == NULL)
smb_panic("init_unistr: malloc fail\n");
rpcstr_push(str->buffer, buf, len*sizeof(uint16), STR_TERMINATE);
}
RPC_DATA_BLOB *cac_MakeRpcDataBlob( TALLOC_CTX * mem_ctx, uint32 data_type,
REG_VALUE_DATA data )
{
RPC_DATA_BLOB *blob = NULL;
int i;
uint32 size = 0;
uint8 *multi = NULL;
uint32 multi_idx = 0;
blob = talloc( mem_ctx, RPC_DATA_BLOB );
if ( !blob ) {
errno = ENOMEM;
return NULL;
}
switch ( data_type ) {
case REG_SZ:
init_rpc_blob_str( blob, data.reg_sz,
strlen( data.reg_sz ) + 1 );
break;
case REG_EXPAND_SZ:
init_rpc_blob_str( blob, data.reg_expand_sz,
strlen( data.reg_sz ) + 1 );
break;
case REG_BINARY:
init_rpc_blob_bytes( blob, data.reg_binary.data,
data.reg_binary.data_length );
break;
case REG_DWORD:
init_rpc_blob_uint32( blob, data.reg_dword );
break;
case REG_DWORD_BE:
init_rpc_blob_uint32( blob, data.reg_dword_be );
break;
case REG_MULTI_SZ:
/*need to find the size */
for ( i = 0; i < data.reg_multi_sz.num_strings; i++ ) {
size += strlen( data.reg_multi_sz.strings[i] ) + 1;
}
/**need a whole bunch of unicode strings in a row (seperated by null characters), with an extra null-character on the end*/
multi = TALLOC_ZERO_ARRAY( mem_ctx, uint8, ( size + 1 ) * 2 ); /*size +1 for the extra null character */
if ( !multi ) {
errno = ENOMEM;
break;
}
/*do it using rpcstr_push() */
multi_idx = 0;
for ( i = 0; i < data.reg_multi_sz.num_strings; i++ ) {
size_t len =
strlen( data.reg_multi_sz.strings[i] ) + 1;
rpcstr_push( ( multi + multi_idx ),
data.reg_multi_sz.strings[i], len * 2,
STR_TERMINATE );
/* x2 becuase it is a uint8 buffer */
multi_idx += len * 2;
}
/*now initialize the buffer as binary data */
init_rpc_blob_bytes( blob, multi, ( size + 1 ) * 2 );
break;
default:
TALLOC_FREE( blob );
blob = NULL;
return NULL;
}
if ( !( blob->buffer ) ) {
TALLOC_FREE( blob );
return NULL;
}
return blob;
}
