summaryrefslogtreecommitdiffstats
path: root/kopete/protocols/groupwise/libgroupwise/gwclientstream.h
blob: 8e2394c3f85e936bb2f56aea5dd70905832a0ab9 (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
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
/*
    gwclientstream.h - Kopete Groupwise Protocol
  
    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 GW_CLIENTSTREAM_H
#define GW_CLIENTSTREAM_H

#include <qca.h>

#include "gwfield.h"
#include "stream.h"

// forward defines
class ByteStream;
class Connector;
class Request;
class TLSHandler;

typedef struct NovellDN
{
	TQString dn;
	TQString server;
};

class ClientStream : public Stream
{
	Q_OBJECT
  TQ_OBJECT
public:
	enum Error {
		ErrConnection = ErrCustom,  // Connection error, ask Connector-subclass what's up
		ErrNeg,                     // Negotiation error, see condition
		ErrTLS,                     // TLS error, see condition
		ErrAuth,                    // Auth error, see condition
		ErrSecurityLayer,           // broken SASL security layer
		ErrBind                     // Resource binding error
	};
	enum Warning {
/*#		WarnOldVersion,             // server uses older XMPP/Jabber "0.9" protocol  // can be customised for novell versions*/
		WarnNoTLS                   // there is no chance for TLS at this point
	};
	enum NegCond {
		HostGone,                   // host no longer hosted
		HostUnknown,                // unknown host
		RemoteConnectionFailed,     // unable to connect to a required remote resource
		SeeOtherHost,               // a 'redirect', see errorText() for other host
		UnsupportedVersion          // unsupported XMPP version
	};
	enum TLSCond {
		TLSStart,                   // server rejected STARTTLS
		TLSFail                     // TLS failed, ask TLSHandler-subclass what's up
	};
	enum SecurityLayer {
		LayerTLS,
		LayerSASL
	};
	enum AuthCond {
		GenericAuthError,           // all-purpose "can't login" error
		NoMech,                     // No appropriate auth mech available
		BadProto,                   // Bad SASL auth protocol
		BadServ,                    // Server failed mutual auth
		EncryptionRequired,         // can't use mech without TLS
/*#		InvalidAuthzid,             // bad input JID  // need to change this to novell DN*/
		InvalidMech,                // bad mechanism
		InvalidRealm,               // bad realm
		MechTooWeak,                // can't use mech with this authzid
		NotAuthorized,              // bad user, bad password, bad creditials
		TemporaryAuthFailure        // please try again later!
	};
	enum BindCond {
		BindNotAllowed,             // not allowed to bind a resource
		BindConflict                // resource in-use
	};

	ClientStream(Connector *conn, TLSHandler *tlsHandler=0, TQObject *parent=0);
	~ClientStream();

	void connectToServer(const NovellDN &id, bool auth=true);
	void accept(); // server
	bool isActive() const;
	bool isAuthenticated() const;

	// login params
	void setUsername(const TQString &s);
	void setPassword(const TQString &s);
	void setRealm(const TQString &s);
	void continueAfterParams();

	// security options (old protocol only uses the first !)
	void setAllowPlain(bool);
	void setRequireMutualAuth(bool);
	void setLocalAddr(const TQHostAddress &addr, TQ_UINT16 port);

	void close();
	
	/**
	 * Are there any messages waiting to be read
	 */
	bool transfersAvailable() const;
	/**
	 * Read a message received from the server
	 */
	Transfer * read();

	/**
	 * Send a message to the server
	 */
	void write( Request * request );

	int errorCondition() const;
	TQString errorText() const;
// #	TQDomElement errorAppSpec() const; // redondo

	// extrahttp://bugs.kde.org/show_bug.cgi?id=85158
/*#	void writeDirect(const TQString &s); // must be for debug testing*/
	void setNoopTime(int mills);

signals:
	void connected();
	void securityLayerActivated(int);
	//void needAuthParams(bool user, bool pass, bool realm);
	void authenticated(); // this signal is ordinarily emitted in processNext
	void warning(int);
// #	void incomingXml(const TQString &s); // signals emitted in processNext but don't seem to go anywhere...
// #	void outgoingXml(const TQString &s); //
//	void readyRead(); //signals that there is a transfer ready to be read - defined in stream
public slots:
	void continueAfterWarning();

private slots:
	void cr_connected();
	void cr_error();
	/**
	 * collects wire ready outgoing data from the core protocol and sends
	 */ 
	void cp_outgoingData( const TQByteArray& );
	/**
	 * collects parsed incoming data as a transfer from the core protocol and queues
	 */
	void cp_incomingData();

	void bs_connectionClosed();
	void bs_delayedCloseFinished();
	void bs_error(int); // server only

	void ss_readyRead();
	void ss_bytesWritten(int);
	void ss_tlsHandshaken();
	void ss_tlsClosed();
	void ss_error(int);

	void doNoop();
	void doReadyRead();

private:
	class Private;
	Private *d;

	void reset(bool all=false);
	void processNext();
	bool handleNeed();
	void handleError();
	void srvProcessNext();
	
	/** 
	 * convert internal method representation to wire
	 */
	static char* encode_method(TQ_UINT8 method);
};

#endif