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 import sun.reflect.Reflection;
34
35
36 /**
37 * <P>The basic service for managing a set of JDBC drivers.<br>
38 * <B>NOTE:</B> The {@link <code>DataSource</code>} interface, new in the
39 * JDBC 2.0 API, provides another way to connect to a data source.
40 * The use of a <code>DataSource</code> object is the preferred means of
41 * connecting to a data source.
42 *
43 * <P>As part of its initialization, the <code>DriverManager</code> class will
44 * attempt to load the driver classes referenced in the "jdbc.drivers"
45 * system property. This allows a user to customize the JDBC Drivers
46 * used by their applications. For example in your
47 * ~/.hotjava/properties file you might specify:
48 * <pre>
49 * <CODE>jdbc.drivers=foo.bah.Driver:wombat.sql.Driver:bad.taste.ourDriver</CODE>
50 * </pre>
51 *<P> The <code>DriverManager</code> methods <code>getConnection</code> and
52 * <code>getDrivers</code> have been enhanced to support the Java Standard Edition
53 * <a href="../../../technotes/guides/jar/jar.html#Service%20Provider">Service Provider</a> mechanism. JDBC 4.0 Drivers must
54 * include the file <code>META-INF/services/java.sql.Driver</code>. This file contains the name of the JDBC drivers
55 * implementation of <code>java.sql.Driver</code>. For example, to load the <code>my.sql.Driver</code> class,
56 * the <code>META-INF/services/java.sql.Driver</code> file would contain the entry:
57 * <pre>
58 * <code>my.sql.Driver</code>
59 * </pre>
60 *
61 * <P>Applications no longer need to explictly load JDBC drivers using <code>Class.forName()</code>. Existing programs
62 * which currently load JDBC drivers using <code>Class.forName()</code> will continue to work without
63 * modification.
64 *
65 * <P>When the method <code>getConnection</code> is called,
66 * the <code>DriverManager</code> will attempt to
67 * locate a suitable driver from amongst those loaded at
68 * initialization and those loaded explicitly using the same classloader
69 * as the current applet or application.
70 *
71 * <P>
72 * Starting with the Java 2 SDK, Standard Edition, version 1.3, a
73 * logging stream can be set only if the proper
74 * permission has been granted. Normally this will be done with
75 * the tool PolicyTool, which can be used to grant <code>permission
76 * java.sql.SQLPermission "setLog"</code>.
77 * @see Driver
78 * @see Connection
79 */
80 public class DriverManager {
81
82
83 // List of registered JDBC drivers
84 private final static CopyOnWriteArrayList<DriverInfo> registeredDrivers = new CopyOnWriteArrayList<>();
85 private static volatile int loginTimeout = 0;
86 private static volatile java.io.PrintWriter logWriter = null;
87 private static volatile java.io.PrintStream logStream = null;
88 // Used in println() to synchronize logWriter
89 private final static Object logSync = new Object();
90
91 /* Prevent the DriverManager class from being instantiated. */
92 private DriverManager(){}
93
94
95 /**
96 * Load the initial JDBC drivers by checking the System property
97 * jdbc.properties and then use the {@code ServiceLoader} mechanism
98 */
99 static {
100 loadInitialDrivers();
101 println("JDBC DriverManager initialized");
102 }
103
104 /**
105 * The <code>SQLPermission</code> constant that allows the
106 * setting of the logging stream.
107 * @since 1.3
108 */
109 final static SQLPermission SET_LOG_PERMISSION =
110 new SQLPermission("setLog");
111
112 //--------------------------JDBC 2.0-----------------------------
113
114 /**
115 * Retrieves the log writer.
116 *
117 * The <code>getLogWriter</code> and <code>setLogWriter</code>
118 * methods should be used instead
119 * of the <code>get/setlogStream</code> methods, which are deprecated.
120 * @return a <code>java.io.PrintWriter</code> object
121 * @see #setLogWriter
122 * @since 1.2
123 */
124 public static java.io.PrintWriter getLogWriter() {
125 return logWriter;
126 }
127
128 /**
129 * Sets the logging/tracing <code>PrintWriter</code> object
130 * that is used by the <code>DriverManager</code> and all drivers.
131 * <P>
132 * There is a minor versioning problem created by the introduction
133 * of the method <code>setLogWriter</code>. The
134 * method <code>setLogWriter</code> cannot create a <code>PrintStream</code> object
135 * that will be returned by <code>getLogStream</code>---the Java platform does
136 * not provide a backward conversion. As a result, a new application
137 * that uses <code>setLogWriter</code> and also uses a JDBC 1.0 driver that uses
138 * <code>getLogStream</code> will likely not see debugging information written
139 * by that driver.
140 *<P>
141 * Starting with the Java 2 SDK, Standard Edition, version 1.3 release, this method checks
142 * to see that there is an <code>SQLPermission</code> object before setting
143 * the logging stream. If a <code>SecurityManager</code> exists and its
144 * <code>checkPermission</code> method denies setting the log writer, this
145 * method throws a <code>java.lang.SecurityException</code>.
146 *
147 * @param out the new logging/tracing <code>PrintStream</code> object;
148 * <code>null</code> to disable logging and tracing
149 * @throws SecurityException
150 * if a security manager exists and its
151 * <code>checkPermission</code> method denies
152 * setting the log writer
153 *
154 * @see SecurityManager#checkPermission
155 * @see #getLogWriter
156 * @since 1.2
157 */
158 public static void setLogWriter(java.io.PrintWriter out) {
159
160 SecurityManager sec = System.getSecurityManager();
161 if (sec != null) {
162 sec.checkPermission(SET_LOG_PERMISSION);
163 }
164 logStream = null;
165 logWriter = out;
166 }
167
168
169 //---------------------------------------------------------------
170
171 /**
172 * Attempts to establish a connection to the given database URL.
173 * The <code>DriverManager</code> attempts to select an appropriate driver from
174 * the set of registered JDBC drivers.
175 *
176 * @param url a database url of the form
177 * <code> jdbc:<em>subprotocol</em>:<em>subname</em></code>
178 * @param info a list of arbitrary string tag/value pairs as
179 * connection arguments; normally at least a "user" and
180 * "password" property should be included
181 * @return a Connection to the URL
182 * @exception SQLException if a database access error occurs
183 */
184 public static Connection getConnection(String url,
185 java.util.Properties info) throws SQLException {
186
187 // Gets the classloader of the code that called this method, may
188 // be null.
189 ClassLoader callerCL = DriverManager.getCallerClassLoader();
190
191 return (getConnection(url, info, callerCL));
192 }
193
194 /**
195 * Attempts to establish a connection to the given database URL.
196 * The <code>DriverManager</code> attempts to select an appropriate driver from
197 * the set of registered JDBC drivers.
198 *
199 * @param url a database url of the form
200 * <code>jdbc:<em>subprotocol</em>:<em>subname</em></code>
201 * @param user the database user on whose behalf the connection is being
202 * made
203 * @param password the user's password
204 * @return a connection to the URL
205 * @exception SQLException if a database access error occurs
206 */
207 public static Connection getConnection(String url,
208 String user, String password) throws SQLException {
209 java.util.Properties info = new java.util.Properties();
210
211 // Gets the classloader of the code that called this method, may
212 // be null.
213 ClassLoader callerCL = DriverManager.getCallerClassLoader();
214
215 if (user != null) {
216 info.put("user", user);
217 }
218 if (password != null) {
219 info.put("password", password);
220 }
221
222 return (getConnection(url, info, callerCL));
223 }
224
225 /**
226 * Attempts to establish a connection to the given database URL.
227 * The <code>DriverManager</code> attempts to select an appropriate driver from
228 * the set of registered JDBC drivers.
229 *
230 * @param url a database url of the form
231 * <code> jdbc:<em>subprotocol</em>:<em>subname</em></code>
232 * @return a connection to the URL
233 * @exception SQLException if a database access error occurs
234 */
235 public static Connection getConnection(String url)
236 throws SQLException {
237
238 java.util.Properties info = new java.util.Properties();
239
240 // Gets the classloader of the code that called this method, may
241 // be null.
242 ClassLoader callerCL = DriverManager.getCallerClassLoader();
243
244 return (getConnection(url, info, callerCL));
245 }
246
247 /**
248 * Attempts to locate a driver that understands the given URL.
249 * The <code>DriverManager</code> attempts to select an appropriate driver from
250 * the set of registered JDBC drivers.
251 *
252 * @param url a database URL of the form
253 * <code>jdbc:<em>subprotocol</em>:<em>subname</em></code>
254 * @return a <code>Driver</code> object representing a driver
255 * that can connect to the given URL
256 * @exception SQLException if a database access error occurs
257 */
258 public static Driver getDriver(String url)
259 throws SQLException {
260
261 println("DriverManager.getDriver(\"" + url + "\")");
262
263 // Gets the classloader of the code that called this method, may
264 // be null.
265 ClassLoader callerCL = DriverManager.getCallerClassLoader();
266
267 // Walk through the loaded registeredDrivers attempting to locate someone
268 // who understands the given URL.
269 for (DriverInfo aDriver : registeredDrivers) {
270 // If the caller does not have permission to load the driver then
271 // skip it.
272 if(isDriverAllowed(aDriver.driver, callerCL)) {
273 try {
274 if(aDriver.driver.acceptsURL(url)) {
275 // Success!
276 println("getDriver returning " + aDriver.driver.getClass().getName());
277 return (aDriver.driver);
278 }
279
280 } catch(SQLException sqe) {
281 // Drop through and try the next driver.
282 }
283 } else {
284 println(" skipping: " + aDriver.driver.getClass().getName());
285 }
286
287 }
288
289 println("getDriver: no suitable driver");
290 throw new SQLException("No suitable driver", "08001");
291 }
292
293
294 /**
295 * Registers the given driver with the <code>DriverManager</code>.
296 * A newly-loaded driver class should call
297 * the method <code>registerDriver</code> to make itself
298 * known to the <code>DriverManager</code>.
299 *
300 * @param driver the new JDBC Driver that is to be registered with the
301 * <code>DriverManager</code>
302 * @exception SQLException if a database access error occurs
303 */
304 public static synchronized void registerDriver(java.sql.Driver driver)
305 throws SQLException {
306
307 /* Register the driver if it has not already been added to our list */
308 if(driver != null) {
309 registeredDrivers.addIfAbsent(new DriverInfo(driver));
310 } else {
311 // This is for compatibility with the original DriverManager
312 throw new NullPointerException();
313 }
314
315 println("registerDriver: " + driver);
316
317 }
318
319 /**
320 * Drops a driver from the <code>DriverManager</code>'s list.
321 * Applets can only deregister drivers from their own classloaders.
322 *
323 * @param driver the JDBC Driver to drop
324 * @exception SQLException if a database access error occurs
325 */
326 public static synchronized void deregisterDriver(Driver driver)
327 throws SQLException {
328 if (driver == null) {
329 return;
330 }
331
332 // Gets the classloader of the code that called this method,
333 // may be null.
334 ClassLoader callerCL = DriverManager.getCallerClassLoader();
335 println("DriverManager.deregisterDriver: " + driver);
336
337 DriverInfo aDriver = new DriverInfo(driver);
338 if(registeredDrivers.contains(aDriver)) {
339 if (isDriverAllowed(driver, callerCL)) {
340 registeredDrivers.remove(aDriver);
341 } else {
342 // If the caller does not have permission to load the driver then
343 // throw a SecurityException.
344 throw new SecurityException();
345 }
346 } else {
347 println(" couldn't find driver to unload");
348 }
349 }
350
351 /**
352 * Retrieves an Enumeration with all of the currently loaded JDBC drivers
353 * to which the current caller has access.
354 *
355 * <P><B>Note:</B> The classname of a driver can be found using
356 * <CODE>d.getClass().getName()</CODE>
357 *
358 * @return the list of JDBC Drivers loaded by the caller's class loader
359 */
360 public static java.util.Enumeration<Driver> getDrivers() {
361 java.util.Vector<Driver> result = new java.util.Vector<>();
362
363 // Gets the classloader of the code that called this method, may
364 // be null.
365 ClassLoader callerCL = DriverManager.getCallerClassLoader();
366
367 // Walk through the loaded registeredDrivers.
368 for(DriverInfo aDriver : registeredDrivers) {
369 // If the caller does not have permission to load the driver then
370 // skip it.
371 if(isDriverAllowed(aDriver.driver, callerCL)) {
372 result.addElement(aDriver.driver);
373 } else {
374 println(" skipping: " + aDriver.getClass().getName());
375 }
376 }
377 return (result.elements());
378 }
379
380
381 /**
382 * Sets the maximum time in seconds that a driver will wait
383 * while attempting to connect to a database.
384 *
385 * @param seconds the login time limit in seconds; zero means there is no limit
386 * @see #getLoginTimeout
387 */
388 public static void setLoginTimeout(int seconds) {
389 loginTimeout = seconds;
390 }
391
392 /**
393 * Gets the maximum time in seconds that a driver can wait
394 * when attempting to log in to a database.
395 *
396 * @return the driver login time limit in seconds
397 * @see #setLoginTimeout
398 */
399 public static int getLoginTimeout() {
400 return (loginTimeout);
401 }
402
403 /**
404 * Sets the logging/tracing PrintStream that is used
405 * by the <code>DriverManager</code>
406 * and all drivers.
407 *<P>
408 * In the Java 2 SDK, Standard Edition, version 1.3 release, this method checks
409 * to see that there is an <code>SQLPermission</code> object before setting
410 * the logging stream. If a <code>SecurityManager</code> exists and its
411 * <code>checkPermission</code> method denies setting the log writer, this
412 * method throws a <code>java.lang.SecurityException</code>.
413 *
414 * @param out the new logging/tracing PrintStream; to disable, set to <code>null</code>
415 * @deprecated
416 * @throws SecurityException if a security manager exists and its
417 * <code>checkPermission</code> method denies setting the log stream
418 *
419 * @see SecurityManager#checkPermission
420 * @see #getLogStream
421 */
422 public static void setLogStream(java.io.PrintStream out) {
423
424 SecurityManager sec = System.getSecurityManager();
425 if (sec != null) {
426 sec.checkPermission(SET_LOG_PERMISSION);
427 }
428
429 logStream = out;
430 if ( out != null )
431 logWriter = new java.io.PrintWriter(out);
432 else
433 logWriter = null;
434 }
435
436 /**
437 * Retrieves the logging/tracing PrintStream that is used by the <code>DriverManager</code>
438 * and all drivers.
439 *
440 * @return the logging/tracing PrintStream; if disabled, is <code>null</code>
441 * @deprecated
442 * @see #setLogStream
443 */
444 public static java.io.PrintStream getLogStream() {
445 return logStream;
446 }
447
448 /**
449 * Prints a message to the current JDBC log stream.
450 *
451 * @param message a log or tracing message
452 */
453 public static void println(String message) {
454 synchronized (logSync) {
455 if (logWriter != null) {
456 logWriter.println(message);
457
458 // automatic flushing is never enabled, so we must do it ourselves
459 logWriter.flush();
460 }
461 }
462 }
463
464 //------------------------------------------------------------------------
465
466 // Internal method used to get the caller's class loader.
467 // Replaces the call to the native method
468 private static ClassLoader getCallerClassLoader() {
469 Class<?> cc = Reflection.getCallerClass(3);
470 ClassLoader cl = cc != null ? cc.getClassLoader() : null;
471 return cl;
472 }
473
474
475 // Indicates whether the class object that would be created if the code calling
476 // DriverManager is accessible.
477 private static boolean isDriverAllowed(Driver driver, ClassLoader classLoader) {
478 boolean result = false;
479 if(driver != null) {
480 Class<?> aClass = null;
481 try {
482 aClass = Class.forName(driver.getClass().getName(), true, classLoader);
483 } catch (Exception ex) {
484 result = false;
485 }
486
487 result = ( aClass == driver.getClass() ) ? true : false;
488 }
489
490 return result;
491 }
492
493 private static void loadInitialDrivers() {
494 String drivers;
495 try {
496 drivers = AccessController.doPrivileged(new PrivilegedAction<String>() {
497 public String run() {
498 return System.getProperty("jdbc.drivers");
499 }
500 });
501 } catch (Exception ex) {
502 drivers = null;
503 }
504 // If the driver is packaged as a Service Provider, load it.
505 // Get all the drivers through the classloader
506 // exposed as a java.sql.Driver.class service.
507 // ServiceLoader.load() replaces the sun.misc.Providers()
508
509 AccessController.doPrivileged(new PrivilegedAction<Void>() {
510 public Void run() {
511
512 ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
513 Iterator driversIterator = loadedDrivers.iterator();
514
515 /* Load these drivers, so that they can be instantiated.
516 * It may be the case that the driver class may not be there
517 * i.e. there may be a packaged driver with the service class
518 * as implementation of java.sql.Driver but the actual class
519 * may be missing. In that case a java.util.ServiceConfigurationError
520 * will be thrown at runtime by the VM trying to locate
521 * and load the service.
522 *
523 * Adding a try catch block to catch those runtime errors
524 * if driver not available in classpath but it's
525 * packaged as service and that service is there in classpath.
526 */
527 try{
528 while(driversIterator.hasNext()) {
529 println(" Loading done by the java.util.ServiceLoader : "+driversIterator.next());
530 }
531 } catch(Throwable t) {
532 // Do nothing
533 }
534 return null;
535 }
536 });
537
538 println("DriverManager.initialize: jdbc.drivers = " + drivers);
539
540 if (drivers == null || drivers.equals("")) {
541 return;
542 }
543 String[] driversList = drivers.split(":");
544 println("number of Drivers:" + driversList.length);
545 for (String aDriver : driversList) {
546 try {
547 println("DriverManager.Initialize: loading " + aDriver);
548 Class.forName(aDriver, true,
549 ClassLoader.getSystemClassLoader());
550 } catch (Exception ex) {
551 println("DriverManager.Initialize: load failed: " + ex);
552 }
553 }
554 }
555
556
557 // Worker method called by the public getConnection() methods.
558 private static Connection getConnection(
559 String url, java.util.Properties info, ClassLoader callerCL) throws SQLException {
560 /*
561 * When callerCl is null, we should check the application's
562 * (which is invoking this class indirectly)
563 * classloader, so that the JDBC driver class outside rt.jar
564 * can be loaded from here.
565 */
566 synchronized(DriverManager.class) {
567 // synchronize loading of the correct classloader.
568 if(callerCL == null) {
569 callerCL = Thread.currentThread().getContextClassLoader();
570 }
571 }
572
573 if(url == null) {
574 throw new SQLException("The url cannot be null", "08001");
575 }
576
577 println("DriverManager.getConnection(\"" + url + "\")");
578
579 // Walk through the loaded registeredDrivers attempting to make a connection.
580 // Remember the first exception that gets raised so we can reraise it.
581 SQLException reason = null;
582
583 for(DriverInfo aDriver : registeredDrivers) {
584 // If the caller does not have permission to load the driver then
585 // skip it.
586 if(isDriverAllowed(aDriver.driver, callerCL)) {
587 try {
588 println(" trying " + aDriver.driver.getClass().getName());
589 Connection con = aDriver.driver.connect(url, info);
590 if (con != null) {
591 // Success!
592 println("getConnection returning " + aDriver.driver.getClass().getName());
593 return (con);
594 }
595 } catch (SQLException ex) {
596 if (reason == null) {
597 reason = ex;
598 }
599 }
600
601 } else {
602 println(" skipping: " + aDriver.getClass().getName());
603 }
604
605 }
606
607 // if we got here nobody could connect.
608 if (reason != null) {
609 println("getConnection failed: " + reason);
610 throw reason;
611 }
612
613 println("getConnection: no suitable driver found for "+ url);
614 throw new SQLException("No suitable driver found for "+ url, "08001");
615 }
616
617
618 }
619
620 /*
621 * Wrapper class for registered Drivers in order to not expose Driver.equals()
622 * to avoid the capture of the Driver it being compared to as it might not
623 * normally have access.
624 */
625 class DriverInfo {
626
627 final Driver driver;
628 DriverInfo(Driver driver) {
629 this.driver = driver;
630 }
631
632 @Override
633 public boolean equals(Object other) {
634 return (other instanceof DriverInfo)
635 && this.driver == ((DriverInfo) other).driver;
636 }
637
638 @Override
639 public int hashCode() {
640 return driver.hashCode();
641 }
642
643 @Override
644 public String toString() {
645 return ("driver[className=" + driver + "]");
646 }
647 }