void DataChannelClose() { foreach (MultiplexedTcpConnection connection in new List <MultiplexedTcpConnection>(connections.Values)) { try { lock (connectionLock) { connections.Remove(connection.Id); } connection.Dispose(); } catch (Exception ex) { Trace.TraceError("Error shutting down multiplex connection: {0}", ex.Message); } } if (dataChannel != null) { dataChannel.Close(); dataChannel = null; } }
void StreamAccepted(HybridConnectionStream hybridConnectionStream) { try { if (hybridConnectionStream != null) { relayListener.AcceptConnectionAsync().ContinueWith(t => StreamAccepted(t.Result)); var preambleReader = new BinaryReader(hybridConnectionStream); var connectionInfo = preambleReader.ReadString(); if (connectionInfo.StartsWith("tcp:", StringComparison.OrdinalIgnoreCase)) { int port; if (!int.TryParse(connectionInfo.Substring(4), out port)) { try { hybridConnectionStream.Close(); } catch (Exception ex) { Trace.TraceError("Error closing stream: {0}", ex.Message); } return; } bool portAllowed = noPortConstraints; Trace.TraceInformation("Incoming connection for port {0}", port); if (!portAllowed) { for (int i = 0; i < allowedPorts.Count; i++) { if (port == allowedPorts[i]) { portAllowed = true; break; } } } if (!portAllowed) { Trace.TraceWarning("Incoming connection for port {0} not permitted", port); try { hybridConnectionStream.Close(); } catch (Exception ex) { Trace.TraceError("Error closing stream: {0}", ex.Message); } return; } } else if (connectionInfo.StartsWith("np:", StringComparison.OrdinalIgnoreCase)) { string pipeName = connectionInfo.Substring(3); Trace.TraceInformation("Incoming connection for pipe {0}", pipeName); bool pipeAllowed = noPipeConstraints; if (!pipeAllowed) { for (int i = 0; i < allowedPipes.Count; i++) { if (pipeName.Equals(allowedPipes[i], StringComparison.OrdinalIgnoreCase)) { pipeAllowed = true; break; } } } if (!pipeAllowed) { Trace.TraceWarning("Incoming connection for pipe {0} not permitted", pipeName); try { hybridConnectionStream.Close(); } catch (Exception ex) { Trace.TraceError("Error closing stream: {0}", ex.Message); } return; } } else { Trace.TraceError("Unable to handle connection for {0}", connectionInfo); hybridConnectionStream.Close(); return; } MultiplexConnectionInputPump connectionPump = new MultiplexConnectionInputPump( hybridConnectionStream.Read, OnCreateConnection, new StreamConnection(hybridConnectionStream, connectionInfo)); connectionPump.Run(false); } } catch (Exception ex) { Trace.TraceError("Error accepting connection: {0}", ex.Message); } }
private Task OnNewClient(Guid streamId, HybridConnectionStream stream, CancellationToken token) { return(Task.Factory.StartNew(async() => { var buffer = new byte[65536]; while (true) { var id = Guid.Empty; int remotePort = 0; var count = 0; Int32 controlCommand = ControlCommands.Forward; Int32 frameSize = 0; Int32 bytesRead = 0; var memStream = new MemoryStream(); // read control command count = await stream.ReadAsync(buffer, 0, sizeof(Int32)); if (0 == count || token.IsCancellationRequested) { break; } controlCommand = BitConverter.ToInt32(new ArraySegment <byte>(buffer, 0, sizeof(Int32)).ToArray(), 0); if (ControlCommands.Forward == controlCommand) { // read forwarding preamble count = await stream.ReadAsync(buffer, 0, 16 + sizeof(Int32) + sizeof(Int32)); if (0 == count || token.IsCancellationRequested) { break; } id = new Guid(new ArraySegment <byte>(buffer, 0, 16).ToArray()); remotePort = BitConverter.ToInt32(new ArraySegment <byte>(buffer, 16, sizeof(Int32)).ToArray(), 0); frameSize = BitConverter.ToInt32(new ArraySegment <byte>(buffer, 16 + sizeof(Int32), sizeof(Int32)).ToArray(), 0); if (!_validPorts.Contains(remotePort)) { _logger.LogError($"Connection on port {remotePort} not allowed for hybrid connectio {_connectionName}."); stream.Close(); } while (true) { var length = frameSize - bytesRead > buffer.Length ? buffer.Length : frameSize - bytesRead; count = await stream.ReadAsync(buffer, 0, length); if (0 == count || token.IsCancellationRequested) { break; } bytesRead += count; await memStream.WriteAsync(buffer, 0, count); if (bytesRead == frameSize) { await _demultiplexer.Demultiplex(streamId, id, remotePort, memStream.ToArray()); break; } } if (0 == count || token.IsCancellationRequested) { break; } } else { count = await stream.ReadAsync(buffer, 0, 16); if (0 == count || token.IsCancellationRequested) { break; } id = new Guid(new ArraySegment <byte>(buffer, 0, 16).ToArray()); await _demultiplexer.ClientConnectionClosed(streamId, id); } } lock (_syncRoot) { _hybridConnectionStreams.Remove(streamId); } await stream.ShutdownAsync(_cts.Token); })); }