QTransportAuthPrivate Class Reference

#include <qtransportauth_qws_p.h>

Inheritance diagram for QTransportAuthPrivate:

Public Functions
const unsigned char *	getClientKey (unsigned char progId)
	Find client keys for the progId. More...
void	invalidateClientKeyCache ()
	QTransportAuthPrivate ()
	~QTransportAuthPrivate ()
Public Functions inherited from QObjectPrivate
void	_q_reregisterTimers (void *pointer)
void	addConnection (int signal, Connection *c)
void	cleanConnectionLists ()
void	connectNotify (const char *signal)
void	deleteChildren ()
void	disconnectNotify (const char *signal)
bool	isSender (const QObject *receiver, const char *signal) const
bool	isSignalConnected (uint signalIdx) const
	Returns true if the signal with index signal_index from object sender is connected. More...
void	moveToThread_helper ()
	QObjectPrivate (int version=QObjectPrivateVersion)
QObjectList	receiverList (const char *signal) const
QObjectList	senderList () const
void	setParent_helper (QObject *)
void	setThreadData_helper (QThreadData *currentData, QThreadData *targetData)
int	signalIndex (const char *signalName) const
	Returns the signal index used in the internal connectionLists vector. More...
virtual	~QObjectPrivate ()
Public Functions inherited from QObjectData
virtual	~QObjectData ()=0

Public Variables
AuthCookie	authKey
QHash< QObject *, QIODevice * >	buffersByClient
QCache< unsigned char, char >	keyCache
QMutex	keyfileMutex
bool	keyInitialised
QString	m_keyFilePath
QString	m_logFilePath
QObject *	m_packageRegistry
Public Variables inherited from QObjectPrivate
union {
QObject *   currentChildBeingDeleted
QAbstractDeclarativeData *   declarativeData
};
quint32	connectedSignals [2]
QObjectConnectionListVector *	connectionLists
Sender *	currentSender
QList< QPointer< QObject > >	eventFilters
ExtraData *	extraData
QString	objectName
Connection *	senders
QAtomicPointer< QtSharedPointer::ExternalRefCountData >	sharedRefcount
QThreadData *	threadData
void *	unused
Public Variables inherited from QObjectData
uint	blockSig: 1
QObjectList	children
uint	hasGuards: 1
uint	inEventHandler: 1
uint	inThreadChangeEvent: 1
uint	isWidget: 1
QMetaObject *	metaObject
uint	ownObjectName: 1
QObject *	parent
uint	pendTimer: 1
int	postedEvents
QObject *	q_ptr
uint	receiveChildEvents: 1
uint	sendChildEvents: 1
uint	unused: 22
uint	wasDeleted: 1

Additional Inherited Members
Public Types inherited from QObjectPrivate
typedef void(*	StaticMetaCallFunction) (QObject *, QMetaObject::Call, int, void **)
Static Public Functions inherited from QObjectPrivate
static void	clearGuards (QObject *)
static QObjectPrivate *	get (QObject *o)
static void	resetCurrentSender (QObject *receiver, Sender *currentSender, Sender *previousSender)
static Sender *	setCurrentSender (QObject *receiver, Sender *sender)
static void	signalSignature (const QMetaMethod &signal, QVarLengthArray< char > *result)

Detailed Description

Definition at line 141 of file qtransportauth_qws_p.h.

Constructors and Destructors

QTransportAuthPrivate()

QTransportAuthPrivate::QTransportAuthPrivate

(

)

Definition at line 184 of file qtransportauth_qws.cpp.

    : keyInitialised(false)
    , m_packageRegistry( 0 )
{
}

~QTransportAuthPrivate()

QTransportAuthPrivate::~QTransportAuthPrivate

(

)

Definition at line 190 of file qtransportauth_qws.cpp.

{
}

Functions

getClientKey()

const unsigned char * QTransportAuthPrivate::getClientKey

(

unsigned char

progId

)

Find client keys for the progId.

Warning

This function is not part of the public interface. If it is cached should be very fast, otherwise requires a read of the secret key file

In the success case a pointer to the keys is returned. The pointer is to storage allocated for the internal cache and must be used asap.

The list returned is a sequence of one or more keys which match the progId. There is no separator, each 16 byte sequence represents a key. The sequence is followed by two iterations of the SXE magic bytes,eg 0xBA, 0xD4, 0xD4, 0xBA, 0xBA, 0xD4, 0xD4, 0xBA

NULL is returned in the following cases:

• the keyfiles could not be accessed - error condition
• there was no key for the supplied program id - key auth failed

Note that for the keyfiles, there is multi-thread and multi-process concurrency issues: they can be read by the qpe process when QTransportAuth calls getClientKey to verify a request, and they can be read or written by the packagemanager when updating package data.

To protect against this, the keyfileMutex & SxeRegistryLocker is used.

The sxe_installer tool can also update inode and device numbers in the manifest file, but this only occurs outside of normal operation, so qpe and packagemanager are never running when this occurs.

Definition at line 658 of file qtransportauth_qws.cpp.

{
    int manifestMatchCount = 0;
    struct IdBlock mr;
    int total_size = 0;
    char *result = 0;
    char *result_ptr;
    int keysFound = 0;
    bool foundKey;
    int keysRead = 0;
    struct usr_key_entry keys_list[128];

    if ( keyCache.contains( progId ))
        return (const unsigned char *)keyCache[progId];

    SxeRegistryLocker rlock( m_packageRegistry );

    // ### Qt 4.3: this is hacky - see documentation for setKeyFilePath
    QString manifestPath = m_keyFilePath + QLatin1String("/manifest");
    QString actualKeyPath = QLatin1String("/proc/lids/keys");
    bool noFailOnKeyMissing = true;
    if ( !QFile::exists( actualKeyPath )) {
        actualKeyPath = m_keyFilePath + QLatin1String( "/" QSXE_KEYFILE );
    }
    QFile kf( actualKeyPath );
    QFile mn( manifestPath );
    if ( !__fileOpen( &mn ))
        goto key_not_found;
    // first find how much storage is needed
    while ( mn.read( (char*)&mr, sizeof(struct IdBlock)) > 0 )
        if ( mr.progId == progId )
            manifestMatchCount++;
    if ( manifestMatchCount == 0 )
        goto key_not_found;
    if ( !__fileOpen( &kf ))
    {
        noFailOnKeyMissing = false;
        goto key_not_found;
    }
    total_size = 2 * QSXE_MAGIC_BYTES + manifestMatchCount * QSXE_KEY_LEN;
    result = (char*)malloc( total_size );
    Q_CHECK_PTR( result );
    mn.seek( 0 );
    result_ptr = result;
    /* reading whole key array in is much more efficient, 99% case is this loop only
       executes once, should not have more than 128 keyed items */
    while (( keysRead = kf.read( (char*)keys_list, sizeof(struct usr_key_entry)*128 )) > 0 )
    {
        /* qDebug("PID %d: getClientKey() - read %d bytes = %d keys from %s", getpid(), keysRead,
                keysRead/sizeof(struct usr_key_entry), qPrintable(actualKeyPath)); */
        keysRead /= sizeof(struct usr_key_entry);
        while ( mn.read( (char*)&mr, sizeof(struct IdBlock)) > 0 )
        {
            if ( mr.progId == progId )
            {
                foundKey = false;
                for ( int i = 0; i < keysRead; ++i )
                {
                    /* if ( i == 0 )
                        qDebug() << "         pid" << getpid() << "looking for device"  << (dev_t)mr.device << "inode" << (ino_t)mr.inode;
                    qDebug() << "         pid" << getpid() << "trying device" <<  keys_list[i].dev << "inode" <<  keys_list[i].ino; */
                    if ( keys_list[i].ino == (ino_t)mr.inode && keys_list[i].dev == (dev_t)mr.device )
                    {
                        memcpy( result_ptr, keys_list[i].key, QSXE_KEY_LEN );
                        result_ptr += QSXE_KEY_LEN;
                        foundKey = true;
                        break;
                    }
                }
                if ( foundKey )
                {
                    keysFound++;
                    if ( keysFound == manifestMatchCount )
                        break;
                }
            }
        }
    }
    if ( result_ptr == result ) // nothing found!
        goto key_not_found;
    // 2 x magic bytes sentinel at end of sequence
    for ( int i = 0; i < 2; ++i )
        for ( int j = 0; j < QSXE_MAGIC_BYTES; ++j )
            *result_ptr++ = magic[j];
    keyCache.insert( progId, result, total_size / 10 );
    /* qDebug( "PID %d : Found %d client keys for prog %u", getpid(), keysFound, progId ); */
    goto success_out;

key_not_found:
    if ( noFailOnKeyMissing )  // return an "empty" set of keys in this case
    {
        if ( result == 0 )
        {
            result = (char*)malloc( 2 * QSXE_MAGIC_BYTES );
            Q_CHECK_PTR( result );
        }
        result_ptr = result;
        for ( int i = 0; i < 2; ++i )
            for ( int j = 0; j < QSXE_MAGIC_BYTES; ++j )
                *result_ptr++ = magic[j];
        return (unsigned char *)result;
    }
    qWarning( "PID %d : Not found client key for prog %u", getpid(), progId );
    if ( result )
    {
        free( result );
        result = 0;
    }
success_out:
    if ( mn.isOpen() )
        mn.close();
    if ( kf.isOpen() )
        kf.close();
    return (unsigned char *)result;
}

invalidateClientKeyCache()

void QTransportAuthPrivate::invalidateClientKeyCache

(

)

Definition at line 774 of file qtransportauth_qws.cpp.

{
    keyfileMutex.lock();
    keyCache.clear();
    keyfileMutex.unlock();
}

Properties

authKey

AuthCookie QTransportAuthPrivate::authKey

Definition at line 155 of file qtransportauth_qws_p.h.

buffersByClient

QHash< QObject*, QIODevice*> QTransportAuthPrivate::buffersByClient

Definition at line 157 of file qtransportauth_qws_p.h.

keyCache

QCache<unsigned char, char> QTransportAuthPrivate::keyCache

Definition at line 156 of file qtransportauth_qws_p.h.

keyfileMutex

QMutex QTransportAuthPrivate::keyfileMutex

Definition at line 158 of file qtransportauth_qws_p.h.

keyInitialised

bool QTransportAuthPrivate::keyInitialised

Definition at line 151 of file qtransportauth_qws_p.h.

m_keyFilePath

QString QTransportAuthPrivate::m_keyFilePath

Definition at line 153 of file qtransportauth_qws_p.h.

m_logFilePath

QString QTransportAuthPrivate::m_logFilePath

Definition at line 152 of file qtransportauth_qws_p.h.

m_packageRegistry

QObject* QTransportAuthPrivate::m_packageRegistry

Definition at line 154 of file qtransportauth_qws_p.h.

---

The documentation for this class was generated from the following files:

• /src/gui/embedded/qtransportauth_qws_p.h
• /src/gui/embedded/qtransportauth_qws.cpp