summaryrefslogtreecommitdiffstats
blob: 0c26848ea2dfb8f12946c661314b465f7633345f (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
/*
 * Copyright (c) 2011-2016 Isode Limited.
 * All rights reserved.
 * See the COPYING file for more information.
 */

#pragma once

#include <memory>

#include <Swiften/Base/API.h>
#include <Swiften/Base/SafeByteArray.h>
#include <Swiften/Base/SafeString.h>
#include <Swiften/Elements/StreamType.h>
#include <Swiften/EventLoop/EventOwner.h>
#include <Swiften/Network/BOSHConnectionPool.h>
#include <Swiften/Session/SessionStream.h>
#include <Swiften/TLS/TLSOptions.h>

namespace Swift {
    class CompressionLayer;
    class ConnectionLayer;
    class EventLoop;
    class HTTPTrafficFilter;
    class PayloadParserFactoryCollection;
    class PayloadSerializerCollection;
    class StreamStack;
    class TLSContextFactory;
    class TimerFactory;
    class XMLParserFactory;
    class XMPPLayer;

    class SWIFTEN_API BOSHSessionStream : public SessionStream, public EventOwner, public std::enable_shared_from_this<BOSHSessionStream> {
        public:
            BOSHSessionStream(
                    const URL& boshURL,
                    PayloadParserFactoryCollection* payloadParserFactories,
                    PayloadSerializerCollection* payloadSerializers,
                    ConnectionFactory* connectionFactory,
                    TLSContextFactory* tlsContextFactory,
                    TimerFactory* whitespacePingLayerFactory,
                    XMLParserFactory* xmlParserFactory,
                    EventLoop* eventLoop,
                    DomainNameResolver* resolver,
                    const std::string& to,
                    const URL& boshHTTPConnectProxyURL,
                    const SafeString& boshHTTPConnectProxyAuthID,
                    const SafeString& boshHTTPConnectProxyAuthPassword,
                    const TLSOptions& tlsOptions,
                    std::shared_ptr<HTTPTrafficFilter> trafficFilter
            );
            virtual ~BOSHSessionStream();

            void open();
            virtual void close();
            virtual bool isOpen();

            virtual void writeHeader(const ProtocolHeader& header);
            virtual void writeElement(std::shared_ptr<ToplevelElement>);
            virtual void writeFooter();
            virtual void writeData(const std::string& data);

            virtual bool supportsZLibCompression();
            virtual void addZLibCompression();

            virtual bool supportsTLSEncryption();
            virtual void addTLSEncryption();
            virtual bool isTLSEncrypted();
            virtual Certificate::ref getPeerCertificate() const;
            virtual std::vector<Certificate::ref> getPeerCertificateChain() const;
            virtual std::shared_ptr<CertificateVerificationError> getPeerCertificateVerificationError() const;
            virtual ByteArray getTLSFinishMessage() const;

            virtual void setWhitespacePingEnabled(bool);

            virtual void resetXMPPParser();

        private:
            void handleXMPPError();
            void handleStreamStartReceived(const ProtocolHeader&);
            void handleElementReceived(std::shared_ptr<ToplevelElement>);
            void handlePoolXMPPDataRead(const SafeByteArray& data);
            void handleXMPPLayerDataWritten(const SafeByteArray& data);
            void handlePoolSessionStarted();
            void handlePoolBOSHDataRead(const SafeByteArray& data);
            void handlePoolBOSHDataWritten(const SafeByteArray& data);
            void handlePoolSessionTerminated(BOSHError::ref condition);

        private:
            void fakeStreamHeaderReceipt();
            void fakeStreamFooterReceipt(BOSHError::ref error);

        private:
            BOSHConnectionPool* connectionPool;
            bool available;
            XMPPLayer* xmppLayer;
            ProtocolHeader streamHeader;
            EventLoop* eventLoop;
            bool firstHeader;
    };

}