1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
|
/*
securestream.h - Kopete Groupwise Protocol
Combines a ByteStream with TLS and SASL
Copyright (c) 2004 SUSE Linux AG http://www.suse.com
Based on Iris, Copyright (C) 2003 Justin Karneges
Kopete (c) 2002-2004 by the Kopete developers <[email protected]>
*************************************************************************
* *
* 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 of the License, or (at your option) any later version. *
* *
*************************************************************************
*/
#ifndef SECURESTREAM_H
#define SECURESTREAM_H
#include <tqca.h>
#include "tlshandler.h"
#include "bytestream.h"
#define USE_TLSHANDLER
#ifdef USE_TLSHANDLER
class TLSHandler;
#endif
class SecureStream : public ByteStream
{
TQ_OBJECT
public:
enum Error { ErrTLS = ErrCustom, ErrSASL };
SecureStream(ByteStream *s);
~SecureStream();
void startTLSClient(TQCA::TLS *t, const TQByteArray &spare=TQByteArray());
void startTLSServer(TQCA::TLS *t, const TQByteArray &spare=TQByteArray());
void setLayerSASL(TQCA::SASL *s, const TQByteArray &spare=TQByteArray());
#ifdef USE_TLSHANDLER
void startTLSClient(TLSHandler *t, const TQString &server, const TQByteArray &spare=TQByteArray());
#endif
void closeTLS();
int errorCode() const;
// reimplemented
bool isOpen() const;
void write(const TQByteArray &);
int bytesToWrite() const;
signals:
void tlsHandshaken();
void tlsClosed();
private slots:
void bs_readyRead();
void bs_bytesWritten(int);
void layer_tlsHandshaken();
void layer_tlsClosed(const TQByteArray &);
void layer_readyRead(const TQByteArray &);
void layer_needWrite(const TQByteArray &);
void layer_error(int);
private:
void linkLayer(TQObject *);
int calcPrebytes() const;
void insertData(const TQByteArray &a);
void writeRawData(const TQByteArray &a);
void incomingData(const TQByteArray &a);
class Private;
Private *d;
};
class LayerTracker
{
public:
struct Item
{
int plain;
int encoded;
};
USE_TLSHANDLER
LayerTracker();
void reset();
void addPlain(int plain);
void specifyEncoded(int encoded, int plain);
int finished(int encoded);
int p;
TQValueList<Item> list;
};
class SecureLayer : public TQObject
{
TQ_OBJECT
public:
SecureLayer(TQCA::TLS *t);
SecureLayer(TQCA::SASL *s);
#ifdef USE_TLSHANDLER
SecureLayer(TLSHandler *t);
#endif
void init();
void write(const TQByteArray &a);
void writeIncoming(const TQByteArray &a);
int finished(int plain);
enum { TLS, SASL, TLSH };
int type;
union {
TQCA::TLS *tls;
TQCA::SASL *sasl;
#ifdef USE_TLSHANDLER
TLSHandler *tlsHandler;
#endif
} p;
LayerTracker layer;
bool tls_done;
int prebytes;
signals:
void tlsHandshaken();
void tlsClosed(const TQByteArray &);
void readyRead(const TQByteArray &);
void needWrite(const TQByteArray &);
void error(int);
private slots:
void tls_handshaken();
void tls_readyRead();
void tls_readyReadOutgoing(int plainBytes);
void tls_closed();
void tls_error(int x);
void sasl_readyRead();
void sasl_readyReadOutgoing(int plainBytes);
void sasl_error(int x);
#ifdef USE_TLSHANDLER
void tlsHandler_success();
void tlsHandler_fail();
void tlsHandler_closed();
void tlsHandler_readyRead(const TQByteArray &a);
void tlsHandler_readyReadOutgoing(const TQByteArray &a, int plainBytes);
#endif
};
#endif
|
