/// <summary> /// Creates an MqttMessage from a data stream /// </summary> /// <param name="str">Input stream</param> /// <param name="header">The first byte of the fixed header of the message</param> public MqttMessage(INetworkStream str, byte header) { this._timestamp = DateTime.Now.Ticks; ConstructHeader(header); variableHeaderLength = DecodeVariableHeaderLength(str); ConstructFromStream(str); }
public void Connect() { _channel = StreamFactory.CreateStream(_connString); readOp = _channel.BeginRead(headerBuffer, 0, 1, callback, null); // Give the qosManager a handle to the streams qosManager.SetStreamManager(this); _connected = true; }
private ITcpClientFactory CreateClientFactory() { var tcpClientFactory = MockRepository.GenerateStub<ITcpClientFactory>(); _tcpClient = MockRepository.GenerateMock<ITcpClient>(); _stream = MockRepository.GenerateMock<INetworkStream>(); tcpClientFactory.Stub(x => x.Create()).Return(_tcpClient); return tcpClientFactory; }
public INetworkStream GetStream () { if (_stream == null) { _stream = new IosNetworkStream (_client.GetStream ()); } return _stream; }
public static IAsyncResult BeginSend( this DicomClient @this, INetworkStream stream, string callingAe, string calledAe, AsyncCallback callback, object state) { return AsyncFactory.ToBegin(@this.SendAsync(stream, callingAe, calledAe), callback, state); }
/// <summary> /// Initializes a new instance of the <see cref="DicomService"/> class. /// </summary> /// <param name="stream">Network stream.</param> /// <param name="fallbackEncoding">Fallback encoding.</param> /// <param name="log">Logger</param> protected DicomService(INetworkStream stream, Encoding fallbackEncoding, Logger log) { _network = stream; _lock = new object(); _pduQueue = new Queue<PDU>(); MaximumPDUsInQueue = 16; _msgQueue = new Queue<DicomMessage>(); _pending = new List<DicomRequest>(); _isConnected = true; _fallbackEncoding = fallbackEncoding ?? DicomEncoding.Default; Logger = log ?? LogManager.GetLogger("Dicom.Network"); Options = new DicomServiceOptions(); BackgroundWorker = ReadAndProcessPDUAsync(); }
protected override void ConstructFromStream(INetworkStream str) { int payloadLen = base.variableHeaderLength; _topic = ReadStringFromStream(str); payloadLen -= (GetUTF8StringLength(_topic) + 2); if (msgQos != QoS.BestEfforts) { _messageID = ReadUshortFromStream(str); payloadLen -= 2; } _payload = new byte[payloadLen]; ReadCompleteBuffer(str, _payload); }
public PrintService(INetworkStream stream, Encoding fallbackEncoding, Dicom.Log.Logger log) : base(stream, fallbackEncoding, log) { var pi = stream.GetType() .GetProperty( "Socket", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance); if (pi != null) { var endPoint = ((System.Net.Sockets.Socket)pi.GetValue(stream, null)).RemoteEndPoint as System.Net.IPEndPoint; RemoteIP = endPoint.Address; } else { RemoteIP = new System.Net.IPAddress(new byte[] { 127, 0, 0, 1 }); } }
public static MqttMessage CreateMessage(INetworkStream str, byte header) { // Look at the fixed header to decide what message type we have MessageType messageType = (MessageType)((header & 0xf0) >> 4); //Log.Write( LogLevel.DEBUG, "Message " + messageType + " received"); switch (messageType) { case MessageType.CONNACK: return new MqttConnackMessage(str, header); case MessageType.DISCONNECT: return null; case MessageType.PINGREQ: return new MqttPingReqMessage(); case MessageType.PUBACK: return new MqttPubackMessage(str, header); case MessageType.PUBCOMP: return new MqttPubcompMessage(str, header); case MessageType.PUBLISH: return new MqttPublishMessage(str, header); case MessageType.PUBREC: return new MqttPubrecMessage(str, header); case MessageType.PUBREL: return new MqttPubrelMessage(str, header); case MessageType.SUBACK: return new MqttSubackMessage(str, header); case MessageType.UNSUBACK: return new MqttUnsubackMessage(str, header); case MessageType.PINGRESP: return new MqttPingRespMessage(str, header); case MessageType.UNSUBSCRIBE: case MessageType.CONNECT: case MessageType.SUBSCRIBE: default: throw new Exception("Unsupported Message Type"); } }
protected override void ConstructFromStream(INetworkStream str) { // Read the message ID that the server is acknowlodging _ackID = ReadUshortFromStream(str); int qosCount = variableHeaderLength - 2; grantedQos = new QoS[qosCount]; for (int i = 0; i < qosCount; i++) { int res = str.ReadByte(); if (res != -1) { grantedQos[i] = (QoS)res; } else { throw new Exception("Failed to read byte from stream"); } } }
public MqttPubackMessage(INetworkStream str, byte header) : base(str, header) { // Nothing to construct }
public static NetworkStream ToImplementation([CanBeNull] this INetworkStream abstraction) { return(((IAbstraction <NetworkStream>)abstraction)?.UnsafeConvert()); }
internal static void Connect(Connection connection, ITcpClient tcpClient, INetworkStream stream) { SetupSuccessfulConnectionExpectations(tcpClient, stream); connection.Connect("server", 10000, "password"); }
/// <summary> /// Constructor. /// </summary> /// <param name="stream">The stream to return the tokens from.</param> /// <param name="bufferLength">The buffer length to read.</param> internal NetworkClient(INetworkStream stream, int bufferLength) { _stream = stream; _bufferLength = bufferLength; }
public ImmediateSuccessAsyncDicomCFindProvider(INetworkStream stream, Encoding fallbackEncoding, Logger log) : base(stream, fallbackEncoding, log) { }
/// <summary> /// Connect to a Folding@Home client server. /// </summary> /// <param name="host">Hostname or IP address.</param> /// <param name="port">TCP port number.</param> /// <param name="password">Server password.</param> /// <exception cref="InvalidOperationException">Connection is already connected.</exception> /// <exception cref="ArgumentNullException"><paramref name="host"/> or <paramref name="password"/> is null.</exception> /// <exception cref="TimeoutException">Connection attempt timed out.</exception> public void Connect(string host, int port, string password) { // check connection status, callers should make sure no connection exists first if (Connected) throw new InvalidOperationException("Client is already connected."); if (host == null) throw new ArgumentNullException("host"); if (password == null) throw new ArgumentNullException("password"); if (_tcpClient != null) { _tcpClient.Dispose(); } _tcpClient = CreateClient(); IAsyncResult ar = _tcpClient.BeginConnect(host, port, null, null); try { if (!ar.AsyncWaitHandle.WaitOne(TimeSpan.FromMilliseconds(ConnectTimeout), false)) { _tcpClient.Close(); throw new TimeoutException("Client connection has timed out."); } _tcpClient.EndConnect(ar); _stream = _tcpClient.GetStream(); if (password.Length != 0) { // send authentication SendCommand("auth " + password); } if (Connected) { // send connected event OnConnectedChanged(new ConnectedChangedEventArgs(true)); // maybe use Connected property? // send status message OnStatusMessage(new StatusMessageEventArgs(String.Format(CultureInfo.CurrentCulture, "Connected to {0}:{1}", host, port), TraceLevel.Info)); // start listening for messages // from the network stream _timer.Start(); } } finally { ar.AsyncWaitHandle.Close(); } }
public NeverRespondingDicomServer(INetworkStream stream, Encoding fallbackEncoding, Logger log) : base(stream, fallbackEncoding, log) { _requests = new ConcurrentBag <DicomRequest>(); }
public ChunkedEncoding(INetworkStream serverStream, INetworkStream browserStream) { buffer = new byte[BufferSize]; this.serverStream = serverStream; this.browserStream = browserStream; }
public QRService(INetworkStream stream, Encoding fallbackEncoding, ILogger log, ILogManager logmanager, INetworkManager network, ITranscoderManager transcoder) : base(stream, fallbackEncoding, log, logmanager, network, transcoder) { /* initialization per association can be done here */ }
public CStoreScp(INetworkStream stream, Encoding fallbackEncoding, Logger log, ILogManager logManager, INetworkManager networkManager, ITranscoderManager transcoderManager) : base(stream, fallbackEncoding, log, logManager, networkManager, transcoderManager) { }
public SimpleStorageComitmentProvider(INetworkStream stream, Encoding fallbackEncoding, Logger log) : base(stream, fallbackEncoding, log) { }
public SlowPendingResponsesDicomServer(INetworkStream stream, Encoding fallbackEncoding, Logger log) : base(stream, fallbackEncoding, log) { }
public SimpleCStoreProvider(INetworkStream stream, Encoding fallbackEncoding, Logger log) : base(stream, fallbackEncoding, log) { }
public CFindSCP(INetworkStream stream, Encoding fallbackEncoding, Logger log) : base(stream, fallbackEncoding, log) { m_WorklistRepository = new WorklistRepository(); }
public void Dispose() { if (_stream != null) { _logger.LogMessage("Socket", LogLevel.Verbose, "Closing existing network stream."); _stream.Close(); // also closes the socket _stream = null; } _socket = null; }
//--------------------------------------------------------------------- // Ctor //--------------------------------------------------------------------- public FragmentingStream(INetworkStream stream) { this.stream = stream; }
private INetworkStream GetStream() { if (_stream == null) { lock (_streamCreationLock) { if (_stream == null) { if (_encryptionLevel == SslProtocols.None) { _stream = new UnsecureStream(_socket); } else { try { _stream = new SecureStream(_remoteHost, _socket, _caCert, _encryptionLevel); } catch (SocketException ex) { if (ex.ErrorCode == -1) { var detail = new ErrorContextException("The remote certificate is invalid according to the validation procedure.", ex); throw detail; } throw; } } } } } return _stream; }
public CStoreSCPProvider(INetworkStream stream, Encoding fallbackEncoding, Logger log) : base(stream, fallbackEncoding, log) { _pacsReader = new PacsNodeReader(); }
protected override void ConstructFromStream(INetworkStream str) { byte[] buffer = new byte[2]; ReadCompleteBuffer(str, buffer); _response = (MqttConnectionResponse)buffer[1]; }
protected static byte[] ReadCompleteBuffer(INetworkStream str, byte[] buffer) { int read = 0; while (read < buffer.Length) { int res = str.Stream.Read(buffer, read, buffer.Length - read); if (res == -1) { throw new Exception("End of stream reached whilst filling buffer"); } read += res; } return buffer; }
public DicomCEchoProvider(INetworkStream stream, Encoding fallbackEncoding, Logger log) : base(stream, fallbackEncoding, log) { }
protected static ushort ReadUshortFromStream(INetworkStream str) { // Read two bytes and interpret as ushort in Network Order byte[] data = new byte[2]; ReadCompleteBuffer( str, data ); return (ushort)((data[0] << 8) + data[1]); }
public PendingAsyncDicomCFindProvider(INetworkStream stream, Encoding fallbackEncoding, Logger log) : base(stream, fallbackEncoding, log) { }
/// <summary> /// Decodes the length of the variable header and payload from the given stream /// </summary> /// <param name="str">Input Stream</param> /// <returns>Length of the variable header and the payload</returns> private int DecodeVariableHeaderLength(INetworkStream str) { int multiplier = 1 ; int value = 0 ; int digit = 0; do { digit = str.ReadByte(); if (digit == -1) { return 0; } value += (digit & 127) * multiplier; multiplier *= 128; } while ((digit & 128) != 0); return value; }
/// <summary> /// Relay all received by one stream to another stream. /// </summary> public static Task RelayToAsync( this INetworkStream readStream, INetworkStream writeStream, CancellationToken token) { return(Task.Run(async() => { // Use a buffer that is as large as possible, but does not exceed // any of the two stream's capabilities. int bufferSize = Math.Min( writeStream.MaxWriteSize, Math.Max( MaxBufferSize, readStream.MinReadSize)); var buffer = new byte[bufferSize]; while (true) { token.ThrowIfCancellationRequested(); try { TraceSources.Compute.TraceVerbose($"NetworkStream [{readStream} > {writeStream}]: Reading..."); int bytesRead = await readStream.ReadAsync( buffer, 0, buffer.Length, token).ConfigureAwait(false); if (bytesRead > 0) { TraceSources.Compute.TraceVerbose($"NetworkStream [{readStream} > {writeStream}]: Read {bytesRead} bytes"); await writeStream.WriteAsync(buffer, 0, bytesRead, token).ConfigureAwait(false); } else { TraceSources.Compute.TraceVerbose($"NetworkStream [{readStream} > {writeStream}]: gracefully closed connection"); // Propagate. await writeStream.CloseAsync(token).ConfigureAwait(false); break; } } catch (NetworkStreamClosedException) { TraceSources.Compute.TraceVerbose($"NetworkStream [{readStream} > {writeStream}]: forcefully closed connection"); // Propagate. await writeStream.CloseAsync(token).ConfigureAwait(false); break; } catch (Exception) { TraceSources.Compute.TraceVerbose($"NetworkStream [{readStream} > {writeStream}]: Caught unhandled exception"); throw; } } })); }
public SimpleAssociationAcceptProvider(INetworkStream stream, Encoding fallbackEncoding, Logger log) : base(stream, fallbackEncoding, log) { }
public CStoreSCP(INetworkStream stream, Encoding fallbackEncoding, Logger log) : base(stream, fallbackEncoding, log) { }
private static void SetupSuccessfulConnectionExpectations(ITcpClient tcpClient, INetworkStream stream, bool withPassword = true) { // setup connect expectations var asyncResult = MockRepository.GenerateStub <IAsyncResult>(); tcpClient.Expect(x => x.BeginConnect("server", 10000, null, null)).Return(asyncResult); asyncResult.Stub(x => x.AsyncWaitHandle).Return(new EventWaitHandle(true, EventResetMode.ManualReset)); tcpClient.Expect(x => x.Client).Return(new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)).Repeat.AtLeastOnce(); tcpClient.Expect(x => x.EndConnect(asyncResult)).Do(new Action <IAsyncResult>(ar => { // setup Connected property expectations tcpClient.Expect(x => x.Connected).Return(true).Repeat.AtLeastOnce(); })); tcpClient.Expect(x => x.GetStream()).Return(stream); if (withPassword) { // setup SendCommand() expectation stream.Expect(x => x.BeginWrite(null, 0, 0, null, null)).IgnoreArguments().Do( new Func <byte[], int, int, AsyncCallback, object, IAsyncResult>(TestUtilities.DoBeginWrite)).Repeat.AtLeastOnce(); } }
protected static string ReadStringFromStream(INetworkStream str) { ushort len = ReadUshortFromStream(str); byte[] data = new byte[len]; ReadCompleteBuffer(str, data); UTF8Encoding enc = new UTF8Encoding(); return enc.GetString(data, 0, data.Length); }
public CStoreScp(INetworkStream stream, Encoding fallbackEncoding, Logger log) : base(stream, fallbackEncoding, log) { }
/// <summary> /// Concrete Message classes should extract their variable header and payload from the given stream /// </summary> /// <param name="str">Input Stream</param> protected virtual void ConstructFromStream(INetworkStream str) { throw new Exception("Protocol does not support receiving this type of message"); }
/// <summary> /// Abort DICOM service connection. /// </summary> public void Abort() { if (this.aborted) return; if (this.associateNotifier != null && !this.associateNotifier.Task.IsCompleted) { this.associateNotifier.TrySetResult(false); } if (this.completeNotifier != null) this.completeNotifier.TrySetResult(true); if (this.networkStream != null) { try { this.networkStream.Dispose(); } catch { } } this.service = null; this.networkStream = null; this.aborted = true; }
//------------------------------------------------------------------------------ // // Method: ReadAndParseMessageData // //------------------------------------------------------------------------------ /// <summary> /// Reads bytes from the inputted network stream and parses them, storing the results in the inputted parameters. /// </summary> /// <param name="networkStream">The network stream to read data from.</param> /// <param name="parseState">Represents the current state of parsing.</param> /// <param name="messageSequenceNumberBytes">The bytes containing the message sequence number.</param> /// <param name="messageSequenceNumberCurrentPosition">The current read position within the message sequence number bytes.</param> /// <param name="messageSequenceNumber">The message sequence number.</param> /// <param name="messageSizeHeaderBytes">The header bytes containing the message size.</param> /// <param name="messageSizeHeaderCurrentPosition">The current read position within the message size header bytes.</param> /// <param name="messageSize">The size of the message body.</param> /// <param name="messageBytes">The bytes containing the message body.</param> private void ReadAndParseMessageData(INetworkStream networkStream, ref MessageParseState parseState, byte[] messageSequenceNumberBytes, ref int messageSequenceNumberCurrentPosition, ref int messageSequenceNumber, byte[] messageSizeHeaderBytes, ref int messageSizeHeaderCurrentPosition, ref long messageSize, Queue <byte> messageBytes) { int availableBytes = client.Available; if (availableBytes > 0) { byte[] tempBuffer = new byte[availableBytes]; // Temporary buffer to store bytes read from the network before parsing networkStream.Read(ref tempBuffer, 0, availableBytes); // Iterate through the bytes in the buffer, advancing the parse state as successive sections (i.e. start delimiter, sequence number, size header, body, etc...) are read for (int i = 0; i < tempBuffer.Length; i = i + 1) { switch (parseState) { case MessageParseState.StartOfMessage: if (tempBuffer[i] != messageStartDelimiter) { throw new Exception("First byte of received message was expected to be " + messageStartDelimiter.ToString() + ", but was " + tempBuffer[i].ToString() + "."); } else { parseState = MessageParseState.ReadStartDelimiter; } break; case MessageParseState.ReadStartDelimiter: messageSequenceNumberBytes[messageSequenceNumberCurrentPosition] = tempBuffer[i]; messageSequenceNumberCurrentPosition++; // If 4 bytes have been read into the sequence number byte array, then set the sequence number, and advance to the next parse state if (messageSequenceNumberCurrentPosition == 4) { // Decode as little endian if (BitConverter.IsLittleEndian == false) { Array.Reverse(messageSequenceNumberBytes); } messageSequenceNumber = BitConverter.ToInt32(messageSequenceNumberBytes, 0); parseState = MessageParseState.ReadSequenceNumber; } break; case MessageParseState.ReadSequenceNumber: messageSizeHeaderBytes[messageSizeHeaderCurrentPosition] = tempBuffer[i]; messageSizeHeaderCurrentPosition++; // If 8 bytes have been read into the message size header byte array, then set the message size, and advance to the next parse state if (messageSizeHeaderCurrentPosition == 8) { // Decode as little endian if (BitConverter.IsLittleEndian == false) { Array.Reverse(messageSizeHeaderBytes); } messageSize = BitConverter.ToInt64(messageSizeHeaderBytes, 0); parseState = MessageParseState.ReadSizeHeader; } break; case MessageParseState.ReadSizeHeader: messageBytes.Enqueue(tempBuffer[i]); // If the number of bytes read matches the size specified in the header, advance to the next parse state if (messageBytes.Count == messageSize) { parseState = MessageParseState.ReadMessageBody; } break; case MessageParseState.ReadMessageBody: if (tempBuffer[i] != messageEndDelimiter) { throw new Exception("Last byte of received message was expected to be " + messageEndDelimiter.ToString() + ", but was " + tempBuffer[i].ToString() + "."); } else { parseState = MessageParseState.ReadCompleteMessage; } break; case MessageParseState.ReadCompleteMessage: throw new Exception("Surplus data encountered after message delimiter character, starting with " + tempBuffer[i].ToString() + "."); } } } }
public AcceptOnlyEchoStoreProvider(INetworkStream stream, Encoding fallbackEncoding, Logger log) : base(stream, fallbackEncoding, log) { AcceptedSopClasses.Add(DicomUID.Verification); AcceptedSopClasses.AddRange(DicomUID.Enumerate().Where(u => u.IsImageStorage)); }
protected override void ConstructFromStream(INetworkStream str) { // Nothing to construct }
public ImmediateSuccessAsyncDicomCFindProvider(INetworkStream stream, Encoding fallbackEncoding, Logger log, ILogManager logManager, INetworkManager networkManager, ITranscoderManager transcoderManager) : base(stream, fallbackEncoding, log, logManager, networkManager, transcoderManager) { }
/// <summary> /// Asynchonously send existing requests to DICOM service. /// </summary> /// <param name="host">DICOM host.</param> /// <param name="port">Port.</param> /// <param name="useTls">Treu if TLS security should be enabled, false otherwise.</param> /// <param name="callingAe">Calling Application Entity Title.</param> /// <param name="calledAe">Called Application Entity Title.</param> /// <returns>Awaitable task.</returns> public async Task SendAsync(string host, int port, bool useTls, string callingAe, string calledAe) { if (!this.CanSend) return; var noDelay = this.Options != null ? this.Options.TcpNoDelay : DicomServiceOptions.Default.TcpNoDelay; var ignoreSslPolicyErrors = (this.Options ?? DicomServiceOptions.Default).IgnoreSslPolicyErrors; this.networkStream = NetworkManager.CreateNetworkStream(host, port, useTls, noDelay, ignoreSslPolicyErrors); this.InitializeSend(this.networkStream.AsStream(), callingAe, calledAe); await this.completeNotifier.Task.ConfigureAwait(false); this.FinalizeSend(); }
public SimpleStorageComitmentProvider(INetworkStream stream, Encoding fallbackEncoding, ILogger log, ILogManager logManager, INetworkManager networkManager, ITranscoderManager transcoderManager) : base(stream, fallbackEncoding, log, logManager, networkManager, transcoderManager) { }
private void FinalizeSend() { if (!this.associateNotifier.Task.IsCompleted) { this.associateNotifier.TrySetResult(true); } if (this.networkStream != null) { try { this.networkStream.Dispose(); } catch { } } this.service = null; this.networkStream = null; }
public WorklistService(INetworkStream stream, Encoding fallbackEncoding, Logger log) : base(stream, fallbackEncoding, log) { }
protected override void ConstructFromStream(INetworkStream str) { _ackID = ReadUshortFromStream(str); }
public void Send(IMessage message, INetworkStream outputStream) { var serialized = serializer.Serialize(message); outputStream.Write(serialized, 0, serialized.Length); }
private void CreateSocket(AddressFamily addressFamily) { if (_stream != null) { _logger.LogMessage("Socket", LogLevel.Verbose, "Closing existing network stream."); _stream.Close(); // also closes the socket _stream = null; _socket = null; } _socket = new Socket(addressFamily, SocketType.Stream, ProtocolType.Tcp); //_socket.ReceiveTimeout = MqttProtocolInformation.Settings.NetworkTimeout * 1000; //_socket.SendTimeout = MqttProtocolInformation.Settings.NetworkTimeout * 1000; }
public DicomClientConnection(DicomClient dicomClient, INetworkStream networkStream) : base(networkStream, dicomClient.FallbackEncoding, dicomClient.Logger) { DicomClient = dicomClient; NetworkStream = networkStream; }
/// <summary> /// Close the connection to the Folding@Home client server. /// </summary> public void Close() { // stop the timer _timer.Stop(); // close the network stream if (_stream != null) { _stream.Close(); } // remove reference to the network stream _stream = null; // close the actual connection _tcpClient.Close(); // send connected event OnConnectedChanged(new ConnectedChangedEventArgs(false)); // maybe use Connected property? // send status message OnStatusMessage(new StatusMessageEventArgs("Connection closed.", TraceLevel.Info)); }
public AsyncDicomCStoreProviderPreferingUncompressedTS(INetworkStream stream, Encoding fallbackEncoding, Logger log) : base(stream, fallbackEncoding, log) { }
/// <summary> /// Construct a MqttConneckMessage from a stream /// </summary> /// <param name="str"></param> /// <param name="header"></param> public MqttConnackMessage(INetworkStream str, byte header) : base(str, header) { }
public AsyncDicomCStoreProvider(INetworkStream stream, Encoding fallbackEncoding, Logger log) : base(stream, fallbackEncoding, log) { }
public MockCEchoProvider(INetworkStream stream, Encoding fallbackEncoding, Logger log) : base(stream, fallbackEncoding, log) { }
public AsyncDicomCStoreProvider(INetworkStream stream, Encoding fallbackEncoding, Logger log, ILogManager logManager, INetworkManager networkManager, ITranscoderManager transcoderManager) : base(stream, fallbackEncoding, log, logManager, networkManager, transcoderManager) { }