coap_server_misc.c

Go to the documentation of this file.

/**
 * @file coap_server_misc.c
 * @brief Helper functions for CoAP server
 *
 * @section License
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 *
 * Copyright (C) 2010-2026 Oryx Embedded SARL. All rights reserved.
 *
 * This file is part of CycloneTCP Open.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 * @author Oryx Embedded SARL (www.oryx-embedded.com)
 * @version 2.6.4
 **/
 
//Switch to the appropriate trace level
#define TRACE_LEVEL COAP_TRACE_LEVEL
 
//Dependencies
#include <stdlib.h>
#include "coap/coap_server.h"
#include "coap/coap_server_observe.h"
#include "coap/coap_server_transport.h"
#include "coap/coap_server_misc.h"
#include "coap/coap_common.h"
#include "coap/coap_debug.h"
#include "debug.h"
 
//Check TCP/IP stack configuration
#if (COAP_SERVER_SUPPORT == ENABLED)
 
 
/**
 * @brief Handle periodic operations
 * @param[in] context Pointer to the CoAP server context
 **/
 
void coapServerTick(CoapServerContext *context)
{
#if (COAP_SERVER_DTLS_SUPPORT == ENABLED)
   error_t error;
   uint_t i;
   systime_t time;
   TlsState state;
   CoapDtlsSession *session;
 
   //Get current time
   time = osGetSystemTime();
 
   //Loop through DTLS sessions
   for(i = 0; i < context->numSessions; i++)
   {
      //Point to the current DTLS session
      session = &context->sessions[i];
 
      //Valid DTLS session?
      if(session->dtlsContext != NULL)
      {
         //Implementations should limit the lifetime of established sessions
         if((time - session->timestamp) >= COAP_SERVER_SESSION_TIMEOUT)
         {
            //Debug message
            TRACE_INFO("CoAP Server: DTLS session timeout!\r\n");
 
            //Send a close notify alert to the client
            tlsShutdown(session->dtlsContext);
            //Release DTLS session
            coapServerDeleteSession(session);
         }
         else
         {
            //Retrieve current state
            state = tlsGetState(session->dtlsContext);
 
            //DTLS handshake in progress?
            if(state < TLS_STATE_APPLICATION_DATA)
            {
               //Continue DTLS handshake
               error = tlsConnect(session->dtlsContext);
            }
            else
            {
               //Handle periodic operations
               error = tlsTick(session->dtlsContext);
            }
 
            //Any error to report?
            if(error != NO_ERROR &&
               error != ERROR_TIMEOUT &&
               error != ERROR_WOULD_BLOCK)
            {
               //Debug message
               TRACE_INFO("CoAP Server: DTLS handshake failed!\r\n");
 
               //Release DTLS session
               coapServerDeleteSession(session);
            }
         }
      }
   }
#endif
 
#if (COAP_SERVER_OBSERVE_SUPPORT == ENABLED)
   //Process observe-related events
   coapServerProcessObserveEvents(context);
#endif
}
 
 
/**
 * @brief Process CoAP message
 * @param[in] context Pointer to the CoAP server context
 * @param[in] data Pointer to the incoming CoAP message
 * @param[in] length Length of the CoAP message, in bytes
 * @return Error code
 **/
 
error_t coapServerProcessMessage(CoapServerContext *context,
   const uint8_t *data, size_t length)
{
   error_t error;
   CoapMessageType type;
 
   //Check the length of the CoAP message
   if(length > COAP_MAX_MSG_SIZE)
      return ERROR_INVALID_LENGTH;
 
   //Copy the request message
   osMemcpy(context->request.buffer, data, length);
 
   //Save the length of the request message
   context->request.length = length;
   context->request.pos = 0;
 
   //Parse the received message
   error = coapParseMessage(&context->request);
 
   //Valid CoAP message?
   if(error == NO_ERROR)
   {
      //Terminate the payload with a NULL character
      context->request.buffer[context->request.length] = '\0';
 
      //Debug message
      TRACE_INFO("CoAP Server: CoAP message received (%" PRIuSIZE " bytes)...\r\n",
         context->request.length);
 
      //Dump the contents of the message for debugging purpose
      coapDumpMessage(context->request.buffer, context->request.length);
 
      //Retrieve message type
      coapGetType(&context->request, &type);
 
      //Check the type of the message
      if(type == COAP_TYPE_CON || type == COAP_TYPE_NON)
      {
         //CoAP requests are carried in Confirmable or non-confirmable messages
         error = coapServerProcessRequest(context);
      }
      else if(type == COAP_TYPE_ACK)
      {
#if (COAP_SERVER_OBSERVE_SUPPORT == ENABLED)
         //An Acknowledgement message acknowledges that a specific Confirmable
         //message arrived
         error = coapServerProcessAck(context);
#else
         //Recipients of Acknowledgement and Reset messages must not respond
         //with either Acknowledgement or Reset messages
         error = ERROR_INVALID_MESSAGE;
#endif
      }
      else if(type == COAP_TYPE_RST)
      {
#if (COAP_SERVER_OBSERVE_SUPPORT == ENABLED)
         //A Reset message indicates that a specific message (Confirmable or
         //Non-confirmable) was received, but some context is missing to
         //properly process it
         error = coapServerProcessReset(context);
#else
         //Recipients of Acknowledgement and Reset messages must not respond
         //with either Acknowledgement or Reset messages
         error = ERROR_INVALID_MESSAGE;
#endif
      }
      else
      {
         //Invalid message type
         error = ERROR_INVALID_MESSAGE;
      }
   }
   else if(error == ERROR_INVALID_HEADER || error == ERROR_INVALID_VERSION)
   {
      //Messages with a size smaller than four bytes or with unknown version
      //numbers must be silently ignored (refer to RFC 7252, section 3)
   }
   else
   {
      //Other message format errors, such as an incomplete datagram or the
      //usage of reserved values, are rejected with a Reset message
      error = coapServerRejectRequest(context);
   }
 
   //Check status code
   if(!error)
   {
      //Any response?
      if(context->response.length > 0)
      {
         //Debug message
         TRACE_INFO("CoAP Server: Sending CoAP message (%" PRIuSIZE " bytes)...\r\n",
            context->response.length);
 
         //Dump the contents of the message for debugging purpose
         coapDumpMessage(context->response.buffer, context->response.length);
 
         //Send CoAP response message
         error = coapServerSendResponse(context, context->response.buffer,
            context->response.length);
      }
   }
 
   //Return status code
   return error;
}
 
 
/**
 * @brief Process CoAP request
 * @param[in] context Pointer to the CoAP server context
 * @return Error code
 **/
 
error_t coapServerProcessRequest(CoapServerContext *context)
{
   error_t error;
   CoapCode code;
 
   //Initialize CoAP response
   coapServerInitResponse(context);
 
   //The Code field 8-bit unsigned integer, split into a 3-bit class (most
   //significant bits) and a 5-bit detail (least significant bits)
   coapGetCode(&context->request, &code);
 
   //In case of a request, the Code field indicates the request method
   if(code == COAP_CODE_GET ||
      code == COAP_CODE_POST ||
      code == COAP_CODE_PUT ||
      code == COAP_CODE_DELETE ||
      code == COAP_CODE_FETCH ||
      code == COAP_CODE_PATCH ||
      code == COAP_CODE_IPATCH)
   {
      //Reconstruct the path component from Uri-Path options
      coapJoinRepeatableOption(&context->request, COAP_OPT_URI_PATH,
         context->uri, COAP_SERVER_MAX_URI_LEN, '/');
 
      //If the resource name is the empty string, set it to a single "/"
      //character (refer to RFC 7252, section 6.5)
      if(context->uri[0] == '\0')
      {
         osStrcpy(context->uri, "/");
      }
 
      //Initialize status code
      error = ERROR_NOT_FOUND;
 
#if (COAP_SERVER_OBSERVE_SUPPORT == ENABLED)
      //GET request?
      if(code == COAP_CODE_GET)
      {
         //A client registers its interest in a resource by initiating an
         //extended GET request to the server. In addition to returning a
         //representation of the target resource, this request causes the
         //server to add the client to the list of observers of the resource
         error = coapServerProcessRegistrationRequest(context);
      }
#endif
 
      //Check status code
      if(error == ERROR_NOT_FOUND)
      {
         //Any registered callback?
         if(context->requestCallback != NULL)
         {
            //Invoke user callback function
            error = context->requestCallback(context, code, context->uri);
         }
      }
 
      //Check status code
      if(error == ERROR_NOT_FOUND)
      {
         //Generate a 4.04 piggybacked response
         error = coapSetCode(&context->response, COAP_CODE_NOT_FOUND);
      }
   }
   else if(code == COAP_CODE_EMPTY)
   {
      //Provoking a Reset message by sending an Empty Confirmable message
      //can be used to check of the liveness of an endpoint (refer to
      //RFC 7252, section 4.3)
      error = coapServerRejectRequest(context);
   }
   else
   {
      //A request with an unrecognized or unsupported method code must
      //generate a 4.05 piggybacked response (refer to RFC 7252, section
      //5.8)
      error = coapSetCode(&context->response, COAP_CODE_METHOD_NOT_ALLOWED);
   }
 
   //Return status code
   return error;
}
 
 
/**
 * @brief Reject a CoAP request
 * @param[in] context Pointer to the CoAP server context
 * @return Error code
 **/
 
error_t coapServerRejectRequest(CoapServerContext *context)
{
   error_t error;
   const CoapMessageHeader *header;
 
   //Initialize status code
   error = NO_ERROR;
 
   //Debug message
   TRACE_INFO("CoAP Server: Rejecting CoAP message...\r\n");
 
   //Point to the CoAP message header
   header = (CoapMessageHeader *) &context->request.buffer;
 
   //Check the type of the request
   if(header->type == COAP_TYPE_CON)
   {
      //Rejecting a Confirmable message is effected by sending a matching
      //Reset message
      error = coapServerFormatReset(context, ntohs(header->mid));
   }
   else if(header->type == COAP_TYPE_NON)
   {
      //Rejecting a Non-confirmable message may involve sending a matching
      //Reset message, and apart from the Reset message the rejected message
      //must be silently ignored (refer to RFC 7252, section 4.3)
      error = coapServerFormatReset(context, ntohs(header->mid));
   }
   else
   {
      //Rejecting an Acknowledgment or Reset message is effected by silently
      //ignoring it (refer to RFC 7252, section 4.2)
      context->response.length = 0;
   }
 
   //Return status code
   return error;
}
 
 
/**
 * @brief Initialize CoAP response
 * @param[in] context Pointer to the CoAP server context
 * @return Error code
 **/
 
error_t coapServerInitResponse(CoapServerContext *context)
{
   CoapMessageHeader *requestHeader;
   CoapMessageHeader *responseHeader;
 
   //Point to the CoAP request header
   requestHeader = (CoapMessageHeader *) context->request.buffer;
   //Point to the CoAP response header
   responseHeader = (CoapMessageHeader *) context->response.buffer;
 
   //Format message header
   responseHeader->version = COAP_VERSION_1;
   responseHeader->tokenLen = requestHeader->tokenLen;
   responseHeader->code = COAP_CODE_INTERNAL_SERVER;
   responseHeader->mid = requestHeader->mid;
 
   //If immediately available, the response to a request carried in a
   //Confirmable message is carried in an Acknowledgement (ACK) message
   if(requestHeader->type == COAP_TYPE_CON)
   {
      responseHeader->type = COAP_TYPE_ACK;
   }
   else
   {
      responseHeader->type = COAP_TYPE_NON;
   }
 
   //The token is used to match a response with a request
   osMemcpy(responseHeader->token, requestHeader->token,
      requestHeader->tokenLen);
 
   //Set the length of the CoAP message
   context->response.length = sizeof(CoapMessageHeader) + responseHeader->tokenLen;
   context->response.pos = 0;
 
   //Successful processing
   return NO_ERROR;
}
 
 
/**
 * @brief Send CoAP response
 * @param[in] context Pointer to the CoAP server context
 * @param[in] data Pointer to a buffer containing the response message
 * @param[in] length Length of the response message, in bytes
 * @return Error code
 **/
 
error_t coapServerSendResponse(CoapServerContext *context,
   const void *data, size_t length)
{
   error_t error;
 
#if (COAP_SERVER_DTLS_SUPPORT == ENABLED)
   //DTLS-secured communication?
   if(context->dtlsInitCallback != NULL)
   {
      uint_t i;
      CoapDtlsSession *session;
 
      //Loop through DTLS sessions
      for(i = 0; i < context->numSessions; i++)
      {
         //Point to the current DTLS session
         session = &context->sessions[i];
 
         //Valid DTLS session?
         if(session->dtlsContext != NULL)
         {
            //Matching DTLS session?
            if(session->interface == context->localInterface &&
               ipCompAddr(&session->serverIpAddr, &context->localIpAddr) &&
               ipCompAddr(&session->clientIpAddr, &context->remoteIpAddr) &&
               session->clientPort == context->remotePort)
            {
               break;
            }
         }
      }
 
      //Any matching DTLS session?
      if(i < context->numSessions)
      {
         //Send DTLS datagram
         error = tlsWrite(session->dtlsContext, data, length, NULL, 0);
      }
      else
      {
         //Report an error
         error = ERROR_FAILURE;
      }
   }
   else
#endif
   {
      SocketMsg msg;
 
      //Point to the send buffer
      msg = SOCKET_DEFAULT_MSG;
      msg.data = (void *) data;
      msg.length = length;
 
      //Set the source and destination IP addresses
      msg.interface = context->localInterface;
      msg.srcIpAddr = context->localIpAddr;
      msg.destIpAddr = context->remoteIpAddr;
      msg.destPort = context->remotePort;
 
      //Send datagram
      error = socketSendMsg(context->socket, &msg, 0);
   }
 
   //Return status code
   return error;
}
 
 
/**
 * @brief Format Reset message
 * @param[in] context Pointer to the CoAP server context
 * @param[in] mid Message ID
 * @return Error code
 **/
 
error_t coapServerFormatReset(CoapServerContext *context, uint16_t mid)
{
   CoapMessageHeader *header;
 
   //Point to the CoAP response header
   header = (CoapMessageHeader *) context->response.buffer;
 
   //Format Reset message
   header->version = COAP_VERSION_1;
   header->type = COAP_TYPE_RST;
   header->tokenLen = 0;
   header->code = COAP_CODE_EMPTY;
 
   //The Reset message message must echo the message ID of the confirmable
   //message and must be empty (refer to RFC 7252, section 4.2)
   header->mid = htons(mid);
 
   //Set the length of the CoAP message
   context->response.length = sizeof(CoapMessageHeader);
 
   //Successful processing
   return NO_ERROR;
}
 
#endif