debian/0000775000000000000000000000000013272261154007173 5ustar debian/quassel-client-qt4.install0000664000000000000000000000010312314413402014203 0ustar usr/bin/quasselclient usr/share/applications/quasselclient.desktop debian/quassel-core.postinst0000664000000000000000000000310312314413402013367 0ustar #!/bin/sh set -e # some variables QUASSEL_GROUP=quassel QUASSEL_USER=quasselcore QUASSEL_HOME=/var/lib/quassel QUASSEL_LOG=/var/log/quassel if [ "$1" = "configure" ] && [ -z "$2" ]; then # create $HOME echo "Creating $QUASSEL_HOME directory ..." mkdir -p $QUASSEL_HOME # create group grep -q $QUASSEL_GROUP /etc/group || ( echo Creating $QUASSEL_GROUP group... ; \ addgroup --quiet --system $QUASSEL_GROUP) # create user grep -q $QUASSEL_USER /etc/passwd || ( echo Creating $QUASSEL_USER user... ; \ adduser --quiet --system --ingroup $QUASSEL_GROUP \ --home $QUASSEL_HOME --no-create-home $QUASSEL_USER ) chown $QUASSEL_USER:$QUASSEL_GROUP $QUASSEL_HOME chmod 750 $QUASSEL_HOME echo "Creating $QUASSEL_LOG directory ..." mkdir -p $QUASSEL_LOG chown $QUASSEL_USER:$QUASSEL_GROUP -R $QUASSEL_LOG chmod 750 $QUASSEL_LOG # generate a SSL certificate for 18 months (support time) + 6 months (development time) # this covers the worst case scenario of earliest possible install + no whatsoever # updates while support time frame. otherwise the key will be regenerated # FIXME: Not over-writing existing certs, but need to (someday) replace old certs if [ ! -e $QUASSEL_HOME/quasselCert.pem ] ; then echo "Generating SSL certificate as $QUASSEL_HOME/quasselCert.pem ..." openssl req -x509 -nodes -batch -days 680 -newkey rsa:1024 -keyout \ $QUASSEL_HOME/quasselCert.pem -out $QUASSEL_HOME/quasselCert.pem chown $QUASSEL_USER:$QUASSEL_GROUP $QUASSEL_HOME/quasselCert.pem chmod 640 $QUASSEL_HOME/quasselCert.pem fi fi #DEBHELPER# debian/quassel-qt4.manpages0000664000000000000000000000001212314413402013053 0ustar quassel.1 debian/clean0000664000000000000000000000005012314413402010162 0ustar quassel.1 quasselcore.1 quasselclient.1 debian/compat0000664000000000000000000000000212314413402010360 0ustar 7 debian/usr.bin.quasselcore0000664000000000000000000000133412314413402013013 0ustar # Author: Felix Geyer # # This program is free software; you can redistribute it and/or # modify it under the terms of version 2 of the GNU General Public # License published by the Free Software Foundation. #include /usr/bin/quasselcore { #include #include #include #include /var/lib/quassel/ rw, /var/lib/quassel/** rwk, /var/log/quassel/* rw, /etc/xdg/Trolltech.conf r, deny /etc/xdg/Trolltech.conf k, /etc/ssl/openssl.cnf r, /usr/lib/ssl/openssl.cnf r, # Site-specific additions and overrides. See local/README for details. #include } debian/quassel-qt4.install0000664000000000000000000000007012314413402012732 0ustar usr/bin/quassel usr/share/applications/quassel.desktop debian/quassel-core.quasselcore.upstart0000664000000000000000000000162712314413402015544 0ustar # quasselcore - distributed IRC client using a central core component # # This is the core component of Quassel. A modern, # cross-platform, distributed IRC client, meaning that one # (or multiple) client(s) can attach to and detach from this # central core. It's much like the popular combination # of screen and a text-based IRC client such as WeeChat. description "distributed IRC client using a central core component" author "Michael Marley " start on (filesystem and net-device-up IFACE!=lo) stop on runlevel [!2345] setuid quasselcore setgid quassel chdir /var/lib/quassel env HOME=/var/lib/quassel respawn script DATADIR="/var/lib/quassel" LOGFILE="/var/log/quassel/core.log" LOGLEVEL="Info" PORT="4242" test -f /etc/default/quasselcore && . /etc/default/quasselcore exec quasselcore --configdir=$DATADIR --logfile=$LOGFILE --loglevel=$LOGLEVEL --port=$PORT end script debian/quassel-core.dirs0000664000000000000000000000002712314413402012447 0ustar etc/ufw/applications.d debian/quassel-core.quasselcore.init0000664000000000000000000001263412314413402015005 0ustar #!/bin/sh # # Copyright (C) 2008 Harald Sitter # # This is free software; you may redistribute it and/or modify # it under the terms of the GNU General Public License as # published by the Free Software Foundation; either version 2, # or (at your option) any later version. # # This is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License with # the Debian operating system, in /usr/share/common-licenses/GPL; if # not, write to the Free Software Foundation, Inc., 59 Temple Place, # Suite 330, Boston, MA 02111-1307 USA # ### BEGIN INIT INFO # Provides: quasselcore # Required-Start: $network $local_fs $remote_fs # Required-Stop: $network $local_fs $remote_fs # Should-Start: # Should-Stop: # Default-Start: 2 3 4 5 # Default-Stop: 0 1 6 # Short-Description: distributed IRC client using a central core component # Description: This is the core component of Quassel. A modern, # cross-platform, distributed IRC client, meaning that one # (or multiple) client(s) can attach to and detach from this # central core. It's much like the popular combination # of screen and a text-based IRC client such as WeeChat. ### END INIT INFO PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin DAEMON=/usr/bin/quasselcore NAME=quasselcore DESC="distributed IRC core" LOGDIR=/var/log/quassel PIDFILE=/var/run/quasselcore.pid test -x $DAEMON || exit 0 . /lib/lsb/init-functions DAEMON_OPTS="" DIETIME=10 STARTTIME=5 LOGFILE=$LOGDIR/core.log DATADIR=/var/lib/quassel DAEMONUSER=quasselcore if [ -f /etc/default/$NAME ] ; then . /etc/default/$NAME fi if [ -n "$DAEMONUSER" ] ; then if getent passwd | grep -q "^$DAEMONUSER:"; then # Obtain the uid and gid DAEMONUID=`getent passwd |grep "^$DAEMONUSER:" | awk -F : '{print $3}'` DAEMONGID=`getent passwd |grep "^$DAEMONUSER:" | awk -F : '{print $4}'` else log_failure_msg "The user $DAEMONUSER, required to run $NAME does not exist." exit 1 fi fi set -e running_pid() { pid=$1 name=$2 [ -z "$pid" ] && return 1 [ ! -d /proc/$pid ] && return 1 cmd=`cat /proc/$pid/cmdline | tr "\000" "\n"|head -n 1 |cut -d : -f 1` [ "$cmd" != "$name" ] && return 1 return 0 } running() { [ ! -f "$PIDFILE" ] && return 1 pid=`cat $PIDFILE` running_pid $pid $DAEMON || return 1 return 0 } start_server() { start-stop-daemon --start --quiet --pidfile $PIDFILE --make-pidfile \ --background --chuid $DAEMONUSER --exec $DAEMON \ -- --logfile=$LOGFILE --loglevel=$LOGLEVEL --configdir=$DATADIR \ --port=$PORT \ $DAEMON_OPTS errcode=$? return $errcode } stop_server() { start-stop-daemon --stop --quiet --pidfile $PIDFILE --user $DAEMONUSER \ --exec $DAEMON errcode=$? return $errcode } force_stop() { [ ! -e "$PIDFILE" ] && return if running ; then kill -15 $pid # Is it really dead? sleep "$DIETIME"s if running ; then kill -9 $pid sleep "$DIETIME"s if running ; then echo "Cannot kill $NAME (pid=$pid)!" exit 1 fi fi fi rm -f $PIDFILE } case "$1" in start) log_daemon_msg "Starting $DESC" "$NAME" # Check if it's running first if running ; then log_progress_msg "apparently already running" log_end_msg 0 exit 0 fi if start_server ; then [ -n "$STARTTIME" ] && sleep $STARTTIME # Wait some time if running ; then log_end_msg 0 else log_end_msg 1 fi else log_end_msg 1 fi ;; stop) log_daemon_msg "Stopping $DESC" "$NAME" if running ; then stop_server log_end_msg $? else log_progress_msg "apparently not running" log_end_msg 0 exit 0 fi ;; force-stop) $0 stop if running; then # If it's still running try to kill it more forcefully log_daemon_msg "Stopping (force) $DESC" "$NAME" force_stop log_end_msg $? fi ;; restart|force-reload) log_daemon_msg "Restarting $DESC" "$NAME" stop_server # Wait some sensible amount, some server need this [ -n "$DIETIME" ] && sleep $DIETIME start_server [ -n "$STARTTIME" ] && sleep $STARTTIME running log_end_msg $? ;; status) log_daemon_msg "Checking status of $DESC" "$NAME" if running ; then log_success_msg "running" log_end_msg 0 else log_success_msg "apparently not running" log_end_msg 1 exit 1 fi ;; reload) log_warning_msg "Reloading $NAME daemon: not implemented, as the daemon" log_warning_msg "cannot re-read the config file (use restart)." ;; *) N=/etc/init.d/$NAME echo "Usage: $N {start|stop|force-stop|restart|force-reload|status}" >&2 exit 1 ;; esac exit 0 debian/quassel-core.quasselcore.default0000664000000000000000000000032712314413402015462 0ustar # Defaults for quasselcore initscript # sourced by /etc/init.d/quasselcore # Loglevel Debug|Info|Warning|Error. Default is: Info LOGLEVEL="Info" # The port quasselcore will listen at. Default is: 4242 PORT="4242" debian/quassel-data.links0000664000000000000000000000006412314413402012610 0ustar usr/share/kde4/apps/quassel/ usr/share/apps/quassel debian/quassel.install0000664000000000000000000000007412314413402012230 0ustar usr/bin/quassel usr/share/applications/kde4/quassel.desktop debian/source/0000775000000000000000000000000012314413402010462 5ustar debian/source/format0000664000000000000000000000001412314413402011670 0ustar 3.0 (quilt) debian/control0000664000000000000000000001260312314413402010567 0ustar Source: quassel Section: net Priority: optional Maintainer: Ubuntu Developers XSBC-Original-Maintainer: Harald Sitter Build-Depends: debhelper (>= 7.3.16), dpkg-dev (>= 1.16.1~), dh-apparmor, pkg-kde-tools (>= 0.5.0), cmake, libqt4-dev (>= 4:4.6.0), libdbus-1-dev, libqca2-dev, kdelibs5-dev (>= 4:4.3.80), libindicate-qt-dev, libdbusmenu-qt-dev, zlib1g-dev, qt4-dev-tools, libqtwebkit-dev Standards-Version: 3.9.3 Homepage: http://www.quassel-irc.org/ Vcs-Bzr: lp:~ubuntu-dev/quassel/ubuntu Vcs-Browser: http://bazaar.launchpad.net/~ubuntu-dev/quassel/ubuntu Package: quassel Architecture: any Depends: ${shlibs:Depends}, ${misc:Depends}, quassel-data (= ${source:Version}), libqt4-sql-sqlite Recommends: oxygen-icon-theme Conflicts: quassel-qt4 Description: KDE/Qt-based IRC client This is a modern, cross-platform, distributed KDE/Qt4 IRC client. One (or multiple) client(s) can attach to and detach from a central core. It's much like the popular combination of screen and a text-based IRC client such as WeeChat, but graphical. . This package provides a complete traditional IRC client (client and core) in a single integrated package Package: quassel-client Architecture: any Depends: ${shlibs:Depends}, ${misc:Depends}, quassel-data (= ${source:Version}) Recommends: oxygen-icon-theme Conflicts: quassel-client-qt4 Description: distributed, KDE/Qt-based IRC client - client component This is the client component of Quassel. A modern, cross-platform, distributed IRC client, meaning that one (or multiple) client(s) can attach to and detach from this central core. It's much like the popular combination of screen and a text-based IRC client such as WeeChat, but graphical. . This package only provides Quassel's client component. If you need to run the core/server component on your local machine install the package 'quassel' instead. Package: quassel-core Architecture: any Depends: ${shlibs:Depends}, ${misc:Depends}, adduser, openssl, libqt4-sql-sqlite Conflicts: quassel Description: distributed, KDE/Qt-based IRC client - core/server component This is the core component of Quassel. A modern, cross-platform, distributed IRC client, meaning that one (or multiple) client(s) can attach to and detach from this central core. It's much like the popular combination of screen and a text-based IRC client such as WeeChat, but graphical. . This package only provides Quassel's core/server component. Package: quassel-qt4 Architecture: any Depends: ${shlibs:Depends}, ${misc:Depends}, quassel-data (>= ${source:Version}), libqt4-sql-sqlite Recommends: quassel-qt4-data Conflicts: quassel Description: Qt-based IRC client (no KDE dependencies) This is a modern, cross-platform, distributed Qt4 IRC client. One (or multiple) client(s) can attach to and detach from a central core. It's much like the popular combination of screen and a text-based IRC client such as WeeChat, but graphical. . This package provides a complete traditional IRC client (client and core) in a single integrated package, without dependencies on KDE4 libraries. Package: quassel-client-qt4 Architecture: any Depends: ${shlibs:Depends}, ${misc:Depends}, quassel-data (>= ${source:Version}) Recommends: quassel-qt4-data Conflicts: quassel-client Description: distributed, Qt based IRC client - client component (no KDE dependencies) This is the client component of Quassel. A modern, cross-platform, distributed IRC client, meaning that one (or multiple) client(s) can attach to and detach from this central core. It's much like the popular combination of screen and a text-based IRC client such as WeeChat, but graphical. . This package only provides Quassel's client component. If you need to run the core/server component on your local machine, install the package 'quassel' instead. Package: quassel-data Architecture: all Depends: ${misc:Depends} Description: distributed, KDE/Qt-based IRC client - data files This is a modern, cross-platform, distributed IRC client, meaning that one (or multiple) client(s) can attach to and detach from a central core. It's much like the popular combination of screen and a text-based IRC client such as WeeChat, but graphical. . This package contains architecture-independent data files needed to run Quassel. Package: quassel-qt4-data Architecture: all Depends: ${misc:Depends} Description: distributed, Qt-based IRC client - Qt version data files This is a modern, cross-platform, distributed IRC client, meaning that one (or multiple) client(s) can attach to and detach from a central core. It's much like the popular combination of screen and a text-based IRC client such as WeeChat, but graphical. . This package contains additional architecture-independent data files needed to run the Qt variant of Quassel. Package: quassel-dbg Section: debug Architecture: any Priority: extra Depends: quassel (= ${binary:Version}) | quassel-client (= ${binary:Version}) | quassel-core (= ${binary:Version}), ${misc:Depends} Description: distributed, KDE/Qt-based IRC client - debugging symbols These are the debugging symbols of Quassel. A modern, cross-platform, distributed IRC client, meaning that one (or multiple) client(s) can attach to and detach from this central core. It's much like the popular combination of screen and a text-based IRC client such as WeeChat, but graphical. . This package only provides Quassel's debugging symbols. debian/quassel-data.install0000664000000000000000000000056512314413402013144 0ustar usr/share/icons/hicolor/*/apps/quassel.png usr/share/icons/hicolor/*/status/quassel*.png usr/share/kde4/apps/quassel/icons/oxygen/*/status/irc*.png usr/share/kde4/apps/quassel/translations/ usr/share/pixmaps/ usr/share/kde4/apps/quassel/quassel.notifyrc usr/share/kde4/apps/quassel/networks.ini usr/share/kde4/apps/quassel/stylesheets/ usr/share/kde4/apps/quassel/scripts/ debian/watch0000664000000000000000000000020312314413402010206 0ustar version=3 # call with uscan --repack to get an orig.tar.gz http://quassel-irc.org/pub/quassel-([0-9\.]+)\.tar\.bz2 debian uupdate debian/patches/0000775000000000000000000000000013272250641010621 5ustar debian/patches/Reject_clients_that_attempt_to_login_before_the_core_is_configured.patch0000664000000000000000000000315413272250641027344 0ustar Backported from 0.12 branch: From 08bace4e9ecf08273f094c0c6aa8b3363d38ac3e Mon Sep 17 00:00:00 2001 From: Michael Marley Date: Mon, 2 Apr 2018 19:11:31 -0400 Subject: [PATCH] Reject clients that attempt to login before the core is configured Properly-implemented clients should never try to do this, but if it is done, this patch prevents it from crashing the core. Thanks to @chaign_c (https://twitter.com/chaign_c/) for finding this issue. (cherry picked from commit e17fca767d60c06ca02bc5898ced04f06d3670bd) --- src/core/coreauthhandler.cpp | 6 ++++++ 1 file changed, 6 insertions(+) Index: quassel-0.10.0/src/core/coreauthhandler.cpp =================================================================== --- quassel-0.10.0.orig/src/core/coreauthhandler.cpp 2018-04-27 19:12:25.862655957 -0400 +++ quassel-0.10.0/src/core/coreauthhandler.cpp 2018-04-27 19:12:25.854655957 -0400 @@ -197,6 +197,12 @@ if (!checkClientRegistered()) return; + if (!Core::isConfigured()) { + qWarning() << qPrintable(tr("Client")) << qPrintable(socket()->peerAddress().toString()) << qPrintable(tr("attempted to login before the core was configured, rejecting.")); + _peer->dispatch(ClientDenied(tr("Attempted to login before core was configured!
The core must be configured before attempting to login."))); + return; + } + UserId uid = Core::validateUser(msg.user, msg.password); if (uid == 0) { _peer->dispatch(LoginFailed(tr("Invalid username or password!
The username/password combination you supplied could not be found in the database."))); debian/patches/CVE-2014-8483.patch0000664000000000000000000000322212432374505013251 0ustar From 6b2d80b85a521392b3a34c902ab8ef85899f9cb6 Mon Sep 17 00:00:00 2001 From: Manuel Nickschas Date: Tue, 21 Oct 2014 21:20:07 +0200 Subject: [PATCH] Check for invalid input in encrypted buffers The ECB Blowfish decryption function assumed that encrypted input would always come in blocks of 12 characters, as specified. However, buggy clients or annoying people may not adhere to that assumption, causing the core to crash while trying to process the invalid base64 input. With this commit we make sure that we're not overstepping the bounds of the input string while decoding it; instead we bail out early and display the original input. Fixes #1314. Thanks to Tucos for finding that one! --- src/core/cipher.cpp | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/src/core/cipher.cpp b/src/core/cipher.cpp index 7cc75d0..7d1fe46 100644 --- a/src/core/cipher.cpp +++ b/src/core/cipher.cpp @@ -364,6 +364,10 @@ QByteArray Cipher::blowfishECB(QByteArray cipherText, bool direction) } else { + // ECB Blowfish encodes in blocks of 12 chars, so anything else is malformed input + if ((temp.length() % 12) != 0) + return cipherText; + temp = b64ToByte(temp); while ((temp.length() % 8) != 0) temp.append('\0'); } @@ -376,8 +380,13 @@ QByteArray Cipher::blowfishECB(QByteArray cipherText, bool direction) if (!cipher.ok()) return cipherText; - if (direction) + if (direction) { + // Sanity check + if ((temp2.length() % 8) != 0) + return cipherText; + temp2 = byteToB64(temp2); + } return temp2; } debian/patches/CVE-2015-3427.patch0000664000000000000000000000461712521741660013253 0ustar From 6605882f41331c80f7ac3a6992650a702ec71283 Mon Sep 17 00:00:00 2001 From: Michael Marley Date: Thu, 23 Apr 2015 08:46:43 -0400 Subject: [PATCH] Execute initDbSession() on DB reconnects Previously, the initDbSession() function would only be run on the initial connect. Since the initDbSession() code in PostgreSQL is used to fix the CVE-2013-4422 SQL Injection bug, this means that Quassel was still vulnerable to that CVE if the PostgreSQL server is restarted or the connection is lost at any point while Quassel is running. This bug also causes the Qt5 psql timezone fix to stop working after a reconnect. The fix is to disable Qt's automatic reconnecting, check the connection status ourselves, and reconnect if necessary, executing the initDbSession() function afterward. --- src/core/abstractsqlstorage.cpp | 15 ++++++++++++++- src/core/abstractsqlstorage.h | 1 + 2 files changed, 15 insertions(+), 1 deletion(-) diff --git a/src/core/abstractsqlstorage.cpp b/src/core/abstractsqlstorage.cpp index cb07454..dce39cb 100644 --- a/src/core/abstractsqlstorage.cpp +++ b/src/core/abstractsqlstorage.cpp @@ -53,7 +53,14 @@ QSqlDatabase AbstractSqlStorage::logDb() if (!_connectionPool.contains(QThread::currentThread())) addConnectionToPool(); - return QSqlDatabase::database(_connectionPool[QThread::currentThread()]->name()); + QSqlDatabase db = QSqlDatabase::database(_connectionPool[QThread::currentThread()]->name(),false); + + if (!db.isOpen()) { + qWarning() << "Database connection" << displayName() << "for thread" << QThread::currentThread() << "was lost, attempting to reconnect..."; + dbConnect(db); + } + + return db; } @@ -90,6 +97,12 @@ void AbstractSqlStorage::addConnectionToPool() db.setPassword(password()); } + dbConnect(db); +} + + +void AbstractSqlStorage::dbConnect(QSqlDatabase &db) +{ if (!db.open()) { quWarning() << "Unable to open database" << displayName() << "for thread" << QThread::currentThread(); quWarning() << "-" << db.lastError().text(); diff --git a/src/core/abstractsqlstorage.h b/src/core/abstractsqlstorage.h index 90a8aa9..c39e826 100644 --- a/src/core/abstractsqlstorage.h +++ b/src/core/abstractsqlstorage.h @@ -87,6 +87,7 @@ private slots: private: void addConnectionToPool(); + void dbConnect(QSqlDatabase &db); int _schemaVersion; bool _debug; debian/patches/kubuntu_02_enable_message_indicator.diff0000664000000000000000000000463512314413402020517 0ustar Index: quassel-0.9~beta1/src/qtui/indicatornotificationbackend.cpp =================================================================== --- quassel-0.9~beta1.orig/src/qtui/indicatornotificationbackend.cpp 2013-03-06 14:54:18.000000000 -0500 +++ quassel-0.9~beta1/src/qtui/indicatornotificationbackend.cpp 2013-03-06 15:18:07.516584109 -0500 @@ -44,7 +44,7 @@ : AbstractNotificationBackend(parent) { NotificationSettings notificationSettings; - _enabled = notificationSettings.value("Indicator/Enabled", false).toBool(); + _enabled = notificationSettings.value("Indicator/Enabled", true).toBool(); notificationSettings.notify("Indicator/Enabled", this, SLOT(enabledChanged(const QVariant &))); @@ -210,7 +210,7 @@ void IndicatorNotificationBackend::ConfigWidget::load() { NotificationSettings s; - enabled = s.value("Indicator/Enabled", false).toBool(); + enabled = s.value("Indicator/Enabled", true).toBool(); ui.enabled->setChecked(enabled); setChangedState(false); Index: quassel-0.9~beta1/src/qtui/settingspages/appearancesettingspage.ui =================================================================== --- quassel-0.9~beta1.orig/src/qtui/settingspages/appearancesettingspage.ui 2013-03-06 14:54:18.000000000 -0500 +++ quassel-0.9~beta1/src/qtui/settingspages/appearancesettingspage.ui 2013-03-06 15:16:16.904579806 -0500 @@ -150,13 +150,13 @@ Show system tray icon - true + false UseSystemTrayIcon - true + false Index: quassel-0.9~beta1/src/qtui/qtui.cpp =================================================================== --- quassel-0.9~beta1.orig/src/qtui/qtui.cpp 2013-03-06 14:54:18.000000000 -0500 +++ quassel-0.9~beta1/src/qtui/qtui.cpp 2013-03-06 15:19:15.164586738 -0500 @@ -80,7 +80,7 @@ { _mainWin->init(); QtUiSettings uiSettings; - uiSettings.initAndNotify("UseSystemTrayIcon", this, SLOT(useSystemTrayChanged(QVariant)), true); + uiSettings.initAndNotify("UseSystemTrayIcon", this, SLOT(useSystemTrayChanged(QVariant)), false); GraphicalUi::init(); // needs to be called after the mainWin is initialized } debian/patches/Implement_custom_deserializer.patch0000664000000000000000000007411713272250641017742 0ustar Backported from 0.12 branch: From 18389a713a6810f57ab237b945e8ee03df857b8b Mon Sep 17 00:00:00 2001 From: Janne Koschinski Date: Mon, 2 Apr 2018 22:26:34 +0200 Subject: [PATCH] Implement custom deserializer to add our own sanity checks This is a rough first implementation in preparation of writing proper serializers independently of QDataStream. Thanks to @chaign_c (https://twitter.com/chaign_c/) for finding issues with QDataStream that prompted this change. (cherry picked from commit 2b777e99fc9f74d4ed21491710260664a1721d1f)) --- src/common/CMakeLists.txt | 2 + src/common/protocols/datastream/datastreampeer.cpp | 4 +- src/common/protocols/legacy/legacypeer.cpp | 19 +- src/common/serializers/serializers.cpp | 676 +++++++++++++++++++++ src/common/serializers/serializers.h | 117 ++++ 5 files changed, 812 insertions(+), 6 deletions(-) create mode 100644 src/common/serializers/serializers.cpp create mode 100644 src/common/serializers/serializers.h diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txt index bb3aef27a..4ad9d1c55 100644 --- a/src/common/CMakeLists.txt +++ b/src/common/CMakeLists.txt @@ -39,6 +39,8 @@ set(SOURCES syncableobject.cpp util.cpp + serializers/serializers.cpp + protocols/datastream/datastreampeer.cpp protocols/legacy/legacypeer.cpp ) diff --git a/src/common/protocols/datastream/datastreampeer.cpp b/src/common/protocols/datastream/datastreampeer.cpp index cddd06719..c3d9f7f07 100644 --- a/src/common/protocols/datastream/datastreampeer.cpp +++ b/src/common/protocols/datastream/datastreampeer.cpp @@ -25,6 +25,7 @@ #include "datastreampeer.h" #include "quassel.h" +#include "serializers/serializers.h" using namespace Protocol; @@ -59,7 +60,8 @@ void DataStreamPeer::processMessage(const QByteArray &msg) QDataStream stream(msg); stream.setVersion(QDataStream::Qt_4_2); QVariantList list; - stream >> list; + if (!Serializers::deserialize(stream, list)) + close("Peer sent corrupt data, closing down!"); if (stream.status() != QDataStream::Ok) { close("Peer sent corrupt data, closing down!"); return; diff --git a/src/common/protocols/legacy/legacypeer.cpp b/src/common/protocols/legacy/legacypeer.cpp index 2a9764117..2a6a776cf 100644 --- a/src/common/protocols/legacy/legacypeer.cpp +++ b/src/common/protocols/legacy/legacypeer.cpp @@ -23,6 +23,7 @@ #include "legacypeer.h" #include "quassel.h" +#include "serializers/serializers.h" /* version.inc is no longer used for this */ const uint protocolVersion = 10; @@ -62,7 +63,10 @@ void LegacyPeer::processMessage(const QByteArray &msg) QVariant item; if (_useCompression) { QByteArray rawItem; - stream >> rawItem; + if (!Serializers::deserialize(stream, rawItem)) { + close("Peer sent corrupt data: unable to load QVariant!"); + return; + } int nbytes = rawItem.size(); if (nbytes <= 4) { @@ -77,10 +81,15 @@ void LegacyPeer::processMessage(const QByteArray &msg) QDataStream itemStream(&rawItem, QIODevice::ReadOnly); itemStream.setVersion(QDataStream::Qt_4_2); - itemStream >> item; - } - else { - stream >> item; + if (!Serializers::deserialize(itemStream, item)) { + close("Peer sent corrupt data: unable to load QVariant!"); + return; + } + } else { + if (!Serializers::deserialize(stream, item)) { + close("Peer sent corrupt data: unable to load QVariant!"); + return; + } } if (stream.status() != QDataStream::Ok || !item.isValid()) { diff --git a/src/common/serializers/serializers.cpp b/src/common/serializers/serializers.cpp new file mode 100644 index 000000000..dbba9a8e5 --- /dev/null +++ b/src/common/serializers/serializers.cpp @@ -0,0 +1,658 @@ +/*************************************************************************** + * Copyright (C) 2005-2018 by the Quassel Project * + * devel@quassel-irc.org * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) version 3. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the * + * Free Software Foundation, Inc., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * + ***************************************************************************/ + +#include "serializers.h" + +bool checkStreamValid(QDataStream &stream) +{ + if (stream.status() != QDataStream::Ok) { + qWarning() << "Peer sent corrupt data"; + return false; + } + + return true; +} + +bool Serializers::deserialize(QDataStream &stream, QVariantList &data) +{ + uint32_t size; + if (!deserialize(stream, size)) + return false; + if (size > 4 * 1024 * 1024) { + qWarning() << "Peer sent too large QVariantList: " << size; + return false; + } + for (uint32_t i = 0; i < size; i++) { + QVariant element; + if (!deserialize(stream, element)) + return false; + data << element; + } + return checkStreamValid(stream); +} + +bool Serializers::deserialize(QDataStream &stream, QVariantMap &data) +{ + uint32_t size; + if (!deserialize(stream, size)) + return false; + if (size > 4 * 1024 * 1024) { + qWarning() << "Peer sent too large QVariantMap: " << size; + return false; + } + for (uint32_t i = 0; i < size; i++) { + QString key; + QVariant value; + if (!deserialize(stream, key)) + return false; + if (!deserialize(stream, value)) + return false; + data[key] = value; + } + return checkStreamValid(stream); +} + +bool Serializers::deserialize(QDataStream &stream, QVariant &data) +{ + quint32 type; + int8_t isNull; + if (!deserializeVariantType(stream, type)) + return false; + if (!deserialize(stream, isNull)) + return false; + if (type == Types::VariantType::UserType) { + QByteArray name; + if (!deserialize(stream, name)) + return false; + while (name.length() > 0 && name.at(name.length() - 1) == 0) + name.chop(1); + if (!deserializeQuasselType(stream, data, Types::fromName(name))) + return false; + } else { + if (!deserializeVariantType(stream, data, type)) + return false; + } + return checkStreamValid(stream); +} + +bool Serializers::deserializeVariantType(QDataStream &stream, QVariant &data, quint32 type) +{ + switch (type) { + case Types::VariantType::Void: { + return true; + } + case Types::VariantType::Bool: { + bool content; + if (!deserialize(stream, content)) + return false; + data = QVariant(content); + return true; + } + case Types::VariantType::Int: { + int32_t content; + if (!deserialize(stream, content)) + return false; + data = QVariant(content); + return true; + } + case Types::VariantType::UInt: { + uint32_t content; + if (!deserialize(stream, content)) + return false; + data = QVariant(content); + return true; + } + case Types::VariantType::QChar: { + QChar content; + if (!deserialize(stream, content)) + return false; + data = QVariant(content); + return true; + } + case Types::VariantType::QVariantMap: { + QVariantMap content; + if (!deserialize(stream, content)) + return false; + data = QVariant(content); + return true; + } + case Types::VariantType::QVariantList: { + QVariantList content; + if (!deserialize(stream, content)) + return false; + data = QVariant(content); + return true; + } + case Types::VariantType::QString: { + QString content; + if (!deserialize(stream, content)) + return false; + data = QVariant(content); + return true; + } + case Types::VariantType::QStringList: { + QStringList content; + if (!deserialize(stream, content)) + return false; + data = QVariant(content); + return true; + } + case Types::VariantType::QByteArray: { + QByteArray content; + if (!deserialize(stream, content)) + return false; + data = QVariant(content); + return true; + } + case Types::VariantType::QDate: { + QDate content; + if (!deserialize(stream, content)) + return false; + data = QVariant(content); + return true; + } + case Types::VariantType::QTime: { + QTime content; + if (!deserialize(stream, content)) + return false; + data = QVariant(content); + return true; + } + case Types::VariantType::QDateTime: { + QDateTime content; + if (!deserialize(stream, content)) + return false; + data = QVariant(content); + return true; + } + case Types::VariantType::Long: { + qlonglong content; + if (!deserialize(stream, content)) + return false; + data = QVariant(content); + return true; + } + case Types::VariantType::Short: { + int16_t content; + if (!deserialize(stream, content)) + return false; + data = QVariant(content); + return true; + } + case Types::VariantType::Char: { + int8_t content; + if (!deserialize(stream, content)) + return false; + data = QVariant(content); + return true; + } + case Types::VariantType::ULong: { + qulonglong content; + if (!deserialize(stream, content)) + return false; + data = QVariant(content); + return true; + } + case Types::VariantType::UShort: { + uint16_t content; + if (!deserialize(stream, content)) + return false; + data = QVariant(content); + return true; + } + case Types::VariantType::UChar: { + uint8_t content; + if (!deserialize(stream, content)) + return false; + data = QVariant(content); + return true; + } + case Types::VariantType::QVariant: { + QVariant content; + if (!deserialize(stream, content)) + return false; + data = QVariant(content); + return true; + } + default: { + qWarning() << "Usertype should have been caught earlier already"; + return false; + } + } +} + +bool Serializers::deserializeQuasselType(QDataStream &stream, QVariant &data, Types::QuasselType::Enum type) +{ + switch (type) { + case Types::QuasselType::BufferId: { + BufferId content; + if (!deserialize(stream, content)) + return false; + data = qVariantFromValue(content); + return true; + } + case Types::QuasselType::BufferInfo: { + BufferInfo content; + if (!deserialize(stream, content)) + return false; + data = qVariantFromValue(content); + return true; + } + case Types::QuasselType::Identity: { + Identity content; + if (!deserialize(stream, content)) + return false; + data = qVariantFromValue(content); + return true; + } + case Types::QuasselType::IdentityId: { + IdentityId content; + if (!deserialize(stream, content)) + return false; + data = qVariantFromValue(content); + return true; + } + case Types::QuasselType::Message: { + Message content; + if (!deserialize(stream, content)) + return false; + data = qVariantFromValue(content); + return true; + } + case Types::QuasselType::MsgId: { + MsgId content; + if (!deserialize(stream, content)) + return false; + data = qVariantFromValue(content); + return true; + } + case Types::QuasselType::NetworkId: { + NetworkId content; + if (!deserialize(stream, content)) + return false; + data = qVariantFromValue(content); + return true; + } + case Types::QuasselType::NetworkInfo: { + NetworkInfo content; + if (!deserialize(stream, content)) + return false; + data = qVariantFromValue(content); + return true; + } + case Types::QuasselType::Network_Server: { + Network::Server content; + if (!deserialize(stream, content)) + return false; + data = qVariantFromValue(content); + return true; + } + default: { + qWarning() << "Invalid QType"; + return false; + } + } +} + +bool Serializers::deserializeVariantType(QDataStream &stream, quint32 &data) +{ + uint32_t raw; + if (!deserialize(stream, raw)) + return false; + data = static_cast(raw); + return checkStreamValid(stream); +} + +bool Serializers::deserialize(QDataStream &stream, QStringList &data) +{ + uint32_t size; + if (!deserialize(stream, size)) + return false; + for (uint32_t i = 0; i < size; i++) { + QString element; + if (!deserialize(stream, element)) + return false; + data << element; + } + return checkStreamValid(stream); +} + +bool Serializers::deserialize(QDataStream &stream, Network::Server &server) +{ + QVariantMap serverMap; + if (!deserialize(stream, serverMap)) + return false; + server.host = serverMap["Host"].toString(); + server.port = serverMap["Port"].toUInt(); + server.password = serverMap["Password"].toString(); + server.useSsl = serverMap["UseSSL"].toBool(); + server.sslVersion = serverMap["sslVersion"].toInt(); + server.useProxy = serverMap["UseProxy"].toBool(); + server.proxyType = serverMap["ProxyType"].toInt(); + server.proxyHost = serverMap["ProxyHost"].toString(); + server.proxyPort = serverMap["ProxyPort"].toUInt(); + server.proxyUser = serverMap["ProxyUser"].toString(); + server.proxyPass = serverMap["ProxyPass"].toString(); + return checkStreamValid(stream); +} + +bool Serializers::deserialize(QDataStream &stream, Identity &data) +{ + QVariantMap raw; + if (!deserialize(stream, raw)) + return false; + data.fromVariantMap(raw); + return checkStreamValid(stream); +} + +bool Serializers::deserialize(QDataStream &stream, NetworkInfo &info) +{ + QVariantMap i; + if (!deserialize(stream, i)) + return false; + info.networkId = i["NetworkId"].value(); + info.networkName = i["NetworkName"].toString(); + info.identity = i["Identity"].value(); + info.codecForServer = i["CodecForServer"].toByteArray(); + info.codecForEncoding = i["CodecForEncoding"].toByteArray(); + info.codecForDecoding = i["CodecForDecoding"].toByteArray(); + info.serverList = fromVariantList(i["ServerList"].toList()); + info.useRandomServer = i["UseRandomServer"].toBool(); + info.perform = i["Perform"].toStringList(); + info.useAutoIdentify = i["UseAutoIdentify"].toBool(); + info.autoIdentifyService = i["AutoIdentifyService"].toString(); + info.autoIdentifyPassword = i["AutoIdentifyPassword"].toString(); + info.useSasl = i["UseSasl"].toBool(); + info.saslAccount = i["SaslAccount"].toString(); + info.saslPassword = i["SaslPassword"].toString(); + info.useAutoReconnect = i["UseAutoReconnect"].toBool(); + info.autoReconnectInterval = i["AutoReconnectInterval"].toUInt(); + info.autoReconnectRetries = i["AutoReconnectRetries"].toInt(); + info.unlimitedReconnectRetries = i["UnlimitedReconnectRetries"].toBool(); + info.rejoinChannels = i["RejoinChannels"].toBool(); + return checkStreamValid(stream); +} + +bool Serializers::deserialize(QDataStream &stream, QByteArray &data) +{ + data.clear(); + uint32_t length; + if (!deserialize(stream, length)) + return false; + // -1 - or 0xffffffff - is used for an empty byte array + if (length == 0xffffffff) { + return true; + } + + // 64 MB should be enough + if (length > 64 * 1024 * 1024) { + qWarning() << "Peer sent too large QByteArray: " << length; + return false; + } + + const uint32_t Step = 1024 * 1024; + uint32_t allocated = 0; + do { + int blockSize = qMin(Step, length - allocated); + data.resize(allocated + blockSize); + if (stream.readRawData(data.data() + allocated, blockSize) != blockSize) { + data.clear(); + qWarning() << "BufferUnderFlow while reading QByteArray"; + return false; + } + allocated += blockSize; + } while (allocated < length); + return checkStreamValid(stream); +} + +bool Serializers::deserialize(QDataStream &stream, QString &data) +{ + uint32_t bytes = 0; + // read size of string + if (!deserialize(stream, bytes)) + return false; + + // empty string + if (bytes == 0) { + return true; + } + + // null string + if (bytes == 0xffffffff) { + data.clear(); + return true; + } + + // 64 MB should be enough + if (bytes > 64 * 1024 * 1024) { + qWarning() << "Peer sent too large QString: " << bytes; + return false; + } + + if (bytes & 0x1) { + data.clear(); + qWarning() << "Read corrupted data: UTF-6 String with odd length: " << bytes; + return false; + } + const uint32_t step = 1024 * 1024; + uint32_t length = bytes / 2; + uint32_t allocated = 0; + while (allocated < length) { + int blockSize = qMin(step, length - allocated); + data.resize(allocated + blockSize); + if (stream.readRawData(reinterpret_cast(data.data()) + allocated * 2, blockSize * 2) != blockSize * 2) { + data.clear(); + qWarning() << "BufferUnderFlow while reading QString"; + return false; + } + allocated += blockSize; + } + if ((stream.byteOrder() == QDataStream::BigEndian) != (QSysInfo::ByteOrder == QSysInfo::BigEndian)) { + uint16_t *rawData = reinterpret_cast(data.data()); + while (length--) { + *rawData = qbswap(*rawData); + ++rawData; + } + } + return checkStreamValid(stream); +} + +bool Serializers::deserialize(QDataStream &stream, QChar &data) +{ + stream >> data; + return checkStreamValid(stream); +} + +bool Serializers::deserialize(QDataStream &stream, QDate &data) +{ + stream >> data; + return checkStreamValid(stream); +} + +bool Serializers::deserialize(QDataStream &stream, QTime &data) +{ + stream >> data; + return checkStreamValid(stream); +} + +bool Serializers::deserialize(QDataStream &stream, QDateTime &data) +{ + stream >> data; + return checkStreamValid(stream); +} + +bool Serializers::deserialize(QDataStream &stream, int32_t &data) +{ + stream >> data; + return checkStreamValid(stream); +} + +bool Serializers::deserialize(QDataStream &stream, uint32_t &data) +{ + stream >> data; + return checkStreamValid(stream); +} + +bool Serializers::deserialize(QDataStream &stream, int16_t &data) +{ + stream >> data; + return checkStreamValid(stream); +} + +bool Serializers::deserialize(QDataStream &stream, uint16_t &data) +{ + stream >> data; + return checkStreamValid(stream); +} + +bool Serializers::deserialize(QDataStream &stream, int8_t &data) +{ + stream >> data; + return checkStreamValid(stream); +} + +bool Serializers::deserialize(QDataStream &stream, uint8_t &data) +{ + stream >> data; + return checkStreamValid(stream); +} + +bool Serializers::deserialize(QDataStream &stream, qlonglong &data) +{ + stream >> data; + return checkStreamValid(stream); +} + +bool Serializers::deserialize(QDataStream &stream, qulonglong &data) +{ + stream >> data; + return checkStreamValid(stream); +} + +bool Serializers::deserialize(QDataStream &stream, bool &data) +{ + stream >> data; + return checkStreamValid(stream); +} + +bool Serializers::deserialize(QDataStream &stream, BufferInfo &data) +{ + stream >> data; + return checkStreamValid(stream); +} + +bool Serializers::deserialize(QDataStream &stream, Message &data) +{ + stream >> data; + return checkStreamValid(stream); +} + +bool Serializers::deserialize(QDataStream &stream, NetworkId &data) +{ + stream >> data; + return checkStreamValid(stream); +} + +bool Serializers::deserialize(QDataStream &stream, IdentityId &data) +{ + stream >> data; + return checkStreamValid(stream); +} + +bool Serializers::deserialize(QDataStream &stream, BufferId &data) +{ + stream >> data; + return checkStreamValid(stream); +} + +bool Serializers::deserialize(QDataStream &stream, MsgId &data) +{ + stream >> data; + return checkStreamValid(stream); +} + +quint32 Serializers::Types::variantType(Serializers::Types::QuasselType::Enum type) +{ + switch (type) { + case QuasselType::BufferId: + return VariantType::UserType; + case QuasselType::BufferInfo: + return VariantType::UserType; + case QuasselType::Identity: + return VariantType::UserType; + case QuasselType::IdentityId: + return VariantType::UserType; + case QuasselType::Message: + return VariantType::UserType; + case QuasselType::MsgId: + return VariantType::UserType; + case QuasselType::NetworkId: + return VariantType::UserType; + case QuasselType::NetworkInfo: + return VariantType::UserType; + case QuasselType::Network_Server: + return VariantType::UserType; + default: + return VariantType::UserType; + } +} + +QString Serializers::Types::toName(Serializers::Types::QuasselType::Enum type) +{ + switch (type) { + case QuasselType::BufferId: + return QString("BufferId"); + case QuasselType::BufferInfo: + return QString("BufferInfo"); + case QuasselType::Identity: + return QString("Identity"); + case QuasselType::IdentityId: + return QString("IdentityId"); + case QuasselType::Message: + return QString("Message"); + case QuasselType::MsgId: + return QString("MsgId"); + case QuasselType::NetworkId: + return QString("NetworkId"); + case QuasselType::NetworkInfo: + return QString("NetworkInfo"); + case QuasselType::Network_Server: + return QString("Network::Server"); + default: + return QString("Invalid Type"); + } +} + +Serializers::Types::QuasselType::Enum Serializers::Types::fromName(::QByteArray &name) +{ + if (qstrcmp(name, "BufferId") == 0) return QuasselType::BufferId; + else if (qstrcmp(name, "BufferInfo") == 0) return QuasselType::BufferInfo; + else if (qstrcmp(name, "Identity") == 0) return QuasselType::Identity; + else if (qstrcmp(name, "IdentityId") == 0) return QuasselType::IdentityId; + else if (qstrcmp(name, "Message") == 0) return QuasselType::Message; + else if (qstrcmp(name, "MsgId") == 0) return QuasselType::MsgId; + else if (qstrcmp(name, "NetworkId") == 0) return QuasselType::NetworkId; + else if (qstrcmp(name, "NetworkInfo") == 0) return QuasselType::NetworkInfo; + else if (qstrcmp(name, "Network::Server") == 0) return QuasselType::Network_Server; + else { + qWarning() << "Type name is not valid: " << name; + return QuasselType::Invalid; + } +} diff --git a/src/common/serializers/serializers.h b/src/common/serializers/serializers.h new file mode 100644 index 000000000..7401dad96 --- /dev/null +++ b/src/common/serializers/serializers.h @@ -0,0 +1,119 @@ +/*************************************************************************** + * Copyright (C) 2005-2018 by the Quassel Project * + * devel@quassel-irc.org * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) version 3. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the * + * Free Software Foundation, Inc., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * + ***************************************************************************/ + +#pragma once + +#include +#include +#include +#include +#include +#include + +#include "bufferinfo.h" +#include "identity.h" +#include "message.h" +#include "network.h" + +namespace Serializers { + namespace Types { + namespace VariantType { + enum Enum { + Void = 0, + Bool = 1, + Int = 2, + UInt = 3, + + QChar = 7, + QVariantMap = 8, + QVariantList = 9, + QString = 10, + QStringList = 11, + QByteArray = 12, + + QDate = 14, + QTime = 15, + QDateTime = 16, + + Long = 129, + Short = 130, + Char = 131, + ULong = 132, + UShort = 133, + UChar = 134, + + QVariant = 138, + + UserType = 127 + }; + } + + namespace QuasselType { + enum Enum { + Invalid, + BufferId, + BufferInfo, + Identity, + IdentityId, + Message, + MsgId, + NetworkId, + NetworkInfo, + Network_Server + }; + } + + quint32 variantType(QuasselType::Enum type); + QString toName(QuasselType::Enum type); + Types::QuasselType::Enum fromName(::QByteArray &name); + } + + bool deserialize(QDataStream &stream, QVariant &data); + bool deserialize(QDataStream &stream, QVariantList &list); + bool deserialize(QDataStream &stream, QVariantMap &data); + bool deserializeVariantType(QDataStream &stream, QVariant &data, quint32 type); + bool deserializeQuasselType(QDataStream &stream, QVariant &data, Types::QuasselType::Enum type); + bool deserialize(QDataStream &stream, bool &data); + bool deserialize(QDataStream &stream, int8_t &data); + bool deserialize(QDataStream &stream, uint8_t &data); + bool deserialize(QDataStream &stream, int16_t &data); + bool deserialize(QDataStream &stream, uint16_t &data); + bool deserialize(QDataStream &stream, int32_t &data); + bool deserialize(QDataStream &stream, uint32_t &data); + bool deserialize(QDataStream &stream, qlonglong &data); + bool deserialize(QDataStream &stream, qulonglong &data); + bool deserializeVariantType(QDataStream &stream, quint32 &data); + bool deserialize(QDataStream &stream, QChar &data); + bool deserialize(QDataStream &stream, QString &data); + bool deserialize(QDataStream &stream, QTime &data); + bool deserialize(QDataStream &stream, QDate &data); + bool deserialize(QDataStream &stream, QDateTime &data); + bool deserialize(QDataStream &stream, QByteArray &data); + bool deserialize(QDataStream &stream, QStringList &data); + bool deserialize(QDataStream &stream, Message &data); + bool deserialize(QDataStream &stream, BufferInfo &data); + bool deserialize(QDataStream &stream, BufferId &data); + bool deserialize(QDataStream &stream, IdentityId &data); + bool deserialize(QDataStream &stream, NetworkId &data); + bool deserialize(QDataStream &stream, MsgId &data); + bool deserialize(QDataStream &stream, NetworkInfo &data); + bool deserialize(QDataStream &stream, Identity &data); + bool deserialize(QDataStream &stream, Network::Server &data); +}; debian/patches/CVE-2015-2778.patch0000664000000000000000000004511012521741660013254 0ustar >From b5e38970ffd55e2dd9f706ce75af9a8d7730b1b8 Mon Sep 17 00:00:00 2001 From: Michael Marley Date: Sat, 21 Feb 2015 07:33:57 -0500 Subject: [PATCH] Improve the message-splitting algorithm for PRIVMSG and CTCP This introduces a new message splitting algorithm based on QTextBoundaryFinder. It works by first starting with the entire message to be sent, encoding it, and checking to see if it is over the maximum message length. If it is, it uses QTBF to find the word boundary most immediately preceding the maximum length. If no suitable boundary can be found, it falls back to searching for grapheme boundaries. It repeats this process until the entire message has been sent. Unlike what it replaces, the new splitting code is not recursive and cannot cause stack overflows. Additionally, if it is unable to split a string, it will give up gracefully and not crash the core or cause a thread to run away. This patch fixes two bugs. The first is garbage characters caused by accidentally splitting the string in the middle of a multibyte character. Since the new code splits at a character level instead of a byte level, this will no longer be an issue. The second is the core crash caused by sending an overlength CTCP query ("/me") containing only multibyte characters. This bug was caused by the old CTCP splitter using the byte index from lastParamOverrun() as a character index for a QString. --- src/core/corebasichandler.cpp | 3 ++ src/core/corebasichandler.h | 1 + src/core/corenetwork.cpp | 86 +++++++++++++++++++++++++++++++++++++++ src/core/corenetwork.h | 5 +++ src/core/coreuserinputhandler.cpp | 72 +++++++++++--------------------- src/core/coreuserinputhandler.h | 2 +- src/core/ctcpparser.cpp | 26 +++--------- 7 files changed, 124 insertions(+), 71 deletions(-) Index: quassel-0.10.0/src/core/corebasichandler.cpp =================================================================== --- quassel-0.10.0.orig/src/core/corebasichandler.cpp +++ quassel-0.10.0/src/core/corebasichandler.cpp @@ -33,6 +33,9 @@ CoreBasicHandler::CoreBasicHandler(CoreN connect(this, SIGNAL(putCmd(QString, const QList &, const QByteArray &)), network(), SLOT(putCmd(QString, const QList &, const QByteArray &))); + connect(this, SIGNAL(putCmd(QString, const QList > &, const QByteArray &)), + network(), SLOT(putCmd(QString, const QList > &, const QByteArray &))); + connect(this, SIGNAL(putRawLine(const QByteArray &)), network(), SLOT(putRawLine(const QByteArray &))); } Index: quassel-0.10.0/src/core/corebasichandler.h =================================================================== --- quassel-0.10.0.orig/src/core/corebasichandler.h +++ quassel-0.10.0/src/core/corebasichandler.h @@ -55,6 +55,7 @@ public: signals: void displayMsg(Message::Type, BufferInfo::Type, const QString &target, const QString &text, const QString &sender = "", Message::Flags flags = Message::None); void putCmd(const QString &cmd, const QList ¶ms, const QByteArray &prefix = QByteArray()); + void putCmd(const QString &cmd, const QList > ¶ms, const QByteArray &prefix = QByteArray()); void putRawLine(const QByteArray &msg); protected: Index: quassel-0.10.0/src/core/corenetwork.cpp =================================================================== --- quassel-0.10.0.orig/src/core/corenetwork.cpp +++ quassel-0.10.0/src/core/corenetwork.cpp @@ -283,6 +283,16 @@ void CoreNetwork::putCmd(const QString & } +void CoreNetwork::putCmd(const QString &cmd, const QList > ¶ms, const QByteArray &prefix) +{ + QListIterator > i(params); + while (i.hasNext()) { + QList msg = i.next(); + putCmd(cmd, msg, prefix); + } +} + + void CoreNetwork::setChannelJoined(const QString &channel) { _autoWhoQueue.prepend(channel.toLower()); // prepend so this new chan is the first to be checked @@ -979,3 +989,82 @@ void CoreNetwork::requestSetNetworkInfo( } } } + + +CoreNetwork::SplitGenerator::~SplitGenerator() {} + + +QList > CoreNetwork::splitMessage(const QString &cmd, const QString &message, SplitGenerator *cmdGenerator) +{ + QString wrkMsg(message); + QList > msgsToSend; + + // do while (wrkMsg.size() > 0) + do { + // First, check to see if the whole message can be sent at once. The + // cmdGenerator function is passed in by the caller and is used to encode + // and encrypt (if applicable) the message, since different callers might + // want to use different encoding or encode different values. + int splitPos = wrkMsg.size(); + QList initialSplitMsgEnc = (*cmdGenerator)(wrkMsg); + int initialOverrun = userInputHandler()->lastParamOverrun(cmd, initialSplitMsgEnc); + + if (initialOverrun) { + // If the message was too long to be sent, first try splitting it along + // word boundaries with QTextBoundaryFinder. + QString splitMsg(wrkMsg); + QTextBoundaryFinder qtbf(QTextBoundaryFinder::Word, splitMsg); + qtbf.setPosition(initialSplitMsgEnc[1].size() - initialOverrun); + QList splitMsgEnc; + int overrun = initialOverrun; + + while (overrun) { + splitPos = qtbf.toPreviousBoundary(); + + // splitPos==-1 means the QTBF couldn't find a split point at all and + // splitPos==0 means the QTBF could only find a boundary at the beginning of + // the string. Neither one of these works for us. + if (splitPos > 0) { + // If a split point could be found, split the message there, calculate the + // overrun, and continue with the loop. + splitMsg = splitMsg.left(splitPos); + splitMsgEnc = (*cmdGenerator)(splitMsg); + overrun = userInputHandler()->lastParamOverrun(cmd, splitMsgEnc); + } + else { + // If a split point could not be found (the beginning of the message + // is reached without finding a split point short enough to send) and we + // are still in Word mode, switch to Grapheme mode. We also need to restore + // the full wrkMsg to splitMsg, since splitMsg may have been cut down during + // the previous attempt to find a split point. + if (qtbf.type() == QTextBoundaryFinder::Word) { + splitMsg = wrkMsg; + splitPos = splitMsg.size(); + QTextBoundaryFinder graphemeQtbf(QTextBoundaryFinder::Grapheme, splitMsg); + graphemeQtbf.setPosition(initialSplitMsgEnc[1].size() - initialOverrun); + qtbf = graphemeQtbf; + } + else { + // If the QTBF fails to find a split point in Grapheme mode, we give up. + // This should never happen, but it should be handled anyway. + qWarning() << "Unexpected failure to split message!"; + return msgsToSend; + } + } + } + + // Once a message of sendable length has been found, remove it from the wrkMsg and + // add it to the list of messages to be sent. + wrkMsg.remove(0, splitPos); + msgsToSend.append(splitMsgEnc); + } + else{ + // If the entire remaining message is short enough to be sent all at once, remove + // it from the wrkMsg and add it to the list of messages to be sent. + wrkMsg.remove(0, splitPos); + msgsToSend.append(initialSplitMsgEnc); + } + } while (wrkMsg.size() > 0); + + return msgsToSend; +} Index: quassel-0.10.0/src/core/corenetwork.h =================================================================== --- quassel-0.10.0.orig/src/core/corenetwork.h +++ quassel-0.10.0/src/core/corenetwork.h @@ -93,6 +93,13 @@ public: inline quint16 localPort() const { return socket.localPort(); } inline quint16 peerPort() const { return socket.peerPort(); } + // Interface equivalent to a std::function(QString &)>. + struct SplitGenerator { + virtual ~SplitGenerator() = 0; + virtual QList operator() (QString &) = 0; + }; + QList > splitMessage(const QString &cmd, const QString &message, SplitGenerator *cmdGenerator); + public slots: virtual void setMyNick(const QString &mynick); @@ -112,6 +119,7 @@ public slots: void userInput(BufferInfo bufferInfo, QString msg); void putRawLine(QByteArray input); void putCmd(const QString &cmd, const QList ¶ms, const QByteArray &prefix = QByteArray()); + void putCmd(const QString &cmd, const QList > ¶ms, const QByteArray &prefix = QByteArray()); void setChannelJoined(const QString &channel); void setChannelParted(const QString &channel); Index: quassel-0.10.0/src/core/coreuserinputhandler.cpp =================================================================== --- quassel-0.10.0.orig/src/core/coreuserinputhandler.cpp +++ quassel-0.10.0/src/core/coreuserinputhandler.cpp @@ -468,7 +468,6 @@ void CoreUserInputHandler::handleMode(co emit putCmd("MODE", serverEncode(params)); } - // TODO: show privmsgs void CoreUserInputHandler::handleMsg(const BufferInfo &bufferInfo, const QString &msg) { @@ -477,16 +476,15 @@ void CoreUserInputHandler::handleMsg(con return; QString target = msg.section(' ', 0, 0); - QByteArray encMsg = userEncode(target, msg.section(' ', 1)); + QString msgSection = msg.section(' ', 1); #ifdef HAVE_QCA2 - putPrivmsg(serverEncode(target), encMsg, network()->cipher(target)); + putPrivmsg(target, msgSection, /*encodeForChannel=*/false, network()->cipher(target)); #else - putPrivmsg(serverEncode(target), encMsg); + putPrivmsg(target, msgSection, /*encodeForChannel=*/false); #endif } - void CoreUserInputHandler::handleNick(const BufferInfo &bufferInfo, const QString &msg) { Q_UNUSED(bufferInfo) @@ -588,11 +586,10 @@ void CoreUserInputHandler::handleSay(con if (bufferInfo.bufferName().isEmpty() || !bufferInfo.acceptsRegularMessages()) return; // server buffer - QByteArray encMsg = channelEncode(bufferInfo.bufferName(), msg); #ifdef HAVE_QCA2 - putPrivmsg(serverEncode(bufferInfo.bufferName()), encMsg, network()->cipher(bufferInfo.bufferName())); + putPrivmsg(bufferInfo.bufferName(), msg, /*encodeForChannel=*/true, network()->cipher(bufferInfo.bufferName())); #else - putPrivmsg(serverEncode(bufferInfo.bufferName()), encMsg); + putPrivmsg(bufferInfo.bufferName(), msg, /*encodeForChannel=*/true); #endif emit displayMsg(Message::Plain, bufferInfo.type(), bufferInfo.bufferName(), msg, network()->myNick(), Message::Self); } @@ -757,56 +754,37 @@ void CoreUserInputHandler::defaultHandle } -void CoreUserInputHandler::putPrivmsg(const QByteArray &target, const QByteArray &message, Cipher *cipher) -{ - // Encrypted messages need special care. There's no clear relation between cleartext and encrypted message length, - // so we can't just compute the maxSplitPos. Instead, we need to loop through the splitpoints until the crypted - // version is short enough... - // TODO: check out how the various possible encryption methods behave length-wise and make - // this clean by predicting the length of the crypted msg. - // For example, blowfish-ebc seems to create 8-char chunks. - - static const char *cmd = "PRIVMSG"; - static const char *splitter = " .,-"; - - int maxSplitPos = message.count(); - int splitPos = maxSplitPos; - forever { - QByteArray crypted = message.left(splitPos); - bool isEncrypted = false; +CoreUserInputHandler::MsgSplitGenerator::MsgSplitGenerator(CoreUserInputHandler *parent, const QString &target, bool encodeForChannel, Cipher *cipher) + : _parent(parent), _target(target), _encodeForChannel(encodeForChannel), _cipher(cipher) {} + + +CoreUserInputHandler::MsgSplitGenerator::~MsgSplitGenerator() {} + + +QList CoreUserInputHandler::CoreUserInputHandler::MsgSplitGenerator::operator() (QString &splitMsg) { + QByteArray splitMsgEnc; + if (_encodeForChannel) { + splitMsgEnc = _parent->channelEncode(_target, splitMsg); + } else { + splitMsgEnc = _parent->userEncode(_target, splitMsg); + } + #ifdef HAVE_QCA2 - if (cipher && !cipher->key().isEmpty() && !message.isEmpty()) { - isEncrypted = cipher->encrypt(crypted); - } + if (_cipher && !_cipher->key().isEmpty() && !splitMsg.isEmpty()) { + _cipher->encrypt(splitMsgEnc); + } #endif - int overrun = lastParamOverrun(cmd, QList() << target << crypted); - if (overrun) { - // In case this is not an encrypted msg, we can just cut off at the end - if (!isEncrypted) - maxSplitPos = message.count() - overrun; - - splitPos = -1; - for (const char *splitChar = splitter; *splitChar != 0; splitChar++) { - splitPos = qMax(splitPos, message.lastIndexOf(*splitChar, maxSplitPos) + 1); // keep split char on old line - } - if (splitPos <= 0 || splitPos > maxSplitPos) - splitPos = maxSplitPos; - - maxSplitPos = splitPos - 1; - if (maxSplitPos <= 0) { // this should never happen, but who knows... - qWarning() << tr("[Error] Could not encrypt your message: %1").arg(message.data()); - return; - } - continue; // we never come back here for !encrypted! - } - - // now we have found a valid splitpos (or didn't need to split to begin with) - putCmd(cmd, QList() << target << crypted); - if (splitPos < message.count()) - putPrivmsg(target, message.mid(splitPos), cipher); + QByteArray targetEnc = _parent->serverEncode(_target); + return QList() << targetEnc << splitMsgEnc; +} - return; - } + +void CoreUserInputHandler::putPrivmsg(const QString &target, const QString &message, bool encodeForChannel, Cipher *cipher) +{ + QString cmd("PRIVMSG"); + + MsgSplitGenerator cmdGenerator(this, target, encodeForChannel, cipher); + putCmd(cmd, network()->splitMessage(cmd, message, &cmdGenerator)); } Index: quassel-0.10.0/src/core/coreuserinputhandler.h =================================================================== --- quassel-0.10.0.orig/src/core/coreuserinputhandler.h +++ quassel-0.10.0/src/core/coreuserinputhandler.h @@ -36,6 +36,7 @@ public: inline CoreNetwork *coreNetwork() const { return qobject_cast(parent()); } void handleUserInput(const BufferInfo &bufferInfo, const QString &text); + int lastParamOverrun(const QString &cmd, const QList ¶ms); public slots: void handleAway(const BufferInfo &bufferInfo, const QString &text); @@ -86,8 +87,7 @@ protected: private: void doMode(const BufferInfo& bufferInfo, const QChar &addOrRemove, const QChar &mode, const QString &nickList); void banOrUnban(const BufferInfo &bufferInfo, const QString &text, bool ban); - void putPrivmsg(const QByteArray &target, const QByteArray &message, Cipher *cipher = 0); - int lastParamOverrun(const QString &cmd, const QList ¶ms); + void putPrivmsg(const QString &target, const QString &message, bool encodeForChannel, Cipher *cipher = 0); #ifdef HAVE_QCA2 QByteArray encrypt(const QString &target, const QByteArray &message, bool *didEncrypt = 0) const; @@ -100,6 +100,20 @@ private: Command() {} }; + // A SplitGenerator that generates privmsgs. + class MsgSplitGenerator : public CoreNetwork::SplitGenerator { + public: + MsgSplitGenerator(CoreUserInputHandler *parent, const QString &target, bool encodeForChannel, Cipher *cipher); + virtual ~MsgSplitGenerator(); + virtual QList operator() (QString &splitMsg); + + private: + CoreUserInputHandler *_parent; + const QString &_target; + bool _encodeForChannel; + Cipher *_cipher; + }; + QHash _delayedCommands; }; Index: quassel-0.10.0/src/core/ctcpparser.cpp =================================================================== --- quassel-0.10.0.orig/src/core/ctcpparser.cpp +++ quassel-0.10.0/src/core/ctcpparser.cpp @@ -309,11 +309,21 @@ QByteArray CtcpParser::pack(const QByteA } +CtcpParser::CtcpSplitGenerator::CtcpSplitGenerator( + CtcpParser *parent, CoreNetwork *net, const QString &bufname, const QString &ctcpTag) + : _parent(parent), _net(net), _bufname(bufname), _ctcpTag(ctcpTag) {} + +CtcpParser::CtcpSplitGenerator::~CtcpSplitGenerator() {} + +QList CtcpParser::CtcpSplitGenerator::operator() (QString &splitMsg) { + return QList() << _net->serverEncode(_bufname) << _parent->lowLevelQuote(_parent->pack(_net->serverEncode(_ctcpTag), _net->userEncode(_bufname, splitMsg))); +} + void CtcpParser::query(CoreNetwork *net, const QString &bufname, const QString &ctcpTag, const QString &message) { - QList params; - params << net->serverEncode(bufname) << lowLevelQuote(pack(net->serverEncode(ctcpTag), net->userEncode(bufname, message))); - net->putCmd("PRIVMSG", params); + QString cmd("PRIVMSG"); + CtcpSplitGenerator cmdGenerator(this, net, bufname, ctcpTag); + net->putCmd(cmd, net->splitMessage(cmd, message, &cmdGenerator)); } Index: quassel-0.10.0/src/core/ctcpparser.h =================================================================== --- quassel-0.10.0.orig/src/core/ctcpparser.h +++ quassel-0.10.0/src/core/ctcpparser.h @@ -92,6 +92,20 @@ private: CtcpReply(CoreNetwork *net, const QString &buf) : network(net), bufferName(buf) {} }; + // A SplitGenerator that generates CTCP messages. + class CtcpSplitGenerator : public CoreNetwork::SplitGenerator { + public: + CtcpSplitGenerator(CtcpParser *parent, CoreNetwork *net, const QString &bufname, const QString &ctcpTag); + virtual ~CtcpSplitGenerator(); + virtual QList operator() (QString &splitMsg); + + private: + CtcpParser *_parent; + CoreNetwork *_net; + const QString &_bufname; + const QString &_ctcpTag; + }; + QHash _replies; QHash _ctcpMDequoteHash; debian/patches/series0000664000000000000000000000037313272250641012041 0ustar kubuntu_01_default_network_channel.patch kubuntu_02_enable_message_indicator.diff CVE-2014-8483.patch CVE-2015-2778.patch CVE-2015-3427.patch Implement_custom_deserializer.patch Reject_clients_that_attempt_to_login_before_the_core_is_configured.patch debian/patches/kubuntu_01_default_network_channel.patch0000664000000000000000000000117612314413402020601 0ustar Index: quassel-0.5.0~git090717/data/networks.ini =================================================================== --- quassel-0.5.0~git090717.orig/data/networks.ini 2009-07-14 16:58:22.000000000 -0400 +++ quassel-0.5.0~git090717/data/networks.ini 2009-07-15 14:08:19.000000000 -0400 @@ -19,10 +19,14 @@ Servers=irc.enterthegame.com:6667 [Freenode] -Default=Yes DefaultChannels=#quassel Servers=chat.freenode.net:6665,chat.freenode.net:7000 +[Kubuntu IRC] +Default=Yes +DefaultChannels=#kubuntu +Servers=irc.ubuntu.com:8001 + [GalaxyNet] Servers=irc.galaxynet.org:6662,irc.galaxynet.org:7000,boston.ma.us.galaxynet.org:6661 debian/quassel-qt4-data.install0000664000000000000000000000037612314413402013652 0ustar usr/share/apps/quassel/icons/oxygen/16x16 usr/share/apps/quassel/icons/oxygen/48x48 usr/share/apps/quassel/icons/oxygen/128x128 usr/share/apps/quassel/icons/oxygen/22x22 usr/share/apps/quassel/icons/oxygen/32x32 usr/share/apps/quassel/icons/oxygen/64x64 debian/quassel-core.manpages0000664000000000000000000000001612314413402013277 0ustar quasselcore.1 debian/copyright0000664000000000000000000001010112314413402011106 0ustar This package was debianized by Harald Sitter on Thu, 15 May 2008 18:17:16 +0200. It was downloaded from http://www.quassel-irc.org Upstream Author: Quassel IRC Team Copyright: © 2005-2010 Quassel IRC Team License: This package is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) version 3. This package is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this package; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA On Debian systems, the complete text of the GNU General Public License can be found in '/usr/share/common-licenses/GPL'. This license also applies to: src/qtui/indicatornotificationbackend.* Copyright © 2009 Canonical Ltd data/scripts/mpris Copyright © 2009 by Sebastian Goth seezer@roath.org Files in icons/oxygen/ are: Copyright © 2007 David Vignoni Copyright © 2007 Johann Ollivier Lapeyre Copyright © 2007 Kenneth Wimer Copyright © 2007 Nuno Fernades Pinheiro Copyright © 2007 Riccardo Iaconelli Copyright © 2007 David Miller License: This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library. If not, see . On Debian systems, the complete text of the GNU Library General Public License version 3 can be found in '/usr/share/common-licenses/LGPL-3 For data/scripts/inxi: inxi is a fork of infobash 3.02, the original bash sys info script by locsmif As time permits functionality improvements and recoding will occur. inxi, the universal, portable, system info script for irc. Tested with Irssi, Xchat, Konversation, BitchX, KSirc, ircII, Gaim/Pidgin, Weechat, KVIrc and Kopete. Original infobash author and copyright holder: Copyright (C) 2005-2007 Michiel de Boer a.k.a. locsmif inxi version: Copyright (C) 2008-9 Scott Rogers & Harald Hope Further fixes (listed as known): Horst Tritremmel Steven Barrett (aka: damentz) - usb audio patch; swap percent used patch Current script home page: http://techpatterns.com/forums/about1131.html Script svn: http://code.google.com/p/inxi This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . The Debian packaging is © 2008, Harald Sitter and is licensed under the GPL version 2, or (at your option) any later version, see `/usr/share/common-licenses/GPL'. debian/rules0000775000000000000000000000332612314413402010246 0ustar #!/usr/bin/make -f include /usr/share/dpkg/pkg-info.mk CMAKE_OPTIONS = -DWANT_MONO=ON -DEMBED_DATA=OFF DPKG_EXPORT_BUILDFLAGS = 1 export DEB_BUILD_MAINT_OPTIONS = hardening=+pie,+bindnow include /usr/share/dpkg/buildflags.mk CXXFLAGS += $(CPPFLAGS) %: dh $@ --buildsystem=cmake --with=kde --parallel override_dh_clean: dh_clean rm -rf debian/build-qt4 debian/tmp-qt4 override_dh_auto_configure: dh_auto_configure -Skde -- -DWITH_KDE=ON $(CMAKE_OPTIONS) dh_auto_configure -Bdebian/build-qt4 -- -DWITH_KDE=OFF -DWANT_CORE=OFF -DWITH_OXYGEN=ON $(CMAKE_OPTIONS) override_dh_auto_build: dh_auto_build -Skde dh_auto_build -Bdebian/build-qt4 pod2man --section=1 --release=$(DEB_VERSION_UPSTREAM) --center "" debian/mans/quassel.pod > quassel.1 pod2man --section=1 --release=$(DEB_VERSION_UPSTREAM) --center "" debian/mans/quasselcore.pod > quasselcore.1 pod2man --section=1 --release=$(DEB_VERSION_UPSTREAM) --center "" debian/mans/quasselclient.pod > quasselclient.1 override_dh_auto_install: dh_auto_install -Skde dh_auto_install -Bdebian/build-qt4 --destdir=$(CURDIR)/debian/tmp-qt4 override_dh_install: dh_install -pquassel-qt4 -pquassel-client-qt4 -pquassel-qt4-data --sourcedir=debian/tmp-qt4 dh_install --remaining-packages -Xusr/share/kde4/apps/quassel/icons/oxygen/scalable --list-missing install -o root -g root -m 644 debian/quassel-core.ufw.profile debian/quassel-core/etc/ufw/applications.d/quasselcore override_dh_installinit: dh_apparmor -pquassel-core --profile-name=usr.bin.quasselcore dh_installinit -R --error-handler=exit --name=quasselcore override_dh_strip: # only strip the KDE stuff to the dbg package dh_strip -Nquassel-qt4 -Nquassel-client-qt4 --dbg-package=quassel-dbg dh_strip --remaining-packages debian/quassel-client.manpages0000664000000000000000000000002012314413402013620 0ustar quasselclient.1 debian/quassel-client-qt4.manpages0000664000000000000000000000002012314413402014326 0ustar quasselclient.1 debian/mans/0000775000000000000000000000000012321324431010121 5ustar debian/mans/quasselcore.pod0000664000000000000000000000436112321324431013157 0ustar =head1 NAME Quasselcore - Distributed IRC client, server-only binary =head1 SYNOPSIS quasselcore =head1 DESCRIPTION B is part of Quassel, which is a modern, cross-platform, distributed IRC client, meaning that one (or multiple) client(s) can attach to and detach from a central core. It's much like the popular combination of screen and a text-based IRC client such as WeeChat, but graphical. =head1 USAGE Usage: "quasselcore" [arguments] -h, --help Display this help and exit --add-user Starts an interactive session to add a new core user --change-userpass=[CHANGE-USERPASS] Starts an interactive session to change the password of the user identified by username -c, --configdir=[CONFIGDIR] Specify the directory holding configuration files, the SQlite database and the SSL certificate --datadir=[DATADIR] DEPRECATED - Use --configdir instead -d, --debug Enable debug output --listen=[LISTEN] The address(es) quasselcore will listen on. Default is: ::,0.0.0.0 -l, --logfile=[LOGFILE] Log to a file -L, --loglevel=[LOGLEVEL] Loglevel Debug|Info|Warning|Error. Default is: Info -n, --norestore Don't restore last core's state --oidentd Enable oidentd integration --oidentd-conffile=[OIDENTD-CONFFILE] Set path to oidentd configuration file -p, --port=[PORT] The port quasselcore will listen at. Default is: 4242 --select-backend=[SELECT-BACKEND] Switch storage backend (migrating data if possible) --syslog Log to syslog -v, --version Display version information =head1 AUTHORS B was written by the Quassel IRC Team . This manual page was written by Harald Sitter and updated by Scott Kitterman . B is released under the GNU General Public License, version 2 or (at your option) version 3. This manual page is released under the GNU General Public License, version 2 or any later version. =cut debian/mans/quasselclient.pod0000664000000000000000000000143012314413402013476 0ustar =head1 NAME Quasselclient - Distributed IRC client, client-only binary =head1 SYNOPSIS quasselclient =head1 DESCRIPTION B is part of Quassel, which is a modern, cross-platform, distributed IRC client, meaning that one (or multiple) client(s) can attach to and detach from a central core. It's much like the popular combination of screen and a text-based IRC client such as WeeChat, but graphical. =head1 AUTHORS B was written by the Quassel IRC Team . This manual page was written by Harald Sitter . B is released under the GNU General Public License, version 2 or (at your option) version 3. This manual page is released under the GNU General Public License, version 2 or any later version. =cut debian/mans/quassel.pod0000664000000000000000000000135412314413402012304 0ustar =head1 NAME Quassel - Distributed IRC client (monolithic binary) =head1 SYNOPSIS quassel =head1 DESCRIPTION B is a modern, cross-platform, distributed IRC client, meaning that one (or multiple) client(s) can attach to and detach from a central core. It's much like the popular combination of screen and a text-based IRC client such as WeeChat, but graphical. =head1 AUTHORS B was written by the Quassel IRC Team . This manual page was written by Harald Sitter . B is released under the GNU General Public License, version 2 or (at your option) version 3. This manual page is released under the GNU General Public License, version 2 or any later version. =cut debian/docs0000664000000000000000000000000712314413402010032 0ustar README debian/quassel-core.install0000664000000000000000000000007712314413402013161 0ustar usr/bin/quasselcore debian/usr.bin.quasselcore /etc/apparmor.d debian/quassel-core.preinst0000664000000000000000000000274712314413402013205 0ustar #!/bin/sh set -e # Move data dir from /var/cache to /var/lib prep_mv_dir() { DIR="$1" if [ -e "$DIR" ]; then if [ -n "/var/lib/quassel/" ]; then mkdir "/var/lib/quassel/" chown quasselcore:quassel /var/lib/quassel/ chmod 750 /var/lib/quassel/ fi mv /var/cache/quassel/* /var/lib/quassel/ mv /var/cache/quassel/.config /var/lib/quassel/ test -d /var/cache/quassel/ && rmdir /var/cache/quassel/ fi } if [ "$1" = "upgrade" ]; then if dpkg --compare-versions "$2" le "0.7.2-0ubuntu2"; then prep_mv_dir "/var/cache/quassel" fi if dpkg --compare-versions "$2" le "0.7.2-0ubuntu3"; then if [ -d "/var/lib/quassel/" ]; then chown quasselcore:quassel /var/lib/quassel/ fi fi if dpkg --compare-versions "$2" le "0.7.3-0ubuntu1"; then if [ -d "/var/lib/quassel/" ]; then chmod 750 /var/lib/quassel/ fi if [ -d "/var/log/quassel/" ]; then chmod 750 /var/log/quassel/ fi if [ -f "/var/lib/quassel/quasselCert.pem" ]; then chmod 640 /var/lib/quassel/quasselCert.pem fi echo "Stopping quasselcore to update user home dir ..." invoke-rc.d quasselcore stop sleep 5 # wait some time for the daemon to shut down usermod --home /var/lib/quassel quasselcore fi if dpkg --compare-versions "$2" le "0.9.2-0ubuntu1"; then echo "Stopping quasselcore to switch over to Upstart ..." invoke-rc.d quasselcore stop sleep 5 # wait some time for the daemon to shut down fi fi #DEBHELPER# debian/changelog0000664000000000000000000011077213272261154011055 0ustar quassel (0.10.0-0ubuntu2.3) trusty-security; urgency=medium * SECURITY UPDATE: quasselcore, corruption of heap metadata caused by qdatastream (LP: #1767539) - debian/patches/Implement_custom_deserializer.patch: Original patch from upstream 0.12.5 release, adapted for non-C++ 11 systems by Felix Geyer - CVE-2018-1000178 * SECURITY UPDATE: quasselcore, denial of service for unconfigured core (LP: #1767539) - debian/patches/Reject_clients_that_attempt_to_login_before_the_core_is _configured.patch: Original patch from upstream 0.12.5 release, adapted for non-C++ 11 systems by Felix Geyer - CVE-2018-1000179 -- Scott Kitterman Fri, 27 Apr 2018 20:25:50 -0400 quassel (0.10.0-0ubuntu2.2) trusty-security; urgency=medium * SECURITY UPDATE: stack consumption vulnerability in message splitting code - debian/patches/CVE-2015-2778.patch: original patch from Michael Marley, backported by Steinar H. Gunderson - CVE-2015-2778 and CVE-2015-2779 * SECURITY UPDATE: SQL injection vulnerability in PostgreSQL backend - debian/patches/CVE-2015-3427.patch: upstream patch - CVE-2015-3427 - original issue was CVE-2013-4422 which had an incomplete fix - LP: #1448911 -- Felix Geyer Fri, 01 May 2015 18:30:44 +0200 quassel (0.10.0-0ubuntu2.1) trusty-security; urgency=medium * SECURITY UPDATE: out-of-bounds read in ECB Blowfish decryption - debian/patches/CVE-2014-8483.patch: add upstream patch - CVE-2014-8483 - LP: #1388333 -- Felix Geyer Tue, 04 Nov 2014 18:15:46 +0100 quassel (0.10.0-0ubuntu2) trusty; urgency=medium * Update quasselcore man page to cover all usage options -- Scott Kitterman Wed, 09 Apr 2014 16:10:10 -0400 quassel (0.10.0-0ubuntu1) trusty; urgency=medium * New upstream release -- Jonathan Riddell Tue, 25 Mar 2014 23:53:39 +0000 quassel (0.10~rc1-0ubuntu1) trusty; urgency=medium * New upstream RC release -- Jonathan Riddell Sun, 16 Mar 2014 17:49:07 +0000 quassel (0.10~beta1-0ubuntu1) trusty; urgency=low * New upstream beta relase - Drop debian/patches/upstream_fix_fullscreen_mode.diff which had been cherrypicked from upstream -- Scott Kitterman Tue, 18 Feb 2014 23:18:25 -0500 quassel (0.9.2-0ubuntu4) trusty; urgency=medium * Cherry pick upstream commit 47a6910aed00018c7230cc2cc90ae8e80fa77dda as upstream_fix_fullscreen_mode.diff to fix UI breakage when toggling fullscreen mode -- Philip Muškovac Mon, 23 Dec 2013 01:03:22 +0100 quassel (0.9.2-0ubuntu3) trusty; urgency=low * Revert addition of conflict relations between quassel-data and quassel-qt4-data, as the packages are usually installed at the same time and do not ship common files. (LP: #1257592) -- Luke Faraone Wed, 04 Dec 2013 00:34:49 -0500 quassel (0.9.2-0ubuntu2) trusty; urgency=low * Add quasselcore upstart job. Thanks to Michael Marley. (LP: #1244036) * Restart quasselcore after upgrades. * Make quassel-data and quassel-qt4-data conflict as they ship common files. -- Felix Geyer Mon, 02 Dec 2013 16:50:58 +0100 quassel (0.9.2-0ubuntu1) trusty; urgency=low * New upstream release - Includes fix for cross-user data exposure in the core (LP: #1255362) -- Scott Kitterman Tue, 26 Nov 2013 19:56:06 -0500 quassel (0.9.1-0ubuntu1) saucy; urgency=low * New upstream release -- Scott Kitterman Fri, 11 Oct 2013 00:06:18 -0400 quassel (0.9.0-0ubuntu1) raring; urgency=low * New upstream release -- Scott Kitterman Tue, 16 Apr 2013 21:28:37 -0400 quassel (0.9~rc1-0ubuntu1) raring; urgency=low * New upstream release -- Scott Kitterman Tue, 09 Apr 2013 19:34:42 -0400 quassel (0.9~beta1-0ubuntu2) raring; urgency=low * Fix mess with icons due to obsolete package naming and lack of sufficient hicolor icons: - Drop quassel-data depends on no longer existing kde-icons-oxygen | hicolor-icon-theme - Add Recommends: oxygen-icon-theme for quassel/quassel-core - Change build flag for Qt only build to include subset of oxygen icons shipped with quassel - Add new binary, quassel-qt4-data, to hold Qt unique icons and have the Qt only packages Recommend it -- Scott Kitterman Fri, 15 Mar 2013 15:32:25 -0400 quassel (0.9~beta1-0ubuntu1) raring; urgency=low * New upstream beta release - Remove debian/patches/0001-Support-intermediate-CA-certificates.patch, incorporated upstream - Remove 0002-Allow-the-core-to-use-expired-certificates.patch, incorporated upstream - Update kubuntu_02_enable_message_indicator.diff for 0.9 -- Scott Kitterman Wed, 06 Mar 2013 15:07:41 -0500 quassel (0.8.0-0ubuntu2) quantal; urgency=low * Add libqtwebkit-dev to build deps to enable link previews -- Rohan Garg Sun, 26 Aug 2012 13:21:16 +0530 quassel (0.8.0-0ubuntu1) precise; urgency=low * New upstream release * Add debian/patches/0001-Support-intermediate-CA-certificates.patch and 0002-Allow-the-core-to-use-expired-certificates.patch from Felix Geyer to correct issues with SSL integration -- Scott Kitterman Tue, 20 Mar 2012 18:21:56 -0400 quassel (0.8~rc1-0ubuntu2) precise; urgency=low * Build-depend on dh-apparmor. (LP: #948481) * Append $CPPFLAGS to $CXXFLAGS. * Use pkg-info.mk instead of parsing the upstream version manually. * Drop ancient Conflicts and Replaces. * Bump Standards-Version to 3.9.3, no changes needed. * Switch AppArmor profile to enforce mode. * Don't pass -DCMAKE_BUILD_TYPE=Debugfull to cmake anymore. We want the default build type RelWithDebugInfo. * Add an ufw application profile. * Use dh_install --sourcedir instead of specifying absolute paths in the install files. -- Felix Geyer Sun, 11 Mar 2012 23:00:26 +0100 quassel (0.8~rc1-0ubuntu1) precise; urgency=low * New update release candidate -- Scott Kitterman Tue, 21 Feb 2012 17:27:22 -0500 quassel (0.8~beta1-0ubuntu1) precise; urgency=low * New upstream beta release - Update quasselcore man page for new oidentd option -- Scott Kitterman Tue, 14 Feb 2012 18:38:55 -0500 quassel (0.7.3-0ubuntu4) precise; urgency=low * Enable hardening options pie and bindnow. * Drop the quasselcore-makecert manpage since we no longer provide that script. * Add an AppArmor profile for quasselcore in complain mode. -- Felix Geyer Fri, 16 Dec 2011 11:35:10 +0100 quassel (0.7.3-0ubuntu3) oneiric; urgency=low * Fix bug in quassel-core preinst script that caused upgrade commands to be run on new installations. (LP: #853841) -- Felix Geyer Mon, 19 Sep 2011 19:18:08 +0200 quassel (0.7.3-0ubuntu2) oneiric; urgency=low * Set permissions of /var/lib/quassel and /var/log/quassel to 750. (LP: #846922) * Set permissions of /var/lib/quassel/quasselCert.pem to 640. * Update home dir of quasselcore user and stop the daemon before doing so. * Drop quasselcore-makecert script since it's completely broken since at least lucid and there is no need to update the self-signed certificate. * Drop README.source since the package has been converted to the 3.0 (quilt) format. * Update watch file so it only matches real version numbers. * Bump Standards-Version to 3.9.2, no changes needed. * Use kde debhelper buildsystem instead of calling the kubuntu l10n scripts manually. * Fix typo in quasselcore init script so it waits 5 seconds before checking if quasselcore started successfully. (LP: #777191) -- Felix Geyer Mon, 12 Sep 2011 00:06:01 +0200 quassel (0.7.3-0ubuntu1) oneiric; urgency=medium * New upstream bufix release - Fix for quasselcore DoS from specially crafted CTCP requests - Translation updates -- Scott Kitterman Thu, 08 Sep 2011 15:19:49 -0400 quassel (0.7.2-0ubuntu4) oneiric; urgency=low * quassel and quassel-qt4 don't conflict with quassel-sever anymore. * Enable parallel building. * quassel-core.quasselcore.init: Add "$network $local_fs $remote_fs" to Required-Stop. * Strip binaries in *-qt4 packages. * quassel-core: Fix lintian warning maintainer-script-ignores-errors. * Drop dh_builddeb override to use lzma compression as the kde dh sequence already takes care of this. -- Felix Geyer Sun, 15 May 2011 23:14:23 +0200 quassel (0.7.2-0ubuntu3) oneiric; urgency=low * Correct /var/lib/quassel directory ownership for upgrades (LP: #777966) -- Scott Kitterman Thu, 05 May 2011 12:43:51 -0400 quassel (0.7.2-0ubuntu2) natty; urgency=low * Fix up quassel-core.preinst to finish the /var/cache to /var/lib transition (LP: #753080) -- Scott Kitterman Wed, 06 Apr 2011 22:23:47 -0400 quassel (0.7.2-0ubuntu1) natty; urgency=low * New upstream bug fix release * Move quassel-core data dir from /var/cache to /var/lib (LP: #713462) - Add quassel-core.preinst to move existing data - Update debian/quasselcore-makecert, quassel-core.postinst, quassel-core.postrm, and quassel-core.quasselcore.init for the new data dir location * Increase startup time allowance in debian/quassel-core.quasselcore.init to reduce incidence of startup failures (LP: #480022) - Thanks to Ralph Janke for the patch * Update configdir description in debian/mans/quasselcore.pod to not specifically mention SQLite since other database types are also supported * Drop temporary versioning libindicate-qt-dev build-depend -- Scott Kitterman Thu, 24 Mar 2011 09:57:49 -0400 quassel (0.7.1-0ubuntu3) natty; urgency=low * Rebuild with libindicate-qt 0.2.5.91-0ubuntu2 to fix dependency -- Jonathan Riddell Wed, 09 Feb 2011 13:38:14 +0000 quassel (0.7.1-0ubuntu2) natty; urgency=low * Build against libindicate-qt 0.2.5.91 for soname transition -- Jonathan Riddell Mon, 07 Feb 2011 18:00:27 +0000 quassel (0.7.1-0ubuntu1) maverick; urgency=high * SECURITY UPDATE: * References * Upstream Git 0f2c520a76a468d3778e031ebde2d304048e1663 - If we receive multiple CTCP requests in one PRIVMSG we now answer with one packed NOTICE containing all CTCP replies. This fixes a possible DoS Attack rendering Quassels IRC connection useless. Upgrading is strongly recommended. Thanks to Jima for reporting and supporting -- Scott Kitterman Tue, 21 Sep 2010 08:55:19 -0400 quassel (0.7.0-0ubuntu1) maverick; urgency=low * Upstream bugfix update from 0.7.0 rc1 to 0.7.0 final -- Scott Kitterman Tue, 14 Sep 2010 19:06:15 -0400 quassel (0.7~rc1-0ubuntu1) maverick; urgency=low * New upstream RC release * Add missing build-depends on libdbusmenu-qt-dev -- Scott Kitterman Wed, 25 Aug 2010 09:10:56 -0400 quassel (0.7~beta1-0ubuntu1) maverick; urgency=low * New upstream beta release - Add libqca2-dev to build-depends for blowfish support * Switch to source format v3 (Quilt) to use .bz2 tarball - Drop build-depends on quilt and update debian/rules - Add debian/source/format -- Scott Kitterman Wed, 11 Aug 2010 12:48:08 -0400 quassel (0.6.1-0ubuntu4) maverick; urgency=low * Add kubuntu_02_enable_message_indicator.diff to enable message indicator by default -- Jonathan Riddell Mon, 02 Aug 2010 10:39:51 +0100 quassel (0.6.1-0ubuntu3) maverick; urgency=low * Run kubuntu-debhelper-langpack-generate.sh and kubuntu-debhelper-langpack-clean.sh in debian/rules -- Jonathan Riddell Mon, 26 Jul 2010 17:29:17 +0100 quassel (0.6.1-0ubuntu2) maverick; urgency=low * Rebuild for qtwebkit transition -- Jonathan Riddell Fri, 23 Jul 2010 12:07:00 +0100 quassel (0.6.1-0ubuntu1) lucid; urgency=low * New upstream bugfix release - Drop debian/patches/quassel_01_dont_crash_on_startup.patch and debian/patches/quassel_02_enforce_sqlite_in_mono_client.patch -- Scott Kitterman Mon, 19 Apr 2010 08:40:10 -0400 quassel (0.6.0-0ubuntu2) lucid; urgency=low * Only strip KDE 4 packages to -dbg to make it work again, the dbg package should be dropped completely once kubuntu-debug-installer gains ddebs support. * Add quassel_01_dont_crash_on_startup.patch from upstream to fix a crash on startup. * Add quassel_02_enforce_sqlite_in_mono_client.patch to enforce usage of sqlite in the monolitic client (preventing it from whining about usage of PSQL). -- Harald Sitter Thu, 15 Apr 2010 16:13:32 +0200 quassel (0.6.0-0ubuntu1) lucid; urgency=low [ Scott Kitterman ] * New upstream release - Additional bug fixes and updated translations from the last upload * Symlink between the the expected location for architecture independent data in the KDE and Qt4 packages in quassel-data (LP: #557464) [ Harald Sitter ] * Make the init script require $remote_fs to be started -- Harald Sitter Wed, 14 Apr 2010 14:34:05 +0200 quassel (0.6~rc1+git100331-0ubuntu1) lucid; urgency=low * New upstream git snapshot - Bug fixes - Updated translations -- Scott Kitterman Wed, 31 Mar 2010 09:47:44 -0400 quassel (0.6~rc1+git100312-0ubuntu1) lucid; urgency=low * New git snapshot since the last upload was from git head and not the 0.6 branch -- Scott Kitterman Fri, 12 Mar 2010 17:12:17 -0500 quassel (0.6~rc1+git100311-0ubuntu1) lucid; urgency=low * New bugfix snapshot - "Metric ton of bug fixes" -- Scott Kitterman Thu, 11 Mar 2010 13:44:02 -0500 quassel (0.6~rc1-0ubuntu1) lucid; urgency=low * New upstream RC - Including translation updates from Launchpad -- Scott Kitterman Wed, 03 Mar 2010 11:50:11 -0500 quassel (0.6~beta1-0ubuntu1) lucid; urgency=low * New upstream beta release - Update debian/quassel-data.install for hicolor icons moving to debian/tmp/usr/share/icons/hicolor - Update debian/quassel-data.install for Quassel Oxygen icons no longer being shipped - Add qt4-dev-tools to build-depends to provide lconvert for translations * Fix debian/copyright to use the correct © symbol and update for the new year -- Scott Kitterman Wed, 17 Feb 2010 12:49:50 -0500 quassel (0.5.2-0ubuntu2) lucid; urgency=low * Do not remove quassel user or group when the core is purged (LP: #496015) - Has the potentil for leaving unowned files on the system and causes postrm failures -- Scott Kitterman Sat, 23 Jan 2010 12:49:33 -0500 quassel (0.5.2-0ubuntu1) lucid; urgency=low * New upstream bug fix release - Multiple bug fixes - CTCP ignore capability to combat Freenode spam attacks (LP: #509287) -- Scott Kitterman Mon, 18 Jan 2010 19:23:19 -0500 quassel (0.5.1+git20100117-0ubuntu1) lucid; urgency=low * New git snapshot from the upstream 0.5 branch - Mulitple bug fixes - Build system changes to work with libqt4-dev packaging changes (fix SSL support (LP: #506805) * Fix obsolete-relation-form-in-source in quassel-data * Move quassel-dbg to section debug -- Scott Kitterman Sun, 17 Jan 2010 18:20:48 -0500 quassel (0.5.1-0ubuntu5) lucid; urgency=low [ Maia Kozheva ] * The "double build" release. (LP: #374802) * debian/control: - Added quassel-qt4 and quassel-client-qt4 packages, not depending on KDE4. * debian/rules: - Added rules for the second KDE-less build, using debian/build-qt4. * Added *.install and *.manpages files for the two new packages. [ Jonathan Thomas ] * Minor gramatical fixes in package descriptions throughout * Correct all instances of "KDE4" in package descriptions to just be "KDE", as there is no longer a need to differentiate. -- Maia Kozheva Wed, 16 Dec 2009 11:24:57 +0600 quassel (0.5.1-0ubuntu4) lucid; urgency=low * Migrate from cdbs to debhelper 7 build (will enable a double build with and without kdelibs in the future): - Do not build-depend on cdbs. - Build-depend on recent enough pkg-kde-tools (for dh --with=kde). - Bumped debhelper version dependency and compat. - Rewrote debian/rules to use dh instead of cdbs. - Added debian/clean, moved manpages there from debian/rules. - Added debian/docs to install README. Previously, CDBS auto-installed README and AUTHORS. This version does not install AUTHORS, since it is redundant with debian/copyright. -- Maia Kozheva Mon, 30 Nov 2009 17:02:20 +0600 quassel (0.5.1-0ubuntu3) lucid; urgency=low * Add missing epoch to Qt build-depends version -- Jonathan Riddell Wed, 25 Nov 2009 13:47:09 +0000 quassel (0.5.1-0ubuntu2) lucid; urgency=low * Rebuild against Qt 4.6 rc 1, which is binary incompatible with 4.6 beta -- Jonathan Riddell Tue, 24 Nov 2009 09:00:03 +0000 quassel (0.5.1-0ubuntu1) lucid; urgency=low * New upstream bugfix release * Add build dep on zlib1g-dev to work around Bug #487415 -- Scott Kitterman Sat, 21 Nov 2009 12:17:38 -0500 quassel (0.5.0-0ubuntu1) karmic; urgency=low * New uptream release - Fixes core high CPU use with multiple users - Fixes click to focus on last message and message indicator work with default Kubuntu focus stealing prevention (LP: #422062) -- Scott Kitterman Wed, 14 Oct 2009 17:44:45 -0400 quassel (0.5.0~rc2+git091009-0ubuntu1) karmic; urgency=low [ Harald Sitter ] * Add README.source (LP: #440752) [ Scott Kitterman ] * New git snapshot - Use Dr. Konqi or Apport instead of internal crash handler that has never worked in Ubuntu - Fix for high CPU on resize (LP: #435107) - Drop debian/patches/kubuntu_02_message_indicator_optin.patch (fixed upstream) -- Scott Kitterman Sun, 11 Oct 2009 22:16:54 -0400 quassel (0.5.0~rc2-0ubuntu1) karmic; urgency=low [ Harald Sitter ] * quassel and quassel-client need to depend on the precise version of quassel-data rather than >=. Rationale: quassel is installed, newer quassel source is available though, installing quassel-client will not enforce upgrade of quassel which could possibly cause problems * Bump standards version from 3.8.0 to 3.8.3 [ Scott Kitterman ] * New upstream release candidate * Add libindicate-qt-dev to build-depends so message indicator is actually supported - Add debian/patches/kubuntu_02_message_indicator_optin.patch to default MI support off, consistent with the overall opt-in policy for Kubuntu -- Scott Kitterman Fri, 02 Oct 2009 09:32:41 -0400 quassel (0.5.0~rc1+vcshead090918-0ubuntu1) karmic; urgency=low * New git snapshot (from head since the libindicate branch was merged) -- Scott Kitterman Fri, 18 Sep 2009 10:10:58 -0400 quassel (0.5.0~rc1+libindicate+git090914-0ubuntu1) karmic; urgency=low * New git snapshot from the upstream libindicate branch - Drop and remove all patches from debian/patches/kubuntu-message-indicator (included in the upstream git branch) - Update debian/quassel-data.install for icons/oxygen/oxygen_kde split * Updated debian/copyright for new code in 0.5 -- Scott Kitterman Mon, 14 Sep 2009 00:14:42 -0400 quassel (0.5.0~rc1-0ubuntu3) karmic; urgency=low * Add patches in kubuntu-message-indicator for message indicator support, LP: #424379 -- Jonathan Riddell Fri, 04 Sep 2009 16:02:59 +0100 quassel (0.5.0~rc1-0ubuntu2) karmic; urgency=low * Add usr/share/kde4/apps/quassel/icons/oxygen/*/status/irc*.png back to debian/quassel-data.install to fix missing icon problem -- Scott Kitterman Mon, 31 Aug 2009 09:17:16 -0400 quassel (0.5.0~rc1-0ubuntu1) karmic; urgency=low * First release candidate for 0.5 - Reworked core start/shutdown makes it much faster (LP: #347087) - Core/client protocol bump, incompatible with previous client or core packages - Multiline input editing - Added ignore capability - Added netsplit detection and handling - Redesigned topic widget * Stop shipping Oxygen icons that aren't Quassel specific (all included in KDE 4.3) * Adjust debian/quassel-data.install for new stylesheets dir -- Scott Kitterman Wed, 26 Aug 2009 09:57:00 -0400 quassel (0.5.0~git090814-0ubuntu1) karmic; urgency=low * New git snapshot - Do not set a huge font in the default stylesheet - Do not confuse the users with the term buffer list - Additional user interface refinements * Add ${misc:Depends} for quassel-dbg -- Scott Kitterman Fri, 14 Aug 2009 09:38:41 -0400 quassel (0.5.0~git090812-0ubuntu1) karmic; urgency=low * New upstream git snapshot - Add new U/I styling features - Add simplified settings pages - Fix crash when channel has user names than start with "__" * Add data/default.qss to quassel-data.install for default stylesheet -- Scott Kitterman Wed, 12 Aug 2009 09:02:26 -0400 quassel (0.5.0~git090806-0ubuntu1) karmic; urgency=low * New upstream git snapshot (last commit before the styling branch landed) * Adjust paths (add debian/tmp/) in debian/*.install to work with kde.mk and fix FTBFS -- Scott Kitterman Tue, 11 Aug 2009 02:32:29 -0400 quassel (0.5.0~git090719-0ubuntu3) karmic; urgency=low * Add missing debhelper.mk -- Jonathan Riddell Wed, 29 Jul 2009 22:03:42 +0100 quassel (0.5.0~git090719-0ubuntu2) karmic; urgency=low * change to using kde.mk from pkg-kde-tools -- Jonathan Riddell Wed, 29 Jul 2009 18:01:43 +0100 quassel (0.5.0~git090719-0ubuntu1) karmic; urgency=low * New upstream git snapshot - Add usr/share/kde4/apps/quassel/scripts/ to debian/quassel-data.install - Add new icons to debian/quassel-data.install (ship them all for now) * Add kubuntu_01_default_network_channel.patch back -- Scott Kitterman Sun, 19 Jul 2009 23:40:27 -0400 quassel (0.4.2-0ubuntu2) karmic; urgency=low * Drop DEB_BUILD_OPTIONS=nostrip to debloat the package (LP: #370440) * Introduce quassel-dbg to be filled with debugging symbols * Compress packages using LZMA to decrease overall size (especially -dbg) -- Harald Sitter Fri, 12 Jun 2009 18:12:22 +0200 quassel (0.4.2-0ubuntu1) karmic; urgency=low * New upstream release - Drop notification-fix.patch: Applied upstream -- Scott Kitterman Wed, 20 May 2009 13:08:09 -0400 quassel (0.4.1-0ubuntu3) jaunty; urgency=low * Update debian/patches/notification-fix.patch to fix multiple notification hang (Quassel #657) -- Scott Kitterman Fri, 03 Apr 2009 16:43:18 -0400 quassel (0.4.1-0ubuntu2) jaunty; urgency=low * Apply upstream patch to fix notifications action regression (LP: #353286) - debian/patches/notification-fix.patch cherry-picked from upstream git trunk (can be dropped with quassel 0.5) -- Scott Kitterman Wed, 01 Apr 2009 13:21:19 -0400 quassel (0.4.1-0ubuntu1) jaunty; urgency=low * New upstream bug fix release - Numerous minor bug fixes - Updated translations -- Scott Kitterman Wed, 18 Mar 2009 11:24:11 -0400 quassel (0.4.0-0ubuntu2) jaunty; urgency=low * Actually include the new watch file -- Scott Kitterman Tue, 17 Feb 2009 18:18:31 -0500 quassel (0.4.0-0ubuntu1) jaunty; urgency=low * New upstream release - Colorized nicks - Additional bug fixes * Updated watch file for new download locations -- Scott Kitterman Tue, 17 Feb 2009 17:35:54 -0500 quassel (0.4.0~git090215-0ubuntu1) jaunty; urgency=low * New upstream git snapshot - Show identities and network settings on first start - Multi-line paste protection - Settings usability improvments - Continued bug fixing * Adjust quassel-data.install for new and removed icons -- Scott Kitterman Sun, 15 Feb 2009 19:46:44 -0500 quassel (0.4.0~git090213-0ubuntu1) jaunty; urgency=low * New upstream git snapshot - Continued bug fixing -- Scott Kitterman Fri, 13 Feb 2009 10:36:45 -0500 quassel (0.4.0~git090211-0ubuntu1) jaunty; urgency=low * New upstream git snapshot - Hide chatmonitor by default - No notifications for own messages - Added/Updated translations - Use login name to construct default nick/real name - Continued bug fixing -- Scott Kitterman Wed, 11 Feb 2009 22:05:55 -0500 quassel (0.4.0~git090206-0ubuntu2) jaunty; urgency=low * Add DEB_BUILD_OPTIONS=nostrip so the debug actually works -- Scott Kitterman Fri, 06 Feb 2009 10:19:14 -0500 quassel (0.4.0~git090206-0ubuntu1) jaunty; urgency=low * New upstream git snapshot - Added toolbar to u/i (initial drop - still more work to do) - Add more post KDE 4.2 oxygen icons - Redesigned web preview to hog fewer resources - Continued bug fixing * Add new icons to debian/quassel-data.install * Remove scalable Oxygen icons from the binary (not used and saves space) * Build with full debugging enabled * Explicitly set -DEMBED_DATA=off instead of just unsetting it (clearer) -- Scott Kitterman Fri, 06 Feb 2009 08:15:36 -0500 quassel (0.4.0~git090202-0ubuntu1) jaunty; urgency=low * New upstream git snapshot - Shiny new user icons for query buffers - Bug fixing * Adjust quassel-data.install to install IM status icons not shipped in the KDE 4.2 Oxygen * Fix quassel-data to be arch all -- Scott Kitterman Mon, 02 Feb 2009 19:45:22 -0500 quassel (0.4.0~git090201-0ubuntu1) jaunty; urgency=low * New upstream git snapshot - Core/client connection reliability improvements - Other bug fixing * Adjust quassel-data.install to include ../oxygen/*/apps/quassel.svgz and quassel.png -- Scott Kitterman Sun, 01 Feb 2009 16:13:05 -0500 quassel (0.4.0~git090130-0ubuntu1) jaunty; urgency=low * New upstream git snapshot - Improved SSL cert handling - Continued bug fixing * Replace deprecated --datadir with --configdir in quasselcore init * Add quasselcore usage to debian/mans/quasselcore.pod * Do not let the postinst overwrite existing certs (we ought to make this smarter at some point) * Update debian/copyright for the new year -- Scott Kitterman Sun, 01 Feb 2009 01:19:41 -0500 quassel (0.4.0~git090124-0ubuntu1) jaunty; urgency=low * New upstream git snapshot - Possible undocumented client/core protocol incompatibility that may require client and core to be updated together - see Quassel's bug tracker for details http://bugs.quassel-irc.org/issues/show/502 - Fixes minimize to tray bug - Other bug fixes - XDG compliant data paths (with auto migration from old locations) - Adjust quassel.install, quassel-date, and quassel-client.install for new file locations - Replace -DQUASSEL_ICONS=External with -DEMBED_DATA=OFF to use external files where possible with the new build system - Don't ship oxygen or non-application specific hicolor icons, depend on kde-icons-oxygen | hicolor-icon-theme instead - Add translations files to quassel-data.install * Adjust kubuntu_01_default_network_channel.patch to use irc.ubuntu.com instead of the Freenode url for the default channel (irc.ubuntu.com points to Freenode) -- Scott Kitterman Sun, 25 Jan 2009 23:37:07 -0500 quassel (0.4.0~git090119-0ubuntu1) jaunty; urgency=low * New upstream git snapshot - Fixes KDE logout problem - Other bug fixes - SSL cert handling improvements -- Scott Kitterman Mon, 19 Jan 2009 23:45:13 -0500 quassel (0.4.0~git090116-0ubuntu1) jaunty; urgency=low * New upstream git snapshot - Fixes right-click focus problems -- Scott Kitterman Fri, 16 Jan 2009 11:51:33 -0500 quassel (0.4.0~git090113-0ubuntu1) jaunty; urgency=low * New upstream git snapshot - Use networks.ini to provide default network/channel - Provide presets for common IRC networks * Add kubuntu_01_default_network_channel.patch to set Freenode, port 8001, and #kubuntu as defaults * Add build-dep on quilt -- Scott Kitterman Wed, 14 Jan 2009 01:28:49 -0500 quassel (0.4.0~git090110-0ubuntu2) jaunty; urgency=low * Move quassel.notifyrc from quassel/quassel-client to quassel-data to the two packages can be coinstalled - Conflict with appropriate versions -- Scott Kitterman Sun, 11 Jan 2009 13:33:11 -0500 quassel (0.4.0~git090110-0ubuntu1) jaunty; urgency=low [ Harald Sitter ] * debian/control: + Make quassel and quassel-core conflict. A lot of people installed all 3 packages leading to the most weird issues. I hope conflicing those 2 is enough, since there are usecases where one might want to have -client and quassel installed at the same time. + quassel-core depends on openssl due to postinst changes * debian/quassel-core.postinst: + Generate a SSL certificate at every run (lasting 680 days ~ 24 months) + Ensure any updates from earlier than 0.2.0~rc1-0ubuntu1 gets equiped with user, group and log directory. There weren't any reports about this yet, but to be on the save side. * debian/quassel-core.quasselcore.init: + Set STARTIME to 3 seconds * debian/rules: + Make dh_installinit create code that still exits with errorcode 0 if quasselcore is unstartable (which would mostly be the case for upgrades). [ Scott Kitterman ] * New upstream git snapshot * Enable KDE integration - Build-dep on kdelibs5-dev - Add -DWITH_KDE=ON to DEB_CMAKE_EXTRA_FLAGS * Added ${misc:Depends} to all packages * Drop quassel_01_fix_iconloader.patch, incorporated upstream * Remove debian/patches due to current lack of patches * Update package descriptions to better distinguish the different packages * Add data/quassel.notifyrc to debian/quassel.install and debian/quassel-core.install to support notifications in KDE - Install in share/kde4/apps/quassel * Replace patchsys-quilt.mk, debhelper.mk, util.mk, and cmake.mk with kde4.mk in debian/rules now that we are building the kde4 package * Adjust path in quassel-client.install quassel-core.install quassel- data.install quassel.install files because apparently kde4.mk is special * Update debian/copyright for LGPL-3 oxygen icons * Drop build-dep on quilt since no patches are left -- Scott Kitterman Sat, 10 Jan 2009 20:53:11 -0500 quassel (0.3.1-0ubuntu1) jaunty; urgency=low * New upstream release (LP: #271403) * Drop all patches originated from upstream (quassel_*) * Compile with non-builtin quassel icons + Introduce new quassel-data package + quassel and quassel-client depend on quassel-data + Don't manually enforce icon installation for desktop files in debian/rules + Add quassel_01_fix_iconloader.patch * Drop perl build dependency, I have no clue why it was added in the first place. Neither changelog nor Bazaar knows, and since quassel compiles just fine without it, removing it should be save. -- Harald Sitter Mon, 17 Nov 2008 15:22:46 +0100 quassel (0.3.0-0ubuntu9) intrepid; urgency=low * Fix wrong QByteArray use in quassel_16_ctcp_level_and_low_level_quoting (LP: #289291) -- Harald Sitter Sun, 26 Oct 2008 00:39:18 +0200 quassel (0.3.0-0ubuntu8) intrepid; urgency=low * Added patch from upstream: + quassel_16_ctcp_level_and_low_level_quoting.patch Implementing ctcp level quoting and ctcp low level quoting. This fixes a crucial security issue. (LP: #289182) -- Harald Sitter Sat, 25 Oct 2008 18:30:49 +0200 quassel (0.3.0-0ubuntu7) intrepid; urgency=low * Added patches from upstream: + quassel_13_fix_wrong_class.patch + quassel_14_fix_topic_widget.patch + quassel_15_reintroduce_layout_margin_for_topic_line.patch (LP: #276543) -- Harald Sitter Mon, 13 Oct 2008 20:32:24 +0200 quassel (0.3.0-0ubuntu6) intrepid; urgency=low * debian/quassel-core.logrotate: - Added - Rotates weekly for 4 weeks (default log mode is Info, which doesn't produce a lot of output) * debian/quassel-core.posinst: - Exit with code 0 when argument is not "configure" - Only create directories, user and group at first installation - Be more verbose - Added /var/log/quassel as log directory * debian/quassel-core.postinst: - Be more verbose - Remove log directory * debian/quassel-core.quasselcore.default: - Added - Define loglevel and port - Sourced in the init script * debian/quassel-core.quasselcore.init: - Renamed from quassel-core.init.d - Formatting changes - Set and use logdir and datadir as start arguments - Cleanup * debian/quasselcore-makecert: - Typo fix * debian/rules: - Added DEB_DH_INSTALLINIT_ARGS to not stop the daemon at upgrades -- Harald Sitter Fri, 19 Sep 2008 17:18:38 +0200 quassel (0.3.0-0ubuntu5) intrepid; urgency=low * debian/patches/quassel_10_fixing_memleak.patch: - Fixing memleak in chatlinemodelitem * debian/patches/quassel_11_Fix_MOC-defines-for-cmake-2.4.patch: - Fixes some defines for MOC in Cmakelist..now it works now with cmake-2.4 and --without-ssl * debian/patches/quassel_12_int_to_qreal_subst.patch: - Substitute int with qreal in chatlinemodelitem (All Patches cherrypicked from upstream) -- Stephan Hermann Thu, 11 Sep 2008 08:40:22 +0200 quassel (0.3.0-0ubuntu4) intrepid; urgency=low * Fix quasselclient icon -- Harald Sitter Sun, 07 Sep 2008 15:01:25 +0200 quassel (0.3.0-0ubuntu3) intrepid; urgency=low * debian/patches/quassel_01_chatscene.patch, debian/patches/quassel_02_chatview.patch: refreshed with a clean patch from upstrean * added: debian/patches/quassel_03_BR-295-Autobacktraces-are-limited-to-Linux.patch (Fixes Upstream: BR: #295) quassel_04_BR-302-client-crash-on-disconnect.patch (Fixes Upstream: BR: #302) quassel_05_faster-ChatLine-insertion-into-the-ChatScene.-And-so.patch quassel_06_removing-unneeded-semicolons-after-Qt-macros-makin.patch quassel_07_Bring-back-the-workaround-to-not-reserve-space-for-t.patch quassel_08_Bring-back-workaround-for-the-unwanted-scroll-on-buf.patch quassel_09_Various-buildsystem-improvements.patch (Cherrypicked Patches, which are fixing and makeing the app more mature for release, no new features are introduced) -- Stephan Hermann Mon, 01 Sep 2008 15:02:44 +0200 quassel (0.3.0-0ubuntu2) intrepid; urgency=low * debian/patches/quassel_01_chatscene.patch + Fix resizing/scrolling bug * debian/patches/quassel_02_chatview.patch + fix the scrolling issues for now -- Stephan Hermann Thu, 28 Aug 2008 16:24:27 +0200 quassel (0.3.0-0ubuntu1) intrepid; urgency=low * New upstream release * debian/control: - added libdbus-1-dev to build-dep because somewhere it's missing from libqt4 -- Stephan Hermann Wed, 27 Aug 2008 16:13:38 +0200 quassel (0.2.0~rc1-0ubuntu1) intrepid; urgency=low * Switch buildsystem to CMake * Add postinst, postrm and init.d for quassel-core (LP: #243891) - add user quassecore and group quassel - create $HOME -> /var/cache/quassel * Add quasselcore-makecert * Updated kubuntu_01_fix_desktop_file.patch * Bump Standards-Version to 3.8.0 -- Harald Sitter Fri, 27 Jun 2008 19:21:30 +0200 quassel (0.2.0~beta1-0ubuntu2) intrepid; urgency=low * Fix quassel's Depends line -- Harald Sitter Tue, 10 Jun 2008 20:11:14 +0200 quassel (0.2.0~beta1-0ubuntu1) intrepid; urgency=low * Initial release (LP: #195861) -- Harald Sitter Thu, 15 May 2008 18:17:16 +0200 debian/quassel-core.postrm0000664000000000000000000000041412314413402013032 0ustar #!/bin/sh set -e # configure some variables QUASSEL_GROUP=quassel QUASSEL_USER=quasselcore if [ "$1" = "purge" ]; then echo "Deleting /var/lib/quassel ..." rm -rf /var/lib/quassel echo "Deleting /var/log/quassel ..." rm -rf /var/log/quassel fi #DEBHELPER# debian/quassel.manpages0000664000000000000000000000001212314413402012345 0ustar quassel.1 debian/quassel-core.ufw.profile0000664000000000000000000000013212314413402013743 0ustar [Quassel] title=Quassel Core description=Quassel IRC core/server component ports=4242/tcp debian/quassel-core.logrotate0000664000000000000000000000023712314413402013511 0ustar /var/log/quassel/core.log { rotate 4 weekly compress delaycompress copytruncate missingok notifempty } debian/quassel-client.install0000664000000000000000000000011012314413402013473 0ustar usr/bin/quasselclient usr/share/applications/kde4/quasselclient.desktop