Samba: rpc_parse/parse

uint32 reg_init_regval_buffer	(	REGVAL_BUFFER *	buf2,
		REGISTRY_VALUE *	val
	)

parse_reg.c の 36 行で定義されています。

参照先 init_regval_buffer()・regval_data_p()・regval_size().

参照元 _ntsvcs_get_device_reg_property()・init_reg_r_enum_val()・init_reg_r_query_value().

00037 {
00038         uint32          real_size = 0;
00039         
00040         if ( !buf2 || !val )
00041                 return 0;
00042                 
00043         real_size = regval_size(val);
00044         init_regval_buffer( buf2, (unsigned char*)regval_data_p(val), real_size );
00045 
00046         return real_size;
00047 }

void init_reg_q_open_hive	(	REG_Q_OPEN_HIVE *	q_o,
		uint32	access_desired
	)

parse_reg.c の 53 行で定義されています。

参照先 REG_Q_OPEN_HIVE::access・get_talloc_ctx()・REG_Q_OPEN_HIVE::server・smb_panic().

参照元 rpccli_reg_open_hive_int().

00054 {
00055         
00056         q_o->server = TALLOC_P( get_talloc_ctx(), uint16);
00057         if (!q_o->server) {
00058                 smb_panic("init_reg_q_open_hive: talloc fail.\n");
00059                 return;
00060         }
00061         *q_o->server = 0x1;
00062         
00063         q_o->access = access_desired;
00064 }

BOOL reg_io_q_open_hive	(	const char *	desc,
		REG_Q_OPEN_HIVE *	q_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 70 行で定義されています。

参照先 REG_Q_OPEN_HIVE::access・prs_debug()・REG_Q_OPEN_HIVE::server.

参照元 api_reg_open_hkcr()・api_reg_open_hklm()・api_reg_open_hkpd()・api_reg_open_hkpt()・api_reg_open_hku()・rpccli_reg_open_hive_int().

00072 {
00073         prs_debug(ps, depth, desc, "reg_io_q_open_hive");
00074         depth++;
00075 
00076         if(!prs_align(ps))
00077                 return False;
00078 
00079         if(!prs_pointer("server", ps, depth, (void**)&q_u->server, sizeof(uint16), (PRS_POINTER_CAST)prs_uint16))
00080                 return False;
00081 
00082         if(!prs_align(ps))
00083                 return False;
00084         if(!prs_uint32("access", ps, depth, &q_u->access))
00085                 return False;
00086 
00087         return True;
00088 }

BOOL reg_io_r_open_hive	(	const char *	desc,
		REG_R_OPEN_HIVE *	r_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 95 行で定義されています。

参照先 REG_R_OPEN_HIVE::pol・prs_debug()・smb_io_pol_hnd()・REG_R_OPEN_HIVE::status.

参照元 api_reg_open_hkcr()・api_reg_open_hklm()・api_reg_open_hkpd()・api_reg_open_hkpt()・api_reg_open_hku()・rpccli_reg_open_hive_int().

00097 {
00098         if ( !r_u )
00099                 return False;
00100 
00101         prs_debug(ps, depth, desc, "reg_io_r_open_hive");
00102         depth++;
00103 
00104         if(!prs_align(ps))
00105                 return False;
00106         
00107         if(!smb_io_pol_hnd("", &r_u->pol, ps, depth))
00108                 return False;
00109 
00110         if(!prs_werror("status", ps, depth, &r_u->status))
00111                 return False;
00112 
00113         return True;
00114 }

void init_reg_q_flush_key	(	REG_Q_FLUSH_KEY *	q_u,
		POLICY_HND *	pol
	)

parse_reg.c の 120 行で定義されています。

参照先 pol・REG_Q_FLUSH_KEY::pol.

参照元 rpccli_reg_flush_key().

00121 {
00122         memcpy(&q_u->pol, pol, sizeof(q_u->pol));
00123 }

BOOL reg_io_q_flush_key	(	const char *	desc,
		REG_Q_FLUSH_KEY *	q_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 129 行で定義されています。

参照先 REG_Q_FLUSH_KEY::pol・prs_debug()・smb_io_pol_hnd().

参照元 rpccli_reg_flush_key().

00130 {
00131         if ( !q_u )
00132                 return False;
00133 
00134         prs_debug(ps, depth, desc, "reg_io_q_flush_key");
00135         depth++;
00136 
00137         if(!prs_align(ps))
00138                 return False;
00139         
00140         if(!smb_io_pol_hnd("", &q_u->pol, ps, depth))
00141                 return False;
00142 
00143         return True;
00144 }

BOOL reg_io_r_flush_key	(	const char *	desc,
		REG_R_FLUSH_KEY *	r_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 150 行で定義されています。

参照先 prs_debug()・REG_R_FLUSH_KEY::status.

参照元 rpccli_reg_flush_key().

00152 {
00153         if ( !r_u )
00154                 return False;
00155 
00156         prs_debug(ps, depth, desc, "reg_io_r_flush_key");
00157         depth++;
00158 
00159         if(!prs_align(ps))
00160                 return False;
00161         
00162         if(!prs_werror("status", ps, depth, &r_u->status))
00163                 return False;
00164 
00165         return True;
00166 }

static BOOL reg_io_hdrbuf_sec	(	uint32	ptr,
		uint32 *	ptr3,
		BUFHDR *	hdr_sec,
		SEC_DESC_BUF *	data,
		prs_struct *	ps,
		int	depth
	)			`[static]`

parse_reg.c の 172 行で定義されています。

参照先 sec_desc_buf_info::len・sec_desc_buf_info::max_len・sec_io_desc_buf()・smb_io_hdrbuf_post()・smb_io_hdrbuf_pre().

参照元 reg_io_q_create_key_ex()・reg_io_q_get_key_sec()・reg_io_q_set_key_sec().

00174 {
00175         if (ptr != 0) {
00176                 uint32 hdr_offset;
00177                 uint32 old_offset;
00178                 if(!smb_io_hdrbuf_pre("hdr_sec", hdr_sec, ps, depth,
00179                                       &hdr_offset))
00180                         return False;
00181 
00182                 old_offset = prs_offset(ps);
00183 
00184                 if (ptr3 != NULL) {
00185                         if(!prs_uint32("ptr3", ps, depth, ptr3))
00186                                 return False;
00187                 }
00188 
00189                 if (ptr3 == NULL || *ptr3 != 0) {
00190                         /* JRA - this next line is probably wrong... */
00191                         if(!sec_io_desc_buf("data   ", &data, ps, depth))
00192                                 return False;
00193                 }
00194 
00195                 if(!smb_io_hdrbuf_post("hdr_sec", hdr_sec, ps, depth,
00196                                        hdr_offset, data->max_len, data->len))
00197                                 return False;
00198                 if(!prs_set_offset(ps, old_offset + data->len +
00199                                        sizeof(uint32) * ((ptr3 != NULL) ? 5 : 3)))
00200                         return False;
00201 
00202                 if(!prs_align(ps))
00203                         return False;
00204         }
00205 
00206         return True;
00207 }

void init_reg_q_create_key_ex	(	REG_Q_CREATE_KEY_EX *	q_c,
		POLICY_HND *	hnd,
		char *	name,
		char *	key_class,
		uint32	access_desired,
		SEC_DESC_BUF *	sec_buf
	)

parse_reg.c の 213 行で定義されています。

参照先 REG_Q_CREATE_KEY_EX::access・REG_Q_CREATE_KEY_EX::data・REG_Q_CREATE_KEY_EX::disposition・get_talloc_ctx()・REG_Q_CREATE_KEY_EX::handle・REG_Q_CREATE_KEY_EX::hdr_sec・init_buf_hdr()・init_unistr4()・REG_Q_CREATE_KEY_EX::key_class・sec_desc_buf_info::len・REG_Q_CREATE_KEY_EX::name・REG_Q_CREATE_KEY_EX::ptr2・REG_Q_CREATE_KEY_EX::ptr3・REG_Q_CREATE_KEY_EX::sec_info・smb_panic()・UNI_STR_TERMINATE.

参照元 rpccli_reg_create_key_ex().

00216 {
00217         ZERO_STRUCTP(q_c);
00218 
00219         memcpy(&q_c->handle, hnd, sizeof(q_c->handle));
00220 
00221 
00222         init_unistr4( &q_c->name, name, UNI_STR_TERMINATE );
00223         init_unistr4( &q_c->key_class, key_class, UNI_STR_TERMINATE );
00224 
00225         q_c->access = access_desired;
00226 
00227         q_c->sec_info = TALLOC_P( get_talloc_ctx(), uint32 );
00228         if (!q_c->sec_info) {
00229                 smb_panic("init_reg_q_create_key_ex: talloc fail\n");
00230                 return;
00231         }
00232         *q_c->sec_info = DACL_SECURITY_INFORMATION | SACL_SECURITY_INFORMATION;
00233 
00234         q_c->data = sec_buf;
00235         q_c->ptr2 = 1;
00236         init_buf_hdr(&q_c->hdr_sec, sec_buf->len, sec_buf->len);
00237         q_c->ptr3 = 1;
00238         q_c->disposition = TALLOC_P( get_talloc_ctx(), uint32 );
00239         if (!q_c->disposition) {
00240                 smb_panic("init_reg_q_create_key_ex: talloc fail\n");
00241                 return;
00242         }
00243 }

BOOL reg_io_q_create_key_ex	(	const char *	desc,
		REG_Q_CREATE_KEY_EX *	q_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 249 行で定義されています。

参照先 REG_Q_CREATE_KEY_EX::access・REG_Q_CREATE_KEY_EX::data・REG_Q_CREATE_KEY_EX::disposition・REG_Q_CREATE_KEY_EX::handle・REG_Q_CREATE_KEY_EX::hdr_sec・REG_Q_CREATE_KEY_EX::key_class・REG_Q_CREATE_KEY_EX::name・REG_Q_CREATE_KEY_EX::options・prs_debug()・prs_unistr4()・REG_Q_CREATE_KEY_EX::ptr2・REG_Q_CREATE_KEY_EX::ptr3・reg_io_hdrbuf_sec()・REG_Q_CREATE_KEY_EX::sec_info・smb_io_pol_hnd().

参照元 api_reg_create_key_ex()・rpccli_reg_create_key_ex().

00251 {
00252         if ( !q_u )
00253                 return False;
00254 
00255         prs_debug(ps, depth, desc, "reg_io_q_create_key_ex");
00256         depth++;
00257 
00258         if(!prs_align(ps))
00259                 return False;
00260         
00261         if(!smb_io_pol_hnd("", &q_u->handle, ps, depth))
00262                 return False;
00263 
00264         if(!prs_unistr4 ("name", ps, depth, &q_u->name))
00265                 return False;
00266         if(!prs_align(ps))
00267                 return False;
00268 
00269         if(!prs_unistr4 ("key_class", ps, depth, &q_u->key_class))
00270                 return False;
00271         if(!prs_align(ps))
00272                 return False;
00273 
00274         if(!prs_uint32("options", ps, depth, &q_u->options))
00275                 return False;
00276         if(!prs_uint32("access", ps, depth, &q_u->access))
00277                 return False;
00278 
00279         if(!prs_pointer("sec_info", ps, depth, (void**)&q_u->sec_info, sizeof(uint32), (PRS_POINTER_CAST)prs_uint32))
00280                 return False;
00281 
00282         if ( q_u->sec_info ) {
00283                 if(!prs_uint32("ptr2", ps, depth, &q_u->ptr2))
00284                         return False;
00285                 if(!reg_io_hdrbuf_sec(q_u->ptr2, &q_u->ptr3, &q_u->hdr_sec, q_u->data, ps, depth))
00286                         return False;
00287         }
00288 
00289         if(!prs_pointer("disposition", ps, depth, (void**)&q_u->disposition, sizeof(uint32), (PRS_POINTER_CAST)prs_uint32))
00290                 return False;
00291 
00292         return True;
00293 }

BOOL reg_io_r_create_key_ex	(	const char *	desc,
		REG_R_CREATE_KEY_EX *	r_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 299 行で定義されています。

参照先 REG_R_CREATE_KEY_EX::disposition・REG_R_CREATE_KEY_EX::handle・prs_debug()・smb_io_pol_hnd()・REG_R_CREATE_KEY_EX::status.

参照元 api_reg_create_key_ex()・rpccli_reg_create_key_ex().

00301 {
00302         if ( !r_u )
00303                 return False;
00304 
00305         prs_debug(ps, depth, desc, "reg_io_r_create_key_ex");
00306         depth++;
00307 
00308         if(!prs_align(ps))
00309                 return False;
00310         
00311         if(!smb_io_pol_hnd("", &r_u->handle, ps, depth))
00312                 return False;
00313         if(!prs_uint32("disposition", ps, depth, &r_u->disposition))
00314                 return False;
00315 
00316         if(!prs_werror("status", ps, depth, &r_u->status))
00317                 return False;
00318 
00319         return True;
00320 }

void init_reg_q_delete_val	(	REG_Q_DELETE_VALUE *	q_c,
		POLICY_HND *	hnd,
		char *	name
	)

parse_reg.c の 327 行で定義されています。

参照先 REG_Q_DELETE_VALUE::handle・init_unistr4()・REG_Q_DELETE_VALUE::name・UNI_STR_TERMINATE.

参照元 rpccli_reg_delete_val().

00329 {
00330         ZERO_STRUCTP(q_c);
00331 
00332         memcpy(&q_c->handle, hnd, sizeof(q_c->handle));
00333         init_unistr4(&q_c->name, name, UNI_STR_TERMINATE);
00334 }

BOOL reg_io_q_delete_value	(	const char *	desc,
		REG_Q_DELETE_VALUE *	q_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 340 行で定義されています。

参照先 REG_Q_DELETE_VALUE::handle・REG_Q_DELETE_VALUE::name・prs_debug()・prs_unistr4()・smb_io_pol_hnd().

参照元 api_reg_delete_value()・rpccli_reg_delete_val().

00342 {
00343         if ( !q_u )
00344                 return False;
00345 
00346         prs_debug(ps, depth, desc, "reg_io_q_delete_value");
00347         depth++;
00348 
00349         if(!prs_align(ps))
00350                 return False;
00351         
00352         if(!smb_io_pol_hnd("", &q_u->handle, ps, depth))
00353                 return False;
00354 
00355         if(!prs_unistr4("name", ps, depth, &q_u->name))
00356                 return False;
00357 
00358         return True;
00359 }

BOOL reg_io_r_delete_value	(	const char *	desc,
		REG_R_DELETE_VALUE *	r_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 366 行で定義されています。

参照先 prs_debug()・REG_R_DELETE_VALUE::status.

参照元 api_reg_delete_value()・rpccli_reg_delete_val().

00368 {
00369         if ( !r_u )
00370                 return False;
00371 
00372         prs_debug(ps, depth, desc, "reg_io_r_delete_value");
00373         depth++;
00374 
00375         if(!prs_align(ps))
00376                 return False;
00377         
00378         if(!prs_werror("status", ps, depth, &r_u->status))
00379                 return False;
00380 
00381         return True;
00382 }

void init_reg_q_delete_key	(	REG_Q_DELETE_KEY *	q_c,
		POLICY_HND *	hnd,
		char *	name
	)

parse_reg.c の 388 行で定義されています。

参照先 REG_Q_DELETE_KEY::handle・init_unistr4()・REG_Q_DELETE_KEY::name・UNI_STR_TERMINATE.

参照元 rpccli_reg_delete_key().

00390 {
00391         ZERO_STRUCTP(q_c);
00392 
00393         memcpy(&q_c->handle, hnd, sizeof(q_c->handle));
00394 
00395         init_unistr4(&q_c->name, name, UNI_STR_TERMINATE);
00396 }

BOOL reg_io_q_delete_key	(	const char *	desc,
		REG_Q_DELETE_KEY *	q_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 402 行で定義されています。

参照先 REG_Q_DELETE_KEY::handle・REG_Q_DELETE_KEY::name・prs_debug()・prs_unistr4()・smb_io_pol_hnd().

参照元 api_reg_delete_key()・rpccli_reg_delete_key().

00404 {
00405         if ( !q_u )
00406                 return False;
00407 
00408         prs_debug(ps, depth, desc, "reg_io_q_delete_key");
00409         depth++;
00410 
00411         if(!prs_align(ps))
00412                 return False;
00413         
00414         if(!smb_io_pol_hnd("", &q_u->handle, ps, depth))
00415                 return False;
00416 
00417         if(!prs_unistr4("", ps, depth, &q_u->name))
00418                 return False;
00419 
00420         return True;
00421 }

BOOL reg_io_r_delete_key	(	const char *	desc,
		REG_R_DELETE_KEY *	r_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 427 行で定義されています。

参照先 prs_debug()・REG_R_DELETE_KEY::status.

参照元 api_reg_delete_key()・rpccli_reg_delete_key().

00428 {
00429         if ( !r_u )
00430                 return False;
00431 
00432         prs_debug(ps, depth, desc, "reg_io_r_delete_key");
00433         depth++;
00434 
00435         if(!prs_align(ps))
00436                 return False;
00437         
00438         if(!prs_werror("status", ps, depth, &r_u->status))
00439                 return False;
00440 
00441         return True;
00442 }

void init_reg_q_query_key	(	REG_Q_QUERY_KEY *	q_o,
		POLICY_HND *	hnd,
		const char *	key_class
	)

parse_reg.c の 448 行で定義されています。

参照先 init_unistr4()・REG_Q_QUERY_KEY::key_class・REG_Q_QUERY_KEY::pol・UNI_STR_TERMINATE.

参照元 rpccli_reg_query_key().

00449 {
00450         ZERO_STRUCTP(q_o);
00451 
00452         memcpy(&q_o->pol, hnd, sizeof(q_o->pol));
00453         init_unistr4(&q_o->key_class, key_class, UNI_STR_TERMINATE);
00454 }

BOOL reg_io_q_query_key	(	const char *	desc,
		REG_Q_QUERY_KEY *	q_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 460 行で定義されています。

参照先 REG_Q_QUERY_KEY::key_class・REG_Q_QUERY_KEY::pol・prs_debug()・prs_unistr4()・smb_io_pol_hnd().

参照元 api_reg_query_key()・rpccli_reg_query_key().

00461 {
00462         if ( !q_u )
00463                 return False;
00464 
00465         prs_debug(ps, depth, desc, "reg_io_q_query_key");
00466         depth++;
00467 
00468         if(!prs_align(ps))
00469                 return False;
00470         
00471         if(!smb_io_pol_hnd("", &q_u->pol, ps, depth))
00472                 return False;
00473         if(!prs_unistr4("key_class", ps, depth, &q_u->key_class))
00474                 return False;
00475 
00476         return True;
00477 }

BOOL reg_io_r_query_key	(	const char *	desc,
		REG_R_QUERY_KEY *	r_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 484 行で定義されています。

参照先 REG_R_QUERY_KEY::key_class・REG_R_QUERY_KEY::max_subkeylen・REG_R_QUERY_KEY::max_valbufsize・REG_R_QUERY_KEY::max_valnamelen・REG_R_QUERY_KEY::mod_time・REG_R_QUERY_KEY::num_subkeys・REG_R_QUERY_KEY::num_values・prs_debug()・prs_unistr4()・REG_R_QUERY_KEY::reserved・REG_R_QUERY_KEY::sec_desc・smb_io_time()・REG_R_QUERY_KEY::status.

参照元 api_reg_query_key()・rpccli_reg_query_key().

00485 {
00486         if ( !r_u )
00487                 return False;
00488 
00489         prs_debug(ps, depth, desc, "reg_io_r_query_key");
00490         depth++;
00491 
00492         if(!prs_align(ps))
00493                 return False;
00494         
00495         if(!prs_unistr4("key_class", ps, depth, &r_u->key_class))
00496                 return False;
00497 
00498         if(!prs_align(ps))
00499                 return False;
00500 
00501         if(!prs_uint32("num_subkeys   ", ps, depth, &r_u->num_subkeys))
00502                 return False;
00503         if(!prs_uint32("max_subkeylen ", ps, depth, &r_u->max_subkeylen))
00504                 return False;
00505         if(!prs_uint32("reserved      ", ps, depth, &r_u->reserved))
00506                 return False;
00507         if(!prs_uint32("num_values    ", ps, depth, &r_u->num_values))
00508                 return False;
00509         if(!prs_uint32("max_valnamelen", ps, depth, &r_u->max_valnamelen))
00510                 return False;
00511         if(!prs_uint32("max_valbufsize", ps, depth, &r_u->max_valbufsize))
00512                 return False;
00513         if(!prs_uint32("sec_desc      ", ps, depth, &r_u->sec_desc))
00514                 return False;
00515         if(!smb_io_time("mod_time     ", &r_u->mod_time, ps, depth))
00516                 return False;
00517 
00518         if(!prs_werror("status", ps, depth, &r_u->status))
00519                 return False;
00520 
00521         return True;
00522 }

void init_reg_q_getversion	(	REG_Q_GETVERSION *	q_o,
		POLICY_HND *	hnd
	)

parse_reg.c の 528 行で定義されています。

参照先 REG_Q_GETVERSION::pol.

参照元 rpccli_reg_getversion().

00529 {
00530         memcpy(&q_o->pol, hnd, sizeof(q_o->pol));
00531 }

BOOL reg_io_q_getversion	(	const char *	desc,
		REG_Q_GETVERSION *	q_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 538 行で定義されています。

参照先 REG_Q_GETVERSION::pol・prs_debug()・smb_io_pol_hnd().

参照元 api_reg_getversion()・rpccli_reg_getversion().

00539 {
00540         if ( !q_u )
00541                 return False;
00542 
00543         prs_debug(ps, depth, desc, "reg_io_q_getversion");
00544         depth++;
00545 
00546         if(!prs_align(ps))
00547                 return False;
00548 
00549         if(!smb_io_pol_hnd("", &q_u->pol, ps, depth))
00550                 return False;
00551 
00552         return True;
00553 }

BOOL reg_io_r_getversion	(	const char *	desc,
		REG_R_GETVERSION *	r_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 559 行で定義されています。

参照先 prs_debug()・REG_R_GETVERSION::status・REG_R_GETVERSION::win_version.

参照元 api_reg_getversion()・rpccli_reg_getversion().

00560 {
00561         if ( !r_u )
00562                 return False;
00563 
00564         prs_debug(ps, depth, desc, "reg_io_r_getversion");
00565         depth++;
00566 
00567         if(!prs_align(ps))
00568                 return False;
00569 
00570         if(!prs_uint32("win_version", ps, depth, &r_u->win_version))
00571                 return False;
00572         if(!prs_werror("status" , ps, depth, &r_u->status))
00573                 return False;
00574 
00575         return True;
00576 }

BOOL reg_io_q_restore_key	(	const char *	desc,
		REG_Q_RESTORE_KEY *	q_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 583 行で定義されています。

参照先 REG_Q_RESTORE_KEY::filename・REG_Q_RESTORE_KEY::flags・REG_Q_RESTORE_KEY::pol・prs_debug()・prs_unistr4()・smb_io_pol_hnd().

参照元 api_reg_restore_key().

00584 {
00585         if ( !q_u )
00586                 return False;
00587 
00588         prs_debug(ps, depth, desc, "reg_io_q_restore_key");
00589         depth++;
00590 
00591         if(!prs_align(ps))
00592                 return False;
00593 
00594         if(!smb_io_pol_hnd("", &q_u->pol, ps, depth))
00595                 return False;
00596 
00597         if(!prs_unistr4("filename", ps, depth, &q_u->filename))
00598                 return False;
00599 
00600         if(!prs_uint32("flags", ps, depth, &q_u->flags))
00601                 return False;
00602 
00603         return True;
00604 }

BOOL reg_io_r_restore_key	(	const char *	desc,
		REG_R_RESTORE_KEY *	r_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 610 行で定義されています。

参照先 prs_debug()・REG_R_RESTORE_KEY::status.

参照元 api_reg_restore_key().

00611 {
00612         if ( !r_u )
00613                 return False;
00614 
00615         prs_debug(ps, depth, desc, "reg_io_r_restore_key");
00616         depth++;
00617 
00618         if(!prs_align(ps))
00619                 return False;
00620         
00621         if(!prs_werror("status" , ps, depth, &r_u->status))
00622                 return False;
00623 
00624         return True;
00625 }

void init_q_reg_save_key	(	REG_Q_SAVE_KEY *	q_u,
		POLICY_HND *	handle,
		const char *	fname
	)

parse_reg.c の 630 行で定義されています。

参照先 REG_Q_SAVE_KEY::filename・handle・init_unistr4()・REG_Q_SAVE_KEY::pol・REG_Q_SAVE_KEY::sec_attr・UNI_STR_TERMINATE.

参照元 rpccli_reg_save_key().

00631 {
00632         memcpy(&q_u->pol, handle, sizeof(q_u->pol));
00633         init_unistr4( &q_u->filename, fname, UNI_STR_TERMINATE );
00634         q_u->sec_attr = NULL;
00635 }

BOOL reg_io_q_save_key	(	const char *	desc,
		REG_Q_SAVE_KEY *	q_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 641 行で定義されています。

参照先 REG_Q_SAVE_KEY::filename・REG_Q_SAVE_KEY::pol・prs_debug()・prs_unistr4()・smb_io_pol_hnd().

参照元 api_reg_save_key()・rpccli_reg_save_key().

00642 {
00643         if ( !q_u )
00644                 return False;
00645 
00646         prs_debug(ps, depth, desc, "reg_io_q_save_key");
00647         depth++;
00648 
00649         if(!prs_align(ps))
00650                 return False;
00651 
00652         if(!smb_io_pol_hnd("", &q_u->pol, ps, depth))
00653                 return False;
00654 
00655         if(!prs_unistr4("filename", ps, depth, &q_u->filename))
00656                 return False;
00657 
00658 #if 0   /* reg_io_sec_attr() */
00659         if(!prs_uint32("unknown", ps, depth, &q_u->unknown))
00660                 return False;
00661 #endif
00662 
00663         return True;
00664 }

BOOL reg_io_r_save_key	(	const char *	desc,
		REG_R_SAVE_KEY *	r_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 670 行で定義されています。

参照先 prs_debug()・REG_R_SAVE_KEY::status.

参照元 api_reg_save_key()・rpccli_reg_save_key().

00671 {
00672         if ( !r_u )
00673                 return False;
00674 
00675         prs_debug(ps, depth, desc, "reg_io_r_save_key");
00676         depth++;
00677 
00678         if(!prs_align(ps))
00679                 return False;
00680         
00681         if(!prs_werror("status" , ps, depth, &r_u->status))
00682                 return False;
00683 
00684         return True;
00685 }

void init_reg_q_close	(	REG_Q_CLOSE *	q_c,
		POLICY_HND *	hnd
	)

parse_reg.c の 691 行で定義されています。

参照先 REG_Q_CLOSE::pol.

参照元 rpccli_reg_close().

00692 {
00693         DEBUG(5,("init_reg_q_close\n"));
00694 
00695         memcpy(&q_c->pol, hnd, sizeof(q_c->pol));
00696 }

BOOL reg_io_q_close	(	const char *	desc,
		REG_Q_CLOSE *	q_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 702 行で定義されています。

参照先 REG_Q_CLOSE::pol・prs_debug()・smb_io_pol_hnd().

参照元 api_reg_close()・rpccli_reg_close().

00703 {
00704         if (q_u == NULL)
00705                 return False;
00706 
00707         prs_debug(ps, depth, desc, "reg_io_q_close");
00708         depth++;
00709 
00710         if(!prs_align(ps))
00711                 return False;
00712 
00713         if(!smb_io_pol_hnd("", &q_u->pol, ps, depth))
00714                 return False;
00715         if(!prs_align(ps))
00716                 return False;
00717 
00718         return True;
00719 }

BOOL reg_io_r_close	(	const char *	desc,
		REG_R_CLOSE *	r_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 725 行で定義されています。

参照先 REG_R_CLOSE::pol・prs_debug()・smb_io_pol_hnd()・REG_R_CLOSE::status.

参照元 api_reg_close()・rpccli_reg_close().

00726 {
00727         if ( !r_u )
00728                 return False;
00729 
00730         prs_debug(ps, depth, desc, "reg_io_r_close");
00731         depth++;
00732 
00733         if(!prs_align(ps))
00734                 return False;
00735 
00736         if(!smb_io_pol_hnd("", &r_u->pol, ps, depth))
00737                 return False;
00738         if(!prs_align(ps))
00739                 return False;
00740 
00741         if(!prs_werror("status", ps, depth, &r_u->status))
00742                 return False;
00743 
00744         return True;
00745 }

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
	)

parse_reg.c の 751 行で定義されています。

参照先 REG_Q_SET_KEY_SEC::data・REG_Q_SET_KEY_SEC::handle・REG_Q_SET_KEY_SEC::hdr_sec・init_buf_hdr()・sec_desc_buf_info::len・pol・REG_Q_SET_KEY_SEC::ptr・REG_Q_SET_KEY_SEC::sec_info.

参照元 rpccli_reg_set_key_sec().

00753 {
00754         memcpy(&q_u->handle, pol, sizeof(q_u->handle));
00755 
00756         q_u->sec_info = sec_info;
00757 
00758         q_u->ptr = 1;
00759         init_buf_hdr(&q_u->hdr_sec, sec_desc_buf->len, sec_desc_buf->len);
00760         q_u->data = sec_desc_buf;
00761 }

BOOL reg_io_q_set_key_sec	(	const char *	desc,
		REG_Q_SET_KEY_SEC *	q_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 767 行で定義されています。

参照先 REG_Q_SET_KEY_SEC::data・REG_Q_SET_KEY_SEC::handle・REG_Q_SET_KEY_SEC::hdr_sec・prs_debug()・REG_Q_SET_KEY_SEC::ptr・reg_io_hdrbuf_sec()・REG_Q_SET_KEY_SEC::sec_info・smb_io_pol_hnd().

参照元 api_reg_set_key_sec()・rpccli_reg_set_key_sec().

00768 {
00769         if ( !q_u )
00770                 return False;
00771 
00772         prs_debug(ps, depth, desc, "reg_io_q_set_key_sec");
00773         depth++;
00774 
00775         if(!prs_align(ps))
00776                 return False;
00777         
00778         if(!smb_io_pol_hnd("", &q_u->handle, ps, depth))
00779                 return False;
00780 
00781         if(!prs_uint32("sec_info", ps, depth, &q_u->sec_info))
00782                 return False;
00783         if(!prs_uint32("ptr    ", ps, depth, &q_u->ptr))
00784                 return False;
00785 
00786         if(!reg_io_hdrbuf_sec(q_u->ptr, NULL, &q_u->hdr_sec, q_u->data, ps, depth))
00787                 return False;
00788 
00789         return True;
00790 }

BOOL reg_io_r_set_key_sec	(	const char *	desc,
		REG_R_SET_KEY_SEC *	q_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 796 行で定義されています。

参照先 prs_debug()・REG_R_SET_KEY_SEC::status.

参照元 api_reg_set_key_sec()・rpccli_reg_set_key_sec().

00797 {
00798         if ( !q_u )
00799                 return False;
00800 
00801         prs_debug(ps, depth, desc, "reg_io_r_set_key_sec");
00802         depth++;
00803 
00804         if(!prs_align(ps))
00805                 return False;
00806         
00807         if(!prs_werror("status", ps, depth, &q_u->status))
00808                 return False;
00809 
00810         return True;
00811 }

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
	)

parse_reg.c の 818 行で定義されています。

参照先 REG_Q_GET_KEY_SEC::data・REG_Q_GET_KEY_SEC::handle・REG_Q_GET_KEY_SEC::hdr_sec・init_buf_hdr()・pol・REG_Q_GET_KEY_SEC::ptr・REG_Q_GET_KEY_SEC::sec_info.

参照元 rpccli_reg_get_key_sec().

00821 {
00822         memcpy(&q_u->handle, pol, sizeof(q_u->handle));
00823 
00824         q_u->sec_info = sec_info;
00825 
00826         q_u->ptr = psdb != NULL ? 1 : 0;
00827         q_u->data = psdb;
00828 
00829         init_buf_hdr(&q_u->hdr_sec, sec_buf_size, 0);
00830 }

BOOL reg_io_q_get_key_sec	(	const char *	desc,
		REG_Q_GET_KEY_SEC *	q_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 836 行で定義されています。

参照先 REG_Q_GET_KEY_SEC::data・REG_Q_GET_KEY_SEC::handle・REG_Q_GET_KEY_SEC::hdr_sec・prs_debug()・REG_Q_GET_KEY_SEC::ptr・reg_io_hdrbuf_sec()・REG_Q_GET_KEY_SEC::sec_info・smb_io_pol_hnd().

参照元 api_reg_get_key_sec()・rpccli_reg_get_key_sec().

00837 {
00838         if ( !q_u )
00839                 return False;
00840 
00841         prs_debug(ps, depth, desc, "reg_io_q_get_key_sec");
00842         depth++;
00843 
00844         if(!prs_align(ps))
00845                 return False;
00846         
00847         if(!smb_io_pol_hnd("", &q_u->handle, ps, depth))
00848                 return False;
00849 
00850         if(!prs_uint32("sec_info", ps, depth, &q_u->sec_info))
00851                 return False;
00852         if(!prs_uint32("ptr     ", ps, depth, &q_u->ptr))
00853                 return False;
00854 
00855         if(!reg_io_hdrbuf_sec(q_u->ptr, NULL, &q_u->hdr_sec, q_u->data, ps, depth))
00856                 return False;
00857 
00858         return True;
00859 }

void init_reg_r_get_key_sec	(	REG_R_GET_KEY_SEC *	r_i,
		POLICY_HND *	pol,
		uint32	buf_len,
		uint8 *	buf,
		NTSTATUS	status
	)

parse_reg.c の 865 行で定義されています。

参照先 REG_R_GET_KEY_SEC::data・REG_R_GET_KEY_SEC::hdr_sec・init_buf_hdr()・REG_R_GET_KEY_SEC::ptr・status・REG_R_GET_KEY_SEC::status.

00868 {
00869         r_i->ptr = 1;
00870         init_buf_hdr(&r_i->hdr_sec, buf_len, buf_len);
00871         init_sec_desc_buf(r_i->data, buf_len, 1);
00872 
00873         r_i->status = status; /* 0x0000 0000 or 0x0000 007a */
00874 }

BOOL reg_io_r_get_key_sec	(	const char *	desc,
		REG_R_GET_KEY_SEC *	q_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 881 行で定義されています。

参照先 REG_R_GET_KEY_SEC::data・REG_R_GET_KEY_SEC::hdr_sec・prs_debug()・REG_R_GET_KEY_SEC::ptr・sec_io_desc_buf()・smb_io_hdrbuf()・REG_R_GET_KEY_SEC::status.

参照元 api_reg_get_key_sec()・rpccli_reg_get_key_sec().

00882 {
00883         if ( !q_u )
00884                 return False;
00885 
00886         prs_debug(ps, depth, desc, "reg_io_r_get_key_sec");
00887         depth++;
00888 
00889         if(!prs_align(ps))
00890                 return False;
00891         
00892         if(!prs_uint32("ptr      ", ps, depth, &q_u->ptr))
00893                 return False;
00894 
00895         if (q_u->ptr != 0) {
00896                 if(!smb_io_hdrbuf("", &q_u->hdr_sec, ps, depth))
00897                         return False;
00898                 if(!sec_io_desc_buf("", &q_u->data, ps, depth))
00899                         return False;
00900                 if(!prs_align(ps))
00901                         return False;
00902         }
00903 
00904         if(!prs_werror("status", ps, depth, &q_u->status))
00905                 return False;
00906 
00907         return True;
00908 }

BOOL init_reg_q_query_value	(	REG_Q_QUERY_VALUE *	q_u,
		POLICY_HND *	pol,
		const char *	val_name,
		REGVAL_BUFFER *	value_output
	)

parse_reg.c の 914 行で定義されています。

参照先 REGVAL_BUFFER::buf_max_len・REG_Q_QUERY_VALUE::buf_unk・REG_Q_QUERY_VALUE::buflen・REG_Q_QUERY_VALUE::buflen2・REG_Q_QUERY_VALUE::bufsize・init_unistr4()・REG_Q_QUERY_VALUE::name・pol・REG_Q_QUERY_VALUE::pol・REG_Q_QUERY_VALUE::ptr_buf・REG_Q_QUERY_VALUE::ptr_buflen・REG_Q_QUERY_VALUE::ptr_buflen2・REG_Q_QUERY_VALUE::ptr_bufsize・REG_Q_QUERY_VALUE::ptr_reserved・UNI_STR_TERMINATE・REG_Q_QUERY_VALUE::unk1.

参照元 rpccli_reg_query_value().

00916 {
00917         if (q_u == NULL)
00918                 return False;
00919 
00920         q_u->pol = *pol;
00921 
00922         init_unistr4(&q_u->name, val_name, UNI_STR_TERMINATE);
00923 
00924         q_u->ptr_reserved = 1;
00925         q_u->ptr_buf = 1;
00926 
00927         q_u->ptr_bufsize = 1;
00928         q_u->bufsize = value_output->buf_max_len;
00929         q_u->buf_unk = 0;
00930 
00931         q_u->unk1 = 0;
00932         q_u->ptr_buflen = 1;
00933         q_u->buflen = value_output->buf_max_len; 
00934 
00935         q_u->ptr_buflen2 = 1;
00936         q_u->buflen2 = 0;
00937 
00938         return True;
00939 }

BOOL reg_io_q_query_value	(	const char *	desc,
		REG_Q_QUERY_VALUE *	q_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 945 行で定義されています。

参照先 REG_Q_QUERY_VALUE::buf_unk・REG_Q_QUERY_VALUE::buflen・REG_Q_QUERY_VALUE::buflen2・REG_Q_QUERY_VALUE::bufsize・REG_Q_QUERY_VALUE::name・REG_Q_QUERY_VALUE::pol・prs_debug()・prs_unistr4()・REG_Q_QUERY_VALUE::ptr_buf・REG_Q_QUERY_VALUE::ptr_buflen・REG_Q_QUERY_VALUE::ptr_buflen2・REG_Q_QUERY_VALUE::ptr_bufsize・REG_Q_QUERY_VALUE::ptr_reserved・smb_io_pol_hnd()・REG_Q_QUERY_VALUE::unk1.

参照元 api_reg_query_value()・rpccli_reg_query_value().

00946 {
00947         if ( !q_u )
00948                 return False;
00949 
00950         prs_debug(ps, depth, desc, "reg_io_q_query_value");
00951         depth++;
00952 
00953         if(!prs_align(ps))
00954                 return False;
00955         
00956         if(!smb_io_pol_hnd("", &q_u->pol, ps, depth))
00957                 return False;
00958         if(!prs_unistr4("name", ps, depth, &q_u->name))
00959                 return False;
00960 
00961         if(!prs_align(ps))
00962                 return False;
00963         
00964         if(!prs_uint32("ptr_reserved", ps, depth, &(q_u->ptr_reserved)))
00965                 return False;
00966 
00967         if(!prs_uint32("ptr_buf", ps, depth, &(q_u->ptr_buf)))
00968                 return False;
00969 
00970         if(q_u->ptr_buf) {
00971                 if(!prs_uint32("ptr_bufsize", ps, depth, &(q_u->ptr_bufsize)))
00972                         return False;
00973                 if(!prs_uint32("bufsize", ps, depth, &(q_u->bufsize)))
00974                         return False;
00975                 if(!prs_uint32("buf_unk", ps, depth, &(q_u->buf_unk)))
00976                         return False;
00977         }
00978 
00979         if(!prs_uint32("unk1", ps, depth, &(q_u->unk1)))
00980                 return False;
00981 
00982         if(!prs_uint32("ptr_buflen", ps, depth, &(q_u->ptr_buflen)))
00983                 return False;
00984 
00985         if (q_u->ptr_buflen) {
00986                 if(!prs_uint32("buflen", ps, depth, &(q_u->buflen)))
00987                         return False;
00988                 if(!prs_uint32("ptr_buflen2", ps, depth, &(q_u->ptr_buflen2)))
00989                         return False;
00990                 if(!prs_uint32("buflen2", ps, depth, &(q_u->buflen2)))
00991                         return False;
00992         }
00993 
00994         return True;
00995 }

BOOL init_reg_r_query_value	(	uint32	include_keyval,
		REG_R_QUERY_VALUE *	r_u,
		REGISTRY_VALUE *	val,
		WERROR	status
	)

parse_reg.c の 1002 行で定義されています。

参照先 REG_R_QUERY_VALUE::buf_len・REG_R_QUERY_VALUE::buf_max_len・get_talloc_ctx()・reg_init_regval_buffer()・status・REG_R_QUERY_VALUE::status・REGISTRY_VALUE::type・REG_R_QUERY_VALUE::type・REG_R_QUERY_VALUE::value.

参照元 _reg_query_value().

01004 {
01005         uint32                  buf_len = 0;
01006         REGVAL_BUFFER           buf2;
01007                 
01008         if( !r_u || !val )
01009                 return False;
01010         
01011         r_u->type = TALLOC_P( get_talloc_ctx(), uint32 );
01012         if (!r_u->type) {
01013                 return False;
01014         }
01015         *r_u->type = val->type;
01016 
01017         buf_len = reg_init_regval_buffer( &buf2, val );
01018         
01019         r_u->buf_max_len = TALLOC_P( get_talloc_ctx(), uint32 );
01020         if (!r_u->buf_max_len) {
01021                 return False;
01022         }
01023         *r_u->buf_max_len = buf_len;
01024 
01025         r_u->buf_len = TALLOC_P( get_talloc_ctx(), uint32 );
01026         if (!r_u->buf_len) {
01027                 return False;
01028         }
01029         *r_u->buf_len = buf_len;
01030         
01031         /* if include_keyval is not set, don't send the key value, just
01032            the buflen data. probably used by NT5 to allocate buffer space - SK */
01033 
01034         if ( include_keyval ) {
01035                 r_u->value = TALLOC_P( get_talloc_ctx(), REGVAL_BUFFER );
01036                 if (!r_u->value) {
01037                         return False;
01038                 }
01039                 /* steal the memory */
01040                 *r_u->value = buf2;
01041         }
01042 
01043         r_u->status = status;
01044 
01045         return True;
01046 }

BOOL reg_io_r_query_value	(	const char *	desc,
		REG_R_QUERY_VALUE *	r_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 1052 行で定義されています。

参照先 REG_R_QUERY_VALUE::buf_len・REG_R_QUERY_VALUE::buf_max_len・prs_debug()・smb_io_regval_buffer()・REG_R_QUERY_VALUE::status・REG_R_QUERY_VALUE::type・REG_R_QUERY_VALUE::value.

参照元 api_reg_query_value()・rpccli_reg_query_value().

01053 {
01054         if ( !r_u )
01055                 return False;
01056 
01057         prs_debug(ps, depth, desc, "reg_io_r_query_value");
01058         depth++;
01059 
01060         if(!prs_align(ps))
01061                 return False;
01062         
01063         if ( !prs_pointer("type", ps, depth, (void**)&r_u->type, sizeof(uint32), (PRS_POINTER_CAST)prs_uint32))
01064                 return False;
01065 
01066         if ( !prs_pointer("value", ps, depth, (void**)&r_u->value, sizeof(REGVAL_BUFFER), (PRS_POINTER_CAST)smb_io_regval_buffer))
01067                 return False;
01068         if(!prs_align(ps))
01069                 return False;
01070 
01071         if ( !prs_pointer("buf_max_len", ps, depth, (void**)&r_u->buf_max_len, sizeof(uint32), (PRS_POINTER_CAST)prs_uint32))
01072                 return False;
01073         if ( !prs_pointer("buf_len", ps, depth, (void**)&r_u->buf_len, sizeof(uint32), (PRS_POINTER_CAST)prs_uint32))
01074                 return False;
01075 
01076         if(!prs_werror("status", ps, depth, &r_u->status))
01077                 return False;
01078 
01079         return True;
01080 }

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
	)

parse_reg.c の 1086 行で定義されています。

参照先 REGVAL_BUFFER::buf_max_len・REG_Q_ENUM_VALUE::buffer_len・get_talloc_ctx()・REG_Q_ENUM_VALUE::name・REG_Q_ENUM_VALUE::name_len・pol・REG_Q_ENUM_VALUE::pol・UNISTR4::size・smb_panic()・UNISTR4::string・REG_Q_ENUM_VALUE::type・UNISTR2::uni_max_len・REG_Q_ENUM_VALUE::val_index・REG_Q_ENUM_VALUE::value.

参照元 rpccli_reg_enum_val().

01089 {
01090         ZERO_STRUCTP(q_u);
01091 
01092         memcpy(&q_u->pol, pol, sizeof(q_u->pol));
01093 
01094         q_u->val_index = val_idx;
01095 
01096         q_u->name.size = max_name_len*2;
01097         q_u->name.string = TALLOC_ZERO_P( get_talloc_ctx(), UNISTR2 );
01098         if (!q_u->name.string) {
01099                 smb_panic("init_reg_q_enum_val: talloc fail\n");
01100                 return;
01101         }
01102         q_u->name.string->uni_max_len = max_name_len;
01103         
01104         q_u->type = TALLOC_P( get_talloc_ctx(), uint32 );
01105         if (!q_u->type) {
01106                 smb_panic("init_reg_q_enum_val: talloc fail\n");
01107                 return;
01108         }
01109         *q_u->type = 0x0;
01110 
01111         q_u->value = TALLOC_ZERO_P( get_talloc_ctx(), REGVAL_BUFFER );
01112         if (!q_u->value) {
01113                 smb_panic("init_reg_q_enum_val: talloc fail\n");
01114                 return;
01115         }
01116                 
01117         q_u->value->buf_max_len = max_buf_len;
01118 
01119         q_u->buffer_len = TALLOC_P( get_talloc_ctx(), uint32 );
01120         if (!q_u->buffer_len) {
01121                 smb_panic("init_reg_q_enum_val: talloc fail\n");
01122                 return;
01123         }
01124         *q_u->buffer_len = max_buf_len;
01125 
01126         q_u->name_len = TALLOC_P( get_talloc_ctx(), uint32 );
01127         if (!q_u->name_len) {
01128                 smb_panic("init_reg_q_enum_val: talloc fail\n");
01129                 return;
01130         }
01131         *q_u->name_len = 0x0;
01132 }

void init_reg_r_enum_val	(	REG_R_ENUM_VALUE *	r_u,
		REGISTRY_VALUE *	val
	)

parse_reg.c の 1138 行で定義されています。

参照先 REG_R_ENUM_VALUE::buffer_len1・REG_R_ENUM_VALUE::buffer_len2・get_talloc_ctx()・init_unistr4()・REG_R_ENUM_VALUE::name・reg_init_regval_buffer()・smb_panic()・REGISTRY_VALUE::type・REG_R_ENUM_VALUE::type・UNI_STR_TERMINATE・REG_R_ENUM_VALUE::value・REGISTRY_VALUE::valuename.

参照元 _reg_enum_value().

01139 {
01140         uint32 real_size;
01141         
01142         ZERO_STRUCTP(r_u);
01143 
01144         /* value name */
01145 
01146         DEBUG(10,("init_reg_r_enum_val: Valuename => [%s]\n", val->valuename));
01147         
01148         init_unistr4( &r_u->name, val->valuename, UNI_STR_TERMINATE);
01149                 
01150         /* type */
01151         
01152         r_u->type = TALLOC_P( get_talloc_ctx(), uint32 );
01153         if (!r_u->type) {
01154                 smb_panic("init_reg_r_enum_val: talloc fail\n");
01155                 return;
01156         }
01157         *r_u->type = val->type;
01158 
01159         /* REG_SZ & REG_MULTI_SZ must be converted to UNICODE */
01160         
01161         r_u->value = TALLOC_P( get_talloc_ctx(), REGVAL_BUFFER );
01162         if (!r_u->value) {
01163                 smb_panic("init_reg_r_enum_val: talloc fail\n");
01164                 return;
01165         }
01166         real_size = reg_init_regval_buffer( r_u->value, val );
01167         
01168         /* lengths */
01169 
01170         r_u->buffer_len1 = TALLOC_P( get_talloc_ctx(), uint32 );
01171         if (!r_u->buffer_len1) {
01172                 smb_panic("init_reg_r_enum_val: talloc fail\n");
01173                 return;
01174         }
01175         *r_u->buffer_len1 = real_size;
01176         r_u->buffer_len2 = TALLOC_P( get_talloc_ctx(), uint32 );
01177         if (!r_u->buffer_len2) {
01178                 smb_panic("init_reg_r_enum_val: talloc fail\n");
01179                 return;
01180         }
01181         *r_u->buffer_len2 = real_size;
01182 }

BOOL reg_io_q_enum_val	(	const char *	desc,
		REG_Q_ENUM_VALUE *	q_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 1188 行で定義されています。

参照先 REG_Q_ENUM_VALUE::buffer_len・REG_Q_ENUM_VALUE::name・REG_Q_ENUM_VALUE::name_len・REG_Q_ENUM_VALUE::pol・prs_debug()・prs_unistr4()・smb_io_pol_hnd()・smb_io_regval_buffer()・REG_Q_ENUM_VALUE::type・REG_Q_ENUM_VALUE::val_index・REG_Q_ENUM_VALUE::value.

参照元 api_reg_enum_value()・rpccli_reg_enum_val().

01189 {
01190         if (q_u == NULL)
01191                 return False;
01192 
01193         prs_debug(ps, depth, desc, "reg_io_q_enum_val");
01194         depth++;
01195 
01196         if(!prs_align(ps))
01197                 return False;
01198         
01199         if(!smb_io_pol_hnd("", &q_u->pol, ps, depth))
01200                 return False;
01201         
01202         if(!prs_uint32("val_index", ps, depth, &q_u->val_index))
01203                 return False;
01204                 
01205         if(!prs_unistr4("name", ps, depth, &q_u->name ))
01206                 return False;
01207         if(!prs_align(ps))
01208                 return False;
01209 
01210         if(!prs_pointer("type", ps, depth, (void**)&q_u->type, sizeof(uint32), (PRS_POINTER_CAST)prs_uint32))
01211                 return False;
01212 
01213         if ( !prs_pointer("value", ps, depth, (void**)&q_u->value, sizeof(REGVAL_BUFFER), (PRS_POINTER_CAST)smb_io_regval_buffer))
01214                 return False;
01215         if(!prs_align(ps))
01216                 return False;
01217 
01218         if(!prs_pointer("buffer_len", ps, depth, (void**)&q_u->buffer_len, sizeof(uint32), (PRS_POINTER_CAST)prs_uint32))
01219                 return False;
01220         if(!prs_pointer("name_len", ps, depth, (void**)&q_u->name_len, sizeof(uint32), (PRS_POINTER_CAST)prs_uint32))
01221                 return False;
01222 
01223         return True;
01224 }

BOOL reg_io_r_enum_val	(	const char *	desc,
		REG_R_ENUM_VALUE *	r_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 1230 行で定義されています。

参照先 REG_R_ENUM_VALUE::buffer_len1・REG_R_ENUM_VALUE::buffer_len2・REG_R_ENUM_VALUE::name・prs_debug()・prs_unistr4()・smb_io_regval_buffer()・REG_R_ENUM_VALUE::status・REG_R_ENUM_VALUE::type・REG_R_ENUM_VALUE::value.

参照元 api_reg_enum_value()・rpccli_reg_enum_val().

01231 {
01232         if ( !r_u )
01233                 return False;
01234 
01235         prs_debug(ps, depth, desc, "reg_io_r_enum_val");
01236         depth++;
01237 
01238         if(!prs_align(ps))
01239                 return False;
01240         
01241         if(!prs_unistr4("name", ps, depth, &r_u->name ))
01242                 return False;
01243         if(!prs_align(ps))
01244                 return False;
01245 
01246         if(!prs_pointer("type", ps, depth, (void**)&r_u->type, sizeof(uint32), (PRS_POINTER_CAST)prs_uint32))
01247                 return False;
01248 
01249         if ( !prs_pointer("value", ps, depth, (void**)&r_u->value, sizeof(REGVAL_BUFFER), (PRS_POINTER_CAST)smb_io_regval_buffer))
01250                 return False;
01251         if(!prs_align(ps))
01252                 return False;
01253 
01254         if(!prs_pointer("buffer_len1", ps, depth, (void**)&r_u->buffer_len1, sizeof(uint32), (PRS_POINTER_CAST)prs_uint32))
01255                 return False;
01256         if(!prs_pointer("buffer_len2", ps, depth, (void**)&r_u->buffer_len2, sizeof(uint32), (PRS_POINTER_CAST)prs_uint32))
01257                 return False;
01258 
01259         if(!prs_werror("status", ps, depth, &r_u->status))
01260                 return False;
01261 
01262         return True;
01263 }

void init_reg_q_set_val	(	REG_Q_SET_VALUE *	q_u,
		POLICY_HND *	pol,
		char *	val_name,
		uint32	type,
		RPC_DATA_BLOB *	val
	)

parse_reg.c の 1269 行で定義されています。

参照先 RPC_DATA_BLOB::buf_len・REG_Q_SET_VALUE::handle・init_unistr4()・REG_Q_SET_VALUE::name・pol・REG_Q_SET_VALUE::size・REG_Q_SET_VALUE::type・UNI_STR_TERMINATE・REG_Q_SET_VALUE::value.

参照元 rpccli_reg_set_val().

01272 {
01273         ZERO_STRUCTP(q_u);
01274 
01275         memcpy(&q_u->handle, pol, sizeof(q_u->handle));
01276 
01277         init_unistr4(&q_u->name, val_name, UNI_STR_TERMINATE);
01278         
01279         q_u->type      = type;
01280         q_u->value     = *val;
01281         q_u->size      = val->buf_len;
01282 }

BOOL reg_io_q_set_value	(	const char *	desc,
		REG_Q_SET_VALUE *	q_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 1288 行で定義されています。

参照先 REG_Q_SET_VALUE::handle・REG_Q_SET_VALUE::name・prs_debug()・prs_unistr4()・REG_Q_SET_VALUE::size・smb_io_pol_hnd()・smb_io_rpc_blob()・REG_Q_SET_VALUE::type・REG_Q_SET_VALUE::value.

参照元 api_reg_set_value()・rpccli_reg_set_val().

01289 {
01290         if (q_u == NULL)
01291                 return False;
01292 
01293         prs_debug(ps, depth, desc, "reg_io_q_set_value");
01294         depth++;
01295 
01296         if(!prs_align(ps))
01297                 return False;
01298         
01299         if(!smb_io_pol_hnd("", &q_u->handle, ps, depth))
01300                 return False;
01301         
01302         if(!prs_unistr4("name", ps, depth, &q_u->name ))
01303                 return False;
01304         if(!prs_align(ps))
01305                 return False;
01306 
01307         if(!prs_uint32("type", ps, depth, &q_u->type))
01308                 return False;
01309 
01310         if(!smb_io_rpc_blob("value", &q_u->value, ps, depth ))
01311                 return False;
01312         if(!prs_align(ps))
01313                 return False;
01314 
01315         if(!prs_uint32("size", ps, depth, &q_u->size))
01316                 return False;
01317 
01318         return True;
01319 }

BOOL reg_io_r_set_value	(	const char *	desc,
		REG_R_SET_VALUE *	q_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 1325 行で定義されています。

参照先 prs_debug()・REG_R_SET_VALUE::status.

参照元 api_reg_set_value()・rpccli_reg_set_val().

01326 {
01327         if ( !q_u )
01328                 return False;
01329 
01330         prs_debug(ps, depth, desc, "reg_io_r_set_value");
01331         depth++;
01332 
01333         if(!prs_align(ps))
01334                 return False;
01335         
01336         if(!prs_werror("status", ps, depth, &q_u->status))
01337                 return False;
01338 
01339         return True;
01340 }

void init_reg_q_enum_key	(	REG_Q_ENUM_KEY *	q_u,
		POLICY_HND *	pol,
		uint32	key_idx
	)

parse_reg.c の 1346 行で定義されています。

参照先 REG_Q_ENUM_KEY::key_index・REG_Q_ENUM_KEY::key_name_len・REG_Q_ENUM_KEY::pad1・REG_Q_ENUM_KEY::pad2・pol・REG_Q_ENUM_KEY::pol・REG_Q_ENUM_KEY::ptr1・REG_Q_ENUM_KEY::ptr2・REG_Q_ENUM_KEY::ptr3・REG_Q_ENUM_KEY::time・unix_to_nt_time()・REG_Q_ENUM_KEY::unknown_1・REG_Q_ENUM_KEY::unknown_2.

参照元 rpccli_reg_enum_key().

01347 {
01348         memcpy(&q_u->pol, pol, sizeof(q_u->pol));
01349 
01350         q_u->key_index = key_idx;
01351         q_u->key_name_len = 0;
01352         q_u->unknown_1 = 0x0414;
01353 
01354         q_u->ptr1 = 1;
01355         q_u->unknown_2 = 0x0000020A;
01356         memset(q_u->pad1, 0, sizeof(q_u->pad1));
01357 
01358         q_u->ptr2 = 1;
01359         memset(q_u->pad2, 0, sizeof(q_u->pad2));
01360 
01361         q_u->ptr3 = 1;
01362         unix_to_nt_time(&q_u->time, 0);            /* current time? */
01363 }

void init_reg_r_enum_key	(	REG_R_ENUM_KEY *	r_u,
		char *	subkey
	)

parse_reg.c の 1369 行で定義されています。

参照先 REG_R_ENUM_KEY::classname・get_talloc_ctx()・init_unistr4()・REG_R_ENUM_KEY::keyname・smb_panic()・REG_R_ENUM_KEY::time・UNI_STR_TERMINATE.

参照元 _reg_enum_key().

01370 {
01371         if ( !r_u )
01372                 return;
01373                 
01374         init_unistr4( &r_u->keyname, subkey, UNI_STR_TERMINATE );
01375         r_u->classname = TALLOC_ZERO_P( get_talloc_ctx(), UNISTR4 );
01376         if (!r_u->classname) {
01377                 smb_panic("init_reg_r_enum_key: talloc fail\n");
01378                 return;
01379         }
01380         r_u->time = TALLOC_ZERO_P( get_talloc_ctx(), NTTIME );
01381         if (!r_u->time) {
01382                 smb_panic("init_reg_r_enum_key: talloc fail\n");
01383                 return;
01384         }
01385 }

BOOL reg_io_q_enum_key	(	const char *	desc,
		REG_Q_ENUM_KEY *	q_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 1391 行で定義されています。

参照先 REG_Q_ENUM_KEY::key_index・REG_Q_ENUM_KEY::key_name_len・REG_Q_ENUM_KEY::pad1・REG_Q_ENUM_KEY::pad2・REG_Q_ENUM_KEY::pol・prs_debug()・REG_Q_ENUM_KEY::ptr1・REG_Q_ENUM_KEY::ptr2・REG_Q_ENUM_KEY::ptr3・smb_io_pol_hnd()・smb_io_time()・REG_Q_ENUM_KEY::time・REG_Q_ENUM_KEY::unknown_1・REG_Q_ENUM_KEY::unknown_2.

参照元 api_reg_enum_key()・rpccli_reg_enum_key().

01392 {
01393         if (q_u == NULL)
01394                 return False;
01395 
01396         prs_debug(ps, depth, desc, "reg_io_q_enum_key");
01397         depth++;
01398 
01399         if(!prs_align(ps))
01400                 return False;
01401         
01402         if(!smb_io_pol_hnd("", &q_u->pol, ps, depth))
01403                 return False;
01404         
01405         if(!prs_uint32("key_index", ps, depth, &q_u->key_index))
01406                 return False;
01407         if(!prs_uint16("key_name_len", ps, depth, &q_u->key_name_len))
01408                 return False;
01409         if(!prs_uint16("unknown_1", ps, depth, &q_u->unknown_1))
01410                 return False;
01411 
01412         if(!prs_uint32("ptr1", ps, depth, &q_u->ptr1))
01413                 return False;
01414 
01415         if (q_u->ptr1 != 0) {
01416                 if(!prs_uint32("unknown_2", ps, depth, &q_u->unknown_2))
01417                         return False;
01418                 if(!prs_uint8s(False, "pad1", ps, depth, q_u->pad1, sizeof(q_u->pad1)))
01419                         return False;
01420         }
01421 
01422         if(!prs_uint32("ptr2", ps, depth, &q_u->ptr2))
01423                 return False;
01424 
01425         if (q_u->ptr2 != 0) {
01426                 if(!prs_uint8s(False, "pad2", ps, depth, q_u->pad2, sizeof(q_u->pad2)))
01427                         return False;
01428         }
01429 
01430         if(!prs_uint32("ptr3", ps, depth, &q_u->ptr3))
01431                 return False;
01432 
01433         if (q_u->ptr3 != 0) {
01434                 if(!smb_io_time("", &q_u->time, ps, depth))
01435                         return False;
01436         }
01437 
01438         return True;
01439 }

BOOL reg_io_r_enum_key	(	const char *	desc,
		REG_R_ENUM_KEY *	q_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 1445 行で定義されています。

参照先 REG_R_ENUM_KEY::classname・REG_R_ENUM_KEY::keyname・prs_debug()・prs_unistr4()・smb_io_nttime()・REG_R_ENUM_KEY::status・REG_R_ENUM_KEY::time.

参照元 api_reg_enum_key()・rpccli_reg_enum_key().

01446 {
01447         if ( !q_u )
01448                 return False;
01449 
01450         prs_debug(ps, depth, desc, "reg_io_r_enum_key");
01451         depth++;
01452 
01453         if(!prs_align(ps))
01454                 return False;
01455         if ( !prs_unistr4( "keyname", ps, depth, &q_u->keyname ) )
01456                 return False;
01457         
01458         if(!prs_align(ps))
01459                 return False;
01460         if (!prs_pointer("class", ps, depth, (void**)&q_u->classname, sizeof(UNISTR4), (PRS_POINTER_CAST)prs_unistr4))
01461                 return False;
01462 
01463         if(!prs_align(ps))
01464                 return False;
01465         if (!prs_pointer("time", ps, depth, (void**)&q_u->time, sizeof(NTTIME), (PRS_POINTER_CAST)smb_io_nttime))
01466                 return False;
01467 
01468         if(!prs_align(ps))
01469                 return False;
01470         if(!prs_werror("status", ps, depth, &q_u->status))
01471                 return False;
01472 
01473         return True;
01474 }

void init_reg_q_open_entry	(	REG_Q_OPEN_ENTRY *	q_u,
		POLICY_HND *	pol,
		char *	key_name,
		uint32	access_desired
	)

parse_reg.c の 1480 行で定義されています。

参照先 REG_Q_OPEN_ENTRY::access・init_unistr4()・REG_Q_OPEN_ENTRY::name・pol・REG_Q_OPEN_ENTRY::pol・UNI_STR_TERMINATE・REG_Q_OPEN_ENTRY::unknown_0.

参照元 rpccli_reg_open_entry().

01482 {
01483         memcpy(&q_u->pol, pol, sizeof(q_u->pol));
01484 
01485         init_unistr4(&q_u->name, key_name, UNI_STR_TERMINATE);
01486 
01487         q_u->unknown_0 = 0x00000000;
01488         q_u->access = access_desired;
01489 }

BOOL reg_io_q_open_entry	(	const char *	desc,
		REG_Q_OPEN_ENTRY *	q_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 1495 行で定義されています。

参照先 REG_Q_OPEN_ENTRY::access・REG_Q_OPEN_ENTRY::name・REG_Q_OPEN_ENTRY::pol・prs_debug()・prs_unistr4()・smb_io_pol_hnd()・REG_Q_OPEN_ENTRY::unknown_0.

参照元 api_reg_open_entry()・rpccli_reg_open_entry().

01496 {
01497         if ( !q_u )
01498                 return False;
01499 
01500         prs_debug(ps, depth, desc, "reg_io_q_open_entry");
01501         depth++;
01502 
01503         if(!prs_align(ps))
01504                 return False;
01505         
01506         if(!smb_io_pol_hnd("", &q_u->pol, ps, depth))
01507                 return False;
01508         if(!prs_unistr4("name", ps, depth, &q_u->name))
01509                 return False;
01510 
01511         if(!prs_align(ps))
01512                 return False;
01513         
01514         if(!prs_uint32("unknown_0        ", ps, depth, &q_u->unknown_0))
01515                 return False;
01516         if(!prs_uint32("access", ps, depth, &q_u->access))
01517                 return False;
01518 
01519         return True;
01520 }

BOOL reg_io_r_open_entry	(	const char *	desc,
		REG_R_OPEN_ENTRY *	r_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 1526 行で定義されています。

参照先 REG_R_OPEN_ENTRY::handle・prs_debug()・smb_io_pol_hnd()・REG_R_OPEN_ENTRY::status.

参照元 api_reg_open_entry()・rpccli_reg_open_entry().

01527 {
01528         if ( !r_u )
01529                 return False;
01530 
01531         prs_debug(ps, depth, desc, "reg_io_r_open_entry");
01532         depth++;
01533 
01534         if(!prs_align(ps))
01535                 return False;
01536         
01537         if(!smb_io_pol_hnd("handle", &r_u->handle, ps, depth))
01538                 return False;
01539 
01540         if(!prs_werror("status", ps, depth, &r_u->status))
01541                 return False;
01542 
01543         return True;
01544 }

void init_reg_q_shutdown	(	REG_Q_SHUTDOWN *	q_u,
		const char *	msg,
		uint32	timeout,
		BOOL	do_reboot,
		BOOL	force
	)

parse_reg.c の 1550 行で定義されています。

参照先 REG_Q_SHUTDOWN::force・get_talloc_ctx()・init_unistr4()・REG_Q_SHUTDOWN::message・REG_Q_SHUTDOWN::reboot・REG_Q_SHUTDOWN::server・UNISTR4::size・smb_panic()・UNISTR4::string・REG_Q_SHUTDOWN::timeout・UNI_FLAGS_NONE・UNISTR2::uni_max_len.

参照元 init_reg_q_shutdown_ex()・rpccli_reg_shutdown().

01552 {
01553         q_u->server = TALLOC_P( get_talloc_ctx(), uint16 );
01554         if (!q_u->server) {
01555                 smb_panic("init_reg_q_shutdown: talloc fail\n");
01556                 return;
01557         }
01558         *q_u->server = 0x1;
01559 
01560         q_u->message = TALLOC_ZERO_P( get_talloc_ctx(), UNISTR4 );
01561         if (!q_u->message) {
01562                 smb_panic("init_reg_q_shutdown: talloc fail\n");
01563                 return;
01564         }
01565 
01566         if ( msg && *msg ) { 
01567                 init_unistr4( q_u->message, msg, UNI_FLAGS_NONE );
01568 
01569                 /* Win2000 is apparently very sensitive to these lengths */
01570                 /* do a special case here */
01571 
01572                 q_u->message->string->uni_max_len++;
01573                 q_u->message->size += 2;
01574 
01575         }
01576 
01577         q_u->timeout = timeout;
01578 
01579         q_u->reboot = do_reboot ? 1 : 0;
01580         q_u->force = force ? 1 : 0;
01581 }

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
	)

parse_reg.c の 1587 行で定義されています。

参照先 REG_Q_SHUTDOWN::force・REG_Q_SHUTDOWN_EX::force・init_reg_q_shutdown()・REG_Q_SHUTDOWN::message・REG_Q_SHUTDOWN_EX::message・REG_Q_SHUTDOWN_EX::reason・REG_Q_SHUTDOWN::reboot・REG_Q_SHUTDOWN_EX::reboot・REG_Q_SHUTDOWN::server・REG_Q_SHUTDOWN_EX::server.

01589 {
01590         REG_Q_SHUTDOWN q_u;
01591         
01592         ZERO_STRUCT( q_u );
01593         
01594         init_reg_q_shutdown( &q_u, msg, timeout, do_reboot, force );
01595         
01596         /* steal memory */
01597         
01598         q_u_ex->server  = q_u.server;
01599         q_u_ex->message = q_u.message;
01600         
01601         q_u_ex->reboot  = q_u.reboot;
01602         q_u_ex->force   = q_u.force;
01603         
01604         q_u_ex->reason = reason;
01605 }

BOOL reg_io_q_shutdown	(	const char *	desc,
		REG_Q_SHUTDOWN *	q_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 1611 行で定義されています。

参照先 REG_Q_SHUTDOWN::force・REG_Q_SHUTDOWN::message・prs_debug()・prs_unistr4()・REG_Q_SHUTDOWN::reboot・REG_Q_SHUTDOWN::server・REG_Q_SHUTDOWN::timeout.

参照元 api_reg_shutdown()・rpccli_reg_shutdown().

01613 {
01614         if ( !q_u )
01615                 return False;
01616 
01617         prs_debug(ps, depth, desc, "reg_io_q_shutdown");
01618         depth++;
01619 
01620         if (!prs_align(ps))
01621                 return False;
01622 
01623         if (!prs_pointer("server", ps, depth, (void**)&q_u->server, sizeof(uint16), (PRS_POINTER_CAST)prs_uint16))
01624                 return False;
01625         if (!prs_align(ps))
01626                 return False;
01627 
01628         if (!prs_pointer("message", ps, depth, (void**)&q_u->message, sizeof(UNISTR4), (PRS_POINTER_CAST)prs_unistr4))
01629                 return False;
01630 
01631         if (!prs_align(ps))
01632                 return False;
01633 
01634         if (!prs_uint32("timeout", ps, depth, &(q_u->timeout)))
01635                 return False;
01636 
01637         if (!prs_uint8("force  ", ps, depth, &(q_u->force)))
01638                 return False;
01639         if (!prs_uint8("reboot ", ps, depth, &(q_u->reboot)))
01640                 return False;
01641 
01642 
01643         return True;
01644 }

BOOL reg_io_r_shutdown	(	const char *	desc,
		REG_R_SHUTDOWN *	r_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 1649 行で定義されています。

参照先 prs_debug()・REG_R_SHUTDOWN::status.

参照元 api_reg_shutdown()・rpccli_reg_shutdown().

01651 {
01652         if ( !r_u )
01653                 return False;
01654 
01655         prs_debug(ps, depth, desc, "reg_io_r_shutdown");
01656         depth++;
01657 
01658         if(!prs_align(ps))
01659                 return False;
01660 
01661         if(!prs_werror("status", ps, depth, &r_u->status))
01662                 return False;
01663 
01664         return True;
01665 }

BOOL reg_io_q_shutdown_ex	(	const char *	desc,
		REG_Q_SHUTDOWN_EX *	q_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 1671 行で定義されています。

参照先 REG_Q_SHUTDOWN_EX::force・REG_Q_SHUTDOWN_EX::message・prs_debug()・prs_unistr4()・REG_Q_SHUTDOWN_EX::reason・REG_Q_SHUTDOWN_EX::reboot・REG_Q_SHUTDOWN_EX::server・REG_Q_SHUTDOWN_EX::timeout.

参照元 api_reg_shutdown_ex().

01673 {
01674         if ( !q_u )
01675                 return False;
01676 
01677         prs_debug(ps, depth, desc, "reg_io_q_shutdown_ex");
01678         depth++;
01679 
01680         if (!prs_align(ps))
01681                 return False;
01682 
01683         if (!prs_pointer("server", ps, depth, (void**)&q_u->server, sizeof(uint16), (PRS_POINTER_CAST)prs_uint16))
01684                 return False;
01685         if (!prs_align(ps))
01686                 return False;
01687 
01688         if (!prs_pointer("message", ps, depth, (void**)&q_u->message, sizeof(UNISTR4), (PRS_POINTER_CAST)prs_unistr4))
01689                 return False;
01690 
01691         if (!prs_align(ps))
01692                 return False;
01693 
01694         if (!prs_uint32("timeout", ps, depth, &(q_u->timeout)))
01695                 return False;
01696 
01697         if (!prs_uint8("force  ", ps, depth, &(q_u->force)))
01698                 return False;
01699         if (!prs_uint8("reboot ", ps, depth, &(q_u->reboot)))
01700                 return False;
01701 
01702         if (!prs_align(ps))
01703                 return False;
01704         if (!prs_uint32("reason", ps, depth, &(q_u->reason)))
01705                 return False;
01706 
01707 
01708         return True;
01709 }

BOOL reg_io_r_shutdown_ex	(	const char *	desc,
		REG_R_SHUTDOWN_EX *	r_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 1714 行で定義されています。

参照先 prs_debug()・REG_R_SHUTDOWN_EX::status.

参照元 api_reg_shutdown_ex().

01716 {
01717         if ( !r_u )
01718                 return False;
01719 
01720         prs_debug(ps, depth, desc, "reg_io_r_shutdown_ex");
01721         depth++;
01722 
01723         if(!prs_align(ps))
01724                 return False;
01725 
01726         if(!prs_werror("status", ps, depth, &r_u->status))
01727                 return False;
01728 
01729         return True;
01730 }

void init_reg_q_abort_shutdown ( REG_Q_ABORT_SHUTDOWN * q_u )

parse_reg.c の 1736 行で定義されています。

参照先 get_talloc_ctx()・REG_Q_ABORT_SHUTDOWN::server・smb_panic().

01737 {
01738         q_u->server = TALLOC_P( get_talloc_ctx(), uint16 );
01739         if (!q_u->server) {
01740                 smb_panic("init_reg_q_abort_shutdown: talloc fail\n");
01741                 return;
01742         }
01743         *q_u->server = 0x1;
01744 }

BOOL reg_io_q_abort_shutdown	(	const char *	desc,
		REG_Q_ABORT_SHUTDOWN *	q_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 1750 行で定義されています。

参照先 prs_debug()・REG_Q_ABORT_SHUTDOWN::server.

参照元 api_reg_abort_shutdown()・rpccli_reg_abort_shutdown().

01752 {
01753         if ( !q_u )
01754                 return False;
01755 
01756         prs_debug(ps, depth, desc, "reg_io_q_abort_shutdown");
01757         depth++;
01758 
01759         if (!prs_align(ps))
01760                 return False;
01761 
01762         if (!prs_pointer("server", ps, depth, (void**)&q_u->server, sizeof(uint16), (PRS_POINTER_CAST)prs_uint16))
01763                 return False;
01764         if (!prs_align(ps))
01765                 return False;
01766 
01767         return True;
01768 }

BOOL reg_io_r_abort_shutdown	(	const char *	desc,
		REG_R_ABORT_SHUTDOWN *	r_u,
		prs_struct *	ps,
		int	depth
	)

parse_reg.c の 1773 行で定義されています。

参照先 prs_debug()・REG_R_ABORT_SHUTDOWN::status.

参照元 api_reg_abort_shutdown()・rpccli_reg_abort_shutdown().

01775 {
01776         if ( !r_u )
01777                 return False;
01778 
01779         prs_debug(ps, depth, desc, "reg_io_r_abort_shutdown");
01780         depth++;
01781 
01782         if (!prs_align(ps))
01783                 return False;
01784 
01785         if (!prs_werror("status", ps, depth, &r_u->status))
01786                 return False;
01787 
01788         return True;
01789 }


関数
uint32	reg_init_regval_buffer (REGVAL_BUFFER buf2, REGISTRY_VALUE val)
void	init_reg_q_open_hive (REG_Q_OPEN_HIVE *q_o, uint32 access_desired)
BOOL	reg_io_q_open_hive (const char desc, REG_Q_OPEN_HIVE q_u, prs_struct *ps, int depth)
BOOL	reg_io_r_open_hive (const char desc, REG_R_OPEN_HIVE r_u, prs_struct *ps, int depth)
void	init_reg_q_flush_key (REG_Q_FLUSH_KEY q_u, POLICY_HND pol)
BOOL	reg_io_q_flush_key (const char desc, REG_Q_FLUSH_KEY q_u, prs_struct *ps, int depth)
BOOL	reg_io_r_flush_key (const char desc, REG_R_FLUSH_KEY r_u, prs_struct *ps, int depth)
static BOOL	reg_io_hdrbuf_sec (uint32 ptr, uint32 ptr3, BUFHDR hdr_sec, SEC_DESC_BUF data, prs_struct ps, int depth)
void	init_reg_q_create_key_ex (REG_Q_CREATE_KEY_EX q_c, POLICY_HND hnd, char name, char key_class, uint32 access_desired, SEC_DESC_BUF *sec_buf)
BOOL	reg_io_q_create_key_ex (const char desc, REG_Q_CREATE_KEY_EX q_u, prs_struct *ps, int depth)
BOOL	reg_io_r_create_key_ex (const char desc, REG_R_CREATE_KEY_EX r_u, prs_struct *ps, int depth)
void	init_reg_q_delete_val (REG_Q_DELETE_VALUE q_c, POLICY_HND hnd, char *name)
BOOL	reg_io_q_delete_value (const char desc, REG_Q_DELETE_VALUE q_u, prs_struct *ps, int depth)
BOOL	reg_io_r_delete_value (const char desc, REG_R_DELETE_VALUE r_u, prs_struct *ps, int depth)
void	init_reg_q_delete_key (REG_Q_DELETE_KEY q_c, POLICY_HND hnd, char *name)
BOOL	reg_io_q_delete_key (const char desc, REG_Q_DELETE_KEY q_u, prs_struct *ps, int depth)
BOOL	reg_io_r_delete_key (const char desc, REG_R_DELETE_KEY r_u, prs_struct *ps, int depth)
void	init_reg_q_query_key (REG_Q_QUERY_KEY q_o, POLICY_HND hnd, const char *key_class)
BOOL	reg_io_q_query_key (const char desc, REG_Q_QUERY_KEY q_u, prs_struct *ps, int depth)
BOOL	reg_io_r_query_key (const char desc, REG_R_QUERY_KEY r_u, prs_struct *ps, int depth)
void	init_reg_q_getversion (REG_Q_GETVERSION q_o, POLICY_HND hnd)
BOOL	reg_io_q_getversion (const char desc, REG_Q_GETVERSION q_u, prs_struct *ps, int depth)
BOOL	reg_io_r_getversion (const char desc, REG_R_GETVERSION r_u, prs_struct *ps, int depth)
BOOL	reg_io_q_restore_key (const char desc, REG_Q_RESTORE_KEY q_u, prs_struct *ps, int depth)
BOOL	reg_io_r_restore_key (const char desc, REG_R_RESTORE_KEY r_u, prs_struct *ps, int depth)
void	init_q_reg_save_key (REG_Q_SAVE_KEY q_u, POLICY_HND handle, const char *fname)
BOOL	reg_io_q_save_key (const char desc, REG_Q_SAVE_KEY q_u, prs_struct *ps, int depth)
BOOL	reg_io_r_save_key (const char desc, REG_R_SAVE_KEY r_u, prs_struct *ps, int depth)
void	init_reg_q_close (REG_Q_CLOSE q_c, POLICY_HND hnd)
BOOL	reg_io_q_close (const char desc, REG_Q_CLOSE q_u, prs_struct *ps, int depth)
BOOL	reg_io_r_close (const char desc, REG_R_CLOSE r_u, prs_struct *ps, int depth)
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)
BOOL	reg_io_q_set_key_sec (const char desc, REG_Q_SET_KEY_SEC q_u, prs_struct *ps, int depth)
BOOL	reg_io_r_set_key_sec (const char desc, REG_R_SET_KEY_SEC q_u, prs_struct *ps, int depth)
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)
BOOL	reg_io_q_get_key_sec (const char desc, REG_Q_GET_KEY_SEC q_u, prs_struct *ps, int depth)
void	init_reg_r_get_key_sec (REG_R_GET_KEY_SEC r_i, POLICY_HND pol, uint32 buf_len, uint8 *buf, NTSTATUS status)
BOOL	reg_io_r_get_key_sec (const char desc, REG_R_GET_KEY_SEC q_u, prs_struct *ps, int depth)
BOOL	init_reg_q_query_value (REG_Q_QUERY_VALUE q_u, POLICY_HND pol, const char val_name, REGVAL_BUFFER value_output)
BOOL	reg_io_q_query_value (const char desc, REG_Q_QUERY_VALUE q_u, prs_struct *ps, int depth)
BOOL	init_reg_r_query_value (uint32 include_keyval, REG_R_QUERY_VALUE r_u, REGISTRY_VALUE val, WERROR status)
BOOL	reg_io_r_query_value (const char desc, REG_R_QUERY_VALUE r_u, prs_struct *ps, int depth)
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)
void	init_reg_r_enum_val (REG_R_ENUM_VALUE r_u, REGISTRY_VALUE val)
BOOL	reg_io_q_enum_val (const char desc, REG_Q_ENUM_VALUE q_u, prs_struct *ps, int depth)
BOOL	reg_io_r_enum_val (const char desc, REG_R_ENUM_VALUE r_u, prs_struct *ps, int depth)
void	init_reg_q_set_val (REG_Q_SET_VALUE q_u, POLICY_HND pol, char val_name, uint32 type, RPC_DATA_BLOB val)
BOOL	reg_io_q_set_value (const char desc, REG_Q_SET_VALUE q_u, prs_struct *ps, int depth)
BOOL	reg_io_r_set_value (const char desc, REG_R_SET_VALUE q_u, prs_struct *ps, int depth)
void	init_reg_q_enum_key (REG_Q_ENUM_KEY q_u, POLICY_HND pol, uint32 key_idx)
void	init_reg_r_enum_key (REG_R_ENUM_KEY r_u, char subkey)
BOOL	reg_io_q_enum_key (const char desc, REG_Q_ENUM_KEY q_u, prs_struct *ps, int depth)
BOOL	reg_io_r_enum_key (const char desc, REG_R_ENUM_KEY q_u, prs_struct *ps, int depth)
void	init_reg_q_open_entry (REG_Q_OPEN_ENTRY q_u, POLICY_HND pol, char *key_name, uint32 access_desired)
BOOL	reg_io_q_open_entry (const char desc, REG_Q_OPEN_ENTRY q_u, prs_struct *ps, int depth)
BOOL	reg_io_r_open_entry (const char desc, REG_R_OPEN_ENTRY r_u, prs_struct *ps, int depth)
void	init_reg_q_shutdown (REG_Q_SHUTDOWN q_u, const char msg, uint32 timeout, BOOL do_reboot, BOOL force)
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)
BOOL	reg_io_q_shutdown (const char desc, REG_Q_SHUTDOWN q_u, prs_struct *ps, int depth)
BOOL	reg_io_r_shutdown (const char desc, REG_R_SHUTDOWN r_u, prs_struct *ps, int depth)
BOOL	reg_io_q_shutdown_ex (const char desc, REG_Q_SHUTDOWN_EX q_u, prs_struct *ps, int depth)
BOOL	reg_io_r_shutdown_ex (const char desc, REG_R_SHUTDOWN_EX r_u, prs_struct *ps, int depth)
void	init_reg_q_abort_shutdown (REG_Q_ABORT_SHUTDOWN *q_u)
BOOL	reg_io_q_abort_shutdown (const char desc, REG_Q_ABORT_SHUTDOWN q_u, prs_struct *ps, int depth)
BOOL	reg_io_r_abort_shutdown (const char desc, REG_R_ABORT_SHUTDOWN r_u, prs_struct *ps, int depth)

rpc_parse/parse_reg.c

関数

関数