You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
539 lines
14 KiB
539 lines
14 KiB
/****************************************************************************
|
|
**
|
|
** Implementation of TQComLibrary class
|
|
**
|
|
** Copyright (C) 2001-2008 Trolltech ASA. All rights reserved.
|
|
**
|
|
** This file is part of the tools module of the TQt GUI Toolkit.
|
|
**
|
|
** This file may be used under the terms of the GNU General
|
|
** Public License versions 2.0 or 3.0 as published by the Free
|
|
** Software Foundation and appearing in the files LICENSE.GPL2
|
|
** and LICENSE.GPL3 included in the packaging of this file.
|
|
** Alternatively you may (at your option) use any later version
|
|
** of the GNU General Public License if such license has been
|
|
** publicly approved by Trolltech ASA (or its successors, if any)
|
|
** and the KDE Free TQt Foundation.
|
|
**
|
|
** Please review the following information to ensure GNU General
|
|
** Public Licensing requirements will be met:
|
|
** http://trolltech.com/products/qt/licenses/licensing/opensource/.
|
|
** If you are unsure which license is appropriate for your use, please
|
|
** review the following information:
|
|
** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
|
|
** or contact the sales department at sales@trolltech.com.
|
|
**
|
|
** This file may be used under the terms of the Q Public License as
|
|
** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
|
|
** included in the packaging of this file. Licensees holding valid TQt
|
|
** Commercial licenses may use this file in accordance with the TQt
|
|
** Commercial License Agreement provided with the Software.
|
|
**
|
|
** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
|
|
** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
|
|
** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
|
|
** herein.
|
|
**
|
|
**********************************************************************/
|
|
|
|
#include "qcomlibrary_p.h"
|
|
|
|
#ifndef TQT_NO_COMPONENT
|
|
#include <ntqapplication.h>
|
|
#include <ntqsettings.h>
|
|
#include <ntqfileinfo.h>
|
|
#include <ntqdatetime.h>
|
|
#include <ntqcleanuphandler.h>
|
|
#ifndef NO_ERRNO_H
|
|
#include <errno.h>
|
|
#endif // NO_ERROR_H
|
|
|
|
#ifdef TQT_THREAD_SUPPORT
|
|
# include "qmutexpool_p.h"
|
|
#endif // TQT_THREAD_SUPPORT
|
|
|
|
#ifndef QT_DEBUG_COMPONENT
|
|
# if defined(QT_DEBUG)
|
|
# define QT_DEBUG_COMPONENT 1
|
|
# endif
|
|
#endif
|
|
|
|
|
|
TQComLibrary::TQComLibrary( const TQString &filename )
|
|
: TQLibrary( filename ), entry( 0 ), libiface( 0 ), qt_version( 0 )
|
|
{
|
|
}
|
|
|
|
TQComLibrary::~TQComLibrary()
|
|
{
|
|
if ( autoUnload() )
|
|
unload();
|
|
if ( libiface )
|
|
libiface->release();
|
|
if ( entry )
|
|
entry->release();
|
|
}
|
|
|
|
bool TQComLibrary::unload()
|
|
{
|
|
int refs = entry ? entry->release() : 0;
|
|
entry = 0;
|
|
if (refs || !libiface)
|
|
return FALSE;
|
|
|
|
libiface->cleanup();
|
|
if ( !libiface->canUnload() )
|
|
return FALSE;
|
|
libiface->release();
|
|
libiface = 0;
|
|
|
|
return TQLibrary::unload();
|
|
}
|
|
|
|
static bool qt_verify( const TQString& library, uint version, uint flags,
|
|
const TQCString &key, bool warn )
|
|
{
|
|
uint our_flags = 1;
|
|
#if defined(TQT_THREAD_SUPPORT)
|
|
our_flags |= 2;
|
|
#endif
|
|
|
|
if ( (flags & 1) == 0 ) {
|
|
if ( warn )
|
|
tqWarning( "Conflict in %s:\n"
|
|
" Plugin cannot be queried successfully!",
|
|
(const char*) TQFile::encodeName(library) );
|
|
} else if ( ( version > TQT_VERSION ) ||
|
|
( ( TQT_VERSION & 0xff0000 ) > ( version & 0xff0000 ) ) ) {
|
|
if ( warn )
|
|
tqWarning( "Conflict in %s:\n"
|
|
" Plugin uses incompatible TQt library (%d.%d.%d)!",
|
|
(const char*) TQFile::encodeName(library),
|
|
(version&0xff0000) >> 16, (version&0xff00) >> 8, version&0xff );
|
|
} else if ( (flags & 2) != (our_flags & 2) ) {
|
|
if ( warn )
|
|
tqWarning( "Conflict in %s:\n"
|
|
" Plugin uses %s TQt library!",
|
|
(const char*) TQFile::encodeName(library),
|
|
(flags & 2) ? "multi threaded" : "single threaded" );
|
|
} else if ( key != TQT_BUILD_KEY ) {
|
|
if ( warn )
|
|
tqWarning( "Conflict in %s:\n"
|
|
" Plugin uses incompatible TQt library!\n"
|
|
" expected build key \"%s\", got \"%s\".",
|
|
(const char*) TQFile::encodeName(library),
|
|
TQT_BUILD_KEY,
|
|
key.isEmpty() ? "<null>" : (const char *) key );
|
|
} else {
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
struct qt_token_info
|
|
{
|
|
qt_token_info( const char *f, const ulong fc )
|
|
: fields( f ), field_count( fc ), results( fc ), lengths( fc )
|
|
{
|
|
results.fill( 0 );
|
|
lengths.fill( 0 );
|
|
}
|
|
|
|
const char *fields;
|
|
const ulong field_count;
|
|
|
|
TQMemArray<const char *> results;
|
|
TQMemArray<ulong> lengths;
|
|
};
|
|
|
|
/*
|
|
return values:
|
|
1 parse ok
|
|
0 eos
|
|
-1 parse error
|
|
*/
|
|
static int qt_tokenize( const char *s, ulong s_len, ulong *advance,
|
|
const qt_token_info &token_info )
|
|
{
|
|
ulong pos = 0, field = 0, fieldlen = 0;
|
|
char current;
|
|
int ret = -1;
|
|
*advance = 0;
|
|
for (;;) {
|
|
current = s[ pos ];
|
|
|
|
// next char
|
|
++pos;
|
|
++fieldlen;
|
|
++*advance;
|
|
|
|
if ( ! current || pos == s_len + 1 ) {
|
|
// save result
|
|
token_info.results[ (int)field ] = s;
|
|
token_info.lengths[ (int)field ] = fieldlen - 1;
|
|
|
|
// end of string
|
|
ret = 0;
|
|
break;
|
|
}
|
|
|
|
if ( current == token_info.fields[ field ] ) {
|
|
// save result
|
|
token_info.results[ (int)field ] = s;
|
|
token_info.lengths[ (int)field ] = fieldlen - 1;
|
|
|
|
// end of field
|
|
fieldlen = 0;
|
|
++field;
|
|
if ( field == token_info.field_count - 1 ) {
|
|
// parse ok
|
|
ret = 1;
|
|
}
|
|
if ( field == token_info.field_count ) {
|
|
// done parsing
|
|
break;
|
|
}
|
|
|
|
// reset string and its length
|
|
s = s + pos;
|
|
s_len -= pos;
|
|
pos = 0;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
returns TRUE if the string s was correctly parsed, FALSE otherwise.
|
|
*/
|
|
static bool qt_parse_pattern( const char *s, uint *version, uint *flags,
|
|
TQCString *key )
|
|
{
|
|
bool ret = TRUE;
|
|
|
|
qt_token_info pinfo("=\n", 2);
|
|
int parse;
|
|
ulong at = 0, advance, parselen = tqstrlen( s );
|
|
do {
|
|
parse = qt_tokenize( s + at, parselen, &advance, pinfo );
|
|
if ( parse == -1 ) {
|
|
ret = FALSE;
|
|
break;
|
|
}
|
|
|
|
at += advance;
|
|
parselen -= advance;
|
|
|
|
if ( tqstrncmp( "version", pinfo.results[ 0 ], pinfo.lengths[ 0 ] ) == 0 ) {
|
|
// parse version string
|
|
qt_token_info pinfo2("..-", 3);
|
|
if ( qt_tokenize( pinfo.results[ 1 ], pinfo.lengths[ 1 ],
|
|
&advance, pinfo2 ) != -1 ) {
|
|
TQCString m( pinfo2.results[ 0 ], pinfo2.lengths[ 0 ] + 1 );
|
|
TQCString n( pinfo2.results[ 1 ], pinfo2.lengths[ 1 ] + 1 );
|
|
TQCString p( pinfo2.results[ 2 ], pinfo2.lengths[ 2 ] + 1 );
|
|
*version = (m.toUInt() << 16) | (n.toUInt() << 8) | p.toUInt();
|
|
} else {
|
|
ret = FALSE;
|
|
break;
|
|
}
|
|
} else if ( tqstrncmp( "flags", pinfo.results[ 0 ], pinfo.lengths[ 0 ] ) == 0 ) {
|
|
// parse flags string
|
|
char ch;
|
|
*flags = 0;
|
|
ulong p = 0, c = 0, bit = 0;
|
|
while ( p < pinfo.lengths[ 1 ] ) {
|
|
ch = pinfo.results[ 1 ][ p ];
|
|
bit = pinfo.lengths[ 1 ] - p - 1;
|
|
c = 1 << bit;
|
|
if ( ch == '1' ) {
|
|
*flags |= c;
|
|
} else if ( ch != '0' ) {
|
|
ret = FALSE;
|
|
break;
|
|
}
|
|
++p;
|
|
}
|
|
} else if ( tqstrncmp( "buildkey", pinfo.results[ 0 ],
|
|
pinfo.lengths[ 0 ] ) == 0 ){
|
|
// save buildkey
|
|
*key = TQCString( pinfo.results[ 1 ], pinfo.lengths[ 1 ] + 1 );
|
|
}
|
|
} while ( parse == 1 && parselen > 0 );
|
|
|
|
return ret;
|
|
}
|
|
|
|
#if defined(Q_OS_UNIX)
|
|
|
|
#if defined(Q_OS_FREEBSD) || defined(Q_OS_LINUX)
|
|
# define USE_MMAP
|
|
# include <sys/types.h>
|
|
# include <sys/mman.h>
|
|
#endif // Q_OS_FREEBSD || Q_OS_LINUX
|
|
|
|
static long qt_find_pattern( const char *s, ulong s_len,
|
|
const char *pattern, ulong p_len )
|
|
{
|
|
/*
|
|
this uses the same algorithm as TQString::findRev...
|
|
|
|
we search from the end of the file because on the supported
|
|
systems, the read-only data/text segments are placed at the end
|
|
of the file. HOWEVER, when building with debugging enabled, all
|
|
the debug symbols are placed AFTER the data/text segments.
|
|
|
|
what does this mean? when building in release mode, the search
|
|
is fast because the data we are looking for is at the end of the
|
|
file... when building in debug mode, the search is slower
|
|
because we have to skip over all the debugging symbols first
|
|
*/
|
|
|
|
if ( ! s || ! pattern || p_len > s_len ) return -1;
|
|
ulong i, hs = 0, hp = 0, delta = s_len - p_len;
|
|
|
|
for (i = 0; i < p_len; ++i ) {
|
|
hs += s[delta + i];
|
|
hp += pattern[i];
|
|
}
|
|
i = delta;
|
|
for (;;) {
|
|
if ( hs == hp && tqstrncmp( s + i, pattern, p_len ) == 0 )
|
|
return i;
|
|
if ( i == 0 )
|
|
break;
|
|
--i;
|
|
hs -= s[i + p_len];
|
|
hs += s[i];
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
This opens the specified library, mmaps it into memory, and searches
|
|
for the QT_UCM_VERIFICATION_DATA. The advantage of this approach is that
|
|
we can get the verification data without have to actually load the library.
|
|
This lets us detect mismatches more safely.
|
|
|
|
Returns FALSE if version/flags/key information is not present, or if the
|
|
information could not be read.
|
|
Returns TRUE if version/flags/key information is present and succesfully read.
|
|
*/
|
|
static bool qt_unix_query( const TQString &library, uint *version, uint *flags,
|
|
TQCString *key )
|
|
{
|
|
TQFile file( library );
|
|
if (! file.open( IO_ReadOnly ) ) {
|
|
tqWarning( "%s: %s", (const char*) TQFile::encodeName(library),
|
|
strerror( errno ) );
|
|
return FALSE;
|
|
}
|
|
|
|
TQByteArray data;
|
|
char *filedata = 0;
|
|
ulong fdlen = 0;
|
|
|
|
#ifdef USE_MMAP
|
|
char *mapaddr = 0;
|
|
size_t maplen = file.size();
|
|
mapaddr = (char *) mmap( mapaddr, maplen, PROT_READ, MAP_PRIVATE, file.handle(), 0 );
|
|
if ( mapaddr != MAP_FAILED ) {
|
|
// mmap succeeded
|
|
filedata = mapaddr;
|
|
fdlen = maplen;
|
|
} else {
|
|
// mmap failed
|
|
tqWarning( "mmap: %s", strerror( errno ) );
|
|
#endif // USE_MMAP
|
|
// try reading the data into memory instead
|
|
data = file.readAll();
|
|
filedata = data.data();
|
|
fdlen = data.size();
|
|
#ifdef USE_MMAP
|
|
}
|
|
#endif // USE_MMAP
|
|
|
|
// verify that the pattern is present in the plugin
|
|
const char *pattern = "pattern=QT_UCM_VERIFICATION_DATA";
|
|
const ulong plen = tqstrlen( pattern );
|
|
long pos = qt_find_pattern( filedata, fdlen, pattern, plen );
|
|
|
|
bool ret = FALSE;
|
|
if ( pos >= 0 ) {
|
|
ret = qt_parse_pattern( filedata + pos, version, flags, key );
|
|
}
|
|
|
|
#ifdef USE_MMAP
|
|
if ( mapaddr != MAP_FAILED && munmap(mapaddr, maplen) != 0 ) {
|
|
tqWarning( "munmap: %s", strerror( errno ) );
|
|
}
|
|
#endif // USE_MMAP
|
|
|
|
file.close();
|
|
return ret;
|
|
}
|
|
|
|
#endif // Q_OS_UNIX
|
|
|
|
|
|
static TQSettings *cache = 0;
|
|
static TQSingleCleanupHandler<TQSettings> cleanup_cache;
|
|
|
|
void TQComLibrary::createInstanceInternal()
|
|
{
|
|
if ( library().isEmpty() )
|
|
return;
|
|
|
|
TQFileInfo fileinfo( library() );
|
|
TQString lastModified = fileinfo.lastModified().toString(TQt::ISODate);
|
|
TQString regkey = TQString("/TQt Plugins %1.%2/%3")
|
|
.arg( ( TQT_VERSION & 0xff0000 ) >> 16 )
|
|
.arg( ( TQT_VERSION & 0xff00 ) >> 8 )
|
|
.arg( library() );
|
|
TQStringList reg;
|
|
uint flags = 0;
|
|
TQCString key;
|
|
bool query_done = FALSE;
|
|
bool warn_mismatch = TRUE;
|
|
|
|
#ifdef TQT_THREAD_SUPPORT
|
|
TQMutexLocker locker( tqt_global_mutexpool ?
|
|
tqt_global_mutexpool->get( &cache ) : 0 );
|
|
#endif // TQT_THREAD_SUPPORT
|
|
|
|
if ( ! cache ) {
|
|
cache = new TQSettings;
|
|
cache->insertSearchPath( TQSettings::Windows, "/Trolltech" );
|
|
cleanup_cache.set( &cache );
|
|
}
|
|
|
|
reg = cache->readListEntry( regkey );
|
|
if ( reg.count() == 4 ) {
|
|
// check timestamp
|
|
if ( lastModified == reg[3] ) {
|
|
qt_version = reg[0].toUInt(0, 16);
|
|
flags = reg[1].toUInt(0, 16);
|
|
key = reg[2].latin1();
|
|
|
|
query_done = TRUE;
|
|
warn_mismatch = FALSE;
|
|
}
|
|
}
|
|
|
|
#if defined(Q_OS_UNIX)
|
|
if ( ! query_done ) {
|
|
// get the query information directly from the plugin without loading
|
|
if ( qt_unix_query( library(), &qt_version, &flags, &key ) ) {
|
|
// info read succesfully from library
|
|
query_done = TRUE;
|
|
}
|
|
}
|
|
#else // !Q_OS_UNIX
|
|
if ( ! query_done ) {
|
|
// get the query information by loading the plugin
|
|
if ( !isLoaded() ) {
|
|
Q_ASSERT( entry == 0 );
|
|
if ( !load() )
|
|
return;
|
|
}
|
|
|
|
# ifdef Q_CC_BOR
|
|
typedef const char * __stdcall (*UCMQueryVerificationDataProc)();
|
|
# else
|
|
typedef const char * (*UCMQueryVerificationDataProc)();
|
|
# endif
|
|
UCMQueryVerificationDataProc ucmQueryVerificationdataProc;
|
|
ucmQueryVerificationdataProc =
|
|
(UCMQueryVerificationDataProc) resolve( "qt_ucm_query_verification_data" );
|
|
|
|
if ( !ucmQueryVerificationdataProc ||
|
|
!qt_parse_pattern( ucmQueryVerificationdataProc(),
|
|
&qt_version, &flags, &key ) ) {
|
|
qt_version = flags = 0;
|
|
key = "unknown";
|
|
} else {
|
|
query_done = TRUE;
|
|
}
|
|
}
|
|
#endif // Q_OS_UNIX
|
|
|
|
TQStringList queried;
|
|
queried << TQString::number( qt_version,16 )
|
|
<< TQString::number( flags, 16 )
|
|
<< key
|
|
<< lastModified;
|
|
|
|
if ( queried != reg ) {
|
|
cache->writeEntry( regkey, queried );
|
|
// delete the cache, which forces the settings to be written
|
|
delete cache;
|
|
cache = 0;
|
|
}
|
|
|
|
if ( ! query_done ) {
|
|
if ( warn_mismatch ) {
|
|
tqWarning( "Conflict in %s:\n Plugin cannot be queried successfully!",
|
|
(const char*) TQFile::encodeName( library() ) );
|
|
}
|
|
unload();
|
|
return;
|
|
}
|
|
|
|
if ( ! qt_verify( library(), qt_version, flags, key, warn_mismatch ) ) {
|
|
unload();
|
|
return;
|
|
} else if ( !isLoaded() ) {
|
|
Q_ASSERT( entry == 0 );
|
|
if ( !load() )
|
|
return;
|
|
}
|
|
|
|
#ifdef Q_CC_BOR
|
|
typedef TQUnknownInterface* __stdcall (*UCMInstanceProc)();
|
|
#else
|
|
typedef TQUnknownInterface* (*UCMInstanceProc)();
|
|
#endif
|
|
UCMInstanceProc ucmInstanceProc;
|
|
ucmInstanceProc = (UCMInstanceProc) resolve( "ucm_instantiate" );
|
|
#if defined(QT_DEBUG_COMPONENT)
|
|
if ( !ucmInstanceProc )
|
|
tqWarning( "%s: Not a UCOM library.", (const char*) TQFile::encodeName(library()) );
|
|
#endif
|
|
entry = ucmInstanceProc ? ucmInstanceProc() : 0;
|
|
|
|
if ( entry ) {
|
|
if ( entry->queryInterface( IID_QLibrary, (TQUnknownInterface**)&libiface ) == TQS_OK ) {
|
|
if ( libiface && !libiface->init() ) {
|
|
libiface->release();
|
|
libiface = 0;
|
|
unload();
|
|
return;
|
|
}
|
|
}
|
|
} else {
|
|
#if defined(QT_DEBUG_COMPONENT)
|
|
tqWarning( "%s: No exported component provided.", (const char*) TQFile::encodeName(library()) );
|
|
#endif
|
|
unload();
|
|
}
|
|
}
|
|
|
|
TQRESULT TQComLibrary::queryInterface( const TQUuid& request, TQUnknownInterface** iface )
|
|
{
|
|
if ( !entry )
|
|
createInstanceInternal();
|
|
return entry ? entry->queryInterface( request, iface ) : TQE_NOCOMPONENT;
|
|
}
|
|
|
|
uint TQComLibrary::qtVersion()
|
|
{
|
|
if ( !entry )
|
|
createInstanceInternal();
|
|
return entry ? qt_version : 0;
|
|
}
|
|
|
|
|
|
#endif // TQT_NO_COMPONENT
|