ESP32 Forum

i am working on coap server , my problem is i need to run server for sometime and stop the server but after stopping the server also it getting the responses from the server

these is my code and called the function void coap_server_stop() from another function it is coming inside but task is not deleting and not freeing the coap context

#include "application.h"
#include "coap_server.h"
#include "json.h"
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private structures --------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
/* Private functions ---------------------------------------------------------*/
static TaskHandle_t coap_server_task;
const static char *TAG = "COAP_SERVER";
static char espressif_data[100];
static int espressif_data_len = 0;
uint8_t temp_val,i;


#ifdef CONFIG_COAP_MBEDTLS_PKI
/* CA cert, taken from coap_ca.pem
Server cert, taken from coap_server.crt
Server key, taken from coap_server.key

The PEM, CRT and KEY file are examples taken from the wpa2 enterprise
example.

To embed it in the app binary, the PEM, CRT and KEY file is named
in the component.mk COMPONENT_EMBED_TXTFILES variable.
*/
extern uint8_t ca_pem_start[] asm("_binary_coap_ca_pem_start");
extern uint8_t ca_pem_end[] asm("_binary_coap_ca_pem_end");
extern uint8_t server_crt_start[] asm("_binary_coap_server_crt_start");
extern uint8_t server_crt_end[] asm("_binary_coap_server_crt_end");
extern uint8_t server_key_start[] asm("_binary_coap_server_key_start");
extern uint8_t server_key_end[] asm("_binary_coap_server_key_end");
#endif /* CONFIG_COAP_MBEDTLS_PKI */

#define INITIAL_DATA "INI_RLY_STS :00"

/********************************************************************************
* @brief COAP GET FUNCTION
* @param context
* @param resource
* @param session
* @param request
* @param token,query
* @param response
* @retval None
*****************************************************************************/

void glowfy_coap_get(coap_context_t *ctx, coap_resource_t *resource,coap_session_t *session,coap_pdu_t *request, coap_binary_t *token,coap_string_t *query, coap_pdu_t *response)
{

uint8_t ack_payload[]= "{\"CMD\":\"1\",\"RELAY_STATUS\":\"\"}";
int ack_payload_len;
uint8_t status_buffer[10];
sprintf((char*)status_buffer,"%d%d",relay_1_sts,relay_2_sts);
json_insert_key_val(ack_payload ,(uint8_t*)JSON_RELAY_STATUS,status_buffer);
ack_payload_len = sizeof(ack_payload)+1;

ESP_LOGI(TAG,"ACK_PACKET is %s",ack_payload);
coap_add_data_blocked_response(resource, session, request, response, token,
COAP_MEDIATYPE_TEXT_PLAIN, 0,
(size_t)ack_payload_len,
(const u_char *)ack_payload);
}


/* End of Function glowfy_coap_get()*******************************************/

/********************************************************************************
* @brief COAP PUT FUNCTION
* @param context
* @param resource
* @param session
* @param request
* @param token,query
* @param response
* @retval None
*****************************************************************************/
void glowfy_coap_put(coap_context_t *ctx,coap_resource_t *resource,coap_session_t *session,coap_pdu_t *request,coap_binary_t *token,coap_string_t *query,coap_pdu_t *response)
{
size_t size;
unsigned char *data;

coap_resource_notify_observers(resource, NULL);

if (strcmp (espressif_data, INITIAL_DATA) == 0)
{
response->code = COAP_RESPONSE_CODE(201);
}
else
{
response->code = COAP_RESPONSE_CODE(204);
}

/* coap_get_data() sets size to 0 on error */
(void)coap_get_data(request, &size, &data);

if (size == 0) { /* re-init */
snprintf(espressif_data, sizeof(espressif_data), INITIAL_DATA);
espressif_data_len = strlen(espressif_data);
} else {
espressif_data_len = size > sizeof (espressif_data) ? sizeof (espressif_data) : size;
memcpy (espressif_data, data, espressif_data_len);
}

ESP_LOGI(TAG,"RECEIVED PAYLOAD is %s",espressif_data);



}




/* End of Function glowfy_coap_put()*******************************************/

#ifdef CONFIG_COAP_MBEDTLS_PKI

static int
verify_cn_callback(const char *cn,
const uint8_t *asn1_public_cert,
size_t asn1_length,
coap_session_t *session,
unsigned depth,
int validated,
void *arg
)
{
coap_log(LOG_INFO, "CN '%s' presented by server (%s)\n",
cn, depth ? "CA" : "Certificate");
return 1;
}
#endif /* CONFIG_COAP_MBEDTLS_PKI */


/********************************************************************************
* @brief coap task
* @param args
* @retval None
*****************************************************************************/
coap_context_t *ctx1 = NULL;

void coap_example_server(void *p)
{

coap_address_t serv_addr;
coap_resource_t *resource = NULL;

snprintf(espressif_data, sizeof(espressif_data), INITIAL_DATA);
espressif_data_len = strlen(espressif_data);
coap_set_log_level(EXAMPLE_COAP_LOG_DEFAULT_LEVEL);

while (1) {
coap_endpoint_t *ep = NULL;
unsigned wait_ms;

/* Prepare the CoAP server socket */
coap_address_init(&serv_addr);
serv_addr.addr.sin.sin_family = AF_INET;
serv_addr.addr.sin.sin_addr.s_addr = INADDR_ANY;
serv_addr.addr.sin.sin_port = htons(COAP_DEFAULT_PORT);

ctx1 = coap_new_context(NULL);
if (!ctx1) {
ESP_LOGE(TAG, "coap_new_context() failed");
continue;
}
#ifdef CONFIG_COAP_MBEDTLS_PSK
/* Need PSK setup before we set up endpoints */
coap_context_set_psk(ctx1, "CoAP",
(const uint8_t *)EXAMPLE_COAP_PSK_KEY,
sizeof(EXAMPLE_COAP_PSK_KEY) - 1);
#endif /* CONFIG_COAP_MBEDTLS_PSK */

#ifdef CONFIG_COAP_MBEDTLS_PKI
unsigned int ca_pem_bytes = ca_pem_end - ca_pem_start;
unsigned int server_crt_bytes = server_crt_end - server_crt_start;
unsigned int server_key_bytes = server_key_end - server_key_start;
coap_dtls_pki_t dtls_pki;

memset (&dtls_pki, 0, sizeof(dtls_pki));
dtls_pki.version = COAP_DTLS_PKI_SETUP_VERSION;
if (ca_pem_bytes) {

/* Add in additional certificate checking.
* This list of enabled can be tuned for the specific
* requirements - see 'man coap_encryption'.
*
* Note: A list of root ca file can be setup separately using
* coap_context_set_pki_root_cas(), but the below is used to
* define what checking actually takes place.*/

dtls_pki.verify_peer_cert = 1;
dtls_pki.require_peer_cert = 1;
dtls_pki.allow_self_signed = 1;
dtls_pki.allow_expired_certs = 1;
dtls_pki.cert_chain_validation = 1;
dtls_pki.cert_chain_verify_depth = 2;
dtls_pki.check_cert_revocation = 1;
dtls_pki.allow_no_crl = 1;
dtls_pki.allow_expired_crl = 1;
dtls_pki.allow_bad_md_hash = 1;
dtls_pki.allow_short_rsa_length = 1;
dtls_pki.validate_cn_call_back = verify_cn_callback;
dtls_pki.cn_call_back_arg = NULL;
dtls_pki.validate_sni_call_back = NULL;
dtls_pki.sni_call_back_arg = NULL;
}
dtls_pki.pki_key.key_type = COAP_PKI_KEY_PEM_BUF;
dtls_pki.pki_key.key.pem_buf.public_cert = server_crt_start;
dtls_pki.pki_key.key.pem_buf.public_cert_len = server_crt_bytes;
dtls_pki.pki_key.key.pem_buf.private_key = server_key_start;
dtls_pki.pki_key.key.pem_buf.private_key_len = server_key_bytes;
dtls_pki.pki_key.key.pem_buf.ca_cert = ca_pem_start;
dtls_pki.pki_key.key.pem_buf.ca_cert_len = ca_pem_bytes;

coap_context_set_pki(ctx, &dtls_pki);
#endif /* CONFIG_COAP_MBEDTLS_PKI */


ep = coap_new_endpoint(ctx1, &serv_addr, COAP_PROTO_UDP);
if (!ep) {
ESP_LOGE(TAG, "udp: coap_new_endpoint() failed");
//goto clean_up;
}
#if defined(CONFIG_COAP_MBEDTLS_PSK) || defined(CONFIG_COAP_MBEDTLS_PKI)
if (coap_dtls_is_supported()) {
#ifndef CONFIG_MBEDTLS_TLS_SERVER
/* This is not critical as unencrypted support is still available */
ESP_LOGI(TAG, "MbedTLS (D)TLS Server Mode not configured");
#else /* CONFIG_MBEDTLS_TLS_SERVER */
serv_addr.addr.sin.sin_port = htons(COAPS_DEFAULT_PORT);
ep = coap_new_endpoint(ctx1, &serv_addr, COAP_PROTO_DTLS);
if (!ep) {
ESP_LOGE(TAG, "dtls: coap_new_endpoint() failed");
//goto clean_up;
}
#endif /* CONFIG_MBEDTLS_TLS_SERVER */
} else {
/* This is not critical as unencrypted support is still available */
ESP_LOGI(TAG, "MbedTLS (D)TLS Server Mode not configured");
}
#endif /* CONFIG_COAP_MBEDTLS_PSK CONFIG_COAP_MBEDTLS_PKI */
resource = coap_resource_init(coap_make_str_const("GLOWFY2PM"), 0);
if (!resource) {
ESP_LOGE(TAG, "coap_resource_init() failed");
//goto clean_up;
}
coap_register_handler(resource, COAP_REQUEST_GET, glowfy_coap_get);
coap_register_handler(resource, COAP_REQUEST_PUT, glowfy_coap_put);
/* We possibly want to Observe the GETs */
coap_resource_set_get_observable(resource, 1);
coap_add_resource(ctx1, resource);

wait_ms = COAP_RESOURCE_CHECK_TIME * 1000;

while (1) {
int result = coap_run_once(ctx1, wait_ms);
if (result < 0) {
break;
} else if (result && (unsigned)result < wait_ms) {
/* decrement if there is a result wait time returned */
wait_ms -= result;
}
if (result) {
/* result must have been >= wait_ms, so reset wait_ms */
wait_ms = COAP_RESOURCE_CHECK_TIME * 1000;
}

}
}




}


/* End of Function coap_task()*******************************************/

void coap_server_stop(void)
{

coap_free_context(ctx1);
coap_cleanup();
vTaskDelete(coap_server_task);

}

void coap_server_init(void)
{
ESP_LOGI(TAG,"COAP SERVER TASK STARTED");
xTaskCreate(coap_example_server, "coap", 8 * 1024, NULL, 5, coap_server_task);

}