Samba: rpc_parse/parse

const char* cli_get_pipe_name ( int pipe_idx )

parse_rpc.c の 233 行で定義されています。

参照先 pipe_id_info::client_pipe・pipe_names.

参照元 cli_rpc_pipe_open()・cli_rpc_pipe_open_noauth()・do_cmd()・run_rpc_command().

00234 {
00235         return &pipe_names[pipe_idx].client_pipe[5];
00236 }

void init_rpc_hdr	(	RPC_HDR *	hdr,
		enum RPC_PKT_TYPE	pkt_type,
		uint8	flags,
		uint32	call_id,
		int	data_len,
		int	auth_len
	)

parse_rpc.c の 242 行で定義されています。

参照先 rpc_hdr_info::auth_len・rpc_hdr_info::call_id・rpc_hdr_info::flags・rpc_hdr_info::frag_len・rpc_hdr_info::major・rpc_hdr_info::minor・rpc_hdr_info::pack_type・rpc_hdr_info::pkt_type.

参照元 api_pipe_alter_context()・create_bind_or_alt_ctx_internal()・create_rpc_bind_auth3()・rpc_api_pipe_req()・setup_bind_nak()・setup_cancel_ack_reply()・setup_fault_pdu().

00244 {
00245         hdr->major        = 5;               /* RPC version 5 */
00246         hdr->minor        = 0;               /* minor version 0 */
00247         hdr->pkt_type     = pkt_type;        /* RPC packet type */
00248         hdr->flags        = flags;           /* dce/rpc flags */
00249         hdr->pack_type[0] = 0x10;            /* little-endian data representation */
00250         hdr->pack_type[1] = 0;               /* packed data representation */
00251         hdr->pack_type[2] = 0;               /* packed data representation */
00252         hdr->pack_type[3] = 0;               /* packed data representation */
00253         hdr->frag_len     = data_len;        /* fragment length, fill in later */
00254         hdr->auth_len     = auth_len;        /* authentication length */
00255         hdr->call_id      = call_id;         /* call identifier - match incoming RPC */
00256 }

BOOL smb_io_rpc_hdr	(	const char *	desc,
		RPC_HDR *	rpc,
		prs_struct *	ps,
		int	depth
	)

parse_rpc.c の 262 行で定義されています。

参照先 rpc_hdr_info::auth_len・rpc_hdr_info::call_id・rpc_hdr_info::flags・rpc_hdr_info::frag_len・rpc_hdr_info::major・rpc_hdr_info::minor・rpc_hdr_info::pack_type・rpc_hdr_info::pkt_type・prs_debug().

参照元 api_pipe_alter_context()・cli_pipe_get_current_pdu()・create_bind_or_alt_ctx_internal()・create_next_pdu_noauth()・create_next_pdu_ntlmssp()・create_next_pdu_schannel()・create_rpc_bind_auth3()・rpc_api_pipe_req()・rpc_finish_spnego_ntlmssp_bind()・rpc_pipe_bind()・setup_bind_nak()・setup_cancel_ack_reply()・setup_fault_pdu()・unmarshall_rpc_header().

00263 {
00264         if (rpc == NULL)
00265                 return False;
00266 
00267         prs_debug(ps, depth, desc, "smb_io_rpc_hdr");
00268         depth++;
00269 
00270         if(!prs_uint8 ("major     ", ps, depth, &rpc->major))
00271                 return False;
00272 
00273         if(!prs_uint8 ("minor     ", ps, depth, &rpc->minor))
00274                 return False;
00275         if(!prs_uint8 ("pkt_type  ", ps, depth, &rpc->pkt_type))
00276                 return False;
00277         if(!prs_uint8 ("flags     ", ps, depth, &rpc->flags))
00278                 return False;
00279 
00280         /* We always marshall in little endian format. */
00281         if (MARSHALLING(ps))
00282                 rpc->pack_type[0] = 0x10;
00283 
00284         if(!prs_uint8("pack_type0", ps, depth, &rpc->pack_type[0]))
00285                 return False;
00286         if(!prs_uint8("pack_type1", ps, depth, &rpc->pack_type[1]))
00287                 return False;
00288         if(!prs_uint8("pack_type2", ps, depth, &rpc->pack_type[2]))
00289                 return False;
00290         if(!prs_uint8("pack_type3", ps, depth, &rpc->pack_type[3]))
00291                 return False;
00292 
00293         /*
00294          * If reading and pack_type[0] == 0 then the data is in big-endian
00295          * format. Set the flag in the prs_struct to specify reverse-endainness.
00296          */
00297 
00298         if (UNMARSHALLING(ps) && rpc->pack_type[0] == 0) {
00299                 DEBUG(10,("smb_io_rpc_hdr: PDU data format is big-endian. Setting flag.\n"));
00300                 prs_set_endian_data(ps, RPC_BIG_ENDIAN);
00301         }
00302 
00303         if(!prs_uint16("frag_len  ", ps, depth, &rpc->frag_len))
00304                 return False;
00305         if(!prs_uint16("auth_len  ", ps, depth, &rpc->auth_len))
00306                 return False;
00307         if(!prs_uint32("call_id   ", ps, depth, &rpc->call_id))
00308                 return False;
00309         return True;
00310 }

static BOOL smb_io_rpc_iface	(	const char *	desc,
		RPC_IFACE *	ifc,
		prs_struct *	ps,
		int	depth
	)			`[static]`

parse_rpc.c の 316 行で定義されています。

参照先 prs_debug()・smb_io_uuid()・rpc_iface_info::uuid・rpc_iface_info::version.

参照元 smb_io_rpc_context()・smb_io_rpc_hdr_ba().

00317 {
00318         if (ifc == NULL)
00319                 return False;
00320 
00321         prs_debug(ps, depth, desc, "smb_io_rpc_iface");
00322         depth++;
00323 
00324         if (!prs_align(ps))
00325                 return False;
00326 
00327         if (!smb_io_uuid(  "uuid", &ifc->uuid, ps, depth))
00328                 return False;
00329 
00330         if(!prs_uint32 ("version", ps, depth, &ifc->version))
00331                 return False;
00332 
00333         return True;
00334 }

static void init_rpc_addr_str	(	RPC_ADDR_STR *	str,
		const char *	name
	)			`[static]`

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

参照先 rpc_addr_info::len・rpc_addr_info::str.

参照元 init_rpc_hdr_ba().

00341 {
00342         str->len = strlen(name) + 1;
00343         fstrcpy(str->str, name);
00344 }

static BOOL smb_io_rpc_addr_str	(	const char *	desc,
		RPC_ADDR_STR *	str,
		prs_struct *	ps,
		int	depth
	)			`[static]`

parse_rpc.c の 350 行で定義されています。

参照先 rpc_addr_info::len・prs_debug()・rpc_addr_info::str.

参照元 smb_io_rpc_hdr_ba().

00351 {
00352         if (str == NULL)
00353                 return False;
00354 
00355         prs_debug(ps, depth, desc, "smb_io_rpc_addr_str");
00356         depth++;
00357         if(!prs_align(ps))
00358                 return False;
00359 
00360         if(!prs_uint16 (      "len", ps, depth, &str->len))
00361                 return False;
00362         if(!prs_uint8s (True, "str", ps, depth, (uchar*)str->str, MIN(str->len, sizeof(str->str)) ))
00363                 return False;
00364         return True;
00365 }

static void init_rpc_hdr_bba	(	RPC_HDR_BBA *	bba,
		uint16	max_tsize,
		uint16	max_rsize,
		uint32	assoc_gid
	)			`[static]`

parse_rpc.c の 371 行で定義されています。

参照先 rpc_hdr_bba_info::assoc_gid・rpc_hdr_bba_info::max_rsize・rpc_hdr_bba_info::max_tsize.

参照元 init_rpc_hdr_ba()・init_rpc_hdr_rb().

00372 {
00373         bba->max_tsize = max_tsize; /* maximum transmission fragment size (0x1630) */
00374         bba->max_rsize = max_rsize; /* max receive fragment size (0x1630) */   
00375         bba->assoc_gid = assoc_gid; /* associated group id (0x0) */ 
00376 }

static BOOL smb_io_rpc_hdr_bba	(	const char *	desc,
		RPC_HDR_BBA *	rpc,
		prs_struct *	ps,
		int	depth
	)			`[static]`

parse_rpc.c の 382 行で定義されています。

参照先 rpc_hdr_bba_info::assoc_gid・rpc_hdr_bba_info::max_rsize・rpc_hdr_bba_info::max_tsize・prs_debug().

参照元 smb_io_rpc_hdr_ba()・smb_io_rpc_hdr_rb().

00383 {
00384         if (rpc == NULL)
00385                 return False;
00386 
00387         prs_debug(ps, depth, desc, "smb_io_rpc_hdr_bba");
00388         depth++;
00389 
00390         if(!prs_uint16("max_tsize", ps, depth, &rpc->max_tsize))
00391                 return False;
00392         if(!prs_uint16("max_rsize", ps, depth, &rpc->max_rsize))
00393                 return False;
00394         if(!prs_uint32("assoc_gid", ps, depth, &rpc->assoc_gid))
00395                 return False;
00396         return True;
00397 }

void init_rpc_context	(	RPC_CONTEXT *	rpc_ctx,
		uint16	context_id,
		RPC_IFACE *	abstract,
		RPC_IFACE *	transfer
	)

parse_rpc.c の 404 行で定義されています。

参照先 rpc_context::abstract・rpc_context::context_id・rpc_context::num_transfer_syntaxes・rpc_context::transfer.

参照元 create_bind_or_alt_ctx_internal().

00405 {
00406         rpc_ctx->context_id   = context_id   ; /* presentation context identifier (0x0) */
00407         rpc_ctx->num_transfer_syntaxes = 1 ; /* the number of syntaxes (has always been 1?)(0x1) */
00408 
00409         /* num and vers. of interface client is using */
00410         rpc_ctx->abstract = *abstract;
00411 
00412         /* vers. of interface to use for replies */
00413         rpc_ctx->transfer = transfer;
00414 }

void init_rpc_hdr_rb	(	RPC_HDR_RB *	rpc,
		uint16	max_tsize,
		uint16	max_rsize,
		uint32	assoc_gid,
		RPC_CONTEXT *	context
	)

parse_rpc.c の 421 行で定義されています。

参照先 rpc_bind_req_info::bba・init_rpc_hdr_bba()・rpc_bind_req_info::num_contexts・rpc_bind_req_info::rpc_context.

参照元 create_bind_or_alt_ctx_internal().

00424 {
00425         init_rpc_hdr_bba(&rpc->bba, max_tsize, max_rsize, assoc_gid);
00426 
00427         rpc->num_contexts = 1;
00428         rpc->rpc_context = context;
00429 }

BOOL smb_io_rpc_context	(	const char *	desc,
		RPC_CONTEXT *	rpc_ctx,
		prs_struct *	ps,
		int	depth
	)

parse_rpc.c の 435 行で定義されています。

参照先 rpc_context::abstract・rpc_context::context_id・rpc_context::num_transfer_syntaxes・smb_io_rpc_iface()・rpc_context::transfer.

参照元 smb_io_rpc_hdr_rb().

00436 {
00437         int i;
00438 
00439         if (rpc_ctx == NULL)
00440                 return False;
00441 
00442         if(!prs_align(ps))
00443                 return False;
00444         if(!prs_uint16("context_id  ", ps, depth, &rpc_ctx->context_id ))
00445                 return False;
00446         if(!prs_uint8 ("num_transfer_syntaxes", ps, depth, &rpc_ctx->num_transfer_syntaxes))
00447                 return False;
00448 
00449         /* num_transfer_syntaxes must not be zero. */
00450         if (rpc_ctx->num_transfer_syntaxes == 0)
00451                 return False;
00452 
00453         if(!smb_io_rpc_iface("", &rpc_ctx->abstract, ps, depth))
00454                 return False;
00455 
00456         if (UNMARSHALLING(ps)) {
00457                 if (!(rpc_ctx->transfer = PRS_ALLOC_MEM(ps, RPC_IFACE, rpc_ctx->num_transfer_syntaxes))) {
00458                         return False;
00459                 }
00460         }
00461 
00462         for (i = 0; i < rpc_ctx->num_transfer_syntaxes; i++ ) {
00463                 if (!smb_io_rpc_iface("", &rpc_ctx->transfer[i], ps, depth))
00464                         return False;
00465         }
00466         return True;
00467 }

BOOL smb_io_rpc_hdr_rb	(	const char *	desc,
		RPC_HDR_RB *	rpc,
		prs_struct *	ps,
		int	depth
	)

parse_rpc.c の 473 行で定義されています。

参照先 rpc_bind_req_info::bba・rpc_bind_req_info::num_contexts・prs_debug()・rpc_bind_req_info::rpc_context・smb_io_rpc_context()・smb_io_rpc_hdr_bba().

参照元 api_pipe_alter_context()・create_bind_or_alt_ctx_internal().

00474 {
00475         int i;
00476         
00477         if (rpc == NULL)
00478                 return False;
00479 
00480         prs_debug(ps, depth, desc, "smb_io_rpc_hdr_rb");
00481         depth++;
00482 
00483         if(!smb_io_rpc_hdr_bba("", &rpc->bba, ps, depth))
00484                 return False;
00485 
00486         if(!prs_uint8("num_contexts", ps, depth, &rpc->num_contexts))
00487                 return False;
00488 
00489         /* 3 pad bytes following - will be mopped up by the prs_align in smb_io_rpc_context(). */
00490 
00491         /* num_contexts must not be zero. */
00492         if (rpc->num_contexts == 0)
00493                 return False;
00494 
00495         if (UNMARSHALLING(ps)) {
00496                 if (!(rpc->rpc_context = PRS_ALLOC_MEM(ps, RPC_CONTEXT, rpc->num_contexts))) {
00497                         return False;
00498                 }
00499         }
00500 
00501         for (i = 0; i < rpc->num_contexts; i++ ) {
00502                 if (!smb_io_rpc_context("", &rpc->rpc_context[i], ps, depth))
00503                         return False;
00504         }
00505 
00506         return True;
00507 }

static void init_rpc_results	(	RPC_RESULTS *	res,
		uint8	num_results,
		uint16	result,
		uint16	reason
	)			`[static]`

parse_rpc.c の 515 行で定義されています。

参照先 rpc_results_info::num_results・rpc_results_info::reason・rpc_results_info::result.

参照元 init_rpc_hdr_ba().

00517 {
00518         res->num_results = num_results; /* the number of results (0x01) */
00519         res->result      = result     ;  /* result (0x00 = accept) */
00520         res->reason      = reason     ;  /* reason (0x00 = no reason specified) */
00521 }

static BOOL smb_io_rpc_results	(	const char *	desc,
		RPC_RESULTS *	res,
		prs_struct *	ps,
		int	depth
	)			`[static]`

parse_rpc.c の 529 行で定義されています。

参照先 rpc_results_info::num_results・prs_debug()・rpc_results_info::reason・rpc_results_info::result.

参照元 smb_io_rpc_hdr_ba().

00530 {
00531         if (res == NULL)
00532                 return False;
00533 
00534         prs_debug(ps, depth, desc, "smb_io_rpc_results");
00535         depth++;
00536 
00537         if(!prs_align(ps))
00538                 return False;
00539         
00540         if(!prs_uint8 ("num_results", ps, depth, &res->num_results))    
00541                 return False;
00542 
00543         if(!prs_align(ps))
00544                 return False;
00545         
00546         if(!prs_uint16("result     ", ps, depth, &res->result))
00547                 return False;
00548         if(!prs_uint16("reason     ", ps, depth, &res->reason))
00549                 return False;
00550         return True;
00551 }

void init_rpc_hdr_ba	(	RPC_HDR_BA *	rpc,
		uint16	max_tsize,
		uint16	max_rsize,
		uint32	assoc_gid,
		const char *	pipe_addr,
		uint8	num_results,
		uint16	result,
		uint16	reason,
		RPC_IFACE *	transfer
	)

parse_rpc.c の 560 行で定義されています。

参照先 rpc_hdr_ba_info::addr・rpc_hdr_ba_info::bba・init_rpc_addr_str()・init_rpc_hdr_bba()・init_rpc_results()・rpc_hdr_ba_info::res・rpc_hdr_ba_info::transfer.

参照元 api_pipe_alter_context().

00565 {
00566         init_rpc_hdr_bba (&rpc->bba, max_tsize, max_rsize, assoc_gid);
00567         init_rpc_addr_str(&rpc->addr, pipe_addr);
00568         init_rpc_results (&rpc->res, num_results, result, reason);
00569 
00570         /* the transfer syntax from the request */
00571         memcpy(&rpc->transfer, transfer, sizeof(rpc->transfer));
00572 }

BOOL smb_io_rpc_hdr_ba	(	const char *	desc,
		RPC_HDR_BA *	rpc,
		prs_struct *	ps,
		int	depth
	)

parse_rpc.c の 578 行で定義されています。

参照先 rpc_hdr_ba_info::addr・rpc_hdr_ba_info::bba・prs_debug()・rpc_hdr_ba_info::res・smb_io_rpc_addr_str()・smb_io_rpc_hdr_bba()・smb_io_rpc_iface()・smb_io_rpc_results()・rpc_hdr_ba_info::transfer.

参照元 api_pipe_alter_context()・rpc_pipe_bind().

00579 {
00580         if (rpc == NULL)
00581                 return False;
00582 
00583         prs_debug(ps, depth, desc, "smb_io_rpc_hdr_ba");
00584         depth++;
00585 
00586         if(!smb_io_rpc_hdr_bba("", &rpc->bba, ps, depth))
00587                 return False;
00588         if(!smb_io_rpc_addr_str("", &rpc->addr, ps, depth))
00589                 return False;
00590         if(!smb_io_rpc_results("", &rpc->res, ps, depth))
00591                 return False;
00592         if(!smb_io_rpc_iface("", &rpc->transfer, ps, depth))
00593                 return False;
00594         return True;
00595 }

void init_rpc_hdr_req	(	RPC_HDR_REQ *	hdr,
		uint32	alloc_hint,
		uint16	opnum
	)

parse_rpc.c の 601 行で定義されています。

参照先 rpc_hdr_req_info::alloc_hint・rpc_hdr_req_info::context_id・rpc_hdr_req_info::opnum.

参照元 rpc_api_pipe_req().

00602 {
00603         hdr->alloc_hint   = alloc_hint; /* allocation hint */
00604         hdr->context_id   = 0;         /* presentation context identifier */
00605         hdr->opnum        = opnum;     /* opnum */
00606 }

BOOL smb_io_rpc_hdr_req	(	const char *	desc,
		RPC_HDR_REQ *	rpc,
		prs_struct *	ps,
		int	depth
	)

parse_rpc.c の 612 行で定義されています。

参照先 rpc_hdr_req_info::alloc_hint・rpc_hdr_req_info::context_id・rpc_hdr_req_info::opnum・prs_debug().

参照元 process_request_pdu()・rpc_api_pipe_req().

00613 {
00614         if (rpc == NULL)
00615                 return False;
00616 
00617         prs_debug(ps, depth, desc, "smb_io_rpc_hdr_req");
00618         depth++;
00619 
00620         if(!prs_uint32("alloc_hint", ps, depth, &rpc->alloc_hint))
00621                 return False;
00622         if(!prs_uint16("context_id", ps, depth, &rpc->context_id))
00623                 return False;
00624         if(!prs_uint16("opnum     ", ps, depth, &rpc->opnum))
00625                 return False;
00626         return True;
00627 }

BOOL smb_io_rpc_hdr_resp	(	const char *	desc,
		RPC_HDR_RESP *	rpc,
		prs_struct *	ps,
		int	depth
	)

parse_rpc.c の 633 行で定義されています。

参照先 rpc_hdr_resp_info::alloc_hint・rpc_hdr_resp_info::cancel_count・rpc_hdr_resp_info::context_id・prs_debug()・rpc_hdr_resp_info::reserved.

参照元 cli_pipe_validate_current_pdu()・create_next_pdu_noauth()・create_next_pdu_ntlmssp()・create_next_pdu_schannel()・setup_fault_pdu().

00634 {
00635         if (rpc == NULL)
00636                 return False;
00637 
00638         prs_debug(ps, depth, desc, "smb_io_rpc_hdr_resp");
00639         depth++;
00640 
00641         if(!prs_uint32("alloc_hint", ps, depth, &rpc->alloc_hint))
00642                 return False;
00643         if(!prs_uint16("context_id", ps, depth, &rpc->context_id))
00644                 return False;
00645         if(!prs_uint8 ("cancel_ct ", ps, depth, &rpc->cancel_count))
00646                 return False;
00647         if(!prs_uint8 ("reserved  ", ps, depth, &rpc->reserved))
00648                 return False;
00649         return True;
00650 }

BOOL smb_io_rpc_hdr_fault	(	const char *	desc,
		RPC_HDR_FAULT *	rpc,
		prs_struct *	ps,
		int	depth
	)

parse_rpc.c の 656 行で定義されています。

参照先 prs_debug()・rpc_hdr_fault_info::reserved・rpc_hdr_fault_info::status.

参照元 cli_pipe_validate_current_pdu()・setup_fault_pdu().

00657 {
00658         if (rpc == NULL)
00659                 return False;
00660 
00661         prs_debug(ps, depth, desc, "smb_io_rpc_hdr_fault");
00662         depth++;
00663 
00664         if(!prs_dcerpc_status("status  ", ps, depth, &rpc->status))
00665                 return False;
00666         if(!prs_uint32("reserved", ps, depth, &rpc->reserved))
00667                 return False;
00668 
00669     return True;
00670 }

void init_rpc_hdr_auth	(	RPC_HDR_AUTH *	rai,
		uint8	auth_type,
		uint8	auth_level,
		uint8	auth_pad_len,
		uint32	auth_context_id
	)

parse_rpc.c の 676 行で定義されています。

参照先 rpc_hdr_auth_info::auth_context_id・rpc_hdr_auth_info::auth_level・rpc_hdr_auth_info::auth_pad_len・rpc_hdr_auth_info::auth_reserved・rpc_hdr_auth_info::auth_type.

参照元 add_ntlmssp_auth_footer()・add_schannel_auth_footer()・create_krb5_auth_bind_req()・create_next_pdu_ntlmssp()・create_next_pdu_schannel()・create_ntlmssp_auth_rpc_bind_req()・create_rpc_alter_context()・create_rpc_bind_auth3()・create_schannel_auth_rpc_bind_req()・create_spnego_ntlmssp_auth_rpc_bind_req()・pipe_ntlmssp_auth_bind()・pipe_schannel_auth_bind()・pipe_spnego_auth_bind_continue()・pipe_spnego_auth_bind_negotiate().

00680 {
00681         rai->auth_type     = auth_type;
00682         rai->auth_level    = auth_level;
00683         rai->auth_pad_len  = auth_pad_len;
00684         rai->auth_reserved = 0;
00685         rai->auth_context_id = auth_context_id;
00686 }

BOOL smb_io_rpc_hdr_auth	(	const char *	desc,
		RPC_HDR_AUTH *	rai,
		prs_struct *	ps,
		int	depth
	)

parse_rpc.c の 692 行で定義されています。

参照先 rpc_hdr_auth_info::auth_context_id・rpc_hdr_auth_info::auth_level・rpc_hdr_auth_info::auth_pad_len・rpc_hdr_auth_info::auth_reserved・rpc_hdr_auth_info::auth_type・prs_debug().

参照元 add_ntlmssp_auth_footer()・add_schannel_auth_footer()・api_pipe_alter_context()・api_pipe_bind_auth3()・api_pipe_ntlmssp_auth_process()・api_pipe_schannel_process()・cli_pipe_verify_ntlmssp()・cli_pipe_verify_schannel()・create_bind_or_alt_ctx_internal()・create_next_pdu_ntlmssp()・create_next_pdu_schannel()・create_rpc_bind_auth3()・pipe_ntlmssp_auth_bind()・pipe_schannel_auth_bind()・pipe_spnego_auth_bind_continue()・pipe_spnego_auth_bind_negotiate()・rpc_finish_auth3_bind()・rpc_finish_spnego_ntlmssp_bind().

00693 {
00694         if (rai == NULL)
00695                 return False;
00696 
00697         prs_debug(ps, depth, desc, "smb_io_rpc_hdr_auth");
00698         depth++;
00699 
00700         if(!prs_align(ps))
00701                 return False;
00702 
00703         if(!prs_uint8 ("auth_type    ", ps, depth, &rai->auth_type))
00704                 return False;
00705         if(!prs_uint8 ("auth_level   ", ps, depth, &rai->auth_level))
00706                 return False;
00707         if(!prs_uint8 ("auth_pad_len ", ps, depth, &rai->auth_pad_len))
00708                 return False;
00709         if(!prs_uint8 ("auth_reserved", ps, depth, &rai->auth_reserved))
00710                 return False;
00711         if(!prs_uint32("auth_context_id", ps, depth, &rai->auth_context_id))
00712                 return False;
00713 
00714         return True;
00715 }

BOOL rpc_auth_verifier_chk	(	RPC_AUTH_VERIFIER *	rav,
		const char *	signature,
		uint32	msg_type
	)

parse_rpc.c の 721 行で定義されています。

参照先 rpc_auth_verif_info::msg_type・rpc_auth_verif_info::signature・strequal().

00723 {
00724         return (strequal(rav->signature, signature) && rav->msg_type == msg_type);
00725 }

void init_rpc_auth_verifier	(	RPC_AUTH_VERIFIER *	rav,
		const char *	signature,
		uint32	msg_type
	)

parse_rpc.c の 731 行で定義されています。

参照先 rpc_auth_verif_info::msg_type・rpc_auth_verif_info::signature.

参照元 pipe_schannel_auth_bind().

00733 {
00734         fstrcpy(rav->signature, signature); /* "NTLMSSP" */
00735         rav->msg_type = msg_type; /* NTLMSSP_MESSAGE_TYPE */
00736 }

BOOL smb_io_rpc_auth_verifier	(	const char *	desc,
		RPC_AUTH_VERIFIER *	rav,
		prs_struct *	ps,
		int	depth
	)

parse_rpc.c の 742 行で定義されています。

参照先 rpc_auth_verif_info::msg_type・prs_debug()・rpc_auth_verif_info::signature.

00743 {
00744         if (rav == NULL)
00745                 return False;
00746 
00747         prs_debug(ps, depth, desc, "smb_io_rpc_auth_verifier");
00748         depth++;
00749 
00750         /* "NTLMSSP" */
00751         if(!prs_string("signature", ps, depth, rav->signature,
00752                         sizeof(rav->signature)))
00753                 return False;
00754         if(!prs_uint32("msg_type ", ps, depth, &rav->msg_type)) /* NTLMSSP_MESSAGE_TYPE */
00755                 return False;
00756 
00757         return True;
00758 }

BOOL smb_io_rpc_schannel_verifier	(	const char *	desc,
		RPC_AUTH_VERIFIER *	rav,
		prs_struct *	ps,
		int	depth
	)

parse_rpc.c の 764 行で定義されています。

参照先 rpc_auth_verif_info::msg_type・prs_debug()・rpc_auth_verif_info::signature.

参照元 pipe_schannel_auth_bind().

00765 {
00766         if (rav == NULL)
00767                 return False;
00768 
00769         prs_debug(ps, depth, desc, "smb_io_rpc_schannel_verifier");
00770         depth++;
00771 
00772         if(!prs_string("signature", ps, depth, rav->signature, sizeof(rav->signature)))
00773                 return False;
00774         if(!prs_uint32("msg_type ", ps, depth, &rav->msg_type))
00775                 return False;
00776 
00777         return True;
00778 }

void init_rpc_auth_schannel_neg	(	RPC_AUTH_SCHANNEL_NEG *	neg,
		const char *	domain,
		const char *	myname
	)

parse_rpc.c の 784 行で定義されています。

参照先 rpc_auth_schannel_neg_info::domain・rpc_auth_schannel_neg_info::myname・rpc_auth_schannel_neg_info::type1・rpc_auth_schannel_neg_info::type2.

参照元 create_schannel_auth_rpc_bind_req().

00786 {
00787         neg->type1 = 0;
00788         neg->type2 = 0x3;
00789         fstrcpy(neg->domain, domain);
00790         fstrcpy(neg->myname, myname);
00791 }

BOOL smb_io_rpc_auth_schannel_neg	(	const char *	desc,
		RPC_AUTH_SCHANNEL_NEG *	neg,
		prs_struct *	ps,
		int	depth
	)

parse_rpc.c の 797 行で定義されています。

参照先 rpc_auth_schannel_neg_info::domain・rpc_auth_schannel_neg_info::myname・prs_debug()・rpc_auth_schannel_neg_info::type1・rpc_auth_schannel_neg_info::type2.

参照元 create_schannel_auth_rpc_bind_req()・pipe_schannel_auth_bind().

00799 {
00800         if (neg == NULL)
00801                 return False;
00802 
00803         prs_debug(ps, depth, desc, "smb_io_rpc_auth_schannel_neg");
00804         depth++;
00805 
00806         if(!prs_align(ps))
00807                 return False;
00808 
00809         if(!prs_uint32("type1", ps, depth, &neg->type1))
00810                 return False;
00811         if(!prs_uint32("type2", ps, depth, &neg->type2))
00812                 return False;
00813         if(!prs_string("domain  ", ps, depth, neg->domain, sizeof(neg->domain)))
00814                 return False;
00815         if(!prs_string("myname  ", ps, depth, neg->myname, sizeof(neg->myname)))
00816                 return False;
00817 
00818         return True;
00819 }

BOOL smb_io_rpc_auth_schannel_chk	(	const char *	desc,
		int	auth_len,
		RPC_AUTH_SCHANNEL_CHK *	chk,
		prs_struct *	ps,
		int	depth
	)

parse_rpc.c の 825 行で定義されています。

参照先 rpc_auth_schannel_chk_info::confounder・rpc_auth_schannel_chk_info::packet_digest・prs_debug()・rpc_auth_schannel_chk_info::seq_num・rpc_auth_schannel_chk_info::sig.

参照元 add_schannel_auth_footer()・api_pipe_schannel_process()・cli_pipe_verify_schannel()・create_next_pdu_schannel().

00828 {
00829         if (chk == NULL)
00830                 return False;
00831 
00832         prs_debug(ps, depth, desc, "smb_io_rpc_auth_schannel_chk");
00833         depth++;
00834 
00835         if ( !prs_uint8s(False, "sig  ", ps, depth, chk->sig, sizeof(chk->sig)) )
00836                 return False;
00837                 
00838         if ( !prs_uint8s(False, "seq_num", ps, depth, chk->seq_num, sizeof(chk->seq_num)) )
00839                 return False;
00840                 
00841         if ( !prs_uint8s(False, "packet_digest", ps, depth, chk->packet_digest, sizeof(chk->packet_digest)) )
00842                 return False;
00843         
00844         if ( auth_len == RPC_AUTH_SCHANNEL_SIGN_OR_SEAL_CHK_LEN ) {
00845                 if ( !prs_uint8s(False, "confounder", ps, depth, chk->confounder, sizeof(chk->confounder)) )
00846                         return False;
00847         }
00848 
00849         return True;
00850 }

struct pipe_id_info pipe_names[]

初期値:

{
        
        { PIPE_LSARPC  , SYNT_LSARPC_V0        , PIPE_LSASS    , TRANS_SYNT_V2 },
        { PIPE_LSARPC  , SYNT_LSARPC_V0_DS     , PIPE_LSASS    , TRANS_SYNT_V2 },
        { PIPE_SAMR    , SYNT_SAMR_V1          , PIPE_LSASS    , TRANS_SYNT_V2 },
        { PIPE_NETLOGON, SYNT_NETLOGON_V1      , PIPE_LSASS    , TRANS_SYNT_V2 },
        { PIPE_SRVSVC  , SYNT_SRVSVC_V3        , PIPE_NTSVCS   , TRANS_SYNT_V2 },
        { PIPE_WKSSVC  , SYNT_WKSSVC_V1        , PIPE_NTSVCS   , TRANS_SYNT_V2 },
        { PIPE_WINREG  , SYNT_WINREG_V1        , PIPE_WINREG   , TRANS_SYNT_V2 },
        { PIPE_SPOOLSS , SYNT_SPOOLSS_V1       , PIPE_SPOOLSS  , TRANS_SYNT_V2 },
        { PIPE_NETDFS  , SYNT_NETDFS_V3        , PIPE_NETDFS   , TRANS_SYNT_V2 },
        { PIPE_ECHO    , SYNT_ECHO_V1          , PIPE_ECHO     , TRANS_SYNT_V2 },
        { PIPE_SHUTDOWN, SYNT_SHUTDOWN_V1      , PIPE_SHUTDOWN , TRANS_SYNT_V2 },
        { PIPE_SVCCTL  , SYNT_SVCCTL_V2        , PIPE_NTSVCS   , TRANS_SYNT_V2 },
        { PIPE_EVENTLOG, SYNT_EVENTLOG_V0      , PIPE_EVENTLOG , TRANS_SYNT_V2 },
        { PIPE_NTSVCS  , SYNT_NTSVCS_V1        , PIPE_NTSVCS   , TRANS_SYNT_V2 },
        { NULL         , SYNT_NONE_V0          , NULL          , SYNT_NONE_V0  }
}

parse_rpc.c の 209 行で定義されています。


関数
const char *	cli_get_pipe_name (int pipe_idx)
void	init_rpc_hdr (RPC_HDR *hdr, enum RPC_PKT_TYPE pkt_type, uint8 flags, uint32 call_id, int data_len, int auth_len)
BOOL	smb_io_rpc_hdr (const char desc, RPC_HDR rpc, prs_struct *ps, int depth)
static BOOL	smb_io_rpc_iface (const char desc, RPC_IFACE ifc, prs_struct *ps, int depth)
static void	init_rpc_addr_str (RPC_ADDR_STR str, const char name)
static BOOL	smb_io_rpc_addr_str (const char desc, RPC_ADDR_STR str, prs_struct *ps, int depth)
static void	init_rpc_hdr_bba (RPC_HDR_BBA *bba, uint16 max_tsize, uint16 max_rsize, uint32 assoc_gid)
static BOOL	smb_io_rpc_hdr_bba (const char desc, RPC_HDR_BBA rpc, prs_struct *ps, int depth)
void	init_rpc_context (RPC_CONTEXT rpc_ctx, uint16 context_id, RPC_IFACE abstract, RPC_IFACE *transfer)
void	init_rpc_hdr_rb (RPC_HDR_RB rpc, uint16 max_tsize, uint16 max_rsize, uint32 assoc_gid, RPC_CONTEXT context)
BOOL	smb_io_rpc_context (const char desc, RPC_CONTEXT rpc_ctx, prs_struct *ps, int depth)
BOOL	smb_io_rpc_hdr_rb (const char desc, RPC_HDR_RB rpc, prs_struct *ps, int depth)
static void	init_rpc_results (RPC_RESULTS *res, uint8 num_results, uint16 result, uint16 reason)
static BOOL	smb_io_rpc_results (const char desc, RPC_RESULTS res, prs_struct *ps, int depth)
void	init_rpc_hdr_ba (RPC_HDR_BA rpc, uint16 max_tsize, uint16 max_rsize, uint32 assoc_gid, const char pipe_addr, uint8 num_results, uint16 result, uint16 reason, RPC_IFACE *transfer)
BOOL	smb_io_rpc_hdr_ba (const char desc, RPC_HDR_BA rpc, prs_struct *ps, int depth)
void	init_rpc_hdr_req (RPC_HDR_REQ *hdr, uint32 alloc_hint, uint16 opnum)
BOOL	smb_io_rpc_hdr_req (const char desc, RPC_HDR_REQ rpc, prs_struct *ps, int depth)
BOOL	smb_io_rpc_hdr_resp (const char desc, RPC_HDR_RESP rpc, prs_struct *ps, int depth)
BOOL	smb_io_rpc_hdr_fault (const char desc, RPC_HDR_FAULT rpc, prs_struct *ps, int depth)
void	init_rpc_hdr_auth (RPC_HDR_AUTH *rai, uint8 auth_type, uint8 auth_level, uint8 auth_pad_len, uint32 auth_context_id)
BOOL	smb_io_rpc_hdr_auth (const char desc, RPC_HDR_AUTH rai, prs_struct *ps, int depth)
BOOL	rpc_auth_verifier_chk (RPC_AUTH_VERIFIER rav, const char signature, uint32 msg_type)
void	init_rpc_auth_verifier (RPC_AUTH_VERIFIER rav, const char signature, uint32 msg_type)
BOOL	smb_io_rpc_auth_verifier (const char desc, RPC_AUTH_VERIFIER rav, prs_struct *ps, int depth)
BOOL	smb_io_rpc_schannel_verifier (const char desc, RPC_AUTH_VERIFIER rav, prs_struct *ps, int depth)
void	init_rpc_auth_schannel_neg (RPC_AUTH_SCHANNEL_NEG neg, const char domain, const char *myname)
BOOL	smb_io_rpc_auth_schannel_neg (const char desc, RPC_AUTH_SCHANNEL_NEG neg, prs_struct *ps, int depth)
BOOL	smb_io_rpc_auth_schannel_chk (const char desc, int auth_len, RPC_AUTH_SCHANNEL_CHK chk, prs_struct *ps, int depth)
変数
pipe_id_info	pipe_names []

rpc_parse/parse_rpc.c

関数

変数

関数

変数