aboutsummaryrefslogtreecommitdiffstatshomepage
diff options
context:
space:
mode:
Diffstat
-rw-r--r--OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs12
-rw-r--r--OpenSim/Framework/Servers/HttpServer/WebsocketServerHandler.cs1085
-rwxr-xr-xbin/HttpServer_OpenSim.dllbin116224 -> 116224 bytes
-rw-r--r--bin/HttpServer_OpenSim.pdbbin302592 -> 343552 bytes
4 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
28using System;
29using System.Collections.Generic;
30using System.IO;
31using System.Security.Cryptography;
32using System.Text;
33using HttpServer;
34
35namespace 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
865nib 0 1 2 3 4 5 6 7
866byt 0 1 2 3
867dec 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 /*
919byt 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}
diff --git a/bin/HttpServer_OpenSim.dll b/bin/HttpServer_OpenSim.dll
index 9cd1e08..fd7ad74 100755
--- a/bin/HttpServer_OpenSim.dll
+++ b/bin/HttpServer_OpenSim.dll
Binary files differ
diff --git a/bin/HttpServer_OpenSim.pdb b/bin/HttpServer_OpenSim.pdb
index d20a0c5..f56e891 100644
--- a/bin/HttpServer_OpenSim.pdb
+++ b/bin/HttpServer_OpenSim.pdb
Binary files differ
generated by cgit v1.1 at 2024-12-28 17:48:38 +0000