gloox 1.0.27
socks5bytestreammanager.h
1/*
2 Copyright (c) 2007-2023 by Jakob Schröter <js@camaya.net>
3 This file is part of the gloox library. http://camaya.net/gloox
4
5 This software is distributed under a license. The full license
6 agreement can be found in the file LICENSE in this distribution.
7 This software may not be copied, modified, sold or distributed
8 other than expressed in the named license agreement.
9
10 This software is distributed without any warranty.
11*/
12
13
14#ifndef SOCKS5BYTESTREAMMANAGER_H__
15#define SOCKS5BYTESTREAMMANAGER_H__
16
17#include "iqhandler.h"
18#include "jid.h"
19#include "stanzaextension.h"
20
21namespace gloox
22{
23
24 class BytestreamHandler;
25 class SOCKS5BytestreamServer;
26 class SOCKS5Bytestream;
27 class ClientBase;
28
33 {
35 std::string host;
36 int port;
37// std::string zeroconf; /**< A zeroconf identifier. */
38 };
39
43 typedef std::list<StreamHost> StreamHostList;
44
51 class GLOOX_API SOCKS5BytestreamManager : public IqHandler
52 {
53
54 friend class SOCKS5Bytestream;
55
56 public:
57
62 {
65 S5BInvalid
66 };
67
75
80
86 void setStreamHosts( StreamHostList hosts ) { m_hosts = hosts; }
87
94 void addStreamHost( const JID& jid, const std::string& host, int port );
95
111 bool requestSOCKS5Bytestream( const JID& to, S5BMode mode, const std::string& sid = EmptyString,
112 const JID& from = JID() );
113
120 bool dispose( SOCKS5Bytestream* s5b );
121
126 void acceptSOCKS5Bytestream( const std::string& sid );
127
133 void rejectSOCKS5Bytestream( const std::string& sid, StanzaError reason = StanzaErrorNotAcceptable );
134
142 { m_socks5BytestreamHandler = s5bh; }
143
148 { m_socks5BytestreamHandler = 0; }
149
155 void registerSOCKS5BytestreamServer( SOCKS5BytestreamServer* server ) { m_server = server; }
156
160 void removeSOCKS5BytestreamServer() { m_server = 0; }
161
162 // reimplemented from IqHandler.
163 virtual bool handleIq( const IQ& iq );
164
165 // reimplemented from IqHandler.
166 virtual void handleIqID( const IQ& iq, int context );
167
168 private:
169#ifdef SOCKS5BYTESTREAMMANAGER_TEST
170 public:
171#endif
172
173 class Query : public StanzaExtension
174 {
175 public:
179 Query();
180
187 Query( const std::string& sid, S5BMode mode,
188 const StreamHostList& hosts );
189
197 Query( const JID& jid, const std::string& sid, bool activate );
198
203 Query( const Tag* tag );
204
208 virtual ~Query();
209
214 const std::string& sid() const { return m_sid; }
215
220 const JID& jid() const { return m_jid; }
221
226 S5BMode mode() const { return m_mode; }
227
232 const StreamHostList& hosts() const { return m_hosts; }
233
234 // reimplemented from StanzaExtension
235 virtual const std::string& filterString() const;
236
237 // reimplemented from StanzaExtension
238 virtual StanzaExtension* newInstance( const Tag* tag ) const
239 {
240 return new Query( tag );
241 }
242
243 // reimplemented from StanzaExtension
244 virtual Tag* tag() const;
245
246 // reimplemented from StanzaExtension
247 virtual StanzaExtension* clone() const
248 {
249 return new Query( *this );
250 }
251
252 private:
253 enum QueryType
254 {
255 TypeSH,
256 TypeSHU,
257 TypeA,
259 };
260
261 std::string m_sid;
262 JID m_jid;
264 StreamHostList m_hosts;
265 QueryType m_type;
266
267 };
268
269 SOCKS5BytestreamManager& operator=( const SOCKS5BytestreamManager&);
270 void rejectSOCKS5Bytestream( const JID& from, const std::string& id, StanzaError reason = StanzaErrorNotAcceptable );
271 bool haveStream( const JID& from );
272 const StreamHost* findProxy( const JID& from, const std::string& hostjid, const std::string& sid );
273
274 void acknowledgeStreamHost( bool success, const JID& jid, const std::string& sid );
275
276 enum IBBActionType
277 {
278 S5BOpenStream,
279 S5BCloseStream,
280 S5BActivateStream
281 };
282
283 typedef std::map<std::string, SOCKS5Bytestream*> S5BMap;
284 S5BMap m_s5bMap;
285
286 struct AsyncS5BItem
287 {
288 JID from;
289 JID to;
290 std::string id;
291 StreamHostList sHosts;
292 bool incoming;
293 };
294 typedef std::map<std::string, AsyncS5BItem> AsyncTrackMap;
295 AsyncTrackMap m_asyncTrackMap;
296
297 ClientBase* m_parent;
298 BytestreamHandler* m_socks5BytestreamHandler;
299 SOCKS5BytestreamServer* m_server;
300 StreamHostList m_hosts;
301 StringMap m_trackMap;
302
303 };
304
305}
306
307#endif // SOCKS5BYTESTREAMMANAGER_H__
A virtual interface that allows to receive new incoming Bytestream requests from remote entities.
This is the common base class for a Jabber/XMPP Client and a Jabber Component.
Definition: clientbase.h:79
An abstraction of an IQ stanza.
Definition: iq.h:34
A virtual interface which can be reimplemented to receive IQ stanzas.
Definition: iqhandler.h:32
An abstraction of a JID.
Definition: jid.h:31
An SOCKS5BytestreamManager dispatches SOCKS5 Bytestreams.
void setStreamHosts(StreamHostList hosts)
void registerSOCKS5BytestreamServer(SOCKS5BytestreamServer *server)
void registerBytestreamHandler(BytestreamHandler *s5bh)
A server listening for SOCKS5 bytestreams.
An implementation of a single SOCKS5 Bytestream (XEP-0065).
This class abstracts a stanza extension, which is usually an XML child element in a specific namespac...
This is an abstraction of an XML element.
Definition: tag.h:47
The namespace for the gloox library.
Definition: adhoc.cpp:28
const std::string EmptyString
Definition: gloox.cpp:124
StanzaError
Definition: gloox.h:872
@ StanzaErrorNotAcceptable
Definition: gloox.h:900
@ TypeInvalid
Definition: dataform.h:44
std::list< StreamHost > StreamHostList
std::map< std::string, std::string > StringMap
Definition: gloox.h:1261