Beispiel #1
0
        /// <summary>
        ///     Serialize message and sent it add it to the buffer
        /// </summary>
        /// <param name="args">Socket buffer</param>
        public void Send(ISocketBuffer args)
        {
            if (_bytesTransferred < _bytesEnqueued)
            {
                //TODO: Is this faster than moving the bytes to the beginning of the buffer and append more bytes?
                args.SetBuffer(_bufferSlice.Buffer, _bufferSlice.Offset + _bytesTransferred,
                               _bytesEnqueued - _bytesTransferred);
                return;
            }

            if (!_headerIsSent)
            {
                var headerLength = CreateHeader();
                var bytesToWrite = (int)Math.Min(_bufferSlice.Capacity - headerLength, _bodyStream.Length);
                _bodyStream.Read(_bufferSlice.Buffer, _bufferSlice.Offset + headerLength, bytesToWrite);
                args.SetBuffer(_bufferSlice.Buffer, _bufferSlice.Offset, bytesToWrite + headerLength);
                _bytesEnqueued   = headerLength + bytesToWrite;
                _bytesLeftToSend = headerLength + (int)_bodyStream.Length;
            }
            else
            {
                _bytesEnqueued = Math.Min(_bufferSlice.Capacity, _bytesLeftToSend);
                _bodyStream.Read(_bufferSlice.Buffer, _bufferSlice.Offset, _bytesEnqueued);
                args.SetBuffer(_bufferSlice.Buffer, _bufferSlice.Offset, _bytesEnqueued);
            }
        }
        /// <summary>
        ///     Buffer structure used for socket send operations.
        /// </summary>
        /// <param name="buffer">
        ///     Do note that there are not buffer attached to the structure, you have to assign one yourself using
        ///     <see cref="ISocketBuffer.SetBuffer(int,int)" />. This choice was made
        ///     to prevent unnecessary copy operations.
        /// </param>
        public void Send(ISocketBuffer buffer)
        {
            // last send operation did not send all bytes enqueued in the buffer
            // so let's just continue until doing next message
            if (_bytesToSend > 0)
            {
                buffer.SetBuffer(_buffer, _offset, _bytesToSend);
                return;
            }

            // continuing with the message body
            if (_isHeaderSent)
            {
                var bytes = Math.Min(_totalAmountToSend, _buffer.Length);
                _message.Body.Read(_buffer, 0, bytes);
                _bytesToSend = bytes;

                buffer.SetBuffer(_buffer, 0, bytes);
                return;
            }

            _writer.WriteLine(_message.StatusLine);
            foreach (var header in _message.Headers)
            {
                _writer.Write("{0}: {1}\r\n", header.Key, header.Value);
            }
            _writer.Write("\r\n");
            _writer.Flush();
            _isHeaderSent = true;
            buffer.UserToken = _message;

            if (_message.Body == null || _message.ContentLength == 0)
            {
                _bytesToSend = (int) _stream.Length;
                _totalAmountToSend = _bytesToSend;
                buffer.SetBuffer(_buffer, 0, (int) _stream.Length);
                return;
            }
            else
            {
                
            }

            var bytesLeft = _buffer.Length - _stream.Length;
            var bytesToSend = Math.Min(_message.ContentLength, (int) bytesLeft);
            var offset = (int) _stream.Position;
            _message.Body.Read(_buffer, offset, bytesToSend);
            _bytesToSend = (int) _stream.Length + bytesToSend;
            _totalAmountToSend = (int) _stream.Length + _message.ContentLength;
            buffer.SetBuffer(_buffer, 0, _bytesToSend);
        }
        /// <summary>
        ///     Buffer structure used for socket send operations.
        /// </summary>
        /// <param name="buffer">
        ///     Do note that there are not buffer attached to the structure, you have to assign one yourself using
        ///     <see cref="ISocketBuffer.SetBuffer(int,int)" />. This choice was made
        ///     to prevent unnecessary copy operations.
        /// </param>
        public void Send(ISocketBuffer buffer)
        {
            // last send operation did not send all bytes enqueued in the buffer
            // so let's just continue until doing next message
            if (_bytesToSend > 0)
            {
                buffer.SetBuffer(_buffer, _offset, _bytesToSend);
                return;
            }

            // continuing with the message body
            if (_isHeaderSent)
            {
                var bytes = Math.Min(_totalAmountToSend, _buffer.Length);
                _message.Body.Read(_buffer, 0, bytes);
                _bytesToSend = bytes;

                buffer.SetBuffer(_buffer, 0, bytes);
                return;
            }

            _writer.WriteLine(_message.StatusLine);
            foreach (var header in _message.Headers)
            {
                _writer.Write("{0}: {1}\r\n", header.Key, header.Value);
            }
            _writer.Write("\r\n");
            _writer.Flush();
            _isHeaderSent    = true;
            buffer.UserToken = _message;

            if (_message.Body == null || _message.ContentLength == 0)
            {
                _bytesToSend       = (int)_stream.Length;
                _totalAmountToSend = _bytesToSend;
                buffer.SetBuffer(_buffer, 0, (int)_stream.Length);
                return;
            }
            else
            {
            }

            var bytesLeft   = _buffer.Length - _stream.Length;
            var bytesToSend = Math.Min(_message.ContentLength, (int)bytesLeft);
            var offset      = (int)_stream.Position;

            _message.Body.Read(_buffer, offset, bytesToSend);
            _bytesToSend       = (int)_stream.Length + bytesToSend;
            _totalAmountToSend = (int)_stream.Length + _message.ContentLength;
            buffer.SetBuffer(_buffer, 0, _bytesToSend);
        }
        public void Send(ISocketBuffer args)
        {
            if (_bytesTransferred < _bytesEnqueued)
            {
                //TODO: Is this faster than moving the bytes to the beginning of the buffer and append more bytes?
                args.SetBuffer(_bufferSlice.Buffer, _bufferSlice.Offset + _bytesTransferred, _bytesEnqueued - _bytesTransferred);
                return;
            }

            if (!_headerIsSent)
            {
                var headerLength = CreateHeader();
                var bytesToWrite = (int)Math.Min(_bufferSlice.Capacity - headerLength, _bodyStream.Length);
                _bodyStream.Read(_bufferSlice.Buffer, _bufferSlice.Offset + headerLength, bytesToWrite);
                args.SetBuffer(_bufferSlice.Buffer, _bufferSlice.Offset, bytesToWrite + headerLength);
                _bytesEnqueued = headerLength + bytesToWrite;
                _bytesLeftToSend = headerLength + (int)_bodyStream.Length;
            }
            else
            {
                _bytesEnqueued = (int)Math.Min(_bufferSlice.Capacity, _bytesLeftToSend);
                _bodyStream.Write(_bufferSlice.Buffer, _bufferSlice.Offset, _bytesEnqueued);
                args.SetBuffer(_bufferSlice.Buffer, _bufferSlice.Offset, _bytesEnqueued);
            }
        }
        /// <summary>
        ///     Buffer structure used for socket send operations.
        /// </summary>
        /// <param name="buffer">
        ///     Do note that there are not buffer attached to the structure, you have to assign one yourself using
        ///     <see cref="ISocketBuffer.SetBuffer" />. This choice was made
        ///     to prevent unnecessary copy operations.
        /// </param>
        public void Send(ISocketBuffer buffer)
        {
            if (_bytesToSend > 0)
            {
                buffer.SetBuffer(_buffer, _offset, _bytesToSend);
                return;
            }
            if (_isHeaderSent)
            {
                var bytes = Math.Min(_totalAmountToSend, _buffer.Length);
                _message.Body.Read(_buffer, 0, bytes);
                _bytesToSend = bytes;

                buffer.SetBuffer(_buffer, 0, bytes);
                return;
            }

            _writer.WriteLine(_message.StatusLine);

            foreach (var header in _message.Headers)
            {
                _writer.Write("{0}:{1}\r\n", header.Key, header.Value);
            }

            _writer.Write("\r\n");
            _writer.Flush();
            _isHeaderSent = true;

            if (_message.Body == null || _message.ContentLength == 0)
            {
                _bytesToSend = (int) _stream.Length;
                _totalAmountToSend = _bytesToSend;
                buffer.SetBuffer(_buffer, 0, (int) _stream.Length);
                return;
            }

            var bytesLeft = _buffer.Length - _stream.Length;
            var bytesToSend = Math.Min(_message.ContentLength, (int) bytesLeft);
            var offset = (int) _stream.Position;
            _message.Body.Read(_buffer, offset, bytesToSend);
            _bytesToSend = (int) _stream.Length + bytesToSend;
            _totalAmountToSend = (int) _stream.Length + _message.ContentLength;
            buffer.SetBuffer(_buffer, 0, _totalAmountToSend);
        }
        public void Send(ISocketBuffer buffer)
        {
            this.stream.Position = 0;
            this.stream.SetLength(0);

            if (!this.isHeaderSent)
            {
                this.writer.WriteLine(this.response.StatusLine);

                foreach (var header in this.response.Headers)
                {
                    if (string.IsNullOrEmpty(header.Key))
                    {
                        continue;
                    }

                    this.writer.Write("{0}: {1}\r\n", header.Key, header.Value);
                }

                this.writer.Write("\r\n");


                this.isHeaderSent = true;
                buffer.UserToken  = this.response;
                this.writer.Flush();
            }

            //stopwatch.Stop();

            //Debug.WriteLine("Network: " + stopwatch.ElapsedMilliseconds);

            //stopwatch.Restart();

            this.nextFrameAvailable = this.response.StreamSource.WriteNextFrame(this.multipartStream).Result;

            //stopwatch.Stop();

            //Debug.WriteLine("Encoding: " + stopwatch.ElapsedMilliseconds);

            //stopwatch.Restart();

            // Send
            buffer.SetBuffer(this.buffer, 0, (int)this.stream.Length);
        }
        /// <summary>
        ///     Buffer structure used for socket send operations.
        /// </summary>
        /// <param name="buffer">
        ///     Do note that there are not buffer attached to the structure, you have to assign one yourself using
        ///     <see cref="ISocketBuffer.SetBuffer" />. This choice was made
        ///     to prevent unnecessary copy operations.
        /// </param>
        /// <remarks>
        ///     The <c>buffer</c> variable is typically a wrapper around <see cref="SocketAsyncEventArgs" />, but may be something
        ///     else if required.
        /// </remarks>
        public void Send(ISocketBuffer buffer)
        {
            buffer.SetBuffer(_buffer, _offset, _bytesLeft);

        }
        /// <summary>
        ///     Buffer structure used for socket send operations.
        /// </summary>
        /// <param name="buffer">
        ///     Do note that there are not buffer attached to the structure, you have to assign one yourself using
        ///     <see cref="ISocketBuffer.SetBuffer(int,int)" />. This choice was made
        ///     to prevent unnecessary copy operations.
        /// </param>
        public void Send(ISocketBuffer buffer)
        {
            if (_message == null)
            {
                _httpMessageEncoder.Send(buffer);
            }
            else
            {
                // last send operation did not send all bytes enqueued in the buffer
                // so let's just continue until doing next message
                if (_bytesToSend > 0)
                {
                    buffer.SetBuffer(_buffer, _offset, _bytesToSend);
                    return;
                }

                var offset      = (int)_message.Payload.Position;
                var length      = (int)_message.Payload.Length;
                var frameLength = length - offset;

                var fin = WebSocketFin.Final;
                if (frameLength > WebSocketFrame.FragmentLength)
                {
                    frameLength = WebSocketFrame.FragmentLength;
                    fin         = WebSocketFin.More;
                }
                var opcode = WebSocketOpcode.Continuation;
                if (offset == 0) // first frame
                {
                    opcode = _message.Opcode;
                }

                var buff = new byte[frameLength];
                _message.Payload.Read(buff, 0, buff.Length);
                var payload = new MemoryStream(buff);

                WebSocketFrame frame = new WebSocketFrame(fin, opcode, (_handshake is IHttpRequest) ? WebSocketMask.Mask : WebSocketMask.Unmask, payload);

                using (var stream = new MemoryStream())
                {
                    var header = (int)frame.Fin;
                    header = (header << 1) + (int)frame.Rsv1;
                    header = (header << 1) + (int)frame.Rsv2;
                    header = (header << 1) + (int)frame.Rsv3;
                    header = (header << 4) + (int)frame.Opcode;
                    header = (header << 1) + (int)frame.Mask;
                    header = (header << 7) + (int)frame.PayloadLength;

                    stream.Write(WebSocketUtils.GetBigEndianBytes((ushort)header), 0, 2);

                    if (frame.PayloadLength > 125)
                    {
                        stream.Write(frame.ExtPayloadLength, 0, frame.ExtPayloadLength.Length);
                    }

                    if (frame.Mask == WebSocketMask.Mask)
                    {
                        stream.Write(frame.MaskingKey, 0, frame.MaskingKey.Length);
                        frame.Unmask();
                    }

                    _totalAmountToSend += (int)stream.Length;

                    if (frame.PayloadLength > 0)
                    {
                        frame.Payload.CopyTo(stream);
                    }

                    buffer.UserToken = _message;

                    _buffer      = stream.ToArray();
                    _bytesToSend = _buffer.Length;

                    buffer.SetBuffer(_buffer, 0, _bytesToSend);
                }
            }
        }
        /// <summary>
        ///     Buffer structure used for socket send operations.
        /// </summary>
        /// <param name="buffer">
        ///     Do note that there are not buffer attached to the structure, you have to assign one yourself using
        ///     <see cref="ISocketBuffer.SetBuffer(int,int)" />. This choice was made
        ///     to prevent unnecessary copy operations.
        /// </param>
        public void Send(ISocketBuffer buffer)
        {
            if (_bytesToSend > 0)
            {
                buffer.SetBuffer(_buffer, _offset, _bytesToSend, _bytesToSend);
                return;
            }
            if (_isHeaderSent)
            {
                var bytes = Math.Min(_totalAmountToSend, _buffer.Length);
                _frame.Body.Read(_buffer, 0, bytes);
                _bytesToSend = bytes;

                // include null char as message delimter
                if (bytes < _buffer.Length)
                {
                    buffer.Buffer[_bytesToSend] = 0;
                    bytes++;
                }

                buffer.SetBuffer(_buffer, 0, bytes, bytes);
                return;
            }

            if (_frame.Name == "NoOp")
            {
                _bytesToSend = 0;
                buffer.Buffer[0] = 10;
                buffer.SetBuffer(0, 1);
                return;
            }

            _writer.Write("{0}\n", _frame.Name);
            foreach (var header in _frame.Headers)
            {
                _writer.Write("{0}:{1}\n", header.Key, header.Value);
            }

            _writer.Write("\n");
            _writer.Flush();
            _isHeaderSent = true;

            if (_frame.Body == null || _frame.ContentLength == 0)
            {
                _stream.Write(new byte[] {0}, 0, 1);
                _bytesToSend = (int) _stream.Length;
                _totalAmountToSend = _bytesToSend;
                buffer.SetBuffer(_buffer, 0, (int) _stream.Length);
                return;
            }

            var bytesLeft = _buffer.Length - _stream.Length;
            var bytesToSend = Math.Min(_frame.ContentLength, (int) bytesLeft);
            var offset = (int) _stream.Position;
            _frame.Body.Read(_buffer, offset, bytesToSend);
            _bytesToSend = (int) _stream.Length + bytesToSend;
            _totalAmountToSend = (int) _stream.Length + _frame.ContentLength + 1;

            // everything is done in the first run
            // so add the message delimiter.
            if (_totalAmountToSend < buffer.Count)
            {
                _totalAmountToSend++;
                _bytesToSend++;
                _buffer[_bytesToSend] = 0;
            }

            buffer.SetBuffer(_buffer, 0, _totalAmountToSend);
        }
Beispiel #10
0
 /// <summary>
 /// Buffer structure used for socket send operations.
 /// </summary>
 /// <param name="buffer">Do note that there are not buffer attached to the structure, you have to assign one yourself using <see cref="ISocketBuffer.SetBuffer"/>. This choice was made
 /// to prevent unnecessary copy operations.</param>
 public void Send(ISocketBuffer buffer)
 {
     buffer.SetBuffer(Buffer, Offset, Count);
 }
        /// <summary>
        ///     Buffer structure used for socket send operations.
        /// </summary>
        /// <param name="buffer">
        ///     Do note that there are not buffer attached to the structure, you have to assign one yourself using
        ///     <see cref="ISocketBuffer.SetBuffer(int,int)" />. This choice was made
        ///     to prevent unnecessary copy operations.
        /// </param>
        public void Send(ISocketBuffer buffer)
        {
            if (_message == null)
            {
                _httpMessageEncoder.Send(buffer);
            }
            else
            {
                // last send operation did not send all bytes enqueued in the buffer
                // so let's just continue until doing next message
                if (_bytesToSend > 0)
                {
                    buffer.SetBuffer(_buffer, _offset, _bytesToSend);
                    return;
                }

                var offset = (int)_message.Payload.Position;
                var length = (int)_message.Payload.Length;
                var frameLength = length - offset;

                var fin = WebSocketFin.Final;
                if (frameLength > WebSocketFrame.FragmentLength)
                {
                    frameLength = WebSocketFrame.FragmentLength;
                    fin = WebSocketFin.More;
                }
                var opcode = WebSocketOpcode.Continuation;
                if (offset == 0) // first frame
                {
                    opcode = _message.Opcode;
                }

                var buff = new byte[frameLength];
                _message.Payload.Read(buff, 0, buff.Length);
                var payload = new MemoryStream(buff);

                WebSocketFrame frame = new WebSocketFrame(fin, opcode, (_handshake is IHttpRequest) ? WebSocketMask.Mask : WebSocketMask.Unmask, payload);

                using (var stream = new MemoryStream())
                {
                    var header = (int)frame.Fin;
                    header = (header << 1) + (int)frame.Rsv1;
                    header = (header << 1) + (int)frame.Rsv2;
                    header = (header << 1) + (int)frame.Rsv3;
                    header = (header << 4) + (int)frame.Opcode;
                    header = (header << 1) + (int)frame.Mask;
                    header = (header << 7) + (int)frame.PayloadLength;

                    stream.Write(WebSocketUtils.GetBigEndianBytes((ushort)header), 0, 2);

                    if (frame.PayloadLength > 125)
                    {
                        stream.Write(frame.ExtPayloadLength, 0, frame.ExtPayloadLength.Length);
                    }

                    if (frame.Mask == WebSocketMask.Mask)
                    {
                        stream.Write(frame.MaskingKey, 0, frame.MaskingKey.Length);
                        frame.Unmask();
                    }

                    _totalAmountToSend += (int)stream.Length;

                    if (frame.PayloadLength > 0)
                    {
                        frame.Payload.CopyTo(stream);
                    }

                    buffer.UserToken = _message;

                    _buffer = stream.ToArray();
                    _bytesToSend = _buffer.Length;

                    buffer.SetBuffer(_buffer, 0, _bytesToSend);
                }
            }
        }
Beispiel #12
0
        /// <summary>
        ///     Buffer structure used for socket send operations.
        /// </summary>
        /// <param name="buffer">
        ///     Do note that there are not buffer attached to the structure, you have to assign one yourself using
        ///     <see cref="ISocketBuffer.SetBuffer(int,int)" />. This choice was made
        ///     to prevent unnecessary copy operations.
        /// </param>
        public void Send(ISocketBuffer buffer)
        {
            if (_bytesToSend > 0)
            {
                buffer.SetBuffer(_buffer, _offset, _bytesToSend, _bytesToSend);
                return;
            }
            if (_isHeaderSent)
            {
                var bytes = Math.Min(_totalAmountToSend, _buffer.Length);
                _frame.Body.Read(_buffer, 0, bytes);
                _bytesToSend = bytes;

                // include null char as message delimter
                if (bytes < _buffer.Length)
                {
                    buffer.Buffer[_bytesToSend] = 0;
                    bytes++;
                }

                buffer.SetBuffer(_buffer, 0, bytes, bytes);
                return;
            }

            if (_frame.Name == "NoOp")
            {
                _bytesToSend     = 0;
                buffer.Buffer[0] = 10;
                buffer.SetBuffer(0, 1);
                return;
            }

            _writer.Write("{0}\n", _frame.Name);
            foreach (var header in _frame.Headers)
            {
                _writer.Write("{0}:{1}\n", header.Key, header.Value);
            }

            _writer.Write("\n");
            _writer.Flush();
            _isHeaderSent = true;

            if (_frame.Body == null || _frame.ContentLength == 0)
            {
                _stream.Write(new byte[] { 0 }, 0, 1);
                _bytesToSend       = (int)_stream.Length;
                _totalAmountToSend = _bytesToSend;
                buffer.SetBuffer(_buffer, 0, (int)_stream.Length);
                return;
            }

            var bytesLeft   = _buffer.Length - _stream.Length;
            var bytesToSend = Math.Min(_frame.ContentLength, (int)bytesLeft);
            var offset      = (int)_stream.Position;

            _frame.Body.Read(_buffer, offset, bytesToSend);
            _bytesToSend       = (int)_stream.Length + bytesToSend;
            _totalAmountToSend = (int)_stream.Length + _frame.ContentLength + 1;

            // everything is done in the first run
            // so add the message delimiter.
            if (_totalAmountToSend < buffer.Count)
            {
                _totalAmountToSend++;
                _bytesToSend++;
                _buffer[_bytesToSend] = 0;
            }

            buffer.SetBuffer(_buffer, 0, _totalAmountToSend);
        }
 /// <summary>
 ///     Buffer structure used for socket send operations.
 /// </summary>
 /// <param name="buffer">
 ///     Do note that there are not buffer attached to the structure, you have to assign one yourself using
 ///     <see cref="ISocketBuffer.SetBuffer(int,int)" />. This choice was made
 ///     to prevent unnecessary copy operations.
 /// </param>
 /// <remarks>
 ///     The <c>buffer</c> variable is typically a wrapper around <see cref="SocketAsyncEventArgs" />, but may be something
 ///     else if required.
 /// </remarks>
 public void Send(ISocketBuffer buffer)
 {
     buffer.SetBuffer(_buffer, _offset, _bytesLeft);
 }
 public void Send(ISocketBuffer buffer)
 {
     // Continue from where the last send operation stopped.
     buffer.SetBuffer(_memoryStream.GetBuffer(), _offset, _bytesLeft);
 }
Beispiel #15
0
 /// <summary>
 /// Buffer structure used for socket send operations.
 /// </summary>
 /// <param name="buffer">Do note that there are not buffer attached to the structure, you have to assign one yourself using <see cref="ISocketBuffer.SetBuffer"/>. This choice was made
 /// to prevent unnecessary copy operations.</param>
 public void Send(ISocketBuffer buffer)
 {
     buffer.SetBuffer(Buffer, Offset, Count);
 }
Beispiel #16
0
 public void Send(ISocketBuffer buffer)
 {
     // Continue from where the last send operation stopped.
     buffer.SetBuffer(_memoryStream.GetBuffer(), _offset, _bytesLeft);
 }