libjava/javax/naming/spi/NamingManager.java

   1 /* NamingManager.java --
   2    Copyright (C) 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package javax.naming.spi;
  40
  41 import java.util.Enumeration;
  42 import java.util.Hashtable;
  43 import java.util.StringTokenizer;
  44 import javax.naming.CannotProceedException;
  45 import javax.naming.Context;
  46 import javax.naming.Name;
  47 import javax.naming.NamingException;
  48 import javax.naming.NoInitialContextException;
  49 import javax.naming.RefAddr;
  50 import javax.naming.Reference;
  51 import javax.naming.Referenceable;
  52 import javax.naming.StringRefAddr;
  53
  54 public class NamingManager
  55 {
  56   public static final String CPE = "java.naming.spi.CannotProceedException";
  57
  58   private static InitialContextFactoryBuilder icfb = null;
  59
  60   // Package private so DirectoryManager can access it.
  61   static ObjectFactoryBuilder ofb = null;
  62
  63   // This class cannot be instantiated.
  64   NamingManager ()
  65   {
  66   }
  67
  68   public static boolean hasInitialContextFactoryBuilder ()
  69   {
  70     return icfb != null;
  71   }
  72
  73   public static Context getInitialContext (Hashtable environment)
  74     throws NamingException
  75   {
  76     InitialContextFactory icf = null;
  77
  78     if (icfb != null)
  79       icf = icfb.createInitialContextFactory(environment);
  80     else
  81       {
  82         String java_naming_factory_initial = null;
  83         if (environment != null)
  84           java_naming_factory_initial
  85             = (String) environment.get (Context.INITIAL_CONTEXT_FACTORY);
  86         if (java_naming_factory_initial == null)
  87           java_naming_factory_initial =
  88             System.getProperty (Context.INITIAL_CONTEXT_FACTORY);
  89         if (java_naming_factory_initial == null)
  90           throw new
  91             NoInitialContextException ("Can't find property: "
  92                                        + Context.INITIAL_CONTEXT_FACTORY);
  93
  94         try
  95           {
  96             icf = (InitialContextFactory)Class.forName
  97                 (java_naming_factory_initial, true,
  98                  Thread.currentThread().getContextClassLoader())
  99                 .newInstance ();
 100           }
 101         catch (Exception exception)
 102           {
 103             NoInitialContextException e
 104               = new NoInitialContextException
 105               ("Can't load InitialContextFactory class: "
 106                + java_naming_factory_initial);
 107             e.setRootCause(exception);
 108             throw e;
 109           }
 110       }
 111
 112     return icf.getInitialContext (environment);
 113   }
 114
 115   static Context getURLContext (Object refInfo,
 116                                 Name name,
 117                                 Context nameCtx,
 118                                 String scheme,
 119                                 Hashtable environment)
 120     throws NamingException
 121   {
 122     String prefixes = null;
 123     if (environment != null)
 124       prefixes = (String) environment.get (Context.URL_PKG_PREFIXES);
 125     if (prefixes == null)
 126       prefixes = System.getProperty (Context.URL_PKG_PREFIXES);
 127     if (prefixes == null)
 128       {
 129         // Specified as the default in the docs.  Unclear if this is
 130         // right for us.
 131         prefixes = "com.sun.jndi.url";
 132       }
 133
 134     scheme = scheme + "." + scheme + "URLContextFactory";
 135
 136     StringTokenizer tokens = new StringTokenizer (prefixes, ":");
 137     while (tokens.hasMoreTokens ())
 138       {
 139         String aTry = tokens.nextToken ();
 140         try
 141           {
 142             Class factoryClass = Class.forName (aTry + "." + scheme,
 143                                                 true,
 144                                                 Thread.currentThread().getContextClassLoader());
 145             ObjectFactory factory =
 146               (ObjectFactory) factoryClass.newInstance ();
 147             Object obj = factory.getObjectInstance (refInfo, name,
 148                                                     nameCtx, environment);
 149             Context ctx = (Context) obj;
 150             if (ctx != null)
 151               return ctx;
 152           }
 153         catch (ClassNotFoundException _1)
 154           {
 155             // Ignore it.
 156           }
 157         catch (ClassCastException _2)
 158           {
 159             // This means that the class we found was not an
 160             // ObjectFactory or that the factory returned something
 161             // which was not a Context.
 162           }
 163         catch (InstantiationException _3)
 164           {
 165             // If we couldn't instantiate the factory we might get
 166             // this.
 167           }
 168         catch (IllegalAccessException _4)
 169           {
 170             // Another possibility when instantiating.
 171           }
 172         catch (NamingException _5)
 173           {
 174             throw _5;
 175           }
 176         catch (Exception _6)
 177           {
 178             // Anything from getObjectInstance.
 179           }
 180       }
 181
 182     return null;
 183   }
 184
 185   public static Context getURLContext (String scheme,
 186                                        Hashtable environment)
 187        throws NamingException
 188   {
 189     return getURLContext (null, null, null, scheme, environment);
 190   }
 191
 192   public static void setObjectFactoryBuilder (ObjectFactoryBuilder builder)
 193     throws NamingException
 194   {
 195     SecurityManager sm = System.getSecurityManager ();
 196     if (sm != null)
 197       sm.checkSetFactory ();
 198     // Once the builder is installed it cannot be replaced.
 199     if (ofb != null)
 200       throw new IllegalStateException ("builder already installed");
 201     if (builder != null)
 202       ofb = builder;
 203   }
 204
 205   static StringTokenizer getPlusPath (String property, Hashtable env,
 206                                       Context nameCtx)
 207     throws NamingException
 208   {
 209     String path = (String) env.get (property);
 210     if (nameCtx == null)
 211       nameCtx = getInitialContext (env);
 212     String path2 = (String) nameCtx.getEnvironment ().get (property);
 213     if (path == null)
 214       path = path2;
 215     else if (path2 != null)
 216       path += ":" + path2;
 217     return new StringTokenizer (path != null ? path : "", ":");
 218   }
 219
 220   public static Object getObjectInstance (Object refInfo,
 221                                           Name name,
 222                                           Context nameCtx,
 223                                           Hashtable environment)
 224     throws Exception
 225   {
 226     ObjectFactory factory = null;
 227
 228     if (ofb != null)
 229       factory = ofb.createObjectFactory (refInfo, environment);
 230     else
 231       {
 232         // First see if we have a Reference or a Referenceable.  If so
 233         // we do some special processing.
 234         Object ref2 = refInfo;
 235         if (refInfo instanceof Referenceable)
 236           ref2 = ((Referenceable) refInfo).getReference ();
 237         if (ref2 instanceof Reference)
 238           {
 239             Reference ref = (Reference) ref2;
 240
 241             // If we have a factory class name then we use that.
 242             String fClass = ref.getFactoryClassName ();
 243             if (fClass != null)
 244               {
 245                 // Exceptions here are passed to the caller.
 246                 Class k = Class.forName (fClass,
 247                                          true,
 248                                          Thread.currentThread().getContextClassLoader());
 249                 factory = (ObjectFactory) k.newInstance ();
 250               }
 251             else
 252               {
 253                 // There's no factory class name.  If the address is a
 254                 // StringRefAddr with address type `URL', then we try
 255                 // the URL's context factory.
 256                 Enumeration e = ref.getAll ();
 257                 while (e.hasMoreElements ())
 258                   {
 259                     RefAddr ra = (RefAddr) e.nextElement ();
 260                     if (ra instanceof StringRefAddr
 261                         && "URL".equals (ra.getType ()))
 262                       {
 263                         factory
 264                           = (ObjectFactory) getURLContext (refInfo,
 265                                                            name,
 266                                                            nameCtx,
 267                                                            (String) ra.getContent (),
 268                                                            environment);
 269                         Object obj = factory.getObjectInstance (refInfo,
 270                                                                 name,
 271                                                                 nameCtx,
 272                                                                 environment);
 273                         if (obj != null)
 274                           return obj;
 275                       }
 276                   }
 277
 278                 // Have to try the next step.
 279                 factory = null;
 280               }
 281           }
 282
 283         // Now look at OBJECT_FACTORIES to find the factory.
 284         if (factory == null)
 285           {
 286             StringTokenizer tokens = getPlusPath (Context.OBJECT_FACTORIES,
 287                                                   environment, nameCtx);
 288
 289             while (tokens.hasMoreTokens ())
 290               {
 291                 String klassName = tokens.nextToken ();
 292                 Class k = Class.forName (klassName,
 293                                          true,
 294                                          Thread.currentThread().getContextClassLoader());
 295                 factory = (ObjectFactory) k.newInstance ();
 296                 Object obj = factory.getObjectInstance (refInfo, name,
 297                                                         nameCtx, environment);
 298                 if (obj != null)
 299                   return obj;
 300               }
 301
 302             // Failure.
 303             return refInfo;
 304           }
 305       }
 306
 307     if (factory == null)
 308       return refInfo;
 309     Object obj = factory.getObjectInstance (refInfo, name,
 310                                             nameCtx, environment);
 311     return obj == null ? refInfo : obj;
 312   }
 313
 314   public static void setInitialContextFactoryBuilder (InitialContextFactoryBuilder builder)
 315     throws NamingException
 316   {
 317     SecurityManager sm = System.getSecurityManager ();
 318     if (sm != null)
 319       sm.checkSetFactory ();
 320     // Once the builder is installed it cannot be replaced.
 321     if (icfb != null)
 322       throw new IllegalStateException ("builder already installed");
 323     if (builder != null)
 324       icfb = builder;
 325   }
 326
 327   public static Context getContinuationContext (CannotProceedException cpe)
 328     throws NamingException
 329   {
 330     Hashtable env = cpe.getEnvironment ();
 331     if (env != null)
 332       env.put (CPE, cpe);
 333
 334     // It is really unclear to me if this is right.
 335     try
 336       {
 337         Object obj = getObjectInstance (cpe.getResolvedObj(),
 338                                         cpe.getAltName (),
 339                                         cpe.getAltNameCtx (),
 340                                         env);
 341         if (obj != null)
 342           return (Context) obj;
 343       }
 344     catch (Exception _)
 345       {
 346       }
 347
 348     // fix stack trace for re-thrown exception (message confusing otherwise)
 349     cpe.fillInStackTrace();
 350
 351     throw cpe;
 352   }
 353
 354   public static Object getStateToBind (Object obj, Name name,
 355                                        Context nameCtx, Hashtable environment)
 356     throws NamingException
 357   {
 358     StringTokenizer tokens = getPlusPath (Context.STATE_FACTORIES,
 359                                           environment, nameCtx);
 360     while (tokens.hasMoreTokens ())
 361       {
 362         String klassName = tokens.nextToken ();
 363         try
 364           {
 365             Class k = Class.forName (klassName,
 366                                      true,
 367                                      Thread.currentThread().getContextClassLoader());
 368             StateFactory factory = (StateFactory) k.newInstance ();
 369             Object o = factory.getStateToBind (obj, name, nameCtx,
 370                                                environment);
 371             if (o != null)
 372               return o;
 373           }
 374         catch (ClassNotFoundException _1)
 375           {
 376             // Ignore it.
 377           }
 378         catch (ClassCastException _2)
 379           {
 380             // This means that the class we found was not an
 381             // ObjectFactory or that the factory returned something
 382             // which was not a Context.
 383           }
 384         catch (InstantiationException _3)
 385           {
 386             // If we couldn't instantiate the factory we might get
 387             // this.
 388           }
 389         catch (IllegalAccessException _4)
 390           {
 391             // Another possibility when instantiating.
 392           }
 393       }
 394
 395     return obj;
 396   }
 397 }