src/core/api/coap_api.cpp - third_party/openthread - Git at Google

 /*
  *  Copyright (c) 2016, The OpenThread Authors.
  *  All rights reserved.
  *
  *  Redistribution and use in source and binary forms, with or without
  *  modification, are permitted provided that the following conditions are met:
  *  1. Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
  *     documentation and/or other materials provided with the distribution.
  *  3. Neither the name of the copyright holder nor the
  *     names of its contributors may be used to endorse or promote products
  *     derived from this software without specific prior written permission.
  *
  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  *  POSSIBILITY OF SUCH DAMAGE.
  */

 /**
  * @file
  *   This file implements the OpenThread CoAP API.
  */

 #include "openthread-core-config.h"

 #if OPENTHREAD_CONFIG_COAP_API_ENABLE

 #include <openthread/coap.h>

 #include "coap/coap_message.hpp"
 #include "common/as_core_type.hpp"
 #include "common/locator_getters.hpp"

 using namespace ot;

 otMessage *otCoapNewMessage(otInstance *aInstance, const otMessageSettings *aSettings)
 {
     return AsCoreType(aInstance).GetApplicationCoap().NewMessage(Message::Settings::From(aSettings));
 }

 void otCoapMessageInit(otMessage *aMessage, otCoapType aType, otCoapCode aCode)
 {
     AsCoapMessage(aMessage).Init(MapEnum(aType), MapEnum(aCode));
 }

 otError otCoapMessageInitResponse(otMessage *aResponse, const otMessage *aRequest, otCoapType aType, otCoapCode aCode)
 {
     Coap::Message &      response = AsCoapMessage(aResponse);
     const Coap::Message &request  = AsCoapMessage(aRequest);

     response.Init(MapEnum(aType), MapEnum(aCode));
     response.SetMessageId(request.GetMessageId());

     return response.SetTokenFromMessage(request);
 }

 otError otCoapMessageSetToken(otMessage *aMessage, const uint8_t *aToken, uint8_t aTokenLength)
 {
     return AsCoapMessage(aMessage).SetToken(aToken, aTokenLength);
 }

 void otCoapMessageGenerateToken(otMessage *aMessage, uint8_t aTokenLength)
 {
     IgnoreError(AsCoapMessage(aMessage).GenerateRandomToken(aTokenLength));
 }

 otError otCoapMessageAppendContentFormatOption(otMessage *aMessage, otCoapOptionContentFormat aContentFormat)
 {
     return AsCoapMessage(aMessage).AppendContentFormatOption(aContentFormat);
 }

 otError otCoapMessageAppendOption(otMessage *aMessage, uint16_t aNumber, uint16_t aLength, const void *aValue)
 {
     return AsCoapMessage(aMessage).AppendOption(aNumber, aLength, aValue);
 }

 otError otCoapMessageAppendUintOption(otMessage *aMessage, uint16_t aNumber, uint32_t aValue)
 {
     return AsCoapMessage(aMessage).AppendUintOption(aNumber, aValue);
 }

 otError otCoapMessageAppendObserveOption(otMessage *aMessage, uint32_t aObserve)
 {
     return AsCoapMessage(aMessage).AppendObserveOption(aObserve);
 }

 otError otCoapMessageAppendUriPathOptions(otMessage *aMessage, const char *aUriPath)
 {
     return AsCoapMessage(aMessage).AppendUriPathOptions(aUriPath);
 }

 uint16_t otCoapBlockSizeFromExponent(otCoapBlockSzx aSize)
 {
     return static_cast<uint16_t>(1 << (static_cast<uint8_t>(aSize) + Coap::Message::kBlockSzxBase));
 }

 otError otCoapMessageAppendBlock2Option(otMessage *aMessage, uint32_t aNum, bool aMore, otCoapBlockSzx aSize)
 {
     return AsCoapMessage(aMessage).AppendBlockOption(Coap::Message::kBlockType2, aNum, aMore, aSize);
 }

 otError otCoapMessageAppendBlock1Option(otMessage *aMessage, uint32_t aNum, bool aMore, otCoapBlockSzx aSize)
 {
     return AsCoapMessage(aMessage).AppendBlockOption(Coap::Message::kBlockType1, aNum, aMore, aSize);
 }

 otError otCoapMessageAppendProxyUriOption(otMessage *aMessage, const char *aUriPath)
 {
     return AsCoapMessage(aMessage).AppendProxyUriOption(aUriPath);
 }

 otError otCoapMessageAppendMaxAgeOption(otMessage *aMessage, uint32_t aMaxAge)
 {
     return AsCoapMessage(aMessage).AppendMaxAgeOption(aMaxAge);
 }

 otError otCoapMessageAppendUriQueryOption(otMessage *aMessage, const char *aUriQuery)
 {
     return AsCoapMessage(aMessage).AppendUriQueryOption(aUriQuery);
 }

 otError otCoapMessageSetPayloadMarker(otMessage *aMessage)
 {
     return AsCoapMessage(aMessage).SetPayloadMarker();
 }

 otCoapType otCoapMessageGetType(const otMessage *aMessage)
 {
     return static_cast<otCoapType>(AsCoapMessage(aMessage).GetType());
 }

 otCoapCode otCoapMessageGetCode(const otMessage *aMessage)
 {
     return static_cast<otCoapCode>(AsCoapMessage(aMessage).GetCode());
 }

 void otCoapMessageSetCode(otMessage *aMessage, otCoapCode aCode)
 {
     AsCoapMessage(aMessage).SetCode(MapEnum(aCode));
 }

 const char *otCoapMessageCodeToString(const otMessage *aMessage)
 {
     return AsCoapMessage(aMessage).CodeToString();
 }

 uint16_t otCoapMessageGetMessageId(const otMessage *aMessage)
 {
     return AsCoapMessage(aMessage).GetMessageId();
 }

 uint8_t otCoapMessageGetTokenLength(const otMessage *aMessage)
 {
     return AsCoapMessage(aMessage).GetTokenLength();
 }

 const uint8_t *otCoapMessageGetToken(const otMessage *aMessage)
 {
     return AsCoapMessage(aMessage).GetToken();
 }

 otError otCoapOptionIteratorInit(otCoapOptionIterator *aIterator, const otMessage *aMessage)
 {
     return AsCoreType(aIterator).Init(AsCoapMessage(aMessage));
 }

 const otCoapOption *otCoapOptionIteratorGetFirstOptionMatching(otCoapOptionIterator *aIterator, uint16_t aOption)
 {
     Coap::Option::Iterator &iterator = AsCoreType(aIterator);

     IgnoreError(iterator.Init(iterator.GetMessage(), aOption));
     return iterator.GetOption();
 }

 const otCoapOption *otCoapOptionIteratorGetFirstOption(otCoapOptionIterator *aIterator)
 {
     Coap::Option::Iterator &iterator = AsCoreType(aIterator);

     IgnoreError(iterator.Init(iterator.GetMessage()));
     return iterator.GetOption();
 }

 const otCoapOption *otCoapOptionIteratorGetNextOptionMatching(otCoapOptionIterator *aIterator, uint16_t aOption)
 {
     Coap::Option::Iterator &iterator = AsCoreType(aIterator);

     IgnoreError(iterator.Advance(aOption));
     return iterator.GetOption();
 }

 const otCoapOption *otCoapOptionIteratorGetNextOption(otCoapOptionIterator *aIterator)
 {
     Coap::Option::Iterator &iterator = AsCoreType(aIterator);

     IgnoreError(iterator.Advance());
     return iterator.GetOption();
 }

 otError otCoapOptionIteratorGetOptionUintValue(otCoapOptionIterator *aIterator, uint64_t *aValue)
 {
     return AsCoreType(aIterator).ReadOptionValue(*aValue);
 }

 otError otCoapOptionIteratorGetOptionValue(otCoapOptionIterator *aIterator, void *aValue)
 {
     return AsCoreType(aIterator).ReadOptionValue(aValue);
 }

 #if OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE
 otError otCoapSendRequestBlockWiseWithParameters(otInstance *                aInstance,
                                                  otMessage *                 aMessage,
                                                  const otMessageInfo *       aMessageInfo,
                                                  otCoapResponseHandler       aHandler,
                                                  void *                      aContext,
                                                  const otCoapTxParameters *  aTxParameters,
                                                  otCoapBlockwiseTransmitHook aTransmitHook,
                                                  otCoapBlockwiseReceiveHook  aReceiveHook)
 {
     Error                     error;
     const Coap::TxParameters &txParameters = Coap::TxParameters::From(aTxParameters);

     if (aTxParameters != nullptr)
     {
         VerifyOrExit(txParameters.IsValid(), error = kErrorInvalidArgs);
     }

     error = AsCoreType(aInstance).GetApplicationCoap().SendMessage(AsCoapMessage(aMessage), AsCoreType(aMessageInfo),
                                                                    txParameters, aHandler, aContext, aTransmitHook,
                                                                    aReceiveHook);

 exit:
     return error;
 }
 #endif // OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE

 otError otCoapSendRequestWithParameters(otInstance *              aInstance,
                                         otMessage *               aMessage,
                                         const otMessageInfo *     aMessageInfo,
                                         otCoapResponseHandler     aHandler,
                                         void *                    aContext,
                                         const otCoapTxParameters *aTxParameters)
 {
     Error error;

     const Coap::TxParameters &txParameters = Coap::TxParameters::From(aTxParameters);

     if (aTxParameters != nullptr)
     {
         VerifyOrExit(txParameters.IsValid(), error = kErrorInvalidArgs);
     }

     error = AsCoreType(aInstance).GetApplicationCoap().SendMessage(AsCoapMessage(aMessage), AsCoreType(aMessageInfo),
                                                                    txParameters, aHandler, aContext);

 exit:
     return error;
 }

 otError otCoapStart(otInstance *aInstance, uint16_t aPort)
 {
     return AsCoreType(aInstance).GetApplicationCoap().Start(aPort);
 }

 otError otCoapStop(otInstance *aInstance)
 {
     return AsCoreType(aInstance).GetApplicationCoap().Stop();
 }

 #if OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE
 void otCoapAddBlockWiseResource(otInstance *aInstance, otCoapBlockwiseResource *aResource)
 {
     AsCoreType(aInstance).GetApplicationCoap().AddBlockWiseResource(AsCoreType(aResource));
 }

 void otCoapRemoveBlockWiseResource(otInstance *aInstance, otCoapBlockwiseResource *aResource)
 {
     AsCoreType(aInstance).GetApplicationCoap().RemoveBlockWiseResource(AsCoreType(aResource));
 }
 #endif

 void otCoapAddResource(otInstance *aInstance, otCoapResource *aResource)
 {
     AsCoreType(aInstance).GetApplicationCoap().AddResource(AsCoreType(aResource));
 }

 void otCoapRemoveResource(otInstance *aInstance, otCoapResource *aResource)
 {
     AsCoreType(aInstance).GetApplicationCoap().RemoveResource(AsCoreType(aResource));
 }

 void otCoapSetDefaultHandler(otInstance *aInstance, otCoapRequestHandler aHandler, void *aContext)
 {
     AsCoreType(aInstance).GetApplicationCoap().SetDefaultHandler(aHandler, aContext);
 }

 #if OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE
 otError otCoapSendResponseBlockWiseWithParameters(otInstance *                aInstance,
                                                   otMessage *                 aMessage,
                                                   const otMessageInfo *       aMessageInfo,
                                                   const otCoapTxParameters *  aTxParameters,
                                                   void *                      aContext,
                                                   otCoapBlockwiseTransmitHook aTransmitHook)
 {
     return AsCoreType(aInstance).GetApplicationCoap().SendMessage(AsCoapMessage(aMessage), AsCoreType(aMessageInfo),
                                                                   Coap::TxParameters::From(aTxParameters), nullptr,
                                                                   aContext, aTransmitHook, nullptr);
 }
 #endif

 otError otCoapSendResponseWithParameters(otInstance *              aInstance,
                                          otMessage *               aMessage,
                                          const otMessageInfo *     aMessageInfo,
                                          const otCoapTxParameters *aTxParameters)
 {
     return AsCoreType(aInstance).GetApplicationCoap().SendMessage(
         AsCoapMessage(aMessage), AsCoreType(aMessageInfo), Coap::TxParameters::From(aTxParameters), nullptr, nullptr);
 }

 #endif // OPENTHREAD_CONFIG_COAP_API_ENABLE
	/*
	* Copyright (c) 2016, The OpenThread Authors.
	* All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are met:
	* 1. Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.
	* 3. Neither the name of the copyright holder nor the
	* names of its contributors may be used to endorse or promote products
	* derived from this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	* POSSIBILITY OF SUCH DAMAGE.
	*/

	/**
	* @file
	* This file implements the OpenThread CoAP API.
	*/

	#include "openthread-core-config.h"

	#if OPENTHREAD_CONFIG_COAP_API_ENABLE

	#include <openthread/coap.h>

	#include "coap/coap_message.hpp"
	#include "common/as_core_type.hpp"
	#include "common/locator_getters.hpp"

	using namespace ot;

	otMessage otCoapNewMessage(otInstance aInstance, const otMessageSettings *aSettings)
	{
	return AsCoreType(aInstance).GetApplicationCoap().NewMessage(Message::Settings::From(aSettings));
	}

	void otCoapMessageInit(otMessage *aMessage, otCoapType aType, otCoapCode aCode)
	{
	AsCoapMessage(aMessage).Init(MapEnum(aType), MapEnum(aCode));
	}

	otError otCoapMessageInitResponse(otMessage aResponse, const otMessage aRequest, otCoapType aType, otCoapCode aCode)
	{
	Coap::Message & response = AsCoapMessage(aResponse);
	const Coap::Message &request = AsCoapMessage(aRequest);

	response.Init(MapEnum(aType), MapEnum(aCode));
	response.SetMessageId(request.GetMessageId());

	return response.SetTokenFromMessage(request);
	}

	otError otCoapMessageSetToken(otMessage aMessage, const uint8_t aToken, uint8_t aTokenLength)
	{
	return AsCoapMessage(aMessage).SetToken(aToken, aTokenLength);
	}

	void otCoapMessageGenerateToken(otMessage *aMessage, uint8_t aTokenLength)
	{
	IgnoreError(AsCoapMessage(aMessage).GenerateRandomToken(aTokenLength));
	}

	otError otCoapMessageAppendContentFormatOption(otMessage *aMessage, otCoapOptionContentFormat aContentFormat)
	{
	return AsCoapMessage(aMessage).AppendContentFormatOption(aContentFormat);
	}

	otError otCoapMessageAppendOption(otMessage aMessage, uint16_t aNumber, uint16_t aLength, const void aValue)
	{
	return AsCoapMessage(aMessage).AppendOption(aNumber, aLength, aValue);
	}

	otError otCoapMessageAppendUintOption(otMessage *aMessage, uint16_t aNumber, uint32_t aValue)
	{
	return AsCoapMessage(aMessage).AppendUintOption(aNumber, aValue);
	}

	otError otCoapMessageAppendObserveOption(otMessage *aMessage, uint32_t aObserve)
	{
	return AsCoapMessage(aMessage).AppendObserveOption(aObserve);
	}

	otError otCoapMessageAppendUriPathOptions(otMessage aMessage, const char aUriPath)
	{
	return AsCoapMessage(aMessage).AppendUriPathOptions(aUriPath);
	}

	uint16_t otCoapBlockSizeFromExponent(otCoapBlockSzx aSize)
	{
	return static_cast<uint16_t>(1 << (static_cast<uint8_t>(aSize) + Coap::Message::kBlockSzxBase));
	}

	otError otCoapMessageAppendBlock2Option(otMessage *aMessage, uint32_t aNum, bool aMore, otCoapBlockSzx aSize)
	{
	return AsCoapMessage(aMessage).AppendBlockOption(Coap::Message::kBlockType2, aNum, aMore, aSize);
	}

	otError otCoapMessageAppendBlock1Option(otMessage *aMessage, uint32_t aNum, bool aMore, otCoapBlockSzx aSize)
	{
	return AsCoapMessage(aMessage).AppendBlockOption(Coap::Message::kBlockType1, aNum, aMore, aSize);
	}

	otError otCoapMessageAppendProxyUriOption(otMessage aMessage, const char aUriPath)
	{
	return AsCoapMessage(aMessage).AppendProxyUriOption(aUriPath);
	}

	otError otCoapMessageAppendMaxAgeOption(otMessage *aMessage, uint32_t aMaxAge)
	{
	return AsCoapMessage(aMessage).AppendMaxAgeOption(aMaxAge);
	}

	otError otCoapMessageAppendUriQueryOption(otMessage aMessage, const char aUriQuery)
	{
	return AsCoapMessage(aMessage).AppendUriQueryOption(aUriQuery);
	}

	otError otCoapMessageSetPayloadMarker(otMessage *aMessage)
	{
	return AsCoapMessage(aMessage).SetPayloadMarker();
	}

	otCoapType otCoapMessageGetType(const otMessage *aMessage)
	{
	return static_cast<otCoapType>(AsCoapMessage(aMessage).GetType());
	}

	otCoapCode otCoapMessageGetCode(const otMessage *aMessage)
	{
	return static_cast<otCoapCode>(AsCoapMessage(aMessage).GetCode());
	}

	void otCoapMessageSetCode(otMessage *aMessage, otCoapCode aCode)
	{
	AsCoapMessage(aMessage).SetCode(MapEnum(aCode));
	}

	const char otCoapMessageCodeToString(const otMessage aMessage)
	{
	return AsCoapMessage(aMessage).CodeToString();
	}

	uint16_t otCoapMessageGetMessageId(const otMessage *aMessage)
	{
	return AsCoapMessage(aMessage).GetMessageId();
	}

	uint8_t otCoapMessageGetTokenLength(const otMessage *aMessage)
	{
	return AsCoapMessage(aMessage).GetTokenLength();
	}

	const uint8_t otCoapMessageGetToken(const otMessage aMessage)
	{
	return AsCoapMessage(aMessage).GetToken();
	}

	otError otCoapOptionIteratorInit(otCoapOptionIterator aIterator, const otMessage aMessage)
	{
	return AsCoreType(aIterator).Init(AsCoapMessage(aMessage));
	}

	const otCoapOption otCoapOptionIteratorGetFirstOptionMatching(otCoapOptionIterator aIterator, uint16_t aOption)
	{
	Coap::Option::Iterator &iterator = AsCoreType(aIterator);

	IgnoreError(iterator.Init(iterator.GetMessage(), aOption));
	return iterator.GetOption();
	}

	const otCoapOption otCoapOptionIteratorGetFirstOption(otCoapOptionIterator aIterator)
	{
	Coap::Option::Iterator &iterator = AsCoreType(aIterator);

	IgnoreError(iterator.Init(iterator.GetMessage()));
	return iterator.GetOption();
	}

	const otCoapOption otCoapOptionIteratorGetNextOptionMatching(otCoapOptionIterator aIterator, uint16_t aOption)
	{
	Coap::Option::Iterator &iterator = AsCoreType(aIterator);

	IgnoreError(iterator.Advance(aOption));
	return iterator.GetOption();
	}

	const otCoapOption otCoapOptionIteratorGetNextOption(otCoapOptionIterator aIterator)
	{
	Coap::Option::Iterator &iterator = AsCoreType(aIterator);

	IgnoreError(iterator.Advance());
	return iterator.GetOption();
	}

	otError otCoapOptionIteratorGetOptionUintValue(otCoapOptionIterator aIterator, uint64_t aValue)
	{
	return AsCoreType(aIterator).ReadOptionValue(*aValue);
	}

	otError otCoapOptionIteratorGetOptionValue(otCoapOptionIterator aIterator, void aValue)
	{
	return AsCoreType(aIterator).ReadOptionValue(aValue);
	}

	#if OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE
	otError otCoapSendRequestBlockWiseWithParameters(otInstance * aInstance,
	otMessage * aMessage,
	const otMessageInfo * aMessageInfo,
	otCoapResponseHandler aHandler,
	void * aContext,
	const otCoapTxParameters * aTxParameters,
	otCoapBlockwiseTransmitHook aTransmitHook,
	otCoapBlockwiseReceiveHook aReceiveHook)
	{
	Error error;
	const Coap::TxParameters &txParameters = Coap::TxParameters::From(aTxParameters);

	if (aTxParameters != nullptr)
	{
	VerifyOrExit(txParameters.IsValid(), error = kErrorInvalidArgs);
	}

	error = AsCoreType(aInstance).GetApplicationCoap().SendMessage(AsCoapMessage(aMessage), AsCoreType(aMessageInfo),
	txParameters, aHandler, aContext, aTransmitHook,
	aReceiveHook);

	exit:
	return error;
	}
	#endif // OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE

	otError otCoapSendRequestWithParameters(otInstance * aInstance,
	otMessage * aMessage,
	const otMessageInfo * aMessageInfo,
	otCoapResponseHandler aHandler,
	void * aContext,
	const otCoapTxParameters *aTxParameters)
	{
	Error error;

	const Coap::TxParameters &txParameters = Coap::TxParameters::From(aTxParameters);

	if (aTxParameters != nullptr)
	{
	VerifyOrExit(txParameters.IsValid(), error = kErrorInvalidArgs);
	}

	error = AsCoreType(aInstance).GetApplicationCoap().SendMessage(AsCoapMessage(aMessage), AsCoreType(aMessageInfo),
	txParameters, aHandler, aContext);

	exit:
	return error;
	}

	otError otCoapStart(otInstance *aInstance, uint16_t aPort)
	{
	return AsCoreType(aInstance).GetApplicationCoap().Start(aPort);
	}

	otError otCoapStop(otInstance *aInstance)
	{
	return AsCoreType(aInstance).GetApplicationCoap().Stop();
	}

	#if OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE
	void otCoapAddBlockWiseResource(otInstance aInstance, otCoapBlockwiseResource aResource)
	{
	AsCoreType(aInstance).GetApplicationCoap().AddBlockWiseResource(AsCoreType(aResource));
	}

	void otCoapRemoveBlockWiseResource(otInstance aInstance, otCoapBlockwiseResource aResource)
	{
	AsCoreType(aInstance).GetApplicationCoap().RemoveBlockWiseResource(AsCoreType(aResource));
	}
	#endif

	void otCoapAddResource(otInstance aInstance, otCoapResource aResource)
	{
	AsCoreType(aInstance).GetApplicationCoap().AddResource(AsCoreType(aResource));
	}

	void otCoapRemoveResource(otInstance aInstance, otCoapResource aResource)
	{
	AsCoreType(aInstance).GetApplicationCoap().RemoveResource(AsCoreType(aResource));
	}

	void otCoapSetDefaultHandler(otInstance aInstance, otCoapRequestHandler aHandler, void aContext)
	{
	AsCoreType(aInstance).GetApplicationCoap().SetDefaultHandler(aHandler, aContext);
	}

	#if OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE
	otError otCoapSendResponseBlockWiseWithParameters(otInstance * aInstance,
	otMessage * aMessage,
	const otMessageInfo * aMessageInfo,
	const otCoapTxParameters * aTxParameters,
	void * aContext,
	otCoapBlockwiseTransmitHook aTransmitHook)
	{
	return AsCoreType(aInstance).GetApplicationCoap().SendMessage(AsCoapMessage(aMessage), AsCoreType(aMessageInfo),
	Coap::TxParameters::From(aTxParameters), nullptr,
	aContext, aTransmitHook, nullptr);
	}
	#endif

	otError otCoapSendResponseWithParameters(otInstance * aInstance,
	otMessage * aMessage,
	const otMessageInfo * aMessageInfo,
	const otCoapTxParameters *aTxParameters)
	{
	return AsCoreType(aInstance).GetApplicationCoap().SendMessage(
	AsCoapMessage(aMessage), AsCoreType(aMessageInfo), Coap::TxParameters::From(aTxParameters), nullptr, nullptr);
	}

	#endif // OPENTHREAD_CONFIG_COAP_API_ENABLE