#include "includes.h"
#include "regfio.h"
+#include "../librpc/gen_ndr/ndr_security.h"
+
+#undef DBGC_CLASS
+#define DBGC_CLASS DBGC_REGISTRY
/*******************************************************************
*
*
******************************************************************/
+#if defined(PARANOID_MALLOC_CHECKER)
+#define PRS_ALLOC_MEM(ps, type, count) (type *)prs_alloc_mem_((ps),sizeof(type),(count))
+#else
+#define PRS_ALLOC_MEM(ps, type, count) (type *)prs_alloc_mem((ps),sizeof(type),(count))
+#endif
+
+/*******************************************************************
+ Reads or writes an NTTIME structure.
+********************************************************************/
+
+static 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;
+}
/*******************************************************************
*******************************************************************/
/* check for end of file */
- if ( sys_fstat( file->fd, &sbuf ) ) {
+ if (sys_fstat(file->fd, &sbuf, false)) {
DEBUG(0,("write_block: stat() failed! (%s)\n", strerror(errno)));
return -1;
}
/* check for end of file */
- if ( sys_fstat( file->fd, &sbuf ) ) {
+ if (sys_fstat(file->fd, &sbuf, false)) {
DEBUG(0,("read_block: stat() failed! (%s)\n", strerror(errno)));
return -1;
}
- if ( (size_t)file_offset >= sbuf.st_size )
+ if ( (size_t)file_offset >= sbuf.st_ex_size )
return -1;
/* if block_size == 0, we are parsing HBIN records and need
return -1;
}
- prs_init( ps, block_size, file->mem_ctx, UNMARSHALL );
+ if (!prs_init( ps, block_size, file->mem_ctx, UNMARSHALL )) {
+ DEBUG(0,("read_block: prs_init() failed! (%s)\n", strerror(errno) ));
+ return -1;
+ }
buffer = prs_data_p( ps );
bytes_read = returned = 0;
/*******************************************************************
*******************************************************************/
-static BOOL write_hbin_block( REGF_FILE *file, REGF_HBIN *hbin )
+static bool write_hbin_block( REGF_FILE *file, REGF_HBIN *hbin )
{
if ( !hbin->dirty )
return True;
/*******************************************************************
*******************************************************************/
-static BOOL hbin_block_close( REGF_FILE *file, REGF_HBIN *hbin )
+static bool hbin_block_close( REGF_FILE *file, REGF_HBIN *hbin )
{
REGF_HBIN *p;
/*******************************************************************
*******************************************************************/
-static BOOL prs_regf_block( const char *desc, prs_struct *ps, int depth, REGF_FILE *file )
+static bool prs_regf_block( const char *desc, prs_struct *ps, int depth, REGF_FILE *file )
{
prs_debug(ps, depth, desc, "prs_regf_block");
depth++;
/*******************************************************************
*******************************************************************/
-static BOOL prs_hbin_block( const char *desc, prs_struct *ps, int depth, REGF_HBIN *hbin )
+static bool prs_hbin_block( const char *desc, prs_struct *ps, int depth, REGF_HBIN *hbin )
{
uint32 block_size2;
/*******************************************************************
*******************************************************************/
-static BOOL prs_nk_rec( const char *desc, prs_struct *ps, int depth, REGF_NK_REC *nk )
+static bool prs_nk_rec( const char *desc, prs_struct *ps, int depth, REGF_NK_REC *nk )
{
uint16 class_length, name_length;
uint32 start;
/*******************************************************************
*******************************************************************/
-static BOOL read_regf_block( REGF_FILE *file )
+static bool read_regf_block( REGF_FILE *file )
{
prs_struct ps;
uint32 checksum;
block for it
*******************************************************************/
-static BOOL hbin_contains_offset( REGF_HBIN *hbin, uint32 offset )
+static bool hbin_contains_offset( REGF_HBIN *hbin, uint32 offset )
{
if ( !hbin )
return False;
/*******************************************************************
*******************************************************************/
-static BOOL prs_hash_rec( const char *desc, prs_struct *ps, int depth, REGF_HASH_REC *hash )
+static bool prs_hash_rec( const char *desc, prs_struct *ps, int depth, REGF_HASH_REC *hash )
{
prs_debug(ps, depth, desc, "prs_hash_rec");
depth++;
/*******************************************************************
*******************************************************************/
-static BOOL hbin_prs_lf_records( const char *desc, REGF_HBIN *hbin, int depth, REGF_NK_REC *nk )
+static bool hbin_prs_lf_records( const char *desc, REGF_HBIN *hbin, int depth, REGF_NK_REC *nk )
{
int i;
REGF_LF_REC *lf = &nk->subkeys;
/*******************************************************************
*******************************************************************/
-static BOOL hbin_prs_sk_rec( const char *desc, REGF_HBIN *hbin, int depth, REGF_SK_REC *sk )
+static bool hbin_prs_sk_rec( const char *desc, REGF_HBIN *hbin, int depth, REGF_SK_REC *sk )
{
prs_struct *ps = &hbin->ps;
uint16 tag = 0xFFFF;
if ( !prs_uint32( "size", ps, depth, &sk->size))
return False;
- if ( !sec_io_desc( "sec_desc", &sk->sec_desc, ps, depth ))
- return False;
+ {
+ NTSTATUS status;
+ TALLOC_CTX *mem_ctx = prs_get_mem_context(&hbin->ps);
+ DATA_BLOB blob;
+
+ if (MARSHALLING(&hbin->ps)) {
+ status = marshall_sec_desc(mem_ctx,
+ sk->sec_desc,
+ &blob.data, &blob.length);
+ if (!NT_STATUS_IS_OK(status))
+ return False;
+ if (!prs_copy_data_in(&hbin->ps, (const char *)blob.data, blob.length))
+ return False;
+ } else {
+ blob = data_blob_const(prs_data_p(&hbin->ps),
+ prs_data_size(&hbin->ps));
+ status = unmarshall_sec_desc(mem_ctx,
+ blob.data, blob.length,
+ &sk->sec_desc);
+ if (!NT_STATUS_IS_OK(status))
+ return False;
+ prs_set_offset(&hbin->ps, blob.length);
+ }
+ }
end_off = prs_offset( &hbin->ps );
/*******************************************************************
*******************************************************************/
-static BOOL hbin_prs_vk_rec( const char *desc, REGF_HBIN *hbin, int depth, REGF_VK_REC *vk, REGF_FILE *file )
+static bool hbin_prs_vk_rec( const char *desc, REGF_HBIN *hbin, int depth, REGF_VK_REC *vk, REGF_FILE *file )
{
uint32 offset;
uint16 name_length;
/* get the data if necessary */
if ( vk->data_size != 0 ) {
- BOOL charmode = False;
+ bool charmode = False;
if ( (vk->type == REG_SZ) || (vk->type == REG_MULTI_SZ) )
charmode = True;
in the prs_struct *ps.
*******************************************************************/
-static BOOL hbin_prs_vk_records( const char *desc, REGF_HBIN *hbin, int depth, REGF_NK_REC *nk, REGF_FILE *file )
+static bool hbin_prs_vk_records( const char *desc, REGF_HBIN *hbin, int depth, REGF_NK_REC *nk, REGF_FILE *file )
{
int i;
uint32 record_size;
/*******************************************************************
*******************************************************************/
-static REGF_SK_REC* find_sk_record_by_sec_desc( REGF_FILE *file, SEC_DESC *sd )
+static REGF_SK_REC* find_sk_record_by_sec_desc( REGF_FILE *file, struct security_descriptor *sd )
{
REGF_SK_REC *p;
for ( p=file->sec_desc_list; p; p=p->next ) {
- if ( sec_desc_equal( p->sec_desc, sd ) )
+ if ( security_descriptor_equal( p->sec_desc, sd ) )
return p;
}
/*******************************************************************
*******************************************************************/
-static BOOL hbin_prs_key( REGF_FILE *file, REGF_HBIN *hbin, REGF_NK_REC *nk )
+static bool hbin_prs_key( REGF_FILE *file, REGF_HBIN *hbin, REGF_NK_REC *nk )
{
int depth = 0;
REGF_HBIN *sub_hbin;
/*******************************************************************
*******************************************************************/
-static BOOL next_record( REGF_HBIN *hbin, const char *hdr, BOOL *eob )
+static bool next_record( REGF_HBIN *hbin, const char *hdr, bool *eob )
{
uint8 header[REC_HDR_SIZE];
uint32 record_size;
uint32 curr_off, block_size;
- BOOL found = False;
+ bool found = False;
prs_struct *ps = &hbin->ps;
curr_off = prs_offset( ps );
/*******************************************************************
*******************************************************************/
-static BOOL next_nk_record( REGF_FILE *file, REGF_HBIN *hbin, REGF_NK_REC *nk, BOOL *eob )
+static bool next_nk_record( REGF_FILE *file, REGF_HBIN *hbin, REGF_NK_REC *nk, bool *eob )
{
if ( next_record( hbin, "nk", eob ) && hbin_prs_key( file, hbin, nk ) )
return True;
block header to disk
*******************************************************************/
-static BOOL init_regf_block( REGF_FILE *file )
+static bool init_regf_block( REGF_FILE *file )
{
prs_struct ps;
- BOOL result = True;
+ bool result = True;
if ( !prs_init( &ps, REGF_BLOCKSIZE, file->mem_ctx, MARSHALL ) )
return False;
/* cleanup for a file opened for write */
- if ( file->open_flags & (O_WRONLY|O_RDWR) ) {
+ if ((file->fd != -1) && (file->open_flags & (O_WRONLY|O_RDWR))) {
prs_struct ps;
REGF_SK_REC *sk;
/* nothing tdo do if there is no open file */
- if ( !file || (file->fd == -1) )
+ if (file->fd == -1)
return 0;
fd = file->fd;
REGF_NK_REC *nk;
REGF_HBIN *hbin;
uint32 offset = REGF_BLOCKSIZE;
- BOOL found = False;
- BOOL eob;
+ bool found = False;
+ bool eob;
if ( !file )
return NULL;
memcpy( hbin->header, "hbin", sizeof(HBIN_HDR_SIZE) );
- if ( sys_fstat( file->fd, &sbuf ) ) {
+ if (sys_fstat(file->fd, &sbuf, false)) {
DEBUG(0,("regf_hbin_allocate: stat() failed! (%s)\n", strerror(errno)));
return NULL;
}
- hbin->file_off = sbuf.st_size;
+ hbin->file_off = sbuf.st_ex_size;
hbin->free_off = HBIN_HEADER_REC_SIZE;
- hbin->free_size = block_size - hbin->free_off + sizeof(uint32);;
+ hbin->free_size = block_size - hbin->free_off + sizeof(uint32);
hbin->block_size = block_size;
hbin->first_hbin_off = hbin->file_off - REGF_BLOCKSIZE;
{
REGF_HBIN *hbin, *p_hbin;
uint32 block_off;
- BOOL cached;
+ bool cached;
/* check open block list */
/*******************************************************************
*******************************************************************/
-static uint32 sk_record_data_size( SEC_DESC * sd )
+static uint32 sk_record_data_size( struct security_descriptor * sd )
{
uint32 size, size_mod8;
/* the record size is sizeof(hdr) + name + static members + data_size_field */
- size = sizeof(uint32)*5 + sec_desc_size( sd ) + sizeof(uint32);
+ size = sizeof(uint32)*5 + ndr_size_security_descriptor(sd, 0) + sizeof(uint32);
/* multiple of 8 */
size_mod8 = size & 0xfffffff8;
/*******************************************************************
*******************************************************************/
-static BOOL create_vk_record( REGF_FILE *file, REGF_VK_REC *vk, REGISTRY_VALUE *value )
+static bool create_vk_record(REGF_FILE *file, REGF_VK_REC *vk,
+ struct regval_blob *value)
{
char *name = regval_name(value);
REGF_HBIN *data_hbin;
/*******************************************************************
*******************************************************************/
- REGF_NK_REC* regfio_write_key( REGF_FILE *file, const char *name,
- REGVAL_CTR *values, REGSUBKEY_CTR *subkeys,
- SEC_DESC *sec_desc, REGF_NK_REC *parent )
+ REGF_NK_REC* regfio_write_key( REGF_FILE *file, const char *name,
+ struct regval_ctr *values, struct regsubkey_ctr *subkeys,
+ struct security_descriptor *sec_desc, REGF_NK_REC *parent )
{
REGF_NK_REC *nk;
REGF_HBIN *vlist_hbin = NULL;
parent->subkey_index++;
/* sort the list by keyname */
-
- qsort( parent->subkeys.hashes, parent->subkey_index, sizeof(REGF_HASH_REC), QSORT_CAST hashrec_cmp );
+ TYPESAFE_QSORT(parent->subkeys.hashes, parent->subkey_index, hashrec_cmp);
if ( !hbin_prs_lf_records( "lf_rec", parent->subkeys.hbin, 0, parent ) )
return False;
nk->sec_desc->ref_count = 0;
/* size value must be self-inclusive */
- nk->sec_desc->size = sec_desc_size(sec_desc) + sizeof(uint32);
+ nk->sec_desc->size = ndr_size_security_descriptor(sec_desc, 0)
+ + sizeof(uint32);
DLIST_ADD_END( file->sec_desc_list, nk->sec_desc, REGF_SK_REC *);
if this is the first record, then just set the next and prev
offsets to ourself. */
- if ( nk->sec_desc->prev ) {
- REGF_SK_REC *prev = nk->sec_desc->prev;
+ if ( DLIST_PREV(nk->sec_desc) ) {
+ REGF_SK_REC *prev = DLIST_PREV(nk->sec_desc);
nk->sec_desc->prev_sk_off = prev->hbin_off + prev->hbin->first_hbin_off - HBIN_HDR_SIZE;
prev->next_sk_off = nk->sec_desc->sk_off;
for ( i=0; i<nk->num_values; i++ ) {
uint32 vk_size, namelen, datalen;
- REGISTRY_VALUE *r;
+ struct regval_blob *r;
r = regval_ctr_specific_value( values, i );
create_vk_record( file, &nk->values[i], r );
git.samba.org / amitay / samba.git / blobdiff