X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcommon%2Fquassel.cpp;h=eb854b30e01da5c41b6a171622ac251fb25bbafe;hp=88b87c246f8524720d4682034a55818ce68022d2;hb=8a0b44b52a6a0a855a832fa7b46f3631a8684a3f;hpb=480eab8daec4fb56a6886918c6a913cc197330f1 diff --git a/src/common/quassel.cpp b/src/common/quassel.cpp index 88b87c24..eb854b30 100644 --- a/src/common/quassel.cpp +++ b/src/common/quassel.cpp @@ -1,5 +1,5 @@ /*************************************************************************** - * Copyright (C) 2005-08 by the Quassel IRC Team * + * Copyright (C) 2005-09 by the Quassel Project * * devel@quassel-irc.org * * * * This program is free software; you can redistribute it and/or modify * @@ -20,12 +20,19 @@ #include "quassel.h" +#include #include +#if !defined Q_OS_WIN32 && !defined Q_OS_MAC +# include +#endif #include #include -#include -#include +#include +#include +#include +#include +#include #include "message.h" #include "identity.h" @@ -34,86 +41,132 @@ #include "types.h" #include "syncableobject.h" -#if defined(HAVE_EXECINFO) and not defined(Q_OS_MAC) -# define BUILD_CRASHHANDLER -# include -# include -# include -#endif - Quassel::BuildInfo Quassel::_buildInfo; -CliParser *Quassel::_cliParser = 0; +AbstractCliParser *Quassel::_cliParser = 0; Quassel::RunMode Quassel::_runMode; +QString Quassel::_configDirPath; +QString Quassel::_translationDirPath; +QStringList Quassel::_dataDirPaths; bool Quassel::_initialized = false; bool Quassel::DEBUG = false; +QString Quassel::_coreDumpFileName; +Quassel *Quassel::_instance = 0; +bool Quassel::_handleCrashes = true; +Quassel::LogLevel Quassel::_logLevel = InfoLevel; +QFile *Quassel::_logFile = 0; +bool Quassel::_logToSyslog = false; Quassel::Quassel() { - Q_INIT_RESOURCE(i18n); + Q_ASSERT(!_instance); + _instance = this; // We catch SIGTERM and SIGINT (caused by Ctrl+C) to graceful shutdown Quassel. signal(SIGTERM, handleSignal); signal(SIGINT, handleSignal); - -#ifdef BUILD_CRASHHANDLER - signal(SIGABRT, handleSignal); - signal(SIGBUS, handleSignal); - signal(SIGSEGV, handleSignal); -#endif // #if defined(HAVE_EXECINFO) and not defined(Q_OS_MAC) - - _cliParser = new CliParser(); - - // put shared client&core arguments here - cliParser()->addSwitch("debug",'d', tr("Enable debug output")); - cliParser()->addSwitch("help",'h', tr("Display this help and exit")); } Quassel::~Quassel() { + if(logFile()) { + logFile()->close(); + logFile()->deleteLater(); + } delete _cliParser; } bool Quassel::init() { - if(_initialized) return true; // allow multiple invocations because of MonolithicApplication + if(_initialized) + return true; // allow multiple invocations because of MonolithicApplication + + if (_handleCrashes) { + // we have crashhandler for win32 and unix (based on execinfo). +#if defined(Q_OS_WIN32) || defined(HAVE_EXECINFO) +# ifndef Q_OS_WIN32 + // we only handle crashes ourselves if coredumps are disabled + struct rlimit *limit = (rlimit *) malloc(sizeof(struct rlimit)); + int rc = getrlimit(RLIMIT_CORE, limit); + + if(rc == -1 || !((long)limit->rlim_cur > 0 || limit->rlim_cur == RLIM_INFINITY)) { +# endif /* Q_OS_WIN32 */ + signal(SIGABRT, handleSignal); + signal(SIGSEGV, handleSignal); +# ifndef Q_OS_WIN32 + signal(SIGBUS, handleSignal); + } + free(limit); +# endif /* Q_OS_WIN32 */ +#endif /* Q_OS_WIN32 || HAVE_EXECINFO */ + } + _initialized = true; qsrand(QTime(0,0,0).secsTo(QTime::currentTime())); registerMetaTypes(); - setupTranslations(); - - QCoreApplication::setApplicationName(buildInfo().applicationName); - QCoreApplication::setOrganizationName(buildInfo().organizationName); - QCoreApplication::setOrganizationDomain(buildInfo().organizationDomain); Network::setDefaultCodecForServer("ISO-8859-1"); Network::setDefaultCodecForEncoding("UTF-8"); Network::setDefaultCodecForDecoding("ISO-8859-15"); - if(!cliParser()->parse(QCoreApplication::arguments()) || isOptionSet("help")) { + if(isOptionSet("help")) { cliParser()->usage(); return false; } + + if(isOptionSet("version")) { + std::cout << qPrintable("Quassel IRC: " + Quassel::buildInfo().plainVersionString) << std::endl; + return false; + } + DEBUG = isOptionSet("debug"); + + // set up logging + if(Quassel::runMode() != Quassel::ClientOnly) { + if(isOptionSet("loglevel")) { + QString level = optionValue("loglevel"); + + if(level == "Debug") _logLevel = DebugLevel; + else if(level == "Info") _logLevel = InfoLevel; + else if(level == "Warning") _logLevel= WarningLevel; + else if(level == "Error") _logLevel = ErrorLevel; + } + + QString logfilename = optionValue("logfile"); + if(!logfilename.isEmpty()) { + _logFile = new QFile(logfilename); + if(!_logFile->open(QIODevice::Append | QIODevice::Text)) { + qWarning() << "Could not open log file" << logfilename << ":" << _logFile->errorString(); + _logFile->deleteLater(); + _logFile = 0; + } + } +#ifdef HAVE_SYSLOG + _logToSyslog = isOptionSet("syslog"); +#endif + } + return true; } +void Quassel::quit() { + QCoreApplication::quit(); +} + //! Register our custom types with Qt's Meta Object System. /** This makes them available for QVariant and in signals/slots, among other things. * */ void Quassel::registerMetaTypes() { // Complex types - qRegisterMetaType("QVariant"); qRegisterMetaType("Message"); qRegisterMetaType("BufferInfo"); qRegisterMetaType("NetworkInfo"); + qRegisterMetaType("Network::Server"); qRegisterMetaType("Identity"); - qRegisterMetaType("Network::ConnectionState"); - qRegisterMetaTypeStreamOperators("QVariant"); qRegisterMetaTypeStreamOperators("Message"); qRegisterMetaTypeStreamOperators("BufferInfo"); qRegisterMetaTypeStreamOperators("NetworkInfo"); + qRegisterMetaTypeStreamOperators("Network::Server"); qRegisterMetaTypeStreamOperators("Identity"); - qRegisterMetaTypeStreamOperators("Network::ConnectionState"); qRegisterMetaType("IdentityId"); qRegisterMetaType("BufferId"); @@ -122,33 +175,26 @@ void Quassel::registerMetaTypes() { qRegisterMetaType("AccountId"); qRegisterMetaType("MsgId"); + qRegisterMetaType("QHostAddress"); + qRegisterMetaTypeStreamOperators("IdentityId"); qRegisterMetaTypeStreamOperators("BufferId"); qRegisterMetaTypeStreamOperators("NetworkId"); qRegisterMetaTypeStreamOperators("UserId"); qRegisterMetaTypeStreamOperators("AccountId"); qRegisterMetaTypeStreamOperators("MsgId"); -} - -void Quassel::setupTranslations() { - // Set up i18n support - QLocale locale = QLocale::system(); - QTranslator *qtTranslator = new QTranslator(qApp); - qtTranslator->setObjectName("QtTr"); - qtTranslator->load(QString(":i18n/qt_%1").arg(locale.name())); - qApp->installTranslator(qtTranslator); - - QTranslator *quasselTranslator = new QTranslator(qApp); - quasselTranslator->setObjectName("QuasselTr"); - quasselTranslator->load(QString(":i18n/quassel_%1").arg(locale.name())); - qApp->installTranslator(quasselTranslator); + // Versions of Qt prior to 4.7 didn't define QVariant as a meta type + if(!QMetaType::type("QVariant")) { + qRegisterMetaType("QVariant"); + qRegisterMetaTypeStreamOperators("QVariant"); + } } void Quassel::setupBuildInfo(const QString &generated) { _buildInfo.applicationName = "Quassel IRC"; - _buildInfo.coreApplicationName = "Quassel Core"; - _buildInfo.clientApplicationName = "Quassel Client"; + _buildInfo.coreApplicationName = "quasselcore"; + _buildInfo.clientApplicationName = "quasselclient"; _buildInfo.organizationName = "Quassel Project"; _buildInfo.organizationDomain = "quassel-irc.org"; @@ -170,7 +216,7 @@ void Quassel::setupBuildInfo(const QString &generated) { _buildInfo.plainVersionString = QString("v%1 (dist-%2)") .arg(_buildInfo.baseVersion) .arg(_buildInfo.commitHash.left(7)); - _buildInfo.fancyVersionString = QString("v%1 (dist-%2)") + _buildInfo.fancyVersionString = QString("v%1 (dist-%2)") .arg(_buildInfo.baseVersion) .arg(_buildInfo.commitHash.left(7)) .arg(_buildInfo.commitHash); @@ -182,13 +228,13 @@ void Quassel::setupBuildInfo(const QString &generated) { // analyze what we got from git-describe QRegExp rx("(.*)-(\\d+)-g([0-9a-f]+)$"); if(rx.exactMatch(_buildInfo.generatedVersion)) { - QString distance = rx.cap(2) == "0" ? QString() : QString(" [+%1]").arg(rx.cap(2)); - _buildInfo.plainVersionString = QString("v%1%2 (git-%3%4)") - .arg(rx.cap(1), distance, rx.cap(3)) + QString distance = rx.cap(2) == "0" ? QString() : QString("%1+%2 ").arg(rx.cap(1), rx.cap(2)); + _buildInfo.plainVersionString = QString("v%1 (%2git-%3%4)") + .arg(_buildInfo.baseVersion, distance, rx.cap(3)) .arg(_buildInfo.isSourceDirty ? "*" : ""); if(!_buildInfo.commitHash.isEmpty()) { - _buildInfo.fancyVersionString = QString("v%1%2 (git-%3%4)") - .arg(rx.cap(1), distance, rx.cap(3)) + _buildInfo.fancyVersionString = QString("v%1 (%2git-%3%4)") + .arg(_buildInfo.baseVersion, distance, rx.cap(3)) .arg(_buildInfo.isSourceDirty ? "*" : "") .arg(_buildInfo.commitHash); } @@ -203,84 +249,217 @@ void Quassel::setupBuildInfo(const QString &generated) { //! Signal handler for graceful shutdown. void Quassel::handleSignal(int sig) { switch(sig) { - case SIGTERM: - case SIGINT: - qWarning("%s", qPrintable(QString("Caught signal %1 - exiting.").arg(sig))); + case SIGTERM: + case SIGINT: + qWarning("%s", qPrintable(QString("Caught signal %1 - exiting.").arg(sig))); + if(_instance) + _instance->quit(); + else QCoreApplication::quit(); - break; + break; + case SIGABRT: + case SIGSEGV: +#ifndef Q_OS_WIN32 + case SIGBUS: +#endif + logBacktrace(coreDumpFileName()); + exit(EXIT_FAILURE); + break; + default: + break; + } +} + +void Quassel::logFatalMessage(const char *msg) { +#ifdef Q_OS_MAC + Q_UNUSED(msg) +#else + QFile dumpFile(coreDumpFileName()); + dumpFile.open(QIODevice::Append); + QTextStream dumpStream(&dumpFile); + + dumpStream << "Fatal: " << msg << '\n'; + dumpStream.flush(); + dumpFile.close(); +#endif +} + +Quassel::Features Quassel::features() { + Features feats = 0; + for(int i = 1; i <= NumFeatures; i<<=1) + feats |= (Feature) i; -#ifdef BUILD_CRASHHANDLER - case SIGABRT: - case SIGBUS: - case SIGSEGV: - handleCrash(); + return feats; +} + +const QString &Quassel::coreDumpFileName() { + if(_coreDumpFileName.isEmpty()) { + QDir configDir(configDirPath()); + _coreDumpFileName = configDir.absoluteFilePath(QString("Quassel-Crash-%1.log").arg(QDateTime::currentDateTime().toString("yyyyMMdd-hhmm"))); + QFile dumpFile(_coreDumpFileName); + dumpFile.open(QIODevice::Append); + QTextStream dumpStream(&dumpFile); + dumpStream << "Quassel IRC: " << _buildInfo.baseVersion << ' ' << _buildInfo.commitHash << '\n'; + qDebug() << "Quassel IRC: " << _buildInfo.baseVersion << ' ' << _buildInfo.commitHash; + dumpStream.flush(); + dumpFile.close(); + } + return _coreDumpFileName; +} + +QString Quassel::configDirPath() { + if(!_configDirPath.isEmpty()) + return _configDirPath; + + if(Quassel::isOptionSet("datadir")) { + qWarning() << "Obsolete option --datadir used!"; + _configDirPath = Quassel::optionValue("datadir"); + } else if(Quassel::isOptionSet("configdir")) { + _configDirPath = Quassel::optionValue("configdir"); + } else { + +#ifdef Q_WS_MAC + // On Mac, the path is always the same + _configDirPath = QDir::homePath() + "/Library/Application Support/Quassel/"; +#else + // We abuse QSettings to find us a sensible path on the other platforms +# ifdef Q_WS_WIN + // don't use the registry + QSettings::Format format = QSettings::IniFormat; +# else + QSettings::Format format = QSettings::NativeFormat; +# endif + QSettings s(format, QSettings::UserScope, QCoreApplication::organizationDomain(), buildInfo().applicationName); + QFileInfo fileInfo(s.fileName()); + _configDirPath = fileInfo.dir().absolutePath(); +#endif /* Q_WS_MAC */ + } + + if(!_configDirPath.endsWith(QDir::separator()) && !_configDirPath.endsWith('/')) + _configDirPath += QDir::separator(); + + QDir qDir(_configDirPath); + if(!qDir.exists(_configDirPath)) { + if(!qDir.mkpath(_configDirPath)) { + qCritical() << "Unable to create Quassel config directory:" << qPrintable(qDir.absolutePath()); + return QString(); + } + } + + return _configDirPath; +} + +QStringList Quassel::dataDirPaths() { + return _dataDirPaths; +} + +QStringList Quassel::findDataDirPaths() const { + QStringList dataDirNames = QString(qgetenv("XDG_DATA_DIRS")).split(':', QString::SkipEmptyParts); + + if(!dataDirNames.isEmpty()) { + for(int i = 0; i < dataDirNames.count(); i++) + dataDirNames[i].append("/apps/quassel/"); + } else { + // Provide a fallback +#ifdef Q_OS_WIN32 + dataDirNames << qgetenv("APPDATA") + QCoreApplication::organizationDomain() + "/share/apps/quassel/" + << qgetenv("APPDATA") + QCoreApplication::organizationDomain() + << QCoreApplication::applicationDirPath(); + } +#elif defined Q_WS_MAC + dataDirNames << QDir::homePath() + "/Library/Application Support/Quassel/" + << QCoreApplication::applicationDirPath(); + } +#else + dataDirNames.append("/usr/share/apps/quassel/"); + } + // on UNIX, we always check our install prefix + QString appDir = QCoreApplication::applicationDirPath(); + int binpos = appDir.lastIndexOf("/bin"); + if(binpos >= 0) { + appDir.replace(binpos, 4, "/share"); + appDir.append("/apps/quassel/"); + if(!dataDirNames.contains(appDir)) + dataDirNames.append(appDir); + } #endif - break; - default: - break; + + // add resource path and workdir just in case + dataDirNames << QCoreApplication::applicationDirPath() + "/data/" + << ":/data/"; + + // append trailing '/' and check for existence + QStringList::Iterator iter = dataDirNames.begin(); + while(iter != dataDirNames.end()) { + if(!iter->endsWith(QDir::separator()) && !iter->endsWith('/')) + iter->append(QDir::separator()); + if(!QFile::exists(*iter)) + iter = dataDirNames.erase(iter); + else + ++iter; } + + return dataDirNames; } -void Quassel::handleCrash() { -#ifdef BUILD_CRASHHANDLER - void* callstack[128]; - int i, frames = backtrace(callstack, 128); +QString Quassel::findDataFilePath(const QString &fileName) { + QStringList dataDirs = dataDirPaths(); + foreach(QString dataDir, dataDirs) { + QString path = dataDir + fileName; + if(QFile::exists(path)) + return path; + } + return QString(); +} - QFile dumpFile(QString("Quassel-Crash-%1").arg(QDateTime::currentDateTime().toString("yyyyMMdd-hhmm.log"))); - dumpFile.open(QIODevice::WriteOnly); - QTextStream dumpStream(&dumpFile); +QStringList Quassel::scriptDirPaths() { + QStringList res(configDirPath() + "scripts/"); + foreach(QString path, dataDirPaths()) + res << path + "scripts/"; + return res; +} - for (i = 0; i < frames; ++i) { - Dl_info info; - dladdr (callstack[i], &info); - // as a reference: - // typedef struct - // { - // __const char *dli_fname; /* File name of defining object. */ - // void *dli_fbase; /* Load address of that object. */ - // __const char *dli_sname; /* Name of nearest symbol. */ - // void *dli_saddr; /* Exact value of nearest symbol. */ - // } Dl_info; - - #if __LP64__ - int addrSize = 16; - #else - int addrSize = 8; - #endif - - QString funcName; - if(info.dli_sname) { - char *func = abi::__cxa_demangle(info.dli_sname, 0, 0, 0); - if(func) { - funcName = QString(func); - free(func); - } else { - funcName = QString(info.dli_sname); +QString Quassel::translationDirPath() { + if(_translationDirPath.isEmpty()) { + // We support only one translation dir; fallback mechanisms wouldn't work else. + // This means that if we have a $data/translations dir, the internal :/i18n resource won't be considered. + foreach(const QString &dir, dataDirPaths()) { + if(QFile::exists(dir + "translations/")) { + _translationDirPath = dir + "translations/"; + break; } - } else { - funcName = QString("0x%1").arg((long)info.dli_saddr, addrSize, QLatin1Char('0')); } + if(_translationDirPath.isEmpty()) + _translationDirPath = ":/i18n/"; + } + return _translationDirPath; +} - // prettificating the filename - QString fileName("???"); - if(info.dli_fname) { - fileName = QString(info.dli_fname); - int slashPos = fileName.lastIndexOf('/'); - if(slashPos != -1) - fileName = fileName.mid(slashPos + 1); - if(fileName.count() < 20) - fileName += QString(20 - fileName.count(), ' '); - } +void Quassel::loadTranslation(const QLocale &locale) { + QTranslator *qtTranslator = QCoreApplication::instance()->findChild("QtTr"); + QTranslator *quasselTranslator = QCoreApplication::instance()->findChild("QuasselTr"); - QString debugLine = QString("#%1 %2 0x%3 %4").arg(i, 3, 10) - .arg(fileName) - .arg((long)(callstack[i]), addrSize, 16, QLatin1Char('0')) - .arg(funcName); + if(qtTranslator) + qApp->removeTranslator(qtTranslator); + if(quasselTranslator) + qApp->removeTranslator(quasselTranslator); - dumpStream << debugLine << "\n"; - qDebug() << qPrintable(debugLine); - } - dumpFile.close(); - exit(27); -#endif /* BUILD_CRASHHANDLER */ + // We use QLocale::C to indicate that we don't want a translation + if(locale.language() == QLocale::C) + return; + + qtTranslator = new QTranslator(qApp); + qtTranslator->setObjectName("QtTr"); + qApp->installTranslator(qtTranslator); + + quasselTranslator = new QTranslator(qApp); + quasselTranslator->setObjectName("QuasselTr"); + qApp->installTranslator(quasselTranslator); + + QLocale::setDefault(locale); + + bool success = qtTranslator->load(QString("qt_%1").arg(locale.name()), translationDirPath()); + if(!success) + qtTranslator->load(QString("qt_%1").arg(locale.name()), QLibraryInfo::location(QLibraryInfo::TranslationsPath)); + quasselTranslator->load(QString("%1").arg(locale.name()), translationDirPath()); }