private bool IsBareRequest(CoapPacket packet, byte[] payload) { var message = CoapMessage.CreateFromBytes(packet.Payload); if (!message.Code.IsRequest()) { return(false); } if (message.Options.Get <Options.Block1>() != null) { return(false); } if (message.Options.Get <Options.Block2>() != null) { return(false); } if (payload != null && !payload.SequenceEqual(message.Payload)) { return(false); } return(true); }
private bool IsBlockSequence(CoapPacket packet, int blockNumber, int blockSize, bool hasMore, byte[] payload) { var message = CoapMessage.CreateFromBytes(packet.Payload); var block = message.Options.Get <Options.Block1>() as Options.BlockBase ?? message.Options.Get <Options.Block2>(); if (block is Options.Block1) { if (!block.Equals(new Options.Block1(blockNumber, blockSize, hasMore))) { return(false); } if (payload != null && !payload.SequenceEqual(message.Payload)) { return(false); } } else if (block is Options.Block2) { if (!block.Equals(new Options.Block2(blockNumber, blockSize, hasMore))) { return(false); } } return(true); }
public virtual Task SendAsync(CoapPacket packet, CancellationToken token) { Debug.WriteLine($"Writing packet {{{string.Join(", ", packet.Payload)}}} {CoapMessage.CreateFromBytes(packet.Payload)}"); return(IsDisposed ? throw new CoapEndpointException("Encdpoint Disposed") : MockSendAsync(packet, token)); }
public void EnqueueReceivePacket(CoapPacket packet) { lock (_receiveQueue) { _receiveQueue.Enqueue(packet); } _receiveEnqueuedEvent.Set(); }
public Task SendAsync(CoapPacket packet, CancellationToken token) { if (!_udpTransport.IsClosed && _dtlsTransport != null) { _dtlsTransport.Send(packet.Payload, 0, packet.Payload.Length); } return(Task.CompletedTask); }
public Task SendAsync(CoapPacket packet, CancellationToken token) { EnsureConnected(); var bytes = packet.Payload; _datagramTransport.Send(bytes, 0, bytes.Length); return(Task.CompletedTask); }
public void EnqueueReceivePacket(CoapPacket packet) { lock (_receiveQueue) { Debug.WriteLine($"MockEndpoint: Enqueing packet {{{string.Join(", ", packet.Payload)}}} {CoapMessage.CreateFromBytes(packet.Payload)}"); _receiveQueue.Enqueue(packet); } _receiveEnqueuedEvent.Set(); }
public override Task MockSendAsync(CoapPacket packet, CancellationToken token) { var request = CoapMessage.CreateFromBytes(packet.Payload); var block = request.Options.Get <Block1>() as BlockBase ?? request.Options.Get <Block2>(); var blockNumber = block != null ? block.BlockNumber : 0; var from = block != null ? (block.BlockNumber * block.BlockSize) : 0; var to = block != null ? Math.Min(from + block.BlockSize, TotalBytes) : BlockSize; CoapMessage response; if (block is Block1) { if (block.BlockSize > BlockSize) { response = BaseResponse.Clone(); switch (Mode) { case MockBlockwiseEndpointMode.ReduceBlockSize: response.Options.Add(new Options.Block1(0, BlockSize, true)); break; case MockBlockwiseEndpointMode.RequestTooLarge: response.Code = CoapMessageCode.RequestEntityTooLarge; break; default: throw new NotImplementedException(); } } else { response = block.IsMoreFollowing ? BaseResponse.Clone() : FinalResponse.Clone(); if (!block.IsMoreFollowing) { response.Options.Add(new Options.Block2(0, BlockSize, TotalBytes > BlockSize)); response.Payload = ByteRange(0, BlockSize); } response.Options.Add(new Options.Block1(block.BlockNumber, block.BlockSize, block.IsMoreFollowing)); response.Code = CoapMessageCode.Continue; } } else //if (block is Block2) { if (block != null && block.BlockSize < BlockSize) { BlockSize = block.BlockSize; to = from + BlockSize; } response = FinalResponse.Clone(); response.Options.Add(new Block2(blockNumber, BlockSize, to < TotalBytes)); response.Payload = ByteRange(from, to); } response.Id = request.Id; response.Token = request.Token; response.Type = CoapMessageType.Acknowledgement; EnqueueReceivePacket(new CoapPacket { Payload = response.ToBytes() }); return(Task.CompletedTask); }
public async Task SendAsync(CoapPacket packet) { if (Client == null) { await BindAsync(); } CoapUdpEndPoint udpDestEndpoint; switch (packet.Endpoint) { case CoapUdpEndPoint udpEndPoint: udpDestEndpoint = udpEndPoint; break; case CoapEndpoint coapEndpoint: int port = coapEndpoint.BaseUri.Port; if (port == -1) { port = coapEndpoint.IsSecure ? Coap.PortDTLS : Coap.Port; } IPAddress address = null; if (coapEndpoint.IsMulticast) { address = _multicastAddressIPv4; } else if (coapEndpoint.BaseUri.HostNameType == UriHostNameType.IPv4 || coapEndpoint.BaseUri.HostNameType == UriHostNameType.IPv6) { address = IPAddress.Parse(coapEndpoint.BaseUri.Host); } else if (coapEndpoint.BaseUri.HostNameType == UriHostNameType.Dns) { // TODO: how do we select the best ip address after looking it up? address = (await Dns.GetHostAddressesAsync(coapEndpoint.BaseUri.Host)).FirstOrDefault(); } else { throw new CoapUdpEndpointException($"Unsupported Uri HostNameType ({coapEndpoint.BaseUri.HostNameType:G}"); } // Check is we still don't have an address if (address == null) { throw new CoapUdpEndpointException($"Can not resolve host name for {coapEndpoint.BaseUri.Host}"); } udpDestEndpoint = new CoapUdpEndPoint(address, port); // TODO: Support sending to IPv6 multicast endpoints as well. break; default: throw new CoapUdpEndpointException($"Unsupported {nameof(CoapPacket)}.{nameof(CoapPacket.Endpoint)} type ({packet.Endpoint.GetType().FullName})"); } try { await Client.SendAsync(packet.Payload, packet.Payload.Length, udpDestEndpoint.Endpoint); } catch (SocketException se) { _logger?.LogInformation($"Failed to send data. {se.GetType().FullName} (0x{se.HResult:x}): {se.Message}", se); } }
public Task SendAsync(CoapPacket packet) => _coapEndpoint.SendAsync(packet);
public async Task SendAsync(CoapPacket packet, CancellationToken token) { //packet has the CoapDtlsServerClientEndPoint which we have to respond to. await packet.Endpoint.SendAsync(packet, token); }
public async Task SendAsync(CoapPacket packet, CancellationToken token) { if (Client == null) { await BindAsync(); } CoapUdpEndPoint udpDestEndpoint; switch (packet.Endpoint) { case CoapUdpEndPoint udpEndPoint: udpDestEndpoint = udpEndPoint; break; case CoapEndpoint coapEndpoint: int port = coapEndpoint.BaseUri.Port; if (port == -1) { port = coapEndpoint.IsSecure ? Coap.PortDTLS : Coap.Port; } IPAddress address = null; if (coapEndpoint.IsMulticast) { address = _multicastAddressIPv4; } else if (coapEndpoint.BaseUri.HostNameType == UriHostNameType.IPv4 || coapEndpoint.BaseUri.HostNameType == UriHostNameType.IPv6) { address = IPAddress.Parse(coapEndpoint.BaseUri.Host); } else if (coapEndpoint.BaseUri.HostNameType == UriHostNameType.Dns) { // TODO: how do we select the best ip address after looking it up? address = (await Dns.GetHostAddressesAsync(coapEndpoint.BaseUri.Host)).FirstOrDefault(); } else { throw new CoapUdpEndpointException($"Unsupported Uri HostNameType ({coapEndpoint.BaseUri.HostNameType:G}"); } // Check is we still don't have an address if (address == null) { throw new CoapUdpEndpointException($"Can not resolve host name for {coapEndpoint.BaseUri.Host}"); } udpDestEndpoint = new CoapUdpEndPoint(address, port); // TODO: Support sending to IPv6 multicast endpoints as well. break; default: throw new CoapUdpEndpointException($"Unsupported {nameof(CoapPacket)}.{nameof(CoapPacket.Endpoint)} type ({packet.Endpoint.GetType().FullName})"); } token.ThrowIfCancellationRequested(); var tcs = new TaskCompletionSource <bool>(); using (token.Register(() => tcs.SetResult(false))) { try { await Task.WhenAny(Client.SendAsync(packet.Payload, packet.Payload.Length, udpDestEndpoint.Endpoint), tcs.Task); if (token.IsCancellationRequested) { Client.Dispose(); // Since UdpClient doesn't provide a mechanism for cancelling an async task. the safest way is to dispose the whole object } } catch (SocketException se) { _logger?.LogInformation($"Failed to send data. {se.GetType().FullName} (0x{se.HResult:x}): {se.Message}", se); } } token.ThrowIfCancellationRequested(); }
public virtual Task MockSendAsync(CoapPacket packet) { return(Task.CompletedTask); }
public virtual Task SendAsync(CoapPacket packet) { return(IsDisposed ? throw new CoapEndpointException("Encdpoint Disposed") : MockSendAsync(packet)); }
public virtual Task SendAsync(CoapPacket packet, CancellationToken token) { return(Task.CompletedTask); }