1 /*
2 * Copyright (c) 1999, 2010, 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 */
25
26 package com.sun.jndi.rmi.registry;
27
28
29 import java.util.Hashtable;
30 import java.util.Properties;
31 import java.rmi.*;
32 import java.rmi.server.*;
33 import java.rmi.registry.Registry;
34 import java.rmi.registry.LocateRegistry;
35
36 import javax.naming.*;
37 import javax.naming.spi.NamingManager;
38
39
40 /**
41 * A RegistryContext is a context representing a remote RMI registry.
42 *
43 * @author Scott Seligman
44 */
45
46
47 public class RegistryContext implements Context, Referenceable {
48
49 private Hashtable environment;
50 private Registry registry;
51 private String host;
52 private int port;
53 private static final NameParser nameParser = new AtomicNameParser();
54 private static final String SOCKET_FACTORY = "com.sun.jndi.rmi.factory.socket";
55
56 Reference reference = null; // ref used to create this context, if any
57
58 // Environment property that, if set, indicates that a security
59 // manager should be installed (if none is already in place).
60 public static final String SECURITY_MGR =
61 "java.naming.rmi.security.manager";
62
63 /**
64 * Returns a context for the registry at a given host and port.
65 * If "host" is null, uses default host.
66 * If "port" is non-positive, uses default port.
67 * Cloning of "env" is handled by caller; see comments within
68 * RegistryContextFactory.getObjectInstance(), for example.
69 */
70 public RegistryContext(String host, int port, Hashtable env)
71 throws NamingException
72 {
73 environment = ((env == null) ? new Hashtable(5) : env);
74 if (environment.get(SECURITY_MGR) != null) {
75 installSecurityMgr();
76 }
77
78 // chop off '[' and ']' in an IPv6 literal address
79 if ((host != null) && (host.charAt(0) == '[')) {
80 host = host.substring(1, host.length() - 1);
81 }
82
83 RMIClientSocketFactory socketFactory =
84 (RMIClientSocketFactory) environment.get(SOCKET_FACTORY);
85 registry = getRegistry(host, port, socketFactory);
86 this.host = host;
87 this.port = port;
88 }
89
90 /**
91 * Returns a clone of a registry context. The context's private state
92 * is independent of the original's (so closing one context, for example,
93 * won't close the other).
94 */
95 // %%% Alternatively, this could be done with a clone() method.
96 RegistryContext(RegistryContext ctx) {
97 environment = (Hashtable)ctx.environment.clone();
98 registry = ctx.registry;
99 host = ctx.host;
100 port = ctx.port;
101 reference = ctx.reference;
102 }
103
104 protected void finalize() {
105 close();
106 }
107
108 public Object lookup(Name name) throws NamingException {
109 if (name.isEmpty()) {
110 return (new RegistryContext(this));
111 }
112 Remote obj;
113 try {
114 obj = registry.lookup(name.get(0));
115 } catch (NotBoundException e) {
116 throw (new NameNotFoundException(name.get(0)));
117 } catch (RemoteException e) {
118 throw (NamingException)wrapRemoteException(e).fillInStackTrace();
119 }
120 return (decodeObject(obj, name.getPrefix(1)));
121 }
122
123 public Object lookup(String name) throws NamingException {
124 return lookup(new CompositeName(name));
125 }
126
127 /**
128 * If the object to be bound is both Remote and Referenceable, binds the
129 * object itself, not its Reference.
130 */
131 public void bind(Name name, Object obj) throws NamingException {
132 if (name.isEmpty()) {
133 throw (new InvalidNameException(
134 "RegistryContext: Cannot bind empty name"));
135 }
136 try {
137 registry.bind(name.get(0), encodeObject(obj, name.getPrefix(1)));
138 } catch (AlreadyBoundException e) {
139 NamingException ne = new NameAlreadyBoundException(name.get(0));
140 ne.setRootCause(e);
141 throw ne;
142 } catch (RemoteException e) {
143 throw (NamingException)wrapRemoteException(e).fillInStackTrace();
144 }
145 }
146
147 public void bind(String name, Object obj) throws NamingException {
148 bind(new CompositeName(name), obj);
149 }
150
151 public void rebind(Name name, Object obj) throws NamingException {
152 if (name.isEmpty()) {
153 throw (new InvalidNameException(
154 "RegistryContext: Cannot rebind empty name"));
155 }
156 try {
157 registry.rebind(name.get(0), encodeObject(obj, name.getPrefix(1)));
158 } catch (RemoteException e) {
159 throw (NamingException)wrapRemoteException(e).fillInStackTrace();
160 }
161 }
162
163 public void rebind(String name, Object obj) throws NamingException {
164 rebind(new CompositeName(name), obj);
165 }
166
167 public void unbind(Name name) throws NamingException {
168 if (name.isEmpty()) {
169 throw (new InvalidNameException(
170 "RegistryContext: Cannot unbind empty name"));
171 }
172 try {
173 registry.unbind(name.get(0));
174 } catch (NotBoundException e) {
175 // method is idempotent
176 } catch (RemoteException e) {
177 throw (NamingException)wrapRemoteException(e).fillInStackTrace();
178 }
179 }
180
181 public void unbind(String name) throws NamingException {
182 unbind(new CompositeName(name));
183 }
184
185 /**
186 * Rename is implemented by this sequence of operations:
187 * lookup, bind, unbind. The sequence is not performed atomically.
188 */
189 public void rename(Name oldName, Name newName) throws NamingException {
190 bind(newName, lookup(oldName));
191 unbind(oldName);
192 }
193
194 public void rename(String name, String newName) throws NamingException {
195 rename(new CompositeName(name), new CompositeName(newName));
196 }
197
198 public NamingEnumeration list(Name name) throws NamingException {
199 if (!name.isEmpty()) {
200 throw (new InvalidNameException(
201 "RegistryContext: can only list \"\""));
202 }
203 try {
204 String[] names = registry.list();
205 return (new NameClassPairEnumeration(names));
206 } catch (RemoteException e) {
207 throw (NamingException)wrapRemoteException(e).fillInStackTrace();
208 }
209 }
210
211 public NamingEnumeration list(String name) throws NamingException {
212 return list(new CompositeName(name));
213 }
214
215 public NamingEnumeration listBindings(Name name)
216 throws NamingException
217 {
218 if (!name.isEmpty()) {
219 throw (new InvalidNameException(
220 "RegistryContext: can only list \"\""));
221 }
222 try {
223 String[] names = registry.list();
224 return (new BindingEnumeration(this, names));
225 } catch (RemoteException e) {
226 throw (NamingException)wrapRemoteException(e).fillInStackTrace();
227 }
228 }
229
230 public NamingEnumeration listBindings(String name) throws NamingException {
231 return listBindings(new CompositeName(name));
232 }
233
234 public void destroySubcontext(Name name) throws NamingException {
235 throw (new OperationNotSupportedException());
236 }
237
238 public void destroySubcontext(String name) throws NamingException {
239 throw (new OperationNotSupportedException());
240 }
241
242 public Context createSubcontext(Name name) throws NamingException {
243 throw (new OperationNotSupportedException());
244 }
245
246 public Context createSubcontext(String name) throws NamingException {
247 throw (new OperationNotSupportedException());
248 }
249
250 public Object lookupLink(Name name) throws NamingException {
251 return lookup(name);
252 }
253
254 public Object lookupLink(String name) throws NamingException {
255 return lookup(name);
256 }
257
258 public NameParser getNameParser(Name name) throws NamingException {
259 return nameParser;
260 }
261
262 public NameParser getNameParser(String name) throws NamingException {
263 return nameParser;
264 }
265
266 public Name composeName(Name name, Name prefix) throws NamingException {
267 Name result = (Name)prefix.clone();
268 return result.addAll(name);
269 }
270
271 public String composeName(String name, String prefix)
272 throws NamingException
273 {
274 return composeName(new CompositeName(name),
275 new CompositeName(prefix)).toString();
276 }
277
278 public Object removeFromEnvironment(String propName)
279 throws NamingException
280 {
281 return environment.remove(propName);
282 }
283
284 public Object addToEnvironment(String propName, Object propVal)
285 throws NamingException
286 {
287 if (propName.equals(SECURITY_MGR)) {
288 installSecurityMgr();
289 }
290 return environment.put(propName, propVal);
291 }
292
293 public Hashtable getEnvironment() throws NamingException {
294 return (Hashtable)environment.clone();
295 }
296
297 public void close() {
298 environment = null;
299 registry = null;
300 // &&& If we were caching registry connections, we would probably
301 // uncache this one now.
302 }
303
304 public String getNameInNamespace() {
305 return ""; // Registry has an empty name
306 }
307
308 /**
309 * Returns an RMI registry reference for this context.
310 *<p>
311 * If this context was created from a reference, that reference is
312 * returned. Otherwise, an exception is thrown if the registry's
313 * host is "localhost" or the default (null). Although this could
314 * possibly make for a valid reference, it's far more likely to be
315 * an easily made error.
316 *
317 * @see RegistryContextFactory
318 */
319 public Reference getReference() throws NamingException {
320 if (reference != null) {
321 return (Reference)reference.clone(); // %%% clone the addrs too?
322 }
323 if (host == null || host.equals("localhost")) {
324 throw (new ConfigurationException(
325 "Cannot create a reference for an RMI registry whose " +
326 "host was unspecified or specified as \"localhost\""));
327 }
328 String url = "rmi://";
329
330 // Enclose IPv6 literal address in '[' and ']'
331 url = (host.indexOf(":") > -1) ? url + "[" + host + "]" :
332 url + host;
333 if (port > 0) {
334 url += ":" + Integer.toString(port);
335 }
336 RefAddr addr = new StringRefAddr(RegistryContextFactory.ADDRESS_TYPE,
337 url);
338 return (new Reference(RegistryContext.class.getName(),
339 addr,
340 RegistryContextFactory.class.getName(),
341 null));
342 }
343
344
345 /**
346 * Wrap a RemoteException inside a NamingException.
347 */
348 public static NamingException wrapRemoteException(RemoteException re) {
349
350 NamingException ne;
351
352 if (re instanceof ConnectException) {
353 ne = new ServiceUnavailableException();
354
355 } else if (re instanceof AccessException) {
356 ne = new NoPermissionException();
357
358 } else if (re instanceof StubNotFoundException ||
359 re instanceof UnknownHostException ||
360 re instanceof SocketSecurityException) {
361 ne = new ConfigurationException();
362
363 } else if (re instanceof ExportException ||
364 re instanceof ConnectIOException ||
365 re instanceof MarshalException ||
366 re instanceof UnmarshalException ||
367 re instanceof NoSuchObjectException) {
368 ne = new CommunicationException();
369
370 } else if (re instanceof ServerException &&
371 re.detail instanceof RemoteException) {
372 ne = wrapRemoteException((RemoteException)re.detail);
373
374 } else {
375 ne = new NamingException();
376 }
377 ne.setRootCause(re);
378 return ne;
379 }
380
381 /**
382 * Returns the registry at a given host, port and socket factory.
383 * If "host" is null, uses default host.
384 * If "port" is non-positive, uses default port.
385 * If "socketFactory" is null, uses the default socket.
386 */
387 private static Registry getRegistry(String host, int port,
388 RMIClientSocketFactory socketFactory)
389 throws NamingException
390 {
391 // %%% We could cache registry connections here. The transport layer
392 // may already reuse connections.
393 try {
394 if (socketFactory == null) {
395 return LocateRegistry.getRegistry(host, port);
396 } else {
397 return LocateRegistry.getRegistry(host, port, socketFactory);
398 }
399 } catch (RemoteException e) {
400 throw (NamingException)wrapRemoteException(e).fillInStackTrace();
401 }
402 }
403
404 /**
405 * Attempts to install a security manager if none is currently in
406 * place.
407 */
408 private static void installSecurityMgr() {
409
410 try {
411 System.setSecurityManager(new RMISecurityManager());
412 } catch (Exception e) {
413 }
414 }
415
416 /**
417 * Encodes an object prior to binding it in the registry. First,
418 * NamingManager.getStateToBind() is invoked. If the resulting
419 * object is Remote, it is returned. If it is a Reference or
420 * Referenceable, the reference is wrapped in a Remote object.
421 * Otherwise, an exception is thrown.
422 *
423 * @param name The object's name relative to this context.
424 */
425 private Remote encodeObject(Object obj, Name name)
426 throws NamingException, RemoteException
427 {
428 obj = NamingManager.getStateToBind(obj, name, this, environment);
429
430 if (obj instanceof Remote) {
431 return (Remote)obj;
432 }
433 if (obj instanceof Reference) {
434 return (new ReferenceWrapper((Reference)obj));
435 }
436 if (obj instanceof Referenceable) {
437 return (new ReferenceWrapper(((Referenceable)obj).getReference()));
438 }
439 throw (new IllegalArgumentException(
440 "RegistryContext: " +
441 "object to bind must be Remote, Reference, or Referenceable"));
442 }
443
444 /**
445 * Decodes an object that has been retrieved from the registry.
446 * First, if the object is a RemoteReference, the Reference is
447 * unwrapped. Then, NamingManager.getObjectInstance() is invoked.
448 *
449 * @param name The object's name relative to this context.
450 */
451 private Object decodeObject(Remote r, Name name) throws NamingException {
452 try {
453 Object obj = (r instanceof RemoteReference)
454 ? ((RemoteReference)r).getReference()
455 : (Object)r;
456 return NamingManager.getObjectInstance(obj, name, this,
457 environment);
458 } catch (NamingException e) {
459 throw e;
460 } catch (RemoteException e) {
461 throw (NamingException)
462 wrapRemoteException(e).fillInStackTrace();
463 } catch (Exception e) {
464 NamingException ne = new NamingException();
465 ne.setRootCause(e);
466 throw ne;
467 }
468 }
469
470 }
471
472
473 /**
474 * A name parser for case-sensitive atomic names.
475 */
476 class AtomicNameParser implements NameParser {
477 private static final Properties syntax = new Properties();
478
479 public Name parse(String name) throws NamingException {
480 return (new CompoundName(name, syntax));
481 }
482 }
483
484
485 /**
486 * An enumeration of name / class-name pairs. Since we don't know anything
487 * about the classes, each class name is returned as the generic
488 * "java.lang.Object".
489 */
490 class NameClassPairEnumeration implements NamingEnumeration {
491 private final String[] names;
492 private int nextName; // index into "names"
493
494 NameClassPairEnumeration(String[] names) {
495 this.names = names;
496 nextName = 0;
497 }
498
499 public boolean hasMore() {
500 return (nextName < names.length);
501 }
502
503 public Object next() throws NamingException {
504 if (!hasMore()) {
505 throw (new java.util.NoSuchElementException());
506 }
507 // Convert name to a one-element composite name, so embedded
508 // meta-characters are properly escaped.
509 String name = names[nextName++];
510 Name cname = (new CompositeName()).add(name);
511 NameClassPair ncp = new NameClassPair(cname.toString(),
512 "java.lang.Object");
513 ncp.setNameInNamespace(name);
514 return ncp;
515 }
516
517 public boolean hasMoreElements() {
518 return hasMore();
519 }
520
521 public Object nextElement() {
522 try {
523 return next();
524 } catch (NamingException e) { // should never happen
525 throw (new java.util.NoSuchElementException(
526 "javax.naming.NamingException was thrown"));
527 }
528 }
529
530 public void close() {
531 nextName = names.length;
532 }
533 }
534
535
536 /**
537 * An enumeration of Bindings.
538 *
539 * The actual registry lookups are performed when next() is called. It would
540 * be nicer to defer this until the object (or its class name) is actually
541 * requested. The problem with that approach is that Binding.getObject()
542 * cannot throw NamingException.
543 */
544 class BindingEnumeration implements NamingEnumeration {
545 private RegistryContext ctx;
546 private final String[] names;
547 private int nextName; // index into "names"
548
549 BindingEnumeration(RegistryContext ctx, String[] names) {
550 // Clone ctx in case someone closes it before we're through.
551 this.ctx = new RegistryContext(ctx);
552 this.names = names;
553 nextName = 0;
554 }
555
556 protected void finalize() {
557 ctx.close();
558 }
559
560 public boolean hasMore() {
561 if (nextName >= names.length) {
562 ctx.close();
563 }
564 return (nextName < names.length);
565 }
566
567 public Object next() throws NamingException {
568 if (!hasMore()) {
569 throw (new java.util.NoSuchElementException());
570 }
571 // Convert name to a one-element composite name, so embedded
572 // meta-characters are properly escaped.
573 String name = names[nextName++];
574 Name cname = (new CompositeName()).add(name);
575
576 Object obj = ctx.lookup(cname);
577 String cnameStr = cname.toString();
578 Binding binding = new Binding(cnameStr, obj);
579 binding.setNameInNamespace(cnameStr);
580 return binding;
581 }
582
583 public boolean hasMoreElements() {
584 return hasMore();
585 }
586
587 public Object nextElement() {
588 try {
589 return next();
590 } catch (NamingException e) {
591 throw (new java.util.NoSuchElementException(
592 "javax.naming.NamingException was thrown"));
593 }
594 }
595
596 public void close () {
597 finalize();
598 }
599 }