parse_reg.c

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

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

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

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

	if(!prs_pointer("buffer_len", ps, depth, (void**)&q_u->buffer_len, sizeof(uint32), (PRS_POINTER_CAST)prs_uint32))
		return False;
	if(!prs_pointer("name_len", ps, depth, (void**)&q_u->name_len, sizeof(uint32), (PRS_POINTER_CAST)prs_uint32))
		return False;

	return True;
}

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

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

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

	if(!prs_align(ps))
		return False;
	
	if(!prs_unistr4("name", ps, depth, &r_u->name ))
		return False;
	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("buffer_len1", ps, depth, (void**)&r_u->buffer_len1, sizeof(uint32), (PRS_POINTER_CAST)prs_uint32))
		return False;
	if(!prs_pointer("buffer_len2", ps, depth, (void**)&r_u->buffer_len2, 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_set_val(REG_Q_SET_VALUE *q_u, POLICY_HND *pol,
				char *val_name, uint32 type,
				RPC_DATA_BLOB *val)
{
	ZERO_STRUCTP(q_u);

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

	init_unistr4(&q_u->name, val_name, UNI_STR_TERMINATE);
	
	q_u->type      = type;
	q_u->value     = *val;
	q_u->size      = val->buf_len;
}

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

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

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

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

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

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

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

	return True;
}

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

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

	prs_debug(ps, depth, desc, "reg_io_r_set_value");
	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_enum_key(REG_Q_ENUM_KEY *q_u, POLICY_HND *pol, uint32 key_idx)
{
	memcpy(&q_u->pol, pol, sizeof(q_u->pol));

	q_u->key_index = key_idx;
	q_u->key_name_len = 0;
	q_u->unknown_1 = 0x0414;

	q_u->ptr1 = 1;
	q_u->unknown_2 = 0x0000020A;
	memset(q_u->pad1, 0, sizeof(q_u->pad1));

	q_u->ptr2 = 1;
	memset(q_u->pad2, 0, sizeof(q_u->pad2));

	q_u->ptr3 = 1;
	unix_to_nt_time(&q_u->time, 0);            /* current time? */
}

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

void init_reg_r_enum_key(REG_R_ENUM_KEY *r_u, char *subkey )
{
	if ( !r_u )
		return;
		
	init_unistr4( &r_u->keyname, subkey, UNI_STR_TERMINATE );
	r_u->classname = TALLOC_ZERO_P( get_talloc_ctx(), UNISTR4 );
	r_u->time       = TALLOC_ZERO_P( get_talloc_ctx(), NTTIME );
}

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

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

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

	if(!prs_align(ps))
		return False;
	
	if(!smb_io_pol_hnd("", &q_u->pol, ps, depth))
		return False;
	
	if(!prs_uint32("key_index", ps, depth, &q_u->key_index))
		return False;
	if(!prs_uint16("key_name_len", ps, depth, &q_u->key_name_len))
		return False;
	if(!prs_uint16("unknown_1", ps, depth, &q_u->unknown_1))
		return False;

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

	if (q_u->ptr1 != 0) {
		if(!prs_uint32("unknown_2", ps, depth, &q_u->unknown_2))
			return False;
		if(!prs_uint8s(False, "pad1", ps, depth, q_u->pad1, sizeof(q_u->pad1)))
			return False;
	}

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

	if (q_u->ptr2 != 0) {
		if(!prs_uint8s(False, "pad2", ps, depth, q_u->pad2, sizeof(q_u->pad2)))
			return False;
	}

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

	if (q_u->ptr3 != 0) {
		if(!smb_io_time("", &q_u->time, ps, depth))
			return False;
	}

	return True;
}

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

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

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

	if(!prs_align(ps))
		return False;
	if ( !prs_unistr4( "keyname", ps, depth, &q_u->keyname ) )
		return False;
	
	if(!prs_align(ps))
		return False;
	if (!prs_pointer("class", ps, depth, (void**)&q_u->classname, sizeof(UNISTR4), (PRS_POINTER_CAST)prs_unistr4))
		return False;

	if(!prs_align(ps))
		return False;
	if (!prs_pointer("time", ps, depth, (void**)&q_u->time, sizeof(NTTIME), (PRS_POINTER_CAST)smb_io_nttime))
		return False;

	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_open_entry(REG_Q_OPEN_ENTRY *q_u, POLICY_HND *pol,
				char *key_name, uint32 access_desired)
{
	memcpy(&q_u->pol, pol, sizeof(q_u->pol));

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

	q_u->unknown_0 = 0x00000000;
	q_u->access = access_desired;
}

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

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

	prs_debug(ps, depth, desc, "reg_io_q_open_entry");
	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("unknown_0        ", ps, depth, &q_u->unknown_0))
		return False;
	if(!prs_uint32("access", ps, depth, &q_u->access))
		return False;

	return True;
}

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

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

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

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

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

	return True;
}

/*******************************************************************
Inits a structure.
********************************************************************/

void init_reg_q_shutdown(REG_Q_SHUTDOWN *q_u, const char *msg,
			uint32 timeout, BOOL do_reboot, BOOL force)
{
	q_u->server = TALLOC_P( get_talloc_ctx(), uint16 );
	*q_u->server = 0x1;

	q_u->message = TALLOC_ZERO_P( get_talloc_ctx(), UNISTR4 );

	if ( msg && *msg ) { 
		init_unistr4( q_u->message, msg, UNI_FLAGS_NONE );

		/* Win2000 is apparently very sensitive to these lengths */
		/* do a special case here */

		q_u->message->string->uni_max_len++;
		q_u->message->size += 2;

	}

	q_u->timeout = timeout;

	q_u->reboot = do_reboot ? 1 : 0;
	q_u->force = force ? 1 : 0;
}

/*******************************************************************
Inits a REG_Q_SHUTDOWN_EX structure.
********************************************************************/

void init_reg_q_shutdown_ex(REG_Q_SHUTDOWN_EX * q_u_ex, const char *msg,
			uint32 timeout, BOOL do_reboot, BOOL force, uint32 reason)
{
	REG_Q_SHUTDOWN q_u;
	
	ZERO_STRUCT( q_u );
	
	init_reg_q_shutdown( &q_u, msg, timeout, do_reboot, force );
	
	/* steal memory */
	
	q_u_ex->server  = q_u.server;
	q_u_ex->message = q_u.message;
	
	q_u_ex->reboot  = q_u.reboot;
	q_u_ex->force   = q_u.force;
	
	q_u_ex->reason = reason;
}

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

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

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

	if (!prs_align(ps))
		return False;

	if (!prs_pointer("server", ps, depth, (void**)&q_u->server, sizeof(uint16), (PRS_POINTER_CAST)prs_uint16))
		return False;
	if (!prs_align(ps))
		return False;

	if (!prs_pointer("message", ps, depth, (void**)&q_u->message, sizeof(UNISTR4), (PRS_POINTER_CAST)prs_unistr4))
		return False;

	if (!prs_align(ps))
		return False;

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

	if (!prs_uint8("force  ", ps, depth, &(q_u->force)))
		return False;
	if (!prs_uint8("reboot ", ps, depth, &(q_u->reboot)))
		return False;


	return True;
}

/*******************************************************************
reads or writes a structure.
********************************************************************/
BOOL reg_io_r_shutdown(const char *desc, REG_R_SHUTDOWN *r_u, prs_struct *ps,
		       int depth)
{
	if ( !r_u )
		return False;

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

	if(!prs_align(ps))
		return False;

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

	return True;
}

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

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

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

	if (!prs_align(ps))
		return False;

	if (!prs_pointer("server", ps, depth, (void**)&q_u->server, sizeof(uint16), (PRS_POINTER_CAST)prs_uint16))
		return False;
	if (!prs_align(ps))
		return False;

	if (!prs_pointer("message", ps, depth, (void**)&q_u->message, sizeof(UNISTR4), (PRS_POINTER_CAST)prs_unistr4))
		return False;

	if (!prs_align(ps))
		return False;

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

	if (!prs_uint8("force  ", ps, depth, &(q_u->force)))
		return False;
	if (!prs_uint8("reboot ", ps, depth, &(q_u->reboot)))
		return False;

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


	return True;
}

/*******************************************************************
reads or writes a REG_R_SHUTDOWN_EX structure.
********************************************************************/
BOOL reg_io_r_shutdown_ex(const char *desc, REG_R_SHUTDOWN_EX *r_u, prs_struct *ps,
		       int depth)
{
	if ( !r_u )
		return False;

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

	if(!prs_align(ps))
		return False;

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

	return True;
}



/*******************************************************************
Inits a structure.
********************************************************************/
void init_reg_q_abort_shutdown(REG_Q_ABORT_SHUTDOWN *q_u)
{
	q_u->server = TALLOC_P( get_talloc_ctx(), uint16 );
	*q_u->server = 0x1;
}

/*******************************************************************
reads or writes a structure.
********************************************************************/
BOOL reg_io_q_abort_shutdown(const char *desc, REG_Q_ABORT_SHUTDOWN *q_u,
			     prs_struct *ps, int depth)
{
	if ( !q_u )
		return False;

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

	if (!prs_align(ps))
		return False;

	if (!prs_pointer("server", ps, depth, (void**)&q_u->server, sizeof(uint16), (PRS_POINTER_CAST)prs_uint16))
		return False;
	if (!prs_align(ps))
		return False;

	return True;
}

/*******************************************************************
reads or writes a structure.
********************************************************************/
BOOL reg_io_r_abort_shutdown(const char *desc, REG_R_ABORT_SHUTDOWN *r_u,
			     prs_struct *ps, int depth)
{
	if ( !r_u )
		return False;

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

	if (!prs_align(ps))
		return False;

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

	return True;
}