summaryrefslogtreecommitdiffstats
path: root/kopete/protocols/groupwise/libgroupwise/securestream.h
blob: d5b877fdfee9b316cac4bf155a3454825129d57c (plain)
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 <kopete-devel@kde.org>
 
    *************************************************************************
    *                                                                       *
    * 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 <qca.h>
#include "tlshandler.h"
#include "bytestream.h"

#define USE_TLSHANDLER

#ifdef USE_TLSHANDLER
	class TLSHandler;
#endif

class SecureStream : public ByteStream
{
	Q_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
{
	Q_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