1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_connectivity.hxx"
26 
27 #include "java/sql/Connection.hxx"
28 #include "java/lang/Class.hxx"
29 #include "java/tools.hxx"
30 #include "java/ContextClassLoader.hxx"
31 #include "java/sql/DatabaseMetaData.hxx"
32 #include "java/sql/JStatement.hxx"
33 #include "java/sql/Driver.hxx"
34 #include "java/sql/PreparedStatement.hxx"
35 #include "java/sql/CallableStatement.hxx"
36 #include "java/sql/SQLWarning.hxx"
37 #include <com/sun/star/lang/DisposedException.hpp>
38 #include <com/sun/star/sdbc/SQLWarning.hpp>
39 #include <com/sun/star/sdbc/SQLWarning.hpp>
40 #include <com/sun/star/beans/NamedValue.hpp>
41 #include "connectivity/sqlparse.hxx"
42 #include "connectivity/dbexception.hxx"
43 #include "java/util/Property.hxx"
44 #include "java/LocalRef.hxx"
45 #include "resource/jdbc_log.hrc"
46 #include "com/sun/star/uno/XComponentContext.hpp"
47 #include "jvmaccess/classpath.hxx"
48 #include <comphelper/namedvaluecollection.hxx>
49 #include <rtl/ustrbuf.hxx>
50 #include <jni.h>
51 #include "resource/common_res.hrc"
52 #include <unotools/confignode.hxx>
53 
54 #include <list>
55 #include <memory>
56 
57 using namespace connectivity;
58 using namespace connectivity::jdbc;
59 using namespace ::com::sun::star::uno;
60 using namespace ::com::sun::star::beans;
61 using namespace ::com::sun::star::sdbc;
62 using namespace ::com::sun::star::container;
63 using namespace ::com::sun::star::lang;
64 
65 namespace {
66 
67 struct ClassMapEntry {
ClassMapEntry__anon5f61faf00111::ClassMapEntry68     ClassMapEntry(
69         rtl::OUString const & theClassPath, rtl::OUString const & theClassName):
70         classPath(theClassPath), className(theClassName), classLoader(NULL),
71         classObject(NULL) {}
72 
73     rtl::OUString classPath;
74     rtl::OUString className;
75     jweak classLoader;
76     jweak classObject;
77 };
78 
79 typedef std::list< ClassMapEntry > ClassMap;
80 
81 struct ClassMapData {
82     osl::Mutex mutex;
83 
84     ClassMap map;
85 };
86 
87 struct ClassMapDataInit {
operator ()__anon5f61faf00111::ClassMapDataInit88     ClassMapData * operator()() {
89         static ClassMapData instance;
90         return &instance;
91     }
92 };
93 
94 template < typename T >
getLocalFromWeakRef(jweak & _weak,LocalRef<T> & _inout_local)95 bool getLocalFromWeakRef( jweak& _weak, LocalRef< T >& _inout_local )
96 {
97     _inout_local.set( static_cast< T >( _inout_local.env().NewLocalRef( _weak ) ) );
98 
99     if ( !_inout_local.is() )
100     {
101         if ( _inout_local.env().ExceptionCheck())
102         {
103             return false;
104         }
105         else if ( _weak != NULL )
106         {
107             _inout_local.env().DeleteWeakGlobalRef( _weak );
108             _weak = NULL;
109         }
110     }
111     return true;
112 }
113 
114 // Load a class.  A map from pairs of (classPath, name) to pairs of weak Java
115 // references to (ClassLoader, Class) is maintained, so that a class is only
116 // loaded once.
117 //
118 // It may happen that the weak reference to the ClassLoader becomes null while
119 // the reference to the Class remains non-null (in case the Class was actually
120 // loaded by some parent of the ClassLoader), in which case the ClassLoader is
121 // resurrected (which cannot cause any classes to be loaded multiple times, as
122 // the ClassLoader is no longer reachable, so no classes it has ever loaded are
123 // still reachable).
124 //
125 // Similarly, it may happen that the weak reference to the Class becomes null
126 // while the reference to the ClassLoader remains non-null, in which case the
127 // Class is simply re-loaded.
128 //
129 // This code is close to the implementation of jvmaccess::ClassPath::loadClass
130 // in jvmaccess/classpath.hxx, but not close enough to avoid the duplication.
131 //
132 // If false is returned, a (still pending) JNI exception occurred.
loadClass(Reference<XComponentContext> const & context,JNIEnv & environment,rtl::OUString const & classPath,rtl::OUString const & name,LocalRef<jobject> * classLoaderPtr,LocalRef<jclass> * classPtr)133 bool loadClass(
134     Reference< XComponentContext > const & context, JNIEnv& environment,
135     rtl::OUString const & classPath, rtl::OUString const & name,
136     LocalRef< jobject > * classLoaderPtr, LocalRef< jclass > * classPtr)
137 {
138     OSL_ASSERT(classLoaderPtr != NULL);
139     // For any jweak entries still present in the map upon destruction,
140     // DeleteWeakGlobalRef is not called (which is a leak):
141     ClassMapData * d =
142         rtl_Instance< ClassMapData, ClassMapDataInit, osl::MutexGuard,
143         osl::GetGlobalMutex >::create(
144             ClassMapDataInit(), osl::GetGlobalMutex());
145     osl::MutexGuard g(d->mutex);
146     ClassMap::iterator i(d->map.begin());
147     LocalRef< jobject > cloader(environment);
148     LocalRef< jclass > cl(environment);
149     // Prune dangling weak references from the list while searching for a match,
150     // so that the list cannot grow unbounded:
151     for (; i != d->map.end();)
152     {
153         LocalRef< jobject > classLoader( environment );
154         if ( !getLocalFromWeakRef( i->classLoader, classLoader ) )
155             return false;
156 
157         LocalRef< jclass > classObject( environment );
158         if ( !getLocalFromWeakRef( i->classObject, classObject ) )
159             return false;
160 
161         if ( !classLoader.is() && !classObject.is() )
162         {
163             i = d->map.erase(i);
164         }
165         else if ( i->classPath == classPath && i->className == name )
166         {
167             cloader.set( classLoader.release() );
168             cl.set( classObject.release() );
169             break;
170         }
171         else
172         {
173             ++i;
174         }
175     }
176     if ( !cloader.is() || !cl.is() )
177     {
178         if ( i == d->map.end() )
179         {
180             // Push a new ClassMapEntry (which can potentially fail) before
181             // loading the class, so that it never happens that a class is
182             // loaded but not added to the map (which could have effects on the
183             // JVM that are not easily undone).  If the pushed ClassMapEntry is
184             // not used after all (return false, etc.) it will be pruned on next
185             // call because its classLoader/classObject are null:
186             d->map.push_front( ClassMapEntry( classPath, name ) );
187             i = d->map.begin();
188         }
189 
190         LocalRef< jclass > clClass( environment );
191         clClass.set( environment.FindClass( "java/net/URLClassLoader" ) );
192         if ( !clClass.is() )
193             return false;
194 
195         jweak wcloader = NULL;
196         if (!cloader.is())
197         {
198             jmethodID ctorLoader( environment.GetMethodID( clClass.get(), "<init>", "([Ljava/net/URL;)V" ) );
199             if (ctorLoader == NULL)
200                 return false;
201 
202             LocalRef< jobjectArray > arr( environment );
203             arr.set( jvmaccess::ClassPath::translateToUrls( context, &environment, classPath ) );
204             if ( !arr.is() )
205                 return false;
206 
207             jvalue arg;
208             arg.l = arr.get();
209             cloader.set( environment.NewObjectA( clClass.get(), ctorLoader, &arg ) );
210             if ( !cloader.is() )
211                 return false;
212 
213             wcloader = environment.NewWeakGlobalRef( cloader.get() );
214             if ( wcloader == NULL )
215                 return false;
216         }
217 
218         jweak wcl = NULL;
219         if ( !cl.is() )
220         {
221             jmethodID methLoadClass( environment.GetMethodID( clClass.get(), "loadClass", "(Ljava/lang/String;)Ljava/lang/Class;" ) );
222             if ( methLoadClass == NULL )
223                 return false;
224 
225             LocalRef< jstring > str( environment );
226             str.set( convertwchar_tToJavaString( &environment, name ) );
227             if ( !str.is() )
228                 return false;
229 
230             jvalue arg;
231             arg.l = str.get();
232             cl.set( static_cast< jclass >( environment.CallObjectMethodA( cloader.get(), methLoadClass, &arg ) ) );
233             if ( !cl.is() )
234                 return false;
235 
236             wcl = environment.NewWeakGlobalRef( cl.get() );
237             if ( wcl == NULL )
238                 return false;
239         }
240 
241         if ( wcloader != NULL)
242         {
243             i->classLoader = wcloader;
244         }
245         if ( wcl != NULL )
246         {
247             i->classObject = wcl;
248         }
249     }
250 
251     classLoaderPtr->set( cloader.release() );
252     classPtr->set( cl.release() );
253     return true;
254 }
255 
256 }
257 
258 //------------------------------------------------------------------------------
259 IMPLEMENT_SERVICE_INFO(java_sql_Connection,"com.sun.star.sdbcx.JConnection","com.sun.star.sdbc.Connection");
260 //------------------------------------------------------------------------------
261 //**************************************************************
262 //************ Class: java.sql.Connection
263 //**************************************************************
264 jclass java_sql_Connection::theClass = 0;
265 
java_sql_Connection(const java_sql_Driver & _rDriver)266 java_sql_Connection::java_sql_Connection( const java_sql_Driver& _rDriver )
267     :java_lang_Object( _rDriver.getContext().getLegacyServiceFactory() )
268     ,OSubComponent<java_sql_Connection, java_sql_Connection_BASE>((::cppu::OWeakObject*)(&_rDriver), this)
269     ,m_pDriver( &_rDriver )
270     ,m_pDriverobject(NULL)
271     ,m_pDriverClassLoader()
272     ,m_Driver_theClass(NULL)
273     ,m_aLogger( _rDriver.getLogger() )
274     ,m_bParameterSubstitution(sal_False)
275     ,m_bIgnoreDriverPrivileges(sal_True)
276     ,m_bIgnoreCurrency(sal_False)
277 {
278 }
279 // -----------------------------------------------------------------------------
~java_sql_Connection()280 java_sql_Connection::~java_sql_Connection()
281 {
282 	::rtl::Reference< jvmaccess::VirtualMachine > xTest = java_lang_Object::getVM();
283 	if ( xTest.is() )
284 	{
285 		SDBThreadAttach t;
286         clearObject(*t.pEnv);
287 
288 		{
289 			if ( m_pDriverobject )
290 				t.pEnv->DeleteGlobalRef( m_pDriverobject );
291 			m_pDriverobject = NULL;
292 			if ( m_Driver_theClass )
293 				t.pEnv->DeleteGlobalRef( m_Driver_theClass );
294 			m_Driver_theClass = NULL;
295 		}
296 		t.releaseRef();
297 	}
298 }
299 //-----------------------------------------------------------------------------
release()300 void SAL_CALL java_sql_Connection::release() throw()
301 {
302 	relase_ChildImpl();
303 }
304 //------------------------------------------------------------------------------
disposing()305 void java_sql_Connection::disposing()
306 {
307 	::osl::MutexGuard aGuard(m_aMutex);
308 
309     m_aLogger.log( LogLevel::INFO, STR_LOG_SHUTDOWN_CONNECTION );
310 
311     dispose_ChildImpl();
312 	java_sql_Connection_BASE::disposing();
313 
314 	if ( object )
315 	{
316         static jmethodID mID(NULL);
317         callVoidMethod("close",mID);
318 	}
319 }
320 // -------------------------------------------------------------------------
getMyClass() const321 jclass java_sql_Connection::getMyClass() const
322 {
323 	// die Klasse muss nur einmal geholt werden, daher statisch
324 	if( !theClass )
325         theClass = findMyClass("java/sql/Connection");
326 	return theClass;
327 }
328 
329 // -------------------------------------------------------------------------
getCatalog()330 ::rtl::OUString SAL_CALL java_sql_Connection::getCatalog(  ) throw(SQLException, RuntimeException)
331 {
332 	::osl::MutexGuard aGuard( m_aMutex );
333 	checkDisposed(java_sql_Connection_BASE::rBHelper.bDisposed);
334 
335     static jmethodID mID(NULL);
336     return callStringMethod("getCatalog",mID);
337 }
338 // -------------------------------------------------------------------------
getMetaData()339 Reference< XDatabaseMetaData > SAL_CALL java_sql_Connection::getMetaData(  ) throw(SQLException, RuntimeException)
340 {
341 	::osl::MutexGuard aGuard( m_aMutex );
342 	checkDisposed(java_sql_Connection_BASE::rBHelper.bDisposed);
343 
344 
345 	Reference< XDatabaseMetaData > xMetaData = m_xMetaData;
346 	if(!xMetaData.is())
347 	{
348         SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java Enviroment geloescht worden!");
349         static jmethodID mID(NULL);
350         jobject out = callObjectMethod(t.pEnv,"getMetaData","()Ljava/sql/DatabaseMetaData;", mID);
351 		if(out)
352 		{
353 			xMetaData = new java_sql_DatabaseMetaData( t.pEnv, out, *this );
354 			m_xMetaData = xMetaData;
355 		}
356 	}
357 
358 	return xMetaData;
359 }
360 // -------------------------------------------------------------------------
close()361 void SAL_CALL java_sql_Connection::close(  ) throw(SQLException, RuntimeException)
362 {
363 	dispose();
364 }
365 // -------------------------------------------------------------------------
commit()366 void SAL_CALL java_sql_Connection::commit(  ) throw(SQLException, RuntimeException)
367 {
368     static jmethodID mID(NULL);
369     callVoidMethod("commit",mID);
370 }
371 // -------------------------------------------------------------------------
isClosed()372 sal_Bool SAL_CALL java_sql_Connection::isClosed(  ) throw(SQLException, RuntimeException)
373 {
374 	::osl::MutexGuard aGuard( m_aMutex );
375 
376     static jmethodID mID(NULL);
377     return callBooleanMethod( "isClosed", mID ) && java_sql_Connection_BASE::rBHelper.bDisposed;
378 }
379 // -------------------------------------------------------------------------
isReadOnly()380 sal_Bool SAL_CALL java_sql_Connection::isReadOnly(  ) throw(SQLException, RuntimeException)
381 {
382 	::osl::MutexGuard aGuard( m_aMutex );
383 	checkDisposed(java_sql_Connection_BASE::rBHelper.bDisposed);
384     static jmethodID mID(NULL);
385     return callBooleanMethod( "isReadOnly", mID );
386 }
387 // -------------------------------------------------------------------------
setCatalog(const::rtl::OUString & catalog)388 void SAL_CALL java_sql_Connection::setCatalog( const ::rtl::OUString& catalog ) throw(SQLException, RuntimeException)
389 {
390     static jmethodID mID(NULL);
391     callVoidMethodWithStringArg("setCatalog",mID,catalog);
392 }
393 // -------------------------------------------------------------------------
rollback()394 void SAL_CALL java_sql_Connection::rollback(  ) throw(SQLException, RuntimeException)
395 {
396     static jmethodID mID(NULL);
397     callVoidMethod("rollback",mID);
398 }
399 // -------------------------------------------------------------------------
getAutoCommit()400 sal_Bool SAL_CALL java_sql_Connection::getAutoCommit(  ) throw(SQLException, RuntimeException)
401 {
402     static jmethodID mID(NULL);
403     return callBooleanMethod( "getAutoCommit", mID );
404 }
405 // -------------------------------------------------------------------------
setReadOnly(sal_Bool readOnly)406 void SAL_CALL java_sql_Connection::setReadOnly( sal_Bool readOnly ) throw(SQLException, RuntimeException)
407 {
408     static jmethodID mID(NULL);
409     callVoidMethodWithBoolArg("setReadOnly",mID,readOnly);
410 }
411 // -------------------------------------------------------------------------
setAutoCommit(sal_Bool autoCommit)412 void SAL_CALL java_sql_Connection::setAutoCommit( sal_Bool autoCommit ) throw(SQLException, RuntimeException)
413 {
414     static jmethodID mID(NULL);
415     callVoidMethodWithBoolArg("setAutoCommit",mID,autoCommit);
416 }
417 // -------------------------------------------------------------------------
getTypeMap()418 Reference< ::com::sun::star::container::XNameAccess > SAL_CALL java_sql_Connection::getTypeMap(  ) throw(SQLException, RuntimeException)
419 {
420 	::osl::MutexGuard aGuard( m_aMutex );
421 	checkDisposed(java_sql_Connection_BASE::rBHelper.bDisposed);
422 
423     SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java Enviroment geloescht worden!");
424     static jmethodID mID(NULL);
425     /*jobject out = */callObjectMethod(t.pEnv,"getTypeMap","()Ljava/util/Map;", mID);
426 	// ACHTUNG: der Aufrufer wird Eigentuemer des zurueckgelieferten Zeigers !!!
427 	return 0;// ? 0 : Map2XNameAccess( t.pEnv, out );
428 }
429 // -------------------------------------------------------------------------
setTypeMap(const Reference<::com::sun::star::container::XNameAccess> &)430 void SAL_CALL java_sql_Connection::setTypeMap( const Reference< ::com::sun::star::container::XNameAccess >& /*typeMap*/ ) throw(SQLException, RuntimeException)
431 {
432 	::osl::MutexGuard aGuard( m_aMutex );
433 	checkDisposed(java_sql_Connection_BASE::rBHelper.bDisposed);
434 
435     ::dbtools::throwFeatureNotImplementedException( "XConnection::setTypeMap", *this );
436 }
437 
438 // -------------------------------------------------------------------------
getTransactionIsolation()439 sal_Int32 SAL_CALL java_sql_Connection::getTransactionIsolation(  ) throw(SQLException, RuntimeException)
440 {
441 	::osl::MutexGuard aGuard( m_aMutex );
442 	checkDisposed(java_sql_Connection_BASE::rBHelper.bDisposed);
443 
444     static jmethodID mID(NULL);
445 	return callIntMethod("getTransactionIsolation",mID);
446 }
447 // -------------------------------------------------------------------------
setTransactionIsolation(sal_Int32 level)448 void SAL_CALL java_sql_Connection::setTransactionIsolation( sal_Int32 level ) throw(SQLException, RuntimeException)
449 {
450 	::osl::MutexGuard aGuard( m_aMutex );
451 	checkDisposed(java_sql_Connection_BASE::rBHelper.bDisposed);
452 
453     static jmethodID mID(NULL);
454     callVoidMethodWithIntArg("setTransactionIsolation",mID,level);
455 }
456 // -------------------------------------------------------------------------
createStatement()457 Reference< XStatement > SAL_CALL java_sql_Connection::createStatement(  ) throw(SQLException, RuntimeException)
458 {
459 	::osl::MutexGuard aGuard( m_aMutex );
460 	checkDisposed(java_sql_Connection_BASE::rBHelper.bDisposed);
461     m_aLogger.log( LogLevel::FINE, STR_LOG_CREATE_STATEMENT );
462 
463 	SDBThreadAttach t;
464     java_sql_Statement* pStatement = new java_sql_Statement( t.pEnv, *this );
465 	Reference< XStatement > xStmt = pStatement;
466 	m_aStatements.push_back( WeakReferenceHelper( xStmt ) );
467 
468     m_aLogger.log( LogLevel::FINE, STR_LOG_CREATED_STATEMENT_ID, pStatement->getStatementObjectID() );
469     return xStmt;
470 }
471 // -----------------------------------------------------------------------------
transFormPreparedStatement(const::rtl::OUString & _sSQL)472 ::rtl::OUString java_sql_Connection::transFormPreparedStatement(const ::rtl::OUString& _sSQL)
473 {
474 	::rtl::OUString sSqlStatement = _sSQL;
475 	if ( m_bParameterSubstitution )
476 	{
477 		try
478 		{
479 			OSQLParser aParser( m_pDriver->getContext().getLegacyServiceFactory() );
480 			::rtl::OUString sErrorMessage;
481 			::rtl::OUString sNewSql;
482 			OSQLParseNode* pNode = aParser.parseTree(sErrorMessage,_sSQL);
483 			if(pNode)
484 			{	// special handling for parameters
485 				OSQLParseNode::substituteParameterNames(pNode);
486 				pNode->parseNodeToStr( sNewSql, this );
487 				delete pNode;
488 				sSqlStatement = sNewSql;
489 			}
490 		}
491 		catch(const Exception&)
492 		{
493 		}
494 	}
495 	return sSqlStatement;
496 }
497 // -------------------------------------------------------------------------
prepareStatement(const::rtl::OUString & sql)498 Reference< XPreparedStatement > SAL_CALL java_sql_Connection::prepareStatement( const ::rtl::OUString& sql ) throw(SQLException, RuntimeException)
499 {
500 	::osl::MutexGuard aGuard( m_aMutex );
501 	checkDisposed(java_sql_Connection_BASE::rBHelper.bDisposed);
502     m_aLogger.log( LogLevel::FINE, STR_LOG_PREPARE_STATEMENT, sql );
503 
504     SDBThreadAttach t;
505 	::rtl::OUString sSqlStatement = sql;
506 	sSqlStatement = transFormPreparedStatement( sSqlStatement );
507 
508     java_sql_PreparedStatement* pStatement = new java_sql_PreparedStatement( t.pEnv, *this, sSqlStatement );
509 	Reference< XPreparedStatement > xReturn( pStatement );
510 	m_aStatements.push_back(WeakReferenceHelper(xReturn));
511 
512     m_aLogger.log( LogLevel::FINE, STR_LOG_PREPARED_STATEMENT_ID, pStatement->getStatementObjectID() );
513 	return xReturn;
514 }
515 // -------------------------------------------------------------------------
prepareCall(const::rtl::OUString & sql)516 Reference< XPreparedStatement > SAL_CALL java_sql_Connection::prepareCall( const ::rtl::OUString& sql ) throw(SQLException, RuntimeException)
517 {
518 	::osl::MutexGuard aGuard( m_aMutex );
519 	checkDisposed(java_sql_Connection_BASE::rBHelper.bDisposed);
520     m_aLogger.log( LogLevel::FINE, STR_LOG_PREPARE_CALL, sql );
521 
522 	SDBThreadAttach t;
523 	::rtl::OUString sSqlStatement = sql;
524 	sSqlStatement = transFormPreparedStatement( sSqlStatement );
525 
526     java_sql_CallableStatement* pStatement = new java_sql_CallableStatement( t.pEnv, *this, sSqlStatement );
527 	Reference< XPreparedStatement > xStmt( pStatement );
528 	m_aStatements.push_back(WeakReferenceHelper(xStmt));
529 
530     m_aLogger.log( LogLevel::FINE, STR_LOG_PREPARED_CALL_ID, pStatement->getStatementObjectID() );
531     return xStmt;
532 }
533 // -------------------------------------------------------------------------
nativeSQL(const::rtl::OUString & sql)534 ::rtl::OUString SAL_CALL java_sql_Connection::nativeSQL( const ::rtl::OUString& sql ) throw(SQLException, RuntimeException)
535 {
536 	::osl::MutexGuard aGuard( m_aMutex );
537 	checkDisposed(java_sql_Connection_BASE::rBHelper.bDisposed);
538 
539 	::rtl::OUString aStr;
540     SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java Enviroment geloescht worden!");
541 	{
542 
543 		// temporaere Variable initialisieren
544 		static const char * cSignature = "(Ljava/lang/String;)Ljava/lang/String;";
545 		static const char * cMethodName = "nativeSQL";
546 		// Java-Call absetzen
547 		static jmethodID mID(NULL);
548         obtainMethodId(t.pEnv, cMethodName,cSignature, mID);
549 		// Parameter konvertieren
550 		jdbc::LocalRef< jstring > str( t.env(),convertwchar_tToJavaString(t.pEnv,sql));
551 
552 		jobject out = t.pEnv->CallObjectMethod( object, mID, str.get() );
553 		aStr = JavaString2String(t.pEnv, (jstring)out );
554 		ThrowLoggedSQLException( m_aLogger, t.pEnv, *this );
555 	} //t.pEnv
556 
557     m_aLogger.log( LogLevel::FINER, STR_LOG_NATIVE_SQL, sql, aStr );
558 
559 	return aStr;
560 }
561 // -------------------------------------------------------------------------
clearWarnings()562 void SAL_CALL java_sql_Connection::clearWarnings(  ) throw(SQLException, RuntimeException)
563 {
564     static jmethodID mID(NULL);
565     callVoidMethod("clearWarnings",mID);
566 }
567 // -------------------------------------------------------------------------
getWarnings()568 Any SAL_CALL java_sql_Connection::getWarnings(  ) throw(SQLException, RuntimeException)
569 {
570 	::osl::MutexGuard aGuard( m_aMutex );
571 	checkDisposed(java_sql_Connection_BASE::rBHelper.bDisposed);
572 
573 	SDBThreadAttach t;
574     static jmethodID mID(NULL);
575     jobject out = callObjectMethod(t.pEnv,"getWarnings","()Ljava/sql/SQLWarning;", mID);
576 	// ACHTUNG: der Aufrufer wird Eigentuemer des zurueckgelieferten Zeigers !!!
577 	if( out )
578 	{
579 		java_sql_SQLWarning_BASE		warn_base(t.pEnv, out);
580         SQLException aAsException( static_cast< starsdbc::SQLException >( java_sql_SQLWarning( warn_base, *this ) ) );
581 
582         // translate to warning
583         SQLWarning aWarning;
584         aWarning.Context = aAsException.Context;
585         aWarning.Message = aAsException.Message;
586         aWarning.SQLState = aAsException.SQLState;
587         aWarning.ErrorCode = aAsException.ErrorCode;
588         aWarning.NextException = aAsException.NextException;
589 
590 		return makeAny( aWarning );
591 	}
592 
593 	return Any();
594 }
595 
596 // -----------------------------------------------------------------------------
597 namespace
598 {
lcl_getDriverLoadErrorMessage(const::connectivity::SharedResources & _aResource,const::rtl::OUString & _rDriverClass,const::rtl::OUString & _rDriverClassPath)599     ::rtl::OUString lcl_getDriverLoadErrorMessage( const ::connectivity::SharedResources& _aResource,const ::rtl::OUString& _rDriverClass, const ::rtl::OUString& _rDriverClassPath )
600     {
601         ::rtl::OUString sError1( _aResource.getResourceStringWithSubstitution(
602                 STR_NO_CLASSNAME,
603                 "$classname$", _rDriverClass
604              ) );
605         if ( _rDriverClassPath.getLength() )
606         {
607             const ::rtl::OUString sError2( _aResource.getResourceStringWithSubstitution(
608                 STR_NO_CLASSNAME_PATH,
609                 "$classpath$", _rDriverClassPath
610              ) );
611             sError1 += sError2;
612         } // if ( _rDriverClassPath.getLength() )
613         return sError1;
614     }
615 }
616 
617 // -----------------------------------------------------------------------------
618 namespace
619 {
lcl_setSystemProperties_nothrow(const java::sql::ConnectionLog & _rLogger,JNIEnv & _rEnv,const Sequence<NamedValue> & _rSystemProperties)620     bool lcl_setSystemProperties_nothrow( const java::sql::ConnectionLog& _rLogger,
621         JNIEnv& _rEnv, const Sequence< NamedValue >& _rSystemProperties )
622     {
623         if ( _rSystemProperties.getLength() == 0 )
624             // nothing to do
625             return true;
626 
627         LocalRef< jclass > systemClass( _rEnv );
628         jmethodID nSetPropertyMethodID = 0;
629         // retrieve the java.lang.System class
630         systemClass.set( _rEnv.FindClass( "java/lang/System" ) );
631         if ( systemClass.is() )
632         {
633             nSetPropertyMethodID = _rEnv.GetStaticMethodID(
634                 systemClass.get(), "setProperty", "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;" );
635         }
636 
637         if ( nSetPropertyMethodID == 0 )
638             return false;
639 
640         for (   const NamedValue* pSystemProp = _rSystemProperties.getConstArray();
641                 pSystemProp != _rSystemProperties.getConstArray() + _rSystemProperties.getLength();
642                 ++pSystemProp
643             )
644         {
645             ::rtl::OUString sValue;
646             OSL_VERIFY( pSystemProp->Value >>= sValue );
647 
648             _rLogger.log( LogLevel::FINER, STR_LOG_SETTING_SYSTEM_PROPERTY, pSystemProp->Name, sValue );
649 
650             LocalRef< jstring > jName( _rEnv, convertwchar_tToJavaString( &_rEnv, pSystemProp->Name ) );
651             LocalRef< jstring > jValue( _rEnv, convertwchar_tToJavaString( &_rEnv, sValue ) );
652 
653             _rEnv.CallStaticObjectMethod( systemClass.get(), nSetPropertyMethodID, jName.get(), jValue.get() );
654             LocalRef< jthrowable > throwable( _rEnv, _rEnv.ExceptionOccurred() );
655             if ( throwable.is() )
656                 return false;
657         }
658 
659         return true;
660     }
661 }
662 
663 // -----------------------------------------------------------------------------
loadDriverFromProperties(const::rtl::OUString & _sDriverClass,const::rtl::OUString & _sDriverClassPath,const Sequence<NamedValue> & _rSystemProperties)664 void java_sql_Connection::loadDriverFromProperties( const ::rtl::OUString& _sDriverClass, const ::rtl::OUString& _sDriverClassPath,
665     const Sequence< NamedValue >& _rSystemProperties )
666 {
667     // contains the statement which should be used when query for automatically generated values
668 	::rtl::OUString		sGeneratedValueStatement;
669     // set to <TRUE/> when we should allow to query for generated values
670 	sal_Bool			bAutoRetrievingEnabled = sal_False;
671 
672     // first try if the jdbc driver is alraedy registered at the driver manager
673     SDBThreadAttach t;
674 	try
675 	{
676         if ( !object )
677         {
678             if ( !lcl_setSystemProperties_nothrow( getLogger(), *t.pEnv, _rSystemProperties ) )
679                 ThrowLoggedSQLException( getLogger(), t.pEnv, *this );
680 
681             m_pDriverClassLoader.reset();
682 
683             // here I try to find the class for jdbc driver
684             java_sql_SQLException_BASE::st_getMyClass();
685             java_lang_Throwable::st_getMyClass();
686 
687             if ( !_sDriverClass.getLength() )
688             {
689                 m_aLogger.log( LogLevel::SEVERE, STR_LOG_NO_DRIVER_CLASS );
690                 ::dbtools::throwGenericSQLException(
691                     lcl_getDriverLoadErrorMessage( getResources(),_sDriverClass, _sDriverClassPath ),
692                     *this
693                 );
694             }
695             else
696             {
697                 m_aLogger.log( LogLevel::INFO, STR_LOG_LOADING_DRIVER, _sDriverClass );
698                 // the driver manager holds the class of the driver for later use
699                 ::std::auto_ptr< java_lang_Class > pDrvClass;
700                 if ( !_sDriverClassPath.getLength() )
701                 {
702 					// if forName didn't find the class it will throw an exception
703 					pDrvClass = ::std::auto_ptr< java_lang_Class >(java_lang_Class::forName(_sDriverClass));
704                 }
705                 else
706                 {
707                     LocalRef< jclass > driverClass(t.env());
708                     LocalRef< jobject > driverClassLoader(t.env());
709 
710                     loadClass(
711                         m_pDriver->getContext().getUNOContext(),
712                         t.env(), _sDriverClassPath, _sDriverClass, &driverClassLoader, &driverClass );
713 
714                     m_pDriverClassLoader.set( driverClassLoader );
715                     pDrvClass.reset( new java_lang_Class( t.pEnv, driverClass.release() ) );
716 
717                     ThrowLoggedSQLException( m_aLogger, t.pEnv, *this );
718                 }
719                 if ( pDrvClass.get() )
720                 {
721                     LocalRef< jobject > driverObject( t.env() );
722                     driverObject.set( pDrvClass->newInstanceObject() );
723                     ThrowLoggedSQLException( m_aLogger, t.pEnv, *this );
724                     m_pDriverobject = driverObject.release();
725 
726                     if( t.pEnv && m_pDriverobject )
727                         m_pDriverobject = t.pEnv->NewGlobalRef( m_pDriverobject );
728 
729                     {
730                         jclass tempClass = t.pEnv->GetObjectClass(m_pDriverobject);
731                         if ( m_pDriverobject )
732                         {
733                             m_Driver_theClass = (jclass)t.pEnv->NewGlobalRef( tempClass );
734                             t.pEnv->DeleteLocalRef( tempClass );
735                         }
736                     }
737                 }
738                 m_aLogger.log( LogLevel::INFO, STR_LOG_CONN_SUCCESS );
739             }
740         }
741 	}
742     catch( const SQLException& e )
743 	{
744 		throw SQLException(
745             lcl_getDriverLoadErrorMessage( getResources(),_sDriverClass, _sDriverClassPath ),
746             *this,
747             ::rtl::OUString(),
748             1000,
749             makeAny(e)
750         );
751 	}
752 	catch( Exception& )
753 	{
754 		::dbtools::throwGenericSQLException(
755             lcl_getDriverLoadErrorMessage( getResources(),_sDriverClass, _sDriverClassPath ),
756             *this
757         );
758 	}
759 
760 	enableAutoRetrievingEnabled( bAutoRetrievingEnabled );
761 	setAutoRetrievingStatement( sGeneratedValueStatement );
762 }
763 // -----------------------------------------------------------------------------
impl_getJavaDriverClassPath_nothrow(const::rtl::OUString & _sDriverClass)764 ::rtl::OUString java_sql_Connection::impl_getJavaDriverClassPath_nothrow(const ::rtl::OUString& _sDriverClass)
765 {
766     static const ::rtl::OUString s_sNodeName(RTL_CONSTASCII_USTRINGPARAM("org.openoffice.Office.DataAccess/JDBC/DriverClassPaths"));
767     ::utl::OConfigurationTreeRoot aNamesRoot = ::utl::OConfigurationTreeRoot::createWithServiceFactory(
768         m_pDriver->getContext().getLegacyServiceFactory(), s_sNodeName, -1, ::utl::OConfigurationTreeRoot::CM_READONLY);
769     ::rtl::OUString sURL;
770     if ( aNamesRoot.isValid() && aNamesRoot.hasByName( _sDriverClass ) )
771     {
772         ::utl::OConfigurationNode aRegisterObj = aNamesRoot.openNode( _sDriverClass );
773         OSL_VERIFY( aRegisterObj.getNodeValue( "Path" ) >>= sURL );
774     }
775     return sURL;
776 }
777 // -----------------------------------------------------------------------------
construct(const::rtl::OUString & url,const Sequence<PropertyValue> & info)778 sal_Bool java_sql_Connection::construct(const ::rtl::OUString& url,
779 									const Sequence< PropertyValue >& info)
780 {
781 	{ // initialize the java vm
782 		::rtl::Reference< jvmaccess::VirtualMachine > xTest = java_lang_Object::getVM(getORB());
783 		if ( !xTest.is() )
784             throwGenericSQLException(STR_NO_JAVA,*this);
785 	}
786 	SDBThreadAttach t;
787 	t.addRef();		 // will be released in dtor
788 	if ( !t.pEnv )
789 		throwGenericSQLException(STR_NO_JAVA,*this);
790 
791 	::rtl::OUString		sGeneratedValueStatement; // contains the statement which should be used when query for automatically generated values
792 	sal_Bool			bAutoRetrievingEnabled = sal_False; // set to <TRUE/> when we should allow to query for generated values
793     ::rtl::OUString sDriverClassPath,sDriverClass;
794     Sequence< NamedValue > aSystemProperties;
795 
796     ::comphelper::NamedValueCollection aSettings( info );
797     sDriverClass = aSettings.getOrDefault( "JavaDriverClass", sDriverClass );
798     sDriverClassPath = aSettings.getOrDefault( "JavaDriverClassPath", sDriverClassPath);
799     if ( !sDriverClassPath.getLength() )
800         sDriverClassPath = impl_getJavaDriverClassPath_nothrow(sDriverClass);
801     bAutoRetrievingEnabled = aSettings.getOrDefault( "IsAutoRetrievingEnabled", bAutoRetrievingEnabled );
802     sGeneratedValueStatement = aSettings.getOrDefault( "AutoRetrievingStatement", sGeneratedValueStatement );
803     m_bParameterSubstitution = aSettings.getOrDefault( "ParameterNameSubstitution", m_bParameterSubstitution );
804     m_bIgnoreDriverPrivileges = aSettings.getOrDefault( "IgnoreDriverPrivileges", m_bIgnoreDriverPrivileges );
805     m_bIgnoreCurrency = aSettings.getOrDefault( "IgnoreCurrency", m_bIgnoreCurrency );
806     aSystemProperties = aSettings.getOrDefault( "SystemProperties", aSystemProperties );
807     m_aCatalogRestriction = aSettings.getOrDefault( "ImplicitCatalogRestriction", Any() );
808     m_aSchemaRestriction = aSettings.getOrDefault( "ImplicitSchemaRestriction", Any() );
809 
810     loadDriverFromProperties( sDriverClass, sDriverClassPath, aSystemProperties );
811 
812 	enableAutoRetrievingEnabled(bAutoRetrievingEnabled);
813 	setAutoRetrievingStatement(sGeneratedValueStatement);
814 
815 	if ( t.pEnv && m_Driver_theClass && m_pDriverobject )
816 	{
817 		// temporaere Variable initialisieren
818 		static const char * cSignature = "(Ljava/lang/String;Ljava/util/Properties;)Ljava/sql/Connection;";
819 		static const char * cMethodName = "connect";
820 		// Java-Call absetzen
821 		jmethodID mID = NULL;
822         if ( !mID  )
823             mID  = t.pEnv->GetMethodID( m_Driver_theClass, cMethodName, cSignature );
824         if ( mID )
825 		{
826 			jvalue args[2];
827 			// Parameter konvertieren
828 			args[0].l = convertwchar_tToJavaString(t.pEnv,url);
829 			java_util_Properties* pProps = createStringPropertyArray(info);
830 			args[1].l = pProps->getJavaObject();
831 
832             LocalRef< jobject > ensureDelete( t.env(), args[0].l );
833 
834             jobject out = NULL;
835             // In some cases (e.g.,
836             // connectivity/source/drivers/hsqldb/HDriver.cxx:1.24
837             // l. 249) the JavaDriverClassPath contains multiple jars,
838             // as creating the JavaDriverClass instance requires
839             // (reflective) access to those other jars.  Now, if the
840             // JavaDriverClass is actually loaded by some parent class
841             // loader (e.g., because its jar is also on the global
842             // class path), it would still not have access to the
843             // additional jars on the JavaDriverClassPath.  Hence, the
844             // JavaDriverClassPath class loader is pushed as context
845             // class loader around the JavaDriverClass instance
846             // creation:
847             // #i82222# / 2007-10-15
848             {
849                 ContextClassLoaderScope ccl( t.env(), getDriverClassLoader(), getLogger(), *this );
850                 out = t.pEnv->CallObjectMethod( m_pDriverobject, mID, args[0].l,args[1].l );
851                 delete pProps, pProps = NULL;
852                 ThrowLoggedSQLException( m_aLogger, t.pEnv, *this );
853             }
854 
855             if ( !out )
856                 m_aLogger.log( LogLevel::SEVERE, STR_LOG_NO_SYSTEM_CONNECTION );
857 
858 			if ( out )
859 				object = t.pEnv->NewGlobalRef( out );
860 
861             if ( object )
862                 m_aLogger.log( LogLevel::INFO, STR_LOG_GOT_JDBC_CONNECTION, url );
863 
864             m_aConnectionInfo = info;
865 		} //mID
866 	} //t.pEnv
867 	 return object != NULL;
868 }
869 // -----------------------------------------------------------------------------
870