Exemple #1
0
        /// <summary>
        /// Send the specified byte collection to the client. This may take a number of buffers to complete
        /// and therefore not be synchronous.
        /// </summary>
        public void Send(byte[] buffer, int offset, int count, TransportOptions options = null, IAction onSent = null)
        {
            // is disposed?
            if (_disposed)
            {
                Log.Warning("Cannot send from disposed connection.");
                return;
            }

            // reset the timeout
            if (_timeoutTimer != null)
            {
                _timeoutTimer.Reset(_timeoutMilliseconds);
            }

            _lock.Take();

            // process the options
            ProcessOptions(options);

            _onSent = onSent;

            // perform the send
            SendBytes(buffer, offset, count);
        }
Exemple #2
0
        /// <summary>
        /// Send the file at the specified local path.
        /// </summary>
        public void SendLocal(string path, TransportOptions options = null, IAction onSent = null)
        {
            // is disposed?
            if (_disposed)
            {
                Log.Warning("Cannot send from disposed connection.");
                return;
            }

            // reset the timeout
            if (_timeoutTimer != null)
            {
                _timeoutTimer.Reset(_timeoutMilliseconds);
            }

            // get the extension from the path
            string extension;
            int    extensionIndex = path.LastIndexOf(Chars.Stop);

            extension = extensionIndex == -1 ? null : path.Substring(extensionIndex);

            // open a file stream to the resource
            Stream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);

            // start sending the file
            StartSendStream(fileStream, (int)fileStream.Length, options, onSent);
        }
Exemple #3
0
        /// <summary>
        /// Start sending the stream. The client is locked until the stream is complete.
        /// </summary>
        protected void StartSendStream(Stream stream, int length, TransportOptions options = null, IAction onSent = null)
        {
            // does the buffer need to be compressed?
            if (options != null && options.Compression != DecompressionMethods.None ||
                _defaultCompression != DecompressionMethods.None)
            {
                // yes, compress the stream
                stream = StreamHelper.Compress(options == null ? _defaultCompression : options.Compression,
                                               System.IO.Compression.CompressionLevel.Fastest, stream, length);
                length = (int)stream.Length;

                // take the send lock
                _lock.Take();

                // process the options
                ProcessOptions(options);

                // is the stream to be encrypted? yes, encrypt it
                if (_header.EncryptionPassword != null)
                {
                    var encryptedStream = Crypto.EncryptWithPassword(stream, _header.EncryptionPassword);
                    // dispose of the compressed stream
                    stream.Dispose();
                    // reference the encrypted stream
                    stream = encryptedStream;
                    // set the new stream length
                    length = (int)stream.Length;
                }
            }
            else
            {
                // no, take the send lock
                _lock.Take();

                // process the options
                ProcessOptions(options);

                // is the stream to be encrypted? yes, encrypt it
                if (_header.EncryptionPassword != null)
                {
                    stream = Crypto.EncryptWithPassword(stream, _header.EncryptionPassword);
                    length = (int)stream.Length;
                }
            }

            try {
                // enqueue the header
                EnqueueHeader(length);

                // send the stream
                AsyncSocket.Enqueue(stream, length);
                AsyncSocket.Send(onSent);
            } finally {
                _lock.Release();
            }
        }
Exemple #4
0
        /// <summary>
        /// Process the send options into headers for a following send operation.
        /// </summary>
        protected void ProcessOptions(TransportOptions options)
        {
            if (options == null)
            {
                _header.Compression        = _defaultCompression;
                _header.EncryptionPassword = null;
                return;
            }

            _header.Compression        = options.Compression;
            _header.EncryptionPassword = options.EncryptionPassword;
        }
Exemple #5
0
        /// <summary>
        /// Send the specified web resource.
        /// </summary>
        public void Send(WebResource resource, TransportOptions options = null, IAction onSent = null)
        {
            // is disposed?
            if (_disposed)
            {
                Log.Warning("Cannot send from disposed connection.");
                return;
            }

            // get the resource stream then prepare to send the resource stream data
            resource.GetStream(ActionSet.New(SendResource, (Stream)null, (Lock)null, resource, options, onSent));
        }
Exemple #6
0
        /// <summary>
        /// Send the specified string to the client.
        /// </summary>
        public unsafe void Send(string str, TransportOptions options = null, IAction onSent = null)
        {
            // is disposed?
            if (_disposed)
            {
                Log.Warning("Cannot send from disposed connection.");
                return;
            }

            // reset the timeout
            if (_timeoutTimer != null)
            {
                _timeoutTimer.Reset(_timeoutMilliseconds);
            }

            // is the string empty? skip
            if (string.IsNullOrEmpty(str))
            {
                return;
            }

            _lock.Take();

            // process send options
            ProcessOptions(options);

            _onSent = onSent;

            var buffer = BufferCache.Get(str.Length + str.Length);
            int count;

            // get pointers to the string and the send byte buffer
            fixed(char *src = str)
            fixed(byte *dst = &buffer[0])
            {
                // get the bytes that the string represents
                count = _encoder.GetBytes(src, str.Length, dst, buffer.Length, true);
            }

            // send the byte buffer
            SendBytes(buffer, 0, count);

            // cache the buffer
            BufferCache.Set(buffer);
        }
Exemple #7
0
        /// <summary>
        /// Send the specified stream, optionally with a byte length. This method is
        /// asynchronous and will close the stream on completion.
        /// </summary>
        public void Send(Stream stream, int length = -1, TransportOptions options = null, IAction onSent = null)
        {
            // is disposed?
            if (_disposed)
            {
                Log.Warning("Cannot send from disposed connection.");
                return;
            }

            // reset the timeout
            if (_timeoutTimer != null)
            {
                _timeoutTimer.Reset(_timeoutMilliseconds);
            }

            // start sending the stream
            StartSendStream(stream, length == -1 ? (int)(stream.Length - stream.Position) : length, options, onSent);
        }
        /// <summary>
        /// Deserialize transport options. Returns 'Null' if the transport options weren't serialized.
        /// </summary>
        public static TransportOptions Deserialize(ByteBuffer reader)
        {
            // read a flag to indicate a transport option instance follows
            if (!reader.ReadBoolean())
            {
                return(null);
            }

            // create the transport options
            TransportOptions options = new TransportOptions();

            // read the compression enum
            options.Compression = (DecompressionMethods)reader.ReadByte();
            // read the encryption flag
            options.EncryptionPassword = reader.ReadString();

            return(options);
        }
Exemple #9
0
        /// <summary>
        /// Send the specified udp message. This assumes the stream was written
        /// </summary>
        public void Send(UdpMessage message, TransportOptions options = null, IAction onSent = null)
        {
            // is disposed?
            if (_disposed)
            {
                Log.Warning("Cannot send from disposed connection.");
                return;
            }

            // reset the timeout
            if (_timeoutTimer != null)
            {
                _timeoutTimer.Reset(_timeoutMilliseconds);
            }

            // reset the message stream position
            message.Buffer.Position = 0;

            // start sending the message stream
            StartSendStream(message.Buffer.Stream, (int)message.Buffer.WriteEnd, options, onSent);
        }
Exemple #10
0
        /// <summary>
        /// Begin sending the stream of a web resource and prepare to release the resource lock on completion.
        /// </summary>
        protected void SendResource(Stream stream, Lock resourceLock, WebResource resource, TransportOptions options, IAction onSent)
        {
            // was the stream retrieved?
            if (stream == null)
            {
                // no, unlock the resource
                resourceLock.Release();

                // callback
                ProcessError(new Exception("A resource stream '" + resource.FullPath + "' was unable to be resolved."));

                return;
            }

            _lock.Take();

            if (onSent == null)
            {
                _onSent = new ActionSet(resourceLock.Release);
            }
            else
            {
                _onSent = new ActionPair(resourceLock.Release, onSent);
            }

            // set the content type
            ProcessOptions(options);

            int length = resource.Size == -1 ? (int)stream.Length : (int)resource.Size;

            // start sending the stream
            StartSendStream(stream, length, resource);
        }