1 /*
   2  * Copyright (c) 1996, 2011, 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 java.sql;
  27 
  28 import java.util.Iterator;
  29 import java.util.ServiceLoader;
  30 import java.security.AccessController;
  31 import java.security.PrivilegedAction;
  32 import java.util.concurrent.CopyOnWriteArrayList;

  33 
  34 
  35 /**
  36  * <P>The basic service for managing a set of JDBC drivers.<br>
  37  * <B>NOTE:</B> The {@link <code>DataSource</code>} interface, new in the
  38  * JDBC 2.0 API, provides another way to connect to a data source.
  39  * The use of a <code>DataSource</code> object is the preferred means of
  40  * connecting to a data source.
  41  *
  42  * <P>As part of its initialization, the <code>DriverManager</code> class will
  43  * attempt to load the driver classes referenced in the "jdbc.drivers"
  44  * system property. This allows a user to customize the JDBC Drivers
  45  * used by their applications. For example in your
  46  * ~/.hotjava/properties file you might specify:
  47  * <pre>
  48  * <CODE>jdbc.drivers=foo.bah.Driver:wombat.sql.Driver:bad.taste.ourDriver</CODE>
  49  * </pre>
  50  *<P> The <code>DriverManager</code> methods <code>getConnection</code> and
  51  * <code>getDrivers</code> have been enhanced to support the Java Standard Edition
  52  * <a href="../../../technotes/guides/jar/jar.html#Service%20Provider">Service Provider</a> mechanism. JDBC 4.0 Drivers must
  53  * include the file <code>META-INF/services/java.sql.Driver</code>. This file contains the name of the JDBC drivers
  54  * implementation of <code>java.sql.Driver</code>.  For example, to load the <code>my.sql.Driver</code> class,
  55  * the <code>META-INF/services/java.sql.Driver</code> file would contain the entry:
  56  * <pre>
  57  * <code>my.sql.Driver</code>
  58  * </pre>
  59  *
  60  * <P>Applications no longer need to explictly load JDBC drivers using <code>Class.forName()</code>. Existing programs
  61  * which currently load JDBC drivers using <code>Class.forName()</code> will continue to work without
  62  * modification.
  63  *
  64  * <P>When the method <code>getConnection</code> is called,
  65  * the <code>DriverManager</code> will attempt to
  66  * locate a suitable driver from amongst those loaded at
  67  * initialization and those loaded explicitly using the same classloader
  68  * as the current applet or application.
  69  *
  70  * <P>
  71  * Starting with the Java 2 SDK, Standard Edition, version 1.3, a
  72  * logging stream can be set only if the proper
  73  * permission has been granted.  Normally this will be done with
  74  * the tool PolicyTool, which can be used to grant <code>permission
  75  * java.sql.SQLPermission "setLog"</code>.
  76  * @see Driver
  77  * @see Connection
  78  */
  79 public class DriverManager {
  80 
  81 
  82     // List of registered JDBC drivers
  83     private final static CopyOnWriteArrayList<DriverInfo> registeredDrivers = new CopyOnWriteArrayList<>();
  84     private static volatile int loginTimeout = 0;
  85     private static volatile java.io.PrintWriter logWriter = null;
  86     private static volatile java.io.PrintStream logStream = null;
  87     // Used in println() to synchronize logWriter
  88     private final static  Object logSync = new Object();
  89 
  90     /* Prevent the DriverManager class from being instantiated. */
  91     private DriverManager(){}
  92 
  93 
  94     /**
  95      * Load the initial JDBC drivers by checking the System property
  96      * jdbc.properties and then use the {@code ServiceLoader} mechanism
  97      */
  98     static {
  99         loadInitialDrivers();
 100         println("JDBC DriverManager initialized");
 101     }
 102 
 103     /**
 104      * The <code>SQLPermission</code> constant that allows the
 105      * setting of the logging stream.
 106      * @since 1.3
 107      */
 108     final static SQLPermission SET_LOG_PERMISSION =
 109         new SQLPermission("setLog");
 110 
 111     //--------------------------JDBC 2.0-----------------------------
 112 
 113     /**
 114      * Retrieves the log writer.
 115      *
 116      * The <code>getLogWriter</code> and <code>setLogWriter</code>
 117      * methods should be used instead
 118      * of the <code>get/setlogStream</code> methods, which are deprecated.
 119      * @return a <code>java.io.PrintWriter</code> object
 120      * @see #setLogWriter
 121      * @since 1.2
 122      */
 123     public static java.io.PrintWriter getLogWriter() {
 124             return logWriter;
 125     }
 126 
 127     /**
 128      * Sets the logging/tracing <code>PrintWriter</code> object
 129      * that is used by the <code>DriverManager</code> and all drivers.
 130      * <P>
 131      * There is a minor versioning problem created by the introduction
 132      * of the method <code>setLogWriter</code>.  The
 133      * method <code>setLogWriter</code> cannot create a <code>PrintStream</code> object
 134      * that will be returned by <code>getLogStream</code>---the Java platform does
 135      * not provide a backward conversion.  As a result, a new application
 136      * that uses <code>setLogWriter</code> and also uses a JDBC 1.0 driver that uses
 137      * <code>getLogStream</code> will likely not see debugging information written
 138      * by that driver.
 139      *<P>
 140      * Starting with the Java 2 SDK, Standard Edition, version 1.3 release, this method checks
 141      * to see that there is an <code>SQLPermission</code> object before setting
 142      * the logging stream.  If a <code>SecurityManager</code> exists and its
 143      * <code>checkPermission</code> method denies setting the log writer, this
 144      * method throws a <code>java.lang.SecurityException</code>.
 145      *
 146      * @param out the new logging/tracing <code>PrintStream</code> object;
 147      *      <code>null</code> to disable logging and tracing
 148      * @throws SecurityException
 149      *    if a security manager exists and its
 150      *    <code>checkPermission</code> method denies
 151      *    setting the log writer
 152      *
 153      * @see SecurityManager#checkPermission
 154      * @see #getLogWriter
 155      * @since 1.2
 156      */
 157     public static void setLogWriter(java.io.PrintWriter out) {
 158 
 159         SecurityManager sec = System.getSecurityManager();
 160         if (sec != null) {
 161             sec.checkPermission(SET_LOG_PERMISSION);
 162         }
 163             logStream = null;
 164             logWriter = out;
 165     }
 166 
 167 
 168     //---------------------------------------------------------------
 169 
 170     /**
 171      * Attempts to establish a connection to the given database URL.
 172      * The <code>DriverManager</code> attempts to select an appropriate driver from
 173      * the set of registered JDBC drivers.
 174      *
 175      * @param url a database url of the form
 176      * <code> jdbc:<em>subprotocol</em>:<em>subname</em></code>
 177      * @param info a list of arbitrary string tag/value pairs as
 178      * connection arguments; normally at least a "user" and
 179      * "password" property should be included
 180      * @return a Connection to the URL
 181      * @exception SQLException if a database access error occurs
 182      */
 183     public static Connection getConnection(String url,
 184         java.util.Properties info) throws SQLException {
 185 
 186         // Gets the classloader of the code that called this method, may
 187         // be null.
 188         ClassLoader callerCL = DriverManager.getCallerClassLoader();
 189 
 190         return (getConnection(url, info, callerCL));
 191     }
 192 
 193     /**
 194      * Attempts to establish a connection to the given database URL.
 195      * The <code>DriverManager</code> attempts to select an appropriate driver from
 196      * the set of registered JDBC drivers.
 197      *
 198      * @param url a database url of the form
 199      * <code>jdbc:<em>subprotocol</em>:<em>subname</em></code>
 200      * @param user the database user on whose behalf the connection is being
 201      *   made
 202      * @param password the user's password
 203      * @return a connection to the URL
 204      * @exception SQLException if a database access error occurs
 205      */
 206     public static Connection getConnection(String url,
 207         String user, String password) throws SQLException {
 208         java.util.Properties info = new java.util.Properties();
 209 
 210         // Gets the classloader of the code that called this method, may
 211         // be null.
 212         ClassLoader callerCL = DriverManager.getCallerClassLoader();
 213 
 214         if (user != null) {
 215             info.put("user", user);
 216         }
 217         if (password != null) {
 218             info.put("password", password);
 219         }
 220 
 221         return (getConnection(url, info, callerCL));
 222     }
 223 
 224     /**
 225      * Attempts to establish a connection to the given database URL.
 226      * The <code>DriverManager</code> attempts to select an appropriate driver from
 227      * the set of registered JDBC drivers.
 228      *
 229      * @param url a database url of the form
 230      *  <code> jdbc:<em>subprotocol</em>:<em>subname</em></code>
 231      * @return a connection to the URL
 232      * @exception SQLException if a database access error occurs
 233      */
 234     public static Connection getConnection(String url)
 235         throws SQLException {
 236 
 237         java.util.Properties info = new java.util.Properties();
 238 
 239         // Gets the classloader of the code that called this method, may
 240         // be null.
 241         ClassLoader callerCL = DriverManager.getCallerClassLoader();
 242 
 243         return (getConnection(url, info, callerCL));
 244     }
 245 
 246     /**
 247      * Attempts to locate a driver that understands the given URL.
 248      * The <code>DriverManager</code> attempts to select an appropriate driver from
 249      * the set of registered JDBC drivers.
 250      *
 251      * @param url a database URL of the form
 252      *     <code>jdbc:<em>subprotocol</em>:<em>subname</em></code>
 253      * @return a <code>Driver</code> object representing a driver
 254      * that can connect to the given URL
 255      * @exception SQLException if a database access error occurs
 256      */
 257     public static Driver getDriver(String url)
 258         throws SQLException {
 259 
 260         println("DriverManager.getDriver(\"" + url + "\")");
 261 
 262         // Gets the classloader of the code that called this method, may
 263         // be null.
 264         ClassLoader callerCL = DriverManager.getCallerClassLoader();
 265 
 266         // Walk through the loaded registeredDrivers attempting to locate someone
 267         // who understands the given URL.
 268         for (DriverInfo aDriver : registeredDrivers) {
 269             // If the caller does not have permission to load the driver then
 270             // skip it.
 271             if(isDriverAllowed(aDriver.driver, callerCL)) {
 272                 try {
 273                     if(aDriver.driver.acceptsURL(url)) {
 274                         // Success!
 275                         println("getDriver returning " + aDriver.driver.getClass().getName());
 276                     return (aDriver.driver);
 277                     }
 278 
 279                 } catch(SQLException sqe) {
 280                     // Drop through and try the next driver.
 281                 }
 282             } else {
 283                 println("    skipping: " + aDriver.driver.getClass().getName());
 284             }
 285 
 286         }
 287 
 288         println("getDriver: no suitable driver");
 289         throw new SQLException("No suitable driver", "08001");
 290     }
 291 
 292 
 293     /**
 294      * Registers the given driver with the <code>DriverManager</code>.
 295      * A newly-loaded driver class should call
 296      * the method <code>registerDriver</code> to make itself
 297      * known to the <code>DriverManager</code>.
 298      *
 299      * @param driver the new JDBC Driver that is to be registered with the
 300      *               <code>DriverManager</code>
 301      * @exception SQLException if a database access error occurs
 302      */
 303     public static synchronized void registerDriver(java.sql.Driver driver)
 304         throws SQLException {
 305 
 306         /* Register the driver if it has not already been added to our list */
 307         if(driver != null) {
 308             registeredDrivers.addIfAbsent(new DriverInfo(driver));
 309         } else {
 310             // This is for compatibility with the original DriverManager
 311             throw new NullPointerException();
 312         }
 313 
 314         println("registerDriver: " + driver);
 315 
 316     }
 317 
 318     /**
 319      * Drops a driver from the <code>DriverManager</code>'s list.
 320      *  Applets can only deregister drivers from their own classloaders.
 321      *
 322      * @param driver the JDBC Driver to drop
 323      * @exception SQLException if a database access error occurs
 324      */
 325     public static synchronized void deregisterDriver(Driver driver)
 326         throws SQLException {
 327         if (driver == null) {
 328             return;
 329         }
 330 
 331         // Gets the classloader of the code that called this method,
 332         // may be null.
 333         ClassLoader callerCL = DriverManager.getCallerClassLoader();
 334         println("DriverManager.deregisterDriver: " + driver);
 335 
 336         DriverInfo aDriver = new DriverInfo(driver);
 337         if(registeredDrivers.contains(aDriver)) {
 338             if (isDriverAllowed(driver, callerCL)) {
 339                  registeredDrivers.remove(aDriver);
 340             } else {
 341                 // If the caller does not have permission to load the driver then
 342                 // throw a SecurityException.
 343                 throw new SecurityException();
 344             }
 345         } else {
 346             println("    couldn't find driver to unload");
 347         }
 348     }
 349 
 350     /**
 351      * Retrieves an Enumeration with all of the currently loaded JDBC drivers
 352      * to which the current caller has access.
 353      *
 354      * <P><B>Note:</B> The classname of a driver can be found using
 355      * <CODE>d.getClass().getName()</CODE>
 356      *
 357      * @return the list of JDBC Drivers loaded by the caller's class loader
 358      */
 359     public static java.util.Enumeration<Driver> getDrivers() {
 360         java.util.Vector<Driver> result = new java.util.Vector<>();
 361 
 362         // Gets the classloader of the code that called this method, may
 363         // be null.
 364         ClassLoader callerCL = DriverManager.getCallerClassLoader();
 365 
 366         // Walk through the loaded registeredDrivers.
 367         for(DriverInfo aDriver : registeredDrivers) {
 368             // If the caller does not have permission to load the driver then
 369             // skip it.
 370             if(isDriverAllowed(aDriver.driver, callerCL)) {
 371                 result.addElement(aDriver.driver);
 372             } else {
 373                 println("    skipping: " + aDriver.getClass().getName());
 374             }
 375         }
 376         return (result.elements());
 377     }
 378 
 379 
 380     /**
 381      * Sets the maximum time in seconds that a driver will wait
 382      * while attempting to connect to a database.
 383      *
 384      * @param seconds the login time limit in seconds; zero means there is no limit
 385      * @see #getLoginTimeout
 386      */
 387     public static void setLoginTimeout(int seconds) {
 388         loginTimeout = seconds;
 389     }
 390 
 391     /**
 392      * Gets the maximum time in seconds that a driver can wait
 393      * when attempting to log in to a database.
 394      *
 395      * @return the driver login time limit in seconds
 396      * @see #setLoginTimeout
 397      */
 398     public static int getLoginTimeout() {
 399         return (loginTimeout);
 400     }
 401 
 402     /**
 403      * Sets the logging/tracing PrintStream that is used
 404      * by the <code>DriverManager</code>
 405      * and all drivers.
 406      *<P>
 407      * In the Java 2 SDK, Standard Edition, version 1.3 release, this method checks
 408      * to see that there is an <code>SQLPermission</code> object before setting
 409      * the logging stream.  If a <code>SecurityManager</code> exists and its
 410      * <code>checkPermission</code> method denies setting the log writer, this
 411      * method throws a <code>java.lang.SecurityException</code>.
 412      *
 413      * @param out the new logging/tracing PrintStream; to disable, set to <code>null</code>
 414      * @deprecated
 415      * @throws SecurityException if a security manager exists and its
 416      *    <code>checkPermission</code> method denies setting the log stream
 417      *
 418      * @see SecurityManager#checkPermission
 419      * @see #getLogStream
 420      */
 421     public static void setLogStream(java.io.PrintStream out) {
 422 
 423         SecurityManager sec = System.getSecurityManager();
 424         if (sec != null) {
 425             sec.checkPermission(SET_LOG_PERMISSION);
 426         }
 427 
 428         logStream = out;
 429         if ( out != null )
 430             logWriter = new java.io.PrintWriter(out);
 431         else
 432             logWriter = null;
 433     }
 434 
 435     /**
 436      * Retrieves the logging/tracing PrintStream that is used by the <code>DriverManager</code>
 437      * and all drivers.
 438      *
 439      * @return the logging/tracing PrintStream; if disabled, is <code>null</code>
 440      * @deprecated
 441      * @see #setLogStream
 442      */
 443     public static java.io.PrintStream getLogStream() {
 444         return logStream;
 445     }
 446 
 447     /**
 448      * Prints a message to the current JDBC log stream.
 449      *
 450      * @param message a log or tracing message
 451      */
 452     public static void println(String message) {
 453         synchronized (logSync) {
 454             if (logWriter != null) {
 455                 logWriter.println(message);
 456 
 457                 // automatic flushing is never enabled, so we must do it ourselves
 458                 logWriter.flush();
 459             }
 460         }
 461     }
 462 
 463     //------------------------------------------------------------------------
 464 









 465     // Indicates whether the class object that would be created if the code calling
 466     // DriverManager is accessible.
 467     private static boolean isDriverAllowed(Driver driver, ClassLoader classLoader) {
 468         boolean result = false;
 469         if(driver != null) {
 470             Class<?> aClass = null;
 471             try {
 472                 aClass =  Class.forName(driver.getClass().getName(), true, classLoader);
 473             } catch (Exception ex) {
 474                 result = false;
 475             }
 476 
 477              result = ( aClass == driver.getClass() ) ? true : false;
 478         }
 479 
 480         return result;
 481     }
 482 
 483     private static void loadInitialDrivers() {
 484         String drivers;
 485         try {
 486             drivers = AccessController.doPrivileged(new PrivilegedAction<String>() {
 487                 public String run() {
 488                     return System.getProperty("jdbc.drivers");
 489                 }
 490             });
 491         } catch (Exception ex) {
 492             drivers = null;
 493         }
 494         // If the driver is packaged as a Service Provider, load it.
 495         // Get all the drivers through the classloader
 496         // exposed as a java.sql.Driver.class service.
 497         // ServiceLoader.load() replaces the sun.misc.Providers()
 498 
 499         AccessController.doPrivileged(new PrivilegedAction<Void>() {
 500             public Void run() {
 501 
 502                 ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
 503                 Iterator driversIterator = loadedDrivers.iterator();
 504 
 505                 /* Load these drivers, so that they can be instantiated.
 506                  * It may be the case that the driver class may not be there
 507                  * i.e. there may be a packaged driver with the service class
 508                  * as implementation of java.sql.Driver but the actual class
 509                  * may be missing. In that case a java.util.ServiceConfigurationError
 510                  * will be thrown at runtime by the VM trying to locate
 511                  * and load the service.
 512                  *
 513                  * Adding a try catch block to catch those runtime errors
 514                  * if driver not available in classpath but it's
 515                  * packaged as service and that service is there in classpath.
 516                  */
 517                 try{
 518                     while(driversIterator.hasNext()) {
 519                         println(" Loading done by the java.util.ServiceLoader :  "+driversIterator.next());
 520                     }
 521                 } catch(Throwable t) {
 522                 // Do nothing
 523                 }
 524                 return null;
 525             }
 526         });
 527 
 528         println("DriverManager.initialize: jdbc.drivers = " + drivers);
 529 
 530         if (drivers == null || drivers.equals("")) {
 531             return;
 532         }
 533         String[] driversList = drivers.split(":");
 534         println("number of Drivers:" + driversList.length);
 535         for (String aDriver : driversList) {
 536             try {
 537                 println("DriverManager.Initialize: loading " + aDriver);
 538                 Class.forName(aDriver, true,
 539                         ClassLoader.getSystemClassLoader());
 540             } catch (Exception ex) {
 541                 println("DriverManager.Initialize: load failed: " + ex);
 542             }
 543         }
 544     }
 545 
 546 
 547     //  Worker method called by the public getConnection() methods.
 548     private static Connection getConnection(
 549         String url, java.util.Properties info, ClassLoader callerCL) throws SQLException {
 550         /*
 551          * When callerCl is null, we should check the application's
 552          * (which is invoking this class indirectly)
 553          * classloader, so that the JDBC driver class outside rt.jar
 554          * can be loaded from here.
 555          */
 556         synchronized(DriverManager.class) {
 557           // synchronize loading of the correct classloader.
 558           if(callerCL == null) {
 559               callerCL = Thread.currentThread().getContextClassLoader();
 560            }
 561         }
 562 
 563         if(url == null) {
 564             throw new SQLException("The url cannot be null", "08001");
 565         }
 566 
 567         println("DriverManager.getConnection(\"" + url + "\")");
 568 
 569         // Walk through the loaded registeredDrivers attempting to make a connection.
 570         // Remember the first exception that gets raised so we can reraise it.
 571         SQLException reason = null;
 572 
 573         for(DriverInfo aDriver : registeredDrivers) {
 574             // If the caller does not have permission to load the driver then
 575             // skip it.
 576             if(isDriverAllowed(aDriver.driver, callerCL)) {
 577                 try {
 578                     println("    trying " + aDriver.driver.getClass().getName());
 579                     Connection con = aDriver.driver.connect(url, info);
 580                     if (con != null) {
 581                         // Success!
 582                         println("getConnection returning " + aDriver.driver.getClass().getName());
 583                         return (con);
 584                     }
 585                 } catch (SQLException ex) {
 586                     if (reason == null) {
 587                         reason = ex;
 588                     }
 589                 }
 590 
 591             } else {
 592                 println("    skipping: " + aDriver.getClass().getName());
 593             }
 594 
 595         }
 596 
 597         // if we got here nobody could connect.
 598         if (reason != null)    {
 599             println("getConnection failed: " + reason);
 600             throw reason;
 601         }
 602 
 603         println("getConnection: no suitable driver found for "+ url);
 604         throw new SQLException("No suitable driver found for "+ url, "08001");
 605     }
 606 
 607     /* Returns the caller's class loader, or null if none */
 608     private static native ClassLoader getCallerClassLoader();
 609 
 610 }
 611 
 612 /*
 613  * Wrapper class for registered Drivers in order to not expose Driver.equals()
 614  * to avoid the capture of the Driver it being compared to as it might not
 615  * normally have access.
 616  */
 617 class DriverInfo {
 618 
 619     final Driver driver;
 620     DriverInfo(Driver driver) {
 621         this.driver = driver;
 622     }
 623 
 624     @Override
 625     public boolean equals(Object other) {
 626         return (other instanceof DriverInfo)
 627                 && this.driver == ((DriverInfo) other).driver;
 628     }
 629 
 630     @Override
 631     public int hashCode() {
 632         return driver.hashCode();
 633     }
 634 
 635     @Override
 636     public String toString() {
 637         return ("driver[className="  + driver + "]");
 638     }
 639 }
--- EOF ---