Merge pull request #12 from teo/out-of-process-gdb

Out of process backtrace generation with gdb

40 files changed, 6779 insertions, 138 deletions

diff --git a/3rdparty/CMakeLists.txt b/3rdparty/CMakeLists.txt
index 1eb2324..221ed29 100644
--- a/3rdparty/CMakeLists.txt
+++ b/3rdparty/CMakeLists.txt
@@ -1 +1,2 @@
 add_subdirectory(breakpad)
+add_subdirectory(drkonqi-parser)
diff --git a/3rdparty/breakpad/CMakeLists.txt b/3rdparty/breakpad/CMakeLists.txt
index 6756109..c4f8537 100644
--- a/3rdparty/breakpad/CMakeLists.txt
+++ b/3rdparty/breakpad/CMakeLists.txt
@@ -75,7 +75,7 @@ endif()
 include_directories(.)
 # ADD_DEFINITIONS( -fPIC )
 add_library(crashreporter-breakpad STATIC ${breakpadSources} )
-# TARGET_LINK_LIBRARIES( tomahawk-breakpad )
+target_link_libraries(crashreporter-breakpad pthread)
 
 if(WIN32)
     target_link_libraries(crashreporter-breakpad "mingwex")
diff --git a/3rdparty/drkonqi-parser/CMakeLists.txt b/3rdparty/drkonqi-parser/CMakeLists.txt
new file mode 100644
index 0000000..2cb91a0
--- /dev/null
+++ b/3rdparty/drkonqi-parser/CMakeLists.txt
@@ -0,0 +1,21 @@
+list(APPEND drkonqi_backtrace_parser_INCLUDE_DIRECTORIES
+    ${QT_QTCORE_INCLUDE_DIR}
+)
+
+
+set(BACKTRACEPARSER_SRCS
+    backtraceparser.cpp
+    backtraceparsergdb.cpp
+    backtraceparserkdbgwin.cpp
+    backtraceparsernull.cpp
+)
+
+
+include_directories(${drkonqi_backtrace_parser_INCLUDE_DIRECTORIES})
+add_library(drkonqi_backtrace_parser STATIC ${BACKTRACEPARSER_SRCS})
+target_link_libraries(drkonqi_backtrace_parser
+    PUBLIC
+        Qt5::Core
+)
+set_target_properties(drkonqi_backtrace_parser PROPERTIES AUTOMOC ON)
+qt5_use_modules(drkonqi_backtrace_parser Core)
diff --git a/3rdparty/drkonqi-parser/LICENSE.GPL2 b/3rdparty/drkonqi-parser/LICENSE.GPL2
new file mode 100644
index 0000000..d511905
--- /dev/null
+++ b/3rdparty/drkonqi-parser/LICENSE.GPL2
@@ -0,0 +1,339 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+	    How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    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) 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, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.
diff --git a/3rdparty/drkonqi-parser/backtraceline.h b/3rdparty/drkonqi-parser/backtraceline.h
new file mode 100644
index 0000000..672faee
--- /dev/null
+++ b/3rdparty/drkonqi-parser/backtraceline.h
@@ -0,0 +1,96 @@
+/*
+    Copyright (C) 2009-2010 George Kiagiadakis <kiagiadakis.george@gmail.com>
+
+    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) 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, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+#ifndef BACKTRACELINE_H
+#define BACKTRACELINE_H
+
+#include <QtCore/QSharedData>
+#include <QtCore/QString>
+
+class BacktraceLine
+{
+public:
+    enum LineType {
+        Unknown, //unknown type. the default
+        EmptyLine, //line is empty
+        Crap, //line is gdb's crap (like "(no debugging symbols found)",
+              //"[New Thread 0x4275c950 (LWP 11931)]", etc...)
+        KCrash, //line is "[KCrash Handler]"
+        ThreadIndicator, //line indicates the current thread,
+                         //ex. "[Current thread is 0 (process 11313)]"
+        ThreadStart, //line indicates the start of a thread's stack.
+        SignalHandlerStart, //line indicates the signal handler start
+                            //(contains "<signal handler called>")
+        StackFrame //line is a normal stack frame
+    };
+
+    enum LineRating {
+        /* RATING           --          EXAMPLE */
+        MissingEverything = 0, // #0 0x0000dead in ?? ()
+        MissingFunction = 1, // #0 0x0000dead in ?? () from /usr/lib/libfoobar.so.4
+        MissingLibrary = 2, // #0 0x0000dead in foobar()
+        MissingSourceFile = 3, // #0 0x0000dead in FooBar::FooBar () from /usr/lib/libfoobar.so.4
+        Good = 4, // #0 0x0000dead in FooBar::crash (this=0x0) at /home/user/foobar.cpp:204
+        InvalidRating = -1 // (dummy invalid value)
+    };
+
+    static const LineRating BestRating = Good;
+
+    BacktraceLine() : d(new Data) {}
+
+    QString toString() const {
+        return d->m_line;
+    }
+    LineType type() const {
+        return d->m_type;
+    }
+    LineRating rating() const {
+        return d->m_rating;
+    }
+
+    int frameNumber() const {
+        return d->m_stackFrameNumber;
+    }
+    QString functionName() const {
+        return d->m_functionName;
+    }
+    QString fileName() const {
+        return d->m_file;
+    }
+    QString libraryName() const {
+        return d->m_library;
+    }
+
+protected:
+    class Data : public QSharedData
+    {
+    public:
+        Data() : m_type(Unknown), m_rating(InvalidRating),
+                 m_stackFrameNumber(-1) {}
+
+        QString m_line;
+        LineType m_type;
+        LineRating m_rating;
+        int m_stackFrameNumber;
+        QString m_functionName;
+        QString m_file;
+        QString m_library;
+    };
+    QExplicitlySharedDataPointer<Data> d;
+};
+
+#endif // BACKTRACELINE_H
diff --git a/3rdparty/drkonqi-parser/backtraceparser.cpp b/3rdparty/drkonqi-parser/backtraceparser.cpp
new file mode 100644
index 0000000..8b5202f
--- /dev/null
+++ b/3rdparty/drkonqi-parser/backtraceparser.cpp
@@ -0,0 +1,392 @@
+/*
+    Copyright (C) 2009-2010 George Kiagiadakis <kiagiadakis.george@gmail.com>
+
+    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) 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, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+#include "backtraceparser_p.h"
+#include "backtraceparsergdb.h"
+#include "backtraceparserkdbgwin.h"
+#include "backtraceparsernull.h"
+#include <QtCore/QRegExp>
+#include <QtCore/QMetaEnum>
+#include <QtCore/QDebug>
+
+//factory
+BacktraceParser *BacktraceParser::newParser(const QString & debuggerName, QObject *parent)
+{
+    if (debuggerName == QLatin1String("gdb")) {
+        return new BacktraceParserGdb(parent);
+    } else if (debuggerName == QLatin1String("kdbgwin")) {
+        return new BacktraceParserKdbgwin(parent);
+    } else {
+        return new BacktraceParserNull(parent);
+    }
+}
+
+BacktraceParser::BacktraceParser(QObject *parent) : QObject(parent), d_ptr(NULL) {}
+BacktraceParser::~BacktraceParser() { delete d_ptr; }
+
+void BacktraceParser::connectToGenerator(QObject *generator)
+{
+    connect(generator, SIGNAL(starting()), this, SLOT(resetState()));
+    connect(generator, SIGNAL(newLine(QString)), this, SLOT(newLine(QString)));
+}
+
+QString BacktraceParser::parsedBacktrace() const
+{
+    Q_D(const BacktraceParser);
+
+    QString result;
+    if (d) {
+        QList<BacktraceLine>::const_iterator i;
+        for (i = d->m_linesList.constBegin(); i != d->m_linesList.constEnd(); ++i) {
+            result += i->toString();
+        }
+    }
+    return result;
+}
+
+QList<BacktraceLine> BacktraceParser::parsedBacktraceLines() const
+{
+    Q_D(const BacktraceParser);
+    return d ? d->m_linesList : QList<BacktraceLine>();
+}
+
+QString BacktraceParser::simplifiedBacktrace() const
+{
+    Q_D(const BacktraceParser);
+
+    //if there is no cached usefulness, the data calculation function has not run yet.
+    if (d && d->m_usefulness == InvalidUsefulness) {
+        const_cast<BacktraceParser*>(this)->calculateRatingData();
+    }
+
+    //if there is no d, the debugger has not run yet, so we have no backtrace.
+    return d ? d->m_simplifiedBacktrace : QString();
+}
+
+BacktraceParser::Usefulness BacktraceParser::backtraceUsefulness() const
+{
+    Q_D(const BacktraceParser);
+
+    //if there is no cached usefulness, the data calculation function has not run yet.
+    if (d && d->m_usefulness == InvalidUsefulness) {
+        const_cast<BacktraceParser*>(this)->calculateRatingData();
+    }
+
+    //if there is no d, the debugger has not run yet,
+    //so we can say that the (inexistent) backtrace is Useless.
+    return d ? d->m_usefulness : Useless;
+}
+
+QStringList BacktraceParser::firstValidFunctions() const
+{
+    Q_D(const BacktraceParser);
+
+    //if there is no cached usefulness, the data calculation function has not run yet.
+    if (d && d->m_usefulness == InvalidUsefulness) {
+        const_cast<BacktraceParser*>(this)->calculateRatingData();
+    }
+
+    //if there is no d, the debugger has not run yet, so we have no functions to return.
+    return d ? d->m_firstUsefulFunctions : QStringList();
+}
+
+
+QSet<QString> BacktraceParser::librariesWithMissingDebugSymbols() const
+{
+    Q_D(const BacktraceParser);
+
+    //if there is no cached usefulness, the data calculation function has not run yet.
+    if (d && d->m_usefulness == InvalidUsefulness) {
+        const_cast<BacktraceParser*>(this)->calculateRatingData();
+    }
+
+    //if there is no d, the debugger has not run yet, so we have no libraries.
+    return d ? d->m_librariesWithMissingDebugSymbols : QSet<QString>();
+}
+
+void BacktraceParser::resetState()
+{
+    //reset the state of the parser by getting a new instance of Private
+    delete d_ptr;
+    d_ptr = constructPrivate();
+}
+
+BacktraceParserPrivate *BacktraceParser::constructPrivate() const
+{
+    return new BacktraceParserPrivate;
+}
+
+
+/* This function returns true if the given stack frame line is the base of the backtrace
+   and thus the parser should not rate any frames below that one. */
+static bool lineIsStackBase(const BacktraceLine & line)
+{
+    //optimization. if there is no function name, do not bother to check it
+    if ( line.rating() == BacktraceLine::MissingEverything
+        || line.rating() == BacktraceLine::MissingFunction )
+        return false;
+
+    //this is the base frame for all threads except the main thread
+    //FIXME that probably works only on linux
+    if ( line.functionName() == QLatin1String("start_thread") )
+        return true;
+
+    QRegExp regExp;
+    regExp.setPattern(QStringLiteral("(kde)?main")); //main() or kdemain() is the base for the main thread
+    if ( regExp.exactMatch(line.functionName()) )
+        return true;
+
+    //HACK for better rating. we ignore all stack frames below any function that matches
+    //the following regular expression. The functions that match this expression are usually
+    //"QApplicationPrivate::notify_helper", "QApplication::notify" and similar, which
+    //are used to send any kind of event to the Qt application. All stack frames below this,
+    //with or without debug symbols, are useless to KDE developers, so we ignore them.
+    regExp.setPattern(QStringLiteral("(Q|K)(Core)?Application(Private)?::notify.*"));
+    if ( regExp.exactMatch(line.functionName()) )
+        return true;
+
+    //attempt to recognize crashes that happen after main has returned (bug 200993)
+    if ( line.functionName() == QLatin1String("~KCleanUpGlobalStatic") ||
+         line.functionName() == QLatin1String("~QGlobalStatic") ||
+         line.functionName() == QLatin1String("exit") ||
+         line.functionName() == QLatin1String("*__GI_exit") )
+        return true;
+
+    return false;
+}
+
+/* This function returns true if the given stack frame line is the top of the bactrace
+   and thus the parser should not rate any frames above that one. This is used to avoid
+   rating the stack frames of abort(), assert(), Q_ASSERT() and qFatal() */
+static bool lineIsStackTop(const BacktraceLine & line)
+{
+    //optimization. if there is no function name, do not bother to check it
+    if ( line.rating() == BacktraceLine::MissingEverything
+        || line.rating() == BacktraceLine::MissingFunction )
+        return false;
+
+    if ( line.functionName().startsWith(QLatin1String("qt_assert")) //qt_assert and qt_assert_x
+        || line.functionName() == QLatin1String("qFatal")
+        || line.functionName() == QLatin1String("abort")
+        || line.functionName() == QLatin1String("*__GI_abort")
+        || line.functionName() == QLatin1String("*__GI___assert_fail") )
+        return true;
+
+    return false;
+}
+
+/* This function returns true if the given stack frame line should be ignored from rating
+   for some reason. Currently it ignores all libc/libstdc++/libpthread functions. */
+static bool lineShouldBeIgnored(const BacktraceLine & line)
+{
+    if ( line.libraryName().contains(QStringLiteral("libc.so"))
+        || line.libraryName().contains(QStringLiteral("libstdc++.so"))
+        || line.functionName().startsWith(QLatin1String("*__GI_")) //glibc2.9 uses *__GI_ as prefix
+        || line.libraryName().contains(QStringLiteral("libpthread.so"))
+        || line.libraryName().contains(QStringLiteral("libglib-2.0.so"))
+        || line.libraryName().contains(QStringLiteral("ntdll.dll"))
+        || line.libraryName().contains(QStringLiteral("kernel32.dll"))
+        || line.functionName().contains(QStringLiteral("_tmain"))
+        || line.functionName() == QLatin1String("WinMain") )
+        return true;
+
+    return false;
+}
+
+static bool isFunctionUseful(const BacktraceLine & line)
+{
+    //We need the function name
+    if ( line.rating() == BacktraceLine::MissingEverything
+        || line.rating() == BacktraceLine::MissingFunction ) {
+        return false;
+    }
+
+    //Misc ignores
+    if ( line.functionName() == QLatin1String("__kernel_vsyscall")
+         || line.functionName() == QLatin1String("raise")
+         || line.functionName() == QLatin1String("abort")
+         || line.functionName() == QLatin1String("__libc_message")
+         || line.functionName() == QLatin1String("thr_kill") /* *BSD */) {
+        return false;
+    }
+
+    //Ignore core Qt functions
+    //(QObject can be useful in some cases)
+    if ( line.functionName().startsWith(QLatin1String("QBasicAtomicInt::"))
+        || line.functionName().startsWith(QLatin1String("QBasicAtomicPointer::"))
+        || line.functionName().startsWith(QLatin1String("QAtomicInt::"))
+        || line.functionName().startsWith(QLatin1String("QAtomicPointer::"))
+        || line.functionName().startsWith(QLatin1String("QMetaObject::"))
+        || line.functionName().startsWith(QLatin1String("QPointer::"))
+        || line.functionName().startsWith(QLatin1String("QWeakPointer::"))
+        || line.functionName().startsWith(QLatin1String("QSharedPointer::"))
+        || line.functionName().startsWith(QLatin1String("QScopedPointer::"))
+        || line.functionName().startsWith(QLatin1String("QMetaCallEvent::")) ) {
+        return false;
+    }
+
+    //Ignore core Qt containers misc functions
+    if ( line.functionName().endsWith(QLatin1String("detach"))
+        || line.functionName().endsWith(QLatin1String("detach_helper"))
+        || line.functionName().endsWith(QLatin1String("node_create"))
+        || line.functionName().endsWith(QLatin1String("deref"))
+        || line.functionName().endsWith(QLatin1String("ref"))
+        || line.functionName().endsWith(QLatin1String("node_copy"))
+        || line.functionName().endsWith(QLatin1String("d_func")) ) {
+        return false;
+    }
+
+    //Misc Qt stuff
+    if ( line.functionName() == QLatin1String("qt_message_output")
+        || line.functionName() == QLatin1String("qt_message")
+        || line.functionName() == QLatin1String("qFatal")
+        || line.functionName().startsWith(QLatin1String("qGetPtrHelper"))
+        || line.functionName().startsWith(QLatin1String("qt_meta_")) ) {
+        return false;
+    }
+
+    return true;
+}
+
+static bool isFunctionUsefulForSearch(const BacktraceLine & line)
+{
+    //Ignore Qt containers (and iterators Q*Iterator)
+    if ( line.functionName().startsWith(QLatin1String("QList"))
+        || line.functionName().startsWith(QLatin1String("QLinkedList"))
+        || line.functionName().startsWith(QLatin1String("QVector"))
+        || line.functionName().startsWith(QLatin1String("QStack"))
+        || line.functionName().startsWith(QLatin1String("QQueue"))
+        || line.functionName().startsWith(QLatin1String("QSet"))
+        || line.functionName().startsWith(QLatin1String("QMap"))
+        || line.functionName().startsWith(QLatin1String("QMultiMap"))
+        || line.functionName().startsWith(QLatin1String("QMapData"))
+        || line.functionName().startsWith(QLatin1String("QHash"))
+        || line.functionName().startsWith(QLatin1String("QMultiHash"))
+        || line.functionName().startsWith(QLatin1String("QHashData")) ) {
+        return false;
+    }
+
+    return true;
+}
+
+void BacktraceParser::calculateRatingData()
+{
+    Q_D(BacktraceParser);
+
+    uint rating = 0, bestPossibleRating = 0, counter = 0;
+    bool haveSeenStackBase = false;
+
+    QListIterator<BacktraceLine> i(d->m_linesToRate);
+    i.toBack(); //start from the end of the list
+
+    while( i.hasPrevious() ) {
+        const BacktraceLine & line = i.previous();
+
+        if ( !i.hasPrevious() && line.rating() == BacktraceLine::MissingEverything ) {
+            //Under some circumstances, the very first stack frame is invalid (ex, calling a function
+            //at an invalid address could result in a stack frame like "0x00000000 in ?? ()"),
+            //which however does not necessarily mean that the backtrace has a missing symbol on
+            //the first line. Here we make sure to ignore this line from rating. (bug 190882)
+            break; //there are no more items anyway, just break the loop
+        }
+
+        if ( lineIsStackBase(line) ) {
+            rating = bestPossibleRating = counter = 0; //restart rating ignoring any previous frames
+            haveSeenStackBase = true;
+        } else if ( lineIsStackTop(line) ) {
+            break; //we have reached the top, no need to inspect any more frames
+        }
+
+        if ( lineShouldBeIgnored(line) ) {
+            continue;
+        }
+
+        if ( line.rating() == BacktraceLine::MissingFunction
+            || line.rating() == BacktraceLine::MissingSourceFile) {
+            d->m_librariesWithMissingDebugSymbols.insert(line.libraryName().trimmed());
+        }
+
+        uint multiplier = ++counter; //give weight to the first lines
+        rating += static_cast<uint>(line.rating()) * multiplier;
+        bestPossibleRating += static_cast<uint>(BacktraceLine::BestRating) * multiplier;
+
+        qDebug() << line.rating() << line.toString();
+    }
+
+    //Generate a simplified backtrace
+    //- Starts from the first useful function
+    //- Max of 5 lines
+    //- Replaces garbage with [...]
+    //At the same time, grab the first three useful functions for search queries
+
+    i.toFront(); //Reuse the list iterator
+    int functionIndex = 0;
+    int usefulFunctionsCount = 0;
+    bool firstUsefulFound = false;
+    while( i.hasNext() && functionIndex < 5 ) {
+        const BacktraceLine & line = i.next();
+        if ( !lineShouldBeIgnored(line) && isFunctionUseful(line) ) { //Line is not garbage to use
+            if (!firstUsefulFound) {
+                firstUsefulFound = true;
+            }
+            //Save simplified backtrace line
+            d->m_simplifiedBacktrace += line.toString();
+
+            //Fetch three useful functions (only functionName) for search queries
+            if (usefulFunctionsCount < 3 && isFunctionUsefulForSearch(line) &&
+                !d->m_firstUsefulFunctions.contains(line.functionName())) {
+                d->m_firstUsefulFunctions.append(line.functionName());
+                usefulFunctionsCount++;
+            }
+
+            functionIndex++;
+        } else if (firstUsefulFound) {
+            //Add "[...]" if there are invalid functions in the middle
+            if (!d->m_simplifiedBacktrace.endsWith(QLatin1String("[...]\n"))) {
+                d->m_simplifiedBacktrace += QLatin1String("[...]\n");
+            }
+        }
+    }
+
+    //calculate rating
+    d->m_usefulness = Useless;
+    if (rating >= (bestPossibleRating*0.90)) {
+        d->m_usefulness = ReallyUseful;
+    } else if (rating >= (bestPossibleRating*0.70)) {
+        d->m_usefulness = MayBeUseful;
+    } else if (rating >= (bestPossibleRating*0.40)) {
+        d->m_usefulness = ProbablyUseless;
+    }
+
+    //if there is no stack base, the executable is probably stripped,
+    //so we need to be more strict with rating
+    if ( !haveSeenStackBase ) {
+        //less than 4 stack frames is useless
+        if ( counter < 4 ) {
+            d->m_usefulness = Useless;
+        //more than 4 stack frames might have some value, so let's not be so strict, just lower the rating
+        } else if ( d->m_usefulness > Useless ) {
+            d->m_usefulness = (Usefulness) (d->m_usefulness - 1);
+        }
+    }
+
+    qDebug() << "Rating:" << rating << "out of" << bestPossibleRating << "Usefulness:"
+             << staticMetaObject.enumerator(staticMetaObject.indexOfEnumerator("Usefulness")).valueToKey(d->m_usefulness);
+    qDebug() << "90%:" << (bestPossibleRating*0.90) << "70%:" << (bestPossibleRating*0.70)
+             << "40%:" << (bestPossibleRating*0.40);
+    qDebug() << "Have seen stack base:" << haveSeenStackBase << "Lines counted:" << counter;
+}
diff --git a/3rdparty/drkonqi-parser/backtraceparser.h b/3rdparty/drkonqi-parser/backtraceparser.h
new file mode 100644
index 0000000..021cd63
--- /dev/null
+++ b/3rdparty/drkonqi-parser/backtraceparser.h
@@ -0,0 +1,99 @@
+/*
+    Copyright (C) 2009-2010 George Kiagiadakis <kiagiadakis.george@gmail.com>
+
+    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) 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, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+#ifndef BACKTRACEPARSER_H
+#define BACKTRACEPARSER_H
+
+#include "backtraceline.h"
+#include <QtCore/QObject>
+#include <QtCore/QStringList>
+#include <QtCore/QMetaType>
+#include <QtCore/QSet>
+class BacktraceParserPrivate;
+
+class BacktraceParser : public QObject
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(BacktraceParser)
+    Q_ENUMS(Usefulness);
+public:
+    enum Usefulness { InvalidUsefulness, Useless, ProbablyUseless, MayBeUseful, ReallyUseful };
+
+    static BacktraceParser *newParser(const QString & debuggerName, QObject *parent = 0);
+    ~BacktraceParser() override;
+
+    /*! Connects the parser to the backtrace generator.
+     * Any QObject that defines the starting() and newLine(QString) signals will do.
+     */
+    void connectToGenerator(QObject *generator);
+
+    /*! Returns the parsed backtrace. Any garbage that should not be shown to the user is removed. */
+    virtual QString parsedBacktrace() const;
+
+    /*! Same as parsedBacktrace(), but the backtrace here is returned as a list of
+     * BacktraceLine objects, which provide extra information on each line.
+     */
+    virtual QList<BacktraceLine> parsedBacktraceLines() const;
+
+    /*! Returns a simplified version of the backtrace. This backtrace:
+     * \li Starts from the first useful function
+     * \li Has maximum 5 lines
+     * \li Replaces garbage with [...]
+     */
+    virtual QString simplifiedBacktrace() const;
+
+    /*! Returns a value that indicates how much useful is the backtrace that we got */
+    virtual Usefulness backtraceUsefulness() const;
+
+    /*! Returns a short list of the first good functions that appear in the backtrace
+     * (in the crashing thread). This is used for quering for duplicate reports.
+     */
+    virtual QStringList firstValidFunctions() const;
+
+    /*! Returns a list of libraries/executables that are missing debug symbols. */
+    virtual QSet<QString> librariesWithMissingDebugSymbols() const;
+
+private Q_SLOTS:
+    void resetState();
+
+protected Q_SLOTS:
+    /*! Called every time there is a new line from the generator. Subclasses should parse
+     * the line here and insert it in the m_linesList field of BacktraceParserPrivate.
+     * If the line is useful for rating as well, it should also be inserted in the m_linesToRate
+     * field, so that calculateRatingData() can use it.
+     */
+    virtual void newLine(const QString & lineStr) = 0;
+
+protected:
+    explicit BacktraceParser(QObject *parent = 0);
+
+    /*! Subclasses should override to provide their own BacktraceParserPrivate instance */
+    virtual BacktraceParserPrivate *constructPrivate() const;
+
+    /*! This method should fill the m_usefulness, m_simplifiedBacktrace, m_firstValidFunctions
+     * and m_librariesWithMissingDebugSymbols members of the BacktraceParserPrivate instance.
+     * The default implementation uses the lines inserted in m_linesToRate and applies a
+     * generic algorithm that should work for many debuggers.
+     */
+    virtual void calculateRatingData();
+
+    BacktraceParserPrivate *d_ptr;
+};
+
+Q_DECLARE_METATYPE(BacktraceParser::Usefulness)
+
+#endif // BACKTRACEPARSER_H
diff --git a/3rdparty/drkonqi-parser/backtraceparser_p.h b/3rdparty/drkonqi-parser/backtraceparser_p.h
new file mode 100644
index 0000000..735efe7
--- /dev/null
+++ b/3rdparty/drkonqi-parser/backtraceparser_p.h
@@ -0,0 +1,37 @@
+/*
+    Copyright (C) 2009-2010 George Kiagiadakis <kiagiadakis.george@gmail.com>
+
+    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) 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, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+#ifndef BACKTRACEPARSER_P_H
+#define BACKTRACEPARSER_P_H
+
+#include "backtraceparser.h"
+
+class BacktraceParserPrivate
+{
+public:
+    BacktraceParserPrivate() : m_usefulness(BacktraceParser::InvalidUsefulness) {}
+    virtual ~BacktraceParserPrivate() {}
+
+    QList<BacktraceLine> m_linesList;
+    QList<BacktraceLine> m_linesToRate;
+    QStringList m_firstUsefulFunctions;
+    QString m_simplifiedBacktrace;
+    QSet<QString> m_librariesWithMissingDebugSymbols;
+    BacktraceParser::Usefulness m_usefulness;
+};
+
+#endif //BACKTRACEPARSER_P_H
diff --git a/3rdparty/drkonqi-parser/backtraceparsergdb.cpp b/3rdparty/drkonqi-parser/backtraceparsergdb.cpp
new file mode 100644
index 0000000..5fdbb09
--- /dev/null
+++ b/3rdparty/drkonqi-parser/backtraceparsergdb.cpp
@@ -0,0 +1,294 @@
+/*
+    Copyright (C) 2009-2010  George Kiagiadakis <gkiagia@users.sourceforge.net>
+
+    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) 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, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+#include "backtraceparsergdb.h"
+#include "backtraceparser_p.h"
+#include <QtCore/QRegExp>
+#include <QtCore/QDebug>
+
+//BEGIN BacktraceLineGdb
+
+class BacktraceLineGdb : public BacktraceLine
+{
+public:
+    BacktraceLineGdb(const QString & line);
+
+private:
+    void parse();
+    void rate();
+};
+
+BacktraceLineGdb::BacktraceLineGdb(const QString & lineStr)
+        : BacktraceLine()
+{
+    d->m_line = lineStr;
+    d->m_functionName = QLatin1String("??");
+    parse();
+    if (d->m_type == StackFrame) {
+        rate();
+    }
+}
+
+void BacktraceLineGdb::parse()
+{
+    QRegExp regExp;
+
+    if (d->m_line == QLatin1String("\n")) {
+        d->m_type = EmptyLine;
+        return;
+    } else if (d->m_line == QLatin1String("[KCrash Handler]\n")) {
+        d->m_type = KCrash;
+        return;
+    } else if (d->m_line.contains(QStringLiteral("<signal handler called>"))) {
+        d->m_type = SignalHandlerStart;
+        return;
+    }
+
+    regExp.setPattern(QStringLiteral("^#([0-9]+)" //matches the stack frame number, ex. "#0"
+                      "[\\s]+(0x[0-9a-f]+[\\s]+in[\\s]+)?" // matches " 0x0000dead in " (optionally)
+                      "((\\(anonymous namespace\\)::)?[^\\(]+)" //matches the function name
+                      //(anything except left parenthesis, which is the start of the arguments section)
+                      //and optionally the prefix "(anonymous namespace)::"
+                      "(\\(.*\\))?" //matches the function arguments
+                                    //(when the app doesn't have debugging symbols)
+                      "[\\s]+(const[\\s]+)?" //matches a traling const, if it exists
+                      "\\(.*\\)" //matches the arguments of the function with their values
+                                 //(when the app has debugging symbols)
+                      "([\\s]+" //beginning of optional file information
+                      "(from|at)[\\s]+" //matches "from " or "at "
+                      "(.+)" //matches the filename (source file or shared library file)
+                      ")?\n$")); //matches trailing newline.
+                    //the )? at the end closes the parenthesis before [\\s]+(from|at) and
+                    //notes that the whole expression from there is optional.
+
+    if (regExp.exactMatch(d->m_line)) {
+        d->m_type = StackFrame;
+        d->m_stackFrameNumber = regExp.cap(1).toInt();
+        d->m_functionName = regExp.cap(3).trimmed();
+
+        if (!regExp.cap(7).isEmpty()) { //we have file information (stuff after from|at)
+            if (regExp.cap(8) == QLatin1String("at")) { //'at' means we have a source file
+                d->m_file = regExp.cap(9);
+            } else { //'from' means we have a library
+                d->m_library = regExp.cap(9);
+            }
+        }
+
+        qDebug() << d->m_stackFrameNumber << d->m_functionName << d->m_file << d->m_library;
+        return;
+    }
+
+    regExp.setPattern(QStringLiteral(".*\\(no debugging symbols found\\).*|"
+                      ".*\\[Thread debugging using libthread_db enabled\\].*|"
+                      ".*\\[New .*|"
+                      "0x[0-9a-f]+.*|"
+                      "Current language:.*"));
+    if (regExp.exactMatch(d->m_line)) {
+        qDebug() << "garbage detected:" << d->m_line;
+        d->m_type = Crap;
+        return;
+    }
+
+    regExp.setPattern(QStringLiteral("Thread [0-9]+\\s+\\(Thread [0-9a-fx]+\\s+\\(.*\\)\\):\n"));
+    if (regExp.exactMatch(d->m_line)) {
+        qDebug() << "thread start detected:" << d->m_line;
+        d->m_type = ThreadStart;
+        return;
+    }
+
+    regExp.setPattern(QStringLiteral("\\[Current thread is [0-9]+ \\(.*\\)\\]\n"));
+    if (regExp.exactMatch(d->m_line)) {
+        qDebug() << "thread indicator detected:" << d->m_line;
+        d->m_type = ThreadIndicator;
+        return;
+    }
+
+    qDebug() << "line" << d->m_line << "did not match";
+}
+
+void BacktraceLineGdb::rate()
+{
+    LineRating r;
+
+    //for explanations, see the LineRating enum definition
+    if (!fileName().isEmpty()) {
+        r = Good;
+    } else if (!libraryName().isEmpty()) {
+        if (functionName() == QLatin1String("??")) {
+            r = MissingFunction;
+        } else {
+            r = MissingSourceFile;
+        }
+    } else {
+        if (functionName() == QLatin1String("??")) {
+            r = MissingEverything;
+        } else {
+            r = MissingLibrary;
+        }
+    }
+
+    d->m_rating = r;
+}
+
+//END BacktraceLineGdb
+
+//BEGIN BacktraceParserGdb
+
+class BacktraceParserGdbPrivate : public BacktraceParserPrivate
+{
+public:
+    BacktraceParserGdbPrivate()
+        : BacktraceParserPrivate(),
+          m_possibleKCrashStart(0), m_threadsCount(0),
+          m_isBelowSignalHandler(false), m_frameZeroAppeared(false) {}
+
+    QString m_lineInputBuffer;
+    int m_possibleKCrashStart;
+    int m_threadsCount;
+    bool m_isBelowSignalHandler;
+    bool m_frameZeroAppeared;
+};
+
+BacktraceParserGdb::BacktraceParserGdb(QObject *parent)
+        : BacktraceParser(parent)
+{
+}
+
+BacktraceParserPrivate* BacktraceParserGdb::constructPrivate() const
+{
+    return new BacktraceParserGdbPrivate;
+}
+
+void BacktraceParserGdb::newLine(const QString & lineStr)
+{
+    Q_D(BacktraceParserGdb);
+
+    //when the line is too long, gdb splits it into two lines.
+    //This breaks parsing and results in two Unknown lines instead of a StackFrame one.
+    //Here we workaround this by joining the two lines when such a scenario is detected.
+    if (d->m_lineInputBuffer.isEmpty()) {
+        d->m_lineInputBuffer = lineStr;
+    } else if (lineStr.startsWith(QLatin1Char(' ')) || lineStr.startsWith(QLatin1Char('\t'))) {
+        //gdb always adds some whitespace at the beginning of the second line
+        d->m_lineInputBuffer.append(lineStr);
+    } else {
+        parseLine(d->m_lineInputBuffer);
+        d->m_lineInputBuffer = lineStr;
+    }
+}
+
+void BacktraceParserGdb::parseLine(const QString & lineStr)
+{
+    Q_D(BacktraceParserGdb);
+
+    BacktraceLineGdb line(lineStr);
+    switch (line.type()) {
+    case BacktraceLine::Crap:
+        break; //we don't want crap in the backtrace ;)
+    case BacktraceLine::ThreadStart:
+        d->m_linesList.append(line);
+        d->m_possibleKCrashStart = d->m_linesList.size();
+        d->m_threadsCount++;
+        //reset the state of the flags that need to be per-thread
+        d->m_isBelowSignalHandler = false;
+        d->m_frameZeroAppeared = false; // gdb bug workaround flag, see below
+        break;
+    case BacktraceLine::SignalHandlerStart:
+        if (!d->m_isBelowSignalHandler) {
+            //replace the stack frames of KCrash with a nice message
+            d->m_linesList.erase(d->m_linesList.begin() + d->m_possibleKCrashStart, d->m_linesList.end());
+            d->m_linesList.insert(d->m_possibleKCrashStart, BacktraceLineGdb(QStringLiteral("[KCrash Handler]\n")));
+            d->m_isBelowSignalHandler = true; //next line is the first below the signal handler
+        } else {
+            //this is not the first time we see a crash handler frame on the same thread,
+            //so we just add it to the list
+            d->m_linesList.append(line);
+        }
+        break;
+    case BacktraceLine::StackFrame:
+        // gdb workaround - (v6.8 at least) - 'thread apply all bt' writes
+        // the #0 stack frame again at the end.
+        // Here we ignore this frame by using a flag that tells us whether
+        // this is the first or the second time that the #0 frame appears in this thread.
+        // The flag is cleared on each thread start.
+        if (line.frameNumber() == 0) {
+            if (d->m_frameZeroAppeared) {
+                break; //break from the switch so that the frame is not added to the list.
+            } else {
+                d->m_frameZeroAppeared = true;
+            }
+        }
+
+        //rate the stack frame if we are below the signal handler
+        if (d->m_isBelowSignalHandler) {
+            d->m_linesToRate.append(line);
+        }
+
+        //fall through and append the line to the list
+    default:
+        d->m_linesList.append(line);
+        break;
+    }
+}
+
+QString BacktraceParserGdb::parsedBacktrace() const
+{
+    Q_D(const BacktraceParserGdb);
+
+    QString result;
+    if (d) {
+        QList<BacktraceLine>::const_iterator i;
+        for (i = d->m_linesList.constBegin(); i != d->m_linesList.constEnd(); ++i) {
+            //if there is only one thread, we can omit the thread indicator,
+            //the thread header and all the empty lines.
+            if (d->m_threadsCount == 1 && ((*i).type() == BacktraceLine::ThreadIndicator
+                                        || (*i).type() == BacktraceLine::ThreadStart
+                                        || (*i).type() == BacktraceLine::EmptyLine))
+            {
+                continue;
+            }
+            result += i->toString();
+        }
+    }
+    return result;
+}
+
+QList<BacktraceLine> BacktraceParserGdb::parsedBacktraceLines() const
+{
+    Q_D(const BacktraceParserGdb);
+
+    QList<BacktraceLine> result;
+    if (d) {
+        QList<BacktraceLine>::const_iterator i;
+        for (i = d->m_linesList.constBegin(); i != d->m_linesList.constEnd(); ++i) {
+            //if there is only one thread, we can omit the thread indicator,
+            //the thread header and all the empty lines.
+            if (d->m_threadsCount == 1 && ((*i).type() == BacktraceLine::ThreadIndicator
+                                        || (*i).type() == BacktraceLine::ThreadStart
+                                        || (*i).type() == BacktraceLine::EmptyLine))
+            {
+                continue;
+            }
+            result.append(*i);
+        }
+    }
+    return result;
+}
+
+//END BacktraceParserGdb
+
+
diff --git a/3rdparty/drkonqi-parser/backtraceparsergdb.h b/3rdparty/drkonqi-parser/backtraceparsergdb.h
new file mode 100644
index 0000000..9c76ce3
--- /dev/null
+++ b/3rdparty/drkonqi-parser/backtraceparsergdb.h
@@ -0,0 +1,44 @@
+/*
+    Copyright (C) 2009-2010 George Kiagiadakis <kiagiadakis.george@gmail.com>
+
+    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) 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, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+#ifndef BACKTRACEPARSERGDB_H
+#define BACKTRACEPARSERGDB_H
+
+#include "backtraceparser.h"
+class BacktraceParserGdbPrivate;
+
+class BacktraceParserGdb : public BacktraceParser
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(BacktraceParserGdb)
+public:
+    explicit BacktraceParserGdb(QObject *parent = 0);
+
+    QString parsedBacktrace() const override;
+    QList<BacktraceLine> parsedBacktraceLines() const override;
+
+protected:
+    BacktraceParserPrivate *constructPrivate() const override;
+
+protected Q_SLOTS:
+    void newLine(const QString & lineStr) override;
+
+private:
+    void parseLine(const QString & lineStr);
+};
+
+#endif // BACKTRACEPARSERGDB_H
diff --git a/3rdparty/drkonqi-parser/backtraceparserkdbgwin.cpp b/3rdparty/drkonqi-parser/backtraceparserkdbgwin.cpp
new file mode 100644
index 0000000..082c197
--- /dev/null
+++ b/3rdparty/drkonqi-parser/backtraceparserkdbgwin.cpp
@@ -0,0 +1,126 @@
+/*
+    Copyright (C) 2010 George Kiagiadakis <kiagiadakis.george@gmail.com>
+
+    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) 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, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+#include "backtraceparserkdbgwin.h"
+#include "backtraceparser_p.h"
+#include <QDebug>
+
+//BEGIN BacktraceLineKdbgwin
+
+class BacktraceLineKdbgwin : public BacktraceLine
+{
+public:
+    BacktraceLineKdbgwin(const QString & line);
+
+private:
+    void parse();
+    void rate();
+};
+
+BacktraceLineKdbgwin::BacktraceLineKdbgwin(const QString & line)
+    : BacktraceLine()
+{
+    d->m_line = line;
+    parse();
+    if (d->m_type == StackFrame) {
+        rate();
+    }
+}
+
+void BacktraceLineKdbgwin::parse()
+{
+    if (d->m_line == QLatin1String("\n")) {
+        d->m_type = EmptyLine;
+        return;
+    } else if (d->m_line == QLatin1String("[KCrash Handler]\n")) {
+        d->m_type = KCrash;
+        return;
+    } else if (d->m_line.startsWith(QLatin1String("Loaded"))) {
+        d->m_type = Crap; //FIXME that's not exactly crap
+        return;
+    }
+
+    QRegExp regExp;
+    regExp.setPattern(QStringLiteral("([^!]+)!" //match the module name, followed by !
+                      "([^\\(]+)\\(\\) " //match the function name, followed by ()
+                      "\\[([^@]+)@ [\\-\\d]+\\] " // [filename @ line]
+                      "at 0x.*")); //at 0xdeadbeef
+
+    if (regExp.exactMatch(d->m_line)) {
+        d->m_type = StackFrame;
+        d->m_library = regExp.cap(1);
+        d->m_functionName = regExp.cap(2);
+        d->m_file = regExp.cap(3).trimmed();
+
+        qDebug() << d->m_functionName << d->m_file << d->m_library;
+        return;
+    }
+
+    qDebug() << "line" << d->m_line << "did not match";
+}
+
+void BacktraceLineKdbgwin::rate()
+{
+    LineRating r;
+
+    //for explanations, see the LineRating enum definition
+    if (fileName() != QLatin1String("[unknown]")) {
+        r = Good;
+    } else if (libraryName() != QLatin1String("[unknown]")) {
+        if (functionName() == QLatin1String("[unknown]")) {
+            r = MissingFunction;
+        } else {
+            r = MissingSourceFile;
+        }
+    } else {
+        if (functionName() == QLatin1String("[unknown]")) {
+            r = MissingEverything;
+        } else {
+            r = MissingLibrary;
+        }
+    }
+
+    d->m_rating = r;
+}
+
+//END BacktraceLineKdbgwin
+
+//BEGIN BacktraceParserKdbgwin
+
+BacktraceParserKdbgwin::BacktraceParserKdbgwin(QObject *parent)
+    : BacktraceParser(parent)
+{
+}
+
+void BacktraceParserKdbgwin::newLine(const QString & lineStr)
+{
+    Q_D(BacktraceParser);
+
+    BacktraceLineKdbgwin line(lineStr);
+    switch(line.type()) {
+    case BacktraceLine::Crap:
+        break; //we don't want crap in the backtrace ;)
+    case BacktraceLine::StackFrame:
+        d->m_linesToRate.append(line);
+    default:
+        d->m_linesList.append(line);
+    }
+}
+
+//END BacktraceParserKdbgwin
+
+
diff --git a/3rdparty/drkonqi-parser/backtraceparserkdbgwin.h b/3rdparty/drkonqi-parser/backtraceparserkdbgwin.h
new file mode 100644
index 0000000..bc68233
--- /dev/null
+++ b/3rdparty/drkonqi-parser/backtraceparserkdbgwin.h
@@ -0,0 +1,34 @@
+/*
+    Copyright (C) 2010 George Kiagiadakis <kiagiadakis.george@gmail.com>
+
+    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) 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, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+#ifndef BACKTRACEPARSERKDBGWIN_H
+#define BACKTRACEPARSERKDBGWIN_H
+
+#include "backtraceparser.h"
+
+class BacktraceParserKdbgwin : public BacktraceParser
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(BacktraceParser)
+public:
+    explicit BacktraceParserKdbgwin(QObject *parent = 0);
+
+protected Q_SLOTS:
+    void newLine(const QString & lineStr) override;
+};
+
+#endif // BACKTRACEPARSERKDBGWIN_H
diff --git a/3rdparty/drkonqi-parser/backtraceparsernull.cpp b/3rdparty/drkonqi-parser/backtraceparsernull.cpp
new file mode 100644
index 0000000..b44b18f
--- /dev/null
+++ b/3rdparty/drkonqi-parser/backtraceparsernull.cpp
@@ -0,0 +1,57 @@
+/*
+    Copyright (C) 2009-2010 George Kiagiadakis <kiagiadakis.george@gmail.com>
+
+    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) 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, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+#include "backtraceparsernull.h"
+#include "backtraceparser_p.h"
+
+//BEGIN BacktraceLineNull
+
+class BacktraceLineNull : public BacktraceLine
+{
+public:
+    BacktraceLineNull(const QString & line);
+};
+
+BacktraceLineNull::BacktraceLineNull(const QString & line)
+    : BacktraceLine()
+{
+    d->m_line = line;
+    d->m_rating = MissingEverything;
+}
+
+//END BacktraceLineNull
+
+//BEGIN BacktraceParserNull
+
+BacktraceParserNull::BacktraceParserNull(QObject *parent) : BacktraceParser(parent) {}
+
+BacktraceParserPrivate *BacktraceParserNull::constructPrivate() const
+{
+    BacktraceParserPrivate *d = BacktraceParser::constructPrivate();
+    d->m_usefulness = MayBeUseful;
+    return d;
+}
+
+void BacktraceParserNull::newLine(const QString & lineStr)
+{
+    d_ptr->m_linesList.append(BacktraceLineNull(lineStr));
+}
+
+
+//END BacktraceParserNull
+
+
diff --git a/3rdparty/drkonqi-parser/backtraceparsernull.h b/3rdparty/drkonqi-parser/backtraceparsernull.h
new file mode 100644
index 0000000..9fbc6be
--- /dev/null
+++ b/3rdparty/drkonqi-parser/backtraceparsernull.h
@@ -0,0 +1,36 @@
+/*
+    Copyright (C) 2009-2010 George Kiagiadakis <kiagiadakis.george@gmail.com>
+
+    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) 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, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+#ifndef BACKTRACEPARSERNULL_H
+#define BACKTRACEPARSERNULL_H
+
+#include "backtraceparser.h"
+
+class BacktraceParserNull : public BacktraceParser
+{
+    Q_OBJECT
+public:
+    explicit BacktraceParserNull(QObject *parent = 0);
+
+protected Q_SLOTS:
+    void newLine(const QString & lineStr) override;
+
+protected:
+    BacktraceParserPrivate *constructPrivate() const override;
+};
+
+#endif // BACKTRACEPARSERNULL_H
diff --git a/src/libcrashreporter-gui/CMakeLists.txt b/src/libcrashreporter-gui/CMakeLists.txt
index 0debc62..79a3bb0 100644
--- a/src/libcrashreporter-gui/CMakeLists.txt
+++ b/src/libcrashreporter-gui/CMakeLists.txt
@@ -1,10 +1,30 @@
-set(crashreporter_SOURCES CrashReporter.cpp)
+set(crashreporter_SOURCES CrashReporter.cpp CrashReporterGzip.cpp)
 set(crashreporter_UI CrashReporter.ui)
 set(crashreporter_RC ../../resources.qrc)
+set(crashreporter_INCLUDE_DIRECTORIES ${CMAKE_CURRENT_BINARY_DIR} ${QT_INCLUDES})
+
+
+if(UNIX AND NOT APPLE)
+list(APPEND crashreporter_INCLUDE_DIRECTORIES
+    ${CMAKE_CURRENT_LIST_DIR}/../../3rdparty/drkonqi-parser
+)
+list(APPEND crashreporter_LIBRARIES
+    drkonqi_backtrace_parser
+)
+list(APPEND crashreporter_SOURCES
+    linux-backtrace-generator/crashedapplication.cpp
+    linux-backtrace-generator/backtracegenerator.cpp
+    linux-backtrace-generator/debugger.cpp
+    linux-backtrace-generator/crqt-kmacroexpander.cpp
+    linux-backtrace-generator/crqt-kmacroexpander_unix.cpp
+    linux-backtrace-generator/crqt-kshell.cpp
+    linux-backtrace-generator/crqt-kshell_unix.cpp
+)
+endif()
 
 qt_wrap_ui( crashreporter_UI_HEADERS ${crashreporter_UI} )
 
-include_directories( ${CMAKE_CURRENT_BINARY_DIR} ${QT_INCLUDES} )
+include_directories( ${crashreporter_INCLUDE_DIRECTORIES} )
 
 add_library(crashreporter-gui STATIC
     ${crashreporter_SOURCES}
@@ -17,6 +37,7 @@ add_library(crashreporter-gui STATIC
 target_link_libraries(crashreporter-gui
     ${QT_QTGUI_LIBRARY}
     ${QT_QTNETWORK_LIBRARY}
+    ${crashreporter_LIBRARIES}
 )
 
 set_target_properties(crashreporter-gui PROPERTIES AUTOMOC ON)
diff --git a/src/libcrashreporter-gui/CrashReporter.cpp b/src/libcrashreporter-gui/CrashReporter.cpp
index fec76a1..b791262 100644
--- a/src/libcrashreporter-gui/CrashReporter.cpp
+++ b/src/libcrashreporter-gui/CrashReporter.cpp
@@ -1,6 +1,7 @@
 /* === This file is part of Tomahawk Player - <http://tomahawk-player.org> ===
  *
  *   Copyright 2010-2011, Christian Muehlhaeuser <muesli@tomahawk-player.org>
+ *   Copyright 2016,      Teo Mrnjavac <teo@kde.org>
  *
  *   Tomahawk is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -18,11 +19,19 @@
 
 #include "CrashReporter.h"
 
+#ifdef Q_OS_LINUX
+#include "linux-backtrace-generator/backtracegenerator.h"
+#include "linux-backtrace-generator/crashedapplication.h"
+#include "CrashReporterGzip.h"
+#include <csignal> // POSIX kill
+#endif
+
 #include <QIcon>
 #include <QDebug>
 #include <QTimer>
 #include <QDir>
 #include <QDateTime>
+#include <QStandardPaths>
 
 // #include "utils/TomahawkUtils.h"
 
@@ -65,13 +74,92 @@ CrashReporter::CrashReporter( const QUrl& url, const QStringList& args )
     m_minidump_file_path = args.value( 1 );
 
     //hide until "send report" has been clicked
-    m_ui->progressBar->setVisible( false );
-    m_ui->button->setVisible( false );
-    m_ui->progressLabel->setVisible( false );
+    m_ui->progressBox->setVisible( false );
+    m_ui->progressLabel->setVisible( true );
+    m_ui->progressLabel->setText( QString() );
     connect( m_ui->sendButton, SIGNAL( clicked() ), SLOT( onSendButton() ) );
 
     adjustSize();
     setFixedSize( size() );
+
+#ifdef Q_OS_LINUX
+    if ( args.count() == 8 )
+    {
+        qDebug() << "These are all our args:" << args.join( ", " );
+        const CrashedApplication* app =
+            new CrashedApplication( args.value( 2 ).toInt(),
+                                    args.value( 3 ).toInt(),
+                                    args.value( 4 ),
+                                    QFileInfo( args.value( 5 ) ),
+                                    QFileInfo( args.value( 5 ) ).baseName(),
+                                    args.value( 6 ),
+                                    args.value( 7 ).toInt(),
+                                    QDateTime::currentDateTime() );
+
+        m_btg = new BacktraceGenerator(
+                    Debugger::availableInternalDebuggers( "KCrash" ).first(),
+                    app,
+                    this );
+        connect( m_btg, &BacktraceGenerator::failedToStart,
+                 this, [ = ]
+        {
+            qDebug() << "Error: GDB failed to start.";
+            m_ui->progressLabel->setText( tr( "We cannot gather useful debug information on your system." ) );
+            m_ui->button->setText( tr( "Close" ) );
+        } );
+        connect( m_btg, &BacktraceGenerator::someError,
+                 this, [ = ]
+        {
+            qDebug() << "Error: GDB backtrace processing failed.";
+            m_ui->progressLabel->setText( tr( "We cannot gather useful debug information on your system." ) );
+            m_ui->button->setText( tr( "Close" ) );
+        } );
+        connect( m_btg, &BacktraceGenerator::done,
+                 this, [ = ]
+        {
+            qDebug() << "Backtrace generation done.";
+            Q_ASSERT( m_btg->state() == BacktraceGenerator::Loaded );
+
+            QString btPath = QString( "%1%2calamares-gdb-%3.txt" )
+                             .arg( QStandardPaths::writableLocation( QStandardPaths::TempLocation ) )
+                             .arg( QDir::separator() )
+                             .arg( QDateTime::currentMSecsSinceEpoch() );
+            QFile btFile( btPath );
+            if ( btFile.open( QFile::WriteOnly | QFile::Text ) )
+            {
+                QTextStream out( &btFile );
+                out << m_btg->backtrace();
+                out.flush();
+                qDebug() << "GDB backtrace written to" << btPath;
+
+                setReportData( "upload_file_linux_backtrace",
+                                gzip_compress( m_btg->backtrace().toLocal8Bit() ),
+                                "application/x-gzip",
+                                QFileInfo( btFile ).fileName().toUtf8() );
+                kill( app->pid(), SIGKILL );
+
+                m_ui->progressBox->setVisible( false );
+                m_ui->sendBox->setVisible( true );
+                m_ui->progressLabel->setText( tr( "Ready to send debug information (<a "
+                                                  "href=\"%1\">view backtrace</a>)." )
+                                              .arg( QUrl::fromLocalFile( btPath ).toString( QUrl::FullyEncoded ) ) );
+            }
+            else
+            {
+                qDebug() << "Cannot open file" << btPath << "to save the backtrace.";
+                m_ui->progressLabel->setText( tr( "We cannot gather useful debug information on your system." ) );
+                m_ui->button->setText( tr( "Close" ) );
+            }
+        });
+
+        m_btg->start();
+        m_ui->progressBox->setVisible( true );
+        m_ui->sendBox->setVisible( false );
+
+        m_ui->progressLabel->setText( tr( "Gathering debug information..." ) );
+        m_ui->progressBar->setRange( 0, 0 );
+    }
+#endif
 }
 
 
@@ -184,6 +272,7 @@ CrashReporter::onDone()
     m_ui->button->setText( tr( "Close" ) );
 
     QString const response = QString::fromUtf8( data );
+    qDebug() << "RESPONSE:" << response;
 
     if ( ( m_reply->error() != QNetworkReply::NoError ) || !response.startsWith( "CrashID=" ) )
     {
@@ -210,11 +299,9 @@ CrashReporter::onFail( int error, const QString& errorString )
 void
 CrashReporter::onSendButton()
 {
-    m_ui->progressBar->setVisible( true );
-    m_ui->button->setVisible( true );
-    m_ui->progressLabel->setVisible( true );
-    m_ui->sendButton->setEnabled( false );
-    m_ui->dontSendButton->setEnabled( false );
+    m_ui->progressBox->setVisible( true );
+    m_ui->sendBox->setVisible( false );
+
     m_ui->commentTextEdit->setEnabled( false );
 
     setReportData( "Comments", m_ui->commentTextEdit->toPlainText().toUtf8() );
diff --git a/src/libcrashreporter-gui/CrashReporter.h b/src/libcrashreporter-gui/CrashReporter.h
index 2b39874..7c9db1a 100644
--- a/src/libcrashreporter-gui/CrashReporter.h
+++ b/src/libcrashreporter-gui/CrashReporter.h
@@ -1,6 +1,7 @@
 /* === This file is part of Tomahawk Player - <http://tomahawk-player.org> ===
  *
  *   Copyright 2010-2011, Christian Muehlhaeuser <muesli@tomahawk-player.org>
+ *   Copyright 2016,      Teo Mrnjavac <teo@kde.org>
  *
  *   Tomahawk is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -30,6 +31,9 @@ namespace Ui
     class CrashReporter;
 }
 
+#ifdef Q_OS_LINUX
+class BacktraceGenerator;
+#endif
 
 class CrashReporter : public QDialog
 {
@@ -48,6 +52,9 @@ public:
 
 private:
     Ui::CrashReporter* m_ui;
+#ifdef Q_OS_LINUX
+    BacktraceGenerator* m_btg;
+#endif
 
     QString m_minidump_file_path;
     QNetworkRequest* m_request;
diff --git a/src/libcrashreporter-gui/CrashReporter.ui b/src/libcrashreporter-gui/CrashReporter.ui
index bc78bcc..67a4563 100644
--- a/src/libcrashreporter-gui/CrashReporter.ui
+++ b/src/libcrashreporter-gui/CrashReporter.ui
@@ -133,40 +133,6 @@
     <widget class="QPlainTextEdit" name="commentTextEdit"/>
    </item>
    <item>
-    <layout class="QHBoxLayout" name="hboxLayout1">
-     <property name="spacing">
-      <number>6</number>
-     </property>
-     <item>
-      <spacer name="horizontalSpacer">
-       <property name="orientation">
-        <enum>Qt::Horizontal</enum>
-       </property>
-       <property name="sizeHint" stdset="0">
-        <size>
-         <width>40</width>
-         <height>20</height>
-        </size>
-       </property>
-      </spacer>
-     </item>
-     <item>
-      <widget class="QPushButton" name="sendButton">
-       <property name="text">
-        <string>Send this report</string>
-       </property>
-      </widget>
-     </item>
-     <item>
-      <widget class="QPushButton" name="dontSendButton">
-       <property name="text">
-        <string>Don't send</string>
-       </property>
-      </widget>
-     </item>
-    </layout>
-   </item>
-   <item>
     <layout class="QVBoxLayout" name="vboxLayout1">
      <property name="spacing">
       <number>0</number>
@@ -186,7 +152,7 @@
      <item>
       <widget class="QLabel" name="progressLabel">
        <property name="sizePolicy">
-        <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+        <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
@@ -194,52 +160,112 @@
        <property name="text">
         <string/>
        </property>
+       <property name="openExternalLinks">
+        <bool>true</bool>
+       </property>
        <property name="textInteractionFlags">
         <set>Qt::LinksAccessibleByMouse|Qt::TextSelectableByKeyboard|Qt::TextSelectableByMouse</set>
        </property>
       </widget>
      </item>
      <item>
-      <layout class="QHBoxLayout">
+      <layout class="QHBoxLayout" name="horizontalLayout">
        <property name="spacing">
-        <number>9</number>
-       </property>
-       <property name="leftMargin">
-        <number>0</number>
-       </property>
-       <property name="topMargin">
-        <number>0</number>
-       </property>
-       <property name="rightMargin">
-        <number>0</number>
-       </property>
-       <property name="bottomMargin">
         <number>0</number>
        </property>
        <item>
-        <widget class="QProgressBar" name="progressBar">
-         <property name="value">
-          <number>24</number>
-         </property>
-         <property name="orientation">
-          <enum>Qt::Horizontal</enum>
-         </property>
+        <widget class="QWidget" name="progressBox" native="true">
+         <layout class="QHBoxLayout">
+          <property name="spacing">
+           <number>9</number>
+          </property>
+          <property name="leftMargin">
+           <number>1</number>
+          </property>
+          <property name="topMargin">
+           <number>1</number>
+          </property>
+          <property name="rightMargin">
+           <number>1</number>
+          </property>
+          <property name="bottomMargin">
+           <number>1</number>
+          </property>
+          <item>
+           <widget class="QProgressBar" name="progressBar">
+            <property name="value">
+             <number>24</number>
+            </property>
+            <property name="orientation">
+             <enum>Qt::Horizontal</enum>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QPushButton" name="button">
+            <property name="sizePolicy">
+             <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+              <horstretch>0</horstretch>
+              <verstretch>0</verstretch>
+             </sizepolicy>
+            </property>
+            <property name="text">
+             <string>Abort</string>
+            </property>
+            <property name="default">
+             <bool>true</bool>
+            </property>
+           </widget>
+          </item>
+         </layout>
         </widget>
        </item>
        <item>
-        <widget class="QPushButton" name="button">
-         <property name="sizePolicy">
-          <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
-           <horstretch>0</horstretch>
-           <verstretch>0</verstretch>
-          </sizepolicy>
-         </property>
-         <property name="text">
-          <string>Abort</string>
-         </property>
-         <property name="default">
-          <bool>true</bool>
-         </property>
+        <widget class="QWidget" name="sendBox" native="true">
+         <layout class="QHBoxLayout" name="_2">
+          <property name="spacing">
+           <number>9</number>
+          </property>
+          <property name="leftMargin">
+           <number>1</number>
+          </property>
+          <property name="topMargin">
+           <number>1</number>
+          </property>
+          <property name="rightMargin">
+           <number>1</number>
+          </property>
+          <property name="bottomMargin">
+           <number>1</number>
+          </property>
+          <item>
+           <spacer name="horizontalSpacer">
+            <property name="orientation">
+             <enum>Qt::Horizontal</enum>
+            </property>
+            <property name="sizeHint" stdset="0">
+             <size>
+              <width>40</width>
+              <height>20</height>
+             </size>
+            </property>
+           </spacer>
+          </item>
+          <item>
+           <widget class="QPushButton" name="sendButton">
+            <property name="text">
+             <string>Send this report</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QPushButton" name="dontSendButton">
+            <property name="text">
+             <string>Don't send</string>
+            </property>
+           </widget>
+          </item>
+         </layout>
         </widget>
        </item>
       </layout>
@@ -270,34 +296,34 @@
  <resources/>
  <connections>
   <connection>
-   <sender>button</sender>
+   <sender>dontSendButton</sender>
    <signal>clicked()</signal>
    <receiver>CrashReporter</receiver>
-   <slot>accept()</slot>
+   <slot>reject()</slot>
    <hints>
     <hint type="sourcelabel">
-     <x>426</x>
-     <y>203</y>
+     <x>380</x>
+     <y>117</y>
     </hint>
     <hint type="destinationlabel">
-     <x>247</x>
-     <y>195</y>
+     <x>218</x>
+     <y>122</y>
     </hint>
    </hints>
   </connection>
   <connection>
-   <sender>dontSendButton</sender>
+   <sender>button</sender>
    <signal>clicked()</signal>
    <receiver>CrashReporter</receiver>
-   <slot>reject()</slot>
+   <slot>accept()</slot>
    <hints>
     <hint type="sourcelabel">
-     <x>380</x>
-     <y>117</y>
+     <x>426</x>
+     <y>203</y>
     </hint>
     <hint type="destinationlabel">
-     <x>218</x>
-     <y>122</y>
+     <x>247</x>
+     <y>195</y>
     </hint>
    </hints>
   </connection>
diff --git a/src/libcrashreporter-gui/CrashReporterGzip.cpp b/src/libcrashreporter-gui/CrashReporterGzip.cpp
new file mode 100644
index 0000000..9c5e5bd
--- /dev/null
+++ b/src/libcrashreporter-gui/CrashReporterGzip.cpp
@@ -0,0 +1,110 @@
+/* === This file is part of Calamares - <http://github.com/calamares> ===
+ *
+ *   Copyright 2010-2011, Christian Muehlhaeuser <muesli@tomahawk-player.org>
+ *   Copyright 2015-2016, Teo Mrnjavac <teo@kde.org>
+ *
+ *   Calamares 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.
+ *
+ *   Calamares 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 Calamares. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "CrashReporterGzip.h"
+
+
+// code taken from http://stackoverflow.com/questions/20734831/compress-string-with-gzip-using-qcompress
+static const quint32 crc_32_tab[] = { /* CRC polynomial 0xedb88320 */
+    0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
+    0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
+    0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
+    0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
+    0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
+    0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
+    0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
+    0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
+    0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
+    0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+    0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
+    0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
+    0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
+    0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
+    0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
+    0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
+    0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
+    0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
+    0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
+    0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+    0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
+    0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
+    0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
+    0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
+    0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
+    0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
+    0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
+    0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
+    0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
+    0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+    0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
+    0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
+    0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
+    0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
+    0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
+    0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
+    0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
+    0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
+    0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
+    0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+    0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
+    0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
+    0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
+};
+
+quint32 updateCRC32(unsigned char ch, quint32 crc)
+{
+    return (crc_32_tab[((crc) ^ ((quint8)ch)) & 0xff] ^ ((crc) >> 8));
+}
+
+quint32 crc32buf(const QByteArray& data)
+{
+    return ~std::accumulate(
+        data.begin(),
+        data.end(),
+        quint32(0xFFFFFFFF),
+        [](quint32 oldcrc32, char buf){ return updateCRC32(buf, oldcrc32); });
+}
+
+QByteArray gzip_compress(const QByteArray& data)
+{
+    auto compressedData = qCompress(data);
+    //  Strip the first six bytes (a 4-byte length put on by qCompress and a 2-byte zlib header)
+    // and the last four bytes (a zlib integrity check).
+    compressedData.remove(0, 6);
+    compressedData.chop(4);
+
+    QByteArray header;
+    QDataStream ds1(&header, QIODevice::WriteOnly);
+    // Prepend a generic 10-byte gzip header (see RFC 1952),
+    ds1 << quint16(0x1f8b)
+        << quint16(0x0800)
+        << quint16(0x0000)
+        << quint16(0x0000)
+        << quint16(0x000b);
+
+    // Append a four-byte CRC-32 of the uncompressed data
+    // Append 4 bytes uncompressed input size modulo 2^32
+    QByteArray footer;
+    QDataStream ds2(&footer, QIODevice::WriteOnly);
+    ds2.setByteOrder(QDataStream::LittleEndian);
+    ds2 << crc32buf(data)
+        << quint32(data.size());
+
+    return header + compressedData + footer;
+}
diff --git a/src/libcrashreporter-gui/CrashReporterGzip.h b/src/libcrashreporter-gui/CrashReporterGzip.h
new file mode 100644
index 0000000..fe369ee
--- /dev/null
+++ b/src/libcrashreporter-gui/CrashReporterGzip.h
@@ -0,0 +1,27 @@
+/* === This file is part of Calamares - <http://github.com/calamares> ===
+ *
+ *   Copyright 2010-2011, Christian Muehlhaeuser <muesli@tomahawk-player.org>
+ *   Copyright 2015-2016, Teo Mrnjavac <teo@kde.org>
+ *
+ *   Calamares 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.
+ *
+ *   Calamares 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 Calamares. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CRASHREPORTER_GZIP_H
+#define CRASHREPORTER_GZIP_H
+
+#include <QDataStream>
+
+QByteArray gzip_compress( const QByteArray& data );
+
+#endif // CRASHREPORTER_GZIP_H
diff --git a/src/libcrashreporter-gui/LICENSE.GPL3 b/src/libcrashreporter-gui/LICENSE.GPL3
new file mode 100644
index 0000000..94a9ed0
--- /dev/null
+++ b/src/libcrashreporter-gui/LICENSE.GPL3
@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    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 <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
diff --git a/src/libcrashreporter-gui/linux-backtrace-generator/LICENSE.GPL2 b/src/libcrashreporter-gui/linux-backtrace-generator/LICENSE.GPL2
new file mode 100644
index 0000000..d511905
--- /dev/null
+++ b/src/libcrashreporter-gui/linux-backtrace-generator/LICENSE.GPL2
@@ -0,0 +1,339 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+	    How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    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) 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, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.
diff --git a/src/libcrashreporter-gui/linux-backtrace-generator/LICENSE.LGPL2 b/src/libcrashreporter-gui/linux-backtrace-generator/LICENSE.LGPL2
new file mode 100644
index 0000000..2d2d780
--- /dev/null
+++ b/src/libcrashreporter-gui/linux-backtrace-generator/LICENSE.LGPL2
@@ -0,0 +1,510 @@
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+	51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations
+below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it
+becomes a de-facto standard.  To achieve this, non-free programs must
+be allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control
+compilation and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at least
+    three years, to give the same user the materials specified in
+    Subsection 6a, above, for a charge no more than the cost of
+    performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply, and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License
+may add an explicit geographical distribution limitation excluding those
+countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+                            NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms
+of the ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.
+It is safest to attach them to the start of each source file to most
+effectively convey the exclusion of warranty; and each file should
+have at least the "copyright" line and a pointer to where the full
+notice is found.
+
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or
+your school, if any, to sign a "copyright disclaimer" for the library,
+if necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James
+  Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
+
+
diff --git a/src/libcrashreporter-gui/linux-backtrace-generator/backtracegenerator.cpp b/src/libcrashreporter-gui/linux-backtrace-generator/backtracegenerator.cpp
new file mode 100644
index 0000000..7a8d35a
--- /dev/null
+++ b/src/libcrashreporter-gui/linux-backtrace-generator/backtracegenerator.cpp
@@ -0,0 +1,174 @@
+/*****************************************************************
+ * drkonqi - The KDE Crash Handler
+ *
+ * Copyright (C) 2000-2003 Hans Petter Bieker <bieker@kde.org>
+ * Copyright (C) 2009  George Kiagiadakis <gkiagia@users.sourceforge.net>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *****************************************************************/
+#include "backtracegenerator.h"
+
+#include "crqt-kshell.h"
+
+#include <QTemporaryFile>
+#include <QDebug>
+
+#include <backtraceparser.h>
+
+BacktraceGenerator::BacktraceGenerator(const Debugger & debugger,
+                                       const CrashedApplication* crashedApp,
+                                       QObject *parent)
+        : QObject(parent),
+          m_debugger(debugger),
+          m_proc(NULL),
+          m_temp(NULL),
+          m_state(NotLoaded),
+          m_crashedApplication(crashedApp)
+{
+    m_parser = BacktraceParser::newParser(m_debugger.codeName(), this);
+    m_parser->connectToGenerator(this);
+}
+
+BacktraceGenerator::~BacktraceGenerator()
+{
+    if (m_proc && m_proc->state() == QProcess::Running) {
+        qWarning() << "Killing running debugger instance";
+        m_proc->disconnect(this);
+        m_proc->terminate();
+        if (!m_proc->waitForFinished(10000)) {
+            m_proc->kill();
+            m_proc->waitForFinished();
+        }
+        delete m_proc;
+        delete m_temp;
+    }
+}
+
+bool BacktraceGenerator::start()
+{
+    //they should always be null before entering this function.
+    Q_ASSERT(m_proc == NULL && m_temp == NULL);
+
+    m_parsedBacktrace.clear();
+    m_state = Loading;
+
+    emit starting();
+
+    if (!m_debugger.isValid() || !m_debugger.isInstalled()) {
+        m_state = FailedToStart;
+        emit failedToStart();
+        return false;
+    }
+
+    m_proc = new QProcess;
+    QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
+    env.insert(QStringLiteral("LC_ALL"), QStringLiteral("C"));   // force C locale
+    m_proc->setProcessEnvironment(env);
+
+    m_temp = new QTemporaryFile;
+    m_temp->open();
+    m_temp->write(m_debugger.backtraceBatchCommands().toLatin1());
+    m_temp->write("\n", 1);
+    m_temp->flush();
+
+    // start the debugger
+    QString str = m_debugger.command();
+    Debugger::expandString(str,
+                           m_crashedApplication,
+                           Debugger::ExpansionUsageShell,
+                           m_temp->fileName());
+
+    QStringList split = KShell::splitArgs(str);
+    m_proc->setProgram(split.takeFirst());
+    if (!split.isEmpty())
+        m_proc->setArguments(split);
+    m_proc->setProcessChannelMode(QProcess::ForwardedErrorChannel);
+    QProcess::OpenMode defaultOpenMode = QIODevice::ReadWrite | QIODevice::Text;
+    connect(m_proc, &QProcess::readyReadStandardOutput,
+            this, &BacktraceGenerator::slotReadInput);
+    connect(m_proc, static_cast<void (QProcess::*)(int, QProcess::ExitStatus)>(&QProcess::finished),
+            this, &BacktraceGenerator::slotProcessExited);
+
+    m_proc->start(defaultOpenMode);
+    if (!m_proc->waitForStarted()) {
+        //we mustn't keep these around...
+        m_proc->deleteLater();
+        m_temp->deleteLater();
+        m_proc = NULL;
+        m_temp = NULL;
+
+        m_state = FailedToStart;
+        emit failedToStart();
+        return false;
+    }
+
+    return true;
+}
+
+void BacktraceGenerator::slotReadInput()
+{
+    // we do not know if the output array ends in the middle of an utf-8 sequence
+    m_output += m_proc->readAllStandardOutput();
+
+    int pos;
+    while ((pos = m_output.indexOf('\n')) != -1) {
+        QString line = QString::fromLocal8Bit(m_output, pos + 1);
+        m_output.remove(0, pos + 1);
+
+        emit newLine(line);
+    }
+}
+
+void BacktraceGenerator::slotProcessExited(int exitCode, QProcess::ExitStatus exitStatus)
+{
+    //these are useless now
+    m_proc->deleteLater();
+    m_temp->deleteLater();
+    m_proc = NULL;
+    m_temp = NULL;
+
+    //mark the end of the backtrace for the parser
+    emit newLine(QString());
+
+    if (exitStatus != QProcess::NormalExit || exitCode != 0) {
+        m_state = Failed;
+        emit someError();
+        return;
+    }
+
+    //no translation, string appears in the report
+    QString tmp(QStringLiteral("Application: %progname (%execname), signal: %signame\n"));
+    Debugger::expandString(tmp, m_crashedApplication);
+
+    m_parsedBacktrace = tmp + m_parser->parsedBacktrace();
+    m_state = Loaded;
+
+#ifdef BACKTRACE_PARSER_DEBUG
+    //append the raw unparsed backtrace
+    m_parsedBacktrace += "\n------------ Unparsed Backtrace ------------\n";
+    m_parsedBacktrace += m_debugParser->parsedBacktrace(); //it's not really parsed, it's from the null parser.
+#endif
+
+    emit done();
+}
+
+
diff --git a/src/libcrashreporter-gui/linux-backtrace-generator/backtracegenerator.h b/src/libcrashreporter-gui/linux-backtrace-generator/backtracegenerator.h
new file mode 100644
index 0000000..41eaa32
--- /dev/null
+++ b/src/libcrashreporter-gui/linux-backtrace-generator/backtracegenerator.h
@@ -0,0 +1,91 @@
+/*****************************************************************
+ * drkonqi - The KDE Crash Handler
+ *
+ * Copyright (C) 2000-2003 Hans Petter Bieker <bieker@kde.org>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *****************************************************************/
+
+#ifndef BACKTRACEGENERATOR_H
+#define BACKTRACEGENERATOR_H
+
+#include <QProcess>
+#include <QTemporaryFile>
+
+#include "debugger.h"
+
+class BacktraceParser;
+
+class BacktraceGenerator : public QObject
+{
+    Q_OBJECT
+
+public:
+    enum State { NotLoaded, Loading, Loaded, Failed, FailedToStart };
+
+    BacktraceGenerator(const Debugger & debugger,
+                       const CrashedApplication* crashedApp,
+                       QObject *parent);
+    ~BacktraceGenerator() override;
+
+    State state() const {
+        return m_state;
+    }
+
+    BacktraceParser *parser() const {
+        return m_parser;
+    }
+
+    QString backtrace() const {
+        return m_parsedBacktrace;
+    }
+
+    const Debugger debugger() const {
+        return m_debugger;
+    }
+
+public Q_SLOTS:
+    bool start();
+
+Q_SIGNALS:
+    void starting();
+    void newLine(const QString &str); // emitted for every line
+    void someError();
+    void failedToStart();
+    void done();
+
+private Q_SLOTS:
+    void slotProcessExited(int exitCode, QProcess::ExitStatus exitStatus);
+    void slotReadInput();
+
+private:
+    const Debugger    m_debugger;
+    QProcess *        m_proc;
+    QTemporaryFile *  m_temp;
+    QByteArray        m_output;
+    State             m_state;
+    BacktraceParser * m_parser;
+    QString           m_parsedBacktrace;
+    const CrashedApplication* m_crashedApplication;
+};
+
+#endif
diff --git a/src/libcrashreporter-gui/linux-backtrace-generator/crashedapplication.cpp b/src/libcrashreporter-gui/linux-backtrace-generator/crashedapplication.cpp
new file mode 100644
index 0000000..6bda14d
--- /dev/null
+++ b/src/libcrashreporter-gui/linux-backtrace-generator/crashedapplication.cpp
@@ -0,0 +1,163 @@
+/*
+    Copyright (C) 2009  George Kiagiadakis <gkiagia@users.sourceforge.net>
+
+    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) 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 <http://www.gnu.org/licenses/>.
+*/
+
+#include "crashedapplication.h"
+
+#if defined(HAVE_STRSIGNAL) && defined(Q_OS_UNIX)
+# include <clocale>
+# include <cstring>
+# include <cstdlib>
+#else
+# if defined(Q_OS_UNIX)
+#  include <signal.h>
+# else
+#  include <windows.h>
+# endif
+#endif
+
+CrashedApplication::CrashedApplication(int pid,
+                                       int signalNumber,
+                                       QString name,
+                                       QFileInfo executable,
+                                       QString fakeBaseName,
+                                       QString version,
+                                       int thread,
+                                       QDateTime dateTime,
+                                       QObject *parent)
+    : QObject(parent)
+    , m_pid(pid)
+    , m_name(name)
+    , m_executable(executable)
+    , m_fakeBaseName(fakeBaseName)
+    , m_version(version)
+    , m_thread(thread)
+    , m_datetime(dateTime)
+{
+}
+
+CrashedApplication::~CrashedApplication()
+{
+}
+
+QString CrashedApplication::name() const
+{
+    return m_name.isEmpty() ? fakeExecutableBaseName() : m_name;
+}
+
+QFileInfo CrashedApplication::executable() const
+{
+    return m_executable;
+}
+
+QString CrashedApplication::fakeExecutableBaseName() const
+{
+    if (!m_fakeBaseName.isEmpty()) {
+        return m_fakeBaseName;
+    } else {
+        return m_executable.baseName();
+    }
+}
+
+QString CrashedApplication::version() const
+{
+    return m_version;
+}
+
+int CrashedApplication::pid() const
+{
+    return m_pid;
+}
+
+int CrashedApplication::signalNumber() const
+{
+    return m_signalNumber;
+}
+
+QString CrashedApplication::signalName() const
+{
+#if defined(HAVE_STRSIGNAL) && defined(Q_OS_UNIX)
+    const char * oldLocale = std::setlocale(LC_MESSAGES, NULL);
+    char * savedLocale;
+    if (oldLocale) {
+        savedLocale = strdup(oldLocale);
+    } else {
+        savedLocale = NULL;
+    }
+    std::setlocale(LC_MESSAGES, "C");
+    const char *name = strsignal(m_signalNumber);
+    std::setlocale(LC_MESSAGES, savedLocale);
+    std::free(savedLocale);
+    return QString::fromLocal8Bit(name != NULL ? name : "Unknown");
+#else
+    switch (m_signalNumber) {
+# if defined(Q_OS_UNIX)
+    case SIGILL: return QLatin1String("SIGILL");
+    case SIGABRT: return QLatin1String("SIGABRT");
+    case SIGFPE: return QLatin1String("SIGFPE");
+    case SIGSEGV: return QLatin1String("SIGSEGV");
+    case SIGBUS: return QLatin1String("SIGBUS");
+# else
+    case EXCEPTION_ACCESS_VIOLATION: return QLatin1String("EXCEPTION_ACCESS_VIOLATION");
+    case EXCEPTION_DATATYPE_MISALIGNMENT: return QLatin1String("EXCEPTION_DATATYPE_MISALIGNMENT");
+    case EXCEPTION_BREAKPOINT: return QLatin1String("EXCEPTION_BREAKPOINT");
+    case EXCEPTION_SINGLE_STEP: return QLatin1String("EXCEPTION_SINGLE_STEP");
+    case EXCEPTION_ARRAY_BOUNDS_EXCEEDED: return QLatin1String("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
+    case EXCEPTION_FLT_DENORMAL_OPERAND: return QLatin1String("EXCEPTION_FLT_DENORMAL_OPERAND");
+    case EXCEPTION_FLT_DIVIDE_BY_ZERO: return QLatin1String("EXCEPTION_FLT_DIVIDE_BY_ZERO");
+    case EXCEPTION_FLT_INEXACT_RESULT: return QLatin1String("EXCEPTION_FLT_INEXACT_RESULT");
+    case EXCEPTION_FLT_INVALID_OPERATION: return QLatin1String("EXCEPTION_FLT_INVALID_OPERATION");
+    case EXCEPTION_FLT_OVERFLOW: return QLatin1String("EXCEPTION_FLT_OVERFLOW");
+    case EXCEPTION_FLT_STACK_CHECK: return QLatin1String("EXCEPTION_FLT_STACK_CHECK");
+    case EXCEPTION_FLT_UNDERFLOW: return QLatin1String("EXCEPTION_FLT_UNDERFLOW");
+    case EXCEPTION_INT_DIVIDE_BY_ZERO: return QLatin1String("EXCEPTION_INT_DIVIDE_BY_ZERO");
+    case EXCEPTION_INT_OVERFLOW: return QLatin1String("EXCEPTION_INT_OVERFLOW");
+    case EXCEPTION_PRIV_INSTRUCTION: return QLatin1String("EXCEPTION_PRIV_INSTRUCTION");
+    case EXCEPTION_IN_PAGE_ERROR: return QLatin1String("EXCEPTION_IN_PAGE_ERROR");
+    case EXCEPTION_ILLEGAL_INSTRUCTION: return QLatin1String("EXCEPTION_ILLEGAL_INSTRUCTION");
+    case EXCEPTION_NONCONTINUABLE_EXCEPTION: return QLatin1String("EXCEPTION_NONCONTINUABLE_EXCEPTION");
+    case EXCEPTION_STACK_OVERFLOW: return QLatin1String("EXCEPTION_STACK_OVERFLOW");
+    case EXCEPTION_INVALID_DISPOSITION: return QLatin1String("EXCEPTION_INVALID_DISPOSITION");
+# endif
+    default: return QLatin1String("Unknown");
+    }
+#endif
+}
+
+int CrashedApplication::thread() const
+{
+    return m_thread;
+}
+
+const QDateTime& CrashedApplication::datetime() const
+{
+    return m_datetime;
+}
+
+QString getSuggestedKCrashFilename(const CrashedApplication* app)
+{
+    QString filename = app->fakeExecutableBaseName() + '-' +
+                       app->datetime().toString(QStringLiteral("yyyyMMdd-hhmmss")) +
+                       ".kcrash.txt";
+
+    if (filename.contains('/')) {
+        filename = filename.mid(filename.lastIndexOf('/') + 1);
+    }
+
+    return filename;
+}
+
+
diff --git a/src/libcrashreporter-gui/linux-backtrace-generator/crashedapplication.h b/src/libcrashreporter-gui/linux-backtrace-generator/crashedapplication.h
new file mode 100644
index 0000000..79677a8
--- /dev/null
+++ b/src/libcrashreporter-gui/linux-backtrace-generator/crashedapplication.h
@@ -0,0 +1,83 @@
+/*
+    Copyright (C) 2009  George Kiagiadakis <gkiagia@users.sourceforge.net>
+
+    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) 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 <http://www.gnu.org/licenses/>.
+*/
+#ifndef CRASHEDAPPLICATION_H
+#define CRASHEDAPPLICATION_H
+
+#include <QtCore/QObject>
+#include <QtCore/QDateTime>
+#include <QtCore/QFileInfo>
+
+class CrashedApplication : public QObject
+{
+    Q_OBJECT
+public:
+    CrashedApplication( int pid,
+                        int signalNumber,
+                        QString name,
+                        QFileInfo executable,
+                        QString fakeBaseName,
+                        QString version,
+                        int thread,
+                        QDateTime dateTime,
+                        QObject *parent = 0);
+
+    ~CrashedApplication() override;
+
+    /** Returns the crashed program's name, possibly translated (ex. "The KDE Crash Handler") */
+    QString name() const;
+
+    /** Returns a QFileInfo with information about the executable that crashed */
+    QFileInfo executable() const;
+
+    /** When an application is run via kdeinit, the executable() method returns kdeinit4, but
+     * we still need a way to know which is the application that was loaded by kdeinit. So,
+     * this method returns the base name of the executable that would have been launched if
+     * the app had not been loaded by kdeinit (ex. "plasma-desktop"). If the application was
+     * not launched via kdeinit, this method returns executable().baseName();
+     */
+    QString fakeExecutableBaseName() const;
+
+    /** Returns the version of the crashed program */
+    QString version() const;
+
+    /** Returns the pid of the crashed program */
+    int pid() const;
+
+    /** Returns the signal number that the crashed program received */
+    int signalNumber() const;
+
+    /** Returns the name of the signal (ex. SIGSEGV) */
+    QString signalName() const;
+
+    int thread() const;
+
+    const QDateTime& datetime() const;
+
+protected:
+    int m_pid;
+    int m_signalNumber;
+    QString m_name;
+    QFileInfo m_executable;
+    QString m_fakeBaseName;
+    QString m_version;
+    int m_thread;
+    QDateTime m_datetime;
+};
+
+QString getSuggestedKCrashFilename(const CrashedApplication* app);
+
+#endif // CRASHEDAPPLICATION_H
diff --git a/src/libcrashreporter-gui/linux-backtrace-generator/crqt-kmacroexpander.cpp b/src/libcrashreporter-gui/linux-backtrace-generator/crqt-kmacroexpander.cpp
new file mode 100644
index 0000000..77de2fd
--- /dev/null
+++ b/src/libcrashreporter-gui/linux-backtrace-generator/crqt-kmacroexpander.cpp
@@ -0,0 +1,405 @@
+/*
+    This file is part of the KDE libraries
+
+    Copyright (c) 2002-2003 Oswald Buddenhagen <ossi@kde.org>
+    Copyright (c) 2003 Waldo Bastian <bastian@kde.org>
+
+    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 2 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; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+
+#include "crqt-kmacroexpander_p.h"
+
+#include <QtCore/QHash>
+#include <QtCore/QStringList>
+
+KMacroExpanderBase::KMacroExpanderBase(QChar c) : d(new KMacroExpanderBasePrivate(c))
+{
+}
+
+KMacroExpanderBase::~KMacroExpanderBase()
+{
+    delete d;
+}
+
+void
+KMacroExpanderBase::setEscapeChar(QChar c)
+{
+    d->escapechar = c;
+}
+
+QChar
+KMacroExpanderBase::escapeChar() const
+{
+    return d->escapechar;
+}
+
+void KMacroExpanderBase::expandMacros(QString &str)
+{
+    int pos;
+    int len;
+    ushort ec = d->escapechar.unicode();
+    QStringList rst;
+    QString rsts;
+
+    for (pos = 0; pos < str.length();) {
+        if (ec != 0) {
+            if (str.unicode()[pos].unicode() != ec) {
+                goto nohit;
+            }
+            if (!(len = expandEscapedMacro(str, pos, rst))) {
+                goto nohit;
+            }
+        } else {
+            if (!(len = expandPlainMacro(str, pos, rst))) {
+                goto nohit;
+            }
+        }
+        if (len < 0) {
+            pos -= len;
+            continue;
+        }
+        rsts = rst.join(QLatin1Char(' '));
+        rst.clear();
+        str.replace(pos, len, rsts);
+        pos += rsts.length();
+        continue;
+    nohit:
+        pos++;
+    }
+}
+
+bool KMacroExpanderBase::expandMacrosShellQuote(QString &str)
+{
+    int pos = 0;
+    return expandMacrosShellQuote(str, pos) && pos == str.length();
+}
+
+int KMacroExpanderBase::expandPlainMacro(const QString &, int, QStringList &)
+{
+    qFatal("KMacroExpanderBase::expandPlainMacro called!");
+    return 0;
+}
+
+int KMacroExpanderBase::expandEscapedMacro(const QString &, int, QStringList &)
+{
+    qFatal("KMacroExpanderBase::expandEscapedMacro called!");
+    return 0;
+}
+
+//////////////////////////////////////////////////
+
+template <typename KT, typename VT>
+class KMacroMapExpander : public KMacroExpanderBase
+{
+
+public:
+    KMacroMapExpander(const QHash<KT, VT> &map, QChar c = QLatin1Char('%')) :
+        KMacroExpanderBase(c), macromap(map) {}
+
+protected:
+    int expandPlainMacro(const QString &str, int pos, QStringList &ret) Q_DECL_OVERRIDE;
+    int expandEscapedMacro(const QString &str, int pos, QStringList &ret) Q_DECL_OVERRIDE;
+
+private:
+    QHash<KT, VT> macromap;
+};
+
+static QStringList &operator+=(QStringList &s, const QString &n)
+{
+    s << n;
+    return s;
+}
+
+////////
+
+static bool
+isIdentifier(ushort c)
+{
+    return c == '_' ||
+           (c >= 'A' && c <= 'Z') ||
+           (c >= 'a' && c <= 'z') ||
+           (c >= '0' && c <= '9');
+}
+
+////////
+
+template <typename VT>
+class KMacroMapExpander<QChar, VT> : public KMacroExpanderBase
+{
+
+public:
+    KMacroMapExpander(const QHash<QChar, VT> &map, QChar c = QLatin1Char('%')) :
+        KMacroExpanderBase(c), macromap(map) {}
+
+protected:
+    int expandPlainMacro(const QString &str, int pos, QStringList &ret) Q_DECL_OVERRIDE;
+    int expandEscapedMacro(const QString &str, int pos, QStringList &ret) Q_DECL_OVERRIDE;
+
+private:
+    QHash<QChar, VT> macromap;
+};
+
+template <typename VT>
+int
+KMacroMapExpander<QChar, VT>::expandPlainMacro(const QString &str, int pos, QStringList &ret)
+{
+    typename QHash<QChar, VT>::const_iterator it = macromap.constFind(str.unicode()[pos]);
+    if (it != macromap.constEnd()) {
+        ret += it.value();
+        return 1;
+    }
+    return 0;
+}
+
+template <typename VT>
+int
+KMacroMapExpander<QChar, VT>::expandEscapedMacro(const QString &str, int pos, QStringList &ret)
+{
+    if (str.length() <= pos + 1) {
+        return 0;
+    }
+
+    if (str.unicode()[pos + 1] == escapeChar()) {
+        ret += QString(escapeChar());
+        return 2;
+    }
+    typename QHash<QChar, VT>::const_iterator it = macromap.constFind(str.unicode()[pos + 1]);
+    if (it != macromap.constEnd()) {
+        ret += it.value();
+        return 2;
+    }
+
+    return 0;
+}
+
+template <typename VT>
+class KMacroMapExpander<QString, VT> : public KMacroExpanderBase
+{
+
+public:
+    KMacroMapExpander(const QHash<QString, VT> &map, QChar c = QLatin1Char('%')) :
+        KMacroExpanderBase(c), macromap(map) {}
+
+protected:
+    int expandPlainMacro(const QString &str, int pos, QStringList &ret) Q_DECL_OVERRIDE;
+    int expandEscapedMacro(const QString &str, int pos, QStringList &ret) Q_DECL_OVERRIDE;
+
+private:
+    QHash<QString, VT> macromap;
+};
+
+template <typename VT>
+int
+KMacroMapExpander<QString, VT>::expandPlainMacro(const QString &str, int pos, QStringList &ret)
+{
+    if (pos && isIdentifier(str.unicode()[pos - 1].unicode())) {
+        return 0;
+    }
+    int sl;
+    for (sl = 0; isIdentifier(str.unicode()[pos + sl].unicode()); sl++)
+        ;
+    if (!sl) {
+        return 0;
+    }
+    typename QHash<QString, VT>::const_iterator it =
+        macromap.constFind(str.mid(pos, sl));
+    if (it != macromap.constEnd()) {
+        ret += it.value();
+        return sl;
+    }
+    return 0;
+}
+
+template <typename VT>
+int
+KMacroMapExpander<QString, VT>::expandEscapedMacro(const QString &str, int pos, QStringList &ret)
+{
+    if (str.length() <= pos + 1) {
+        return 0;
+    }
+
+    if (str.unicode()[pos + 1] == escapeChar()) {
+        ret += QString(escapeChar());
+        return 2;
+    }
+    int sl, rsl, rpos;
+    if (str.unicode()[pos + 1].unicode() == '{') {
+        rpos = pos + 2;
+        if ((sl = str.indexOf(QLatin1Char('}'), rpos)) < 0) {
+            return 0;
+        }
+        sl -= rpos;
+        rsl = sl + 3;
+    } else {
+        rpos = pos + 1;
+        for (sl = 0; isIdentifier(str.unicode()[rpos + sl].unicode()); ++sl)
+            ;
+        rsl = sl + 1;
+    }
+    if (!sl) {
+        return 0;
+    }
+    typename QHash<QString, VT>::const_iterator it =
+        macromap.constFind(str.mid(rpos, sl));
+    if (it != macromap.constEnd()) {
+        ret += it.value();
+        return rsl;
+    }
+    return 0;
+}
+
+////////////
+
+int
+KCharMacroExpander::expandPlainMacro(const QString &str, int pos, QStringList &ret)
+{
+    if (expandMacro(str.unicode()[pos], ret)) {
+        return 1;
+    }
+    return 0;
+}
+
+int
+KCharMacroExpander::expandEscapedMacro(const QString &str, int pos, QStringList &ret)
+{
+    if (str.length() <= pos + 1) {
+        return 0;
+    }
+
+    if (str.unicode()[pos + 1] == escapeChar()) {
+        ret += QString(escapeChar());
+        return 2;
+    }
+    if (expandMacro(str.unicode()[pos + 1], ret)) {
+        return 2;
+    }
+    return 0;
+}
+
+int
+KWordMacroExpander::expandPlainMacro(const QString &str, int pos, QStringList &ret)
+{
+    if (pos && isIdentifier(str.unicode()[pos - 1].unicode())) {
+        return 0;
+    }
+    int sl;
+    for (sl = 0; isIdentifier(str.unicode()[pos + sl].unicode()); sl++)
+        ;
+    if (!sl) {
+        return 0;
+    }
+    if (expandMacro(str.mid(pos, sl), ret)) {
+        return sl;
+    }
+    return 0;
+}
+
+int
+KWordMacroExpander::expandEscapedMacro(const QString &str, int pos, QStringList &ret)
+{
+    if (str.length() <= pos + 1) {
+        return 0;
+    }
+
+    if (str.unicode()[pos + 1] == escapeChar()) {
+        ret += QString(escapeChar());
+        return 2;
+    }
+    int sl, rsl, rpos;
+    if (str.unicode()[pos + 1].unicode() == '{') {
+        rpos = pos + 2;
+        if ((sl = str.indexOf(QLatin1Char('}'), rpos)) < 0) {
+            return 0;
+        }
+        sl -= rpos;
+        rsl = sl + 3;
+    } else {
+        rpos = pos + 1;
+        for (sl = 0; isIdentifier(str.unicode()[rpos + sl].unicode()); ++sl)
+            ;
+        rsl = sl + 1;
+    }
+    if (!sl) {
+        return 0;
+    }
+    if (expandMacro(str.mid(rpos, sl), ret)) {
+        return rsl;
+    }
+    return 0;
+}
+
+////////////
+
+template <typename KT, typename VT>
+inline QString
+TexpandMacros(const QString &ostr, const QHash<KT, VT> &map, QChar c)
+{
+    QString str(ostr);
+    KMacroMapExpander<KT, VT> kmx(map, c);
+    kmx.expandMacros(str);
+    return str;
+}
+
+template <typename KT, typename VT>
+inline QString
+TexpandMacrosShellQuote(const QString &ostr, const QHash<KT, VT> &map, QChar c)
+{
+    QString str(ostr);
+    KMacroMapExpander<KT, VT> kmx(map, c);
+    if (!kmx.expandMacrosShellQuote(str)) {
+        return QString();
+    }
+    return str;
+}
+
+// public API
+namespace KMacroExpander
+{
+
+QString expandMacros(const QString &ostr, const QHash<QChar, QString> &map, QChar c)
+{
+    return TexpandMacros(ostr, map, c);
+}
+QString expandMacrosShellQuote(const QString &ostr, const QHash<QChar, QString> &map, QChar c)
+{
+    return TexpandMacrosShellQuote(ostr, map, c);
+}
+QString expandMacros(const QString &ostr, const QHash<QString, QString> &map, QChar c)
+{
+    return TexpandMacros(ostr, map, c);
+}
+QString expandMacrosShellQuote(const QString &ostr, const QHash<QString, QString> &map, QChar c)
+{
+    return TexpandMacrosShellQuote(ostr, map, c);
+}
+QString expandMacros(const QString &ostr, const QHash<QChar, QStringList> &map, QChar c)
+{
+    return TexpandMacros(ostr, map, c);
+}
+QString expandMacrosShellQuote(const QString &ostr, const QHash<QChar, QStringList> &map, QChar c)
+{
+    return TexpandMacrosShellQuote(ostr, map, c);
+}
+QString expandMacros(const QString &ostr, const QHash<QString, QStringList> &map, QChar c)
+{
+    return TexpandMacros(ostr, map, c);
+}
+QString expandMacrosShellQuote(const QString &ostr, const QHash<QString, QStringList> &map, QChar c)
+{
+    return TexpandMacrosShellQuote(ostr, map, c);
+}
+
+} // namespace
diff --git a/src/libcrashreporter-gui/linux-backtrace-generator/crqt-kmacroexpander.h b/src/libcrashreporter-gui/linux-backtrace-generator/crqt-kmacroexpander.h
new file mode 100644
index 0000000..4e21a5d
--- /dev/null
+++ b/src/libcrashreporter-gui/linux-backtrace-generator/crqt-kmacroexpander.h
@@ -0,0 +1,411 @@
+/*
+    This file is part of the KDE libraries
+
+    Copyright (c) 2002-2003 Oswald Buddenhagen <ossi@kde.org>
+    Copyright (c) 2003 Waldo Bastian <bastian@kde.org>
+
+    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 2 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; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+#ifndef KMACROEXPANDER_H
+#define KMACROEXPANDER_H
+
+#include <QtCore/QChar>
+
+class QString;
+class QStringList;
+template <typename KT, typename VT> class QHash;
+class KMacroExpanderBasePrivate;
+
+/**
+ * \class KMacroExpanderBase kmacroexpander.h <KMacroExpanderBase>
+ *
+ * Abstract base class for the worker classes behind the KMacroExpander namespace
+ * and the KCharMacroExpander and KWordMacroExpander classes.
+ *
+ * @author Oswald Buddenhagen <ossi@kde.org>
+ */
+class KMacroExpanderBase
+{
+
+public:
+    /**
+     * Constructor.
+     * @param c escape char indicating start of macros, or QChar::null for none
+     */
+    explicit KMacroExpanderBase(QChar c = QLatin1Char('%'));
+
+    /**
+     * Destructor.
+     */
+    virtual ~KMacroExpanderBase();
+
+    /**
+     * Perform safe macro expansion (substitution) on a string.
+     *
+     * @param str the string in which macros are expanded in-place
+     */
+    void expandMacros(QString &str);
+
+    // TODO: This documentation is relevant for end-users. Where to put it?
+    /**
+     * Perform safe macro expansion (substitution) on a string for use
+     * in shell commands.
+     *
+     * <h3>*NIX notes</h3>
+     *
+     * Explicitly supported shell constructs:
+     *   \ '' "" $'' $"" {} () $(()) ${} $() ``
+     *
+     * Implicitly supported shell constructs:
+     *   (())
+     *
+     * Unsupported shell constructs that will cause problems:
+     *  Shortened &quot;<tt>case $v in pat)</tt>&quot; syntax. Use
+     *   &quot;<tt>case $v in (pat)</tt>&quot; instead.
+     *
+     * The rest of the shell (incl. bash) syntax is simply ignored,
+     * as it is not expected to cause problems.
+     *
+     * Note that bash contains a bug which makes macro expansion within
+     * double quoted substitutions (<tt>"${VAR:-%macro}"</tt>) inherently
+     * insecure.
+     *
+     * For security reasons, @em never put expandos in command line arguments
+     * that are shell commands by themselves -
+     * &quot;<tt>sh -c 'foo \%f'</tt>&quot; is taboo.
+     * &quot;<tt>file=\%f sh -c 'foo "$file"'</tt>&quot; is OK.
+     *
+     * <h3>Windows notes</h3>
+     *
+     * All quoting syntax supported by KShell is supported here as well.
+     * Additionally, command grouping via parentheses is recognized - note
+     * however, that the parser is much stricter about unquoted parentheses
+     * than cmd itself.
+     * The rest of the cmd syntax is simply ignored, as it is not expected
+     * to cause problems - do not use commands that embed other commands,
+     * though - &quot;<tt>for /f ...</tt>&quot; is taboo.
+     *
+     * @param str the string in which macros are expanded in-place
+     * @param pos the position inside the string at which parsing/substitution
+     *  should start, and upon exit where processing stopped
+     * @return false if the string could not be parsed and therefore no safe
+     *  substitution was possible. Note that macros will have been processed
+     *  up to the point where the error occurred. An unmatched closing paren
+     *  or brace outside any shell construct is @em not an error (unlike in
+     *  the function below), but still prematurely terminates processing.
+     */
+    bool expandMacrosShellQuote(QString &str, int &pos);
+
+    /**
+     * Same as above, but always starts at position 0, and unmatched closing
+     * parens and braces are treated as errors.
+     */
+    bool expandMacrosShellQuote(QString &str);
+
+    /**
+     * Set the macro escape character.
+     * @param c escape char indicating start of macros, or QChar::null if none
+     */
+    void setEscapeChar(QChar c);
+
+    /**
+     * Obtain the macro escape character.
+     * @return escape char indicating start of macros, or QChar::null if none
+     */
+    QChar escapeChar() const;
+
+protected:
+    /**
+     * This function is called for every single char within the string if
+     * the escape char is QChar::null. It should determine whether the
+     * string starting at @p pos within @p str is a valid macro and return
+     * the substitution value for it if so.
+     * @param str the input string
+     * @param pos the offset within @p str
+     * @param ret return value: the string to substitute for the macro
+     * @return If greater than zero, the number of chars at @p pos in @p str
+     *  to substitute with @p ret (i.e., a valid macro was found). If less
+     *  than zero, subtract this value from @p pos (to skip a macro, i.e.,
+     *  substitute it with itself). If zero, no macro starts at @p pos.
+     */
+    virtual int expandPlainMacro(const QString &str, int pos, QStringList &ret);
+
+    /**
+     * This function is called every time the escape char is found if it is
+     * not QChar::null. It should determine whether the
+     * string starting at @p pos witin @p str is a valid macro and return
+     * the substitution value for it if so.
+     * @param str the input string
+     * @param pos the offset within @p str. Note that this is the position of
+     *  the occurrence of the escape char
+     * @param ret return value: the string to substitute for the macro
+     * @return If greater than zero, the number of chars at @p pos in @p str
+     *  to substitute with @p ret (i.e., a valid macro was found). If less
+     *  than zero, subtract this value from @p pos (to skip a macro, i.e.,
+     *  substitute it with itself). If zero, scanning continues as if no
+     *  escape char was encountered at all.
+     */
+    virtual int expandEscapedMacro(const QString &str, int pos, QStringList &ret);
+
+private:
+    KMacroExpanderBasePrivate *const d;
+};
+
+/**
+ * \class KWordMacroExpander kmacroexpander.h <KMacroExpanderBase>
+ *
+ * Abstract base class for simple word macro substitutors. Use this instead of
+ * the functions in the KMacroExpander namespace if speculatively pre-filling
+ * the substitution map would be too expensive.
+ *
+ * A typical application:
+ *
+ * \code
+ * class MyClass {
+ * ...
+ *   private:
+ *     QString m_str;
+ * ...
+ *   friend class MyExpander;
+ * };
+ *
+ * class MyExpander : public KWordMacroExpander {
+ *   public:
+ *     MyExpander( MyClass *_that ) : KWordMacroExpander(), that( _that ) {}
+ *   protected:
+ *     virtual bool expandMacro( const QString &str, QStringList &ret );
+ *   private:
+ *     MyClass *that;
+ * };
+ *
+ * bool MyExpander::expandMacro( const QString &str, QStringList &ret )
+ * {
+ *   if (str == "macro") {
+ *     ret += complexOperation( that->m_str );
+ *     return true;
+ *   }
+ *   return false;
+ * }
+ *
+ * ... MyClass::...(...)
+ * {
+ *   QString str;
+ *   ...
+ *   MyExpander mx( this );
+ *   mx.expandMacrosShellQuote( str );
+ *   ...
+ * }
+ * \endcode
+ *
+ * Alternatively MyClass could inherit from KWordMacroExpander directly.
+ *
+ * @author Oswald Buddenhagen <ossi@kde.org>
+ */
+class KWordMacroExpander : public KMacroExpanderBase
+{
+
+public:
+    /**
+     * Constructor.
+     * @param c escape char indicating start of macros, or QChar::null for none
+     */
+    explicit KWordMacroExpander(QChar c = QLatin1Char('%')) : KMacroExpanderBase(c) {}
+
+protected:
+    /** \internal Not to be called or reimplemented. */
+    int expandPlainMacro(const QString &str, int pos, QStringList &ret) Q_DECL_OVERRIDE;
+    /** \internal Not to be called or reimplemented. */
+    int expandEscapedMacro(const QString &str, int pos, QStringList &ret) Q_DECL_OVERRIDE;
+
+    /**
+     * Return substitution list @p ret for string macro @p str.
+     * @param str the macro to expand
+     * @param ret return variable reference. It is guaranteed to be empty
+     *  when expandMacro is entered.
+     * @return @c true iff @p chr was a recognized macro name
+     */
+    virtual bool expandMacro(const QString &str, QStringList &ret) = 0;
+};
+
+/**
+ * \class KCharMacroExpander kmacroexpander.h <KMacroExpanderBase>
+ *
+ * Abstract base class for single char macro substitutors. Use this instead of
+ * the functions in the KMacroExpander namespace if speculatively pre-filling
+ * the substitution map would be too expensive.
+ *
+ * See KWordMacroExpander for a sample application.
+ *
+ * @author Oswald Buddenhagen <ossi@kde.org>
+ */
+class KCharMacroExpander : public KMacroExpanderBase
+{
+
+public:
+    /**
+     * Constructor.
+     * @param c escape char indicating start of macros, or QChar::null for none
+     */
+    explicit KCharMacroExpander(QChar c = QLatin1Char('%')) : KMacroExpanderBase(c) {}
+
+protected:
+    /** \internal Not to be called or reimplemented. */
+    int expandPlainMacro(const QString &str, int pos, QStringList &ret) Q_DECL_OVERRIDE;
+    /** \internal Not to be called or reimplemented. */
+    int expandEscapedMacro(const QString &str, int pos, QStringList &ret) Q_DECL_OVERRIDE;
+
+    /**
+     * Return substitution list @p ret for single-character macro @p chr.
+     * @param chr the macro to expand
+     * @param ret return variable reference. It is guaranteed to be empty
+     *  when expandMacro is entered.
+     * @return @c true iff @p chr was a recognized macro name
+     */
+    virtual bool expandMacro(QChar chr, QStringList &ret) = 0;
+};
+
+/**
+ * A group of functions providing macro expansion (substitution) in strings,
+ * optionally with quoting appropriate for shell execution.
+ */
+namespace KMacroExpander
+{
+/**
+ * Perform safe macro expansion (substitution) on a string.
+ * The escape char must be quoted with itself to obtain its literal
+ * representation in the resulting string.
+ *
+ * @param str The string to expand
+ * @param map map with substitutions
+ * @param c escape char indicating start of macro, or QChar::null if none
+ * @return the string with all valid macros expanded
+ *
+ * \code
+ * // Code example
+ * QHash<QChar,QString> map;
+ * map.insert('u', "/tmp/myfile.txt");
+ * map.insert('n', "My File");
+ * QString s = "%% Title: %u:%n";
+ * s = KMacroExpander::expandMacros(s, map);
+ * // s is now "% Title: /tmp/myfile.txt:My File";
+ * \endcode
+ */
+QString expandMacros(const QString &str, const QHash<QChar, QString> &map, QChar c = QLatin1Char('%'));
+
+/**
+ * Perform safe macro expansion (substitution) on a string for use
+ * in shell commands.
+ * The escape char must be quoted with itself to obtain its literal
+ * representation in the resulting string.
+ *
+ * @param str The string to expand
+ * @param map map with substitutions
+ * @param c escape char indicating start of macro, or QChar::null if none
+ * @return the string with all valid macros expanded, or a null string
+ *  if a shell syntax error was detected in the command
+ *
+ * \code
+ * // Code example
+ * QHash<QChar,QString> map;
+ * map.insert('u', "/tmp/myfile.txt");
+ * map.insert('n', "My File");
+ * QString s = "kedit --caption %n %u";
+ * s = KMacroExpander::expandMacrosShellQuote(s, map);
+ * // s is now "kedit --caption 'My File' '/tmp/myfile.txt'";
+ * system(QFile::encodeName(s));
+ * \endcode
+ */
+QString expandMacrosShellQuote(const QString &str, const QHash<QChar, QString> &map,
+        QChar c = QLatin1Char('%'));
+
+/**
+ * Perform safe macro expansion (substitution) on a string.
+ * The escape char must be quoted with itself to obtain its literal
+ * representation in the resulting string.
+ * Macro names can consist of chars in the range [A-Za-z0-9_];
+ * use braces to delimit macros from following words starting
+ * with these chars, or to use other chars for macro names.
+ *
+ * @param str The string to expand
+ * @param map map with substitutions
+ * @param c escape char indicating start of macro, or QChar::null if none
+ * @return the string with all valid macros expanded
+ *
+ * \code
+ * // Code example
+ * QHash<QString,QString> map;
+ * map.insert("url", "/tmp/myfile.txt");
+ * map.insert("name", "My File");
+ * QString s = "Title: %{url}-%name";
+ * s = KMacroExpander::expandMacros(s, map);
+ * // s is now "Title: /tmp/myfile.txt-My File";
+ * \endcode
+ */
+QString expandMacros(const QString &str, const QHash<QString, QString> &map,
+                                        QChar c = QLatin1Char('%'));
+
+/**
+ * Perform safe macro expansion (substitution) on a string for use
+ * in shell commands. See KMacroExpanderBase::expandMacrosShellQuote()
+ * for the exact semantics.
+ * The escape char must be quoted with itself to obtain its literal
+ * representation in the resulting string.
+ * Macro names can consist of chars in the range [A-Za-z0-9_];
+ * use braces to delimit macros from following words starting
+ * with these chars, or to use other chars for macro names.
+ *
+ * @param str The string to expand
+ * @param map map with substitutions
+ * @param c escape char indicating start of macro, or QChar::null if none
+ * @return the string with all valid macros expanded, or a null string
+ *  if a shell syntax error was detected in the command
+ *
+ * \code
+ * // Code example
+ * QHash<QString,QString> map;
+ * map.insert("url", "/tmp/myfile.txt");
+ * map.insert("name", "My File");
+ * QString s = "kedit --caption %name %{url}";
+ * s = KMacroExpander::expandMacrosShellQuote(s, map);
+ * // s is now "kedit --caption 'My File' '/tmp/myfile.txt'";
+ * system(QFile::encodeName(s));
+ * \endcode
+ */
+QString expandMacrosShellQuote(const QString &str, const QHash<QString, QString> &map,
+        QChar c = QLatin1Char('%'));
+
+/**
+ * Same as above, except that the macros expand to string lists that
+ * are simply join(" ")ed together.
+ */
+QString expandMacros(const QString &str, const QHash<QChar, QStringList> &map,
+                                        QChar c = QLatin1Char('%'));
+QString expandMacros(const QString &str, const QHash<QString, QStringList> &map,
+                                        QChar c = QLatin1Char('%'));
+
+/**
+ * Same as above, except that the macros expand to string lists.
+ * If the macro appears inside a quoted string, the list is simply
+ * join(" ")ed together; otherwise every element expands to a separate
+ * quoted string.
+ */
+QString expandMacrosShellQuote(const QString &str, const QHash<QChar, QStringList> &map,
+        QChar c = QLatin1Char('%'));
+QString expandMacrosShellQuote(const QString &str, const QHash<QString, QStringList> &map,
+        QChar c = QLatin1Char('%'));
+}
+
+#endif /* KMACROEXPANDER_H */
diff --git a/src/libcrashreporter-gui/linux-backtrace-generator/crqt-kmacroexpander_p.h b/src/libcrashreporter-gui/linux-backtrace-generator/crqt-kmacroexpander_p.h
new file mode 100644
index 0000000..04bb341
--- /dev/null
+++ b/src/libcrashreporter-gui/linux-backtrace-generator/crqt-kmacroexpander_p.h
@@ -0,0 +1,34 @@
+/*
+    This file is part of the KDE libraries
+
+    Copyright (c) 2002-2003,2007 Oswald Buddenhagen <ossi@kde.org>
+
+    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 2 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; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+
+#ifndef KMACROEXPANDER_P_H
+#define KMACROEXPANDER_P_H
+
+#include "crqt-kmacroexpander.h"
+
+class KMacroExpanderBasePrivate
+{
+public:
+    KMacroExpanderBasePrivate(QChar c) : escapechar(c) {}
+    QChar escapechar;
+};
+
+#endif
diff --git a/src/libcrashreporter-gui/linux-backtrace-generator/crqt-kmacroexpander_unix.cpp b/src/libcrashreporter-gui/linux-backtrace-generator/crqt-kmacroexpander_unix.cpp
new file mode 100644
index 0000000..e786c2c
--- /dev/null
+++ b/src/libcrashreporter-gui/linux-backtrace-generator/crqt-kmacroexpander_unix.cpp
@@ -0,0 +1,260 @@
+/*
+    This file is part of the KDE libraries
+
+    Copyright (c) 2002-2003 Oswald Buddenhagen <ossi@kde.org>
+    Copyright (c) 2003 Waldo Bastian <bastian@kde.org>
+
+    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 2 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; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+
+#include "crqt-kmacroexpander_p.h"
+
+#include <QtCore/QStringList>
+#include <QtCore/QStack>
+#include <QtCore/QRegExp>
+
+namespace KMacroExpander
+{
+
+enum Quoting { noquote, singlequote, doublequote, dollarquote,
+               paren, subst, group, math
+             };
+typedef struct {
+    Quoting current;
+    bool dquote;
+} State;
+typedef struct {
+    QString str;
+    int pos;
+} Save;
+
+}
+
+using namespace KMacroExpander;
+
+#pragma message("TODO: Import these methods into Qt")
+
+inline static bool isSpecial(QChar cUnicode)
+{
+    static const uchar iqm[] = {
+        0xff, 0xff, 0xff, 0xff, 0xdf, 0x07, 0x00, 0xd8,
+        0x00, 0x00, 0x00, 0x38, 0x01, 0x00, 0x00, 0x78
+    }; // 0-32 \'"$`<>|;&(){}*?#!~[]
+
+    uint c = cUnicode.unicode();
+    return (c < sizeof(iqm) * 8) && (iqm[c / 8] & (1 << (c & 7)));
+}
+
+static QString quoteArg(const QString &arg)
+{
+    if (!arg.length()) {
+        return QString::fromLatin1("''");
+    }
+    for (int i = 0; i < arg.length(); i++)
+        if (isSpecial(arg.unicode()[i])) {
+            QChar q(QLatin1Char('\''));
+            return QString(arg).replace(q, QLatin1String("'\\''")).prepend(q).append(q);
+        }
+    return arg;
+}
+
+static QString joinArgs(const QStringList &args)
+{
+    QString ret;
+    for (QStringList::ConstIterator it = args.begin(); it != args.end(); ++it) {
+        if (!ret.isEmpty()) {
+            ret.append(QLatin1Char(' '));
+        }
+        ret.append(quoteArg(*it));
+    }
+    return ret;
+}
+
+bool KMacroExpanderBase::expandMacrosShellQuote(QString &str, int &pos)
+{
+    int len;
+    int pos2;
+    ushort ec = d->escapechar.unicode();
+    State state = { noquote, false };
+    QStack<State> sstack;
+    QStack<Save> ostack;
+    QStringList rst;
+    QString rsts;
+
+    while (pos < str.length()) {
+        ushort cc = str.unicode()[pos].unicode();
+        if (ec != 0) {
+            if (cc != ec) {
+                goto nohit;
+            }
+            if (!(len = expandEscapedMacro(str, pos, rst))) {
+                goto nohit;
+            }
+        } else {
+            if (!(len = expandPlainMacro(str, pos, rst))) {
+                goto nohit;
+            }
+        }
+        if (len < 0) {
+            pos -= len;
+            continue;
+        }
+        if (state.dquote) {
+            rsts = rst.join(QLatin1String(" "));
+            rsts.replace(QRegExp(QLatin1String("([$`\"\\\\])")), QLatin1String("\\\\1"));
+        } else if (state.current == dollarquote) {
+            rsts = rst.join(QLatin1String(" "));
+            rsts.replace(QRegExp(QLatin1String("(['\\\\])")), QLatin1String("\\\\1"));
+        } else if (state.current == singlequote) {
+            rsts = rst.join(QLatin1String(" "));
+            rsts.replace(QLatin1Char('\''), QLatin1String("'\\''"));
+        } else {
+            if (rst.isEmpty()) {
+                str.remove(pos, len);
+                continue;
+            } else {
+                rsts = joinArgs(rst);
+            }
+        }
+        rst.clear();
+        str.replace(pos, len, rsts);
+        pos += rsts.length();
+        continue;
+    nohit:
+        if (state.current == singlequote) {
+            if (cc == '\'') {
+                state = sstack.pop();
+            }
+        } else if (cc == '\\') {
+            // always swallow the char -> prevent anomalies due to expansion
+            pos += 2;
+            continue;
+        } else if (state.current == dollarquote) {
+            if (cc == '\'') {
+                state = sstack.pop();
+            }
+        } else if (cc == '$') {
+            cc = str.unicode()[++pos].unicode();
+            if (cc == '(') {
+                sstack.push(state);
+                if (str.unicode()[pos + 1].unicode() == '(') {
+                    Save sav = { str, pos + 2 };
+                    ostack.push(sav);
+                    state.current = math;
+                    pos += 2;
+                    continue;
+                } else {
+                    state.current = paren;
+                    state.dquote = false;
+                }
+            } else if (cc == '{') {
+                sstack.push(state);
+                state.current = subst;
+            } else if (!state.dquote) {
+                if (cc == '\'') {
+                    sstack.push(state);
+                    state.current = dollarquote;
+                } else if (cc == '"') {
+                    sstack.push(state);
+                    state.current = doublequote;
+                    state.dquote = true;
+                }
+            }
+            // always swallow the char -> prevent anomalies due to expansion
+        } else if (cc == '`') {
+            str.replace(pos, 1, QLatin1String("$( "));   // add space -> avoid creating $((
+            pos2 = pos += 3;
+            for (;;) {
+                if (pos2 >= str.length()) {
+                    pos = pos2;
+                    return false;
+                }
+                cc = str.unicode()[pos2].unicode();
+                if (cc == '`') {
+                    break;
+                }
+                if (cc == '\\') {
+                    cc = str.unicode()[++pos2].unicode();
+                    if (cc == '$' || cc == '`' || cc == '\\' ||
+                            (cc == '"' && state.dquote)) {
+                        str.remove(pos2 - 1, 1);
+                        continue;
+                    }
+                }
+                pos2++;
+            }
+            str[pos2] = QLatin1Char(')');
+            sstack.push(state);
+            state.current = paren;
+            state.dquote = false;
+            continue;
+        } else if (state.current == doublequote) {
+            if (cc == '"') {
+                state = sstack.pop();
+            }
+        } else if (cc == '\'') {
+            if (!state.dquote) {
+                sstack.push(state);
+                state.current = singlequote;
+            }
+        } else if (cc == '"') {
+            if (!state.dquote) {
+                sstack.push(state);
+                state.current = doublequote;
+                state.dquote = true;
+            }
+        } else if (state.current == subst) {
+            if (cc == '}') {
+                state = sstack.pop();
+            }
+        } else if (cc == ')') {
+            if (state.current == math) {
+                if (str.unicode()[pos + 1].unicode() == ')') {
+                    state = sstack.pop();
+                    pos += 2;
+                } else {
+                    // false hit: the $(( was a $( ( in fact
+                    // ash does not care, but bash does
+                    pos = ostack.top().pos;
+                    str = ostack.top().str;
+                    ostack.pop();
+                    state.current = paren;
+                    state.dquote = false;
+                    sstack.push(state);
+                }
+                continue;
+            } else if (state.current == paren) {
+                state = sstack.pop();
+            } else {
+                break;
+            }
+        } else if (cc == '}') {
+            if (state.current == KMacroExpander::group) {
+                state = sstack.pop();
+            } else {
+                break;
+            }
+        } else if (cc == '(') {
+            sstack.push(state);
+            state.current = paren;
+        } else if (cc == '{') {
+            sstack.push(state);
+            state.current = KMacroExpander::group;
+        }
+        pos++;
+    }
+    return sstack.empty();
+}
diff --git a/src/libcrashreporter-gui/linux-backtrace-generator/crqt-kshell.cpp b/src/libcrashreporter-gui/linux-backtrace-generator/crqt-kshell.cpp
new file mode 100644
index 0000000..7f3740f
--- /dev/null
+++ b/src/libcrashreporter-gui/linux-backtrace-generator/crqt-kshell.cpp
@@ -0,0 +1,66 @@
+/*
+    This file is part of the KDE libraries
+
+    Copyright (c) 2003,2007 Oswald Buddenhagen <ossi@kde.org>
+
+    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 2 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; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+
+#include "crqt-kshell.h"
+#include "crqt-kshell_p.h"
+
+#include <QtCore/QDir>
+
+QString KShell::homeDir(const QString &user)
+{
+    return QDir::homePath();
+}
+
+QString KShell::joinArgs(const QStringList &args)
+{
+    QString ret;
+    for (QStringList::ConstIterator it = args.begin(); it != args.end(); ++it) {
+        if (!ret.isEmpty()) {
+            ret.append(QLatin1Char(' '));
+        }
+        ret.append(quoteArg(*it));
+    }
+    return ret;
+}
+
+#ifdef Q_OS_WIN
+# define ESCAPE '^'
+#else
+# define ESCAPE '\\'
+#endif
+
+QString KShell::tildeExpand(const QString &fname)
+{
+    if (!fname.isEmpty() && fname[0] == QLatin1Char('~')) {
+        int pos = fname.indexOf(QLatin1Char('/'));
+        if (pos < 0) {
+            return homeDir(fname.mid(1));
+        }
+        QString ret = homeDir(fname.mid(1, pos - 1));
+        if (!ret.isNull()) {
+            ret += fname.midRef(pos);
+        }
+        return ret;
+    } else if (fname.length() > 1 && fname[0] == QLatin1Char(ESCAPE) && fname[1] == QLatin1Char('~')) {
+        return fname.mid(1);
+    }
+    return fname;
+}
diff --git a/src/libcrashreporter-gui/linux-backtrace-generator/crqt-kshell.h b/src/libcrashreporter-gui/linux-backtrace-generator/crqt-kshell.h
new file mode 100644
index 0000000..2924d52
--- /dev/null
+++ b/src/libcrashreporter-gui/linux-backtrace-generator/crqt-kshell.h
@@ -0,0 +1,198 @@
+/*
+    This file is part of the KDE libraries
+
+    Copyright (c) 2003,2007 Oswald Buddenhagen <ossi@kde.org>
+
+    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 2 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; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+#ifndef KSHELL_H
+#define KSHELL_H
+
+#include <qglobal.h>
+
+class QStringList;
+class QString;
+
+/**
+ * \namespace KShell
+ * Emulates some basic system shell functionality.
+ * @see KStringHandler
+ */
+namespace KShell
+{
+
+/**
+ * Flags for splitArgs().
+ */
+enum Option {
+    NoOptions = 0,
+
+    /**
+     * Perform tilde expansion.
+     * On Windows, this flag is ignored, as the Windows shell has no
+     * equivalent functionality.
+     */
+    TildeExpand = 1,
+
+    /**
+     * Put the parser into full shell mode and bail out if a too complex
+     * construct is encountered.
+     * A particular purpose of this flag is finding out whether the
+     * command line being split would be executable directly (via
+     * KProcess::setProgram()) or whether it needs to be run through
+     * a real shell (via KProcess::setShellCommand()). Note, however,
+     * that shell builtins are @em not recognized - you need to do that
+     * yourself (compare with a list of known commands or verify that an
+     * executable exists for the named command).
+     *
+     * Meta characters that cause a bail-out are the command separators
+     * @c semicolon and @c ampersand, the redirection symbols @c less-than,
+     * @c greater-than and the @c pipe @c symbol and the grouping symbols
+     * opening and closing @c parentheses.
+     *
+     * Further meta characters on *NIX are the grouping symbols
+     * opening and closing @c braces, the command substitution symbol
+     * @c backquote, the generic substitution symbol @c dollar (if
+     * not followed by an apostrophe), the wildcards @c asterisk,
+     * @c question @c mark and opening and closing @c square @c brackets
+     * and the comment symbol @c hash @c mark.
+     * Additionally, a variable assignment in the first word is recognized.
+     *
+     * A further meta character on Windows is the environment variable
+     * expansion symbol @c percent. Occurrences of @c \%PERCENT_SIGN% as
+     * inserted by quoteArg() are converted back and cause no bail-out,
+     * though.
+     */
+    AbortOnMeta = 2
+};
+Q_DECLARE_FLAGS(Options, Option)
+
+/**
+ * Status codes from splitArgs()
+ */
+enum Errors {
+    /**
+     * Success.
+     */
+    NoError = 0,
+
+    /**
+     * Indicates a parsing error, like an unterminated quoted string.
+     */
+    BadQuoting,
+
+    /**
+     * The AbortOnMeta flag was set and an unhandled shell meta character
+     * was encountered.
+     */
+    FoundMeta
+};
+
+/**
+ * Splits @p cmd according to system shell word splitting and quoting rules.
+ * Can optionally perform tilde expansion and/or abort if it finds shell
+ * meta characters it cannot process.
+ *
+ * On *NIX the behavior is based on the POSIX shell and bash:
+ * - Whitespace splits tokens
+ * - The backslash quotes the following character
+ * - A string enclosed in single quotes is not split. No shell meta
+ *   characters are interpreted.
+ * - A string enclosed in double quotes is not split. Within the string,
+ *   the backslash quotes shell meta characters - if it is followed
+ *   by a "meaningless" character, the backslash is output verbatim.
+ * - A string enclosed in $'' is not split. Within the string, the
+ *   backslash has a similar meaning to the one in C strings. Consult
+ *   the bash manual for more information.
+ *
+ * On Windows, the behavior is defined by the Microsoft C runtime. Qt and
+ * many other implementations comply with this standard, but many do not.
+ * - Whitespace splits tokens
+ * - A string enclosed in double quotes is not split
+ *   - 2N double quotes within a quoted string yield N literal quotes.
+ *     This is not documented on MSDN.
+ * - Backslashes have special semantics iff they are followed by a double
+ *   quote:
+ *   - 2N backslashes + double quote => N backslashes and begin/end quoting
+ *   - 2N+1 backslashes + double quote => N backslashes + literal quote
+ *
+ * If AbortOnMeta is used on Windows, this function applies cmd shell
+ * semantics before proceeding with word splitting:
+ * - Cmd ignores @em all special chars between double quotes.
+ *   Note that the quotes are @em not removed at this stage - the
+ *   tokenization rules described above still apply.
+ * - The @c circumflex is the escape char for everything including
+ *   itself.
+ *
+ * @param cmd the command to split
+ * @param flags operation flags, see \ref Option
+ * @param err if not NULL, a status code will be stored at the pointer
+ *  target, see \ref Errors
+ * @return a list of unquoted words or an empty list if an error occurred
+ */
+QStringList splitArgs(const QString &cmd, Options flags = NoOptions, Errors *err = 0);
+
+/**
+ * Quotes and joins @p args together according to system shell rules.
+ *
+ * If the output is fed back into splitArgs(), the AbortOnMeta flag
+ * needs to be used on Windows. On *NIX, no such requirement exists.
+ *
+ * See quoteArg() for more info.
+ *
+ * @param args a list of strings to quote and join
+ * @return a command suitable for shell execution
+ */
+QString joinArgs(const QStringList &args);
+
+/**
+ * Quotes @p arg according to system shell rules.
+ *
+ * This function can be used to quote an argument string such that
+ * the shell processes it properly. This is e.g. necessary for
+ * user-provided file names which may contain spaces or quotes.
+ * It also prevents expansion of wild cards and environment variables.
+ *
+ * On *NIX, the output is POSIX shell compliant.
+ * On Windows, it is compliant with the argument splitting code of the
+ * Microsoft C runtime and the cmd shell used together.
+ * Occurrences of the @c percent @c sign are replaced with
+ * @c \%PERCENT_SIGN% to prevent spurious variable expansion;
+ * related KDE functions are prepared for this.
+ *
+ * @param arg the argument to quote
+ * @return the quoted argument
+ */
+QString quoteArg(const QString &arg);
+
+/**
+ * Performs tilde expansion on @p path. Interprets "~/path" and
+ * "~user/path". If the path starts with an escaped tilde ("\~" on UNIX,
+ * "^~" on Windows), the escape char is removed and the path is returned
+ * as is.
+ *
+ * Note that if @p path starts with a tilde but cannot be properly expanded,
+ * this function will return an empty string.
+ *
+ * @param path the path to tilde-expand
+ * @return the expanded path
+ */
+QString tildeExpand(const QString &path);
+}
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(KShell::Options)
+
+#endif /* KSHELL_H */
diff --git a/src/libcrashreporter-gui/linux-backtrace-generator/crqt-kshell_p.h b/src/libcrashreporter-gui/linux-backtrace-generator/crqt-kshell_p.h
new file mode 100644
index 0000000..eae6655
--- /dev/null
+++ b/src/libcrashreporter-gui/linux-backtrace-generator/crqt-kshell_p.h
@@ -0,0 +1,38 @@
+/*
+    This file is part of the KDE libraries
+
+    Copyright (c) 2008 Oswald Buddenhagen <ossi@kde.org>
+
+    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 2 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; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+
+#ifndef KSHELL_P_H
+#define KSHELL_P_H
+
+class QString;
+
+namespace KShell
+{
+
+QString homeDir(const QString &user);
+QString quoteArgInternal(const QString &arg, bool _inquote);
+
+}
+
+#define PERCENT_VARIABLE QLatin1String("PERCENT_SIGN")
+#define PERCENT_ESCAPE QLatin1String("%PERCENT_SIGN%")
+
+#endif /* KSHELL_P_H */
diff --git a/src/libcrashreporter-gui/linux-backtrace-generator/crqt-kshell_unix.cpp b/src/libcrashreporter-gui/linux-backtrace-generator/crqt-kshell_unix.cpp
new file mode 100644
index 0000000..b639f83
--- /dev/null
+++ b/src/libcrashreporter-gui/linux-backtrace-generator/crqt-kshell_unix.cpp
@@ -0,0 +1,319 @@
+/*
+    This file is part of the KDE libraries
+
+    Copyright (c) 2003,2007 Oswald Buddenhagen <ossi@kde.org>
+
+    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 2 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; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+
+#include "crqt-kshell.h"
+#include "crqt-kshell_p.h"
+
+#include <QtCore/QChar>
+#include <QtCore/QStringList>
+
+static int fromHex(QChar cUnicode)
+{
+    char c = cUnicode.toLatin1();
+
+    if (c >= '0' && c <= '9') {
+        return c - '0';
+    } else if (c >= 'A' && c <= 'F') {
+        return c - 'A' + 10;
+    } else if (c >= 'a' && c <= 'f') {
+        return c - 'a' + 10;
+    }
+    return -1;
+}
+
+inline static bool isQuoteMeta(QChar cUnicode)
+{
+#if 0 // it's not worth it, especially after seeing gcc's asm output ...
+    static const uchar iqm[] = {
+        0x00, 0x00, 0x00, 0x00, 0x94, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00
+    }; // \'"$
+
+    return (c < sizeof(iqm) * 8) && (iqm[c / 8] & (1 << (c & 7)));
+#else
+    char c = cUnicode.toLatin1();
+    return c == '\\' || c == '\'' || c == '"' || c == '$';
+#endif
+}
+
+inline static bool isMeta(QChar cUnicode)
+{
+    static const uchar iqm[] = {
+        0x00, 0x00, 0x00, 0x00, 0xdc, 0x07, 0x00, 0xd8,
+        0x00, 0x00, 0x00, 0x38, 0x01, 0x00, 0x00, 0x38
+    }; // \'"$`<>|;&(){}*?#[]
+
+    uint c = cUnicode.unicode();
+
+    return (c < sizeof(iqm) * 8) && (iqm[c / 8] & (1 << (c & 7)));
+}
+
+QStringList KShell::splitArgs(const QString &args, Options flags, Errors *err)
+{
+    QStringList ret;
+    bool firstword = flags & AbortOnMeta;
+
+    for (int pos = 0;;) {
+        QChar c;
+        do {
+            if (pos >= args.length()) {
+                goto okret;
+            }
+            c = args.unicode()[pos++];
+        } while (c == QLatin1Char(' '));
+        QString cret;
+        if ((flags & TildeExpand) && c == QLatin1Char('~')) {
+            int opos = pos;
+            for (;; pos++) {
+                if (pos >= args.length()) {
+                    break;
+                }
+                c = args.unicode()[pos];
+                if (c == QLatin1Char('/') || c == QLatin1Char(' ')) {
+                    break;
+                }
+                if (isQuoteMeta(c)) {
+                    pos = opos;
+                    c = QLatin1Char('~');
+                    goto notilde;
+                }
+                if ((flags & AbortOnMeta) && isMeta(c)) {
+                    goto metaerr;
+                }
+            }
+            QString ccret = homeDir(args.mid(opos, pos - opos));
+            if (ccret.isEmpty()) {
+                pos = opos;
+                c = QLatin1Char('~');
+                goto notilde;
+            }
+            if (pos >= args.length()) {
+                ret += ccret;
+                goto okret;
+            }
+            pos++;
+            if (c == QLatin1Char(' ')) {
+                ret += ccret;
+                firstword = false;
+                continue;
+            }
+            cret = ccret;
+        }
+        // before the notilde label, as a tilde does not match anyway
+        if (firstword) {
+            if (c == QLatin1Char('_') ||
+                    (c >= QLatin1Char('A') && c <= QLatin1Char('Z')) ||
+                    (c >= QLatin1Char('a') && c <= QLatin1Char('z'))) {
+                int pos2 = pos;
+                QChar cc;
+                do {
+                    if (pos2 >= args.length()) {
+                        // Exactly one word
+                        ret += args.mid(pos - 1);
+                        goto okret;
+                    }
+                    cc = args.unicode()[pos2++];
+                } while (cc == QLatin1Char('_') ||
+                         (cc >= QLatin1Char('A') && cc <= QLatin1Char('Z')) ||
+                         (cc >= QLatin1Char('a') && cc <= QLatin1Char('z')) ||
+                         (cc >= QLatin1Char('0') && cc <= QLatin1Char('9')));
+                if (cc == QLatin1Char('=')) {
+                    goto metaerr;
+                }
+            }
+        }
+    notilde:
+        do {
+            if (c == QLatin1Char('\'')) {
+                int spos = pos;
+                do {
+                    if (pos >= args.length()) {
+                        goto quoteerr;
+                    }
+                    c = args.unicode()[pos++];
+                } while (c != QLatin1Char('\''));
+                cret += args.mid(spos, pos - spos - 1);
+            } else if (c == QLatin1Char('"')) {
+                for (;;) {
+                    if (pos >= args.length()) {
+                        goto quoteerr;
+                    }
+                    c = args.unicode()[pos++];
+                    if (c == QLatin1Char('"')) {
+                        break;
+                    }
+                    if (c == QLatin1Char('\\')) {
+                        if (pos >= args.length()) {
+                            goto quoteerr;
+                        }
+                        c = args.unicode()[pos++];
+                        if (c != QLatin1Char('"') &&
+                                c != QLatin1Char('\\') &&
+                                !((flags & AbortOnMeta) &&
+                                  (c == QLatin1Char('$') ||
+                                   c == QLatin1Char('`')))) {
+                            cret += QLatin1Char('\\');
+                        }
+                    } else if ((flags & AbortOnMeta) &&
+                               (c == QLatin1Char('$') ||
+                                c == QLatin1Char('`'))) {
+                        goto metaerr;
+                    }
+                    cret += c;
+                }
+            } else if (c == QLatin1Char('$') && pos < args.length() &&
+                       args.unicode()[pos] == QLatin1Char('\'')) {
+                pos++;
+                for (;;) {
+                    if (pos >= args.length()) {
+                        goto quoteerr;
+                    }
+                    c = args.unicode()[pos++];
+                    if (c == QLatin1Char('\'')) {
+                        break;
+                    }
+                    if (c == QLatin1Char('\\')) {
+                        if (pos >= args.length()) {
+                            goto quoteerr;
+                        }
+                        c = args.unicode()[pos++];
+                        switch (c.toLatin1()) {
+                        case 'a': cret += QLatin1Char('\a'); break;
+                        case 'b': cret += QLatin1Char('\b'); break;
+                        case 'e': cret += QLatin1Char('\033'); break;
+                        case 'f': cret += QLatin1Char('\f'); break;
+                        case 'n': cret += QLatin1Char('\n'); break;
+                        case 'r': cret += QLatin1Char('\r'); break;
+                        case 't': cret += QLatin1Char('\t'); break;
+                        case '\\': cret += QLatin1Char('\\'); break;
+                        case '\'': cret += QLatin1Char('\''); break;
+                        case 'c':
+                            if (pos >= args.length()) {
+                                goto quoteerr;
+                            }
+                            cret += args.unicode()[pos++].toLatin1() & 31;
+                            break;
+                        case 'x': {
+                            if (pos >= args.length()) {
+                                goto quoteerr;
+                            }
+                            int hv = fromHex(args.unicode()[pos++]);
+                            if (hv < 0) {
+                                goto quoteerr;
+                            }
+                            if (pos < args.length()) {
+                                int hhv = fromHex(args.unicode()[pos]);
+                                if (hhv > 0) {
+                                    hv = hv * 16 + hhv;
+                                    pos++;
+                                }
+                                cret += QChar(hv);
+                            }
+                            break;
+                        }
+                        default:
+                            if (c.toLatin1() >= '0' && c.toLatin1() <= '7') {
+                                char cAscii = c.toLatin1();
+                                int hv = cAscii - '0';
+                                for (int i = 0; i < 2; i++) {
+                                    if (pos >= args.length()) {
+                                        break;
+                                    }
+                                    c = args.unicode()[pos];
+                                    if (c.toLatin1() < '0' || c.toLatin1() > '7') {
+                                        break;
+                                    }
+                                    hv = hv * 8 + (c.toLatin1() - '0');
+                                    pos++;
+                                }
+                                cret += QChar(hv);
+                            } else {
+                                cret += QLatin1Char('\\');
+                                cret += c;
+                            }
+                            break;
+                        }
+                    } else {
+                        cret += c;
+                    }
+                }
+            } else {
+                if (c == QLatin1Char('\\')) {
+                    if (pos >= args.length()) {
+                        goto quoteerr;
+                    }
+                    c = args.unicode()[pos++];
+                } else if ((flags & AbortOnMeta) && isMeta(c)) {
+                    goto metaerr;
+                }
+                cret += c;
+            }
+            if (pos >= args.length()) {
+                break;
+            }
+            c = args.unicode()[pos++];
+        } while (c != QLatin1Char(' '));
+        ret += cret;
+        firstword = false;
+    }
+
+okret:
+    if (err) {
+        *err = NoError;
+    }
+    return ret;
+
+quoteerr:
+    if (err) {
+        *err = BadQuoting;
+    }
+    return QStringList();
+
+metaerr:
+    if (err) {
+        *err = FoundMeta;
+    }
+    return QStringList();
+}
+
+inline static bool isSpecial(QChar cUnicode)
+{
+    static const uchar iqm[] = {
+        0xff, 0xff, 0xff, 0xff, 0xdf, 0x07, 0x00, 0xd8,
+        0x00, 0x00, 0x00, 0x38, 0x01, 0x00, 0x00, 0x78
+    }; // 0-32 \'"$`<>|;&(){}*?#!~[]
+
+    uint c = cUnicode.unicode();
+    return ((c < sizeof(iqm) * 8) && (iqm[c / 8] & (1 << (c & 7))));
+}
+
+QString KShell::quoteArg(const QString &arg)
+{
+    if (!arg.length()) {
+        return QString::fromLatin1("''");
+    }
+    for (int i = 0; i < arg.length(); i++)
+        if (isSpecial(arg.unicode()[i])) {
+            QChar q(QLatin1Char('\''));
+            return QString(arg).replace(q, QLatin1String("'\\''")).prepend(q).append(q);
+        }
+    return arg;
+}
diff --git a/src/libcrashreporter-gui/linux-backtrace-generator/debugger.cpp b/src/libcrashreporter-gui/linux-backtrace-generator/debugger.cpp
new file mode 100644
index 0000000..4fe993f
--- /dev/null
+++ b/src/libcrashreporter-gui/linux-backtrace-generator/debugger.cpp
@@ -0,0 +1,130 @@
+/*
+    Copyright (C) 2009  George Kiagiadakis <gkiagia@users.sourceforge.net>
+
+    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) 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 <http://www.gnu.org/licenses/>.
+*/
+#include "debugger.h"
+
+#include "crashedapplication.h"
+#include "crqt-kmacroexpander.h"
+
+#include <QStandardPaths>
+#include <QDir>
+
+//static
+QList<Debugger> Debugger::availableInternalDebuggers(const QString & backend)
+{
+    return availableDebuggers(QStringLiteral("debuggers/internal"), backend);
+}
+
+//static
+QList<Debugger> Debugger::availableExternalDebuggers(const QString & backend)
+{
+    return availableDebuggers(QStringLiteral("debuggers/external"), backend);
+}
+
+bool Debugger::isValid() const
+{
+    return true;
+}
+
+bool Debugger::isInstalled() const
+{
+    QString tryexec = tryExec();
+    return !tryexec.isEmpty() && !QStandardPaths::findExecutable(tryexec).isEmpty();
+}
+
+QString Debugger::name() const
+{
+    return isValid() ? "gdb" : QString();
+}
+
+QString Debugger::codeName() const
+{
+    //fall back to the "TryExec" string if "CodeName" is not specified.
+    //for most debuggers those strings should be the same
+    return isValid() ? "gdb" : QString();
+}
+
+QString Debugger::tryExec() const
+{
+    return isValid() ? "gdb" : QString();
+}
+
+QStringList Debugger::supportedBackends() const
+{
+    return isValid() ? QStringList { "KCrash" } : QStringList();
+}
+
+void Debugger::setUsedBackend(const QString & backendName)
+{
+    if (supportedBackends().contains(backendName)) {
+        m_backend = backendName;
+    }
+}
+
+QString Debugger::command() const
+{
+    return "gdb -nw -n -batch -x %tempfile -p %pid %execpath";
+}
+
+QString Debugger::backtraceBatchCommands() const
+{
+    return "set width 200\nthread\nthread apply all bt";
+}
+
+bool Debugger::runInTerminal() const
+{
+    return false;
+}
+
+//static
+void Debugger::expandString(QString & str,
+                            const CrashedApplication* appInfo,
+                            ExpandStringUsage usage,
+                            const QString & tempFile)
+{
+    QHash<QString, QString> map;
+    map[QLatin1String("progname")] = appInfo->name();
+    map[QLatin1String("execname")] = appInfo->fakeExecutableBaseName();
+    map[QLatin1String("execpath")] = appInfo->executable().absoluteFilePath();
+    map[QLatin1String("signum")] = QString::number(appInfo->signalNumber());
+    map[QLatin1String("signame")] = appInfo->signalName();
+    map[QLatin1String("pid")] = QString::number(appInfo->pid());
+    map[QLatin1String("tempfile")] = tempFile;
+    map[QLatin1String("thread")] = QString::number(appInfo->thread());
+
+    if (usage == ExpansionUsageShell) {
+        str = KMacroExpander::expandMacrosShellQuote(str, map);
+    } else {
+        str = KMacroExpander::expandMacros(str, map);
+    }
+}
+
+//static
+QList<Debugger> Debugger::availableDebuggers(const QString & path, const QString & backend)
+{
+    QString debuggerDir = QStandardPaths::locate(QStandardPaths::DataLocation, path, QStandardPaths::LocateDirectory);
+    QStringList debuggers = QDir(debuggerDir).entryList(QDir::Files);
+
+    QList<Debugger> result;
+    foreach (const QString & debuggerFile, debuggers) {
+        Debugger debugger;
+        if (debugger.supportedBackends().contains(backend)) {
+            debugger.setUsedBackend(backend);
+            result.append(debugger);
+        }
+    }
+    return result;
+}
diff --git a/src/libcrashreporter-gui/linux-backtrace-generator/debugger.h b/src/libcrashreporter-gui/linux-backtrace-generator/debugger.h
new file mode 100644
index 0000000..ee54e1f
--- /dev/null
+++ b/src/libcrashreporter-gui/linux-backtrace-generator/debugger.h
@@ -0,0 +1,89 @@
+/*
+    Copyright (C) 2009  George Kiagiadakis <gkiagia@users.sourceforge.net>
+
+    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) 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 <http://www.gnu.org/licenses/>.
+*/
+#ifndef DEBUGGER_H
+#define DEBUGGER_H
+
+#include <QtCore/QString>
+
+class CrashedApplication;
+
+class Debugger
+{
+public:
+    static QList<Debugger> availableInternalDebuggers(const QString & backend);
+    static QList<Debugger> availableExternalDebuggers(const QString & backend);
+
+    /** Returns true if this Debugger instance is valid, or false otherwise.
+     * Debugger instances are valid only if they have been constructed from
+     * availableInternalDebuggers() or availableExternalDebuggers(). If they
+     * have been constructed directly using the Debugger constructor, they are invalid.
+     */
+    bool isValid() const;
+
+    /** Returns true if this debugger is installed. This is determined by
+     * looking for the executable that tryExec() returns. If it is in $PATH,
+     * this method returns true.
+     */
+    bool isInstalled() const;
+
+    /** Returns the translatable name of the debugger (eg. "GDB") */
+    QString name() const;
+
+    /** Returns the code name of the debugger (eg. "gdb"). */
+    QString codeName() const;
+
+    /** Returns the executable name that drkonqi should check if it exists
+     * to determine whether the debugger is installed
+     */
+    QString tryExec() const;
+
+    /** Returns a list with the drkonqi backends that this debugger supports */
+    QStringList supportedBackends() const;
+
+    /** Sets the backend to be used. This function must be called before using
+     * command(), backtraceBatchCommands() or runInTerminal().
+     */
+    void setUsedBackend(const QString & backendName);
+
+    /** Returns the command that should be run to use the debugger */
+    QString command() const;
+
+    /** Returns the commands that should be given to the debugger when
+     * run in batch mode in order to generate a backtrace
+     */
+    QString backtraceBatchCommands() const;
+
+    /** If this is an external debugger, it returns whether it should be run in a terminal or not */
+    bool runInTerminal() const;
+
+
+    enum ExpandStringUsage {
+        ExpansionUsagePlainText,
+        ExpansionUsageShell
+    };
+
+    static void expandString(QString & str,
+                             const CrashedApplication* appInfo,
+                             ExpandStringUsage usage = ExpansionUsagePlainText,
+                             const QString & tempFile = QString());
+
+private:
+    static QList<Debugger> availableDebuggers(const QString &path, const QString & backend);
+    QString m_backend;
+};
+
+#endif
diff --git a/src/libcrashreporter-handler/Handler.cpp b/src/libcrashreporter-handler/Handler.cpp
index e04474b..ec514ad 100644
--- a/src/libcrashreporter-handler/Handler.cpp
+++ b/src/libcrashreporter-handler/Handler.cpp
@@ -1,6 +1,7 @@
 /*
  *   Copyright 2010-2011, Christian Muehlhaeuser <muesli@tomahawk-player.org>
  *   Copyright 2014,      Dominik Schmidt <domme@tomahawk-player.org>
+ *   Copyright 2016,      Teo Mrnjavac <teo@kde.org>
  *
  *   libcrashreporter is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -34,6 +35,7 @@
 #elif defined __linux__
 #   include <client/linux/handler/exception_handler.h>
 #   include <client/linux/handler/minidump_descriptor.h>
+#   include <cstdio>
 #endif
 
 namespace CrashReporter
@@ -105,6 +107,29 @@ LaunchUploader( const wchar_t* dump_dir, const wchar_t* minidump_id, void* conte
 
 #include <unistd.h>
 
+#ifdef Q_OS_LINUX
+static bool
+GetCrashInfo( const void* crash_context, size_t crash_context_size, void* context )
+{
+    // Don't use the heap here.
+
+    // The callback signature passes the crash context as an opaque object, but from
+    // what I gather from the comments in exception_handler.h, this cast should always
+    // be safe.
+    // We need it for the signal number and thread ID.      -- Teo 3/2016
+    const google_breakpad::ExceptionHandler::CrashContext* cxt =
+        static_cast< const google_breakpad::ExceptionHandler::CrashContext* >( crash_context );
+
+    static_cast< Handler* >( context )->m_signalNumber = cxt->siginfo.si_signo;
+    static_cast< Handler* >( context )->m_threadId = cxt->tid;
+
+    // We always return false so Breakpad will continue with generating the minidump the
+    // usual way. Had we returned true here, to Breakpad it would mean "I'm done with
+    // making the minidump", which is of course not the case here.
+    return false;
+}
+#endif
+
 
 static bool
 #ifdef Q_OS_LINUX
@@ -115,55 +140,92 @@ LaunchUploader( const char* dump_dir, const char* minidump_id, void* context, bo
 {
 #endif
 
-        if ( !succeeded )
-        {
-            printf("Could not write crash dump file");
-            return false;
-        }
-
-        // DON'T USE THE HEAP!!!
-        // So that indeed means, no QStrings, no qDebug(), no QAnything, seriously!
-
-    #ifdef Q_OS_LINUX
-        const char* path = descriptor.path();
-    #else // Q_OS_MAC
-        const char* extension = "dmp";
-
-        char path[4096];
-        strcpy(path, dump_dir);
-        strcat(path, "/");
-        strcat(path, minidump_id);
-        strcat(path, ".");
-        strcat(path,  extension);
-    #endif
+    if ( !succeeded )
+    {
+        printf("Could not write crash dump file");
+        return false;
+    }
 
-        printf("Dump file was written to: %s\n", path);
-
-        const char* crashReporter = static_cast<Handler*>(context)->crashReporterChar();
-        if ( !s_active || strlen( crashReporter ) == 0 )
-            return false;
-
-        pid_t pid = fork();
-        if ( pid == -1 ) // fork failed
-            return false;
-        if ( pid == 0 )
-        {
-            // we are the fork
-            execl( crashReporter,
-                   crashReporter,
-                   path,
-                   (char*) 0 );
-
-            // execl replaces this process, so no more code will be executed
-            // unless it failed. If it failed, then we should return false.
-            printf( "Error: Can't launch CrashReporter!\n" );
-            return false;
-        }
-
-        // we called fork()
-        return true;
+    // DON'T USE THE HEAP!!!
+    // So that indeed means, no QStrings, no qDebug(), no QAnything, seriously!
+
+#ifdef Q_OS_LINUX
+    const char* path = descriptor.path();
+#else // Q_OS_MAC
+    const char* extension = "dmp";
+
+    char path[4096];
+    strcpy(path, dump_dir);
+    strcat(path, "/");
+    strcat(path, minidump_id);
+    strcat(path, ".");
+    strcat(path,  extension);
+#endif
+
+    printf("Dump file was written to: %s\n", path);
+
+    const char* crashReporter = static_cast<Handler*>(context)->crashReporterChar();
+    if ( !s_active || strlen( crashReporter ) == 0 )
+        return false;
+
+#ifdef Q_OS_LINUX
+    const char* applicationName = static_cast<Handler*>(context)->applicationName();
+    if ( strlen( applicationName ) == 0 )
+        return false;
+    const char* executablePath = static_cast<Handler*>(context)->executablePath();
+    if ( strlen( executablePath ) == 0 )
+        return false;
+    const char* applicationVersion = static_cast<Handler*>(context)->applicationVersion();
+    if ( strlen( applicationVersion ) == 0 )
+        return false;
+
+    char procid[17];
+    sprintf( procid, "%d", static_cast<Handler*>(context)->pid() );
+    char signum[17];
+    sprintf( signum, "%d", static_cast<Handler*>(context)->signalNumber() );
+    char tid[17];
+    sprintf( tid, "%d", static_cast<Handler*>(context)->threadId() );
+#endif
+
+    pid_t pid = fork();
+    if ( pid == -1 ) // fork failed
+        return false;
+    if ( pid == 0 )
+    {
+        // we are the fork
+#ifdef Q_OS_LINUX
+        execl( crashReporter,
+               crashReporter,
+               path,
+               procid,
+               signum,
+               applicationName,
+               executablePath,
+               applicationVersion,
+               tid,
+               (char*) 0 );
+#else
+        execl( crashReporter,
+               crashReporter,
+               path,
+               (char*) 0 );
+#endif
+
+        // execl replaces this process, so no more code will be executed
+        // unless it failed. If it failed, then we should return false.
+        printf( "Error: Can't launch CrashReporter!\n" );
+        return false;
     }
+#ifdef Q_OS_LINUX
+    // If we're running on Linux, we expect that the CrashReporter component will
+    // attach gdb, do its thing and then kill this process, so we hang here for the
+    // time being, on purpose.          -- Teo 3/2016
+    pause();
+#endif
 
+    // we called fork()
+    return true;
+}
 
 #endif
 
@@ -173,7 +235,14 @@ Handler::Handler( const QString& dumpFolderPath, bool active, const QString& cra
     s_active = active;
 
     #if defined Q_OS_LINUX
-    m_crash_handler =  new google_breakpad::ExceptionHandler( google_breakpad::MinidumpDescriptor(dumpFolderPath.toStdString()), NULL, LaunchUploader, this, true, -1 );
+    m_crash_handler =  new google_breakpad::ExceptionHandler(
+                           google_breakpad::MinidumpDescriptor( dumpFolderPath.toStdString() ),
+                           NULL,
+                           LaunchUploader,
+                           this,
+                           true,
+                           -1 );
+    m_crash_handler->set_crash_handler(GetCrashInfo);
     #elif defined Q_OS_MAC
     m_crash_handler =  new google_breakpad::ExceptionHandler( dumpFolderPath.toStdString(), NULL, LaunchUploader, this, true, NULL);
     #elif defined Q_OS_WIN
@@ -182,6 +251,9 @@ Handler::Handler( const QString& dumpFolderPath, bool active, const QString& cra
     #endif
 
     setCrashReporter( crashReporter );
+#ifdef Q_OS_LINUX
+    setApplicationData( qApp );
+#endif
 }
 
 
@@ -221,6 +293,35 @@ Handler::setCrashReporter( const QString& crashReporter )
 }
 
 
+void
+Handler::setApplicationData( const QCoreApplication* app )
+{
+    m_pid = app->applicationPid();
+
+    char* cappname;
+    std::string sappname = app->applicationName().toStdString();
+    cappname = new char[ sappname.size() + 1 ];
+    strcpy( cappname, sappname.c_str() );
+    m_applicationName = cappname;
+
+    char* cepath;
+    std::string sepath = app->applicationFilePath().toStdString();
+    cepath = new char[ sepath.size() + 1 ];
+    strcpy( cepath, sepath.c_str() );
+    m_executablePath = cepath;
+
+    char* cappver;
+    std::string sappver = app->applicationVersion().toStdString();
+    cappver = new char[ sappver.size() + 1 ];
+    strcpy( cappver, sappver.c_str() );
+    m_applicationVersion = cappver;
+
+    // To be set by the handler
+    m_signalNumber = -1;
+    m_threadId = -1;
+}
+
+
 Handler::~Handler()
 {
     delete m_crash_handler;
diff --git a/src/libcrashreporter-handler/Handler.h b/src/libcrashreporter-handler/Handler.h
index 185700d..d097418 100644
--- a/src/libcrashreporter-handler/Handler.h
+++ b/src/libcrashreporter-handler/Handler.h
@@ -1,6 +1,7 @@
 /*
  *   Copyright 2010-2011, Christian Muehlhaeuser <muesli@tomahawk-player.org>
  *   Copyright 2014,      Dominik Schmidt <domme@tomahawk-player.org>
+ *   Copyright 2016,      Teo Mrnjavac <teo@kde.org>
  *
  *   libcrashreporter is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -16,7 +17,10 @@
  *   along with Tomahawk. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <QtGlobal>
+
 class QString;
+class QCoreApplication;
 
 namespace google_breakpad
 {
@@ -26,10 +30,24 @@ namespace google_breakpad
 namespace CrashReporter
 {
 
+#ifdef Q_OS_LINUX
+static bool GetCrashInfo( const void* crash_context, size_t crash_context_size, void* context );
+#endif
+
 class Handler
 {
     const char* m_crashReporterChar; // yes! It MUST be const char[]
     const wchar_t* m_crashReporterWChar;
+#ifdef Q_OS_LINUX
+    int m_pid;
+    int m_signalNumber;
+    const char* m_applicationName;
+    const char* m_executablePath;
+    const char* m_applicationVersion;
+    int m_threadId;
+
+    friend bool CrashReporter::GetCrashInfo( const void* crash_context, size_t crash_context_size, void* context );
+#endif
 
 public:
     Handler(const QString& dumpFolderPath, bool active, const QString& crashReporter );
@@ -42,6 +60,16 @@ public:
     const char* crashReporterChar() const { return m_crashReporterChar; }
     const wchar_t* crashReporterWChar() const { return m_crashReporterWChar; }
 
+#ifdef Q_OS_LINUX
+    void setApplicationData( const QCoreApplication* app );
+    int pid() const { return m_pid; }
+    int signalNumber() const { return m_signalNumber; }
+    const char* applicationName() const { return m_applicationName; }
+    const char* executablePath() const { return m_executablePath; }
+    const char* applicationVersion() const { return m_applicationVersion; }
+    int threadId() const { return m_threadId; }
+#endif
+
 private:
     google_breakpad::ExceptionHandler* m_crash_handler;
 };
diff --git a/src/libcrashreporter-handler/LICENSE.GPL3 b/src/libcrashreporter-handler/LICENSE.GPL3
new file mode 100644
index 0000000..94a9ed0
--- /dev/null
+++ b/src/libcrashreporter-handler/LICENSE.GPL3
@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    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 <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.