parse_reg.c

来自「samba-3.0.22.tar.gz 编译smb服务器的源码」· C语言 代码 · 共 1,709 行 · 第 1/3 页

BOOL reg_io_q_restore_key(const char *desc,  REG_Q_RESTORE_KEY *q_u, prs_struct *ps, int depth)
{
	if ( !q_u )
		return False;

	prs_debug(ps, depth, desc, "reg_io_q_restore_key");
	depth++;

	if(!prs_align(ps))
		return False;

	if(!smb_io_pol_hnd("", &q_u->pol, ps, depth))
		return False;

	if(!prs_unistr4("filename", ps, depth, &q_u->filename))
		return False;

	if(!prs_uint32("flags", ps, depth, &q_u->flags))
		return False;

	return True;
}

/*******************************************************************
reads or writes a structure.
********************************************************************/

BOOL reg_io_r_restore_key(const char *desc,  REG_R_RESTORE_KEY *r_u, prs_struct *ps, int depth)
{
	if ( !r_u )
		return False;

	prs_debug(ps, depth, desc, "reg_io_r_restore_key");
	depth++;

	if(!prs_align(ps))
		return False;
	
	if(!prs_werror("status" , ps, depth, &r_u->status))
		return False;

	return True;
}

/*******************************************************************
********************************************************************/

void init_q_reg_save_key( REG_Q_SAVE_KEY *q_u, POLICY_HND *handle, const char *fname )
{
	memcpy(&q_u->pol, handle, sizeof(q_u->pol));
	init_unistr4( &q_u->filename, fname, UNI_STR_TERMINATE );
	q_u->sec_attr = NULL;
}

/*******************************************************************
reads or writes a structure.
********************************************************************/

BOOL reg_io_q_save_key(const char *desc,  REG_Q_SAVE_KEY *q_u, prs_struct *ps, int depth)
{
	if ( !q_u )
		return False;

	prs_debug(ps, depth, desc, "reg_io_q_save_key");
	depth++;

	if(!prs_align(ps))
		return False;

	if(!smb_io_pol_hnd("", &q_u->pol, ps, depth))
		return False;

	if(!prs_unistr4("filename", ps, depth, &q_u->filename))
		return False;

#if 0	/* reg_io_sec_attr() */
	if(!prs_uint32("unknown", ps, depth, &q_u->unknown))
		return False;
#endif

	return True;
}

/*******************************************************************
reads or writes a structure.
********************************************************************/

BOOL reg_io_r_save_key(const char *desc,  REG_R_SAVE_KEY *r_u, prs_struct *ps, int depth)
{
	if ( !r_u )
		return False;

	prs_debug(ps, depth, desc, "reg_io_r_save_key");
	depth++;

	if(!prs_align(ps))
		return False;
	
	if(!prs_werror("status" , ps, depth, &r_u->status))
		return False;

	return True;
}

/*******************************************************************
 Inits an REG_Q_CLOSE structure.
********************************************************************/

void init_reg_q_close(REG_Q_CLOSE *q_c, POLICY_HND *hnd)
{
	DEBUG(5,("init_reg_q_close\n"));

	memcpy(&q_c->pol, hnd, sizeof(q_c->pol));
}

/*******************************************************************
reads or writes a structure.
********************************************************************/

BOOL reg_io_q_close(const char *desc,  REG_Q_CLOSE *q_u, prs_struct *ps, int depth)
{
	if (q_u == NULL)
		return False;

	prs_debug(ps, depth, desc, "reg_io_q_close");
	depth++;

	if(!prs_align(ps))
		return False;

	if(!smb_io_pol_hnd("", &q_u->pol, ps, depth))
		return False;
	if(!prs_align(ps))
		return False;

	return True;
}

/*******************************************************************
reads or writes a structure.
********************************************************************/

BOOL reg_io_r_close(const char *desc,  REG_R_CLOSE *r_u, prs_struct *ps, int depth)
{
	if ( !r_u )
		return False;

	prs_debug(ps, depth, desc, "reg_io_r_close");
	depth++;

	if(!prs_align(ps))
		return False;

	if(!smb_io_pol_hnd("", &r_u->pol, ps, depth))
		return False;
	if(!prs_align(ps))
		return False;

	if(!prs_werror("status", ps, depth, &r_u->status))
		return False;

	return True;
}

/*******************************************************************
makes a structure.
********************************************************************/

void init_reg_q_set_key_sec(REG_Q_SET_KEY_SEC *q_u, POLICY_HND *pol,
                            uint32 sec_info, SEC_DESC_BUF *sec_desc_buf)
{
	memcpy(&q_u->handle, pol, sizeof(q_u->handle));

	q_u->sec_info = sec_info;

	q_u->ptr = 1;
	init_buf_hdr(&q_u->hdr_sec, sec_desc_buf->len, sec_desc_buf->len);
	q_u->data = sec_desc_buf;
}

/*******************************************************************
reads or writes a structure.
********************************************************************/

BOOL reg_io_q_set_key_sec(const char *desc,  REG_Q_SET_KEY_SEC *q_u, prs_struct *ps, int depth)
{
	if ( !q_u )
		return False;

	prs_debug(ps, depth, desc, "reg_io_q_set_key_sec");
	depth++;

	if(!prs_align(ps))
		return False;
	
	if(!smb_io_pol_hnd("", &q_u->handle, ps, depth))
		return False;

	if(!prs_uint32("sec_info", ps, depth, &q_u->sec_info))
		return False;
	if(!prs_uint32("ptr    ", ps, depth, &q_u->ptr))
		return False;

	if(!reg_io_hdrbuf_sec(q_u->ptr, NULL, &q_u->hdr_sec, q_u->data, ps, depth))
		return False;

	return True;
}

/*******************************************************************
reads or writes a structure.
********************************************************************/

BOOL reg_io_r_set_key_sec(const char *desc, REG_R_SET_KEY_SEC *q_u, prs_struct *ps, int depth)
{
	if ( !q_u )
		return False;

	prs_debug(ps, depth, desc, "reg_io_r_set_key_sec");
	depth++;

	if(!prs_align(ps))
		return False;
	
	if(!prs_werror("status", ps, depth, &q_u->status))
		return False;

	return True;
}


/*******************************************************************
makes a structure.
********************************************************************/

void init_reg_q_get_key_sec(REG_Q_GET_KEY_SEC *q_u, POLICY_HND *pol, 
                            uint32 sec_info, uint32 sec_buf_size,
                            SEC_DESC_BUF *psdb)
{
	memcpy(&q_u->handle, pol, sizeof(q_u->handle));

	q_u->sec_info = sec_info;

	q_u->ptr = psdb != NULL ? 1 : 0;
	q_u->data = psdb;

	init_buf_hdr(&q_u->hdr_sec, sec_buf_size, 0);
}

/*******************************************************************
reads or writes a structure.
********************************************************************/

BOOL reg_io_q_get_key_sec(const char *desc,  REG_Q_GET_KEY_SEC *q_u, prs_struct *ps, int depth)
{
	if ( !q_u )
		return False;

	prs_debug(ps, depth, desc, "reg_io_q_get_key_sec");
	depth++;

	if(!prs_align(ps))
		return False;
	
	if(!smb_io_pol_hnd("", &q_u->handle, ps, depth))
		return False;

	if(!prs_uint32("sec_info", ps, depth, &q_u->sec_info))
		return False;
	if(!prs_uint32("ptr     ", ps, depth, &q_u->ptr))
		return False;

	if(!reg_io_hdrbuf_sec(q_u->ptr, NULL, &q_u->hdr_sec, q_u->data, ps, depth))
		return False;

	return True;
}

#if 0
/*******************************************************************
makes a structure.
********************************************************************/
 void init_reg_r_get_key_sec(REG_R_GET_KEY_SEC *r_i, POLICY_HND *pol, 
				uint32 buf_len, uint8 *buf,
				NTSTATUS status)
{
	r_i->ptr = 1;
	init_buf_hdr(&r_i->hdr_sec, buf_len, buf_len);
	init_sec_desc_buf(r_i->data, buf_len, 1);

	r_i->status = status; /* 0x0000 0000 or 0x0000 007a */
}
#endif 

/*******************************************************************
reads or writes a structure.
********************************************************************/

BOOL reg_io_r_get_key_sec(const char *desc,  REG_R_GET_KEY_SEC *q_u, prs_struct *ps, int depth)
{
	if ( !q_u )
		return False;

	prs_debug(ps, depth, desc, "reg_io_r_get_key_sec");
	depth++;

	if(!prs_align(ps))
		return False;
	
	if(!prs_uint32("ptr      ", ps, depth, &q_u->ptr))
		return False;

	if (q_u->ptr != 0) {
		if(!smb_io_hdrbuf("", &q_u->hdr_sec, ps, depth))
			return False;
		if(!sec_io_desc_buf("", &q_u->data, ps, depth))
			return False;
		if(!prs_align(ps))
			return False;
	}

	if(!prs_werror("status", ps, depth, &q_u->status))
		return False;

	return True;
}

/*******************************************************************
makes a structure.
********************************************************************/

BOOL init_reg_q_query_value(REG_Q_QUERY_VALUE *q_u, POLICY_HND *pol, const char *val_name,
                     REGVAL_BUFFER *value_output)
{
        if (q_u == NULL)
                return False;

        q_u->pol = *pol;

        init_unistr4(&q_u->name, val_name, UNI_STR_TERMINATE);

        q_u->ptr_reserved = 1;
        q_u->ptr_buf = 1;

        q_u->ptr_bufsize = 1;
        q_u->bufsize = value_output->buf_max_len;
        q_u->buf_unk = 0;

        q_u->unk1 = 0;
        q_u->ptr_buflen = 1;
        q_u->buflen = value_output->buf_max_len; 

        q_u->ptr_buflen2 = 1;
        q_u->buflen2 = 0;

        return True;
}

/*******************************************************************
reads or writes a structure.
********************************************************************/

BOOL reg_io_q_query_value(const char *desc,  REG_Q_QUERY_VALUE *q_u, prs_struct *ps, int depth)
{
	if ( !q_u )
		return False;

	prs_debug(ps, depth, desc, "reg_io_q_query_value");
	depth++;

	if(!prs_align(ps))
		return False;
	
	if(!smb_io_pol_hnd("", &q_u->pol, ps, depth))
		return False;
	if(!prs_unistr4("name", ps, depth, &q_u->name))
		return False;

	if(!prs_align(ps))
		return False;
	
	if(!prs_uint32("ptr_reserved", ps, depth, &(q_u->ptr_reserved)))
		return False;

	if(!prs_uint32("ptr_buf", ps, depth, &(q_u->ptr_buf)))
		return False;

	if(q_u->ptr_buf) {
		if(!prs_uint32("ptr_bufsize", ps, depth, &(q_u->ptr_bufsize)))
			return False;
		if(!prs_uint32("bufsize", ps, depth, &(q_u->bufsize)))
			return False;
		if(!prs_uint32("buf_unk", ps, depth, &(q_u->buf_unk)))
			return False;
	}

	if(!prs_uint32("unk1", ps, depth, &(q_u->unk1)))
		return False;

	if(!prs_uint32("ptr_buflen", ps, depth, &(q_u->ptr_buflen)))
		return False;

	if (q_u->ptr_buflen) {
		if(!prs_uint32("buflen", ps, depth, &(q_u->buflen)))
			return False;
		if(!prs_uint32("ptr_buflen2", ps, depth, &(q_u->ptr_buflen2)))
			return False;
		if(!prs_uint32("buflen2", ps, depth, &(q_u->buflen2)))
			return False;
	}

 	return True;
}

/*******************************************************************
 Inits a structure.
 New version to replace older init_reg_r_query_value()
********************************************************************/

BOOL init_reg_r_query_value(uint32 include_keyval, REG_R_QUERY_VALUE *r_u,
		     REGISTRY_VALUE *val, WERROR status)
{
	uint32			buf_len = 0;
	REGVAL_BUFFER		buf2;
		
	if( !r_u || !val )
		return False;
	
	r_u->type = TALLOC_P( get_talloc_ctx(), uint32 );
	*r_u->type = val->type;

	buf_len = reg_init_regval_buffer( &buf2, val );
	
	r_u->buf_max_len = TALLOC_P( get_talloc_ctx(), uint32 );
	*r_u->buf_max_len = buf_len;

	r_u->buf_len = TALLOC_P( get_talloc_ctx(), uint32 );
	*r_u->buf_len = buf_len;
	
	/* if include_keyval is not set, don't send the key value, just
	   the buflen data. probably used by NT5 to allocate buffer space - SK */

	if ( include_keyval ) {
		r_u->value = TALLOC_P( get_talloc_ctx(), REGVAL_BUFFER );
		/* steal the memory */
		*r_u->value = buf2;
	}

	r_u->status = status;

	return True;
}

/*******************************************************************
reads or writes a structure.
********************************************************************/

BOOL reg_io_r_query_value(const char *desc, REG_R_QUERY_VALUE *r_u, prs_struct *ps, int depth)
{
	if ( !r_u )
		return False;

	prs_debug(ps, depth, desc, "reg_io_r_query_value");
	depth++;

	if(!prs_align(ps))
		return False;
	
	if ( !prs_pointer("type", ps, depth, (void**)&r_u->type, sizeof(uint32), (PRS_POINTER_CAST)prs_uint32))
		return False;

	if ( !prs_pointer("value", ps, depth, (void**)&r_u->value, sizeof(REGVAL_BUFFER), (PRS_POINTER_CAST)smb_io_regval_buffer))
		return False;
	if(!prs_align(ps))
		return False;

	if ( !prs_pointer("buf_max_len", ps, depth, (void**)&r_u->buf_max_len, sizeof(uint32), (PRS_POINTER_CAST)prs_uint32))
		return False;
	if ( !prs_pointer("buf_len", ps, depth, (void**)&r_u->buf_len, sizeof(uint32), (PRS_POINTER_CAST)prs_uint32))
		return False;

	if(!prs_werror("status", ps, depth, &r_u->status))
		return False;

 	return True;
}

/*******************************************************************
makes a structure.
********************************************************************/

void init_reg_q_enum_val(REG_Q_ENUM_VALUE *q_u, POLICY_HND *pol,
				uint32 val_idx,
				uint32 max_name_len, uint32 max_buf_len)
{
	ZERO_STRUCTP(q_u);

	memcpy(&q_u->pol, pol, sizeof(q_u->pol));

	q_u->val_index = val_idx;

	q_u->name.size = max_name_len*2;
	q_u->name.string = TALLOC_ZERO_P( get_talloc_ctx(), UNISTR2 );
	q_u->name.string->uni_max_len = max_name_len;
	
	q_u->type = TALLOC_P( get_talloc_ctx(), uint32 );
	*q_u->type = 0x0;

	q_u->value = TALLOC_ZERO_P( get_talloc_ctx(), REGVAL_BUFFER );
	q_u->value->buf_max_len = max_buf_len;

	q_u->buffer_len  = TALLOC_P( get_talloc_ctx(), uint32 );
	*q_u->buffer_len = max_buf_len;

	q_u->name_len  = TALLOC_P( get_talloc_ctx(), uint32 );
	*q_u->name_len = 0x0;
}

/*******************************************************************
makes a structure.
********************************************************************/

void init_reg_r_enum_val(REG_R_ENUM_VALUE *r_u, REGISTRY_VALUE *val )
{
	uint32 real_size;
	
	ZERO_STRUCTP(r_u);

	/* value name */

	DEBUG(10,("init_reg_r_enum_val: Valuename => [%s]\n", val->valuename));
	
	init_unistr4( &r_u->name, val->valuename, UNI_STR_TERMINATE);
		
	/* type */
	
	r_u->type = TALLOC_P( get_talloc_ctx(), uint32 );
	*r_u->type = val->type;

	/* REG_SZ & REG_MULTI_SZ must be converted to UNICODE */
	
	r_u->value = TALLOC_P( get_talloc_ctx(), REGVAL_BUFFER );
	real_size = reg_init_regval_buffer( r_u->value, val );
	
	/* lengths */

	r_u->buffer_len1  = TALLOC_P( get_talloc_ctx(), uint32 );
	*r_u->buffer_len1 = real_size;
	r_u->buffer_len2  = TALLOC_P( get_talloc_ctx(), uint32 );
	*r_u->buffer_len2 = real_size;
}

/*******************************************************************
reads or writes a structure.
********************************************************************/

BOOL reg_io_q_enum_val(const char *desc,  REG_Q_ENUM_VALUE *q_u, prs_struct *ps, int depth)
{
	if (q_u == NULL)
		return False;

	prs_debug(ps, depth, desc, "reg_io_q_enum_val");
	depth++;

	if(!prs_align(ps))
		return False;
	
	if(!smb_io_pol_hnd("", &q_u->pol, ps, depth))
		return False;