Mercurial > jdk8-mips64-public > corba / file revision
src/share/classes/com/sun/corba/se/impl/orbutil/ORBUtility.java@6845b95cba6b
src/share/classes/com/sun/corba/se/impl/orbutil/ORBUtility.java
Thu, 31 Aug 2017 18:10:36 +0800
- author
- aoqi
- date
- Thu, 31 Aug 2017 18:10:36 +0800
- changeset 748
- 6845b95cba6b
- parent 475
- 39d15bbb5741
- parent 0
- 7ef37b2cdcad
- child 1410
- 9c913ea7e4a1
- permissions
- -rw-r--r--
merge
1 /*
2 * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
26 package com.sun.corba.se.impl.orbutil;
28 import java.lang.Character;
29 import java.lang.reflect.Field;
30 import java.lang.reflect.Method;
31 import java.rmi.NoSuchObjectException;
32 import java.security.AccessController;
33 import java.security.PermissionCollection;
34 import java.security.Policy;
35 import java.security.PrivilegedAction;
36 import java.security.ProtectionDomain;
37 import java.util.ArrayList;
38 import java.util.Arrays;
39 import java.util.Map;
40 import java.util.List;
41 import java.util.ListIterator;
42 import java.util.Set;
43 import java.util.Map.Entry;
44 import java.util.Collection;
45 import java.util.HashMap;
46 import java.util.HashSet;
47 import java.util.Hashtable;
48 import java.util.Iterator;
49 import java.util.Enumeration;
50 import java.util.Properties;
51 import java.util.IdentityHashMap;
52 import java.util.StringTokenizer;
53 import java.util.NoSuchElementException;
55 import javax.rmi.CORBA.ValueHandler;
56 import javax.rmi.CORBA.ValueHandlerMultiFormat;
57 import javax.rmi.CORBA.Util;
59 import org.omg.CORBA.StructMember ;
60 import org.omg.CORBA.TypeCode ;
61 import org.omg.CORBA.Any ;
62 import org.omg.CORBA.TCKind ;
63 import org.omg.CORBA.SystemException ;
64 import org.omg.CORBA.CompletionStatus ;
65 import org.omg.CORBA.DATA_CONVERSION ;
66 import org.omg.CORBA.BAD_PARAM ;
67 import org.omg.CORBA.BAD_OPERATION ;
68 import org.omg.CORBA.INTERNAL ;
69 import org.omg.CORBA.TypeCodePackage.BadKind ;
70 import org.omg.CORBA.portable.OutputStream ;
71 import org.omg.CORBA.portable.InputStream ;
73 import com.sun.corba.se.pept.transport.ContactInfoList ;
75 import com.sun.corba.se.spi.ior.IOR ;
76 import com.sun.corba.se.spi.presentation.rmi.StubAdapter ;
77 import com.sun.corba.se.spi.orb.ORB ;
78 import com.sun.corba.se.spi.orb.ORBVersion ;
79 import com.sun.corba.se.spi.orb.ORBVersionFactory ;
80 import com.sun.corba.se.spi.protocol.CorbaClientDelegate ;
81 import com.sun.corba.se.spi.protocol.CorbaMessageMediator;
82 import com.sun.corba.se.spi.transport.CorbaContactInfoList ;
83 import com.sun.corba.se.spi.logging.CORBALogDomains ;
84 import com.sun.corba.se.spi.ior.iiop.IIOPProfile;
85 import com.sun.corba.se.spi.ior.iiop.IIOPProfileTemplate;
87 import com.sun.corba.se.impl.protocol.giopmsgheaders.Message;
88 import com.sun.corba.se.impl.corba.CORBAObjectImpl ;
89 import com.sun.corba.se.impl.logging.ORBUtilSystemException ;
90 import com.sun.corba.se.impl.logging.OMGSystemException ;
91 import com.sun.corba.se.impl.ior.iiop.JavaSerializationComponent;
93 import sun.corba.SharedSecrets;
95 /**
96 * Handy class full of static functions that don't belong in util.Utility for pure ORB reasons.
97 */
98 public final class ORBUtility {
99 private ORBUtility() {}
101 private static ORBUtilSystemException wrapper = ORBUtilSystemException.get(
102 CORBALogDomains.UTIL ) ;
103 private static OMGSystemException omgWrapper = OMGSystemException.get(
104 CORBALogDomains.UTIL ) ;
106 private static StructMember[] members = null;
108 private static StructMember[] systemExceptionMembers (ORB orb) {
109 if (members == null) {
110 members = new StructMember[3];
111 members[0] = new StructMember("id", orb.create_string_tc(0), null);
112 members[1] = new StructMember("minor", orb.get_primitive_tc(TCKind.tk_long), null);
113 members[2] = new StructMember("completed", orb.get_primitive_tc(TCKind.tk_long), null);
114 }
115 return members;
116 }
118 private static TypeCode getSystemExceptionTypeCode(ORB orb, String repID, String name) {
119 synchronized (TypeCode.class) {
120 return orb.create_exception_tc(repID, name, systemExceptionMembers(orb));
121 }
122 }
124 private static boolean isSystemExceptionTypeCode(TypeCode type, ORB orb) {
125 StructMember[] systemExceptionMembers = systemExceptionMembers(orb);
126 try {
127 return (type.kind().value() == TCKind._tk_except &&
128 type.member_count() == 3 &&
129 type.member_type(0).equal(systemExceptionMembers[0].type) &&
130 type.member_type(1).equal(systemExceptionMembers[1].type) &&
131 type.member_type(2).equal(systemExceptionMembers[2].type));
132 } catch (BadKind ex) {
133 return false;
134 } catch (org.omg.CORBA.TypeCodePackage.Bounds ex) {
135 return false;
136 }
137 }
139 /**
140 * Static method for writing a CORBA standard exception to an Any.
141 * @param any The Any to write the SystemException into.
142 */
143 public static void insertSystemException(SystemException ex, Any any) {
144 OutputStream out = any.create_output_stream();
145 ORB orb = (ORB)(out.orb());
146 String name = ex.getClass().getName();
147 String repID = ORBUtility.repositoryIdOf(name);
148 out.write_string(repID);
149 out.write_long(ex.minor);
150 out.write_long(ex.completed.value());
151 any.read_value(out.create_input_stream(),
152 getSystemExceptionTypeCode(orb, repID, name));
153 }
155 public static SystemException extractSystemException(Any any) {
156 InputStream in = any.create_input_stream();
157 ORB orb = (ORB)(in.orb());
158 if ( ! isSystemExceptionTypeCode(any.type(), orb)) {
159 throw wrapper.unknownDsiSysex(CompletionStatus.COMPLETED_MAYBE);
160 }
161 return ORBUtility.readSystemException(in);
162 }
164 /**
165 * Return default ValueHandler
166 */
167 public static ValueHandler createValueHandler() {
168 return Util.createValueHandler();
169 }
171 /**
172 * Returns true if it was accurately determined that the remote ORB is
173 * a foreign (non-JavaSoft) ORB. Note: If passed the ORBSingleton, this
174 * will return false.
175 */
176 public static boolean isForeignORB(ORB orb)
177 {
178 if (orb == null)
179 return false;
181 try {
182 return orb.getORBVersion().equals(ORBVersionFactory.getFOREIGN());
183 } catch (SecurityException se) {
184 return false;
185 }
186 }
188 /** Unmarshal a byte array to an integer.
189 Assume the bytes are in BIGENDIAN order.
190 i.e. array[offset] is the most-significant-byte
191 and array[offset+3] is the least-significant-byte.
192 @param array The array of bytes.
193 @param offset The offset from which to start unmarshalling.
194 */
195 public static int bytesToInt(byte[] array, int offset)
196 {
197 int b1, b2, b3, b4;
199 b1 = (array[offset++] << 24) & 0xFF000000;
200 b2 = (array[offset++] << 16) & 0x00FF0000;
201 b3 = (array[offset++] << 8) & 0x0000FF00;
202 b4 = (array[offset++] << 0) & 0x000000FF;
204 return (b1 | b2 | b3 | b4);
205 }
207 /** Marshal an integer to a byte array.
208 The bytes are in BIGENDIAN order.
209 i.e. array[offset] is the most-significant-byte
210 and array[offset+3] is the least-significant-byte.
211 @param array The array of bytes.
212 @param offset The offset from which to start marshalling.
213 */
214 public static void intToBytes(int value, byte[] array, int offset)
215 {
216 array[offset++] = (byte)((value >>> 24) & 0xFF);
217 array[offset++] = (byte)((value >>> 16) & 0xFF);
218 array[offset++] = (byte)((value >>> 8) & 0xFF);
219 array[offset++] = (byte)((value >>> 0) & 0xFF);
220 }
222 /** Converts an Ascii Character into Hexadecimal digit
223 */
224 public static int hexOf( char x )
225 {
226 int val;
228 val = x - '0';
229 if (val >=0 && val <= 9)
230 return val;
232 val = (x - 'a') + 10;
233 if (val >= 10 && val <= 15)
234 return val;
236 val = (x - 'A') + 10;
237 if (val >= 10 && val <= 15)
238 return val;
240 throw wrapper.badHexDigit() ;
241 }
243 // method moved from util.Utility
245 /**
246 * Static method for writing a CORBA standard exception to a stream.
247 * @param strm The OutputStream to use for marshaling.
248 */
249 public static void writeSystemException(SystemException ex, OutputStream strm)
250 {
251 String s;
253 s = repositoryIdOf(ex.getClass().getName());
254 strm.write_string(s);
255 strm.write_long(ex.minor);
256 strm.write_long(ex.completed.value());
257 }
259 /**
260 * Static method for reading a CORBA standard exception from a stream.
261 * @param strm The InputStream to use for unmarshaling.
262 */
263 public static SystemException readSystemException(InputStream strm)
264 {
265 try {
266 String name = classNameOf(strm.read_string());
267 SystemException ex = (SystemException)SharedSecrets.
268 getJavaCorbaAccess().loadClass(name).newInstance();
269 ex.minor = strm.read_long();
270 ex.completed = CompletionStatus.from_int(strm.read_long());
271 return ex;
272 } catch ( Exception ex ) {
273 throw wrapper.unknownSysex( CompletionStatus.COMPLETED_MAYBE, ex );
274 }
275 }
277 /**
278 * Get the class name corresponding to a particular repository Id.
279 * This is used by the system to unmarshal (instantiate) the
280 * appropriate exception class for an marshaled as the value of
281 * its repository Id.
282 * @param repositoryId The repository Id for which we want a class name.
283 */
284 public static String classNameOf(String repositoryId)
285 {
286 String className=null;
288 className = (String) exceptionClassNames.get(repositoryId);
289 if (className == null)
290 className = "org.omg.CORBA.UNKNOWN";
292 return className;
293 }
295 /**
296 * Return true if this repositoryId is a SystemException.
297 * @param repositoryId The repository Id to check.
298 */
299 public static boolean isSystemException(String repositoryId)
300 {
301 String className=null;
303 className = (String) exceptionClassNames.get(repositoryId);
304 if (className == null)
305 return false;
306 else
307 return true;
308 }
310 /**
311 * @return the Java serialization encoding version.
312 */
313 public static byte getEncodingVersion(ORB orb, IOR ior) {
315 // Is Java serialization enabled?
316 // Check the JavaSerializationComponent (tagged component)
317 // in the IIOPProfile. If present, the peer ORB's GIOP is capable
318 // of using Java serialization instead of CDR serialization.
319 // In such a case, use Java serialization, iff the java serialization
320 // versions match.
322 if (orb.getORBData().isJavaSerializationEnabled()) {
323 IIOPProfile prof = ior.getProfile();
324 IIOPProfileTemplate profTemp =
325 (IIOPProfileTemplate) prof.getTaggedProfileTemplate();
326 java.util.Iterator iter = profTemp.iteratorById(
327 ORBConstants.TAG_JAVA_SERIALIZATION_ID);
328 if (iter.hasNext()) {
329 JavaSerializationComponent jc =
330 (JavaSerializationComponent) iter.next();
331 byte jcVersion = jc.javaSerializationVersion();
332 if (jcVersion >= Message.JAVA_ENC_VERSION) {
333 return Message.JAVA_ENC_VERSION;
334 } else if (jcVersion > Message.CDR_ENC_VERSION) {
335 return jc.javaSerializationVersion();
336 } else {
337 // throw error?
338 // Since encodingVersion is <= 0 (CDR_ENC_VERSION).
339 }
340 }
341 }
342 return Message.CDR_ENC_VERSION; // default
343 }
345 /**
346 * Get the repository id corresponding to a particular class.
347 * This is used by the system to write the
348 * appropriate repository id for a system exception.
349 * @param name The class name of the system exception.
350 */
351 public static String repositoryIdOf(String name)
352 {
353 String id;
355 id = (String) exceptionRepositoryIds.get(name);
356 if (id == null)
357 id = "IDL:omg.org/CORBA/UNKNOWN:1.0";
359 return id;
360 }
362 private static final Hashtable exceptionClassNames = new Hashtable();
363 private static final Hashtable exceptionRepositoryIds = new Hashtable();
365 static {
367 //
368 // construct repositoryId -> className hashtable
369 //
370 exceptionClassNames.put("IDL:omg.org/CORBA/BAD_CONTEXT:1.0",
371 "org.omg.CORBA.BAD_CONTEXT");
372 exceptionClassNames.put("IDL:omg.org/CORBA/BAD_INV_ORDER:1.0",
373 "org.omg.CORBA.BAD_INV_ORDER");
374 exceptionClassNames.put("IDL:omg.org/CORBA/BAD_OPERATION:1.0",
375 "org.omg.CORBA.BAD_OPERATION");
376 exceptionClassNames.put("IDL:omg.org/CORBA/BAD_PARAM:1.0",
377 "org.omg.CORBA.BAD_PARAM");
378 exceptionClassNames.put("IDL:omg.org/CORBA/BAD_TYPECODE:1.0",
379 "org.omg.CORBA.BAD_TYPECODE");
380 exceptionClassNames.put("IDL:omg.org/CORBA/COMM_FAILURE:1.0",
381 "org.omg.CORBA.COMM_FAILURE");
382 exceptionClassNames.put("IDL:omg.org/CORBA/DATA_CONVERSION:1.0",
383 "org.omg.CORBA.DATA_CONVERSION");
384 exceptionClassNames.put("IDL:omg.org/CORBA/IMP_LIMIT:1.0",
385 "org.omg.CORBA.IMP_LIMIT");
386 exceptionClassNames.put("IDL:omg.org/CORBA/INTF_REPOS:1.0",
387 "org.omg.CORBA.INTF_REPOS");
388 exceptionClassNames.put("IDL:omg.org/CORBA/INTERNAL:1.0",
389 "org.omg.CORBA.INTERNAL");
390 exceptionClassNames.put("IDL:omg.org/CORBA/INV_FLAG:1.0",
391 "org.omg.CORBA.INV_FLAG");
392 exceptionClassNames.put("IDL:omg.org/CORBA/INV_IDENT:1.0",
393 "org.omg.CORBA.INV_IDENT");
394 exceptionClassNames.put("IDL:omg.org/CORBA/INV_OBJREF:1.0",
395 "org.omg.CORBA.INV_OBJREF");
396 exceptionClassNames.put("IDL:omg.org/CORBA/MARSHAL:1.0",
397 "org.omg.CORBA.MARSHAL");
398 exceptionClassNames.put("IDL:omg.org/CORBA/NO_MEMORY:1.0",
399 "org.omg.CORBA.NO_MEMORY");
400 exceptionClassNames.put("IDL:omg.org/CORBA/FREE_MEM:1.0",
401 "org.omg.CORBA.FREE_MEM");
402 exceptionClassNames.put("IDL:omg.org/CORBA/NO_IMPLEMENT:1.0",
403 "org.omg.CORBA.NO_IMPLEMENT");
404 exceptionClassNames.put("IDL:omg.org/CORBA/NO_PERMISSION:1.0",
405 "org.omg.CORBA.NO_PERMISSION");
406 exceptionClassNames.put("IDL:omg.org/CORBA/NO_RESOURCES:1.0",
407 "org.omg.CORBA.NO_RESOURCES");
408 exceptionClassNames.put("IDL:omg.org/CORBA/NO_RESPONSE:1.0",
409 "org.omg.CORBA.NO_RESPONSE");
410 exceptionClassNames.put("IDL:omg.org/CORBA/OBJ_ADAPTER:1.0",
411 "org.omg.CORBA.OBJ_ADAPTER");
412 exceptionClassNames.put("IDL:omg.org/CORBA/INITIALIZE:1.0",
413 "org.omg.CORBA.INITIALIZE");
414 exceptionClassNames.put("IDL:omg.org/CORBA/PERSIST_STORE:1.0",
415 "org.omg.CORBA.PERSIST_STORE");
416 exceptionClassNames.put("IDL:omg.org/CORBA/TRANSIENT:1.0",
417 "org.omg.CORBA.TRANSIENT");
418 exceptionClassNames.put("IDL:omg.org/CORBA/UNKNOWN:1.0",
419 "org.omg.CORBA.UNKNOWN");
420 exceptionClassNames.put("IDL:omg.org/CORBA/OBJECT_NOT_EXIST:1.0",
421 "org.omg.CORBA.OBJECT_NOT_EXIST");
423 // SystemExceptions from OMG Transactions Service Spec
424 exceptionClassNames.put("IDL:omg.org/CORBA/INVALID_TRANSACTION:1.0",
425 "org.omg.CORBA.INVALID_TRANSACTION");
426 exceptionClassNames.put("IDL:omg.org/CORBA/TRANSACTION_REQUIRED:1.0",
427 "org.omg.CORBA.TRANSACTION_REQUIRED");
428 exceptionClassNames.put("IDL:omg.org/CORBA/TRANSACTION_ROLLEDBACK:1.0",
429 "org.omg.CORBA.TRANSACTION_ROLLEDBACK");
431 // from portability RTF 98-07-01.txt
432 exceptionClassNames.put("IDL:omg.org/CORBA/INV_POLICY:1.0",
433 "org.omg.CORBA.INV_POLICY");
435 // from orbrev/00-09-01 (CORBA 2.4 Draft Specification)
436 exceptionClassNames.
437 put("IDL:omg.org/CORBA/TRANSACTION_UNAVAILABLE:1.0",
438 "org.omg.CORBA.TRANSACTION_UNAVAILABLE");
439 exceptionClassNames.put("IDL:omg.org/CORBA/TRANSACTION_MODE:1.0",
440 "org.omg.CORBA.TRANSACTION_MODE");
442 // Exception types introduced between CORBA 2.4 and 3.0
443 exceptionClassNames.put("IDL:omg.org/CORBA/CODESET_INCOMPATIBLE:1.0",
444 "org.omg.CORBA.CODESET_INCOMPATIBLE");
445 exceptionClassNames.put("IDL:omg.org/CORBA/REBIND:1.0",
446 "org.omg.CORBA.REBIND");
447 exceptionClassNames.put("IDL:omg.org/CORBA/TIMEOUT:1.0",
448 "org.omg.CORBA.TIMEOUT");
449 exceptionClassNames.put("IDL:omg.org/CORBA/BAD_QOS:1.0",
450 "org.omg.CORBA.BAD_QOS");
452 // Exception types introduced in CORBA 3.0
453 exceptionClassNames.put("IDL:omg.org/CORBA/INVALID_ACTIVITY:1.0",
454 "org.omg.CORBA.INVALID_ACTIVITY");
455 exceptionClassNames.put("IDL:omg.org/CORBA/ACTIVITY_COMPLETED:1.0",
456 "org.omg.CORBA.ACTIVITY_COMPLETED");
457 exceptionClassNames.put("IDL:omg.org/CORBA/ACTIVITY_REQUIRED:1.0",
458 "org.omg.CORBA.ACTIVITY_REQUIRED");
460 //
461 // construct className -> repositoryId hashtable
462 //
463 Enumeration keys = exceptionClassNames.keys();
464 java.lang.Object s;
465 String rId;
466 String cName;
468 try{
469 while (keys.hasMoreElements()) {
470 s = keys.nextElement();
471 rId = (String) s;
472 cName = (String) exceptionClassNames.get(rId);
473 exceptionRepositoryIds.put (cName, rId);
474 }
475 } catch (NoSuchElementException e) { }
476 }
478 /** Parse a version string such as "1.1.6" or "jdk1.2fcs" into
479 a version array of integers {1, 1, 6} or {1, 2}.
480 A string of "n." or "n..m" is equivalent to "n.0" or "n.0.m" respectively.
481 */
482 public static int[] parseVersion(String version) {
483 if (version == null)
484 return new int[0];
485 char[] s = version.toCharArray();
486 //find the maximum span of the string "n.n.n..." where n is an integer
487 int start = 0;
488 for (; start < s.length && (s[start] < '0' || s[start] > '9'); ++start)
489 if (start == s.length) //no digit found
490 return new int[0];
491 int end = start + 1;
492 int size = 1;
493 for (; end < s.length; ++end)
494 if (s[end] == '.')
495 ++size;
496 else if (s[end] < '0' || s[end] > '9')
497 break;
498 int[] val = new int[size];
499 for (int i = 0; i < size; ++i) {
500 int dot = version.indexOf('.', start);
501 if (dot == -1 || dot > end)
502 dot = end;
503 if (start >= dot) //cases like "n." or "n..m"
504 val[i] = 0; //convert equivalent to "n.0" or "n.0.m"
505 else
506 val[i] = Integer.parseInt(version.substring(start, dot));
507 start = dot + 1;
508 }
509 return val;
510 }
512 /** Compare two version arrays.
513 Return 1, 0 or -1 if v1 is greater than, equal to, or less than v2.
514 */
515 public static int compareVersion(int[] v1, int[] v2) {
516 if (v1 == null)
517 v1 = new int[0];
518 if (v2 == null)
519 v2 = new int[0];
520 for (int i = 0; i < v1.length; ++i) {
521 if (i >= v2.length || v1[i] > v2[i]) //v1 is longer or greater than v2
522 return 1;
523 if (v1[i] < v2[i])
524 return -1;
525 }
526 return v1.length == v2.length ? 0 : -1;
527 }
529 /** Compare two version strings.
530 Return 1, 0 or -1 if v1 is greater than, equal to, or less than v2.
531 */
532 public static synchronized int compareVersion(String v1, String v2) {
533 return compareVersion(parseVersion(v1), parseVersion(v2));
534 }
536 private static String compressClassName( String name )
537 {
538 // Note that this must end in . in order to be renamed correctly.
539 String prefix = "com.sun.corba.se." ;
540 if (name.startsWith( prefix ) ) {
541 return "(ORB)." + name.substring( prefix.length() ) ;
542 } else
543 return name ;
544 }
546 // Return a compressed representation of the thread name. This is particularly
547 // useful on the server side, where there are many SelectReaderThreads, and
548 // we need a short unambiguous name for such threads.
549 public static String getThreadName( Thread thr )
550 {
551 if (thr == null)
552 return "null" ;
554 // This depends on the formatting in SelectReaderThread and CorbaConnectionImpl.
555 // Pattern for SelectReaderThreads:
556 // SelectReaderThread CorbaConnectionImpl[ <host> <post> <state>]
557 // Any other pattern in the Thread's name is just returned.
558 String name = thr.getName() ;
559 StringTokenizer st = new StringTokenizer( name ) ;
560 int numTokens = st.countTokens() ;
561 if (numTokens != 5)
562 return name ;
564 String[] tokens = new String[numTokens] ;
565 for (int ctr=0; ctr<numTokens; ctr++ )
566 tokens[ctr] = st.nextToken() ;
568 if( !tokens[0].equals("SelectReaderThread"))
569 return name ;
571 return "SelectReaderThread[" + tokens[2] + ":" + tokens[3] + "]" ;
572 }
574 private static String formatStackTraceElement( StackTraceElement ste )
575 {
576 return compressClassName( ste.getClassName() ) + "." + ste.getMethodName() +
577 (ste.isNativeMethod() ? "(Native Method)" :
578 (ste.getFileName() != null && ste.getLineNumber() >= 0 ?
579 "(" + ste.getFileName() + ":" + ste.getLineNumber() + ")" :
580 (ste.getFileName() != null ? "("+ste.getFileName()+")" : "(Unknown Source)")));
581 }
583 private static void printStackTrace( StackTraceElement[] trace )
584 {
585 System.out.println( " Stack Trace:" ) ;
586 // print the stack trace, ommitting the zeroth element, which is
587 // always this method.
588 for ( int ctr = 1; ctr < trace.length; ctr++ ) {
589 System.out.print( " >" ) ;
590 System.out.println( formatStackTraceElement( trace[ctr] ) ) ;
591 }
592 }
594 //
595 // Implements all dprint calls in this package.
596 //
597 public static synchronized void dprint(java.lang.Object obj, String msg) {
598 System.out.println(
599 compressClassName( obj.getClass().getName() ) + "(" +
600 getThreadName( Thread.currentThread() ) + "): " + msg);
601 }
603 public static synchronized void dprint(String className, String msg) {
604 System.out.println(
605 compressClassName( className ) + "(" +
606 getThreadName( Thread.currentThread() ) + "): " + msg);
607 }
609 public synchronized void dprint(String msg) {
610 ORBUtility.dprint(this, msg);
611 }
613 public static synchronized void dprintTrace(Object obj, String msg) {
614 ORBUtility.dprint(obj, msg);
616 Throwable thr = new Throwable() ;
617 printStackTrace( thr.getStackTrace() ) ;
618 }
620 public static synchronized void dprint(java.lang.Object caller,
621 String msg, Throwable t)
622 {
623 System.out.println(
624 compressClassName( caller.getClass().getName() ) +
625 '(' + Thread.currentThread() + "): " + msg);
627 if (t != null)
628 printStackTrace( t.getStackTrace() ) ;
629 }
631 public static String[] concatenateStringArrays( String[] arr1, String[] arr2 )
632 {
633 String[] result = new String[
634 arr1.length + arr2.length ] ;
636 for (int ctr = 0; ctr<arr1.length; ctr++)
637 result[ctr] = arr1[ctr] ;
639 for (int ctr = 0; ctr<arr2.length; ctr++)
640 result[ctr + arr1.length] = arr2[ctr] ;
642 return result ;
643 }
645 /**
646 * Throws the CORBA equivalent of a java.io.NotSerializableException
647 *
648 * Duplicated from util/Utility for Pure ORB reasons. There are two
649 * reasons for this:
650 *
651 * 1) We can't introduce dependencies on the util version from outside
652 * of the io/util packages since it will not exist in the pure ORB
653 * build running on JDK 1.3.x.
654 *
655 * 2) We need to pick up the correct minor code from OMGSystemException.
656 */
657 public static void throwNotSerializableForCorba(String className) {
658 throw omgWrapper.notSerializable( CompletionStatus.COMPLETED_MAYBE,
659 className ) ;
660 }
662 /**
663 * Returns the maximum stream format version supported by our
664 * ValueHandler.
665 */
666 public static byte getMaxStreamFormatVersion() {
667 ValueHandler vh = Util.createValueHandler();
669 if (!(vh instanceof javax.rmi.CORBA.ValueHandlerMultiFormat))
670 return ORBConstants.STREAM_FORMAT_VERSION_1;
671 else
672 return ((ValueHandlerMultiFormat)vh).getMaximumStreamFormatVersion();
673 }
675 public static CorbaClientDelegate makeClientDelegate( IOR ior )
676 {
677 ORB orb = ior.getORB() ;
678 CorbaContactInfoList ccil = orb.getCorbaContactInfoListFactory().create( ior ) ;
679 CorbaClientDelegate del = orb.getClientDelegateFactory().create(ccil);
680 return del ;
681 }
683 /** This method is used to create untyped object references.
684 */
685 public static org.omg.CORBA.Object makeObjectReference( IOR ior )
686 {
687 CorbaClientDelegate del = makeClientDelegate( ior ) ;
688 org.omg.CORBA.Object objectImpl = new CORBAObjectImpl() ;
689 StubAdapter.setDelegate( objectImpl, del ) ;
690 return objectImpl ;
691 }
693 /** This method obtains an IOR from a CORBA object reference.
694 * It will return null if obj is a local object, a null object,
695 * or an object implemented by a different ORB. It will
696 * throw BAD_OPERATION if obj is an unconnected RMI-IIOP object.
697 * @return IOR the IOR that represents this objref. This will
698 * never be null.
699 * @exception BAD_OPERATION (from oi._get_delegate) if obj is a
700 * normal objref, but does not have a delegate set.
701 * @exception BAD_PARAM if obj is a local object, or else was
702 * created by a foreign ORB.
703 */
704 public static IOR getIOR( org.omg.CORBA.Object obj )
705 {
706 if (obj == null)
707 throw wrapper.nullObjectReference() ;
709 IOR ior = null ;
710 if (StubAdapter.isStub(obj)) {
711 org.omg.CORBA.portable.Delegate del = StubAdapter.getDelegate(
712 obj ) ;
714 if (del instanceof CorbaClientDelegate) {
715 CorbaClientDelegate cdel = (CorbaClientDelegate)del ;
716 ContactInfoList cil = cdel.getContactInfoList() ;
718 if (cil instanceof CorbaContactInfoList) {
719 CorbaContactInfoList ccil = (CorbaContactInfoList)cil ;
720 ior = ccil.getTargetIOR() ;
721 if (ior == null)
722 throw wrapper.nullIor() ;
724 return ior ;
725 } else {
726 // This is our code, but the ContactInfoList is not a
727 // CorbaContactInfoList. This should not happen, because
728 // we are in the CORBA application of the DCSA framework.
729 // This is a coding error, and thus an INTERNAL exception
730 // should be thrown.
731 // XXX needs minor code
732 throw new INTERNAL() ;
733 }
734 }
736 // obj is implemented by a foreign ORB, because the Delegate is not a
737 // ClientDelegate.
738 // XXX this case could be handled by marshalling and
739 // unmarshalling. However, object_to_string cannot be used
740 // here, as it is implemented with getIOR. Note that this
741 // will require access to an ORB, so that we can create streams
742 // as needed. The ORB is available simply as io._orb().
743 throw wrapper.objrefFromForeignOrb() ;
744 } else
745 throw wrapper.localObjectNotAllowed() ;
746 }
748 /** Obtains an IOR for the object reference obj, first connecting it to
749 * the ORB if necessary.
750 * @return IOR the IOR that represents this objref. This will
751 * never be null.
752 * @exception BAD_OPERATION if the object could not be connected,
753 * if a connection attempt was needed.
754 * @exception BAD_PARAM if obj is a local object, or else was
755 * created by a foreign ORB.
756 */
757 public static IOR connectAndGetIOR( ORB orb, org.omg.CORBA.Object obj )
758 {
759 IOR result ;
760 try {
761 result = getIOR( obj ) ;
762 } catch (BAD_OPERATION bop) {
763 if (StubAdapter.isStub(obj)) {
764 try {
765 StubAdapter.connect( obj, orb ) ;
766 } catch (java.rmi.RemoteException exc) {
767 throw wrapper.connectingServant( exc ) ;
768 }
769 } else {
770 orb.connect( obj ) ;
771 }
773 result = getIOR( obj ) ;
774 }
776 return result ;
777 }
779 public static String operationNameAndRequestId(CorbaMessageMediator m)
780 {
781 return "op/" + m.getOperationName() + " id/" + m.getRequestId();
782 }
784 public static boolean isPrintable(char c)
785 {
786 if (Character.isJavaIdentifierStart(c)) {
787 // Letters and $ _
788 return true;
789 }
790 if (Character.isDigit(c)) {
791 return true;
792 }
793 switch (Character.getType(c)) {
794 case Character.MODIFIER_SYMBOL : return true; // ` ^
795 case Character.DASH_PUNCTUATION : return true; // -
796 case Character.MATH_SYMBOL : return true; // = ~ + | < >
797 case Character.OTHER_PUNCTUATION : return true; // !@#%&*;':",./?
798 case Character.START_PUNCTUATION : return true; // ( [ {
799 case Character.END_PUNCTUATION : return true; // ) ] }
800 }
801 return false;
802 }
804 public static String getClassSecurityInfo(final Class cl)
805 {
806 // Returns a String which looks similar to:
807 // PermissionCollection java.security.Permissions@1053693 ...
808 // (java.io.FilePermission <<ALL FILES>> ....)
809 // (java.io.FilePermission /export0/sunwappserv/lib/- ...)
810 // ... other permissions ...
811 // Domain ProtectionDomain (file:/export0/sunwappserv/lib-)
812 // java.security.Permissions@141fedb (
813 // (java.io.FilePermission <<ALL FILES>> ...)
814 // (java.io.FilePermission /var/tmp//- ...)
816 String result =
817 (String)AccessController.doPrivileged(new PrivilegedAction() {
818 public java.lang.Object run() {
819 StringBuffer sb = new StringBuffer(500);
820 ProtectionDomain pd = cl.getProtectionDomain();
821 Policy policy = Policy.getPolicy();
822 PermissionCollection pc = policy.getPermissions(pd);
823 sb.append("\nPermissionCollection ");
824 sb.append(pc.toString());
825 // Don't need to add 'Protection Domain' string, it's
826 // in ProtectionDomain.toString() already.
827 sb.append(pd.toString());
828 return sb.toString();
829 }
830 });
831 return result;
832 }
833 }
835 // End of file.
