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
|
// **********************************************************************
//
// Copyright (c) 2003-2016 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************
#ifndef ICE_WS_TRANSCEIVER_I_H
#define ICE_WS_TRANSCEIVER_I_H
#include <Ice/ProtocolInstance.h>
#include <Ice/HttpParser.h>
#include <Ice/LoggerF.h>
#include <Ice/Transceiver.h>
#include <Ice/Network.h>
#include <Ice/Buffer.h>
namespace IceInternal
{
class ConnectorI;
class AcceptorI;
//
// Delegate interface implemented by TcpTransceiver or IceSSL::Transceiver or any transport that WS can
// delegate to.
//
class ICE_API WSTransceiverDelegate : public virtual IceUtil::Shared
{
public:
virtual Ice::ConnectionInfoPtr getWSInfo(const Ice::HeaderDict&) const = 0;
};
class WSTransceiver : public Transceiver
{
public:
virtual NativeInfoPtr getNativeInfo();
#if defined(ICE_USE_IOCP)
virtual AsyncInfo* getAsyncInfo(SocketOperation);
#elif defined(ICE_OS_WINRT)
virtual void setCompletedHandler(SocketOperationCompletedHandler^);
#endif
virtual SocketOperation initialize(Buffer&, Buffer&);
#ifdef ICE_CPP11_MAPPING
virtual SocketOperation closing(bool, std::exception_ptr);
#else
virtual SocketOperation closing(bool, const Ice::LocalException&);
#endif
virtual void close();
virtual SocketOperation write(Buffer&);
virtual SocketOperation read(Buffer&);
#if defined(ICE_USE_IOCP) || defined(ICE_OS_WINRT)
virtual bool startWrite(Buffer&);
virtual void finishWrite(Buffer&);
virtual void startRead(Buffer&);
virtual void finishRead(Buffer&);
#endif
virtual std::string protocol() const;
virtual std::string toString() const;
virtual std::string toDetailedString() const;
virtual Ice::ConnectionInfoPtr getInfo() const;
virtual void checkSendSize(const Buffer&);
virtual void setBufferSize(int rcvSize, int sndSize);
private:
WSTransceiver(const ProtocolInstancePtr&, const TransceiverPtr&, const std::string&, int, const std::string&);
WSTransceiver(const ProtocolInstancePtr&, const TransceiverPtr&);
virtual ~WSTransceiver();
void handleRequest(Buffer&);
void handleResponse();
bool preRead(Buffer&);
bool postRead(Buffer&);
bool preWrite(Buffer&);
bool postWrite(Buffer&);
bool readBuffered(Buffer::Container::size_type);
void prepareWriteHeader(Ice::Byte, Buffer::Container::size_type);
friend class WSConnector;
friend class WSAcceptor;
const ProtocolInstancePtr _instance;
const TransceiverPtr _delegate;
const std::string _host;
const int _port;
const std::string _resource;
const bool _incoming;
enum State
{
StateInitializeDelegate,
StateConnected,
StateUpgradeRequestPending,
StateUpgradeResponsePending,
StateOpened,
StatePingPending,
StatePongPending,
StateClosingRequestPending,
StateClosingResponsePending,
StateClosed
};
State _state;
State _nextState;
HttpParserPtr _parser;
std::string _key;
enum ReadState
{
ReadStateOpcode,
ReadStateHeader,
ReadStateControlFrame,
ReadStatePayload,
};
ReadState _readState;
Buffer _readBuffer;
Buffer::Container::iterator _readI;
const Buffer::Container::size_type _readBufferSize;
bool _readLastFrame;
int _readOpCode;
size_t _readHeaderLength;
size_t _readPayloadLength;
Buffer::Container::iterator _readStart;
Buffer::Container::iterator _readFrameStart;
unsigned char _readMask[4];
enum WriteState
{
WriteStateHeader,
WriteStatePayload,
WriteStateControlFrame,
};
WriteState _writeState;
Buffer _writeBuffer;
const Buffer::Container::size_type _writeBufferSize;
unsigned char _writeMask[4];
size_t _writePayloadLength;
bool _readPending;
bool _writePending;
bool _closingInitiator;
int _closingReason;
std::vector<Ice::Byte> _pingPayload;
};
typedef IceUtil::Handle<WSTransceiver> WSTransceiverPtr;
}
#endif
|
