diff options
author | teravus | 2013-02-07 10:26:48 -0500 |
---|---|---|
committer | teravus | 2013-02-07 10:27:18 -0500 |
commit | 4867a7cbbf7302845fff031db5eae6fbf93bf26b (patch) | |
tree | 865329b6ab50a3f6bae2edc23f1251abe0cd4d4d /OpenSim/Framework/Servers/HttpServer | |
parent | We're not really done here.. but we're getting there. Socket Read is work... (diff) | |
download | opensim-SC-4867a7cbbf7302845fff031db5eae6fbf93bf26b.zip opensim-SC-4867a7cbbf7302845fff031db5eae6fbf93bf26b.tar.gz opensim-SC-4867a7cbbf7302845fff031db5eae6fbf93bf26b.tar.bz2 opensim-SC-4867a7cbbf7302845fff031db5eae6fbf93bf26b.tar.xz |
This is the final commit that enables the Websocket handler
Diffstat (limited to '')
-rw-r--r-- | OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs | 12 | ||||
-rw-r--r-- | OpenSim/Framework/Servers/HttpServer/WebsocketServerHandler.cs | 1085 |
2 files changed, 1095 insertions, 2 deletions
diff --git a/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs b/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs index dcfe99a..70c531c 100644 --- a/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs +++ b/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs | |||
@@ -54,7 +54,15 @@ namespace OpenSim.Framework.Servers.HttpServer | |||
54 | private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); | 54 | private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); |
55 | private HttpServerLogWriter httpserverlog = new HttpServerLogWriter(); | 55 | private HttpServerLogWriter httpserverlog = new HttpServerLogWriter(); |
56 | 56 | ||
57 | public delegate void WebSocketRequestDelegate(string servicepath, WebSocketHTTPServerHandler handler); | 57 | |
58 | /// <summary> | ||
59 | /// This is a pending websocket request before it got an sucessful upgrade response. | ||
60 | /// The consumer must call handler.HandshakeAndUpgrade() to signal to the handler to | ||
61 | /// start the connection and optionally provide an origin authentication method. | ||
62 | /// </summary> | ||
63 | /// <param name="servicepath"></param> | ||
64 | /// <param name="handler"></param> | ||
65 | public delegate void WebSocketRequestDelegate(string servicepath, WebSocketHttpServerHandler handler); | ||
58 | 66 | ||
59 | /// <summary> | 67 | /// <summary> |
60 | /// Gets or sets the debug level. | 68 | /// Gets or sets the debug level. |
@@ -440,7 +448,7 @@ namespace OpenSim.Framework.Servers.HttpServer | |||
440 | } | 448 | } |
441 | if (dWebSocketRequestDelegate != null) | 449 | if (dWebSocketRequestDelegate != null) |
442 | { | 450 | { |
443 | dWebSocketRequestDelegate(req.Url.AbsolutePath, new WebSocketHTTPServerHandler(req, context, 16384)); | 451 | dWebSocketRequestDelegate(req.Url.AbsolutePath, new WebSocketHttpServerHandler(req, context, 8192)); |
444 | return; | 452 | return; |
445 | } | 453 | } |
446 | 454 | ||
diff --git a/OpenSim/Framework/Servers/HttpServer/WebsocketServerHandler.cs b/OpenSim/Framework/Servers/HttpServer/WebsocketServerHandler.cs new file mode 100644 index 0000000..cfb1605 --- /dev/null +++ b/OpenSim/Framework/Servers/HttpServer/WebsocketServerHandler.cs | |||
@@ -0,0 +1,1085 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors, http://opensimulator.org/ | ||
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions are met: | ||
7 | * * Redistributions of source code must retain the above copyright | ||
8 | * notice, this list of conditions and the following disclaimer. | ||
9 | * * Redistributions in binary form must reproduce the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer in the | ||
11 | * documentation and/or other materials provided with the distribution. | ||
12 | * * Neither the name of the OpenSimulator Project nor the | ||
13 | * names of its contributors may be used to endorse or promote products | ||
14 | * derived from this software without specific prior written permission. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | ||
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | ||
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | ||
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | ||
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | ||
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | */ | ||
27 | |||
28 | using System; | ||
29 | using System.Collections.Generic; | ||
30 | using System.IO; | ||
31 | using System.Security.Cryptography; | ||
32 | using System.Text; | ||
33 | using HttpServer; | ||
34 | |||
35 | namespace OpenSim.Framework.Servers.HttpServer | ||
36 | { | ||
37 | // Sealed class. If you're going to unseal it, implement IDisposable. | ||
38 | /// <summary> | ||
39 | /// This class implements websockets. It grabs the network context from C#Webserver and utilizes it directly as a tcp streaming service | ||
40 | /// </summary> | ||
41 | public sealed class WebSocketHttpServerHandler : BaseRequestHandler | ||
42 | { | ||
43 | |||
44 | private class WebSocketState | ||
45 | { | ||
46 | public List<byte> ReceivedBytes; | ||
47 | public int ExpectedBytes; | ||
48 | public WebsocketFrameHeader Header; | ||
49 | public bool FrameComplete; | ||
50 | public WebSocketFrame ContinuationFrame; | ||
51 | } | ||
52 | |||
53 | /// <summary> | ||
54 | /// Binary Data will trigger this event | ||
55 | /// </summary> | ||
56 | public event DataDelegate OnData; | ||
57 | |||
58 | /// <summary> | ||
59 | /// Textual Data will trigger this event | ||
60 | /// </summary> | ||
61 | public event TextDelegate OnText; | ||
62 | |||
63 | /// <summary> | ||
64 | /// A ping request form the other side will trigger this event. | ||
65 | /// This class responds to the ping automatically. You shouldn't send a pong. | ||
66 | /// it's informational. | ||
67 | /// </summary> | ||
68 | public event PingDelegate OnPing; | ||
69 | |||
70 | /// <summary> | ||
71 | /// This is a response to a ping you sent. | ||
72 | /// </summary> | ||
73 | public event PongDelegate OnPong; | ||
74 | |||
75 | /// <summary> | ||
76 | /// This is a regular HTTP Request... This may be removed in the future. | ||
77 | /// </summary> | ||
78 | public event RegularHttpRequestDelegate OnRegularHttpRequest; | ||
79 | |||
80 | /// <summary> | ||
81 | /// When the upgrade from a HTTP request to a Websocket is completed, this will be fired | ||
82 | /// </summary> | ||
83 | public event UpgradeCompletedDelegate OnUpgradeCompleted; | ||
84 | |||
85 | /// <summary> | ||
86 | /// If the upgrade failed, this will be fired | ||
87 | /// </summary> | ||
88 | public event UpgradeFailedDelegate OnUpgradeFailed; | ||
89 | |||
90 | /// <summary> | ||
91 | /// When the websocket is closed, this will be fired. | ||
92 | /// </summary> | ||
93 | public event CloseDelegate OnClose; | ||
94 | |||
95 | /// <summary> | ||
96 | /// Set this delegate to allow your module to validate the origin of the | ||
97 | /// Websocket request. Primary line of defense against cross site scripting | ||
98 | /// </summary> | ||
99 | public ValidateHandshake HandshakeValidateMethodOverride = null; | ||
100 | |||
101 | private OSHttpRequest _request; | ||
102 | private HTTPNetworkContext _networkContext; | ||
103 | private IHttpClientContext _clientContext; | ||
104 | |||
105 | private int _pingtime = 0; | ||
106 | private byte[] _buffer; | ||
107 | private int _bufferPosition; | ||
108 | private int _bufferLength; | ||
109 | private bool _closing; | ||
110 | private bool _upgraded; | ||
111 | |||
112 | private const string HandshakeAcceptText = | ||
113 | "HTTP/1.1 101 Switching Protocols\r\n" + | ||
114 | "upgrade: websocket\r\n" + | ||
115 | "Connection: Upgrade\r\n" + | ||
116 | "sec-websocket-accept: {0}\r\n\r\n";// + | ||
117 | //"{1}"; | ||
118 | |||
119 | private const string HandshakeDeclineText = | ||
120 | "HTTP/1.1 {0} {1}\r\n" + | ||
121 | "Connection: close\r\n\r\n"; | ||
122 | |||
123 | /// <summary> | ||
124 | /// Mysterious constant defined in RFC6455 to append to the client provided security key | ||
125 | /// </summary> | ||
126 | private const string WebsocketHandshakeAcceptHashConstant = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"; | ||
127 | |||
128 | public WebSocketHttpServerHandler(OSHttpRequest preq, IHttpClientContext pContext, int bufferlen) | ||
129 | : base(preq.HttpMethod, preq.Url.OriginalString) | ||
130 | { | ||
131 | _request = preq; | ||
132 | _networkContext = pContext.GiveMeTheNetworkStreamIKnowWhatImDoing(); | ||
133 | _clientContext = pContext; | ||
134 | _bufferLength = bufferlen; | ||
135 | _buffer = new byte[_bufferLength]; | ||
136 | } | ||
137 | |||
138 | // Sealed class implments destructor and an internal dispose method. complies with C# unmanaged resource best practices. | ||
139 | ~WebSocketHttpServerHandler() | ||
140 | { | ||
141 | Dispose(); | ||
142 | |||
143 | } | ||
144 | |||
145 | /// <summary> | ||
146 | /// Sets the length of the stream buffer | ||
147 | /// </summary> | ||
148 | /// <param name="pChunk">Byte length.</param> | ||
149 | public void SetChunksize(int pChunk) | ||
150 | { | ||
151 | if (!_upgraded) | ||
152 | { | ||
153 | _buffer = new byte[pChunk]; | ||
154 | } | ||
155 | else | ||
156 | { | ||
157 | throw new InvalidOperationException("You must set the chunksize before the connection is upgraded"); | ||
158 | } | ||
159 | } | ||
160 | |||
161 | /// <summary> | ||
162 | /// This is the famous nagle. | ||
163 | /// </summary> | ||
164 | public bool NoDelay_TCP_Nagle | ||
165 | { | ||
166 | get | ||
167 | { | ||
168 | if (_networkContext != null && _networkContext.Socket != null) | ||
169 | { | ||
170 | return _networkContext.Socket.NoDelay; | ||
171 | } | ||
172 | else | ||
173 | { | ||
174 | throw new InvalidOperationException("The socket has been shutdown"); | ||
175 | } | ||
176 | } | ||
177 | set | ||
178 | { | ||
179 | if (_networkContext != null && _networkContext.Socket != null) | ||
180 | _networkContext.Socket.NoDelay = value; | ||
181 | else | ||
182 | { | ||
183 | throw new InvalidOperationException("The socket has been shutdown"); | ||
184 | } | ||
185 | } | ||
186 | } | ||
187 | |||
188 | /// <summary> | ||
189 | /// This triggers the websocket to start the upgrade process... | ||
190 | /// This is a Generalized Networking 'common sense' helper method. Some people expect to call Start() instead | ||
191 | /// of the more context appropriate HandshakeAndUpgrade() | ||
192 | /// </summary> | ||
193 | public void Start() | ||
194 | { | ||
195 | HandshakeAndUpgrade(); | ||
196 | } | ||
197 | |||
198 | /// <summary> | ||
199 | /// This triggers the websocket start the upgrade process | ||
200 | /// </summary> | ||
201 | public void HandshakeAndUpgrade() | ||
202 | { | ||
203 | string webOrigin = string.Empty; | ||
204 | string websocketKey = string.Empty; | ||
205 | string acceptKey = string.Empty; | ||
206 | string accepthost = string.Empty; | ||
207 | if (!string.IsNullOrEmpty(_request.Headers["origin"])) | ||
208 | webOrigin = _request.Headers["origin"]; | ||
209 | |||
210 | if (!string.IsNullOrEmpty(_request.Headers["sec-websocket-key"])) | ||
211 | websocketKey = _request.Headers["sec-websocket-key"]; | ||
212 | |||
213 | if (!string.IsNullOrEmpty(_request.Headers["host"])) | ||
214 | accepthost = _request.Headers["host"]; | ||
215 | |||
216 | if (string.IsNullOrEmpty(_request.Headers["upgrade"])) | ||
217 | { | ||
218 | FailUpgrade(OSHttpStatusCode.ClientErrorBadRequest, "no upgrade request submitted"); | ||
219 | } | ||
220 | |||
221 | string connectionheader = _request.Headers["upgrade"]; | ||
222 | if (connectionheader.ToLower() != "websocket") | ||
223 | { | ||
224 | FailUpgrade(OSHttpStatusCode.ClientErrorBadRequest, "no connection upgrade request submitted"); | ||
225 | } | ||
226 | |||
227 | // If the object consumer provided a method to validate the origin, we should call it and give the client a success or fail. | ||
228 | // If not.. we should accept any. The assumption here is that there would be no Websocket handlers registered in baseHTTPServer unless | ||
229 | // Something asked for it... | ||
230 | if (HandshakeValidateMethodOverride != null) | ||
231 | { | ||
232 | if (HandshakeValidateMethodOverride(webOrigin, websocketKey, accepthost)) | ||
233 | { | ||
234 | acceptKey = GenerateAcceptKey(websocketKey); | ||
235 | string rawaccept = string.Format(HandshakeAcceptText, acceptKey); | ||
236 | SendUpgradeSuccess(rawaccept); | ||
237 | |||
238 | } | ||
239 | else | ||
240 | { | ||
241 | FailUpgrade(OSHttpStatusCode.ClientErrorForbidden, "Origin Validation Failed"); | ||
242 | } | ||
243 | } | ||
244 | else | ||
245 | { | ||
246 | acceptKey = GenerateAcceptKey(websocketKey); | ||
247 | string rawaccept = string.Format(HandshakeAcceptText, acceptKey); | ||
248 | SendUpgradeSuccess(rawaccept); | ||
249 | } | ||
250 | } | ||
251 | |||
252 | /// <summary> | ||
253 | /// Generates a handshake response key string based on the client's | ||
254 | /// provided key to prove to the client that we're allowing the Websocket | ||
255 | /// upgrade of our own free will and we were not coerced into doing it. | ||
256 | /// </summary> | ||
257 | /// <param name="key">Client provided security key</param> | ||
258 | /// <returns></returns> | ||
259 | private static string GenerateAcceptKey(string key) | ||
260 | { | ||
261 | if (string.IsNullOrEmpty(key)) | ||
262 | return string.Empty; | ||
263 | |||
264 | string acceptkey = key + WebsocketHandshakeAcceptHashConstant; | ||
265 | |||
266 | SHA1 hashobj = SHA1.Create(); | ||
267 | string ret = Convert.ToBase64String(hashobj.ComputeHash(Encoding.UTF8.GetBytes(acceptkey))); | ||
268 | hashobj.Clear(); | ||
269 | |||
270 | return ret; | ||
271 | } | ||
272 | |||
273 | /// <summary> | ||
274 | /// Informs the otherside that we accepted their upgrade request | ||
275 | /// </summary> | ||
276 | /// <param name="pHandshakeResponse">The HTTP 1.1 101 response that says Yay \o/ </param> | ||
277 | private void SendUpgradeSuccess(string pHandshakeResponse) | ||
278 | { | ||
279 | // Create a new websocket state so we can keep track of data in between network reads. | ||
280 | WebSocketState socketState = new WebSocketState() { ReceivedBytes = new List<byte>(), Header = WebsocketFrameHeader.HeaderDefault(), FrameComplete = true}; | ||
281 | |||
282 | byte[] bhandshakeResponse = Encoding.UTF8.GetBytes(pHandshakeResponse); | ||
283 | try | ||
284 | { | ||
285 | |||
286 | // Begin reading the TCP stream before writing the Upgrade success message to the other side of the stream. | ||
287 | _networkContext.Stream.BeginRead(_buffer, 0, _bufferLength, OnReceive, socketState); | ||
288 | |||
289 | // Write the upgrade handshake success message | ||
290 | _networkContext.Stream.Write(bhandshakeResponse, 0, bhandshakeResponse.Length); | ||
291 | _networkContext.Stream.Flush(); | ||
292 | _upgraded = true; | ||
293 | UpgradeCompletedDelegate d = OnUpgradeCompleted; | ||
294 | if (d != null) | ||
295 | d(this, new UpgradeCompletedEventArgs()); | ||
296 | } | ||
297 | catch (IOException fail) | ||
298 | { | ||
299 | Close(string.Empty); | ||
300 | } | ||
301 | catch (ObjectDisposedException fail) | ||
302 | { | ||
303 | Close(string.Empty); | ||
304 | } | ||
305 | |||
306 | } | ||
307 | |||
308 | /// <summary> | ||
309 | /// The server has decided not to allow the upgrade to a websocket for some reason. The Http 1.1 response that says Nay >:( | ||
310 | /// </summary> | ||
311 | /// <param name="pCode">HTTP Status reflecting the reason why</param> | ||
312 | /// <param name="pMessage">Textual reason for the upgrade fail</param> | ||
313 | private void FailUpgrade(OSHttpStatusCode pCode, string pMessage ) | ||
314 | { | ||
315 | string handshakeResponse = string.Format(HandshakeDeclineText, (int)pCode, pMessage.Replace("\n", string.Empty).Replace("\r", string.Empty)); | ||
316 | byte[] bhandshakeResponse = Encoding.UTF8.GetBytes(handshakeResponse); | ||
317 | _networkContext.Stream.Write(bhandshakeResponse, 0, bhandshakeResponse.Length); | ||
318 | _networkContext.Stream.Flush(); | ||
319 | _networkContext.Stream.Dispose(); | ||
320 | |||
321 | UpgradeFailedDelegate d = OnUpgradeFailed; | ||
322 | if (d != null) | ||
323 | d(this,new UpgradeFailedEventArgs()); | ||
324 | } | ||
325 | |||
326 | |||
327 | /// <summary> | ||
328 | /// This is our ugly Async OnReceive event handler. | ||
329 | /// This chunks the input stream based on the length of the provided buffer and processes out | ||
330 | /// as many frames as it can. It then moves the unprocessed data to the beginning of the buffer. | ||
331 | /// </summary> | ||
332 | /// <param name="ar">Our Async State from beginread</param> | ||
333 | private void OnReceive(IAsyncResult ar) | ||
334 | { | ||
335 | WebSocketState _socketState = ar.AsyncState as WebSocketState; | ||
336 | try | ||
337 | { | ||
338 | int bytesRead = _networkContext.Stream.EndRead(ar); | ||
339 | if (bytesRead == 0) | ||
340 | { | ||
341 | // Do Disconnect | ||
342 | _networkContext.Stream.Dispose(); | ||
343 | _networkContext = null; | ||
344 | return; | ||
345 | } | ||
346 | _bufferPosition += bytesRead; | ||
347 | |||
348 | if (_bufferPosition > _bufferLength) | ||
349 | { | ||
350 | // Message too big for chunksize.. not sure how this happened... | ||
351 | //Close(string.Empty); | ||
352 | } | ||
353 | |||
354 | int offset = 0; | ||
355 | bool headerread = true; | ||
356 | int headerforwardposition = 0; | ||
357 | while (headerread && offset < bytesRead) | ||
358 | { | ||
359 | if (_socketState.FrameComplete) | ||
360 | { | ||
361 | WebsocketFrameHeader pheader = WebsocketFrameHeader.ZeroHeader; | ||
362 | |||
363 | headerread = WebSocketReader.TryReadHeader(_buffer, offset, _bufferPosition - offset, out pheader, | ||
364 | out headerforwardposition); | ||
365 | offset += headerforwardposition; | ||
366 | |||
367 | if (headerread) | ||
368 | { | ||
369 | _socketState.FrameComplete = false; | ||
370 | |||
371 | if (pheader.PayloadLen > 0) | ||
372 | { | ||
373 | if ((int) pheader.PayloadLen > _bufferPosition - offset) | ||
374 | { | ||
375 | byte[] writebytes = new byte[_bufferPosition - offset]; | ||
376 | |||
377 | Buffer.BlockCopy(_buffer, offset, writebytes, 0, (int) _bufferPosition - offset); | ||
378 | _socketState.ExpectedBytes = (int) pheader.PayloadLen; | ||
379 | _socketState.ReceivedBytes.AddRange(writebytes); | ||
380 | _socketState.Header = pheader; // We need to add the header so that we can unmask it | ||
381 | offset += (int) _bufferPosition - offset; | ||
382 | } | ||
383 | else | ||
384 | { | ||
385 | byte[] writebytes = new byte[pheader.PayloadLen]; | ||
386 | Buffer.BlockCopy(_buffer, offset, writebytes, 0, (int) pheader.PayloadLen); | ||
387 | WebSocketReader.Mask(pheader.Mask, writebytes); | ||
388 | pheader.IsMasked = false; | ||
389 | _socketState.FrameComplete = true; | ||
390 | _socketState.ReceivedBytes.AddRange(writebytes); | ||
391 | _socketState.Header = pheader; | ||
392 | offset += (int) pheader.PayloadLen; | ||
393 | } | ||
394 | } | ||
395 | else | ||
396 | { | ||
397 | pheader.Mask = 0; | ||
398 | _socketState.FrameComplete = true; | ||
399 | _socketState.Header = pheader; | ||
400 | } | ||
401 | |||
402 | |||
403 | |||
404 | if (_socketState.FrameComplete) | ||
405 | { | ||
406 | ProcessFrame(_socketState); | ||
407 | _socketState.Header.SetDefault(); | ||
408 | _socketState.ReceivedBytes.Clear(); | ||
409 | _socketState.ExpectedBytes = 0; | ||
410 | |||
411 | } | ||
412 | |||
413 | } | ||
414 | } | ||
415 | else | ||
416 | { | ||
417 | WebsocketFrameHeader frameHeader = _socketState.Header; | ||
418 | int bytesleft = _socketState.ExpectedBytes - _socketState.ReceivedBytes.Count; | ||
419 | |||
420 | if (bytesleft > _bufferPosition) | ||
421 | { | ||
422 | byte[] writebytes = new byte[_bufferPosition]; | ||
423 | |||
424 | Buffer.BlockCopy(_buffer, offset, writebytes, 0, (int) _bufferPosition); | ||
425 | _socketState.ReceivedBytes.AddRange(writebytes); | ||
426 | _socketState.Header = frameHeader; // We need to add the header so that we can unmask it | ||
427 | offset += (int) _bufferPosition; | ||
428 | } | ||
429 | else | ||
430 | { | ||
431 | byte[] writebytes = new byte[_bufferPosition]; | ||
432 | Buffer.BlockCopy(_buffer, offset, writebytes, 0, (int) _bufferPosition); | ||
433 | _socketState.FrameComplete = true; | ||
434 | _socketState.ReceivedBytes.AddRange(writebytes); | ||
435 | _socketState.Header = frameHeader; | ||
436 | offset += (int) _bufferPosition; | ||
437 | } | ||
438 | if (_socketState.FrameComplete) | ||
439 | { | ||
440 | ProcessFrame(_socketState); | ||
441 | _socketState.Header.SetDefault(); | ||
442 | _socketState.ReceivedBytes.Clear(); | ||
443 | _socketState.ExpectedBytes = 0; | ||
444 | // do some processing | ||
445 | } | ||
446 | |||
447 | } | ||
448 | } | ||
449 | if (offset > 0) | ||
450 | { | ||
451 | // If the buffer is maxed out.. we can just move the cursor. Nothing to move to the beginning. | ||
452 | if (offset <_buffer.Length) | ||
453 | Buffer.BlockCopy(_buffer, offset, _buffer, 0, _bufferPosition - offset); | ||
454 | _bufferPosition -= offset; | ||
455 | } | ||
456 | if (_networkContext.Stream != null && _networkContext.Stream.CanRead && !_closing) | ||
457 | { | ||
458 | _networkContext.Stream.BeginRead(_buffer, _bufferPosition, _bufferLength - _bufferPosition, OnReceive, | ||
459 | _socketState); | ||
460 | } | ||
461 | else | ||
462 | { | ||
463 | // We can't read the stream anymore... | ||
464 | } | ||
465 | |||
466 | } | ||
467 | catch (IOException fail) | ||
468 | { | ||
469 | Close(string.Empty); | ||
470 | } | ||
471 | catch (ObjectDisposedException fail) | ||
472 | { | ||
473 | Close(string.Empty); | ||
474 | } | ||
475 | } | ||
476 | |||
477 | /// <summary> | ||
478 | /// Sends a string to the other side | ||
479 | /// </summary> | ||
480 | /// <param name="message">the string message that is to be sent</param> | ||
481 | public void SendMessage(string message) | ||
482 | { | ||
483 | byte[] messagedata = Encoding.UTF8.GetBytes(message); | ||
484 | WebSocketFrame textMessageFrame = new WebSocketFrame() { Header = WebsocketFrameHeader.HeaderDefault(), WebSocketPayload = messagedata }; | ||
485 | textMessageFrame.Header.Opcode = WebSocketReader.OpCode.Text; | ||
486 | textMessageFrame.Header.IsEnd = true; | ||
487 | SendSocket(textMessageFrame.ToBytes()); | ||
488 | |||
489 | } | ||
490 | |||
491 | public void SendData(byte[] data) | ||
492 | { | ||
493 | WebSocketFrame dataMessageFrame = new WebSocketFrame() { Header = WebsocketFrameHeader.HeaderDefault(), WebSocketPayload = data}; | ||
494 | dataMessageFrame.Header.IsEnd = true; | ||
495 | dataMessageFrame.Header.Opcode = WebSocketReader.OpCode.Binary; | ||
496 | SendSocket(dataMessageFrame.ToBytes()); | ||
497 | |||
498 | } | ||
499 | |||
500 | /// <summary> | ||
501 | /// Writes raw bytes to the websocket. Unframed data will cause disconnection | ||
502 | /// </summary> | ||
503 | /// <param name="data"></param> | ||
504 | private void SendSocket(byte[] data) | ||
505 | { | ||
506 | if (!_closing) | ||
507 | { | ||
508 | try | ||
509 | { | ||
510 | |||
511 | _networkContext.Stream.Write(data, 0, data.Length); | ||
512 | } | ||
513 | catch (IOException) | ||
514 | { | ||
515 | |||
516 | } | ||
517 | } | ||
518 | } | ||
519 | |||
520 | /// <summary> | ||
521 | /// Sends a Ping check to the other side. The other side SHOULD respond as soon as possible with a pong frame. This interleaves with incoming fragmented frames. | ||
522 | /// </summary> | ||
523 | public void SendPingCheck() | ||
524 | { | ||
525 | WebSocketFrame pingFrame = new WebSocketFrame() { Header = WebsocketFrameHeader.HeaderDefault(), WebSocketPayload = new byte[0] }; | ||
526 | pingFrame.Header.Opcode = WebSocketReader.OpCode.Ping; | ||
527 | pingFrame.Header.IsEnd = true; | ||
528 | _pingtime = Util.EnvironmentTickCount(); | ||
529 | SendSocket(pingFrame.ToBytes()); | ||
530 | } | ||
531 | |||
532 | /// <summary> | ||
533 | /// Closes the websocket connection. Sends a close message to the other side if it hasn't already done so. | ||
534 | /// </summary> | ||
535 | /// <param name="message"></param> | ||
536 | public void Close(string message) | ||
537 | { | ||
538 | if (_networkContext.Stream != null) | ||
539 | { | ||
540 | if (_networkContext.Stream.CanWrite) | ||
541 | { | ||
542 | byte[] messagedata = Encoding.UTF8.GetBytes(message); | ||
543 | WebSocketFrame closeResponseFrame = new WebSocketFrame() | ||
544 | { | ||
545 | Header = WebsocketFrameHeader.HeaderDefault(), | ||
546 | WebSocketPayload = messagedata | ||
547 | }; | ||
548 | closeResponseFrame.Header.Opcode = WebSocketReader.OpCode.Close; | ||
549 | closeResponseFrame.Header.PayloadLen = (ulong) messagedata.Length; | ||
550 | closeResponseFrame.Header.IsEnd = true; | ||
551 | SendSocket(closeResponseFrame.ToBytes()); | ||
552 | } | ||
553 | } | ||
554 | CloseDelegate closeD = OnClose; | ||
555 | if (closeD != null) | ||
556 | { | ||
557 | closeD(this, new CloseEventArgs()); | ||
558 | } | ||
559 | |||
560 | _closing = true; | ||
561 | } | ||
562 | |||
563 | /// <summary> | ||
564 | /// Processes a websocket frame and triggers consumer events | ||
565 | /// </summary> | ||
566 | /// <param name="psocketState">We need to modify the websocket state here depending on the frame</param> | ||
567 | private void ProcessFrame(WebSocketState psocketState) | ||
568 | { | ||
569 | if (psocketState.Header.IsMasked) | ||
570 | { | ||
571 | byte[] unmask = psocketState.ReceivedBytes.ToArray(); | ||
572 | WebSocketReader.Mask(psocketState.Header.Mask, unmask); | ||
573 | psocketState.ReceivedBytes = new List<byte>(unmask); | ||
574 | } | ||
575 | |||
576 | switch (psocketState.Header.Opcode) | ||
577 | { | ||
578 | case WebSocketReader.OpCode.Ping: | ||
579 | PingDelegate pingD = OnPing; | ||
580 | if (pingD != null) | ||
581 | { | ||
582 | pingD(this, new PingEventArgs()); | ||
583 | } | ||
584 | |||
585 | WebSocketFrame pongFrame = new WebSocketFrame(){Header = WebsocketFrameHeader.HeaderDefault(),WebSocketPayload = new byte[0]}; | ||
586 | pongFrame.Header.Opcode = WebSocketReader.OpCode.Pong; | ||
587 | pongFrame.Header.IsEnd = true; | ||
588 | SendSocket(pongFrame.ToBytes()); | ||
589 | break; | ||
590 | case WebSocketReader.OpCode.Pong: | ||
591 | |||
592 | PongDelegate pongD = OnPong; | ||
593 | if (pongD != null) | ||
594 | { | ||
595 | pongD(this, new PongEventArgs(){PingResponseMS = Util.EnvironmentTickCountSubtract(Util.EnvironmentTickCount(),_pingtime)}); | ||
596 | } | ||
597 | break; | ||
598 | case WebSocketReader.OpCode.Binary: | ||
599 | if (!psocketState.Header.IsEnd) // Not done, so we need to store this and wait for the end frame. | ||
600 | { | ||
601 | psocketState.ContinuationFrame = new WebSocketFrame | ||
602 | { | ||
603 | Header = psocketState.Header, | ||
604 | WebSocketPayload = | ||
605 | psocketState.ReceivedBytes.ToArray() | ||
606 | }; | ||
607 | } | ||
608 | else | ||
609 | { | ||
610 | // Send Done Event! | ||
611 | DataDelegate dataD = OnData; | ||
612 | if (dataD != null) | ||
613 | { | ||
614 | dataD(this,new WebsocketDataEventArgs(){Data = psocketState.ReceivedBytes.ToArray()}); | ||
615 | } | ||
616 | } | ||
617 | break; | ||
618 | case WebSocketReader.OpCode.Text: | ||
619 | if (!psocketState.Header.IsEnd) // Not done, so we need to store this and wait for the end frame. | ||
620 | { | ||
621 | psocketState.ContinuationFrame = new WebSocketFrame | ||
622 | { | ||
623 | Header = psocketState.Header, | ||
624 | WebSocketPayload = | ||
625 | psocketState.ReceivedBytes.ToArray() | ||
626 | }; | ||
627 | } | ||
628 | else | ||
629 | { | ||
630 | TextDelegate textD = OnText; | ||
631 | if (textD != null) | ||
632 | { | ||
633 | textD(this, new WebsocketTextEventArgs() { Data = Encoding.UTF8.GetString(psocketState.ReceivedBytes.ToArray()) }); | ||
634 | } | ||
635 | |||
636 | // Send Done Event! | ||
637 | } | ||
638 | break; | ||
639 | case WebSocketReader.OpCode.Continue: // Continuation. Multiple frames worth of data for one message. Only valid when not using Control Opcodes | ||
640 | //Console.WriteLine("currhead " + psocketState.Header.IsEnd); | ||
641 | //Console.WriteLine("Continuation! " + psocketState.ContinuationFrame.Header.IsEnd); | ||
642 | byte[] combineddata = new byte[psocketState.ReceivedBytes.Count+psocketState.ContinuationFrame.WebSocketPayload.Length]; | ||
643 | byte[] newdata = psocketState.ReceivedBytes.ToArray(); | ||
644 | Buffer.BlockCopy(psocketState.ContinuationFrame.WebSocketPayload, 0, combineddata, 0, psocketState.ContinuationFrame.WebSocketPayload.Length); | ||
645 | Buffer.BlockCopy(newdata, 0, combineddata, | ||
646 | psocketState.ContinuationFrame.WebSocketPayload.Length, newdata.Length); | ||
647 | psocketState.ContinuationFrame.WebSocketPayload = combineddata; | ||
648 | psocketState.Header.PayloadLen = (ulong)combineddata.Length; | ||
649 | if (psocketState.Header.IsEnd) | ||
650 | { | ||
651 | if (psocketState.ContinuationFrame.Header.Opcode == WebSocketReader.OpCode.Text) | ||
652 | { | ||
653 | // Send Done event | ||
654 | TextDelegate textD = OnText; | ||
655 | if (textD != null) | ||
656 | { | ||
657 | textD(this, new WebsocketTextEventArgs() { Data = Encoding.UTF8.GetString(combineddata) }); | ||
658 | } | ||
659 | } | ||
660 | else if (psocketState.ContinuationFrame.Header.Opcode == WebSocketReader.OpCode.Binary) | ||
661 | { | ||
662 | // Send Done event | ||
663 | DataDelegate dataD = OnData; | ||
664 | if (dataD != null) | ||
665 | { | ||
666 | dataD(this, new WebsocketDataEventArgs() { Data = combineddata }); | ||
667 | } | ||
668 | } | ||
669 | else | ||
670 | { | ||
671 | // protocol violation | ||
672 | } | ||
673 | psocketState.ContinuationFrame = null; | ||
674 | } | ||
675 | break; | ||
676 | case WebSocketReader.OpCode.Close: | ||
677 | Close(string.Empty); | ||
678 | |||
679 | break; | ||
680 | |||
681 | } | ||
682 | psocketState.Header.SetDefault(); | ||
683 | psocketState.ReceivedBytes.Clear(); | ||
684 | psocketState.ExpectedBytes = 0; | ||
685 | } | ||
686 | public void Dispose() | ||
687 | { | ||
688 | if (_networkContext != null && _networkContext.Stream != null) | ||
689 | { | ||
690 | if (_networkContext.Stream.CanWrite) | ||
691 | _networkContext.Stream.Flush(); | ||
692 | _networkContext.Stream.Close(); | ||
693 | _networkContext.Stream.Dispose(); | ||
694 | _networkContext.Stream = null; | ||
695 | } | ||
696 | |||
697 | if (_request != null && _request.InputStream != null) | ||
698 | { | ||
699 | _request.InputStream.Close(); | ||
700 | _request.InputStream.Dispose(); | ||
701 | _request = null; | ||
702 | } | ||
703 | |||
704 | if (_clientContext != null) | ||
705 | { | ||
706 | _clientContext.Close(); | ||
707 | _clientContext = null; | ||
708 | } | ||
709 | } | ||
710 | } | ||
711 | |||
712 | /// <summary> | ||
713 | /// Reads a byte stream and returns Websocket frames. | ||
714 | /// </summary> | ||
715 | public class WebSocketReader | ||
716 | { | ||
717 | /// <summary> | ||
718 | /// Bit to determine if the frame read on the stream is the last frame in a sequence of fragmented frames | ||
719 | /// </summary> | ||
720 | private const byte EndBit = 0x80; | ||
721 | |||
722 | /// <summary> | ||
723 | /// These are the Frame Opcodes | ||
724 | /// </summary> | ||
725 | public enum OpCode | ||
726 | { | ||
727 | // Data Opcodes | ||
728 | Continue = 0x0, | ||
729 | Text = 0x1, | ||
730 | Binary = 0x2, | ||
731 | |||
732 | // Control flow Opcodes | ||
733 | Close = 0x8, | ||
734 | Ping = 0x9, | ||
735 | Pong = 0xA | ||
736 | } | ||
737 | |||
738 | /// <summary> | ||
739 | /// Masks and Unmasks data using the frame mask. Mask is applied per octal | ||
740 | /// Note: Frames from clients MUST be masked | ||
741 | /// Note: Frames from servers MUST NOT be masked | ||
742 | /// </summary> | ||
743 | /// <param name="pMask">Int representing 32 bytes of mask data. Mask is applied per octal</param> | ||
744 | /// <param name="pBuffer"></param> | ||
745 | public static void Mask(int pMask, byte[] pBuffer) | ||
746 | { | ||
747 | byte[] maskKey = BitConverter.GetBytes(pMask); | ||
748 | int currentMaskIndex = 0; | ||
749 | for (int i = 0; i < pBuffer.Length; i++) | ||
750 | { | ||
751 | pBuffer[i] = (byte)(pBuffer[i] ^ maskKey[currentMaskIndex]); | ||
752 | if (currentMaskIndex == 3) | ||
753 | { | ||
754 | currentMaskIndex = 0; | ||
755 | } | ||
756 | else | ||
757 | { | ||
758 | currentMaskIndex++; | ||
759 | |||
760 | } | ||
761 | |||
762 | } | ||
763 | } | ||
764 | |||
765 | /// <summary> | ||
766 | /// Attempts to read a header off the provided buffer. Returns true, exports a WebSocketFrameheader, | ||
767 | /// and an int to move the buffer forward when it reads a header. False when it can't read a header | ||
768 | /// </summary> | ||
769 | /// <param name="pBuffer">Bytes read from the stream</param> | ||
770 | /// <param name="pOffset">Starting place in the stream to begin trying to read from</param> | ||
771 | /// <param name="length">Lenth in the stream to try and read from. Provided for cases where the | ||
772 | /// buffer's length is larger then the data in it</param> | ||
773 | /// <param name="oHeader">Outputs the read WebSocket frame header</param> | ||
774 | /// <param name="moveBuffer">Informs the calling stream to move the buffer forward</param> | ||
775 | /// <returns>True if it got a header, False if it didn't get a header</returns> | ||
776 | public static bool TryReadHeader(byte[] pBuffer, int pOffset, int length, out WebsocketFrameHeader oHeader, | ||
777 | out int moveBuffer) | ||
778 | { | ||
779 | oHeader = WebsocketFrameHeader.ZeroHeader; | ||
780 | int minumheadersize = 2; | ||
781 | if (length > pBuffer.Length - pOffset) | ||
782 | throw new ArgumentOutOfRangeException("The Length specified was larger the byte array supplied"); | ||
783 | if (length < minumheadersize) | ||
784 | { | ||
785 | moveBuffer = 0; | ||
786 | return false; | ||
787 | } | ||
788 | |||
789 | byte nibble1 = (byte)(pBuffer[pOffset] & 0xF0); //FIN/RSV1/RSV2/RSV3 | ||
790 | byte nibble2 = (byte)(pBuffer[pOffset] & 0x0F); // Opcode block | ||
791 | |||
792 | oHeader = new WebsocketFrameHeader(); | ||
793 | oHeader.SetDefault(); | ||
794 | |||
795 | if ((nibble1 & WebSocketReader.EndBit) == WebSocketReader.EndBit) | ||
796 | { | ||
797 | oHeader.IsEnd = true; | ||
798 | } | ||
799 | else | ||
800 | { | ||
801 | oHeader.IsEnd = false; | ||
802 | } | ||
803 | //Opcode | ||
804 | oHeader.Opcode = (WebSocketReader.OpCode)nibble2; | ||
805 | //Mask | ||
806 | oHeader.IsMasked = Convert.ToBoolean((pBuffer[pOffset + 1] & 0x80) >> 7); | ||
807 | |||
808 | // Payload length | ||
809 | oHeader.PayloadLen = (byte)(pBuffer[pOffset + 1] & 0x7F); | ||
810 | |||
811 | int index = 2; // LargerPayload length starts at byte 3 | ||
812 | |||
813 | switch (oHeader.PayloadLen) | ||
814 | { | ||
815 | case 126: | ||
816 | minumheadersize += 2; | ||
817 | if (length < minumheadersize) | ||
818 | { | ||
819 | moveBuffer = 0; | ||
820 | return false; | ||
821 | } | ||
822 | Array.Reverse(pBuffer, pOffset + index, 2); // two bytes | ||
823 | oHeader.PayloadLen = BitConverter.ToUInt16(pBuffer, pOffset + index); | ||
824 | index += 2; | ||
825 | break; | ||
826 | case 127: // we got more this is a bigger frame | ||
827 | // 8 bytes - uint64 - most significant bit 0 network byte order | ||
828 | minumheadersize += 8; | ||
829 | if (length < minumheadersize) | ||
830 | { | ||
831 | moveBuffer = 0; | ||
832 | return false; | ||
833 | } | ||
834 | Array.Reverse(pBuffer, pOffset + index, 8); | ||
835 | oHeader.PayloadLen = BitConverter.ToUInt64(pBuffer, pOffset + index); | ||
836 | index += 8; | ||
837 | break; | ||
838 | |||
839 | } | ||
840 | //oHeader.PayloadLeft = oHeader.PayloadLen; // Start the count in case it's chunked over the network. This is different then frame fragmentation | ||
841 | if (oHeader.IsMasked) | ||
842 | { | ||
843 | minumheadersize += 4; | ||
844 | if (length < minumheadersize) | ||
845 | { | ||
846 | moveBuffer = 0; | ||
847 | return false; | ||
848 | } | ||
849 | oHeader.Mask = BitConverter.ToInt32(pBuffer, pOffset + index); | ||
850 | index += 4; | ||
851 | } | ||
852 | moveBuffer = index; | ||
853 | return true; | ||
854 | |||
855 | } | ||
856 | } | ||
857 | |||
858 | /// <summary> | ||
859 | /// RFC6455 Websocket Frame | ||
860 | /// </summary> | ||
861 | public class WebSocketFrame | ||
862 | { | ||
863 | /* | ||
864 | * RFC6455 | ||
865 | nib 0 1 2 3 4 5 6 7 | ||
866 | byt 0 1 2 3 | ||
867 | dec 0 1 2 3 | ||
868 | 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 | ||
869 | +-+-+-+-+-------+-+-------------+-------------------------------+ | ||
870 | |F|R|R|R| opcode|M| Payload len | Extended payload length | | ||
871 | |I|S|S|S| (4) |A| (7) | (16/64) + | ||
872 | |N|V|V|V| |S| | (if payload len==126/127) | | ||
873 | | |1|2|3| |K| | + | ||
874 | +-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - + | ||
875 | | Extended payload length continued, if payload len == 127 | | ||
876 | + - - - - - - - - - - - - - - - +-------------------------------+ | ||
877 | | |Masking-key, if MASK set to 1 | | ||
878 | +-------------------------------+-------------------------------+ | ||
879 | | Masking-key (continued) | Payload Data | | ||
880 | +-------------------------------- - - - - - - - - - - - - - - - + | ||
881 | : Payload Data continued ... : | ||
882 | + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + | ||
883 | | Payload Data continued ... | | ||
884 | +---------------------------------------------------------------+ | ||
885 | |||
886 | * When reading these, the frames are possibly fragmented and interleaved with control frames | ||
887 | * the fragmented frames are not interleaved with data frames. Just control frames | ||
888 | */ | ||
889 | public static readonly WebSocketFrame DefaultFrame = new WebSocketFrame(){Header = new WebsocketFrameHeader(),WebSocketPayload = new byte[0]}; | ||
890 | public WebsocketFrameHeader Header; | ||
891 | public byte[] WebSocketPayload; | ||
892 | |||
893 | public byte[] ToBytes() | ||
894 | { | ||
895 | Header.PayloadLen = (ulong)WebSocketPayload.Length; | ||
896 | return Header.ToBytes(WebSocketPayload); | ||
897 | } | ||
898 | |||
899 | } | ||
900 | |||
901 | public struct WebsocketFrameHeader | ||
902 | { | ||
903 | //public byte CurrentMaskIndex; | ||
904 | /// <summary> | ||
905 | /// The last frame in a sequence of fragmented frames or the one and only frame for this message. | ||
906 | /// </summary> | ||
907 | public bool IsEnd; | ||
908 | |||
909 | /// <summary> | ||
910 | /// Returns whether the payload data is masked or not. Data from Clients MUST be masked, Data from Servers MUST NOT be masked | ||
911 | /// </summary> | ||
912 | public bool IsMasked; | ||
913 | |||
914 | /// <summary> | ||
915 | /// A set of cryptologically sound random bytes XoR-ed against the payload octally. Looped | ||
916 | /// </summary> | ||
917 | public int Mask; | ||
918 | /* | ||
919 | byt 0 1 2 3 | ||
920 | 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 | ||
921 | +---------------+---------------+---------------+---------------+ | ||
922 | | Octal 1 | Octal 2 | Octal 3 | Octal 4 | | ||
923 | +---------------+---------------+---------------+---------------+ | ||
924 | */ | ||
925 | |||
926 | |||
927 | public WebSocketReader.OpCode Opcode; | ||
928 | |||
929 | public UInt64 PayloadLen; | ||
930 | //public UInt64 PayloadLeft; | ||
931 | // Payload is X + Y | ||
932 | //public UInt64 ExtensionDataLength; | ||
933 | //public UInt64 ApplicationDataLength; | ||
934 | public static readonly WebsocketFrameHeader ZeroHeader = WebsocketFrameHeader.HeaderDefault(); | ||
935 | |||
936 | public void SetDefault() | ||
937 | { | ||
938 | |||
939 | //CurrentMaskIndex = 0; | ||
940 | IsEnd = true; | ||
941 | IsMasked = true; | ||
942 | Mask = 0; | ||
943 | Opcode = WebSocketReader.OpCode.Close; | ||
944 | // PayloadLeft = 0; | ||
945 | PayloadLen = 0; | ||
946 | // ExtensionDataLength = 0; | ||
947 | // ApplicationDataLength = 0; | ||
948 | |||
949 | } | ||
950 | |||
951 | /// <summary> | ||
952 | /// Returns a byte array representing the Frame header | ||
953 | /// </summary> | ||
954 | /// <param name="payload">This is the frame data payload. The header describes the size of the payload. | ||
955 | /// If payload is null, a Zero sized payload is assumed</param> | ||
956 | /// <returns>Returns a byte array representing the frame header</returns> | ||
957 | public byte[] ToBytes(byte[] payload) | ||
958 | { | ||
959 | List<byte> result = new List<byte>(); | ||
960 | |||
961 | // Squeeze in our opcode and our ending bit. | ||
962 | result.Add((byte)((byte)Opcode | (IsEnd?0x80:0x00) )); | ||
963 | |||
964 | // Again with the three different byte interpretations of size.. | ||
965 | |||
966 | //bytesize | ||
967 | if (PayloadLen <= 125) | ||
968 | { | ||
969 | result.Add((byte) PayloadLen); | ||
970 | } //Uint16 | ||
971 | else if (PayloadLen <= ushort.MaxValue) | ||
972 | { | ||
973 | result.Add(126); | ||
974 | byte[] payloadLengthByte = BitConverter.GetBytes(Convert.ToUInt16(PayloadLen)); | ||
975 | Array.Reverse(payloadLengthByte); | ||
976 | result.AddRange(payloadLengthByte); | ||
977 | } //UInt64 | ||
978 | else | ||
979 | { | ||
980 | result.Add(127); | ||
981 | byte[] payloadLengthByte = BitConverter.GetBytes(PayloadLen); | ||
982 | Array.Reverse(payloadLengthByte); | ||
983 | result.AddRange(payloadLengthByte); | ||
984 | } | ||
985 | |||
986 | // Only add a payload if it's not null | ||
987 | if (payload != null) | ||
988 | { | ||
989 | result.AddRange(payload); | ||
990 | } | ||
991 | return result.ToArray(); | ||
992 | } | ||
993 | |||
994 | /// <summary> | ||
995 | /// A Helper method to define the defaults | ||
996 | /// </summary> | ||
997 | /// <returns></returns> | ||
998 | |||
999 | public static WebsocketFrameHeader HeaderDefault() | ||
1000 | { | ||
1001 | return new WebsocketFrameHeader | ||
1002 | { | ||
1003 | //CurrentMaskIndex = 0, | ||
1004 | IsEnd = false, | ||
1005 | IsMasked = true, | ||
1006 | Mask = 0, | ||
1007 | Opcode = WebSocketReader.OpCode.Close, | ||
1008 | //PayloadLeft = 0, | ||
1009 | PayloadLen = 0, | ||
1010 | // ExtensionDataLength = 0, | ||
1011 | // ApplicationDataLength = 0 | ||
1012 | }; | ||
1013 | } | ||
1014 | } | ||
1015 | |||
1016 | public delegate void DataDelegate(object sender, WebsocketDataEventArgs data); | ||
1017 | |||
1018 | public delegate void TextDelegate(object sender, WebsocketTextEventArgs text); | ||
1019 | |||
1020 | public delegate void PingDelegate(object sender, PingEventArgs pingdata); | ||
1021 | |||
1022 | public delegate void PongDelegate(object sender, PongEventArgs pongdata); | ||
1023 | |||
1024 | public delegate void RegularHttpRequestDelegate(object sender, RegularHttpRequestEvnetArgs request); | ||
1025 | |||
1026 | public delegate void UpgradeCompletedDelegate(object sender, UpgradeCompletedEventArgs completeddata); | ||
1027 | |||
1028 | public delegate void UpgradeFailedDelegate(object sender, UpgradeFailedEventArgs faileddata); | ||
1029 | |||
1030 | public delegate void CloseDelegate(object sender, CloseEventArgs closedata); | ||
1031 | |||
1032 | public delegate bool ValidateHandshake(string pWebOrigin, string pWebSocketKey, string pHost); | ||
1033 | |||
1034 | |||
1035 | public class WebsocketDataEventArgs : EventArgs | ||
1036 | { | ||
1037 | public byte[] Data; | ||
1038 | } | ||
1039 | |||
1040 | public class WebsocketTextEventArgs : EventArgs | ||
1041 | { | ||
1042 | public string Data; | ||
1043 | } | ||
1044 | |||
1045 | public class PingEventArgs : EventArgs | ||
1046 | { | ||
1047 | /// <summary> | ||
1048 | /// The ping event can arbitrarily contain data | ||
1049 | /// </summary> | ||
1050 | public byte[] Data; | ||
1051 | } | ||
1052 | |||
1053 | public class PongEventArgs : EventArgs | ||
1054 | { | ||
1055 | /// <summary> | ||
1056 | /// The pong event can arbitrarily contain data | ||
1057 | /// </summary> | ||
1058 | public byte[] Data; | ||
1059 | |||
1060 | public int PingResponseMS; | ||
1061 | |||
1062 | } | ||
1063 | |||
1064 | public class RegularHttpRequestEvnetArgs : EventArgs | ||
1065 | { | ||
1066 | |||
1067 | } | ||
1068 | |||
1069 | public class UpgradeCompletedEventArgs : EventArgs | ||
1070 | { | ||
1071 | |||
1072 | } | ||
1073 | |||
1074 | public class UpgradeFailedEventArgs : EventArgs | ||
1075 | { | ||
1076 | |||
1077 | } | ||
1078 | |||
1079 | public class CloseEventArgs : EventArgs | ||
1080 | { | ||
1081 | |||
1082 | } | ||
1083 | |||
1084 | |||
1085 | } | ||