← Back to branch summary

~ubuntu-branches/ubuntu/quantal/psi/quantal

« back to all changes in this revision

Viewing changes to iris/example/server/server.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Jan Niehusmann
  • Date: 2005-01-10 17:41:43 UTC
  • mfrom: (1.2.1 upstream) (2.1.2 hoary)
  • Revision ID: james.westby@ubuntu.com-20050110174143-ltocv5zapl6blf5d
Tags: 0.9.3-1
* New upstream release
* Cleaned up debian/rules (some things are done by upstream Makefiles now)
* Fixed some lintian warnings:
  - removed executable bit from some .png files
  - moved psi.desktop to /usr/share/applications
* Updated menu files

Show diffs side-by-side

added added

removed removed

Lines of Context:
iris/example/server/server.cpp
 
1
#include<qapplication.h>
 
2
#include<qsocket.h>
 
3
#include<qserversocket.h>
 
4
#include<qvaluelist.h>
 
5
#include<qtimer.h>
 
6
#include<qca.h>
 
7
#include<stdlib.h>
 
8
#include<time.h>
 
9
#include"bsocket.h"
 
10
#include"xmpp.h"
 
11
 
 
12
#include<unistd.h>
 
13
 
 
14
char pemdata_cert[] =
 
15
        "-----BEGIN CERTIFICATE-----\n"
 
16
        "MIIDbjCCAtegAwIBAgIBADANBgkqhkiG9w0BAQQFADCBhzELMAkGA1UEBhMCVVMx\n"
 
17
        "EzARBgNVBAgTCkNhbGlmb3JuaWExDzANBgNVBAcTBklydmluZTEYMBYGA1UEChMP\n"
 
18
        "RXhhbXBsZSBDb21wYW55MRQwEgYDVQQDEwtleGFtcGxlLmNvbTEiMCAGCSqGSIb3\n"
 
19
        "DQEJARYTZXhhbXBsZUBleGFtcGxlLmNvbTAeFw0wMzA3MjQwNzMwMDBaFw0wMzA4\n"
 
20
        "MjMwNzMwMDBaMIGHMQswCQYDVQQGEwJVUzETMBEGA1UECBMKQ2FsaWZvcm5pYTEP\n"
 
21
        "MA0GA1UEBxMGSXJ2aW5lMRgwFgYDVQQKEw9FeGFtcGxlIENvbXBhbnkxFDASBgNV\n"
 
22
        "BAMTC2V4YW1wbGUuY29tMSIwIAYJKoZIhvcNAQkBFhNleGFtcGxlQGV4YW1wbGUu\n"
 
23
        "Y29tMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCobzCF268K2sRp473gvBTT\n"
 
24
        "4AgSL1kjeF8N57vxS1P8zWrWMXNs4LuH0NRZmKTajeboy0br8xw+smIy3AbaKAwW\n"
 
25
        "WZToesxebu3m9VeA8dqWyOaUMjoxAcgVYesgVaMpjRe7fcWdJnX1wJoVVPuIcO8m\n"
 
26
        "a+AAPByfTORbzpSTmXAQAwIDAQABo4HnMIHkMB0GA1UdDgQWBBTvFierzLmmYMq0\n"
 
27
        "cB/+5rK1bNR56zCBtAYDVR0jBIGsMIGpgBTvFierzLmmYMq0cB/+5rK1bNR566GB\n"
 
28
        "jaSBijCBhzELMAkGA1UEBhMCVVMxEzARBgNVBAgTCkNhbGlmb3JuaWExDzANBgNV\n"
 
29
        "BAcTBklydmluZTEYMBYGA1UEChMPRXhhbXBsZSBDb21wYW55MRQwEgYDVQQDEwtl\n"
 
30
        "eGFtcGxlLmNvbTEiMCAGCSqGSIb3DQEJARYTZXhhbXBsZUBleGFtcGxlLmNvbYIB\n"
 
31
        "ADAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBBAUAA4GBAGqGhXf7xNOnYNtFO7gz\n"
 
32
        "K6RdZGHFI5q1DAEz4hhNBC9uElh32XGX4wN7giz3zLC8v9icL/W4ff/K5NDfv3Gf\n"
 
33
        "gQe/+Wo9Be3H3ul6uwPPFnx4+PIOF2a5TW99H9smyxWdNjnFtcUte4al3RszcMWG\n"
 
34
        "x3iqsWosGtj6F+ridmKoqKLu\n"
 
35
        "-----END CERTIFICATE-----\n";
 
36
 
 
37
char pemdata_privkey[] =
 
38
        "-----BEGIN RSA PRIVATE KEY-----\n"
 
39
        "MIICXAIBAAKBgQCobzCF268K2sRp473gvBTT4AgSL1kjeF8N57vxS1P8zWrWMXNs\n"
 
40
        "4LuH0NRZmKTajeboy0br8xw+smIy3AbaKAwWWZToesxebu3m9VeA8dqWyOaUMjox\n"
 
41
        "AcgVYesgVaMpjRe7fcWdJnX1wJoVVPuIcO8ma+AAPByfTORbzpSTmXAQAwIDAQAB\n"
 
42
        "AoGAP83u+aYghuIcaWhmM03MLf69z/WztKYSi/fu0BcS977w67bL3MC9CVPoPRB/\n"
 
43
        "0nLSt/jZIuRzHKUCYfXLerSU7v0oXDTy6GPzWMh/oXIrpF0tYNbwWF7LSq2O2gGZ\n"
 
44
        "XtA9MSmUNNJaKzQQeXjqdVFOY8A0Pho+k2KByBiCi+ChkcECQQDRUuyX0+PKJtA2\n"
 
45
        "M36BOTFpy61BAv+JRlXUnHuevOfQWl6NR6YGygqCyH1sWtP1sa9S4wWys3DFH+5A\n"
 
46
        "DkuAqk7zAkEAzf4eUH2hp5CIMsXH+WpIzKj09oY1it2CAKjVq4rUELf8iXvmGoFl\n"
 
47
        "000spua4MjHNUYm7LR0QaKesKrMyGZUesQJAL8aLdYPJI+SD9Tr/jqLtIkZ4frQe\n"
 
48
        "eshw4pvsoyheiHF3zyshO791crAr4EVCx3sMlxB1xnmqLXPCPyCEHxO//QJBAIBY\n"
 
49
        "IYkjDZJ6ofGIe1UyXJNvfdkPu9J+ut4wU5jjEcgs6mK62J6RGuFxhy2iOQfFMdjo\n"
 
50
        "yL+OCUg7mDCun7uCxrECQAtSvnLOFMjO5qExRjFtwi+b1rcSekd3Osk/izyRFSzg\n"
 
51
        "Or+AL56/EKfiogNnFipgaXIbb/xj785Cob6v96XoW1I=\n"
 
52
        "-----END RSA PRIVATE KEY-----\n";
 
53
 
 
54
QCA::Cert *cert;
 
55
QCA::RSAKey *privkey;
 
56
 
 
57
using namespace XMPP;
 
58
 
 
59
int id_num = 0;
 
60
 
 
61
class Session : public QObject
 
62
{
 
63
        Q_OBJECT
 
64
public:
 
65
        Session(const QString &host, const QString &defRealm, ByteStream *bs) : QObject(0)
 
66
        {
 
67
                id = id_num++;
 
68
 
 
69
                tls = new QCA::TLS;
 
70
                tls->setCertificate(*cert, *privkey);
 
71
 
 
72
                cs = new ClientStream(host, defRealm, bs, tls);
 
73
                connect(cs, SIGNAL(connectionClosed()), SLOT(cs_connectionClosed()));
 
74
                connect(cs, SIGNAL(error(int)), SLOT(cs_error(int)));
 
75
        }
 
76
 
 
77
        ~Session()
 
78
        {
 
79
                delete cs;
 
80
                delete tls;
 
81
                printf("[%d]: deleted\n", id);
 
82
        }
 
83
 
 
84
        void start()
 
85
        {
 
86
                printf("[%d]: New session!\n", id);
 
87
                cs->accept();
 
88
        }
 
89
 
 
90
signals:
 
91
        void done();
 
92
 
 
93
private slots:
 
94
        void cs_connectionClosed()
 
95
        {
 
96
                printf("[%d]: Connection closed by peer\n", id);
 
97
                done();
 
98
        }
 
99
 
 
100
        void cs_error(int)
 
101
        {
 
102
                printf("[%d]: Error\n", id);
 
103
                done();
 
104
        }
 
105
 
 
106
private:
 
107
        int id;
 
108
        ClientStream *cs;
 
109
        QCA::TLS *tls;
 
110
};
 
111
 
 
112
class ServerTest : public QServerSocket
 
113
{
 
114
        Q_OBJECT
 
115
public:
 
116
        enum { Idle, Handshaking, Active, Closing };
 
117
 
 
118
        ServerTest(const QString &_host, int _port) : QServerSocket(_port), host(_host), port(_port)
 
119
        {
 
120
                cert = new QCA::Cert;
 
121
                privkey = new QCA::RSAKey;
 
122
 
 
123
                cert->fromPEM(pemdata_cert);
 
124
                privkey->fromPEM(pemdata_privkey);
 
125
 
 
126
                list.setAutoDelete(true);
 
127
        }
 
128
 
 
129
        ~ServerTest()
 
130
        {
 
131
        }
 
132
 
 
133
        void start()
 
134
        {
 
135
                char buf[256];
 
136
                int r = gethostname(buf, sizeof(buf)-1);
 
137
                if(r == -1) {
 
138
                        printf("Error getting hostname!\n");
 
139
                        QTimer::singleShot(0, this, SIGNAL(quit()));
 
140
                        return;
 
141
                }
 
142
                QString myhostname = buf;
 
143
 
 
144
                realm = myhostname;
 
145
                if(host.isEmpty())
 
146
                        host = myhostname;
 
147
 
 
148
                if(cert->isNull() || privkey->isNull()) {
 
149
                        printf("Error loading cert and/or private key!\n");
 
150
                        QTimer::singleShot(0, this, SIGNAL(quit()));
 
151
                        return;
 
152
                }
 
153
                if(!ok()) {
 
154
                        printf("Error binding to port %d!\n", port);
 
155
                        QTimer::singleShot(0, this, SIGNAL(quit()));
 
156
                        return;
 
157
                }
 
158
                printf("Listening on %s:%d ...\n", host.latin1(), port);
 
159
        }
 
160
 
 
161
        void newConnection(int s)
 
162
        {
 
163
                BSocket *bs = new BSocket;
 
164
                bs->setSocket(s);
 
165
                Session *sess = new Session(host, realm, bs);
 
166
                list.append(sess);
 
167
                connect(sess, SIGNAL(done()), SLOT(sess_done()));
 
168
                sess->start();
 
169
        }
 
170
 
 
171
signals:
 
172
        void quit();
 
173
 
 
174
private slots:
 
175
        void sess_done()
 
176
        {
 
177
                Session *sess = (Session *)sender();
 
178
                list.removeRef(sess);
 
179
        }
 
180
 
 
181
private:
 
182
        QString host, realm;
 
183
        int port;
 
184
        QPtrList<Session> list;
 
185
};
 
186
 
 
187
#include"server.moc"
 
188
 
 
189
int main(int argc, char **argv)
 
190
{
 
191
        QApplication app(argc, argv, false);
 
192
        QString host = argc > 1 ? QString(argv[1]) : QString();
 
193
        int port = argc > 2 ? QString(argv[2]).toInt() : 5222;
 
194
 
 
195
        if(!QCA::isSupported(QCA::CAP_TLS)) {
 
196
                printf("TLS not supported!\n");
 
197
                return 1;
 
198
        }
 
199
 
 
200
        if(!QCA::isSupported(QCA::CAP_SASL)) {
 
201
                printf("SASL not supported!\n");
 
202
                return 1;
 
203
        }
 
204
 
 
205
        srand(time(NULL));
 
206
 
 
207
        ServerTest *s = new ServerTest(host, port);
 
208
        QObject::connect(s, SIGNAL(quit()), &app, SLOT(quit()));
 
209
        s->start();
 
210
        app.exec();
 
211
        delete s;
 
212
 
 
213
        // clean up
 
214
        QCA::unloadAllPlugins();
 
215
 
 
216
        return 0;
 
217
}