예제 #1
0
        public static async Task CopyStreamAsync(this Stream input, Stream output, Int32?position, IProgress <Int64> progress, CancellationToken token)
        {
            if (output is null)
            {
                throw new ArgumentNullException(nameof(output));
            }

            Byte[] buffer = new Byte[BufferUtils.DefaultBuffer];

            if (position.HasValue && input.CanSeek)
            {
                input.Position = position.Value;
            }

            Int32 read;
            Int64 already = 0;

            while ((read = await input.ReadAsync(buffer.AsMemory(0, buffer.Length), token).ConfigureAwait(false)) > 0)
            {
                await output.WriteAsync(buffer.AsMemory(0, read), token).ConfigureAwait(false);

                already += read;
                progress?.Report(already);
            }
        }
예제 #2
0
        public static void Encode(
            Stream input,
            TextWriter output,
            Func <ReadOnlyMemory <Byte>, Boolean, String> bufferEncodeFunc,
            Int32 bufferSize = BufferUtils.DefaultBuffer)
        {
            Byte[] buffer = new Byte[bufferSize];
            while (true)
            {
                Int32 bytesRead = input.Read(buffer, 0, bufferSize);
                if (bytesRead < 1)
                {
                    break;
                }

                String result = bufferEncodeFunc(buffer.AsMemory(0, bytesRead), bytesRead < bufferSize);
                output.Write(result);
            }
        }
예제 #3
0
        public static async Task EncodeAsync(
            Stream input,
            TextWriter output,
            Func <ReadOnlyMemory <Byte>, Boolean, String> bufferEncodeFunc,
            Int32 bufferSize = BufferUtils.DefaultBuffer)
        {
            Byte[] buffer = new Byte[bufferSize];
            while (true)
            {
                Int32 bytesRead = await input.ReadAsync(buffer, 0, bufferSize).ConfigureAwait(false);

                if (bytesRead < 1)
                {
                    break;
                }

                String result = bufferEncodeFunc(buffer.AsMemory(0, bytesRead), bytesRead < bufferSize);
                await output.WriteAsync(result).ConfigureAwait(false);
            }
        }
예제 #4
0
        public static async Task Main(string[] args)
        {
            if (args.Length != 4)
            {
                Console.WriteLine("Usage: swvo-websocket-terminator SessId Host:Port BookmarkName LocalPort");
                Console.WriteLine("Example: swvo-websocket-terminator 44E4224D3E4B1C74FCADE675803C1162 sonicwall.company.com:4433 SSH 2222");
                return;
            }

            var sessId       = args[0];
            var hostPort     = args[1];
            var bookmarkName = args[2];
            var localPort    = Int32.Parse(args[3]);

            var domain = hostPort.Split(':')[0];

            var socket = new ClientWebSocket();

            socket.Options.AddSubProtocol("binary");
            socket.Options.Cookies = new CookieContainer();
            socket.Options.Cookies.Add(new Cookie("SessId", sessId)
            {
                Domain = domain
            });
            try
            {
                await socket.ConnectAsync(new Uri($"wss://{hostPort}/ws?bookmark={WebUtility.UrlEncode(bookmarkName)}"), default);
            }
            catch
            {
                Console.WriteLine("Unable to connect to server");
                return;
            }

            Console.WriteLine("Connected to server");

            var tl = new TcpListener(IPAddress.Loopback, localPort);

            tl.Start();
            Console.WriteLine("Waiting for local connection");
            var client = await tl.AcceptTcpClientAsync();

            Console.WriteLine("Starting IO tasks");
            var t1 = Task.Run(async() =>
            {
                var buffer = new Byte[16777216];
                var i      = client.GetStream();
                Int32 bytesRead;

                while ((bytesRead = i.Read(buffer)) > 0)
                {
                    //Trace.WriteLine($"{bytesRead} to server");
                    await socket.SendAsync(buffer.AsMemory(0, bytesRead), WebSocketMessageType.Binary, true,
                                           default);
                }
            });

            var t2 = Task.Run(async() =>
            {
                var buffer = new Byte[16777216];
                var o      = client.GetStream();
                WebSocketReceiveResult result;
                while ((result = await socket.ReceiveAsync(buffer, default)).Count > 0)
                {
                    //Trace.WriteLine($"{result.Count} to client");
                    o.Write(buffer.AsSpan(0, result.Count));
                }
            });

            try
            {
                await t1;
                await t2;
            }
            catch
            {
                // Don't care.
            }
            Console.WriteLine("Program complete");
        }
예제 #5
0
        public async Task Download(Uri uri, String filePath)
        {
            try
            {
                _bytesLastUpdate = 0;
                _nextUpdate      = DateTime.UtcNow.AddSeconds(1);

                // Determine the file size
                var webRequest = WebRequest.Create(uri);
                webRequest.Method  = "HEAD";
                webRequest.Timeout = 5000;
                Int64 responseLength;

                using (var webResponse = await webRequest.GetResponseAsync())
                {
                    responseLength = Int64.Parse(webResponse.Headers.Get("Content-Length"));
                }

                var timeout = DateTimeOffset.UtcNow.AddHours(1);

                while (timeout > DateTimeOffset.UtcNow && !_cancelled)
                {
                    try
                    {
                        var request = WebRequest.Create(uri);
                        using var response = await request.GetResponseAsync();

                        await using var stream = response.GetResponseStream();

                        if (stream == null)
                        {
                            throw new IOException("No stream");
                        }

                        await using var fileStream = new FileStream(filePath, FileMode.Create, FileAccess.Write, FileShare.Write);
                        var buffer = new Byte[64 * 1024];

                        while (fileStream.Length < response.ContentLength && !_cancelled)
                        {
                            var read = await stream.ReadAsync(buffer.AsMemory(0, buffer.Length));

                            if (read > 0)
                            {
                                fileStream.Write(buffer, 0, read);

                                BytesDone  = fileStream.Length;
                                BytesTotal = responseLength;

                                if (DateTime.UtcNow > _nextUpdate)
                                {
                                    Speed = fileStream.Length - _bytesLastUpdate;

                                    _nextUpdate      = DateTime.UtcNow.AddSeconds(1);
                                    _bytesLastUpdate = fileStream.Length;

                                    timeout = DateTimeOffset.UtcNow.AddHours(1);

                                    DownloadProgressChanged?.Invoke(this, new DownloadProgressChangedEventArgs(null)
                                    {
                                        BytesPerSecondSpeed        = Speed,
                                        ProgressedByteSize         = _bytesLastUpdate,
                                        TotalBytesToReceive        = BytesTotal,
                                        AverageBytesPerSecondSpeed = Speed,
                                        ReceivedBytesSize          = BytesDone,
                                    });
                                }
                            }
                            else
                            {
                                break;
                            }
                        }

                        break;
                    }
                    catch (IOException)
                    {
                        await Task.Delay(1000);
                    }
                    catch (WebException)
                    {
                        await Task.Delay(1000);
                    }
                }

                if (timeout <= DateTimeOffset.UtcNow)
                {
                    throw new Exception($"Download timed out");
                }

                DownloadFileCompleted?.Invoke(this, new AsyncCompletedEventArgs(null, false, null));
            }
            catch (Exception ex)
            {
                DownloadFileCompleted?.Invoke(this, new AsyncCompletedEventArgs(ex, false, null));
            }
        }