iop_ior.erl

来自「OTP是开放电信平台的简称」· ERL 代码 · 共 1,532 行 · 第 1/5 页

string_code(IOR, Flags, IP, Port, SSLPort) ->
    Env = #giop_env{version = orber:giop_version(),
		    flags = Flags, host = IP, iiop_port = Port, 
		    iiop_ssl_port = SSLPort, domain = orber:domain(),
		    partial_security = orber:partial_security()},
    {IorByteSeq0, Length0} = cdr_encode:enc_type('tk_octet', Env, 0, [], 0),
    {IorByteSeq, _} = code(Env, IOR, IorByteSeq0, Length0),
    IorByteSeq1 = binary_to_list(list_to_binary(lists:reverse(IorByteSeq))),
    IorHexSeq = bytestring_to_hexstring(IorByteSeq1),
    [$I,$O,$R,$: | IorHexSeq].
    
%%-----------------------------------------------------------------
%% Func: code/3
%%-----------------------------------------------------------------
code(#giop_env{version = Version} = Env, #'IOP_IOR'{type_id=TypeId, profiles=Profiles}, Bytes, Len) ->
    ProfileSeq =code_profile_datas(Version, Profiles),
    %% Byte order
    cdr_encode:enc_type(?IOR_TYPEDEF,
			Env, 
			#'IOP_IOR'{type_id=TypeId, profiles=ProfileSeq},
			Bytes, Len);
%% No Local Interface supplied. Use configuration parameters.
code(#giop_env{version = Version, host = 0, flags = EnvFlags} = Env, 
     {Mod, Type, Key, UserDef, OrberDef, Flags}, Bytes, Len) ->
    MC = case ?ORB_FLAG_TEST(EnvFlags, ?ORB_ENV_EXCLUDE_CODESET_COMPONENT) of
	     true ->
		 [];
	     false ->
		 [#'IOP_TaggedComponent'{tag=?TAG_CODE_SETS, 
					 component_data=?DEFAULT_CODESETS}]
	 end,
    IOR = case ?ORB_FLAG_TEST(EnvFlags, ?ORB_ENV_ENABLE_NAT) of
	      false ->
		  create(Version, Mod:typeID(), orber_env:host(), 
			 orber_env:iiop_port(), orber_env:iiop_ssl_port(),
			 {Mod, Type, Key, UserDef, OrberDef, Flags}, 
			 MC, Flags, EnvFlags);
	      true ->
		  create(Version, Mod:typeID(), orber_env:nat_host(), 
			 orber_env:nat_iiop_port(), orber_env:nat_iiop_ssl_port(),
			 {Mod, Type, Key, UserDef, OrberDef, Flags}, 
			 MC, Flags, EnvFlags)
	  
	  end,
    code(Env, IOR, Bytes, Len);
code(#giop_env{version = Version, host = Host, iiop_port = IIOPort, 
	       iiop_ssl_port = SSLPort, flags = EnvFlags} = Env, 
     {Mod, Type, Key, UserDef, OrberDef, Flags}, Bytes, Len) ->
    MC = case ?ORB_FLAG_TEST(EnvFlags, ?ORB_ENV_EXCLUDE_CODESET_COMPONENT) of
	     true ->
		 [];
	     false ->
		 [#'IOP_TaggedComponent'{tag=?TAG_CODE_SETS, 
					 component_data=?DEFAULT_CODESETS}]
	 end,
    IOR = case ?ORB_FLAG_TEST(EnvFlags, ?ORB_ENV_ENABLE_NAT) of
	      false ->
		  create(Version, Mod:typeID(), Host, check_port(IIOPort, normal), 
			 check_port(SSLPort, ssl), 
			 {Mod, Type, Key, UserDef, OrberDef, Flags}, 
			 MC, Flags, EnvFlags);
	      true ->
		  create(Version, Mod:typeID(), orber_env:nat_host(Host), 
			 orber_env:nat_iiop_port(check_port(IIOPort, normal)), 
			 orber_env:nat_iiop_ssl_port(check_port(SSLPort, ssl)),
			 {Mod, Type, Key, UserDef, OrberDef, Flags}, 
			 MC, Flags, EnvFlags)
	  end,
    code(Env, IOR, Bytes, Len).

check_port(Port, _Type) when integer(Port) ->
    Port;
check_port(_, normal) ->
    orber:iiop_port();
check_port(_, ssl) ->
    orber:iiop_ssl_port().

code_profile_datas(_, []) ->
    [];
code_profile_datas(Version, [#'IOP_TaggedProfile'{tag=?TAG_INTERNET_IOP, profile_data=P} | Profiles]) ->
    NewBytes = list_to_binary(code_profile_data(Version, P)),
    [#'IOP_TaggedProfile'{tag=?TAG_INTERNET_IOP, profile_data=NewBytes} | 
     code_profile_datas(Version, Profiles)];
%% Multiple Components
code_profile_datas(Version, [#'IOP_TaggedProfile'{tag=?TAG_MULTIPLE_COMPONENTS, 
						  profile_data=P} | Profiles]) ->
    Comps= code_comp(Version, P, []),
    {Bytes, Length} = cdr_encode:enc_type('tk_octet', Version, 0, [], 0),
    {Bytes1, _Length1} =  cdr_encode:enc_type(?IOP_TAGGEDCOMPONENT_SEQ, Version, Comps, Bytes, Length),
    Profs = binary_to_list(list_to_binary(lists:reverse(Bytes1))),
    [#'IOP_TaggedProfile'{tag=?TAG_MULTIPLE_COMPONENTS, 
			  profile_data=Profs}| code_profile_datas(Version, Profiles)];
code_profile_datas(Version, [#'IOP_TaggedProfile'{tag=N, profile_data=P} | Profiles]) ->
    [#'IOP_TaggedProfile'{tag=N, profile_data=P} | code_profile_datas(Version, Profiles)];
code_profile_datas(_, Data) ->
    orber:dbg("[~p] iop_ior:code_profile_datas(~p); unsupported TaggedProfile.", 
	      [?LINE, Data], ?DEBUG_LEVEL),
    corba:raise(#'INV_OBJREF'{completion_status=?COMPLETED_NO}).

code_profile_data(Version, ProfileData) ->
    [RecTag, V, H, P, O |Rest] = tuple_to_list(ProfileData),
    {Bytes, Length} = cdr_encode:enc_type('tk_octet', Version, 0, [], 0),
    {Bytes1, Length1} = cdr_encode:enc_type(?IIOP_VERSION, Version, V, Bytes, Length),
    {Bytes2, Length2} = cdr_encode:enc_type({'tk_string', 0}, Version,
					    H, Bytes1, Length1),
    {Bytes3, Length3} = cdr_encode:enc_type('tk_ushort', Version, P, Bytes2, Length2),
    {Bytes4, Length4} = cdr_encode:enc_type({'tk_sequence', 'tk_octet', 0}, Version,
					    corba:objkey_to_string(O), Bytes3, Length3),
    {Bytes5, _Length5} = code_profile_data_1(Version, RecTag, Rest, Bytes4, Length4), 
    Bytes6 = lists:reverse(Bytes5),
    lists:flatten(Bytes6).

code_profile_data_1(_Version, 'IIOP_ProfileBody_1_0', [], Bytes, Length) ->
    {Bytes, Length};
code_profile_data_1(Version, 'IIOP_ProfileBody_1_1', [TaggedComponentSeq], Bytes, Length) ->
    Comps = code_comp(Version, TaggedComponentSeq, []),
    cdr_encode:enc_type(?IOP_TAGGEDCOMPONENT_SEQ, Version, Comps, Bytes, Length);
code_profile_data_1(_,V,S,_,_) ->
    orber:dbg("[~p] iop_ior:code_profile_datas(~p, ~p); probably unsupported IIOP-version", 
	      [?LINE, V, S], ?DEBUG_LEVEL),
    corba:raise(#'NO_IMPLEMENT'{completion_status=?COMPLETED_NO}).

code_comp(_Version, [], CompData) ->
    CompData;
code_comp(Version, [#'IOP_TaggedComponent'{tag=?TAG_CODE_SETS, 
					   component_data=CodeSet}|Comps], CompData) ->
    {Bytes0, Len0} = cdr_encode:enc_type('tk_octet', Version, 0, [], 0),
    {Bytes1, _Len1} = cdr_encode:enc_type(?CONV_FRAME_CODESETCOMPONENTINFO, Version, 
					  CodeSet, Bytes0, Len0),
    Bytes = binary_to_list(list_to_binary(lists:reverse(Bytes1))),
    code_comp(Version, Comps, [#'IOP_TaggedComponent'{tag=?TAG_CODE_SETS, 
						      component_data=Bytes}|CompData]);
code_comp(Version, [#'IOP_TaggedComponent'{tag=?TAG_ORB_TYPE, 
					   component_data=ORBType}|Comps], CompData) ->
    {Bytes0, Len0} = cdr_encode:enc_type('tk_octet', Version, 0, [], 0),
    {Bytes1, _Len1} = cdr_encode:enc_type(?ORB_TYPE, Version, 
					  ORBType, Bytes0, Len0),
    Bytes = binary_to_list(list_to_binary(lists:reverse(Bytes1))),
    code_comp(Version, Comps, [#'IOP_TaggedComponent'{tag=?TAG_ORB_TYPE, 
						      component_data=Bytes}|CompData]);
code_comp(Version, [#'IOP_TaggedComponent'{tag=?TAG_ALTERNATE_IIOP_ADDRESS, 
					   component_data=AltAddr}|Comps], CompData) ->
    {Bytes0, Len0} = cdr_encode:enc_type('tk_octet', Version, 0, [], 0),
    {Bytes1, _Len1} = cdr_encode:enc_type(?ALTERNATE_IIOP_ADDRESS, Version, 
					  AltAddr, Bytes0, Len0),
    Bytes = binary_to_list(list_to_binary(lists:reverse(Bytes1))),
    code_comp(Version, Comps, [#'IOP_TaggedComponent'{tag=?TAG_ALTERNATE_IIOP_ADDRESS, 
						      component_data=Bytes}|CompData]);
code_comp(Version, [#'IOP_TaggedComponent'{tag=?TAG_SSL_SEC_TRANS, 
					   component_data=SSLStruct}|Comps], CompData) ->
    {Bytes0, Len0} = cdr_encode:enc_type('tk_octet', Version, 0, [], 0),
    {Bytes1, _Len1} = cdr_encode:enc_type(?SSLIOP_SSL, Version, 
					  SSLStruct, Bytes0, Len0),
    Bytes = binary_to_list(list_to_binary(lists:reverse(Bytes1))),
    code_comp(Version, Comps, [#'IOP_TaggedComponent'{tag=?TAG_SSL_SEC_TRANS, 
						      component_data=Bytes}|CompData]);
%% Fault Tolerant Components
code_comp(Version, [#'IOP_TaggedComponent'{tag=?TAG_FT_GROUP, 
					   component_data=Data}|Comps], CompData) ->
    {Bytes0, Len0} = cdr_encode:enc_type('tk_octet', Version, 0, [], 0),
    {Bytes1, _Len1} = cdr_encode:enc_type(?FT_TagFTGroupTaggedComponent, Version, 
					  Data, Bytes0, Len0),
    Bytes = binary_to_list(list_to_binary(lists:reverse(Bytes1))),
    code_comp(Version, Comps, [#'IOP_TaggedComponent'{tag=?TAG_FT_GROUP, 
						      component_data=Bytes}|CompData]);
code_comp(Version, [#'IOP_TaggedComponent'{tag=?TAG_FT_PRIMARY, 
					   component_data=Data}|Comps], CompData) ->
    {Bytes0, Len0} = cdr_encode:enc_type('tk_octet', Version, 0, [], 0),
    {Bytes1, _Len1} = cdr_encode:enc_type(?FT_TagFTPrimaryTaggedComponent, Version, 
					  Data, Bytes0, Len0),
    Bytes = binary_to_list(list_to_binary(lists:reverse(Bytes1))),
    code_comp(Version, Comps, [#'IOP_TaggedComponent'{tag=?TAG_FT_PRIMARY, 
						      component_data=Bytes}|CompData]);
code_comp(Version, [#'IOP_TaggedComponent'{tag=?TAG_FT_HEARTBEAT_ENABLED, 
					   component_data=Data}|Comps], CompData) ->
    {Bytes0, Len0} = cdr_encode:enc_type('tk_octet', Version, 0, [], 0),
    {Bytes1, _Len1} = cdr_encode:enc_type(?FT_TagFTHeartbeatEnabledTaggedComponent, Version, 
					  Data, Bytes0, Len0),
    Bytes = binary_to_list(list_to_binary(lists:reverse(Bytes1))),
    code_comp(Version, Comps, [#'IOP_TaggedComponent'{tag=?TAG_FT_HEARTBEAT_ENABLED, 
						      component_data=Bytes}|CompData]);
%% Security - CSIIOP
code_comp(Version, [#'IOP_TaggedComponent'{tag=?TAG_CSI_SEC_MECH_LIST, 
					   component_data=Data}|Comps], CompData) ->
    NewData = Data#'CSIIOP_CompoundSecMechList'
		{mechanism_list = code_sec_mech(Version, 
						Data#'CSIIOP_CompoundSecMechList'.mechanism_list, 
						[])},
    {Bytes0, Len0} = cdr_encode:enc_type('tk_octet', Version, 0, [], 0),
    {Bytes1, _Len1} = cdr_encode:enc_type(?CSIIOP_CompoundSecMechList, Version, 
					  NewData, Bytes0, Len0),
    Bytes = binary_to_list(list_to_binary(lists:reverse(Bytes1))),
    code_comp(Version, Comps, [#'IOP_TaggedComponent'{tag=?TAG_CSI_SEC_MECH_LIST, 
						      component_data=Bytes}|CompData]);
code_comp(Version, [#'IOP_TaggedComponent'{tag=?TAG_TLS_SEC_TRANS, 
					   component_data=Data}|Comps], 
	  CompData) ->
    {Bytes0, Len0} = cdr_encode:enc_type('tk_octet', Version, 0, [], 0),
    {Bytes1, _Len1} = cdr_encode:enc_type(?CSIIOP_TLS_SEC_TRANS, Version, 
					  Data, Bytes0, Len0),
    Bytes = binary_to_list(list_to_binary(lists:reverse(Bytes1))),
    code_comp(Version, Comps, [#'IOP_TaggedComponent'{tag=?TAG_TLS_SEC_TRANS, 
						      component_data=Bytes}|CompData]);
code_comp(Version, [#'IOP_TaggedComponent'{tag=?TAG_SECIOP_SEC_TRANS, 
					   component_data=Data}|Comps], CompData) ->
    {Bytes0, Len0} = cdr_encode:enc_type('tk_octet', Version, 0, [], 0),
    {Bytes1, _Len1} = cdr_encode:enc_type(?CSIIOP_SECIOP_SEC_TRANS, Version, 
					  Data, Bytes0, Len0),
    Bytes = binary_to_list(list_to_binary(lists:reverse(Bytes1))),
    code_comp(Version, Comps, [#'IOP_TaggedComponent'{tag=?TAG_SECIOP_SEC_TRANS, 
						      component_data=Bytes}|CompData]);
code_comp(Version, [#'IOP_TaggedComponent'{tag=?TAG_NULL_TAG}|Comps], CompData) ->
    %% The body of the TAG_NULL_TAG component is a sequence of octets of
    %% length 0.
    {Bytes0, Len0} = cdr_encode:enc_type('tk_octet', Version, 0, [], 0),
    {Bytes1, _Len1} = cdr_encode:enc_type({'tk_sequence', 'tk_octet', 0}, Version, 
					  [], Bytes0, Len0),
    Bytes = binary_to_list(list_to_binary(lists:reverse(Bytes1))),
    code_comp(Version, Comps, [#'IOP_TaggedComponent'{tag=?TAG_NULL_TAG, 
						      component_data=Bytes}|CompData]);
%% Unsupported/not used component.
code_comp(Version, [C|Comps], CompData) -> 
    code_comp(Version, Comps, [C|CompData]).


code_sec_mech(_, [], Acc) ->
    %% We must preserver the order!!
    lists:reverse(Acc);
code_sec_mech(Version, [#'CSIIOP_CompoundSecMech'{transport_mech = TagComp} = CSM|T],
	      Acc) ->
    [EncTagComp] = code_comp(Version, [TagComp], []),
    code_sec_mech(Version, T, [CSM#'CSIIOP_CompoundSecMech'
			       {transport_mech = EncTagComp}|Acc]).


%%-----------------------------------------------------------------
%% Func: string_decode/1
%%-----------------------------------------------------------------
string_decode([$I,$O,$R,$: | IorHexSeq]) ->
    Version = orber:giop_version(),
    IorByteSeq = list_to_binary(hexstring_to_bytestring(IorHexSeq)),
    {ByteOrder, IorRest} = cdr_decode:dec_byte_order(IorByteSeq),
    decode(Version, IorRest, 1, ByteOrder);
string_decode([$i,$o,$r,$: | IorHexSeq]) ->
    Version = orber:giop_version(),
    IorByteSeq = list_to_binary(hexstring_to_bytestring(IorHexSeq)),
    {ByteOrder, IorRest} = cdr_decode:dec_byte_order(IorByteSeq),
    decode(Version, IorRest, 1, ByteOrder);
string_decode(What) ->
    orber:dbg("[~p] iop_ior:string_decode(~p); Should be IOR:.. or ior:..", 
	      [?LINE, What], ?DEBUG_LEVEL),
    corba:raise(#'BAD_PARAM'{completion_status=?COMPLETED_NO}).

%%-----------------------------------------------------------------
%% Func: decode/3
%%-----------------------------------------------------------------
decode(Version, IorByteSeq, Len, ByteOrder) ->
    {#'IOP_IOR'{type_id=TypeId, profiles=Profiles}, Rest, Length} =
	cdr_decode:dec_type(?IOR_TYPEDEF, Version, IorByteSeq, Len, ByteOrder),
    L = decode_profiles(Version, Profiles),
    {#'IOP_IOR'{type_id=TypeId, profiles=L}, Rest, Length}.

decode_profiles(_, []) ->
    [];
decode_profiles(Version, [P | Profiles]) ->
    Struct = decode_profile(Version, P),
    L = decode_profiles(Version, Profiles),
    [Struct | L].

decode_profile(Version, #'IOP_TaggedProfile'{tag=?TAG_INTERNET_IOP, profile_data=ProfileData}) ->
    {ByteOrder, Rest} = cdr_decode:dec_byte_order(list_to_binary(ProfileData)),
    Length = 1,
    {V, Rest1, Length1} = cdr_decode:dec_type(?IIOP_VERSION, Version, Rest, Length,
					      ByteOrder),
    {H, Rest2, Length2} = cdr_decode:dec_type({'tk_string', 0}, Version, Rest1, Length1,
					      ByteOrder),
    {P, Rest3, Length3} = cdr_decode:dec_type('tk_ushort', Version, Rest2, Length2,
					      ByteOrder),
    {ObjKey, Rest4, Length4} = cdr_decode:dec_type({'tk_sequence', 'tk_octet', 0},
						   Version, Rest3, Length3, 
						   ByteOrder),
    Struct = decode_profile_1(V, H, P, ObjKey, Version, Rest4, Length4, ByteOrder),
    #'IOP_TaggedProfile'{tag=?TAG_INTERNET_IOP, profile_data=Struct};
%% Multiple Components
decode_profile(Version, #'IOP_TaggedProfile'{tag=?TAG_MULTIPLE_COMPONENTS, 
					     profile_data=ProfileData}) ->
    {ByteOrder, Rest} = cdr_decode:dec_byte_order(list_to_binary(ProfileData)),
    {Components, <<>>, _Length1} =cdr_decode:dec_type(?IOP_TAGGEDCOMPONENT_SEQ, Version, Rest, 1, ByteOrder),
    CompData = decode_comp(Version, Components, []),
    #'IOP_TaggedProfile'{tag=?TAG_MULTIPLE_COMPONENTS, profile_data=CompData};
decode_profile(_, #'IOP_TaggedProfile'{tag=N, profile_data=ProfileData}) ->
    #'IOP_TaggedProfile'{tag=N, profile_data=ProfileData};
decode_profile(_, Data) ->
    orber:dbg("[~p] iop_ior:decode_profile(~p); unsupported TaggedProfile.", 
	      [?LINE, Data], ?DEBUG_LEVEL),
    corba:raise(#'INV_OBJREF'{completion_status=?COMPLETED_NO}).

decode_profile_1(#'IIOP_Version'{major=1, minor=0}, H, P, ObjKey, _Version, _Rest, _Length, _ByteOrder) ->
    #'IIOP_ProfileBody_1_0'{iiop_version=#'IIOP_Version'{major=1,
							 minor=0}, 
			    host=H, port=P,
			    object_key=corba:string_to_objkey(ObjKey)};
decode_profile_1(#'IIOP_Version'{major=1, minor