src/corelib/plugin/qlibrary.cpp File Reference

#include "qplatformdefs.h"
#include "qlibrary.h"
#include "qlibrary_p.h"
#include <qstringlist.h>
#include <qfile.h>
#include <qfileinfo.h>
#include <qmutex.h>
#include <qmap.h>
#include <qsettings.h>
#include <qdatetime.h>
#include <errno.h>
#include <qdebug.h>
#include <qvector.h>

Include dependency graph for qlibrary.cpp:

Go to the source code of this file.

Classes
struct	qt_token_info
Defines
#define	QLIBRARY_AS_DEBUG   true
#define	QT_NO_DEBUG_PLUGIN_CHECK
Typedefs
typedef QMap< QString, QLibraryPrivate * >	LibraryMap
Functions
static int	qt_tokenize (const char *s, ulong s_len, ulong *advance, qt_token_info &token_info)
static bool	qt_parse_pattern (const char *s, uint *version, bool *debug, QByteArray *key)
static long	qt_find_pattern (const char *s, ulong s_len, const char *pattern, ulong p_len)
static bool	qt_unix_query (const QString &library, uint *version, bool *debug, QByteArray *key, QLibraryPrivate *lib=0)
bool	qt_debug_component ()

---

Define Documentation

#define QLIBRARY_AS_DEBUG   true

Definition at line 51 of file qlibrary.cpp.

Referenced by QLibraryPrivate::isPlugin().

#define QT_NO_DEBUG_PLUGIN_CHECK

Definition at line 57 of file qlibrary.cpp.

---

Typedef Documentation

typedef QMap<QString, QLibraryPrivate*> LibraryMap

Definition at line 401 of file qlibrary.cpp.

---

Function Documentation

bool qt_debug_component

(

)

Definition at line 985 of file qlibrary.cpp.

References qgetenv().

Referenced by QLibraryPrivate::isPlugin(), QFactoryLoader::QFactoryLoader(), qt_unix_query(), and QPluginLoader::setFileName().

{
#if defined(QT_DEBUG_COMPONENT)
    return true;    //compatibility?
#else
    static int debug_env = -1;
    if (debug_env == -1)
       debug_env = ::qgetenv("QT_DEBUG_PLUGINS").toInt();

    return debug_env != 0;
#endif
}

Here is the call graph for this function:

static long qt_find_pattern	(	const char *	s,
		ulong	s_len,
		const char *	pattern,
		ulong	p_len
	)			[static]

Definition at line 284 of file qlibrary.cpp.

References i, and QByteArray::qstrncmp().

Referenced by qt_unix_query().

{
    /*
      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 && qstrncmp(s + i, pattern, p_len) == 0)
            return i;
        if (i == 0)
            break;
        --i;
        hs -= s[i + p_len];
        hs += s[i];
    }

    return -1;
}

Here is the call graph for this function:

static bool qt_parse_pattern	(	const char *	s,
		uint *	version,
		bool *	debug,
		QByteArray *	key
	)			[static]

Definition at line 234 of file qlibrary.cpp.

References key, qt_token_info::lengths, m, n, p, parse(), QByteArray::qstrlen(), QByteArray::qstrncmp(), qt_tokenize(), and qt_token_info::results.

Referenced by QLibraryPrivate::isPlugin(), and qt_unix_query().

{
    bool ret = true;

    qt_token_info pinfo("=\n", 2);
    int parse;
    ulong at = 0, advance, parselen = qstrlen(s);
    do {
        parse = qt_tokenize(s + at, parselen, &advance, pinfo);
        if (parse == -1) {
            ret = false;
            break;
        }

        at += advance;
        parselen -= advance;

        if (qstrncmp("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) {
                QByteArray m(pinfo2.results[0], pinfo2.lengths[0]);
                QByteArray n(pinfo2.results[1], pinfo2.lengths[1]);
                QByteArray p(pinfo2.results[2], pinfo2.lengths[2]);
                *version  = (m.toUInt() << 16) | (n.toUInt() << 8) | p.toUInt();
            } else {
                ret = false;
                break;
            }
        } else if (qstrncmp("debug", pinfo.results[0], pinfo.lengths[0]) == 0) {
            *debug = qstrncmp("true", pinfo.results[1], pinfo.lengths[1]) == 0;
        } else if (qstrncmp("buildkey", pinfo.results[0],
                              pinfo.lengths[0]) == 0){
            // save buildkey
            *key = QByteArray(pinfo.results[1], pinfo.lengths[1] + 1);
        }
    } while (parse == 1 && parselen > 0);

    return ret;
}

Here is the call graph for this function:

static int qt_tokenize	(	const char *	s,
		ulong	s_len,
		ulong *	advance,
		qt_token_info &	token_info
	)			[static]

Definition at line 179 of file qlibrary.cpp.

References qt_token_info::field_count, qt_token_info::fields, qt_token_info::lengths, and qt_token_info::results.

Referenced by qt_parse_pattern().

{
    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;
}

static bool qt_unix_query	(	const QString &	library,
		uint *	version,
		bool *	debug,
		QByteArray *	key,
		QLibraryPrivate *	lib = 0
	)			[static]

Definition at line 330 of file qlibrary.cpp.

References QFile::close(), data, QFile::encodeName(), QIODevice::errorString(), QFile::handle(), key, library, MAP_FAILED, QFile::open(), QByteArray::qstrlen(), qt_debug_component(), qt_error_string(), qt_find_pattern(), qt_parse_pattern(), qWarning(), QIODevice::readAll(), QIODevice::ReadOnly, and QFile::size().

Referenced by QLibraryPrivate::isPlugin().

{
    QFile file(library);
    if (!file.open(QIODevice::ReadOnly)) {
        if (lib)
            lib->errorString = file.errorString();
        if (qt_debug_component()) {
            qWarning("%s: %s", (const char*) QFile::encodeName(library),
                qPrintable(qt_error_string(errno)));
        }
        return false;
    }

    QByteArray 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
        if (qt_debug_component()) {
            qWarning("mmap: %s", qPrintable(qt_error_string(errno)));
        }
        if (lib)
            lib->errorString = QLibrary::tr("Could not mmap '%1': %2")
                .arg(library)
                .arg(qt_error_string());
#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_PLUGIN_VERIFICATION_DATA";
    const ulong plen = qstrlen(pattern);
    long pos = qt_find_pattern(filedata, fdlen, pattern, plen);

    bool ret = false;
    if (pos >= 0)
        ret = qt_parse_pattern(filedata + pos, version, debug, key);

    if (!ret && lib)
        lib->errorString = QLibrary::tr("Plugin verification data mismatch in '%1'").arg(library);
#ifdef USE_MMAP
    if (mapaddr != MAP_FAILED && munmap(mapaddr, maplen) != 0) {
        if (qt_debug_component())
            qWarning("munmap: %s", qPrintable(qt_error_string(errno)));
        if (lib)
            lib->errorString = QLibrary::tr("Could not unmap '%1': %2")
                .arg(library)
                .arg( qt_error_string() );
    }
#endif // USE_MMAP

    file.close();
    return ret;
}

Here is the call graph for this function:

---