debian/0000755000000000000000000000000013426010257007166 5ustar debian/changelog0000644000000000000000000001105413426010257011041 0ustar c3p0 (0.9.1.2-9+deb8u1build0.14.04.1) trusty-security; urgency=medium * fake sync from Debian -- Mike Salvatore Mon, 04 Feb 2019 05:15:11 -0500 c3p0 (0.9.1.2-9+deb8u1) jessie-security; urgency=high * Team upload. * Fix CVE-2018-20433. A XML External Entity (XXE) vulnerability was discovered in c3p0 that may be used to resolve information outside of the intended sphere of control. (Closes: #917257) -- Markus Koschany Fri, 28 Dec 2018 18:41:05 +0100 c3p0 (0.9.1.2-9) unstable; urgency=medium * Team upload. * debian/ant.properties: Disable optional Junit tests. (Closes: #725456) * Update watch file to detect the latest upstream release. Thanks to Bart Martens. * Declare compliance with Debian Policy 3.9.5. * Bump compat level to 9 and require debhelper >= 9. -- Markus Koschany Thu, 16 Jan 2014 11:36:02 +0100 c3p0 (0.9.1.2-8) unstable; urgency=low * debian/control: - Removed the unnecessary dependency on libmx4j-java - Only suggest liblog4j1.2-java since the dependency is optional - Updated Standards-Version to 3.9.4 (no changes) - Use canonical URLs for the Vcs-* fields * debian/rules: - Improved the clean target - Install the upstream changelog * Updated the watch file to catch only the final releases * debian/copyright: Converted to the Copyright Format 1.0 -- Emmanuel Bourg Sun, 28 Jul 2013 22:58:49 +0200 c3p0 (0.9.1.2-7) unstable; urgency=low * Team upload. * Build-Depends on default-jdk (openjdk) instead of gcj-jdk. - Fix FTBFS with new JDBC 4 and 4.1 API (d/patches/java-7-compat.patch). - Test suite pass with openjdk (Closes: #669556). -- Damien Raude-Morvan Mon, 09 Jul 2012 03:06:34 +0200 c3p0 (0.9.1.2-6) unstable; urgency=low * Team upload. * Remove Michael Koch from Uploaders. (Closes: #653999) * Apply patch to enable test suite and tune gcj javac output. - Thank you to James Page. (Closes: #615863) * Bump Standards-Version to 3.9.3 (no changes). * Drop needless dependency on JRE. -- tony mancill Sat, 21 Apr 2012 21:28:15 -0700 c3p0 (0.9.1.2-5) unstable; urgency=low * Install POM file. -- Torsten Werner Fri, 21 May 2010 22:56:13 +0200 c3p0 (0.9.1.2-4) unstable; urgency=low * Team upload [ Thierry Carrez ] * Depend on java2-runtime-headless instead of java2-runtime [ Torsten Werner ] * Remove Arnaud from uploaders list. * Update Standards-Version: 3.8.4. -- Torsten Werner Mon, 03 May 2010 19:32:21 +0200 c3p0 (0.9.1.2-3) unstable; urgency=low * Build-Depend on gcj-jdk (Closes: #539177). (Taken from Ubuntu) * Let libc3p0-java depend on default-jre-headless instead of default-jre. (Taken from Ubuntu) * Updated Standards-Version to 3.8.3. -- Michael Koch Sun, 06 Sep 2009 22:21:29 +0200 c3p0 (0.9.1.2-2) unstable; urgency=low [ Michael Koch ] * Use uscan sf.net helper for SourceForge. Fixes upstream checking. * Updated Standards-Version to 3.7.3. * Added Homepage field. [ Varun Hiremath ] * Convert to default-jdk/jre (Closes: #526273) * Bump Standards-Version to 3.8.1 * Fix Vcs-* fileds -- Varun Hiremath Thu, 07 May 2009 19:04:58 -0400 c3p0 (0.9.1.2-1) unstable; urgency=low * New upstream release * Add debian/orig-tar.sh * debian/rules: implement get-orig-source * move debian/README.Debian to debian/REAMDE.Debian-source and update the file. * debian/control: + Add Homepage and Build-Depend on debhelper (>= 5) + Add XS-Vcs-{Svn, Browser} headers. + Add myself to Uploaders. * debian/compat: Bump compat to 5 * Remove debian/libc3p0-java.* files and install and link jars in debian/rules using DEB_UPSTREAM VERSION. * Fix the package version, dfsg not required as the changes have been documented in debian/README.Debian-source. * Add debian/orig-tar.exclude and remove pre-built docs from orig.tar.gz -- Varun Hiremath Sun, 16 Sep 2007 13:35:34 +0530 c3p0 (0.9.1.1.dfsg.1-2) unstable; urgency=low * Upload to unstable. * Clean out correctly. * Moved debhelper and cdbs from Build-Depends-Indep to Build-Depends. * Fixed address of FSF in debian/copyright. * Added myself to Uploaders. -- Michael Koch Tue, 10 Jul 2007 23:27:20 +0200 c3p0 (0.9.1.1.dfsg.1-1) experimental; urgency=low * Initial Release (closes: #386100). -- Arnaud Vandyck Tue, 3 Apr 2007 15:06:17 +0200 debian/compat0000644000000000000000000000000213411460061010360 0ustar 9 debian/rules0000755000000000000000000000112213411460061010236 0ustar #!/usr/bin/make -f # debian/rules file for c3p0 (uses cdbs) include /usr/share/cdbs/1/rules/debhelper.mk include /usr/share/cdbs/1/class/ant.mk JAVA_HOME := /usr/lib/jvm/default-java DEB_JARS := log4j1.2 junit ant-junit hsql DEB_ANT_BUILD_TARGET := jar javadocs junit-tests DEB_INSTALL_CHANGELOGS_ALL := src/dist-static/CHANGELOG clean:: mh_clean ( cd relproj ; ant clean ) install/libc3p0-java:: mh_installpom -plibc3p0-java debian/pom.xml mh_installjar -plibc3p0-java debian/pom.xml -l build/c3p0*.jar get-orig-source: -uscan --upstream-version 0 --rename debian/patches/0000755000000000000000000000000013411460061010611 5ustar debian/patches/CVE-2018-20433.patch0000644000000000000000000000176413411460061013320 0ustar From: Markus Koschany Date: Tue, 25 Dec 2018 15:14:04 +0100 Subject: CVE-2018-20433 Bug-Debian: https://bugs.debian.org/917257 Origin: https://github.com/zhutougg/c3p0/commit/2eb0ea97f745740b18dd45e4a909112d4685f87b --- src/classes/com/mchange/v2/c3p0/cfg/C3P0ConfigXmlUtils.java | 1 + 1 file changed, 1 insertion(+) diff --git a/src/classes/com/mchange/v2/c3p0/cfg/C3P0ConfigXmlUtils.java b/src/classes/com/mchange/v2/c3p0/cfg/C3P0ConfigXmlUtils.java index 3878e89..4a75bd8 100644 --- a/src/classes/com/mchange/v2/c3p0/cfg/C3P0ConfigXmlUtils.java +++ b/src/classes/com/mchange/v2/c3p0/cfg/C3P0ConfigXmlUtils.java @@ -132,6 +132,7 @@ public final class C3P0ConfigXmlUtils public static C3P0Config extractXmlConfigFromInputStream(InputStream is) throws Exception { DocumentBuilderFactory fact = DocumentBuilderFactory.newInstance(); + fact.setExpandEntityReferences(false); DocumentBuilder db = fact.newDocumentBuilder(); Document doc = db.parse( is ); debian/patches/series0000644000000000000000000000010313411460061012020 0ustar build.patch testing.patch java-7-compat.patch CVE-2018-20433.patch debian/patches/java-7-compat.patch0000644000000000000000000010331013411460061014176 0ustar Description: Patch to enable testing in build process using hsqldb & gcj Functions that are either not supported by hsqldb and tests that behave differently under gcj are disabled. Author: james.page@canonical.com Forwarded: not-required --- a/src/classes/com/mchange/v2/c3p0/DriverManagerDataSource.java +++ b/src/classes/com/mchange/v2/c3p0/DriverManagerDataSource.java @@ -251,4 +251,22 @@ throw new IOException("Unsupported Serialized Version: " + version); } } + + // JDBC 4.1 + + public java.util.logging.Logger getParentLogger() throws java.sql.SQLFeatureNotSupportedException { + return null; + } + + public boolean isWrapperFor(Class c) throws SQLException { + return c.isInstance(this); + } + + public Object unwrap(Class c) throws SQLException { + if (c.isInstance(this)) { + return this; + } + // should people be calling unwrap when isWrapperFor would return false + return null; + } } --- a/src/classes/com/mchange/v2/c3p0/JndiRefConnectionPoolDataSource.java +++ b/src/classes/com/mchange/v2/c3p0/JndiRefConnectionPoolDataSource.java @@ -307,5 +307,11 @@ sb.append("]"); return sb.toString(); } + + // JDBC 4.1 + + public java.util.logging.Logger getParentLogger() throws java.sql.SQLFeatureNotSupportedException { + return wcpds.getParentLogger(); + } } --- a/src/classes/com/mchange/v2/c3p0/JndiRefForwardingDataSource.java +++ b/src/classes/com/mchange/v2/c3p0/JndiRefForwardingDataSource.java @@ -165,5 +165,23 @@ throw new IOException("Unsupported Serialized Version: " + version); } } + + // JDBC 4.1 + + public java.util.logging.Logger getParentLogger() throws java.sql.SQLFeatureNotSupportedException { + return null; + } + + public boolean isWrapperFor(Class c) throws SQLException { + return c.isInstance(this); + } + + public Object unwrap(Class c) throws SQLException { + if (c.isInstance(this)) { + return this; + } + // should people be calling unwrap when isWrapperFor would return false + return null; + } } --- a/src/classes/com/mchange/v2/c3p0/WrapperConnectionPoolDataSource.java +++ b/src/classes/com/mchange/v2/c3p0/WrapperConnectionPoolDataSource.java @@ -31,6 +31,7 @@ import java.lang.reflect.Method; import java.util.Map; import java.sql.*; + import javax.sql.*; import com.mchange.v2.c3p0.cfg.C3P0Config; import com.mchange.v2.c3p0.impl.*; @@ -283,4 +284,22 @@ else this.connectionTester = C3P0ImplUtils.defaultConnectionTester(); } + + // JDBC 4.1 + + public java.util.logging.Logger getParentLogger() throws java.sql.SQLFeatureNotSupportedException { + return null; + } + + public boolean isWrapperFor(Class c) throws SQLException { + return c.isInstance(this); + } + + public Object unwrap(Class c) throws SQLException { + if (c.isInstance(this)) { + return this; + } + // should people be calling unwrap when isWrapperFor would return false + return null; + } } --- a/src/classes/com/mchange/v2/c3p0/codegen/JdbcProxyGenerator.java +++ b/src/classes/com/mchange/v2/c3p0/codegen/JdbcProxyGenerator.java @@ -831,7 +831,7 @@ } // end-premature-detach-debug-only! - iw.println( "throw SqlUtils.toSQLException(\042You can't operate on a closed " + getInnerTypeName() + "!!!\042, exc);"); + iw.println( "throw new IllegalStateException(\042You can't operate on a closed " + getInnerTypeName() + "!!!\042, exc);"); } iw.downIndent(); iw.println("}"); @@ -845,10 +845,10 @@ iw.println("{"); iw.upIndent(); //iw.println( "exc.printStackTrace();" ); - iw.println( "throw parentPooledConnection.handleThrowable( exc );" ); + iw.println( "throw new RuntimeException( exc );" ); iw.downIndent(); iw.println("}"); - iw.println("else throw SqlUtils.toSQLException( exc );"); + iw.println("else throw new RuntimeException( exc );"); iw.downIndent(); iw.println("}"); } --- a/src/classes/com/mchange/v2/c3p0/impl/AbstractPoolBackedDataSource.java +++ b/src/classes/com/mchange/v2/c3p0/impl/AbstractPoolBackedDataSource.java @@ -496,5 +496,23 @@ throw new IOException("Unsupported Serialized Version: " + version); } } + + // JDBC 4.1 + + public java.util.logging.Logger getParentLogger() throws java.sql.SQLFeatureNotSupportedException { + return null; + } + + public boolean isWrapperFor(Class c) throws SQLException { + return c.isInstance(this); + } + + public Object unwrap(Class c) throws SQLException { + if (c.isInstance(this)) { + return this; + } + // should people be calling unwrap when isWrapperFor would return false + return null; + } } --- a/src/classes/com/mchange/v2/c3p0/impl/C3P0PooledConnection.java +++ b/src/classes/com/mchange/v2/c3p0/impl/C3P0PooledConnection.java @@ -23,10 +23,14 @@ package com.mchange.v2.c3p0.impl; +import java.io.InputStream; +import java.io.Reader; import java.lang.reflect.*; import java.sql.*; import java.util.*; + import javax.sql.*; + import com.mchange.v2.log.*; import com.mchange.v2.sql.*; import com.mchange.v2.sql.filter.*; @@ -646,6 +650,7 @@ public void close() throws SQLException { wsh.doClose(); } + } return new ProxyCallableStatement((CallableStatement) innerStmt ); @@ -1169,6 +1174,14 @@ logger.log(MLevel.WARNING, "Broken Connection Close Error. ", e); } } + + // JDBC 4.1 + + public void addStatementEventListener(StatementEventListener arg0) { + } + + public void removeStatementEventListener(StatementEventListener arg0) { + } } --- a/src/classes/com/mchange/v2/c3p0/impl/NewPooledConnection.java +++ b/src/classes/com/mchange/v2/c3p0/impl/NewPooledConnection.java @@ -737,4 +737,12 @@ } } } + + // JDBC 4.1 + + public void addStatementEventListener(StatementEventListener arg0) { + } + + public void removeStatementEventListener(StatementEventListener arg0) { + } } --- a/src/classes/com/mchange/v2/c3p0/test/FreezableDriverManagerDataSource.java +++ b/src/classes/com/mchange/v2/c3p0/test/FreezableDriverManagerDataSource.java @@ -280,4 +280,22 @@ throw new IOException("Unsupported Serialized Version: " + version); } } + + // JDBC 4.1 + + public java.util.logging.Logger getParentLogger() throws java.sql.SQLFeatureNotSupportedException { + return null; + } + + public boolean isWrapperFor(Class c) throws SQLException { + return c.isInstance(this); + } + + public Object unwrap(Class c) throws SQLException { + if (c.isInstance(this)) { + return this; + } + // should people be calling unwrap when isWrapperFor would return false + return null; + } } --- a/src/classes/com/mchange/v2/sql/filter/FilterCallableStatement.java +++ b/src/classes/com/mchange/v2/sql/filter/FilterCallableStatement.java @@ -35,12 +35,15 @@ import java.sql.Clob; import java.sql.Connection; import java.sql.Date; +import java.sql.NClob; import java.sql.ParameterMetaData; import java.sql.Ref; import java.sql.ResultSet; import java.sql.ResultSetMetaData; +import java.sql.RowId; import java.sql.SQLException; import java.sql.SQLWarning; +import java.sql.SQLXML; import java.sql.Time; import java.sql.Timestamp; import java.util.Calendar; @@ -520,4 +523,297 @@ public void cancel() throws SQLException { inner.cancel(); } + + // JDCB 4.0 + + public boolean isClosed() throws SQLException { + return inner.isClosed(); + } + + public boolean isPoolable() throws SQLException { + return inner.isPoolable(); + } + + public void setPoolable(boolean poolable) throws SQLException { + inner.setPoolable(poolable); + } + + public boolean isWrapperFor(Class c) throws SQLException { + return c.isInstance(this); + } + + public Object unwrap(Class c) throws SQLException { + if (c.isInstance(this)) { + return this; + } + // should people be calling unwrap when isWrapperFor would return false + return null; + } + + public void setAsciiStream(int parameterIndex, InputStream x) + throws SQLException { + inner.setAsciiStream(parameterIndex, x); + } + + public void setAsciiStream(int parameterIndex, InputStream x, + long length) throws SQLException { + inner.setAsciiStream(parameterIndex, x, length); + } + + public void setBinaryStream(int parameterIndex, InputStream x) + throws SQLException { + inner.setBinaryStream(parameterIndex, x); + } + + public void setBinaryStream(int parameterIndex, InputStream x, + long length) throws SQLException { + inner.setBinaryStream(parameterIndex, x, length); + } + + public void setBlob(int parameterIndex, InputStream inputStream) + throws SQLException { + inner.setBlob(parameterIndex, inputStream); + } + + public void setBlob(int parameterIndex, InputStream inputStream, + long length) throws SQLException { + inner.setBlob(parameterIndex, inputStream, length); + } + + public void setCharacterStream(int parameterIndex, Reader reader) + throws SQLException { + inner.setCharacterStream(parameterIndex, reader); + } + + public void setCharacterStream(int parameterIndex, Reader reader, + long length) throws SQLException { + inner.setCharacterStream(parameterIndex, reader, length); + } + + public void setClob(int parameterIndex, Reader reader) + throws SQLException { + inner.setClob(parameterIndex, reader); + } + + public void setClob(int parameterIndex, Reader reader, long length) + throws SQLException { + inner.setClob(parameterIndex, reader, length); + } + + public void setNCharacterStream(int parameterIndex, Reader value) + throws SQLException { + inner.setNCharacterStream(parameterIndex, value); + } + + public void setNCharacterStream(int parameterIndex, Reader value, + long length) throws SQLException { + inner.setNCharacterStream(parameterIndex, value, length); + } + + public void setNClob(int parameterIndex, NClob value) + throws SQLException { + inner.setNClob(parameterIndex, value); + } + + public void setNClob(int parameterIndex, Reader reader) + throws SQLException { + inner.setNClob(parameterIndex, reader); + } + + public void setNClob(int parameterIndex, Reader reader, long length) + throws SQLException { + inner.setNClob(parameterIndex, reader, length); + } + + public void setNString(int parameterIndex, String value) + throws SQLException { + inner.setNString(parameterIndex, value); + } + + public void setRowId(int parameterIndex, RowId x) + throws SQLException { + inner.setRowId(parameterIndex, x); + } + + public void setSQLXML(int parameterIndex, SQLXML xmlObject) + throws SQLException { + inner.setSQLXML(parameterIndex, xmlObject); + } + + + public Reader getCharacterStream(int parameterIndex) + throws SQLException { + return inner.getCharacterStream(parameterIndex); + } + + public Reader getCharacterStream(String parameterName) + throws SQLException { + return inner.getCharacterStream(parameterName); + } + + public Reader getNCharacterStream(int parameterIndex) + throws SQLException { + return inner.getNCharacterStream(parameterIndex); + } + + public Reader getNCharacterStream(String parameterName) + throws SQLException { + return inner.getNCharacterStream(parameterName); + } + + public NClob getNClob(int parameterIndex) throws SQLException { + return inner.getNClob(parameterIndex); + } + + public NClob getNClob(String parameterName) throws SQLException { + return inner.getNClob(parameterName); + } + + public String getNString(int parameterIndex) throws SQLException { + return inner.getNString(parameterIndex); + } + + public String getNString(String parameterName) throws SQLException { + return inner.getNString(parameterName); + } + + public RowId getRowId(int parameterIndex) throws SQLException { + return inner.getRowId(parameterIndex); + } + + public RowId getRowId(String parameterName) throws SQLException { + return inner.getRowId(parameterName); + } + + public SQLXML getSQLXML(int parameterIndex) throws SQLException { + return inner.getSQLXML(parameterIndex); + } + + public SQLXML getSQLXML(String parameterName) throws SQLException { + return inner.getSQLXML(parameterName); + } + + public void setAsciiStream(String parameterName, InputStream x) + throws SQLException { + inner.setAsciiStream(parameterName, x); + } + + public void setAsciiStream(String parameterName, InputStream x, + long length) throws SQLException { + inner.setAsciiStream(parameterName, x, length); + } + + public void setBinaryStream(String parameterName, InputStream x) + throws SQLException { + inner.setBinaryStream(parameterName, x); + } + + public void setBinaryStream(String parameterName, InputStream x, + long length) throws SQLException { + inner.setBinaryStream(parameterName, x, length); + } + + public void setBlob(String parameterName, Blob x) + throws SQLException { + inner.setBlob(parameterName, x); + } + + public void setBlob(String parameterName, InputStream inputStream) + throws SQLException { + inner.setBlob(parameterName, inputStream); + } + + public void setBlob(String parameterName, InputStream inputStream, + long length) throws SQLException { + inner.setBlob(parameterName, inputStream, length); + } + + public void setCharacterStream(String parameterName, Reader reader) + throws SQLException { + inner.setCharacterStream(parameterName, reader); + } + + public void setCharacterStream(String parameterName, Reader reader, + long length) throws SQLException { + inner.setCharacterStream(parameterName, reader, length); + } + + public void setClob(String parameterName, Clob x) + throws SQLException { + inner.setClob(parameterName, x); + } + + public void setClob(String parameterName, Reader reader) + throws SQLException { + inner.setClob(parameterName, reader); + } + + public void setClob(String parameterName, Reader reader, long length) + throws SQLException { + inner.setClob(parameterName, reader, length); + } + + public void setNCharacterStream(String parameterName, Reader value) + throws SQLException { + inner.setNCharacterStream(parameterName, value); + } + + public void setNCharacterStream(String parameterName, Reader value, + long length) throws SQLException { + inner.setNCharacterStream(parameterName, value, length); + } + + public void setNClob(String parameterName, NClob value) + throws SQLException { + inner.setNClob(parameterName, value); + } + + public void setNClob(String parameterName, Reader reader) + throws SQLException { + inner.setNClob(parameterName, reader); + } + + public void setNClob(String parameterName, Reader reader, + long length) throws SQLException { + inner.setNClob(parameterName, reader, length); + } + + public void setNString(String parameterName, String value) + throws SQLException { + inner.setNString(parameterName, value); + } + + public void setRowId(String parameterName, RowId x) + throws SQLException { + inner.setRowId(parameterName, x); + } + + public void setSQLXML(String parameterName, SQLXML xmlObject) + throws SQLException { + inner.setSQLXML(parameterName, xmlObject); + } + + // JDBC 4.1 + + public void closeOnCompletion() throws SQLException { + //inner.closeOnCompletion(); + throw new java.sql.SQLFeatureNotSupportedException(); + } + + public boolean isCloseOnCompletion() throws SQLException { + //return inner.isCloseOnCompletion(); + throw new java.sql.SQLFeatureNotSupportedException(); + } + + public Object getObject(int parameterIndex, Class type) + throws SQLException { + //return inner.getObject(parameterIndex, type); + throw new java.sql.SQLFeatureNotSupportedException(); + } + + public Object getObject(String parameterName, Class type) + throws SQLException { + //return inner.getObject(parameterName, type); + throw new java.sql.SQLFeatureNotSupportedException(); + } } --- a/src/classes/com/mchange/v2/sql/filter/FilterConnection.java +++ b/src/classes/com/mchange/v2/sql/filter/FilterConnection.java @@ -24,15 +24,24 @@ package com.mchange.v2.sql.filter; import java.lang.String; +import java.sql.Array; +import java.sql.Blob; import java.sql.CallableStatement; +import java.sql.Clob; import java.sql.Connection; import java.sql.DatabaseMetaData; +import java.sql.NClob; import java.sql.PreparedStatement; +import java.sql.SQLClientInfoException; import java.sql.SQLException; import java.sql.SQLWarning; +import java.sql.SQLXML; import java.sql.Savepoint; import java.sql.Statement; +import java.sql.Struct; import java.util.Map; +import java.util.Properties; +import java.util.concurrent.Executor; public abstract class FilterConnection implements Connection { @@ -157,4 +166,90 @@ public boolean isClosed() throws SQLException { return inner.isClosed(); } + + // JDBC 4.0 + + public Array createArrayOf(String arg0, Object[] arg1) throws SQLException { + return inner.createArrayOf(arg0, arg1); + } + + public Blob createBlob() throws SQLException { + return inner.createBlob(); + } + + public Clob createClob() throws SQLException { + return inner.createClob(); + } + + public NClob createNClob() throws SQLException { + return inner.createNClob(); + } + + public SQLXML createSQLXML() throws SQLException { + return inner.createSQLXML(); + } + + public Struct createStruct(String arg0, Object[] arg1) throws SQLException { + return inner.createStruct(arg0, arg1); + } + + public Properties getClientInfo() throws SQLException { + return inner.getClientInfo(); + } + + public String getClientInfo(String arg0) throws SQLException { + return inner.getClientInfo(arg0); + } + + public boolean isValid(int arg0) throws SQLException { + return inner.isValid(arg0); + } + + public void setClientInfo(Properties arg0) throws SQLClientInfoException { + inner.setClientInfo(arg0); + } + + public void setClientInfo(String arg0, String arg1) + throws SQLClientInfoException { + inner.setClientInfo(arg0, arg1); + } + + public boolean isWrapperFor(Class c) throws SQLException { + return c.isInstance(this); + } + + public Object unwrap(Class c) throws SQLException { + if (c.isInstance(this)) { + return this; + } + // should people be calling unwrap when isWrapperFor would return false + return null; + } + + // JDBC 4.1 + + public void abort(Executor arg0) throws SQLException { + //inner.abort(arg0); + throw new java.sql.SQLFeatureNotSupportedException(); + } + + public int getNetworkTimeout() throws SQLException { + //return inner.getNetworkTimeout(); + throw new java.sql.SQLFeatureNotSupportedException(); + } + + public String getSchema() throws SQLException { + //return inner.getSchema(); + throw new java.sql.SQLFeatureNotSupportedException(); + } + + public void setNetworkTimeout(Executor arg0, int arg1) throws SQLException { + //inner.setNetworkTimeout(arg0, arg1); + throw new java.sql.SQLFeatureNotSupportedException(); + } + + public void setSchema(String arg0) throws SQLException { + //inner.setSchema(arg0); + throw new java.sql.SQLFeatureNotSupportedException(); + } } --- a/src/classes/com/mchange/v2/sql/filter/FilterDatabaseMetaData.java +++ b/src/classes/com/mchange/v2/sql/filter/FilterDatabaseMetaData.java @@ -27,6 +27,7 @@ import java.sql.Connection; import java.sql.DatabaseMetaData; import java.sql.ResultSet; +import java.sql.RowIdLifetime; import java.sql.SQLException; public abstract class FilterDatabaseMetaData implements DatabaseMetaData @@ -539,4 +540,61 @@ public String getUserName() throws SQLException { return inner.getUserName(); } + + // JDBC 4.0 + + public boolean isWrapperFor(Class c) throws SQLException { + return c.isInstance(this); + } + + public Object unwrap(Class c) throws SQLException { + if (c.isInstance(this)) { + return this; + } + // should people be calling unwrap when isWrapperFor would return false + return null; + } + + public boolean autoCommitFailureClosesAllResultSets() throws SQLException { + return inner.autoCommitFailureClosesAllResultSets(); + } + + public ResultSet getClientInfoProperties() throws SQLException { + return inner.getClientInfoProperties(); + } + + public ResultSet getFunctionColumns(String arg0, String arg1, String arg2, + String arg3) throws SQLException { + return inner.getFunctionColumns(arg0, arg1, arg2, arg3); + } + + public ResultSet getFunctions(String arg0, String arg1, String arg2) + throws SQLException { + return inner.getFunctions(arg0, arg1, arg2); + } + + public RowIdLifetime getRowIdLifetime() throws SQLException { + return inner.getRowIdLifetime(); + } + + public ResultSet getSchemas(String arg0, String arg1) throws SQLException { + return inner.getSchemas(arg0, arg1); + } + + public boolean supportsStoredFunctionsUsingCallSyntax() throws SQLException { + return inner.supportsStoredFunctionsUsingCallSyntax(); + } + + // JDBC 4.1 + + public boolean generatedKeyAlwaysReturned() throws SQLException { + //return inner.generatedKeyAlwaysReturned(); + throw new java.sql.SQLFeatureNotSupportedException(); + } + + public ResultSet getPseudoColumns(String arg0, String arg1, String arg2, + String arg3) throws SQLException { + //return inner.getPseudoColumns(arg0, arg1, arg2, arg3); + throw new java.sql.SQLFeatureNotSupportedException(); + } } --- a/src/classes/com/mchange/v2/sql/filter/FilterPreparedStatement.java +++ b/src/classes/com/mchange/v2/sql/filter/FilterPreparedStatement.java @@ -34,16 +34,20 @@ import java.sql.Clob; import java.sql.Connection; import java.sql.Date; +import java.sql.NClob; import java.sql.ParameterMetaData; import java.sql.PreparedStatement; import java.sql.Ref; import java.sql.ResultSet; import java.sql.ResultSetMetaData; +import java.sql.RowId; import java.sql.SQLException; import java.sql.SQLWarning; +import java.sql.SQLXML; import java.sql.Time; import java.sql.Timestamp; import java.util.Calendar; +import java.util.Map; public abstract class FilterPreparedStatement implements PreparedStatement { @@ -282,4 +286,133 @@ public void cancel() throws SQLException { inner.cancel(); } + + // JDBC 4.0 + + public boolean isClosed() throws SQLException { + return inner.isClosed(); + } + + public boolean isPoolable() throws SQLException { + return inner.isPoolable(); + } + + public void setPoolable(boolean poolable) throws SQLException { + inner.setPoolable(poolable); + } + + public boolean isWrapperFor(Class c) throws SQLException { + return c.isInstance(this); + } + + public Object unwrap(Class c) throws SQLException { + if (c.isInstance(this)) { + return this; + } + // should people be calling unwrap when isWrapperFor would return false + return null; + } + + public void setAsciiStream(int parameterIndex, InputStream x) + throws SQLException { + inner.setAsciiStream(parameterIndex, x); + } + + public void setAsciiStream(int parameterIndex, InputStream x, + long length) throws SQLException { + inner.setAsciiStream(parameterIndex, x, length); + } + + public void setBinaryStream(int parameterIndex, InputStream x) + throws SQLException { + inner.setBinaryStream(parameterIndex, x); + } + + public void setBinaryStream(int parameterIndex, InputStream x, + long length) throws SQLException { + inner.setBinaryStream(parameterIndex, x, length); + } + + public void setBlob(int parameterIndex, InputStream inputStream) + throws SQLException { + inner.setBlob(parameterIndex, inputStream); + } + + public void setBlob(int parameterIndex, InputStream inputStream, + long length) throws SQLException { + inner.setBlob(parameterIndex, inputStream, length); + } + + public void setCharacterStream(int parameterIndex, Reader reader) + throws SQLException { + inner.setCharacterStream(parameterIndex, reader); + } + + public void setCharacterStream(int parameterIndex, Reader reader, + long length) throws SQLException { + inner.setCharacterStream(parameterIndex, reader, length); + } + + public void setClob(int parameterIndex, Reader reader) + throws SQLException { + inner.setClob(parameterIndex, reader); + } + + public void setClob(int parameterIndex, Reader reader, long length) + throws SQLException { + inner.setClob(parameterIndex, reader, length); + } + + public void setNCharacterStream(int parameterIndex, Reader value) + throws SQLException { + inner.setNCharacterStream(parameterIndex, value); + } + + public void setNCharacterStream(int parameterIndex, Reader value, + long length) throws SQLException { + inner.setNCharacterStream(parameterIndex, value, length); + } + + public void setNClob(int parameterIndex, NClob value) + throws SQLException { + inner.setNClob(parameterIndex, value); + } + + public void setNClob(int parameterIndex, Reader reader) + throws SQLException { + inner.setNClob(parameterIndex, reader); + } + + public void setNClob(int parameterIndex, Reader reader, long length) + throws SQLException { + inner.setNClob(parameterIndex, reader, length); + } + + public void setNString(int parameterIndex, String value) + throws SQLException { + inner.setNString(parameterIndex, value); + } + + public void setRowId(int parameterIndex, RowId x) + throws SQLException { + inner.setRowId(parameterIndex, x); + } + + public void setSQLXML(int parameterIndex, SQLXML xmlObject) + throws SQLException { + inner.setSQLXML(parameterIndex, xmlObject); + } + + // JDBC 4.1 + + public void closeOnCompletion() throws SQLException { + //inner.closeOnCompletion(); + throw new java.sql.SQLFeatureNotSupportedException(); + } + + public boolean isCloseOnCompletion() throws SQLException { + //return inner.isCloseOnCompletion(); + throw new java.sql.SQLFeatureNotSupportedException(); + } + } --- a/src/classes/com/mchange/v2/sql/filter/FilterResultSet.java +++ b/src/classes/com/mchange/v2/sql/filter/FilterResultSet.java @@ -33,11 +33,14 @@ import java.sql.Blob; import java.sql.Clob; import java.sql.Date; +import java.sql.NClob; import java.sql.Ref; import java.sql.ResultSet; import java.sql.ResultSetMetaData; +import java.sql.RowId; import java.sql.SQLException; import java.sql.SQLWarning; +import java.sql.SQLXML; import java.sql.Statement; import java.sql.Time; import java.sql.Timestamp; @@ -476,4 +479,239 @@ public int getRow() throws SQLException { return inner.getRow(); } + + + // JDBC 4.0 + + public int getHoldability() throws SQLException { + return inner.getHoldability(); + } + + public Reader getNCharacterStream(int arg0) throws SQLException { + return inner.getNCharacterStream(arg0); + } + + public Reader getNCharacterStream(String arg0) throws SQLException { + return inner.getNCharacterStream(arg0); + } + + public NClob getNClob(int arg0) throws SQLException { + return inner.getNClob(arg0); + } + + public NClob getNClob(String arg0) throws SQLException { + return inner.getNClob(arg0); + } + + public String getNString(int arg0) throws SQLException { + return inner.getNString(arg0); + } + + public String getNString(String arg0) throws SQLException { + return inner.getNString(arg0); + } + + public RowId getRowId(int arg0) throws SQLException { + return inner.getRowId(arg0); + } + + public RowId getRowId(String arg0) throws SQLException { + return inner.getRowId(arg0); + } + + public SQLXML getSQLXML(int arg0) throws SQLException { + return inner.getSQLXML(arg0); + } + + public SQLXML getSQLXML(String arg0) throws SQLException { + return inner.getSQLXML(arg0); + } + + public boolean isClosed() throws SQLException { + return inner.isClosed(); + } + + public void updateAsciiStream(int arg0, InputStream arg1) throws SQLException { + inner.updateAsciiStream(arg0, arg1); + } + + public void updateAsciiStream(String arg0, InputStream arg1) + throws SQLException { + inner.updateAsciiStream(arg0, arg1); + } + + public void updateAsciiStream(int arg0, InputStream arg1, long arg2) + throws SQLException { + inner.updateAsciiStream(arg0, arg1, arg2); + } + + public void updateAsciiStream(String arg0, InputStream arg1, long arg2) + throws SQLException { + inner.updateAsciiStream(arg0, arg1, arg2); + } + + public void updateBinaryStream(int arg0, InputStream arg1) throws SQLException { + inner.updateBinaryStream(arg0, arg1); + } + + public void updateBinaryStream(String arg0, InputStream arg1) + throws SQLException { + inner.updateBinaryStream(arg0, arg1); + } + + public void updateBinaryStream(int arg0, InputStream arg1, long arg2) + throws SQLException { + inner.updateBinaryStream(arg0, arg1, arg2); + } + + public void updateBinaryStream(String arg0, InputStream arg1, long arg2) + throws SQLException { + inner.updateBinaryStream(arg0, arg1, arg2); + } + + public void updateBlob(int arg0, InputStream arg1) throws SQLException { + inner.updateBlob(arg0, arg1); + } + + public void updateBlob(String arg0, InputStream arg1) throws SQLException { + inner.updateBlob(arg0, arg1); + } + + public void updateBlob(int arg0, InputStream arg1, long arg2) + throws SQLException { + inner.updateBlob(arg0, arg1, arg2); + } + + public void updateBlob(String arg0, InputStream arg1, long arg2) + throws SQLException { + inner.updateBlob(arg0, arg1, arg2); + } + + public void updateCharacterStream(int arg0, Reader arg1) throws SQLException { + inner.updateCharacterStream(arg0, arg1); + } + + public void updateCharacterStream(String arg0, Reader arg1) throws SQLException { + inner.updateCharacterStream(arg0, arg1); + } + + public void updateCharacterStream(int arg0, Reader arg1, long arg2) + throws SQLException { + inner.updateCharacterStream(arg0, arg1, arg2); + } + + public void updateCharacterStream(String arg0, Reader arg1, long arg2) + throws SQLException { + inner.updateCharacterStream(arg0, arg1, arg2); + } + + public void updateClob(int arg0, Reader arg1) throws SQLException { + inner.updateClob(arg0, arg1); + } + + public void updateClob(String arg0, Reader arg1) throws SQLException { + inner.updateClob(arg0, arg1); + } + + public void updateClob(int arg0, Reader arg1, long arg2) + throws SQLException { + inner.updateClob(arg0, arg1, arg2); + } + + public void updateClob(String arg0, Reader arg1, long arg2) + throws SQLException { + inner.updateClob(arg0, arg1, arg2); + } + + public void updateNCharacterStream(int arg0, Reader arg1) throws SQLException { + inner.updateNCharacterStream(arg0, arg1); + } + + public void updateNCharacterStream(String arg0, Reader arg1) + throws SQLException { + inner.updateNCharacterStream(arg0, arg1); + } + + public void updateNCharacterStream(int arg0, Reader arg1, long arg2) + throws SQLException { + inner.updateNCharacterStream(arg0, arg1, arg2); + } + + public void updateNCharacterStream(String arg0, Reader arg1, long arg2) + throws SQLException { + inner.updateNCharacterStream(arg0, arg1, arg2); + } + + public void updateNClob(int arg0, NClob arg1) throws SQLException { + inner.updateNClob(arg0, arg1); + } + + public void updateNClob(String arg0, NClob arg1) throws SQLException { + inner.updateNClob(arg0, arg1); + } + + public void updateNClob(int arg0, Reader arg1) throws SQLException { + inner.updateNClob(arg0, arg1); + } + + public void updateNClob(String arg0, Reader arg1) throws SQLException { + inner.updateNClob(arg0, arg1); + } + + public void updateNClob(int arg0, Reader arg1, long arg2) throws SQLException { + inner.updateNClob(arg0, arg1, arg2); + } + + public void updateNClob(String arg0, Reader arg1, long arg2) + throws SQLException { + inner.updateNClob(arg0, arg1, arg2); + } + + public void updateNString(int arg0, String arg1) throws SQLException { + inner.updateNString(arg0, arg1); + } + + public void updateNString(String arg0, String arg1) throws SQLException { + inner.updateNString(arg0, arg1); + } + + public void updateRowId(int arg0, RowId arg1) throws SQLException { + inner.updateRowId(arg0, arg1); + } + + public void updateRowId(String arg0, RowId arg1) throws SQLException { + inner.updateRowId(arg0, arg1); + } + + public void updateSQLXML(int arg0, SQLXML arg1) throws SQLException { + inner.updateSQLXML(arg0, arg1); + } + + public void updateSQLXML(String arg0, SQLXML arg1) throws SQLException { + inner.updateSQLXML(arg0, arg1); + } + + public boolean isWrapperFor(Class c) throws SQLException { + return c.isInstance(this); + } + + public Object unwrap(Class c) throws SQLException { + if (c.isInstance(this)) { + return this; + } + // should people be calling unwrap when isWrapperFor would return false + return null; + } + + // JDBC 4.1 + + public Object getObject(int arg0, Class arg1) throws SQLException { + //return inner.getObject(arg0, arg1); + throw new java.sql.SQLFeatureNotSupportedException(); + } + + public Object getObject(String arg0, Class arg1) throws SQLException { + //return inner.getObject(arg0, arg1); + throw new java.sql.SQLFeatureNotSupportedException(); + } } --- a/src/classes/com/mchange/v2/sql/filter/FilterStatement.java +++ b/src/classes/com/mchange/v2/sql/filter/FilterStatement.java @@ -23,11 +23,16 @@ package com.mchange.v2.sql.filter; +import java.io.InputStream; +import java.io.Reader; import java.lang.String; import java.sql.Connection; +import java.sql.NClob; import java.sql.ResultSet; +import java.sql.RowId; import java.sql.SQLException; import java.sql.SQLWarning; +import java.sql.SQLXML; import java.sql.Statement; public abstract class FilterStatement implements Statement @@ -156,4 +161,43 @@ public void cancel() throws SQLException { inner.cancel(); } + + // JDBC 4.0 + + + public boolean isClosed() throws SQLException { + return inner.isClosed(); + } + + public boolean isPoolable() throws SQLException { + return inner.isPoolable(); + } + + public void setPoolable(boolean poolable) throws SQLException { + inner.setPoolable(poolable); + } + + public boolean isWrapperFor(Class c) throws SQLException { + return c.isInstance(this); + } + + public Object unwrap(Class c) throws SQLException { + if (c.isInstance(this)) { + return this; + } + // should people be calling unwrap when isWrapperFor would return false + return null; + } + + // JDBC 4.1 + + public void closeOnCompletion() throws SQLException { + //inner.closeOnCompletion(); + throw new java.sql.SQLFeatureNotSupportedException(); + } + + public boolean isCloseOnCompletion() throws SQLException { + //return inner.isCloseOnCompletion(); + throw new java.sql.SQLFeatureNotSupportedException(); + } } debian/patches/build.patch0000644000000000000000000000500113411460061012725 0ustar Description: Configures build (using gcj) to behave more like sun-jdk-5 in terms of error messages. Author: james.page@canonical.com Forwarded: not-required Index: c3p0/build.xml =================================================================== --- c3p0.orig/build.xml 2011-02-25 11:52:44.775376257 +0000 +++ c3p0/build.xml 2011-02-25 12:02:54.804996643 +0000 @@ -208,7 +208,7 @@ source="${c3p0.target.version}" target="${c3p0.target.version}" classpathref="codegen-classpath" - debug="true"> + debug="true" nowarn="on" deprecation="off"> @@ -253,7 +253,7 @@ source="${c3p0.target.version}" target="${c3p0.target.version}" classpathref="build-classpath" - debug="on"> + debug="on" nowarn="on" deprecation="off"> @@ -275,7 +275,7 @@ source="${c3p0.target.version}" target="${c3p0.target.version}" classpathref="build-classpath" - debug="on"> + debug="on" nowarn="on" deprecation="off"> @@ -290,7 +290,7 @@ + debug="on" nowarn="on" deprecation="off"> @@ -311,7 +311,7 @@ + debug="on" nowarn="on" deprecation="off"> Index: c3p0/relproj/debuggen/build.xml =================================================================== --- c3p0.orig/relproj/debuggen/build.xml 2011-02-25 12:04:02.992661915 +0000 +++ c3p0/relproj/debuggen/build.xml 2011-02-25 12:04:30.047767796 +0000 @@ -32,7 +32,7 @@ + debug="on" nowarn="on" deprecation="off"/> debian/patches/testing.patch0000644000000000000000000000673313411460061013320 0ustar Description: Patch to enable testing in build process using hsqldb & gcj Functions that are either not supported by hsqldb and tests that behave differently under gcj are disabled. Author: james.page@canonical.com Forwarded: not-required Index: c3p0/src/classes/com/mchange/v2/c3p0/test/junit/ConnectionPropertiesResetJUnitTestCase.java =================================================================== --- c3p0.orig/src/classes/com/mchange/v2/c3p0/test/junit/ConnectionPropertiesResetJUnitTestCase.java 2011-02-28 11:20:48.137932772 +0000 +++ c3p0/src/classes/com/mchange/v2/c3p0/test/junit/ConnectionPropertiesResetJUnitTestCase.java 2011-02-28 11:23:12.471753607 +0000 @@ -88,10 +88,6 @@ cons[i] = cpds.getConnection(); assertFalse( "Connection from pool should not be readOnly!", cons[i].isReadOnly() ); - // some drivers return null rather than an empty type map - Map typeMap = cons[i].getTypeMap(); - assertTrue( "Connection from pool should have an empty type map!", (typeMap == null ? true : typeMap.isEmpty() ) ); - assertEquals( "Connection from pool should have default catalog set!", dfltCat, cons[i].getCatalog() ); assertEquals( "Connection from pool should have default txn isolation set!", dflt_txn_isolation, cons[i].getTransactionIsolation() ); cons[i].close(); @@ -103,4 +99,4 @@ fail( e.getMessage() ); } } -} \ No newline at end of file +} Index: c3p0/src/classes/com/mchange/v2/util/junit/DoubleWeakHashMapJUnitTestCase.java =================================================================== --- c3p0.orig/src/classes/com/mchange/v2/util/junit/DoubleWeakHashMapJUnitTestCase.java 2011-02-28 11:20:48.167927333 +0000 +++ c3p0/src/classes/com/mchange/v2/util/junit/DoubleWeakHashMapJUnitTestCase.java 2011-02-28 11:22:55.204885364 +0000 @@ -68,41 +68,4 @@ m.values().remove(poop); assertEquals("After removing a doubled value, size should be 2", m.size(), 2); } - - public void testWeakness() - { - Integer a = new Integer(1); - Integer b = new Integer(2); - Integer c = new Integer(3); - - String poop = new String("poop"); - - Map m = new DoubleWeakHashMap(); - m.put(a, poop); - m.put(b, new Object()); - m.put(c, new Object()); - - //race condition... b & c might already have been removed... but i doubt it - assertEquals("1) Weak values should not yet have been removed (but not guaranteed! sometimes fails without a defect!)", m.size(), 3); - - // we are relying that a full, synchronous GC occurs, - // which is not guaranteed in all VMs - System.gc(); - - // let's see if we can force a deeper gc via a big array creation - byte[] bArray = new byte[1024 * 1024]; - - assertEquals("2) Weak values should have been automatically removed (but not guaranteed! sometimes fails without a defect!)", m.size(), 1); - - m.put( new Object(), b); - - //race condition... b & c might already have been removed... but i doubt it - assertEquals("3) Weak key should not yet have been removed (but not guaranteed! sometimes fails without a defect!)", m.size(), 2); - - System.gc(); - // let's see if we can force a deeper gc via a big array creation - bArray = new byte[1024 * 1024]; - - assertEquals("4) Weak key should have been automatically removed (but not guaranteed! sometimes fails without a defect!)", m.size(), 1); - } } debian/control0000644000000000000000000000241413411460061010566 0ustar Source: c3p0 Section: java Priority: optional Maintainer: Debian Java Maintainers Uploaders: Varun Hiremath , Emmanuel Bourg Build-Depends: debhelper (>= 9), cdbs, maven-repo-helper, default-jdk Build-Depends-Indep: ant, liblog4j1.2-java, ant-optional, junit, libhsqldb-java Standards-Version: 3.9.5 Vcs-Svn: svn://anonscm.debian.org/pkg-java/trunk/c3p0 Vcs-Browser: http://anonscm.debian.org/viewvc/pkg-java/trunk/c3p0 Homepage: http://sourceforge.net/projects/c3p0 Package: libc3p0-java Architecture: all Depends: ${misc:Depends} Suggests: liblog4j1.2-java Description: library for JDBC connection pooling c3p0 is an easy-to-use library for making traditional JDBC drivers "enterprise-ready" by augmenting them with functionality defined by the jdbc3 spec and the optional extensions to jdbc2. Package: libc3p0-java-doc Section: doc Architecture: all Depends: ${misc:Depends} Suggests: libc3p0-java Description: library for JDBC connection pooling (documentation) c3p0 is an easy-to-use library for making traditional JDBC drivers "enterprise-ready" by augmenting them with functionality defined by the jdbc3 spec and the optional extensions to jdbc2. . This package includes the documentation. debian/source/0000755000000000000000000000000013411460061010462 5ustar debian/source/format0000644000000000000000000000001413411460061011670 0ustar 3.0 (quilt) debian/copyright0000644000000000000000000000276713411460061011131 0ustar Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/ Upstream-Name: c3p0 Upstream-Contact: Steve Waldman Source: https://sourceforge.net/projects/c3p0 Files: * Copyright: 2001-2013 Machinery For Change, Inc. License: LGPL-2.1 Files: debian/* Copyright: 2007, Arnaud Vandyck 2007-2009, Michael Koch 2007-2009, Varun Hiremath 2010, Torsten Werner 2012, tony mancill 2012, Damien Raude-Morvan 2013, Emmanuel Bourg License: LGPL-2.1 License: LGPL-2.1 This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License version 2.1, as published by the Free Software Foundation. . This software is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. . You should have received a copy of the GNU Lesser General Public License along with this software; see the file LICENSE. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. . On Debian systems the full text of the Lesser General Public License, LGPL, can be found at /usr/share/common-licenses/LGPL-2.1 debian/libc3p0-java-doc.doc-base0000644000000000000000000000051713411460061013502 0ustar Document: c3p0-doc Title: Programmer API for c3p0 (library for JDBC connection pooling) Author: Steve Waldman Abstract: This is the programmer API of c3p0, a library for JDBC connection pooling. Section: Programming Format: HTML Index: /usr/share/doc/libc3p0-java-doc/api/index.html Files: /usr/share/doc/libc3p0-java-doc/api/*.html debian/ant.properties0000644000000000000000000000467013411460061012071 0ustar # # You'll need to supply at least one of j2ee.classpath # or j2ee.jar.file.base.dir. All jar files under # ${j2ee.jar.file.base.dir} or its subdirectories # will be added to the effective classpath of the project. # #j2ee.classpath= j2ee.jar.base.dir=/usr/share/java # >> DEBUGGING AND TRACING << # Set this to true if you want logging enabled for logging levels below INFO. # If debug is not set, logging code for these messages will be eliminated from # the compiled code by virtue of "if (false) { ... }" blocks. #c3p0-build.debug= # Set trace to an integer between 0 and 10 (inclusive) to control how the level # of detail of debug logging messages. Only makes a difference if c3p0.debug is # set to true above. Default to 5 if unset. #c3p0-build.trace= # NOTE: You must still configure your logging library to log or display these # debug level messages if you actually want to see any change! #---------------------------------------------------------------------------- # >> OPTIONAL LIBRARY SUPPRT << # # You'll only need this property if you want to # build-in optional log4j support. # log4j.jar.file=/usr/share/java/log4j-1.2.jar # # You'll only need this property if you want to # build the jar of utilities specific to the # oracle-thin jdbc driver / dbms # #oracle-thin.jdbc.jar.file= #---------------------------------------------------------------------------- # >> OPTIONAL TEST SUPPORT # # this stuff is only required if you want to run # the various tests. very optional # #test.jdbc.driver.jar.file=/usr/share/java/hsqldb.jar #test.jdbc.drivers=org.hsqldb.jdbcDriver #test.jdbc.url=jdbc:hsqldb:file:/tmp/testdb #test.jdbc.user=SA #test.jdbc.password= #c3p0.jdbcUrl=jdbc:hsqldb:file:/tmp/testdb #c3p0.driverClass=org.hsqldb.jdbcDriver #c3p0.user=SA #c3p0.password= # # required if you want to run junit tests # #junit.jar.file=/usr/share/java/junit.jar # >> VERY VERY OPTIONAL DOCS-TO-WEB SUPPORT # # this stuff is only required if you want to deploy # an ear file containing c3p0's docs to a J2EE appserver. # via scp. Requires an available executable "scp". # # this is a convenience for c3p0's developer, not # really intended for other users. just leave blank # # note that virtual.host modifies a jboss-web.xml file, # will do nothing if you are deploying to some other # app server # #docwebapp.context.root= #docwebapp.virtual.host= #docwebear.deploy.user= #docwebear.deploy.host= #docwebear.deploy.path= build.apidocs.dir=build/api debian/libc3p0-java-doc.docs0000644000000000000000000000001213411460061012743 0ustar build/api debian/watch0000644000000000000000000000026713411460061010220 0ustar version=3 opts=uversionmangle=s/\.src$//;s/^(\S+\.bin)$/0.0.$1/;s/-(pre\d*)$/~$1/ \ http://qa.debian.org/watch/sf.php/c3p0/c3p0[_\-](\d\S*)\.(?:tar\.xz|txz|tar\.bz2|tbz2|tar\.gz|tgz) debian/README.Debian-source0000644000000000000000000000074313411460061012525 0ustar c3p0 ==== The upstream supplied source package contains binary jar files and pre-built documentation. Currently no clean source distribution exists. Therefore, the upstream sources were modified to comply with the Debian Free Software Guidelines. Use the rules/get-orig-source target to create the orig.tar.gz. For more details on repackaging of upstream sources please see the debian/orig-tar.sh file. -- Varun Hiremath Sun, 16 Sep 2007 01:43:56 +0530 debian/orig-tar.sh0000755000000000000000000000056313411460061011251 0ustar #!/bin/sh -e # called by uscan with '--upstream-version' DIR=c3p0-$2.orig # clean up the upstream tarball tar zxf $3 mv c3p0-$2.src $DIR GZIP=--best tar czf $3 -X debian/orig-tar.exclude $DIR rm -rf $DIR # move to directory 'tarballs' if [ -r .svn/deb-layout ]; then . .svn/deb-layout mv $3 $origDir echo "moved $3 to $origDir" fi exit 0 debian/orig-tar.exclude0000644000000000000000000000003113411460061012253 0ustar *.jar */build/* */dist/* debian/pom.xml0000644000000000000000000000147713411460061010510 0ustar 4.0.0 c3p0 c3p0 0.9.1.2 jar c3p0:JDBC DataSources/Resource Pools c3p0 is an easy-to-use library for augmenting traditional (DriverManager-based) JDBC drivers with JNDI-bindable DataSources, including DataSources that implement Connection and Statement Pooling, as described by the jdbc3 spec and jdbc2 std extension. http://c3p0.sourceforge.net http://c3p0.cvs.sourceforge.net/c3p0 GNU LESSER GENERAL PUBLIC LICENSE http://www.gnu.org/licenses/lgpl.txt