/// <summary>
/// Handle request received from remote clients
/// </summary>
/// <param name="msgStream">The byte stream that represents a request message</param>
/// <param name="sender">The remote sender endpoint</param>
protected virtual void ProcessRequestMessageReceived(byte[] msgStream, ref EndPoint sender)
{
CoAPRequest coapReq = new CoAPRequest();
IPEndPoint remoteSender = (IPEndPoint)sender;
try
{
coapReq.FromByteStream(msgStream);
coapReq.RemoteSender = new IPEndPoint(remoteSender.Address, remoteSender.Port); //Setup who sent this message
//setup the default values of host and port
if (!coapReq.Options.HasOption(CoAPHeaderOption.URI_HOST))
{
coapReq.Options.AddOption(CoAPHeaderOption.URI_HOST, AbstractByteUtils.StringToByteUTF8(this._host));
}
if (!coapReq.Options.HasOption(CoAPHeaderOption.URI_PORT))
{
coapReq.Options.AddOption(CoAPHeaderOption.URI_PORT, AbstractByteUtils.GetBytes((UInt16)this._port));
}
if (coapReq.MessageType.Value == CoAPMessageType.CON &&
coapReq.Code.Value == CoAPMessageCode.EMPTY)
{
//This is a PING..send a RST
this.RespondToPing(coapReq);
}
else
{
this.HandleRequestReceived(coapReq);//Other messages, let program handle it
}
}
catch
{
;//TOCHECK::Do nothing, we do not want to crash the server just because we
//could not process one received message...will check later how to improve this
}
}
/// <summary>
/// This thread continuously looks for messages on the socket
/// Once available, it will post them for handling downstream
/// </summary>
protected void ProcessReceivedMessages()
{
byte[] buffer = null;
int maxSize = AbstractNetworkUtils.GetMaxMessageSize();
while (!this._isDone)
{
Thread.Sleep(1000);
try
{
if (this._clientSocket.Available >= 4 /*Min size of CoAP block*/)
{
buffer = new byte[maxSize * 2];
int bytesRead = this._clientSocket.Receive(buffer);
byte[] udpMsg = new byte[bytesRead];
Array.Copy(buffer, udpMsg, bytesRead);
byte mType = AbstractCoAPMessage.PeekMessageType(udpMsg);
if ((mType == CoAPMessageType.CON ||
mType == CoAPMessageType.NON) && AbstractCoAPMessage.PeekIfMessageCodeIsRequestCode(udpMsg))
{
//This is a request
CoAPRequest coapReq = new CoAPRequest();
coapReq.FromByteStream(udpMsg);
coapReq.RemoteSender = this._remoteEP;//Setup who sent this message
string uriHost = ((IPEndPoint)this._remoteEP).Address.ToString();
UInt16 uriPort = (UInt16)((IPEndPoint)this._remoteEP).Port;
//setup the default values of host and port
//setup the default values of host and port
if (!coapReq.Options.HasOption(CoAPHeaderOption.URI_HOST))
{
coapReq.Options.AddOption(CoAPHeaderOption.URI_HOST, AbstractByteUtils.StringToByteUTF8(uriHost));
}
if (!coapReq.Options.HasOption(CoAPHeaderOption.URI_PORT))
{
coapReq.Options.AddOption(CoAPHeaderOption.URI_PORT, AbstractByteUtils.GetBytes(uriPort));
}
this.HandleRequestReceived(coapReq);
}
else
{
//This is a response
CoAPResponse coapResp = new CoAPResponse();
coapResp.FromByteStream(udpMsg);
coapResp.RemoteSender = this._remoteEP;//Setup who sent this message
//Remove the waiting confirmable message from the timeout queue
if (coapResp.MessageType.Value == CoAPMessageType.ACK ||
coapResp.MessageType.Value == CoAPMessageType.RST)
{
this._msgPendingAckQ.RemoveFromWaitQ(coapResp.ID.Value);
}
this.HandleResponseReceived(coapResp);
}
}
}
catch (SocketException se)
{
//Close this client connection
this._isDone = true;
this.HandleError(se, null);
}
catch (ArgumentNullException argEx)
{
this.HandleError(argEx, null);
}
catch (ArgumentException argEx)
{
this.HandleError(argEx, null);
}
catch (CoAPFormatException fEx)
{
//Invalid message..
this.HandleError(fEx, null);
}
}
}
/// <summary>
/// Receive a message from the server. This will block if there
/// are no messages. Please note, you must handle all errors (except timeout)
/// and no error is raised.
/// </summary>
/// <param name="rxTimeoutMillis">
/// The timeout value in milliseconds.The default value is 0, which indicates an infinite time-out period.
/// Specifying -1 also indicates an infinite time-out period
/// </param>
/// <param name="timedOut">Is set to true on timeout</param>
/// <returns>An instance of AbstractCoAPMessage on success, else null on error/timeout</returns>
public AbstractCoAPMessage ReceiveMessage(int rxTimeoutMillis, ref bool timedOut)
{
byte[] buffer = null;
int maxSize = AbstractNetworkUtils.GetMaxMessageSize();
CoAPRequest coapReq = null;
CoAPResponse coapResp = null;
try
{
this._clientSocket.ReceiveTimeout = rxTimeoutMillis;
buffer = new byte[maxSize * 2];
int bytesRead = this._clientSocket.Receive(buffer);
byte[] udpMsg = new byte[bytesRead];
Array.Copy(buffer, udpMsg, bytesRead);
byte mType = AbstractCoAPMessage.PeekMessageType(udpMsg);
if ((mType == CoAPMessageType.CON ||
mType == CoAPMessageType.NON) && AbstractCoAPMessage.PeekIfMessageCodeIsRequestCode(udpMsg))
{
//This is a request
coapReq = new CoAPRequest();
coapReq.FromByteStream(udpMsg);
coapReq.RemoteSender = this._remoteEP;//Setup who sent this message
string uriHost = ((IPEndPoint)this._remoteEP).Address.ToString();
UInt16 uriPort = (UInt16)((IPEndPoint)this._remoteEP).Port;
//setup the default values of host and port
//setup the default values of host and port
if (!coapReq.Options.HasOption(CoAPHeaderOption.URI_HOST))
{
coapReq.Options.AddOption(CoAPHeaderOption.URI_HOST, AbstractByteUtils.StringToByteUTF8(uriHost));
}
if (!coapReq.Options.HasOption(CoAPHeaderOption.URI_PORT))
{
coapReq.Options.AddOption(CoAPHeaderOption.URI_PORT, AbstractByteUtils.GetBytes(uriPort));
}
return(coapReq);
}
else
{
//This is a response
coapResp = new CoAPResponse();
coapResp.FromByteStream(udpMsg);
coapResp.RemoteSender = this._remoteEP;//Setup who sent this message
return(coapResp);
}
}
catch (SocketException se)
{
if (se.ErrorCode == (int)SocketError.TimedOut)
{
timedOut = true;
}
else
{
throw se;
}
}
return(null);
}