xref: /trunk/main/connectivity/source/drivers/adabas/BDriver.cxx (revision 91144cd0085a7583d2099b982122deb2184ab956) 
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_adabas.hxx"
26 #include <unotools/tempfile.hxx>
27 #include "adabas/BDriver.hxx"
28 #include "adabas/BConnection.hxx"
29 #include "odbc/OFunctions.hxx"
30 #include <com/sun/star/lang/DisposedException.hpp>
31 #include "odbc/OTools.hxx"
32 #include "connectivity/dbexception.hxx"
33 #include "TConnection.hxx"
34 #include "diagnose_ex.h"
35 #include <vos/process.hxx>
36 #include <osl/process.h>
37 #include <unotools/ucbhelper.hxx>
38 #include <unotools/ucbstreamhelper.hxx>
39 #include <unotools/localfilehelper.hxx>
40 #include "resource/adabas_res.hrc"
41 #include "resource/sharedresources.hxx"
42 
43 
44 #include <memory>
45 #include <sys/stat.h>
46 
operator <<(SvStream & s,const rtl::OString r)47 inline SvStream& operator<<( SvStream& s, const rtl::OString r) { return (s << r.getStr()); }
operator <<(SvStream & s,const rtl::OUString r)48 inline SvStream& operator<<( SvStream& s, const rtl::OUString r) { return (s << ::rtl::OUStringToOString(r,gsl_getSystemTextEncoding())); }
49 
50 #if defined(UNX)
51 const char sNewLine = '\012';
52 #else
53 const char sNewLine[] = "\015\012"; // \015\012 and not \n
54 #endif
55 #define ADABAS_DB_11            "11.02.00"
56 #define ADABAS_KERNEL_11        "11.02"
57 #define ADABAS_DB_12            "12.01.00"
58 #define ADABAS_KERNEL_12        "12.01"
59 #define CURRENT_DB_VERSION      "13.01.00"
60 #define CURRENT_KERNEL_VERSION  "13.01"
61 
62 #define OPROCESS_ADABAS     (OProcess::TOption_Hidden | OProcess::TOption_Wait | OProcess::TOption_SearchPath)
63 #define OPROCESS_ADABAS_DBG (OProcess::TOption_Wait | OProcess::TOption_SearchPath)
64 
65 
66 using namespace connectivity;
67 namespace connectivity
68 {
69     namespace adabas
70     {
71         // extern declaration of the function pointer
72     extern T3SQLAllocHandle pODBC3SQLAllocHandle;
73     extern T3SQLConnect pODBC3SQLConnect;
74     extern T3SQLDriverConnect pODBC3SQLDriverConnect;
75     extern T3SQLBrowseConnect pODBC3SQLBrowseConnect;
76     extern T3SQLDataSources pODBC3SQLDataSources;
77     extern T3SQLDrivers pODBC3SQLDrivers;
78     extern T3SQLGetInfo pODBC3SQLGetInfo;
79     extern T3SQLGetFunctions pODBC3SQLGetFunctions;
80     extern T3SQLGetTypeInfo pODBC3SQLGetTypeInfo;
81     extern T3SQLSetConnectAttr pODBC3SQLSetConnectAttr;
82     extern T3SQLGetConnectAttr pODBC3SQLGetConnectAttr;
83     extern T3SQLSetEnvAttr pODBC3SQLSetEnvAttr;
84     extern T3SQLGetEnvAttr pODBC3SQLGetEnvAttr;
85     extern T3SQLSetStmtAttr pODBC3SQLSetStmtAttr;
86     extern T3SQLGetStmtAttr pODBC3SQLGetStmtAttr;
87     //extern T3SQLSetDescField pODBC3SQLSetDescField;
88     //extern T3SQLGetDescField pODBC3SQLGetDescField;
89     //extern T3SQLGetDescRec pODBC3SQLGetDescRec;
90     //extern T3SQLSetDescRec pODBC3SQLSetDescRec;
91     extern T3SQLPrepare pODBC3SQLPrepare;
92     extern T3SQLBindParameter pODBC3SQLBindParameter;
93     //extern T3SQLGetCursorName pODBC3SQLGetCursorName;
94     extern T3SQLSetCursorName pODBC3SQLSetCursorName;
95     extern T3SQLExecute pODBC3SQLExecute;
96     extern T3SQLExecDirect pODBC3SQLExecDirect;
97     //extern T3SQLNativeSql pODBC3SQLNativeSql;
98     extern T3SQLDescribeParam pODBC3SQLDescribeParam;
99     extern T3SQLNumParams pODBC3SQLNumParams;
100     extern T3SQLParamData pODBC3SQLParamData;
101     extern T3SQLPutData pODBC3SQLPutData;
102     extern T3SQLRowCount pODBC3SQLRowCount;
103     extern T3SQLNumResultCols pODBC3SQLNumResultCols;
104     extern T3SQLDescribeCol pODBC3SQLDescribeCol;
105     extern T3SQLColAttribute pODBC3SQLColAttribute;
106     extern T3SQLBindCol pODBC3SQLBindCol;
107     extern T3SQLFetch pODBC3SQLFetch;
108     extern T3SQLFetchScroll pODBC3SQLFetchScroll;
109     extern T3SQLGetData pODBC3SQLGetData;
110     extern T3SQLSetPos pODBC3SQLSetPos;
111     extern T3SQLBulkOperations pODBC3SQLBulkOperations;
112     extern T3SQLMoreResults pODBC3SQLMoreResults;
113     //extern T3SQLGetDiagField pODBC3SQLGetDiagField;
114     extern T3SQLGetDiagRec pODBC3SQLGetDiagRec;
115     extern T3SQLColumnPrivileges pODBC3SQLColumnPrivileges;
116     extern T3SQLColumns pODBC3SQLColumns;
117     extern T3SQLForeignKeys pODBC3SQLForeignKeys;
118     extern T3SQLPrimaryKeys pODBC3SQLPrimaryKeys;
119     extern T3SQLProcedureColumns pODBC3SQLProcedureColumns;
120     extern T3SQLProcedures pODBC3SQLProcedures;
121     extern T3SQLSpecialColumns pODBC3SQLSpecialColumns;
122     extern T3SQLStatistics pODBC3SQLStatistics;
123     extern T3SQLTablePrivileges pODBC3SQLTablePrivileges;
124     extern T3SQLTables pODBC3SQLTables;
125     extern T3SQLFreeStmt pODBC3SQLFreeStmt;
126     extern T3SQLCloseCursor pODBC3SQLCloseCursor;
127     extern T3SQLCancel pODBC3SQLCancel;
128     extern T3SQLEndTran pODBC3SQLEndTran;
129     extern T3SQLDisconnect pODBC3SQLDisconnect;
130     extern T3SQLFreeHandle pODBC3SQLFreeHandle;
131     extern T3SQLGetCursorName pODBC3SQLGetCursorName;
132     extern T3SQLNativeSql pODBC3SQLNativeSql;
133 
134 using namespace ::com::sun::star::uno;
135 using namespace ::com::sun::star::beans;
136 using namespace ::com::sun::star::sdbcx;
137 using namespace ::com::sun::star::sdbc;
138 using namespace ::com::sun::star::container;
139 using namespace ::com::sun::star::lang;
140 using namespace utl;
141 using namespace osl;
142 using namespace vos;
143 using namespace ::dbtools;
144 
145     sal_Bool LoadFunctions(oslModule pODBCso);
146     sal_Bool LoadLibrary_ADABAS(::rtl::OUString &_rPath);
147     // --------------------------------------------------------------------------------
fillInfo(const Sequence<PropertyValue> & info,TDatabaseStruct & _rDBInfo)148 void ODriver::fillInfo(const Sequence< PropertyValue >& info, TDatabaseStruct& _rDBInfo)
149 {
150     const PropertyValue* pIter = info.getConstArray();
151     const PropertyValue* pEnd = pIter + info.getLength();
152     for(;pIter != pEnd;++pIter)
153     {
154         if(pIter->Name.equalsIgnoreAsciiCase(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DatabaseName"))))
155         {
156             pIter->Value >>= _rDBInfo.sDBName;
157         }
158         else if(pIter->Name.equalsIgnoreAsciiCase(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ControlUser"))))
159         {
160             pIter->Value >>= _rDBInfo.sControlUser;
161         }
162         else if(pIter->Name.equalsIgnoreAsciiCase(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ControlPassword"))))
163         {
164             pIter->Value >>= _rDBInfo.sControlPassword;
165         }
166         else if(pIter->Name.equalsIgnoreAsciiCase(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DataCacheSizeIncrement"))))
167             pIter->Value >>= _rDBInfo.nDataIncrement;
168         else if(pIter->Name.equalsIgnoreAsciiCase(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ShutdownDatabase"))))
169             pIter->Value >>= _rDBInfo.bShutDown;
170         else if(pIter->Name.equalsIgnoreAsciiCase(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("User"))))
171         {
172             pIter->Value >>= _rDBInfo.sSysUser;
173         }
174         else if(pIter->Name.equalsIgnoreAsciiCase(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Password"))))
175         {
176             pIter->Value >>= _rDBInfo.sSysPassword;
177         }
178         else if(pIter->Name.equalsIgnoreAsciiCase(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DomainPassword"))))
179         {
180             pIter->Value >>= _rDBInfo.sDomainPassword;
181         }
182         else if(pIter->Name.equalsIgnoreAsciiCase(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("CacheSize"))))
183         {
184             pIter->Value >>= _rDBInfo.sCacheSize;
185         }
186         else if(pIter->Name.equalsIgnoreAsciiCase(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("RestoreDatabase"))))
187         {
188             pIter->Value >>= _rDBInfo.bRestoreDatabase;
189         }
190         else if(pIter->Name.equalsIgnoreAsciiCase(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Backup"))))
191         {
192             pIter->Value >>= _rDBInfo.sBackupFile;
193         }
194         else if(pIter->Name.equalsIgnoreAsciiCase(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DataDevSpace"))))
195         {
196             pIter->Value >>= _rDBInfo.sDataDevName;
197         }
198         else if(pIter->Name.equalsIgnoreAsciiCase(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SYSDEVSPACE"))))
199         {
200             pIter->Value >>= _rDBInfo.sSysDevSpace;
201         }
202         else if(pIter->Name.equalsIgnoreAsciiCase(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("TRANSACTION_LOG"))))
203         {
204             pIter->Value >>= _rDBInfo.sTransLogName;
205         }
206         else if(pIter->Name.equalsIgnoreAsciiCase(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DataDevSize"))))
207         {
208             pIter->Value >>= _rDBInfo.nDataSize;
209         }
210         else if(pIter->Name.equalsIgnoreAsciiCase(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("LogDevSize"))))
211         {
212             pIter->Value >>= _rDBInfo.nLogSize;
213         }
214     }
215 }
216 
217 
218 // --------------------------------------------------------------------------------
ODriver(const Reference<XMultiServiceFactory> & _rxFactory)219 ODriver::ODriver(const Reference< XMultiServiceFactory >& _rxFactory) : ODBCDriver(_rxFactory)
220 {
221     osl_incrementInterlockedCount(&m_refCount);
222     fillEnvironmentVariables();
223     Reference< XComponent >  xComponent(m_xORB, UNO_QUERY);
224     if (xComponent.is())
225     {
226         Reference< ::com::sun::star::lang::XEventListener> xEvtL((::cppu::OWeakObject*)this,UNO_QUERY);
227         xComponent->addEventListener(xEvtL);
228     }
229     osl_decrementInterlockedCount(&m_refCount);
230 }
231 //------------------------------------------------------------------------------
disposing()232 void ODriver::disposing()
233 {
234     ::osl::MutexGuard aGuard(m_aMutex);
235     ODriver_BASE::disposing();
236     Reference< XComponent >  xComponent(m_xORB, UNO_QUERY);
237     if (xComponent.is())
238     {
239         Reference< XEventListener> xEvtL((::cppu::OWeakObject*)this,UNO_QUERY);
240         xComponent->removeEventListener(xEvtL);
241     }
242     m_xORB.clear();
243 }
244 
245 // static ServiceInfo
246 //------------------------------------------------------------------------------
getImplementationName_Static()247 rtl::OUString ODriver::getImplementationName_Static(  )
248 {
249     return ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.comp.sdbcx.adabas.ODriver"));
250 }
251 //------------------------------------------------------------------------------
getSupportedServiceNames_Static()252 Sequence< ::rtl::OUString > ODriver::getSupportedServiceNames_Static(  )
253 {
254     Sequence< ::rtl::OUString > aSNS( 2 );
255     aSNS[0] = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.sdbc.Driver"));
256     aSNS[1] = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.sdbcx.Driver"));
257     return aSNS;
258 }
259 //------------------------------------------------------------------
getImplementationName()260 ::rtl::OUString SAL_CALL ODriver::getImplementationName(  )
261 {
262     return getImplementationName_Static();
263 }
264 
265 //------------------------------------------------------------------
supportsService(const::rtl::OUString & _rServiceName)266 sal_Bool SAL_CALL ODriver::supportsService( const ::rtl::OUString& _rServiceName )
267 {
268     const Sequence< ::rtl::OUString > aSupported(getSupportedServiceNames());
269     const ::rtl::OUString* pSupported = aSupported.getConstArray();
270     const ::rtl::OUString* pEnd = pSupported + aSupported.getLength();
271     for (;pSupported != pEnd && !pSupported->equals(_rServiceName); ++pSupported)
272         ;
273 
274     return pSupported != pEnd;
275 }
276 //------------------------------------------------------------------
getSupportedServiceNames()277 Sequence< ::rtl::OUString > SAL_CALL ODriver::getSupportedServiceNames(  )
278 {
279     return getSupportedServiceNames_Static();
280 }
281 //------------------------------------------------------------------
queryInterface(const Type & rType)282 Any SAL_CALL ODriver::queryInterface( const Type & rType )
283 {
284     Any aRet = ::cppu::queryInterface(rType, static_cast<XDataDefinitionSupplier*>(this));
285     if ( !aRet.hasValue() )
286         aRet = ODriver_BASE::queryInterface(rType);
287     return aRet.hasValue() ? aRet : ODriver_BASE2::queryInterface(rType);
288 }
289 //------------------------------------------------------------------
ODriver_CreateInstance(const Reference<::com::sun::star::lang::XMultiServiceFactory> & _rxFac)290 Reference< XInterface >  SAL_CALL ODriver_CreateInstance(const Reference< ::com::sun::star::lang::XMultiServiceFactory >& _rxFac)
291 {
292     return *(new ODriver(_rxFac));
293 }
294 // -----------------------------------------------------------------------------
disposing(const EventObject & Source)295 void SAL_CALL ODriver::disposing( const EventObject& Source )
296 {
297     ::osl::MutexGuard aGuard( m_aMutex );
298 
299     if(m_xORB.is() && Reference< XMultiServiceFactory >(Source.Source,UNO_QUERY) == m_xORB)
300     {
301         TDatabaseMap::iterator aIter = m_aDatabaseMap.begin();
302         for(;aIter != m_aDatabaseMap.end();++aIter)
303         {
304             if(aIter->second.bShutDown)
305             {
306                 ::rtl::OUString sName;
307                 if(getDBName(aIter->first,sName))
308                 {
309                     XUTIL(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SHUTDOWN QUICK")),sName,aIter->second.sControlUser,aIter->second.sControlPassword);
310                     X_STOP(sName);
311                 }
312             }
313         }
314     m_xORB.clear();
315     }
316 }
317 // --------------------------------------------------------------------------------
connect(const::rtl::OUString & url,const Sequence<PropertyValue> & info)318 Reference< XConnection > SAL_CALL ODriver::connect( const ::rtl::OUString& url, const Sequence< PropertyValue >& info )
319 {
320     if ( ! acceptsURL(url) )
321         return NULL;
322 
323     ::osl::MutexGuard aGuard( m_aMutex );
324     if (ODriver_BASE::rBHelper.bDisposed)
325         throw DisposedException();
326 
327     TDatabaseStruct aDBInfo;
328     aDBInfo.bShutDown = sal_False;
329     fillInfo(info,aDBInfo);
330     aDBInfo.sControlUser = aDBInfo.sControlUser.toAsciiUpperCase();
331     aDBInfo.sControlPassword = aDBInfo.sControlPassword.toAsciiUpperCase();
332     aDBInfo.sSysUser = aDBInfo.sSysUser.toAsciiUpperCase();
333     aDBInfo.sSysPassword = aDBInfo.sSysPassword.toAsciiUpperCase();
334 
335 
336     TDatabaseMap::iterator aFind = m_aDatabaseMap.find(url);
337     if(aFind == m_aDatabaseMap.end()) // only when not found yet
338         m_aDatabaseMap[url] = aDBInfo;
339     else
340     {
341         if(aFind->second.bShutDown != aDBInfo.bShutDown)
342             aFind->second.bShutDown &= aDBInfo.bShutDown;
343     }
344 
345     ::rtl::OUString sName;
346     if(aDBInfo.sControlPassword.getLength() && aDBInfo.sControlUser.getLength() && getDBName(url,sName))
347     {
348         // check if we have to add a new data dev space
349         checkAndInsertNewDevSpace(sName,aDBInfo);
350 
351         convertOldVersion(sName,aDBInfo);
352         // check if we must restart the database
353         checkAndRestart(sName,aDBInfo);
354     }
355 
356 
357     if(!m_pDriverHandle)
358     {
359         ::rtl::OUString aPath;
360         if(!EnvironmentHandle(aPath))
361             throw SQLException(aPath,*this,::rtl::OUString(),1000,Any());
362     }
363     OAdabasConnection* pCon = new OAdabasConnection(m_pDriverHandle,this);
364     Reference< XConnection > xCon = pCon;
365     SQLRETURN nSQLRETURN = pCon->Construct(url,info);
366 
367     if (nSQLRETURN == SQL_ERROR || nSQLRETURN == SQL_NO_DATA)
368     {
369         odbc::OTools::ThrowException(pCon,nSQLRETURN,pCon->getConnection(),SQL_HANDLE_DBC,*this);
370     }
371 
372     m_xConnections.push_back(WeakReferenceHelper(*pCon));
373 
374     return xCon;
375 }
376 // -----------------------------------------------------------------------------
getDBName(const::rtl::OUString & _rName,::rtl::OUString & sDBName) const377 sal_Bool ODriver::getDBName(const ::rtl::OUString& _rName,::rtl::OUString& sDBName) const
378 {
379     sDBName = ::rtl::OUString();
380     ::rtl::OUString sName = _rName.copy(12);
381     sal_Int32 nPos = sName.indexOf(':');
382     if(nPos != -1 && nPos < 1)
383         sDBName = sName.copy(1);
384     return (nPos != -1 && nPos < 1);
385 }
386 // --------------------------------------------------------------------------------
acceptsURL(const::rtl::OUString & url)387 sal_Bool SAL_CALL ODriver::acceptsURL( const ::rtl::OUString& url )
388 {
389     return (!url.compareTo(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("sdbc:adabas:")),12));
390 }
391 // --------------------------------------------------------------------------------
getPropertyInfo(const::rtl::OUString & url,const Sequence<PropertyValue> &)392 Sequence< DriverPropertyInfo > SAL_CALL ODriver::getPropertyInfo( const ::rtl::OUString& url, const Sequence< PropertyValue >& /*info*/)
393 {
394     if ( acceptsURL(url) )
395     {
396         ::std::vector< DriverPropertyInfo > aDriverInfo;
397 
398         aDriverInfo.push_back(DriverPropertyInfo(
399                 ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ShutdownDatabase"))
400                 ,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Shut down service when closing."))
401                 ,sal_False
402                 ,::rtl::OUString()
403                 ,Sequence< ::rtl::OUString >())
404                 );
405         aDriverInfo.push_back(DriverPropertyInfo(
406                 ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ControlUser"))
407                 ,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Control user name."))
408                 ,sal_False
409                 ,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("0"))
410                 ,Sequence< ::rtl::OUString >())
411                 );
412         aDriverInfo.push_back(DriverPropertyInfo(
413                 ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ControlPassword"))
414                 ,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Control password."))
415                 ,sal_False
416                 ,::rtl::OUString()
417                 ,Sequence< ::rtl::OUString >())
418                 );
419         aDriverInfo.push_back(DriverPropertyInfo(
420                 ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DataCacheSizeIncrement"))
421                 ,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Data increment (MB)."))
422                 ,sal_False
423                 ,::rtl::OUString()
424                 ,Sequence< ::rtl::OUString >())
425                 );
426         aDriverInfo.push_back(DriverPropertyInfo(
427                 ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("CharSet"))
428                 ,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("CharSet of the database."))
429                 ,sal_False
430                 ,::rtl::OUString()
431                 ,Sequence< ::rtl::OUString >())
432                 );
433         return Sequence< DriverPropertyInfo >(&aDriverInfo[0],aDriverInfo.size());
434     }
435 
436     SharedResources aResources;
437     const ::rtl::OUString sMessage = aResources.getResourceString(STR_URI_SYNTAX_ERROR);
438     ::dbtools::throwGenericSQLException(sMessage ,*this);
439     return Sequence< DriverPropertyInfo >();
440 }
441 // --------------------------------------------------------------------------------
getMajorVersion()442 sal_Int32 SAL_CALL ODriver::getMajorVersion(  )
443 {
444     return 1;
445 }
446 // --------------------------------------------------------------------------------
getMinorVersion()447 sal_Int32 SAL_CALL ODriver::getMinorVersion(  )
448 {
449     return 0;
450 }
451 // -----------------------------------------------------------------------------
452 // XCreateCatalog
createCatalog(const Sequence<PropertyValue> & info)453 void SAL_CALL ODriver::createCatalog( const Sequence< PropertyValue >& info )
454 {
455     ::osl::MutexGuard aGuard( m_aMutex );
456     if (ODriver_BASE::rBHelper.bDisposed)
457         throw DisposedException();
458 
459     try
460     {
461         TDatabaseStruct aDBInfo;
462         fillInfo(info,aDBInfo);
463 
464         ::rtl::OUString envVar(RTL_CONSTASCII_USTRINGPARAM("DBSERVICE"));
465         ::rtl::OUString envData(RTL_CONSTASCII_USTRINGPARAM("0"));
466         osl_setEnvironment(envVar.pData, envData.pData);
467 
468         m_sDbRunDir = m_sDbWorkURL + ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("/wrk/")) + aDBInfo.sDBName;
469         String sTemp;
470         LocalFileHelper::ConvertURLToPhysicalName(m_sDbRunDir,sTemp);
471         m_sDbRunDir = sTemp;
472 
473         createNeededDirs(aDBInfo.sDBName);
474         if(CreateFiles(aDBInfo))
475         {
476             ::connectivity::SharedResources aResources;
477             const ::rtl::OUString sError( aResources.getResourceStringWithSubstitution(
478                     STR_NO_DISK_SPACE,
479                     "$filename$",aDBInfo.sDBName
480                  ) );
481             ::dbtools::throwGenericSQLException(sError,*this);
482         } // if(CreateFiles(aDBInfo))
483 
484         createDb(aDBInfo);
485     }
486     catch( SQLException&)
487     {
488         throw;
489     }
490     catch(Exception&)
491     {
492         throw SQLException();
493     }
494 
495 }
496 // -----------------------------------------------------------------------------
497 // XDropCatalog
dropCatalog(const::rtl::OUString &,const Sequence<PropertyValue> &)498 void SAL_CALL ODriver::dropCatalog( const ::rtl::OUString& /*catalogName*/, const Sequence< PropertyValue >& /*info*/ )
499 {
500     ::osl::MutexGuard aGuard( m_aMutex );
501     if (ODriver_BASE::rBHelper.bDisposed)
502         throw DisposedException();
503 
504     ::dbtools::throwFeatureNotImplementedException( "!XDropCatalog::dropCatalog", *this );
505 }
506 //-----------------------------------------------------------------------------
507 // ODBC Environment (gemeinsam fuer alle Connections):
EnvironmentHandle(::rtl::OUString & _rPath)508 SQLHANDLE ODriver::EnvironmentHandle(::rtl::OUString &_rPath)
509 {
510     // Ist (fuer diese Instanz) bereits ein Environment erzeugt worden?
511     if (!m_pDriverHandle)
512     {
513         SQLHANDLE h = SQL_NULL_HANDLE;
514         // Environment allozieren
515 
516         // ODBC-DLL jetzt laden:
517         if (! LoadLibrary_ADABAS(_rPath))
518             return SQL_NULL_HANDLE;
519 
520         if (N3SQLAllocHandle(SQL_HANDLE_ENV,SQL_NULL_HANDLE,&h) != SQL_SUCCESS)
521             return SQL_NULL_HANDLE;
522 
523         // In globaler Struktur merken ...
524         m_pDriverHandle = h;
525         SQLRETURN nError = N3SQLSetEnvAttr(h, SQL_ATTR_ODBC_VERSION,(SQLPOINTER) SQL_OV_ODBC3, SQL_IS_INTEGER);
526         OSL_UNUSED( nError );
527         //N3SQLSetEnvAttr(h, SQL_ATTR_CONNECTION_POOLING,(SQLPOINTER) SQL_CP_ONE_PER_HENV, SQL_IS_INTEGER);
528     }
529 
530     return m_pDriverHandle;
531 }
532 // --------------------------------------------------------------------------------
533 // XDataDefinitionSupplier
getDataDefinitionByConnection(const Reference<::com::sun::star::sdbc::XConnection> & connection)534 Reference< XTablesSupplier > SAL_CALL ODriver::getDataDefinitionByConnection( const Reference< ::com::sun::star::sdbc::XConnection >& connection )
535 {
536     ::osl::MutexGuard aGuard( m_aMutex );
537     if (ODriver_BASE::rBHelper.bDisposed)
538         throw DisposedException();
539 
540     Reference< XTablesSupplier > xTab;
541     Reference< ::com::sun::star::lang::XUnoTunnel> xTunnel(connection,UNO_QUERY);
542     if ( xTunnel.is() )
543     {
544 
545         OAdabasConnection* pConnection = NULL;
546         OAdabasConnection* pSearchConnection = reinterpret_cast< OAdabasConnection* >( xTunnel->getSomething(OAdabasConnection::getUnoTunnelImplementationId()) );
547         for (OWeakRefArray::iterator i = m_xConnections.begin(); m_xConnections.end() != i; ++i)
548         {
549             if ( (OAdabasConnection*) Reference< XConnection >::query(i->get().get()).get() == pSearchConnection )
550             {
551                 pConnection = pSearchConnection;
552                 break;
553             }
554         }
555 
556 
557         if ( pConnection )
558             xTab = pConnection->createCatalog();
559     }
560     return xTab;
561 }
562 
563 // --------------------------------------------------------------------------------
getDataDefinitionByURL(const::rtl::OUString & url,const Sequence<PropertyValue> & info)564 Reference< XTablesSupplier > SAL_CALL ODriver::getDataDefinitionByURL( const ::rtl::OUString& url, const Sequence< PropertyValue >& info )
565 {
566     if ( ! acceptsURL(url) )
567     {
568         SharedResources aResources;
569         const ::rtl::OUString sMessage = aResources.getResourceString(STR_URI_SYNTAX_ERROR);
570         ::dbtools::throwGenericSQLException(sMessage ,*this);
571     } // if ( ! acceptsURL(url) )
572 
573     return getDataDefinitionByConnection(connect(url,info));
574 }
575 // -----------------------------------------------------------------------------
acquire()576 void SAL_CALL ODriver::acquire() throw()
577 {
578     ODriver_BASE::acquire();
579 }
580 // -----------------------------------------------------------------------------
release()581 void SAL_CALL ODriver::release() throw()
582 {
583     ODriver_BASE::release();
584 }
~ODriver()585 ODriver::~ODriver()
586 {
587 }
588 // -----------------------------------------------------------------------------
getOdbcFunction(sal_Int32 _nIndex) const589 oslGenericFunction ODriver::getOdbcFunction(sal_Int32 _nIndex) const
590 {
591     oslGenericFunction pFunction = NULL;
592     switch(_nIndex)
593     {
594         case ODBC3SQLAllocHandle:
595             pFunction = (oslGenericFunction)pODBC3SQLAllocHandle;
596             break;
597         case ODBC3SQLConnect:
598             pFunction = (oslGenericFunction)pODBC3SQLConnect;
599             break;
600         case ODBC3SQLDriverConnect:
601             pFunction = (oslGenericFunction)pODBC3SQLDriverConnect;
602             break;
603         case ODBC3SQLBrowseConnect:
604             pFunction = (oslGenericFunction)pODBC3SQLBrowseConnect;
605             break;
606         case ODBC3SQLDataSources:
607             pFunction = (oslGenericFunction)pODBC3SQLDataSources;
608             break;
609         case ODBC3SQLDrivers:
610             pFunction = (oslGenericFunction)pODBC3SQLDrivers;
611             break;
612         case ODBC3SQLGetInfo:
613 
614             pFunction = (oslGenericFunction)pODBC3SQLGetInfo;
615             break;
616         case ODBC3SQLGetFunctions:
617 
618             pFunction = (oslGenericFunction)pODBC3SQLGetFunctions;
619             break;
620         case ODBC3SQLGetTypeInfo:
621 
622             pFunction = (oslGenericFunction)pODBC3SQLGetTypeInfo;
623             break;
624         case ODBC3SQLSetConnectAttr:
625 
626             pFunction = (oslGenericFunction)pODBC3SQLSetConnectAttr;
627             break;
628         case ODBC3SQLGetConnectAttr:
629 
630             pFunction = (oslGenericFunction)pODBC3SQLGetConnectAttr;
631             break;
632         case ODBC3SQLSetEnvAttr:
633 
634             pFunction = (oslGenericFunction)pODBC3SQLSetEnvAttr;
635             break;
636         case ODBC3SQLGetEnvAttr:
637 
638             pFunction = (oslGenericFunction)pODBC3SQLGetEnvAttr;
639             break;
640         case ODBC3SQLSetStmtAttr:
641 
642             pFunction = (oslGenericFunction)pODBC3SQLSetStmtAttr;
643             break;
644         case ODBC3SQLGetStmtAttr:
645 
646             pFunction = (oslGenericFunction)pODBC3SQLGetStmtAttr;
647             break;
648         case ODBC3SQLPrepare:
649 
650             pFunction = (oslGenericFunction)pODBC3SQLPrepare;
651             break;
652         case ODBC3SQLBindParameter:
653 
654             pFunction = (oslGenericFunction)pODBC3SQLBindParameter;
655             break;
656         case ODBC3SQLSetCursorName:
657 
658             pFunction = (oslGenericFunction)pODBC3SQLSetCursorName;
659             break;
660         case ODBC3SQLExecute:
661 
662             pFunction = (oslGenericFunction)pODBC3SQLExecute;
663             break;
664         case ODBC3SQLExecDirect:
665 
666             pFunction = (oslGenericFunction)pODBC3SQLExecDirect;
667             break;
668         case ODBC3SQLDescribeParam:
669 
670             pFunction = (oslGenericFunction)pODBC3SQLDescribeParam;
671             break;
672         case ODBC3SQLNumParams:
673 
674             pFunction = (oslGenericFunction)pODBC3SQLNumParams;
675             break;
676         case ODBC3SQLParamData:
677 
678             pFunction = (oslGenericFunction)pODBC3SQLParamData;
679             break;
680         case ODBC3SQLPutData:
681 
682             pFunction = (oslGenericFunction)pODBC3SQLPutData;
683             break;
684         case ODBC3SQLRowCount:
685 
686             pFunction = (oslGenericFunction)pODBC3SQLRowCount;
687             break;
688         case ODBC3SQLNumResultCols:
689 
690             pFunction = (oslGenericFunction)pODBC3SQLNumResultCols;
691             break;
692         case ODBC3SQLDescribeCol:
693 
694             pFunction = (oslGenericFunction)pODBC3SQLDescribeCol;
695             break;
696         case ODBC3SQLColAttribute:
697 
698             pFunction = (oslGenericFunction)pODBC3SQLColAttribute;
699             break;
700         case ODBC3SQLBindCol:
701 
702             pFunction = (oslGenericFunction)pODBC3SQLBindCol;
703             break;
704         case ODBC3SQLFetch:
705 
706             pFunction = (oslGenericFunction)pODBC3SQLFetch;
707             break;
708         case ODBC3SQLFetchScroll:
709 
710             pFunction = (oslGenericFunction)pODBC3SQLFetchScroll;
711             break;
712         case ODBC3SQLGetData:
713 
714             pFunction = (oslGenericFunction)pODBC3SQLGetData;
715             break;
716         case ODBC3SQLSetPos:
717 
718             pFunction = (oslGenericFunction)pODBC3SQLSetPos;
719             break;
720         case ODBC3SQLBulkOperations:
721 
722             pFunction = (oslGenericFunction)pODBC3SQLBulkOperations;
723             break;
724         case ODBC3SQLMoreResults:
725 
726             pFunction = (oslGenericFunction)pODBC3SQLMoreResults;
727             break;
728         case ODBC3SQLGetDiagRec:
729 
730             pFunction = (oslGenericFunction)pODBC3SQLGetDiagRec;
731             break;
732         case ODBC3SQLColumnPrivileges:
733 
734             pFunction = (oslGenericFunction)pODBC3SQLColumnPrivileges;
735             break;
736         case ODBC3SQLColumns:
737 
738             pFunction = (oslGenericFunction)pODBC3SQLColumns;
739             break;
740         case ODBC3SQLForeignKeys:
741 
742             pFunction = (oslGenericFunction)pODBC3SQLForeignKeys;
743             break;
744         case ODBC3SQLPrimaryKeys:
745 
746             pFunction = (oslGenericFunction)pODBC3SQLPrimaryKeys;
747             break;
748         case ODBC3SQLProcedureColumns:
749 
750             pFunction = (oslGenericFunction)pODBC3SQLProcedureColumns;
751             break;
752         case ODBC3SQLProcedures:
753 
754             pFunction = (oslGenericFunction)pODBC3SQLProcedures;
755             break;
756         case ODBC3SQLSpecialColumns:
757 
758             pFunction = (oslGenericFunction)pODBC3SQLSpecialColumns;
759             break;
760         case ODBC3SQLStatistics:
761 
762             pFunction = (oslGenericFunction)pODBC3SQLStatistics;
763             break;
764         case ODBC3SQLTablePrivileges:
765 
766             pFunction = (oslGenericFunction)pODBC3SQLTablePrivileges;
767             break;
768         case ODBC3SQLTables:
769 
770             pFunction = (oslGenericFunction)pODBC3SQLTables;
771             break;
772         case ODBC3SQLFreeStmt:
773 
774             pFunction = (oslGenericFunction)pODBC3SQLFreeStmt;
775             break;
776         case ODBC3SQLCloseCursor:
777 
778             pFunction = (oslGenericFunction)pODBC3SQLCloseCursor;
779             break;
780         case ODBC3SQLCancel:
781 
782             pFunction = (oslGenericFunction)pODBC3SQLCancel;
783             break;
784         case ODBC3SQLEndTran:
785 
786             pFunction = (oslGenericFunction)pODBC3SQLEndTran;
787             break;
788         case ODBC3SQLDisconnect:
789 
790             pFunction = (oslGenericFunction)pODBC3SQLDisconnect;
791             break;
792         case ODBC3SQLFreeHandle:
793 
794             pFunction = (oslGenericFunction)pODBC3SQLFreeHandle;
795             break;
796         case ODBC3SQLGetCursorName:
797 
798             pFunction = (oslGenericFunction)pODBC3SQLGetCursorName;
799             break;
800         case ODBC3SQLNativeSql:
801 
802             pFunction = (oslGenericFunction)pODBC3SQLNativeSql;
803             break;
804         default:
805             OSL_ENSURE(0,"Function unknown!");
806     }
807     return pFunction;
808 }
809 // -----------------------------------------------------------------------------
createNeededDirs(const::rtl::OUString & sDBName)810 void ODriver::createNeededDirs(const ::rtl::OUString& sDBName)
811 {
812     ::rtl::OUString sDbWork,sDBConfig,sTemp;
813 
814     if(m_sDbWork.getLength())
815     {
816         sDbWork = m_sDbWorkURL;
817         if(!UCBContentHelper::IsFolder(m_sDbWorkURL))
818             UCBContentHelper::MakeFolder(m_sDbWorkURL);
819 
820         sDbWork += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("/"));
821         sDbWork += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("wrk"));
822         if(!UCBContentHelper::IsFolder(sDbWork))
823             UCBContentHelper::MakeFolder(sDbWork);
824 
825         sDbWork += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("/"));
826 
827         sTemp = sDbWork;
828         sTemp += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("config"));
829         if(!UCBContentHelper::IsFolder(sTemp))
830             UCBContentHelper::MakeFolder(sTemp);
831 
832         sTemp = sDbWork;
833         sTemp += sDBName;
834         if(!UCBContentHelper::IsFolder(sTemp))
835             UCBContentHelper::MakeFolder(sTemp);
836     }
837 
838     if(m_sDbConfig.getLength())
839     {
840         sDBConfig = m_sDbConfigURL;
841         if(!UCBContentHelper::IsFolder(sDBConfig))
842             UCBContentHelper::MakeFolder(sDBConfig);
843 
844         sDBConfig += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("/"));
845         sTemp = sDBConfig;
846         sTemp += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("config"));
847         if(!UCBContentHelper::IsFolder(sTemp))
848             UCBContentHelper::MakeFolder(sTemp);
849 
850         sTemp += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("/"));
851         sTemp += sDBName;
852         if(UCBContentHelper::Exists(sTemp))
853             UCBContentHelper::Kill(sTemp);
854 
855 #if !(defined(WNT))
856         sTemp = sDBConfig;
857         sTemp += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("diag"));
858         if(!UCBContentHelper::IsFolder(sTemp))
859             UCBContentHelper::MakeFolder(sTemp);
860 
861         sTemp = sDBConfig;
862         sTemp += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ipc"));
863         if(!UCBContentHelper::IsFolder(sTemp))
864             UCBContentHelper::MakeFolder(sTemp);
865 
866         sTemp = sDBConfig;
867         sTemp += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("spool"));
868         if(!UCBContentHelper::IsFolder(sTemp))
869             UCBContentHelper::MakeFolder(sTemp);
870 #endif
871     }
872 }
873 // -----------------------------------------------------------------------------
clearDatabase(const::rtl::OUString & sDBName)874 void ODriver::clearDatabase(const ::rtl::OUString& sDBName)
875 { // stop the database
876     ::rtl::OUString sCommand;
877 #if defined(WNT)
878     ::rtl::OUString sStop = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("stop"));
879     OArgumentList aArgs(2,&sDBName,&sStop);
880     sCommand =  ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("x_cons.exe"));
881 #else
882     OArgumentList aArgs(1,&sDBName);
883     sCommand =  ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("x_clear"));
884 #endif
885 
886     OProcess aApp( sCommand,m_sDbWorkURL);
887 #if OSL_DEBUG_LEVEL > 0
888     OProcess::TProcessError eError =
889 #endif
890         aApp.execute( (OProcess::TProcessOption) OPROCESS_ADABAS, aArgs );
891     OSL_ENSURE( eError == OProcess::E_None, "ODriver::clearDatabase: calling the executable failed!" );
892 }
893 // -----------------------------------------------------------------------------
createDb(const TDatabaseStruct & _aInfo)894 void ODriver::createDb( const TDatabaseStruct& _aInfo)
895 {
896 
897     clearDatabase(_aInfo.sDBName);
898 
899     X_PARAM(_aInfo.sDBName,_aInfo.sControlUser,_aInfo.sControlPassword,String::CreateFromAscii("BINIT"));
900 
901     String sTemp;
902     LocalFileHelper::ConvertURLToPhysicalName(_aInfo.sSysDevSpace,sTemp);
903 
904     PutParam(_aInfo.sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SYSDEVSPACE")),sTemp);
905 
906     sTemp.Erase();
907     LocalFileHelper::ConvertURLToPhysicalName(_aInfo.sTransLogName,sTemp);
908     PutParam(_aInfo.sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("TRANSACTION_LOG")),sTemp);
909     PutParam(_aInfo.sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("MAXUSERTASKS")),::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("3")));
910     PutParam(_aInfo.sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("MAXDEVSPACES")),::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("7")));
911     PutParam(_aInfo.sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("MAXDATADEVSPACES")),::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("5")));
912     PutParam(_aInfo.sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("MAXDATAPAGES")),::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("25599")));
913     PutParam(_aInfo.sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("MAXBACKUPDEVS")),::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("1")));
914     PutParam(_aInfo.sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("MAXSERVERDB")),::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("1")));
915     PutParam(_aInfo.sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DATA_CACHE_PAGES")),_aInfo.sCacheSize);
916     PutParam(_aInfo.sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("CONV_CACHE_PAGES")),::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("23")));
917     PutParam(_aInfo.sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("PROC_DATA_PAGES")),::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("40")));
918     PutParam(_aInfo.sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("RUNDIRECTORY")),m_sDbRunDir);
919     PutParam(_aInfo.sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("KERNELTRACESIZE")),::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("100")));
920     PutParam(_aInfo.sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("LOG_QUEUE_PAGES")),::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("10")));
921 
922 #if !defined(WNT)
923     PutParam(_aInfo.sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("OPMSG1")),::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("/dev/null")));
924 #endif
925 
926     X_PARAM(_aInfo.sDBName,_aInfo.sControlUser,_aInfo.sControlPassword,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("BCHECK")));
927 
928     X_START(_aInfo.sDBName);
929 
930     //  SHOW_STATE()
931     //  %m_sDbRoot%\bin\xutil -d %_aInfo.sDBName% -u %CONUSR%,%CONPWD% -b %INITCMD%
932     ::rtl::OUString aBatch2 =  ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("-b "));
933 
934 //  if(!bBsp && INITCMD.Len() >= 40)
935 //  {
936 //      DirEntry aTmp(INITCMD);
937 //      aTmp.CopyTo(aInitFile, FSYS_ACTION_COPYFILE);
938 //      INITCMD = aInitFile.GetFull();
939 //  }
940     // generate the init file for the database
941     String sInitFile = getDatabaseInitFile(_aInfo);
942 
943     LocalFileHelper::ConvertURLToPhysicalName(sInitFile,sTemp);
944     aBatch2 += sTemp;
945     XUTIL(aBatch2,_aInfo.sDBName,_aInfo.sControlUser,_aInfo.sControlPassword);
946 #if OSL_DEBUG_LEVEL < 2
947     if(UCBContentHelper::Exists(sInitFile))
948         UCBContentHelper::Kill(sInitFile);
949 #endif
950 
951     // install system tables
952     installSystemTables(_aInfo);
953     // now we have to make our SYSDBA user "NOT EXCLUSIVE"
954     {
955         String sExt;
956         sExt.AssignAscii(".sql");
957 
958         String sWorkUrl(m_sDbWorkURL);
959         ::utl::TempFile aInitFile(String::CreateFromAscii("Init"),&sExt,&sWorkUrl);
960         aInitFile.EnableKillingFile();
961         {
962             ::std::auto_ptr<SvStream> pFileStream( UcbStreamHelper::CreateStream(aInitFile.GetURL(),STREAM_WRITE) );
963             (*pFileStream)  << "ALTER USER \""
964                             << _aInfo.sSysUser
965                             << "\" NOT EXCLUSIVE "
966                             << sNewLine;
967             pFileStream->Flush();
968         }
969         { // just to get sure that the tempfile still lives
970             sTemp.Erase();
971             LocalFileHelper::ConvertURLToPhysicalName(aInitFile.GetURL(),sTemp);
972             LoadBatch(_aInfo.sDBName,_aInfo.sSysUser,_aInfo.sSysPassword,sTemp);
973         }
974     }
975 }
976 
977 
978 //-------------------------------------------------------------------------------------------------
X_PARAM(const::rtl::OUString & _DBNAME,const::rtl::OUString & _USR,const::rtl::OUString & _PWD,const::rtl::OUString & _CMD)979 int ODriver::X_PARAM(const ::rtl::OUString& _DBNAME,
980             const ::rtl::OUString& _USR,
981             const ::rtl::OUString& _PWD,
982             const ::rtl::OUString& _CMD)
983 {
984     //  %XPARAM% -u %CONUSR%,%CONPWD% BINIT
985     String sCommandFile = generateInitFile();
986     {
987         ::std::auto_ptr<SvStream> pFileStream( UcbStreamHelper::CreateStream(sCommandFile,STREAM_STD_READWRITE));
988         pFileStream->Seek(STREAM_SEEK_TO_END);
989         (*pFileStream)  << "x_param"
990 #if defined(WNT)
991                         << ".exe"
992 #endif
993                         << " -d "
994                         << _DBNAME
995                         << " -u "
996                         << _USR
997                         << ","
998                         << _PWD
999                         << " "
1000                         << _CMD
1001 #if defined(WNT)
1002 #if (OSL_DEBUG_LEVEL > 1) || defined(DBG_UTIL)
1003                         << " >> %DBWORK%\\create.log 2>&1"
1004 #endif
1005 #else
1006 #if (OSL_DEBUG_LEVEL > 1) || defined(DBG_UTIL)
1007                         << " >> /tmp/kstart.log"
1008 #else
1009                         << " > /dev/null"
1010 #endif
1011 #endif
1012                         << " "
1013                         << sNewLine
1014                         << sNewLine;
1015 
1016         pFileStream->Flush();
1017     }
1018 
1019     OProcess aApp(sCommandFile ,m_sDbWorkURL);
1020 #if OSL_DEBUG_LEVEL > 0
1021     OProcess::TProcessError eError =
1022 #endif
1023         aApp.execute( (OProcess::TProcessOption)(OProcess::TOption_Hidden | OProcess::TOption_Wait));
1024     OSL_ENSURE( eError == OProcess::E_None, "ODriver::X_PARAM: calling the executable failed!" );
1025 #if OSL_DEBUG_LEVEL < 2
1026     if(UCBContentHelper::Exists(sCommandFile))
1027         UCBContentHelper::Kill(sCommandFile);
1028 #endif
1029 
1030     return 0;
1031 }
1032 // -----------------------------------------------------------------------------
CreateFiles(const TDatabaseStruct & _aInfo)1033 sal_Int32 ODriver::CreateFiles(const TDatabaseStruct& _aInfo)
1034 {
1035     int nRet = CreateFile(_aInfo.sSysDevSpace,_aInfo.nDataSize/50) ? 0 : -9;
1036     if(!nRet)
1037         nRet = CreateFile(_aInfo.sTransLogName,_aInfo.nLogSize) ? 0 : -10;
1038     if(!nRet)
1039         nRet = CreateFile(_aInfo.sDataDevName,_aInfo.nDataSize) ? 0 : -11;
1040 
1041     return nRet;
1042 
1043 }
1044 // -----------------------------------------------------------------------------
PutParam(const::rtl::OUString & sDBName,const::rtl::OUString & rWhat,const::rtl::OUString & rHow)1045 void ODriver::PutParam(const ::rtl::OUString& sDBName,
1046                       const ::rtl::OUString& rWhat,
1047                       const ::rtl::OUString& rHow)
1048 {
1049     OArgumentList aArgs(3,&sDBName,&rWhat,&rHow);
1050     ::rtl::OUString sCommand = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("putparam"));
1051 #if defined(WNT)
1052     sCommand += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(".exe"));
1053 #endif
1054 
1055     OProcess aApp(sCommand,m_sDbWorkURL);
1056 #if OSL_DEBUG_LEVEL > 0
1057     OProcess::TProcessError eError =
1058 #endif
1059         aApp.execute( (OProcess::TProcessOption)OPROCESS_ADABAS,aArgs );
1060     OSL_ENSURE( eError == OProcess::E_None, "ODriver::PutParam: calling the executable failed!" );
1061 }
1062 // -----------------------------------------------------------------------------
CreateFile(const::rtl::OUString & _FileName,sal_Int32 _nSize)1063 sal_Bool ODriver::CreateFile(const ::rtl::OUString &_FileName,
1064                 sal_Int32 _nSize)
1065 {
1066 OSL_TRACE("CreateFile %d",_nSize);
1067     sal_Bool bOK = sal_True;
1068     try
1069     {
1070         ::std::auto_ptr<SvStream> pFileStream( UcbStreamHelper::CreateStream(_FileName,STREAM_WRITE));
1071         if( !pFileStream.get())
1072         {
1073             ::connectivity::SharedResources aResources;
1074             const ::rtl::OUString sError( aResources.getResourceStringWithSubstitution(
1075                     STR_NO_DISK_SPACE,
1076                     "$filename$",_FileName
1077                  ) );
1078             ::dbtools::throwGenericSQLException(sError,*this);
1079         }
1080         (*pFileStream).SetFiller('\0');
1081         sal_Int32 nNewSize = 0;
1082         sal_Int32 nCount = _nSize /2;
1083         for(sal_Int32 i=0; bOK && i < nCount; ++i)
1084         {
1085             nNewSize += 8192;//4096;
1086             bOK = (*pFileStream).SetStreamSize(nNewSize);
1087             pFileStream->Flush();
1088         }
1089 
1090         bOK = bOK && static_cast<sal_Int32>(pFileStream->Seek(STREAM_SEEK_TO_END)) == nNewSize;
1091     }
1092     catch(Exception&)
1093     {
1094     OSL_TRACE("Exception");
1095     }
1096     if(!bOK)
1097     {
1098         ::connectivity::SharedResources aResources;
1099         const ::rtl::OUString sError( aResources.getResourceStringWithSubstitution(
1100                 STR_NO_DISK_SPACE,
1101                 "$filename$",_FileName
1102              ) );
1103         ::dbtools::throwGenericSQLException(sError,*this);
1104     }
1105 
1106     return bOK;
1107     // dd if=/dev/zero bs=4k of=$DEV_NAME count=$2
1108 }
1109 // -----------------------------------------------------------------------------
X_START(const::rtl::OUString & sDBName)1110 int ODriver::X_START(const ::rtl::OUString& sDBName)
1111 {
1112     ::rtl::OUString sCommand;
1113 #if defined(WNT)
1114 
1115     ::rtl::OUString sArg1 = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("-d"));
1116     ::rtl::OUString sArg3 = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("-NoDBService"));
1117     ::rtl::OUString sArg4 = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("-NoDBWindow"));
1118 
1119     OArgumentList aArgs(4,&sArg1,&sDBName,&sArg3,&sArg4);
1120     sCommand =  ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("strt.exe"));
1121 #else
1122     OArgumentList aArgs(1,&sDBName);
1123     sCommand =  ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("x_start"));
1124 #endif
1125 
1126     OProcess aApp( sCommand ,m_sDbWorkURL);
1127     OProcess::TProcessError eError = aApp.execute((OProcess::TProcessOption)OPROCESS_ADABAS,aArgs);
1128 
1129     if(eError == OProcess::E_NotFound)
1130     {
1131         ::connectivity::SharedResources aResources;
1132         const ::rtl::OUString sError( aResources.getResourceStringWithSubstitution(
1133                 STR_COMMAND_NOT_FOUND,
1134                 "$databasename$",sDBName,
1135                 "$progname$",sCommand
1136              ) );
1137         ::dbtools::throwGenericSQLException(sError,*this);
1138     }
1139     OSL_ASSERT(eError == OProcess::E_None);
1140 
1141     OProcess::TProcessInfo aInfo;
1142     if(aApp.getInfo(OProcess::TData_ExitCode,&aInfo) == OProcess::E_None && aInfo.Code)
1143         return aInfo.Code;
1144 
1145     return 0;
1146 }
1147 // -----------------------------------------------------------------------------
X_STOP(const::rtl::OUString & sDBName)1148 int ODriver::X_STOP(const ::rtl::OUString& sDBName)
1149 {
1150     ::rtl::OUString sCommand;
1151 #if defined(WNT)
1152 
1153     ::rtl::OUString sArg1 = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("-d"));
1154     ::rtl::OUString sArg2 = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("-NoDBService"));
1155 
1156     OArgumentList aArgs(3,&sArg1,&sDBName,&sArg2);
1157     sCommand =  ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("stp.exe"));
1158 #else
1159     OArgumentList aArgs(1,&sDBName);
1160     sCommand = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("x_stop"));
1161 #endif
1162     OProcess aApp( sCommand ,m_sDbWorkURL);
1163 
1164     OProcess::TProcessError eError = aApp.execute((OProcess::TProcessOption)OPROCESS_ADABAS,aArgs);
1165 
1166 
1167     OSL_ASSERT(eError == OProcess::E_None);
1168     if(eError != OProcess::E_None)
1169         return 1;
1170         OProcess::TProcessInfo aInfo;
1171     if(aApp.getInfo(OProcess::TData_ExitCode,&aInfo) == OProcess::E_None && aInfo.Code)
1172         return aInfo.Code;
1173 
1174     return 0;
1175 }
1176 // -----------------------------------------------------------------------------
XUTIL(const::rtl::OUString & _rParam,const::rtl::OUString & _DBNAME,const::rtl::OUString & _USRNAME,const::rtl::OUString & _USRPWD)1177 void ODriver::XUTIL(const ::rtl::OUString& _rParam,
1178            const ::rtl::OUString& _DBNAME,
1179            const ::rtl::OUString& _USRNAME,
1180            const ::rtl::OUString& _USRPWD)
1181 {
1182     String sWorkUrl(m_sDbWorkURL);
1183     String sExt = String::CreateFromAscii(".log");
1184     ::utl::TempFile aCmdFile(String::CreateFromAscii("xutil"),&sExt,&sWorkUrl);
1185     aCmdFile.EnableKillingFile();
1186 
1187     String sPhysicalPath;
1188     LocalFileHelper::ConvertURLToPhysicalName(aCmdFile.GetURL(),sPhysicalPath);
1189 
1190     String sCommandFile = generateInitFile();
1191 
1192     {
1193         ::std::auto_ptr<SvStream> pFileStream( UcbStreamHelper::CreateStream(sCommandFile,STREAM_STD_READWRITE));
1194         pFileStream->Seek(STREAM_SEEK_TO_END);
1195         (*pFileStream)  <<
1196 #if defined(WNT)
1197                             "xutil.exe"
1198 #else
1199                             "utility"
1200 #endif
1201                         << " -u "
1202                         << _USRNAME
1203                         << ","
1204                         << _USRPWD
1205                         << " -d "
1206                         << _DBNAME
1207                         << " "
1208                         << _rParam
1209                         << " > "
1210                         << sPhysicalPath
1211                         << " 2>&1"
1212                         << sNewLine;
1213         pFileStream->Flush();
1214     }
1215 
1216     OProcess aApp(sCommandFile ,m_sDbWorkURL);
1217 #if OSL_DEBUG_LEVEL > 0
1218     OProcess::TProcessError eError =
1219 #endif
1220         aApp.execute( (OProcess::TProcessOption)(OProcess::TOption_Hidden | OProcess::TOption_Wait));
1221     OSL_ENSURE( eError == OProcess::E_None, "ODriver::XUTIL: calling the executable failed!" );
1222 #if OSL_DEBUG_LEVEL < 2
1223     if(UCBContentHelper::Exists(sCommandFile))
1224         UCBContentHelper::Kill(sCommandFile);
1225 #endif
1226 }
1227 // -----------------------------------------------------------------------------
LoadBatch(const::rtl::OUString & sDBName,const::rtl::OUString & _rUSR,const::rtl::OUString & _rPWD,const::rtl::OUString & _rBatch)1228 void ODriver::LoadBatch(const ::rtl::OUString& sDBName,
1229                const ::rtl::OUString& _rUSR,
1230                const ::rtl::OUString& _rPWD,
1231                const ::rtl::OUString& _rBatch)
1232 {
1233     OSL_ENSURE(_rBatch.getLength(),"No batch file given!");
1234     String sWorkUrl(m_sDbWorkURL);
1235     String sExt = String::CreateFromAscii(".log");
1236     ::utl::TempFile aCmdFile(String::CreateFromAscii("LoadBatch"),&sExt,&sWorkUrl);
1237 #if OSL_DEBUG_LEVEL < 2
1238     aCmdFile.EnableKillingFile();
1239 #endif
1240 
1241     String sPhysicalPath;
1242     LocalFileHelper::ConvertURLToPhysicalName(aCmdFile.GetURL(),sPhysicalPath);
1243 
1244     String sCommandFile = generateInitFile();
1245     {
1246         ::std::auto_ptr<SvStream> pFileStream( UcbStreamHelper::CreateStream(sCommandFile,STREAM_STD_READWRITE));
1247         pFileStream->Seek(STREAM_SEEK_TO_END);
1248         (*pFileStream)  << "xload"
1249 #if defined(WNT)
1250                         << ".exe"
1251 #endif
1252                         << " -d "
1253                         << sDBName
1254                         << " -u "
1255                         << _rUSR
1256                         << ","
1257                         << _rPWD;
1258 
1259         if ( !isKernelVersion(CURRENT_DB_VERSION) )
1260             (*pFileStream) << " -S adabas -b ";
1261         else
1262             (*pFileStream) << " -S NATIVE -b ";
1263 
1264         (*pFileStream)  << _rBatch
1265                         << " > "
1266                         << sPhysicalPath
1267                         << " 2>&1"
1268                         << sNewLine;
1269 
1270         pFileStream->Flush();
1271     }
1272 
1273     OProcess aApp(sCommandFile ,m_sDbWorkURL);
1274 #if OSL_DEBUG_LEVEL > 0
1275     OProcess::TProcessError eError =
1276 #endif
1277         aApp.execute( (OProcess::TProcessOption)(OProcess::TOption_Hidden | OProcess::TOption_Wait));
1278     OSL_ENSURE( eError == OProcess::E_None, "ODriver::LoadBatch: calling the executable failed!" );
1279 #if OSL_DEBUG_LEVEL < 2
1280     if(UCBContentHelper::Exists(sCommandFile))
1281         UCBContentHelper::Kill(sCommandFile);
1282 #endif
1283 }
1284 // -----------------------------------------------------------------------------
fillEnvironmentVariables()1285 void ODriver::fillEnvironmentVariables()
1286 {
1287     // read the environment vars
1288     struct env_data
1289     {
1290         const sal_Char*     pAsciiEnvName;
1291         ::rtl::OUString*    pValue;
1292         ::rtl::OUString*    pValueURL;
1293     } EnvData[] = {
1294         { "DBWORK",     &m_sDbWork,     &m_sDbWorkURL },
1295         { "DBCONFIG",   &m_sDbConfig,   &m_sDbConfigURL },
1296         { "DBROOT",     &m_sDbRoot,     &m_sDbRootURL }
1297     };
1298 
1299     for ( size_t i = 0; i < sizeof( EnvData ) / sizeof( EnvData[0] ); ++i )
1300     {
1301         ::rtl::OUString sVarName = ::rtl::OUString::createFromAscii( EnvData[i].pAsciiEnvName );
1302         ::rtl::OUString sEnvValue;
1303         if(osl_getEnvironment( sVarName.pData, &sEnvValue.pData ) == osl_Process_E_None )
1304         {
1305             *EnvData[i].pValue = sEnvValue;
1306             String sURL;
1307             LocalFileHelper::ConvertPhysicalNameToURL( *EnvData[i].pValue, sURL );
1308             *EnvData[i].pValueURL = sURL;
1309         }
1310     }
1311 
1312     m_sDelimit =  ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("/"));
1313 }
1314 // -----------------------------------------------------------------------------
generateInitFile() const1315 ::rtl::OUString ODriver::generateInitFile() const
1316 {
1317     String sExt;
1318 #if !defined(WNT)
1319     sExt = String::CreateFromAscii(".sh");
1320 #else
1321     sExt = String::CreateFromAscii(".bat");
1322 #endif
1323 
1324     String sWorkUrl(m_sDbWorkURL);
1325     ::utl::TempFile aCmdFile(String::CreateFromAscii("Init"),&sExt,&sWorkUrl);
1326 #if !defined(WNT)
1327     String sPhysicalPath;
1328     LocalFileHelper::ConvertURLToPhysicalName(aCmdFile.GetURL(),sPhysicalPath);
1329     chmod(ByteString(sPhysicalPath,gsl_getSystemTextEncoding()).GetBuffer(),S_IRUSR|S_IWUSR|S_IXUSR);
1330 #endif
1331 
1332 #if !defined(WNT)
1333     SvStream* pFileStream = aCmdFile.GetStream(STREAM_WRITE);
1334     (*pFileStream)  << "#!/bin/sh"
1335                     << sNewLine
1336                     << "cd \"$DBWORK\""
1337                     << sNewLine
1338                     << sNewLine;
1339     pFileStream->Flush();
1340 #endif
1341 
1342     return aCmdFile.GetURL();
1343 }
1344 // -----------------------------------------------------------------------------
getDatabaseInitFile(const TDatabaseStruct & _aDBInfo)1345 ::rtl::OUString ODriver::getDatabaseInitFile(  const TDatabaseStruct& _aDBInfo)
1346 {
1347     String sExt;
1348     sExt.AssignAscii(".ins");
1349 
1350 
1351     String sWorkUrl(m_sDbWorkURL);
1352     ::utl::TempFile aInitFile(String::CreateFromAscii("Init"),&sExt,&sWorkUrl);
1353     {
1354         SvStream* pFileStream = aInitFile.GetStream(STREAM_WRITE);
1355         (*pFileStream) << "* @(#)init.cmd  6.1.1   1994-11-10\n";
1356         (*pFileStream) << "init config\n";
1357         (*pFileStream) << "* default code:\n";
1358         (*pFileStream) << "ascii\n";
1359         (*pFileStream) << "* date time format\n";
1360         (*pFileStream) << "internal\n";
1361         (*pFileStream) << "* command timeout:\n";
1362         (*pFileStream) << "900\n";
1363         (*pFileStream) << "* lock timeout:\n";
1364         (*pFileStream) << "360\n";
1365         (*pFileStream) << "* request timeout:\n";
1366         (*pFileStream) << "180\n";
1367         (*pFileStream) << "* log mode:\n";
1368         (*pFileStream) << "demo\n";
1369         (*pFileStream) << "* log segment size:\n";
1370         (*pFileStream) << "0\n";
1371         (*pFileStream) << "* no of archive logs:\n";
1372         (*pFileStream) << "0\n";
1373         (*pFileStream) << "* no of data devspaces:\n";
1374         (*pFileStream) << "1\n";
1375         (*pFileStream) << "* mirror devspaces:\n";
1376         (*pFileStream) << "n\n";
1377         (*pFileStream) << "if $rc <> 0 then stop\n";
1378         (*pFileStream) << "*---  device description ---\n";
1379         (*pFileStream) << "* sys devspace name:\n";
1380         {
1381             String sTemp;
1382             LocalFileHelper::ConvertURLToPhysicalName(_aDBInfo.sSysDevSpace,sTemp);
1383             (*pFileStream) << sTemp;
1384         }
1385         (*pFileStream) << "\n* log devspace size:\n";
1386         (*pFileStream) << ::rtl::OString::valueOf(_aDBInfo.nLogSize);
1387         (*pFileStream) << "\n* log devspace name:\n";
1388         {
1389             String sTemp;
1390             LocalFileHelper::ConvertURLToPhysicalName(_aDBInfo.sTransLogName,sTemp);
1391             (*pFileStream) << sTemp;
1392         }
1393         (*pFileStream) << "\n* data devspace size:\n";
1394         (*pFileStream) << ::rtl::OString::valueOf(_aDBInfo.nDataSize);
1395         (*pFileStream) << "\n* data devspace name:\n";
1396         {
1397             String sTemp;
1398             LocalFileHelper::ConvertURLToPhysicalName(_aDBInfo.sDataDevName,sTemp);
1399             (*pFileStream) << sTemp;
1400         }
1401 
1402         (*pFileStream) << "\n* END INIT CONFIG\n";
1403         (*pFileStream) << "if $rc <> 0 then stop\n";
1404         if(_aDBInfo.bRestoreDatabase)
1405         {
1406             (*pFileStream) << "RESTORE DATA QUICK FROM '";
1407             {
1408                 String sTemp;
1409                 LocalFileHelper::ConvertURLToPhysicalName(_aDBInfo.sBackupFile,sTemp);
1410                 (*pFileStream) << sTemp;
1411             }
1412             (*pFileStream) << "' BLOCKSIZE 8\n";
1413             (*pFileStream) << "if $rc <> 0 then stop\n";
1414             (*pFileStream) << "RESTART\n";
1415 
1416         }
1417         else
1418         {
1419             (*pFileStream) << "ACTIVATE SERVERDB SYSDBA \"";
1420             (*pFileStream) << _aDBInfo.sSysUser;
1421             (*pFileStream) << "\" PASSWORD \"";
1422             (*pFileStream) << _aDBInfo.sSysPassword;
1423             (*pFileStream) << "\"\n";
1424         }
1425         (*pFileStream) << "if $rc <> 0 then stop\n";
1426         (*pFileStream) << "exit\n";
1427     }
1428     return aInitFile.GetURL();
1429 }
1430 // -----------------------------------------------------------------------------
X_CONS(const::rtl::OUString & sDBName,const::rtl::OString & _ACTION,const::rtl::OUString & _FILENAME)1431 void ODriver::X_CONS(const ::rtl::OUString& sDBName,const ::rtl::OString& _ACTION,const ::rtl::OUString& _FILENAME)
1432 {
1433     String sPhysicalPath;
1434     LocalFileHelper::ConvertURLToPhysicalName(_FILENAME,sPhysicalPath);
1435 
1436     String sCommandFile = generateInitFile();
1437     {
1438         ::std::auto_ptr<SvStream> pFileStream( UcbStreamHelper::CreateStream(sCommandFile,STREAM_STD_READWRITE));
1439         pFileStream->Seek(STREAM_SEEK_TO_END);
1440 
1441         (*pFileStream)  << "x_cons"
1442 #if defined(WNT)
1443                         << ".exe"
1444 #endif
1445                         << " "
1446                         << sDBName
1447                         << " SHOW "
1448                         << _ACTION
1449                         << " > "
1450                         << sPhysicalPath
1451                         << sNewLine;
1452         pFileStream->Flush();
1453     }
1454 
1455     OProcess aApp(sCommandFile ,m_sDbWorkURL);
1456     aApp.execute( (OProcess::TProcessOption)(OProcess::TOption_Hidden | OProcess::TOption_Wait));
1457 #if OSL_DEBUG_LEVEL < 2
1458     if(UCBContentHelper::Exists(sCommandFile))
1459         UCBContentHelper::Kill(sCommandFile);
1460 #endif
1461 }
1462 // -----------------------------------------------------------------------------
checkAndRestart(const::rtl::OUString & sDBName,const TDatabaseStruct & _rDbInfo)1463 void ODriver::checkAndRestart(const ::rtl::OUString& sDBName,const TDatabaseStruct& _rDbInfo)
1464 {
1465     String sWorkUrl(m_sDbWorkURL);
1466     String sExt = String::CreateFromAscii(".st");
1467     ::utl::TempFile aCmdFile(String::CreateFromAscii("State"),&sExt,&sWorkUrl);
1468     aCmdFile.EnableKillingFile();
1469 
1470     X_CONS(sDBName,"STATE",aCmdFile.GetURL());
1471     SvStream* pFileStream = aCmdFile.GetStream(STREAM_SHARE_DENYALL);
1472     if ( pFileStream )
1473     {
1474         ByteString sStateLine;
1475         sal_Bool bRead = sal_True;
1476         sal_Int32 nStart = 2;
1477         while(bRead && !pFileStream->IsEof())
1478         {
1479             String aLine;
1480             bRead = pFileStream->ReadLine(sStateLine);
1481             if(bRead)
1482             {
1483                 if(sStateLine.Search("WARM") != STRING_NOTFOUND)
1484                 {   // nothing to do
1485                     nStart = 0;
1486                     break;
1487                 }
1488                 else if(sStateLine.Search("COLD") != STRING_NOTFOUND)
1489                 {
1490                     nStart = 1;
1491                     break;
1492                 }
1493             }
1494         }
1495         switch(nStart)
1496         {
1497             case 2:
1498                 clearDatabase(sDBName);
1499                 X_START(sDBName);
1500                 // don't break here
1501             case 1:
1502                 XUTIL(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("RESTART")),sDBName,_rDbInfo.sControlUser,_rDbInfo.sControlPassword);
1503             case 0:
1504                 break;
1505         }
1506     }
1507 }
1508 // -----------------------------------------------------------------------------
isVersion(const::rtl::OUString & sDBName,const char * _pVersion)1509 sal_Bool ODriver::isVersion(const ::rtl::OUString& sDBName, const char* _pVersion)
1510 {
1511     String sWorkUrl(m_sDbWorkURL);
1512     String sExt = String::CreateFromAscii(".st");
1513     ::utl::TempFile aCmdFile(String::CreateFromAscii("DevSpaces"),&sExt,&sWorkUrl);
1514     aCmdFile.EnableKillingFile();
1515 
1516     String sPhysicalPath;
1517     LocalFileHelper::ConvertURLToPhysicalName(aCmdFile.GetURL(),sPhysicalPath);
1518 
1519     String sCommandFile = generateInitFile();
1520     {
1521         ::std::auto_ptr<SvStream> pFileStream( UcbStreamHelper::CreateStream(sCommandFile,STREAM_STD_READWRITE));
1522         pFileStream->Seek(STREAM_SEEK_TO_END);
1523 
1524         (*pFileStream)  << "getparam"
1525 #if defined(WNT)
1526                         << ".exe"
1527 #endif
1528                         << " "
1529                         << sDBName
1530                         << " KERNELVERSION > "
1531                         << sPhysicalPath
1532                         << sNewLine;
1533     }
1534 
1535     OProcess aApp(sCommandFile ,m_sDbWorkURL);
1536     aApp.execute( (OProcess::TProcessOption)OPROCESS_ADABAS);
1537 #if OSL_DEBUG_LEVEL < 2
1538     if(UCBContentHelper::Exists(sCommandFile))
1539         UCBContentHelper::Kill(sCommandFile);
1540 #endif
1541     SvStream* pFileStream = aCmdFile.GetStream(STREAM_STD_READWRITE);
1542     ByteString sStateLine;
1543     sal_Bool bRead = sal_True;
1544     sal_Bool bIsVersion = sal_False;
1545     while ( pFileStream && bRead && !pFileStream->IsEof() )
1546     {
1547         bRead = pFileStream->ReadLine(sStateLine);
1548         if ( bRead )
1549         {
1550             bIsVersion = sStateLine.GetToken(1,' ').Equals(_pVersion) != 0;
1551             break;
1552         }
1553     }
1554     return bIsVersion;
1555 }
1556 // -----------------------------------------------------------------------------
checkAndInsertNewDevSpace(const::rtl::OUString & sDBName,const TDatabaseStruct & _rDBInfo)1557 void ODriver::checkAndInsertNewDevSpace(const ::rtl::OUString& sDBName,
1558                                         const TDatabaseStruct& _rDBInfo)
1559 {
1560     //  %DBROOT%\pgm\getparam %2 DATA_CACHE_PAGES > %3
1561     String sWorkUrl(m_sDbWorkURL);
1562     String sExt = String::CreateFromAscii(".st");
1563     ::utl::TempFile aCmdFile(String::CreateFromAscii("DevSpaces"),&sExt,&sWorkUrl);
1564     aCmdFile.EnableKillingFile();
1565 
1566     String sPhysicalPath;
1567     LocalFileHelper::ConvertURLToPhysicalName(aCmdFile.GetURL(),sPhysicalPath);
1568 
1569     String sCommandFile = generateInitFile();
1570     {
1571         ::std::auto_ptr<SvStream> pFileStream( UcbStreamHelper::CreateStream(sCommandFile,STREAM_STD_READWRITE));
1572         pFileStream->Seek(STREAM_SEEK_TO_END);
1573 
1574         (*pFileStream)  << "getparam"
1575 #if defined(WNT)
1576                         << ".exe"
1577 #endif
1578                         << " "
1579                         << sDBName
1580                         << " DATA_CACHE_PAGES > "
1581                         << sPhysicalPath
1582                         << sNewLine;
1583     }
1584 
1585     OProcess aApp(sCommandFile ,m_sDbWorkURL);
1586     aApp.execute( (OProcess::TProcessOption)OPROCESS_ADABAS);
1587 #if OSL_DEBUG_LEVEL < 2
1588     if(UCBContentHelper::Exists(sCommandFile))
1589         UCBContentHelper::Kill(sCommandFile);
1590 #endif
1591     SvStream* pFileStream = aCmdFile.GetStream(STREAM_STD_READWRITE);
1592     ByteString sStateLine;
1593     sal_Bool bRead = sal_True;
1594     sal_Int32 nDataPages = 0;
1595     while(pFileStream && bRead && !pFileStream->IsEof())
1596     {
1597         bRead = pFileStream->ReadLine(sStateLine);
1598         if(bRead)
1599         {
1600             nDataPages = sStateLine.ToInt32();
1601             if(nDataPages && nDataPages < 100)
1602             {
1603                 // the space isn't big enough anymore so we increment it
1604                 PutParam(sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DATA_CACHE_PAGES")),::rtl::OUString::valueOf(nDataPages));
1605                 X_PARAM(sDBName,_rDBInfo.sControlUser,_rDBInfo.sControlPassword,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("BCHECK")));
1606             }
1607         }
1608     }
1609 }
1610 // -----------------------------------------------------------------------------
isKernelVersion(const char * _pVersion)1611 sal_Bool ODriver::isKernelVersion(const char* _pVersion)
1612 {
1613     ::utl::TempFile aCmdFile(String::CreateFromAscii("KernelVersion"));
1614     aCmdFile.EnableKillingFile();
1615 
1616     String sPhysicalPath;
1617     LocalFileHelper::ConvertURLToPhysicalName(aCmdFile.GetURL(),sPhysicalPath);
1618 
1619     String sCommandFile = generateInitFile();
1620     {
1621         ::std::auto_ptr<SvStream> pFileStream( UcbStreamHelper::CreateStream(sCommandFile,STREAM_STD_READWRITE));
1622         pFileStream->Seek(STREAM_SEEK_TO_END);
1623 
1624         (*pFileStream)  << "dbversion"
1625                         << " > "
1626                         << sPhysicalPath
1627                         << sNewLine;
1628     }
1629 
1630     OProcess aApp(sCommandFile ,m_sDbWorkURL);
1631     aApp.execute( (OProcess::TProcessOption)OPROCESS_ADABAS);
1632 #if OSL_DEBUG_LEVEL < 2
1633     if(UCBContentHelper::Exists(sCommandFile))
1634         UCBContentHelper::Kill(sCommandFile);
1635 #endif
1636     SvStream* pFileStream = aCmdFile.GetStream(STREAM_STD_READWRITE);
1637     ByteString sStateLine;
1638     sal_Bool bRead = sal_True;
1639     sal_Bool bIsVersion = sal_True;
1640     while ( pFileStream && bRead && !pFileStream->IsEof() )
1641     {
1642         bRead = pFileStream->ReadLine(sStateLine);
1643         if ( bRead )
1644         {
1645             // convert a 11.02.00 to a 12.01.30 version
1646             bIsVersion = sStateLine.GetToken(0).Equals(_pVersion) != 0;
1647             break;
1648         }
1649     }
1650     return bIsVersion;
1651 }
1652 // -----------------------------------------------------------------------------
installSystemTables(const TDatabaseStruct & _aInfo)1653 void ODriver::installSystemTables(  const TDatabaseStruct& _aInfo)
1654 {
1655 #if defined(WNT)
1656     //  xutil -d %_DBNAME% -u %_CONTROL_USER%,%_CONTROL_PWD% -b %m_sDbRoot%\env\TERMCHAR.ind
1657     ::rtl::OUString aBatch =  ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("-b "));
1658     ::rtl::OUString sTemp2 = m_sDbRootURL   + m_sDelimit
1659                                             + ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("env"))
1660                                             + m_sDelimit
1661                                             + ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("TERMCHAR.ind"));
1662     String sTemp;
1663     sal_Bool bOk = LocalFileHelper::ConvertURLToPhysicalName(sTemp2,sTemp);
1664     aBatch += sTemp;
1665 
1666     XUTIL(aBatch,_aInfo.sDBName,_aInfo.sControlUser,_aInfo.sControlPassword);
1667 
1668     //  xutil -d %_DBNAME% -u %_CONTROL_USER%,%_CONTROL_PWD% DIAGNOSE TRIGGER OFF
1669     XUTIL(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DIAGNOSE TRIGGER OFF")),_aInfo.sDBName,_aInfo.sControlUser,_aInfo.sControlPassword);
1670     //  xload -d %_DBNAME% -u %_SYSDBA_USER%,%_SYSDBA_PWD% -S NATIVE -b %m_sDbRoot%\env\DBS.ins %_DOMAINPWD%
1671     {
1672         sTemp2 = m_sDbRootURL
1673                                 + ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("env"))
1674                                 + m_sDelimit
1675                                 + ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DBS.ins"));
1676         sTemp.Erase();
1677         bOk = LocalFileHelper::ConvertURLToPhysicalName(sTemp2,sTemp);
1678         OSL_ENSURE(bOk,"File could be converted into file system path!");
1679         sTemp.AppendAscii(" ");
1680         sTemp += String(_aInfo.sDomainPassword);
1681 
1682         LoadBatch(_aInfo.sDBName,_aInfo.sSysUser,_aInfo.sSysPassword,sTemp);
1683     }
1684     //  xload -d %_DBNAME% -u DOMAIN,%_DOMAINPWD% -S NATIVE -b %m_sDbRoot%\env\XDD.ins
1685     {
1686         sTemp2 = m_sDbRootURL
1687                                 + ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("env"))
1688                                 + m_sDelimit
1689                                 + ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("XDD.ins"));
1690         sTemp.Erase();
1691         bOk = LocalFileHelper::ConvertURLToPhysicalName(sTemp2,sTemp);
1692         OSL_ENSURE(bOk,"File could be converted into file system path!");
1693 
1694         LoadBatch(_aInfo.sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DOMAIN")),_aInfo.sDomainPassword,sTemp);
1695     }
1696     //  xload -d %_DBNAME% -u %_SYSDBA_USER%,%_SYSDBA_PWD% -S NATIVE -b %m_sDbRoot%\env\QP.ins
1697     {
1698         sTemp2 = m_sDbRootURL
1699                                 + ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("env"))
1700                                 + m_sDelimit
1701                                 + ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("QP.ins"));
1702         sTemp.Erase();
1703         bOk = LocalFileHelper::ConvertURLToPhysicalName(sTemp2,sTemp);
1704         OSL_ENSURE(bOk,"File could be converted into file system path!");
1705         LoadBatch(_aInfo.sDBName,_aInfo.sSysUser,_aInfo.sSysPassword,sTemp);
1706     }
1707     //  xload  -d %_DBNAME% -u DOMAIN,%_DOMAINPWD% -S NATIVE -b %m_sDbRoot%\env\SPROC.ins
1708     {
1709         sTemp2 = m_sDbRootURL
1710                                 + ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("env"))
1711                                 + m_sDelimit
1712                                 + ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SPROC.ins"));
1713         sTemp.Erase();
1714         bOk = LocalFileHelper::ConvertURLToPhysicalName(sTemp2,sTemp);
1715         OSL_ENSURE(bOk,"File could be converted into file system path!");
1716 
1717         LoadBatch(_aInfo.sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DOMAIN")),_aInfo.sDomainPassword,sTemp);
1718     }
1719 
1720     //  xutil -d %_DBNAME% -u %_CONTROL_USER%,%_CONTROL_PWD%  DIAGNOSE TRIGGER ON
1721     XUTIL(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DIAGNOSE TRIGGER ON")),_aInfo.sDBName,_aInfo.sControlUser,_aInfo.sControlPassword);
1722     //  xutil -d %_DBNAME% -u %_CONTROL_USER%,%_CONTROL_PWD%  SET NOLOG OFF
1723     XUTIL(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SET NOLOG OFF")),_aInfo.sDBName,_aInfo.sControlUser,_aInfo.sControlPassword);
1724     //  xutil -d %_DBNAME% -u %_CONTROL_USER%,%_CONTROL_PWD%  SHUTDOWN QUICK
1725     XUTIL(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SHUTDOWN QUICK")),_aInfo.sDBName,_aInfo.sControlUser,_aInfo.sControlPassword);
1726     //  xutil -d %_DBNAME% -u %_CONTROL_USER%,%_CONTROL_PWD%  RESTART
1727     XUTIL(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("RESTART")),_aInfo.sDBName,_aInfo.sControlUser,_aInfo.sControlPassword);
1728 
1729 #else // UNX
1730     String sCommandFile = generateInitFile();
1731     {
1732         ::std::auto_ptr<SvStream> pFileStream( UcbStreamHelper::CreateStream(sCommandFile,STREAM_STD_READWRITE));
1733         pFileStream->Seek(STREAM_SEEK_TO_END);
1734         (*pFileStream)  << "x_dbinst"
1735                         << " -d "
1736                         << _aInfo.sDBName
1737                         << " -u "
1738                         << _aInfo.sSysUser
1739                         << ","
1740                         << _aInfo.sSysPassword
1741                         << " -w "
1742                         << _aInfo.sDomainPassword
1743                         << " -b ";
1744 
1745         if ( isKernelVersion(ADABAS_KERNEL_11) )
1746             (*pFileStream) << "-i all";
1747         (*pFileStream)
1748 #if (OSL_DEBUG_LEVEL > 1) || defined(DBG_UTIL)
1749                     << " >> /tmp/kstart.log"
1750 #else
1751                     << " > /dev/null"
1752 #endif
1753                         << sNewLine
1754                         << sNewLine;
1755         pFileStream->Flush();
1756     }
1757     // now execute the command
1758     OProcess aApp(sCommandFile ,m_sDbWorkURL);
1759     aApp.execute( (OProcess::TProcessOption)(OProcess::TOption_Hidden | OProcess::TOption_Wait));
1760 #if OSL_DEBUG_LEVEL < 2
1761     if(UCBContentHelper::Exists(sCommandFile))
1762         UCBContentHelper::Kill(sCommandFile);
1763 #endif
1764 
1765 #endif //WNT,UNX
1766 }
1767 // -----------------------------------------------------------------------------
convertOldVersion(const::rtl::OUString & sDBName,const TDatabaseStruct & _rDbInfo)1768 void ODriver::convertOldVersion(const ::rtl::OUString& sDBName,const TDatabaseStruct& _rDbInfo)
1769 {
1770     // first we have to check if this database is a old version and we have to update the system tables
1771     if ( !isVersion(sDBName,CURRENT_DB_VERSION) && isKernelVersion(CURRENT_DB_VERSION) )
1772     {
1773         if (    !_rDbInfo.sControlUser.getLength()
1774             ||  !_rDbInfo.sControlPassword.getLength())
1775         {
1776             ::connectivity::SharedResources aResources;
1777             const ::rtl::OUString sError( aResources.getResourceString(STR_DATABASE_NEEDS_CONVERTING) );
1778             ::dbtools::throwGenericSQLException(sError,*this);
1779         }
1780         String sCommandFile = m_sDbWorkURL;
1781         sCommandFile += String::CreateFromAscii("/xparam.prt");
1782         if ( UCBContentHelper::Exists(sCommandFile) )
1783             UCBContentHelper::Kill(sCommandFile);
1784         X_PARAM(sDBName,_rDbInfo.sControlUser,_rDbInfo.sControlPassword,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("BCHECK")));
1785 
1786         if ( UCBContentHelper::Exists(sCommandFile) )
1787         {
1788             {
1789                 ::std::auto_ptr<SvStream> pFileStream( UcbStreamHelper::CreateStream(sCommandFile,STREAM_STD_READ) );
1790                 ByteString sStateLine;
1791                 sal_Bool bRead = sal_True;
1792                 static ByteString s_ErrorId("-21100");
1793                 while ( pFileStream.get() && bRead && !pFileStream->IsEof() )
1794                 {
1795                     bRead = pFileStream->ReadLine(sStateLine);
1796                     if ( bRead && s_ErrorId == sStateLine.GetToken(0,' ') )
1797                     {
1798                         UCBContentHelper::Kill(sCommandFile);
1799                         ::rtl::OUString sError(::rtl::OUString::createFromAscii(sStateLine.GetBuffer()));
1800                         throw SQLException(sError,*this,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("S1000")),1000,Any());
1801                     }
1802                 }
1803             }
1804 
1805             UCBContentHelper::Kill(sCommandFile);
1806         }
1807     }
1808 }
1809 // -----------------------------------------------------------------------------
1810 // -----------------------------------------------------------------------------
1811     } // namespace adabas
1812 }// namespace connectivity
1813 // -----------------------------------------------------------------------------
1814