← Back to branch summary

~ubuntu-branches/ubuntu/breezy/koffice/breezy-security

« back to all changes in this revision

Viewing changes to kexi/scripting/api/eventslot.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Jonathan Riddell
  • Date: 2005-10-11 14:49:50 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20051011144950-lwpngbifzp8nk0ds
Tags: 1:1.4.1-0ubuntu7
* SECURITY UPDATE: fix heap based buffer overflow in the RTF importer of KWord
* Opening specially crafted RTF files in KWord can cause
  execution of abitrary code.
* Add kubuntu_01_rtfimport_heap_overflow.diff
* References:
  CAN-2005-2971
  CESA-2005-005
  http://www.koffice.org/security/advisory-20051011-1.txt

Show diffs side-by-side

added added

removed removed

Lines of Context:
kexi/scripting/api/eventslot.cpp
 
1
/***************************************************************************
 
2
 * eventslot.cpp
 
3
 * This file is part of the KDE project
 
4
 * copyright (C)2004-2005 by Sebastian Sauer (mail@dipe.org)
 
5
 *
 
6
 * This program is free software; you can redistribute it and/or
 
7
 * modify it under the terms of the GNU Library General Public
 
8
 * License as published by the Free Software Foundation; either
 
9
 * version 2 of the License, or (at your option) any later version.
 
10
 * This program is distributed in the hope that it will be useful,
 
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
13
 * Library General Public License for more details.
 
14
 * You should have received a copy of the GNU Library General Public License
 
15
 * along with this program; see the file COPYING.  If not, write to
 
16
 * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 
17
 * Boston, MA 02111-1307, USA.
 
18
 ***************************************************************************/
 
19
 
 
20
#include "eventslot.h"
 
21
 
 
22
#include "interpreter.h"
 
23
#include "object.h"
 
24
#include "list.h"
 
25
#include "qtobject.h"
 
26
#include "variant.h"
 
27
#include "../main/scriptcontainer.h"
 
28
#include "eventmanager.h"
 
29
 
 
30
#include <qvaluelist.h>
 
31
#include <qmetaobject.h>
 
32
 
 
33
using namespace Kross::Api;
 
34
 
 
35
EventSlot::EventSlot(EventManager* eventmanager)
 
36
    : QObject(eventmanager, "EventSlot")
 
37
    , m_eventmanager(eventmanager)
 
38
    , m_sender(0)
 
39
    , m_signal(0)
 
40
    , m_slot(0)
 
41
{
 
42
}
 
43
 
 
44
EventSlot* EventSlot::create(EventManager* eventmanager)
 
45
{
 
46
    return new EventSlot(eventmanager);
 
47
}
 
48
 
 
49
QCString EventSlot::getSlot(const QCString& signal)
 
50
{
 
51
    QString signature = QString(signal).mid(1);
 
52
    int startpos = signature.find("(");
 
53
    int endpos = signature.findRev(")");
 
54
    if(startpos < 0 || startpos > endpos) {
 
55
        kdWarning() << QString("EventSlot::getSlot(%1) Invalid signal.").arg(signal) << endl;
 
56
        return QCString();
 
57
    }
 
58
    QString signalname = signature.left(startpos);
 
59
    QString params = signature.mid(startpos + 1, endpos - startpos - 1);
 
60
    //QStringList paramlist = QStringList::split(",", params);
 
61
    QCString slot = QString("callback(" + params + ")").latin1(); //normalizeSignalSlot();
 
62
 
 
63
    QMetaObject* mo = metaObject();
 
64
    int slotid = mo->findSlot(slot, false);
 
65
    if(slotid < 0) {
 
66
        kdDebug() << QString("EventSlot::getSlot(%1) No such slot '%2' avaiable.").arg(signal).arg(slot) << endl;
 
67
        return QCString();
 
68
    }
 
69
 
 
70
    const QMetaData* md = mo->slot(slotid, false);
 
71
    if(md->access != QMetaData::Public) {
 
72
        kdDebug() << QString("EventSlot::getSlot(%1) The slot '%2' is not public.").arg(signal).arg(slot) << endl;
 
73
        return QCString();
 
74
    }
 
75
 
 
76
//QMember* member = md->member;
 
77
//const QUMethod *method = md->method;
 
78
 
 
79
    kdDebug()<<"signal="<<signal<<" slot="<<slot<<" slotid="<<slotid<<" params="<<params<<" md->name="<<md->name<<endl;
 
80
    return QCString("1" + slot); // Emulate the SLOT(...) macro by adding as first char a "1".
 
81
}
 
82
 
 
83
bool EventSlot::connect(EventManager* eventmanager, QObject* senderobj, const QCString& signal, QString function, const QCString& slot)
 
84
{
 
85
    if(m_sender && ! disconnect())
 
86
        return false;
 
87
 
 
88
    const QCString& myslot = slot.isEmpty() ? getSlot(signal) : slot;
 
89
    if(! myslot)
 
90
        return false;
 
91
 
 
92
    if(! m_eventmanager) {
 
93
        EventSlot* eventslot = create(eventmanager);
 
94
        eventslot->connect(eventmanager, senderobj, signal, function, slot);
 
95
        m_slots.append(eventslot);
 
96
        kdDebug() << QString("EventSlot::connect(%1, %2, %3) added child EventSlot !!!").arg(senderobj->name()).arg(signal).arg(function) << endl;
 
97
    }
 
98
    else {
 
99
        m_sender = senderobj;
 
100
        m_signal = signal;
 
101
        m_function = function;
 
102
        m_slot = myslot;
 
103
        if(! QObject::connect((QObject*)senderobj, signal, this, myslot)) {
 
104
            kdDebug() << QString("EventSlot::connect(%1, %2, %3) failed.").arg(senderobj->name()).arg(signal).arg(function) << endl;
 
105
            return false;
 
106
        }
 
107
        kdDebug() << QString("EventSlot::connect(%1, %2, %3) successfully connected.").arg(senderobj->name()).arg(signal).arg(function) << endl;
 
108
    }
 
109
 
 
110
    return true;
 
111
}
 
112
 
 
113
bool EventSlot::disconnect()
 
114
{
 
115
    if(! m_sender) return false;
 
116
    QObject::disconnect((QObject*)m_sender, m_signal, this, m_slot);
 
117
    m_sender = 0;
 
118
    m_signal = 0;
 
119
    m_slot = 0;
 
120
    m_function = QString::null;
 
121
    return true;
 
122
}
 
123
 
 
124
void EventSlot::call(const QVariant& variant)
 
125
{
 
126
    kdDebug() << QString("EventSlot::call() sender='%1' signal='%2' function='%3'")
 
127
                 .arg(m_sender->name()).arg(m_signal).arg(m_function) << endl;
 
128
 
 
129
    QValueList<Kross::Api::Object*> args;
 
130
    if(variant.isValid())
 
131
        args.append(Kross::Api::Variant::create(variant));
 
132
    m_eventmanager->m_scriptcontainer->callFunction(
 
133
        m_function,
 
134
        variant.isValid() ? Kross::Api::List::create(args) : 0
 
135
    );
 
136
}
 
137
 
 
138
void EventSlot::callback() {
 
139
    call(QVariant()); }
 
140
void EventSlot::callback(short s) {
 
141
    call(QVariant(s)); }
 
142
void EventSlot::callback(int i) {
 
143
    call(QVariant(i)); }
 
144
void EventSlot::callback(int i1, int i2) {
 
145
    call(QVariant( QValueList<QVariant>() << i1 << i2 )); }
 
146
void EventSlot::callback(int i1, int i2, int i3) {
 
147
    call(QVariant( QValueList<QVariant>() << i1 << i2 << i3 )); }
 
148
void EventSlot::callback(int i1, int i2, int i3, int i4) {
 
149
    call(QVariant( QValueList<QVariant>() << i1 << i2 << i3 << i4 )); }
 
150
void EventSlot::callback(int i1, int i2, int i3, int i4, int i5) {
 
151
    call(QVariant( QValueList<QVariant>() << i1 << i2 << i3 << i4 << i5 )); }
 
152
void EventSlot::callback(int i1, int i2, int i3, int i4, bool b) {
 
153
    call(QVariant( QValueList<QVariant>() << i1 << i2 << i3 << i4 << b )); }
 
154
void EventSlot::callback(int i1, bool b) {
 
155
    call(QVariant( QValueList<QVariant>() << i1 << b )); }
 
156
void EventSlot::callback(int i1, int i2, bool b) {
 
157
    call(QVariant( QValueList<QVariant>() << i1 << i2 << b )); }
 
158
void EventSlot::callback(int i1, int i2, const QString& s) {
 
159
    call(QVariant( QValueList<QVariant>() << i1 << i2 << s )); }
 
160
void EventSlot::callback(uint i) {
 
161
    call(QVariant(i)); }
 
162
void EventSlot::callback(long l) {
 
163
    call(QVariant((Q_LLONG)l)); }
 
164
void EventSlot::callback(ulong l) {
 
165
    call(QVariant((Q_ULLONG)l)); }
 
166
void EventSlot::callback(double d) {
 
167
    call(QVariant(d)); }
 
168
void EventSlot::callback(const char* c) {
 
169
    call(QVariant(c)); }
 
170
void EventSlot::callback(bool b) {
 
171
    call(QVariant(b)); }
 
172
void EventSlot::callback(const QString& s) {
 
173
    call(QVariant(s)); }
 
174
void EventSlot::callback(const QString& s, int i) {
 
175
    call(QVariant( QValueList<QVariant>() << s << i )); }
 
176
void EventSlot::callback(const QString& s, int i1, int i2) {
 
177
    call(QVariant( QValueList<QVariant>() << s << i1 << i2 )); }
 
178
void EventSlot::callback(const QString& s, uint i) {
 
179
    call(QVariant( QValueList<QVariant>() << s << i )); }
 
180
void EventSlot::callback(const QString& s, bool b) {
 
181
    call(QVariant( QValueList<QVariant>() << s << b )); }
 
182
void EventSlot::callback(const QString& s, bool b1, bool b2) {
 
183
    call(QVariant( QValueList<QVariant>() << s << b1 << b2 )); }
 
184
void EventSlot::callback(const QString& s, bool b, int i) {
 
185
    call(QVariant( QValueList<QVariant>() << s << b << i )); }
 
186
void EventSlot::callback(const QString& s1, const QString& s2) {
 
187
    call(QVariant( QValueList<QVariant>() << s1 << s2 )); }
 
188
void EventSlot::callback(const QString& s1, const QString& s2, const QString& s3) {
 
189
    call(QVariant( QValueList<QVariant>() << s1 << s2 << s3 )); }
 
190
void EventSlot::callback(const QStringList& sl) {
 
191
    call(QVariant(sl)); }
 
192
void EventSlot::callback(const QVariant& variant) {
 
193
    call(variant); }
 
194