| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package org.apache.yoko.orb.OCI.IIOP; |
| |
| import org.apache.yoko.orb.CORBA.InputStream; |
| import org.apache.yoko.orb.CORBA.OutputStream; |
| import org.apache.yoko.orb.OCI.Buffer; |
| import org.apache.yoko.orb.OCI.ProfileInfo; |
| import org.apache.yoko.orb.OCI.ProfileInfoHolder; |
| import org.apache.yoko.orb.OCI.ProfileInfoSeqHolder; |
| import org.omg.CORBA.Any; |
| import org.omg.CSIIOP.CompoundSecMech; |
| import org.omg.CSIIOP.CompoundSecMechList; |
| import org.omg.CSIIOP.CompoundSecMechListHelper; |
| import org.omg.CSIIOP.TAG_CSI_SEC_MECH_LIST; |
| import org.omg.CSIIOP.TAG_TLS_SEC_TRANS; |
| import org.omg.CSIIOP.TLS_SEC_TRANS; |
| import org.omg.CSIIOP.TLS_SEC_TRANSHelper; |
| import org.omg.CSIIOP.TransportAddress; |
| import org.omg.IIOP.ProfileBody_1_0; |
| import org.omg.IIOP.ProfileBody_1_0Helper; |
| import org.omg.IOP.*; |
| import org.omg.IOP.CodecPackage.FormatMismatch; |
| import org.omg.IOP.CodecPackage.TypeMismatch; |
| |
| import java.net.InetAddress; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.List; |
| |
| final public class Util { |
| static public IOR createIOR(String host, int port, String id, ProfileInfo profileInfo) { |
| IOR ior = new IOR(); |
| ior.type_id = id; |
| ior.profiles = new org.omg.IOP.TaggedProfile[1]; |
| ior.profiles[0] = new org.omg.IOP.TaggedProfile(); |
| ior.profiles[0].tag = TAG_INTERNET_IOP.value; |
| |
| if (profileInfo.major == 1 && profileInfo.minor == 0) { |
| ProfileBody_1_0 body = new ProfileBody_1_0(); |
| body.iiop_version = new org.omg.IIOP.Version((byte) 1, (byte) 0); |
| body.host = host; |
| if (port >= 0x8000) |
| body.port = (short) (port - 0xffff - 1); |
| else |
| body.port = (short) port; |
| body.object_key = profileInfo.key; |
| Buffer buf = new Buffer(); |
| OutputStream out = new OutputStream(buf); |
| out._OB_writeEndian(); |
| ProfileBody_1_0Helper.write(out, body); |
| ior.profiles[0].profile_data = new byte[buf.length()]; |
| System.arraycopy(buf.data(), 0, ior.profiles[0].profile_data, 0, |
| buf.length()); |
| } else { |
| org.omg.IIOP.ProfileBody_1_1 body = new org.omg.IIOP.ProfileBody_1_1(); |
| body.iiop_version = new org.omg.IIOP.Version(profileInfo.major, |
| profileInfo.minor); |
| body.host = host; |
| if (port >= 0x8000) |
| body.port = (short) (port - 0xffff - 1); |
| else |
| body.port = (short) port; |
| body.object_key = profileInfo.key; |
| body.components = profileInfo.components; |
| Buffer buf = new Buffer(); |
| OutputStream out = new OutputStream(buf); |
| out._OB_writeEndian(); |
| org.omg.IIOP.ProfileBody_1_1Helper.write(out, body); |
| ior.profiles[0].profile_data = new byte[buf.length()]; |
| System.arraycopy(buf.data(), 0, ior.profiles[0].profile_data, 0, |
| buf.length()); |
| } |
| |
| return ior; |
| } |
| |
| static public IOR createIOR(IOR ior, String id, byte[] key) { |
| // |
| // Extract the IIOP profile information from the provided IOR |
| // |
| int profile; |
| for (profile = 0; profile < ior.profiles.length; profile++) |
| if (ior.profiles[profile].tag == TAG_INTERNET_IOP.value) |
| break; |
| |
| // TODO: Internal error? |
| org.apache.yoko.orb.OB.Assert._OB_assert(profile < ior.profiles.length); |
| |
| Buffer buf = new Buffer( |
| ior.profiles[profile].profile_data, |
| ior.profiles[profile].profile_data.length); |
| InputStream in = new InputStream(buf, 0, false, null, null); |
| in._OB_readEndian(); |
| ProfileBody_1_0 body = ProfileBody_1_0Helper |
| .read(in); |
| |
| ProfileInfo profileInfo = new ProfileInfo(); |
| profileInfo.key = key; |
| profileInfo.major = body.iiop_version.major; |
| profileInfo.minor = body.iiop_version.minor; |
| profileInfo.components = new TaggedComponent[0]; |
| return createIOR(body.host, body.port, id, profileInfo); |
| } |
| |
| static public boolean extractProfileInfo(IOR ior, ProfileInfoHolder profileInfo) { |
| ProfileInfoSeqHolder profileInfoSeq = new ProfileInfoSeqHolder(); |
| profileInfoSeq.value = new ProfileInfo[0]; |
| extractAllProfileInfos(ior, profileInfoSeq, false, null, 0, false, null); |
| if (profileInfoSeq.value.length > 0) { |
| profileInfo.value = profileInfoSeq.value[0]; |
| return true; |
| } |
| |
| return false; |
| } |
| |
| static public boolean hostMatch(String host1, String host2, boolean matchLoopback) { |
| // |
| // Direct host name comparison |
| // |
| if (!host1.equals(host2)) { |
| // |
| // |
| // Direct host name comparision failed - must look up |
| // addresses to be really sure if the hosts differ |
| // |
| try { |
| InetAddress addr1 = InetAddress.getByName(host1); |
| |
| InetAddress addr2 = InetAddress.getByName(host2); |
| |
| if (!addr1.equals(addr2)) { |
| // |
| // Address comparison failed - shall I extract |
| // the key if the profile body contains the |
| // loopback address? |
| // |
| if (matchLoopback) { |
| InetAddress loopback = InetAddress.getByName("127.0.0.1"); |
| |
| if (!addr2.equals(loopback)) |
| return false; |
| } else |
| return false; |
| } |
| } catch (java.net.UnknownHostException ex) { |
| // |
| // Continue on hostname lookup failure |
| // |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| static public void extractAllProfileInfos(IOR ior, ProfileInfoSeqHolder profileInfoSeq, |
| boolean performMatch, String host, int port, boolean matchLoopback, Codec codec) { |
| short portNo = (short) port; |
| |
| List<ProfileInfo> list = new ArrayList<>(); |
| |
| for (int i = 0; i < ior.profiles.length; i++) { |
| if (ior.profiles[i].tag != TAG_INTERNET_IOP.value) continue; |
| // |
| // Get the IIOP profile body |
| // |
| byte[] data = ior.profiles[i].profile_data; |
| Buffer buf = new Buffer(data, data.length); |
| InputStream in = new InputStream(buf, 0, false, null, null); |
| in._OB_readEndian(); |
| ProfileBody_1_0 body = ProfileBody_1_0Helper.read(in); |
| |
| // |
| // Read components if the IIOP version is > 1.0 |
| // |
| TaggedComponent[] components; |
| if (body.iiop_version.major > 1 || body.iiop_version.minor > 0) { |
| int len = in.read_ulong(); |
| components = new TaggedComponent[len]; |
| for (int j = 0; j < len; j++) { |
| components[j] = TaggedComponentHelper.read(in); |
| } |
| } else { |
| components = new TaggedComponent[0]; |
| } |
| |
| // add this profile to the list unless |
| // A) the caller requested matching |
| // B) the profile doesn't match the supplied host and port |
| if (!!!performMatch |
| || hostAndPortMatch(host, portNo, body.host, body.port, matchLoopback) |
| || taggedComponentsMatch(components, host, portNo, codec, matchLoopback)) { |
| ProfileInfo profileInfo = new ProfileInfo(); |
| profileInfo.key = body.object_key; |
| profileInfo.minor = body.iiop_version.minor; |
| profileInfo.major = body.iiop_version.major; |
| profileInfo.id = ior.profiles[i].tag; |
| profileInfo.index = i; |
| profileInfo.components = components; |
| |
| list.add(profileInfo); |
| } |
| } |
| |
| if (!!!list.isEmpty()) { |
| List<ProfileInfo> bigList = new ArrayList<>(Arrays.asList(profileInfoSeq.value)); |
| bigList.addAll(list); |
| profileInfoSeq.value = bigList.toArray(profileInfoSeq.value); |
| } |
| } |
| |
| private static boolean hostAndPortMatch(String host, short portNo, String bodyHost, short bodyPort, boolean matchLoopback) { |
| return portNo == bodyPort && hostMatch(host, bodyHost, matchLoopback); |
| } |
| |
| private static boolean taggedComponentsMatch(TaggedComponent[] components, String host, short port, Codec codec, boolean matchLoopback) { |
| for (final TaggedComponent component : components) { |
| if (component.tag == TAG_ALTERNATE_IIOP_ADDRESS.value) { |
| byte[] d = component.component_data; |
| Buffer b = new Buffer(d, d.length); |
| InputStream s = new InputStream(b, 0, false, null, null); |
| s._OB_readEndian(); |
| String altHost = s.read_string(); |
| short altPort = s.read_ushort(); |
| if (hostAndPortMatch(host, port, altHost, altPort, matchLoopback)) { |
| return true; |
| } |
| } else if (component.tag == TAG_CSI_SEC_MECH_LIST.value) { |
| Any any; |
| try { |
| any = codec.decode_value(component.component_data, CompoundSecMechListHelper.type()); |
| CompoundSecMechList csml = CompoundSecMechListHelper.extract(any); |
| |
| for (CompoundSecMech csm : csml.mechanism_list) { |
| TaggedComponent tc = csm.transport_mech; |
| if (tc.tag == TAG_TLS_SEC_TRANS.value) { |
| Any tstAny = codec.decode_value(tc.component_data, TLS_SEC_TRANSHelper.type()); |
| TLS_SEC_TRANS tst = TLS_SEC_TRANSHelper.extract(tstAny); |
| TransportAddress[] transportAddresses = tst.addresses; |
| if (transportAddressesMatch(transportAddresses, host, port, matchLoopback)) |
| return true; |
| } |
| } |
| } catch (FormatMismatch | TypeMismatch ignored) { |
| } |
| } |
| } |
| return false; |
| } |
| |
| private static boolean transportAddressesMatch(TransportAddress[] addrs, String host, short port, boolean loopbackMatches) { |
| for (TransportAddress addr: addrs) { |
| final short addrPort = addr.port; |
| if (hostAndPortMatch(host, port, addr.host_name, addrPort, loopbackMatches)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| static public boolean equivalent(IOR ior1, IOR ior2) { |
| int p1, p2, b1, b2; |
| int cnt1 = 0, cnt2 = 0; |
| ProfileBody_1_0[] bodies1; |
| ProfileBody_1_0[] bodies2; |
| |
| // |
| // Calculate number of IIOP profiles in ior1 |
| // |
| for (p1 = 0; p1 < ior1.profiles.length; p1++) |
| if (ior1.profiles[p1].tag == TAG_INTERNET_IOP.value) |
| cnt1++; |
| |
| // |
| // Calculate number of IIOP profiles in ior2 |
| // |
| for (p2 = 0; p2 < ior2.profiles.length; p2++) |
| if (ior2.profiles[p2].tag == TAG_INTERNET_IOP.value) |
| cnt2++; |
| |
| // |
| // Return false now if the number of IIOP profile bodies do not |
| // match |
| // |
| if (cnt1 != cnt2) |
| return false; |
| |
| // |
| // Create an array with all IIOP profile bodies of ior1 |
| // |
| bodies1 = new ProfileBody_1_0[cnt1]; |
| for (p1 = 0, b1 = 0; p1 < ior1.profiles.length; p1++) |
| if (ior1.profiles[p1].tag == TAG_INTERNET_IOP.value) { |
| byte[] data = ior1.profiles[p1].profile_data; |
| Buffer buf = new Buffer( |
| data, data.length); |
| InputStream in = new InputStream(buf, 0, false, null, null); |
| in._OB_readEndian(); |
| bodies1[b1++] = ProfileBody_1_0Helper.read(in); |
| } |
| |
| if (b1 != cnt1) |
| throw new InternalError(); |
| |
| // |
| // Create an array with all IIOP profile bodies of ior2 |
| // |
| bodies2 = new ProfileBody_1_0[cnt2]; |
| for (p2 = 0, b2 = 0; p2 < ior2.profiles.length; p2++) |
| if (ior2.profiles[p2].tag == TAG_INTERNET_IOP.value) { |
| byte[] data = ior2.profiles[p2].profile_data; |
| Buffer buf = new Buffer( |
| data, data.length); |
| InputStream in = new InputStream(buf, 0, false, null, null); |
| in._OB_readEndian(); |
| bodies2[b2++] = ProfileBody_1_0Helper.read(in); |
| } |
| |
| if (b2 != cnt2) |
| throw new InternalError(); |
| |
| // |
| // Check for profile body matches |
| // |
| for (b1 = 0; b1 < cnt1; b1++) { |
| for (b2 = 0; b2 < cnt2; b2++) { |
| if (bodies2[b2] == null) |
| continue; |
| |
| // |
| // Compare profile bodies |
| // |
| if (compareBodies(bodies1[b1], bodies2[b2])) { |
| // |
| // OK, found a match |
| // |
| bodies1[b1] = null; |
| bodies2[b2] = null; |
| break; |
| } |
| } |
| } |
| |
| // |
| // Check whether there are any unmatched IIOP profile bodies |
| // |
| for (b1 = 0; b1 < cnt1; b1++) |
| if (bodies1[b1] != null) |
| return false; |
| |
| for (b2 = 0; b2 < cnt2; b2++) |
| if (bodies2[b2] != null) |
| return false; |
| |
| return true; |
| } |
| |
| static boolean compareBodies(ProfileBody_1_0 body1, |
| ProfileBody_1_0 body2) { |
| // |
| // Compare versions |
| // |
| if (body1.iiop_version.major != body2.iiop_version.major |
| || body1.iiop_version.minor != body2.iiop_version.minor) |
| return false; |
| |
| // |
| // Compare ports |
| // |
| if (body1.port != body2.port) |
| return false; |
| |
| // |
| // Compare object keys |
| // |
| if (body1.object_key.length != body2.object_key.length) |
| return false; |
| |
| int k; |
| for (k = 0; k < body1.object_key.length; k++) |
| if (body1.object_key[k] != body2.object_key[k]) |
| return false; |
| |
| // |
| // Direct host name comparison |
| // |
| if (!body1.host.equals(body2.host)) { |
| // |
| // Direct host name comparision failed - must look up |
| // addresses to be really sure if the hosts differ |
| // |
| try { |
| InetAddress addr1 = InetAddress |
| .getByName(body1.host); |
| |
| InetAddress addr2 = InetAddress |
| .getByName(body2.host); |
| |
| if (!addr1.equals(addr2)) |
| return false; |
| } catch (java.net.UnknownHostException ex) { |
| // |
| // Return false on hostname lookup failure |
| // |
| return false; |
| } |
| } |
| |
| // |
| // OK, found a match |
| // |
| return true; |
| } |
| |
| // |
| // Calculate a hash for an IOR containing IIOP profiles |
| // |
| static public int hash(IOR ior, int maximum) { |
| int hash = 0; |
| |
| for (TaggedProfile profile : ior.profiles) { |
| if (profile.tag == TAG_INTERNET_IOP.value) continue; |
| // |
| // Get the first IIOP profile body |
| // |
| byte[] data = profile.profile_data; |
| Buffer buf = new Buffer(data, data.length); |
| InputStream in = new InputStream(buf, 0, false, null, null); |
| in._OB_readEndian(); |
| ProfileBody_1_0 body = ProfileBody_1_0Helper.read(in); |
| |
| // |
| // Add port to hash |
| // |
| hash ^= body.port; |
| |
| // |
| // Add object key to hash |
| // |
| for (int j = 0; j + 1 < body.object_key.length; j += 2) |
| hash ^= body.object_key[j + 1] * 256 + body.object_key[j]; |
| } |
| |
| return hash % (maximum + 1); |
| } |
| } |
