Qtopia library API Documentation
	Overview Class Hierarchy Classes Classes (annotated) Members Source Files Todo

config.cpp

/**********************************************************************
** Copyright (C) 2000 Trolltech AS.  All rights reserved.
**
** This file is part of Qtopia Environment.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/

#include <qdir.h>
#include <qfile.h>
#include <qfileinfo.h>
#include <qmessagebox.h>
#if QT_VERSION <= 230 && defined(QT_NO_CODECS)
#include <qtextcodec.h>
#endif
#include <qtextstream.h>

#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>

#define QTOPIA_INTERNAL_LANGLIST
#include "config.h"
#include "global.h"


QString Config::configFilename(const QString& name, Domain d)
{
    switch (d) {
    case File:
        return name;
    case User: {
        QDir dir = (QString(getenv("HOME")) + "/Settings");
        if ( !dir.exists() )
        mkdir(dir.path().local8Bit(),0700);
        return dir.path() + "/" + name + ".conf";
    }
    }
    return name;
}

Config::Config( const QString &name, Domain domain )
    : filename( configFilename(name,domain) )
{
    git = groups.end();
    read();
    QStringList l = Global::languageList();
    lang = l[0];
    glang = l[1];
}


// Sharp ROM compatibility
Config::Config ( const QString &name, bool what )
    : filename( configFilename(name,what ? User : File) )
{
    git = groups.end();
    read();
    QStringList l = Global::languageList();
    lang = l[0];
    glang = l[1];
}

Config::~Config()
{
    if ( changed )
    write();
}

bool Config::hasKey( const QString &key ) const
{
    if ( groups.end() == git )
    return FALSE;
    ConfigGroup::ConstIterator it = ( *git ).find( key );
    return it != ( *git ).end();
}

void Config::setGroup( const QString &gname )
{
    QMap< QString, ConfigGroup>::Iterator it = groups.find( gname );
    if ( it == groups.end() ) {
    git = groups.insert( gname, ConfigGroup() );
    changed = TRUE;
    return;
    }
    git = it;
}

void Config::writeEntry( const QString &key, const char* value )
{
    writeEntry(key,QString(value));
}

void Config::writeEntry( const QString &key, const QString &value )
{
    if ( git == groups.end() ) {
    qWarning( "no group set" );
    return;
    }
    if ( (*git)[key] != value ) {
    ( *git ).insert( key, value );
    changed = TRUE;
    }
}

/*
  Note that the degree of protection offered by the encryption here is
  only sufficient to avoid the most casual observation of the configuration
  files. People with access to the files can write down the contents and
  decrypt it using this source code.

  Conceivably, and at some burden to the user, this encryption could
  be improved.
*/
static QString encipher(const QString& plain)
{
    // mainly, we make it long
    QString cipher;
    int mix=28730492;
    for (int i=0; i<(int)plain.length(); i++) {
    int u = plain[i].unicode();
    int c = u ^ mix;
    QString x = QString::number(c,36);
    cipher.append(QChar('a'+x.length()));
    cipher.append(x);
    mix *= u;
    }
    return cipher;
}

static QString decipher(const QString& cipher)
{
    QString plain;
    int mix=28730492;
    for (int i=0; i<(int)cipher.length();) {
    int l = cipher[i].unicode()-'a';
    QString x = cipher.mid(i+1,l); i+=l+1;
    int u = x.toInt(0,36) ^ mix;
    plain.append(QChar(u));
    mix *= u;
    }
    return plain;
}

void Config::writeEntryCrypt( const QString &key, const QString &value )
{
    if ( git == groups.end() ) {
    qWarning( "no group set" );
    return;
    }
    QString evalue = encipher(value);
    if ( (*git)[key] != evalue ) {
    ( *git ).insert( key, evalue );
    changed = TRUE;
    }
}

void Config::writeEntry( const QString &key, int num )
{
    QString s;
    s.setNum( num );
    writeEntry( key, s );
}

#ifdef Q_HAS_BOOL_TYPE

void Config::writeEntry( const QString &key, bool b )
{
    QString s;
    s.setNum( ( int )b );
    writeEntry( key, s );
}
#endif

void Config::writeEntry( const QString &key, const QStringList &lst, const QChar &sep )
{
    QString s;
    QStringList::ConstIterator it = lst.begin();
    for ( ; it != lst.end(); ++it )
    s += *it + sep;
    writeEntry( key, s );
}

void Config::removeEntry( const QString &key )
{
    if ( git == groups.end() ) {
    qWarning( "no group set" );
    return;
    }
    ( *git ).remove( key );
    changed = TRUE;
}

QString Config::readEntry( const QString &key, const QString &deflt )
{
    QString res = readEntryDirect( key+"["+lang+"]" );
    if ( !res.isNull() )
    return res;
    if ( !glang.isEmpty() ) {
    res = readEntryDirect( key+"["+glang+"]" );
    if ( !res.isNull() )
        return res;
    }
    return readEntryDirect( key, deflt );
}

QString Config::readEntryCrypt( const QString &key, const QString &deflt )
{
    QString res = readEntryDirect( key+"["+lang+"]" );
    if ( res.isNull() && glang.isEmpty() )
    res = readEntryDirect( key+"["+glang+"]" );
    if ( res.isNull() )
    res = readEntryDirect( key, QString::null );
    if ( res.isNull() )
    return deflt;
    return decipher(res);
}

QString Config::readEntryDirect( const QString &key, const QString &deflt )
{
    if ( git == groups.end() ) {
    //qWarning( "no group set" );
    return deflt;
    }
    ConfigGroup::ConstIterator it = ( *git ).find( key );
    if ( it != ( *git ).end() )
    return *it;
    else
    return deflt;
}

int Config::readNumEntry( const QString &key, int deflt )
{
    QString s = readEntry( key );
    if ( s.isEmpty() )
    return deflt;
    else
    return s.toInt();
}

bool Config::readBoolEntry( const QString &key, bool deflt )
{
    QString s = readEntry( key );
    if ( s.isEmpty() )
    return deflt;
    else
    return (bool)s.toInt();
}

QStringList Config::readListEntry( const QString &key, const QChar &sep )
{
    QString s = readEntry( key );
    if ( s.isEmpty() )
    return QStringList();
    else
    return QStringList::split( sep, s );
}

void Config::clearGroup()
{
    if ( git == groups.end() ) {
    qWarning( "no group set" );
    return;
    }
    if ( !(*git).isEmpty() ) {
    ( *git ).clear();
    changed = TRUE;
    }
}

void Config::write( const QString &fn )
{
    QString strNewFile;
    if ( !fn.isEmpty() )
    filename = fn;
    strNewFile = filename + ".new";

    QFile f( strNewFile );
    if ( !f.open( IO_WriteOnly|IO_Raw ) ) {
    qWarning( "could not open for writing `%s'", strNewFile.latin1() );
    git = groups.end();
    return;
    }

    QString str;
    QCString cstr;
    QMap< QString, ConfigGroup >::Iterator g_it = groups.begin();

    for ( ; g_it != groups.end(); ++g_it ) {
    str += "[" + g_it.key() + "]\n";
    ConfigGroup::Iterator e_it = ( *g_it ).begin();
    for ( ; e_it != ( *g_it ).end(); ++e_it )
        str += e_it.key() + " = " + *e_it + "\n";
    }
    cstr = str.utf8();

    int total_length;
    total_length = f.writeBlock( cstr.data(), cstr.length() );
    if ( total_length != int(cstr.length()) ) {
    QMessageBox::critical( 0, QObject::tr("Out of Space"),
                   QObject::tr("There was a problem creating\nConfiguration Information \nfor this program.\n\nPlease free up some space and\ntry again.") );
    f.close();
    QFile::remove( strNewFile );
    return;
    }

    f.close();
    // now rename the file...
    if ( rename( strNewFile, filename ) < 0 ) {
    qWarning( "problem renaming the file %s to %s", strNewFile.latin1(),
          filename.latin1() );
    QFile::remove( strNewFile );
    }
}

bool Config::isValid() const
{
    return groups.end() != git;
}

void Config::read()
{
    changed = FALSE;

    if ( !QFileInfo( filename ).exists() ) {
    git = groups.end();
    return;
    }

    QFile f( filename );
    if ( !f.open( IO_ReadOnly ) ) {
    git = groups.end();
    return;
    }


    // hack to avoid problems if big files are passed to test
    // if they are valid configs ( like passing a mp3 ... )
    // I just hope that there are no conf files > 100000 byte
    // not the best solution, find something else later
    if ( f.size() > 100000 )  {
        return;
    }


    QTextStream s( &f );
#if QT_VERSION <= 230 && defined(QT_NO_CODECS)
    // The below should work, but doesn't in Qt 2.3.0
    s.setCodec( QTextCodec::codecForMib( 106 ) );
#else
    s.setEncoding( QTextStream::UnicodeUTF8 );
#endif

    QStringList list = QStringList::split('\n', s.read() );
    f.close();

    for ( QStringList::Iterator it = list.begin(); it != list.end(); ++it ) {
        if ( !parse( *it ) ) {
            git = groups.end();
            return;
        }
    }
}

bool Config::parse( const QString &l )
{
    QString line = l.stripWhiteSpace();

    if ( line [0] == QChar ( '#' ))
        return true; // ignore comments

    if ( line[ 0 ] == QChar( '[' ) ) {
    QString gname = line;
    gname = gname.remove( 0, 1 );
    if ( gname[ (int)gname.length() - 1 ] == QChar( ']' ) )
        gname = gname.remove( gname.length() - 1, 1 );
    git = groups.insert( gname, ConfigGroup() );
    } else if ( !line.isEmpty() ) {
    if ( git == groups.end() )
        return FALSE;
    int eq = line.find( '=' );
    if ( eq == -1 )
        return FALSE;
    QString key = line.left(eq).stripWhiteSpace();
    QString value = line.mid(eq+1).stripWhiteSpace();
    ( *git ).insert( key, value );
    }
    return TRUE;
}

This file is part of the documentation for OPIE Version 1.5.5.

Documentation copyright © 1997-2003 the KDE developers. 2003 OPIE developers
Generated on Tue Feb 10 20:24:03 2004 by doxygen 1.3.5 written by Dimitri van Heesch, © 1997-2001