AWS MQTT TLS connection error

[haseebzaib]

Using nrf9160 with W5500 Ethernet
NCS Version 2.6.1

My normal MQTT connection is working fine, but connecting to aws is being an issue. I am getting mqtt -22 error. I have tried almost everything but nothing is working. I have tested using mqtt client software my AWS side is working fine, so there is definitly issue on my coding side.

.conf file

# GPIO
CONFIG_GPIO=y

# Logging
CONFIG_LOG=y
CONFIG_CONSOLE=y
#CONFIG_LOG_BUFFER_SIZE=2048
CONFIG_HW_ID_LIBRARY=y


CONFIG_JSON_LIBRARY=y


# Heap and stacks
CONFIG_HEAP_MEM_POOL_SIZE=4096
CONFIG_MAIN_STACK_SIZE=4096
#CONFIG_SYSTEM_WORKQUEUE_STACK_SIZE=2048

# Newlibc
CONFIG_NEWLIB_LIBC=y 

# Ethernet
CONFIG_SPI=y
CONFIG_NET_L2_ETHERNET=y
CONFIG_ETH_W5500=y
CONFIG_ETH_W5500_TIMEOUT=10000
CONFIG_ETHERNET_LOG_LEVEL_DBG=y
CONFIG_ETHERNET_LOG_LEVEL_INF=y
CONFIG_NETWORKING=y
CONFIG_NET_IPV6=n
CONFIG_NET_IPV4=y
CONFIG_NET_ARP=y
CONFIG_NET_UDP=y
CONFIG_NET_DHCPV4=y
CONFIG_NET_DHCPV4_OPTION_CALLBACKS=y
#CONFIG_NET_NATIVE=n
CONFIG_NET_SOCKETS=y
CONFIG_NET_SOCKETS_SOCKOPT_TLS=y
#CONFIG_NET_SOCKETS_OFFLOAD=y
CONFIG_NET_TCP=y
CONFIG_NET_CONNECTION_MANAGER=y
CONFIG_NET_CONNECTION_MANAGER_MONITOR_STACK_SIZE=1024
CONFIG_DNS_RESOLVER=y
#CONFIG_DNS_SERVER_IP_ADDRESSES=y
#CONFIG_NET_SOCKETS_POSIX_NAMES=y
#CONFIG_DNS_SERVER1="8.8.8.8"
#CONFIG_NET_CONFIG_NEED_IPV4=y
#CONFIG_NET_CONFIG_SETTINGS=y
CONFIG_TEST_RANDOM_GENERATOR=y
CONFIG_INIT_STACKS=y
CONFIG_NET_MGMT=y
CONFIG_NET_MGMT_EVENT=y
CONFIG_NET_LOG=y
#CONFIG_SLIP_STATISTICS=n
CONFIG_NET_SHELL=y


# # AWS IoT library
# CONFIG_AWS_IOT=y
# CONFIG_AWS_IOT_CLIENT_ID_STATIC="aws_nrf9160"
# CONFIG_AWS_IOT_BROKER_HOST_NAME="ag9gkz7w9pc2h-ats.iot.us-east-1.amazonaws.com"
# CONFIG_AWS_IOT_TOPIC_UPDATE_DELTA_SUBSCRIBE=y
# CONFIG_AWS_IOT_TOPIC_GET_ACCEPTED_SUBSCRIBE=y
# CONFIG_AWS_IOT_TOPIC_GET_REJECTED_SUBSCRIBE=y

# # MQTT helper library
# CONFIG_MQTT_HELPER=y
# CONFIG_MQTT_HELPER_SEC_TAG=201
# CONFIG_MQTT_HELPER_LAST_WILL=y
# CONFIG_MQTT_HELPER_STACK_SIZE=4096

# # MQTT - Maximum MQTT keepalive timeout specified by AWS IoT Core
# CONFIG_MQTT_KEEPALIVE=1200
# CONFIG_MQTT_CLEAN_SESSION=y


# Modem library
# CONFIG_TRUSTED_EXECUTION_NONSECURE=y
# CONFIG_NRF_MODEM_LIB=y
# CONFIG_MODEM_KEY_MGMT=y

# Enable the MQTT Lib
CONFIG_MQTT_LIB=y
CONFIG_MQTT_LIB_TLS=y



# # TLS configuration
CONFIG_MBEDTLS=y
CONFIG_MBEDTLS_BUILTIN=y
# # CONFIG_MBEDTLS_ENABLE_HEAP=y
# # CONFIG_MBEDTLS_HEAP_SIZE=30000
# # CONFIG_MBEDTLS_SSL_MAX_CONTENT_LEN=16384
# CONFIG_MBEDTLS_PEM_CERTIFICATE_FORMAT=y
# CONFIG_MBEDTLS_SERVER_NAME_INDICATION=y

Network establishing file with w5500

#include <zephyr/kernel.h>
#include <zephyr/net/net_if.h>
#include <zephyr/net/net_core.h>
#include <zephyr/net/net_context.h>
#include <zephyr/net/net_mgmt.h>
#include <zephyr/logging/log.h>
#include <zephyr/net/socket.h>

#include <zephyr/net/conn_mgr_connectivity.h>
#include <zephyr/net/conn_mgr_monitor.h>

LOG_MODULE_REGISTER(app_network);

#include "app_network.h"
#define DHCP_OPTION_NTP (42)
static uint8_t ntp_server[4];

/* Network mgmt */
static struct net_mgmt_event_callback mgmt_cb;
static struct net_mgmt_event_callback mgmt_cb_link_up;
static struct net_mgmt_event_callback mgmt_cb_link_down;

static struct net_dhcpv4_option_callback dhcp_cb;



/* Macros used to subscribe to specific Zephyr NET management events. */
#define L4_EVENT_MASK (NET_EVENT_L4_CONNECTED | NET_EVENT_L4_DISCONNECTED)


/* Zephyr NET management event callback structures. */
static struct net_mgmt_event_callback l4_cb;




/* Network interface */
struct net_if *iface;

/* Define message queue */
K_MSGQ_DEFINE(app_event_msq, sizeof(struct app_event), APP_EVENT_QUEUE_SIZE, 4);


static void option_handler(struct net_dhcpv4_option_callback *cb,
			   size_t length,
			   enum net_dhcpv4_msg_type msg_type,
			   struct net_if *iface)
{
	char buf[NET_IPV4_ADDR_LEN];

	LOG_INF("DHCP Option %d: %s", cb->option,
		net_addr_ntop(AF_INET, cb->data, buf, sizeof(buf)));
}

int app_event_manager_push(struct app_event *p_evt)
{
    return k_msgq_put(&app_event_msq, p_evt, K_NO_WAIT);
}

int app_event_manager_get(struct app_event *p_evt)
{
    return k_msgq_get(&app_event_msq, p_evt, K_FOREVER);
}

char *app_event_type_to_string(enum app_event_type type)
{
    switch (type)
    {
    case APP_EVENT_ETHERNET_DISCONNECT:
        return "APP_EVENT_ETHERNET_DISCONNECT";
    case APP_EVENT_ETHERNET_CONNECTED:
        return "APP_EVENT_ETHERNET_CONNECTED";
    case APP_EVENT_ETHERNET_READY:
        return "APP_EVENT_ETHERNET_READY";
    case APP_EVENT_BACKEND_ERROR:
        return "APP_EVENT_BACKEND_ERROR";
    case APP_EVENT_BACKEND_CONNECTED:
        return "APP_EVENT_BACKEND_CONNECTED";
    case APP_EVENT_BACKEND_DISCONNECTED:
        return "APP_EVENT_BACKEND_DISCONNECTED";
    case APP_EVENT_BLE_DATA:
        return "APP_EVENT_BLE_DATA";
    default:
        return "UNKNOWN";
    }
}

/**
 * @brief Network management handler
 *
 * @param cb
 * @param mgmt_event
 * @param iface
 */
static void net_mgmt_handler(struct net_mgmt_event_callback *cb,
                             uint32_t mgmt_event,
                             struct net_if *iface)
{

    int i = 0;

    switch (mgmt_event)
    {
    case NET_EVENT_IPV4_ADDR_ADD:

        for (i = 0; i < NET_IF_MAX_IPV4_ADDR; i++)
        {
            char buf[NET_IPV4_ADDR_LEN];

            if (iface->config.ip.ipv4->unicast[i].addr_type !=
                NET_ADDR_DHCP)
            {
                continue;
            }

            LOG_INF("Your address: %s",
                    (char *)(net_addr_ntop(AF_INET,
                                           &iface->config.ip.ipv4->unicast[i].address.in_addr,
                                           buf, sizeof(buf))));
            LOG_INF("Lease time: %u seconds",
                    iface->config.dhcpv4.lease_time);
            LOG_INF("Subnet: %s",
                    (char *)(net_addr_ntop(AF_INET,
                                           &iface->config.ip.ipv4->netmask,
                                           buf, sizeof(buf))));
            LOG_INF("Router: %s",
                    (char *)(net_addr_ntop(AF_INET,
                                           &iface->config.ip.ipv4->gw,
                                           buf, sizeof(buf))));

            /* Ready event */
           // APP_EVENT_MANAGER_PUSH(APP_EVENT_ETHERNET_READY);
        }

        break;
    default:
        LOG_INF("Net management event: %i", mgmt_event);
        break;
    }
}



static void net_mgmt_link_up(struct net_mgmt_event_callback *cb,
                             uint32_t mgmt_event,
                             struct net_if *iface)
                             {
	if (mgmt_event == NET_EVENT_IF_UP) {
LOG_INF("LINK UP");

    }
                             }


static void net_mgmt_link_down(struct net_mgmt_event_callback *cb,
                             uint32_t mgmt_event,
                             struct net_if *iface)
    {
	if (mgmt_event == NET_EVENT_IF_DOWN) {
LOG_INF("LINK DOWN");

    }
   }


   static void l4_event_handler(struct net_mgmt_event_callback *cb,
			     uint32_t event,
			     struct net_if *iface)
{
	int err;
	enum network_status status;

	switch (event) {
	case NET_EVENT_L4_CONNECTED:
		LOG_INF("Network connectivity established");
		status = NETWORK_CONNECTED;
          APP_EVENT_MANAGER_PUSH(APP_EVENT_ETHERNET_READY);
		break;
	case NET_EVENT_L4_DISCONNECTED:
		LOG_INF("Network connectivity lost");
		status = NETWORK_DISCONNECTED;
		break;
	default:
		/* Don't care */
		return;
	}


}


/**
 * @brief Initialize ethernet network
 *
 */
void app_net_init()
{
	int err;
    LOG_INF("Network Initialization");

    /* Setup callback */
   net_mgmt_init_event_callback(&mgmt_cb, net_mgmt_handler,NET_EVENT_IPV4_ADDR_ADD );
    net_mgmt_init_event_callback(&mgmt_cb_link_up, net_mgmt_link_up,NET_EVENT_IF_UP );
    net_mgmt_init_event_callback(&mgmt_cb_link_down, net_mgmt_link_down,NET_EVENT_IF_DOWN );

    net_mgmt_add_event_callback(&mgmt_cb);
    net_mgmt_add_event_callback(&mgmt_cb_link_up);
    net_mgmt_add_event_callback(&mgmt_cb_link_down);

     net_dhcpv4_init_option_callback(&dhcp_cb, option_handler,
	 				DHCP_OPTION_NTP, ntp_server,
	 				sizeof(ntp_server));

	 net_dhcpv4_add_option_callback(&dhcp_cb);

    /* Get interface */
     iface = net_if_get_default();

     	LOG_INF("Start on %s: index=%d", net_if_get_device(iface)->name,
	 	net_if_get_by_iface(iface));

    

    // /* Start dhcp discovery */
     net_dhcpv4_start(iface);

   

    /* Setup handler for Zephyr NET Connection Manager events. */
	net_mgmt_init_event_callback(&l4_cb, l4_event_handler, L4_EVENT_MASK);
	net_mgmt_add_event_callback(&l4_cb);


	err = conn_mgr_all_if_up(true);
	if (err) {
		LOG_ERR("conn_mgr_all_if_up, error: %d", err);

		return;
	}

	err = conn_mgr_all_if_connect(true);
	if (err) {
		LOG_ERR("conn_mgr_all_if_connect, error: %d", err);

		return;
	}

    // APP_EVENT_MANAGER_PUSH(APP_EVENT_ETHERNET_READY);
}

MQTT file to make AWS connection

#if defined(CONFIG_MQTT_LIB_TLS)
#define SERVER_ADDR		"ag9gkz7w9pc2h-ats.iot.us-east-1.amazonaws.com"
#define SERVER_PORT		8883
#else
#define SERVER_ADDR		"broker.hivemq.com"
#define SERVER_PORT		1883
#endif

#define APP_MQTT_BUFFER_SIZE	128
#define APP_CONNECT_TRIES	10
#define MQTT_CLIENTID		"aws_nrf9160"


#include <zephyr/logging/log.h>
#include <zephyr/kernel.h>
#include <zephyr/net/socket.h>
#include <zephyr/net/mqtt.h>
#include <zephyr/random/random.h>
#include <string.h>
#include <errno.h>
#include <zephyr/net/tls_credentials.h>
// #include <modem/modem_key_mgmt.h>
// #include <modem/nrf_modem_lib.h>
LOG_MODULE_REGISTER(app_mqtt);

#include "app_mqtt.h"
#include "creds.h"

/* Buffers for MQTT client. */
static uint8_t rx_buffer[256];
static uint8_t tx_buffer[256];

/* MQTT client context */
static struct mqtt_client client_ctx;

/* MQTT Broker address information. */
static struct sockaddr_storage broker;

static struct zsock_pollfd fds[1];
static bool connected;

#if defined(CONFIG_MQTT_LIB_TLS)
#define TLS_SNI_HOSTNAME "ag9gkz7w9pc2h-ats.iot.us-east-1.amazonaws.com"
#define APP_CA_CERT_TAG 1
#define APP_DEV_CERT_TAG 2
#define APP_PRIV_CERT_TAG 3

#define APP_CERT_TAG 16842753
#define APP_PSK_TAG 2

#define TLS_TAG_DEVICE_CERTIFICATE 1
#define TLS_TAG_DEVICE_PRIVATE_KEY 1
#define TLS_TAG_AWS_CA_CERTIFICATE 2

static sec_tag_t m_sec_tags[] = {
	TLS_TAG_DEVICE_CERTIFICATE,
	// TLS_TAG_AWS_CA_CERTIFICATE,
};

static int tls_init(void)
{
	int ret;




	ret = tls_credential_add(TLS_TAG_DEVICE_CERTIFICATE, TLS_CREDENTIAL_CA_CERTIFICATE, ca_cert,
							 ca_cert_len);
	if (ret < 0)
	{
		LOG_ERR("Failed to add ca certs: %d", ret);
		return ret;
	}

		ret = tls_credential_add(TLS_TAG_DEVICE_PRIVATE_KEY, TLS_CREDENTIAL_PRIVATE_KEY,
							 private_key, private_key_len);
	if (ret < 0)
	{
		LOG_ERR("Failed to add device private key: %d", ret);
		return ret;
	}

	ret = tls_credential_add(TLS_TAG_DEVICE_CERTIFICATE, TLS_CREDENTIAL_SERVER_CERTIFICATE,
							 public_cert, public_cert_len);
	if (ret < 0)
	{
		LOG_ERR("Failed to add device certificate: %d", ret);
		return ret;
	}

	return ret;
}

#endif

static void mqtt_evt_handler(struct mqtt_client *client,
							 const struct mqtt_evt *evt)
{
	int err;

	switch (evt->type)
	{
	case MQTT_EVT_CONNACK:
		if (evt->result != 0)
		{
			LOG_ERR("MQTT connect failed %d", evt->result);
			break;
		}

		connected = true;
		LOG_INF("MQTT client connected!");

		break;

	case MQTT_EVT_DISCONNECT:
		LOG_INF("MQTT client disconnected %d", evt->result);

		connected = false;

		break;

	case MQTT_EVT_PUBACK:
		if (evt->result != 0)
		{
			LOG_ERR("MQTT PUBACK error %d", evt->result);
			break;
		}

		LOG_INF("PUBACK packet id: %u", evt->param.puback.message_id);

		break;

	case MQTT_EVT_PUBREC:
		if (evt->result != 0)
		{
			LOG_ERR("MQTT PUBREC error %d", evt->result);
			break;
		}

		LOG_INF("PUBREC packet id: %u", evt->param.pubrec.message_id);

		const struct mqtt_pubrel_param rel_param = {
			.message_id = evt->param.pubrec.message_id};

		break;

	case MQTT_EVT_PUBCOMP:
		if (evt->result != 0)
		{
			LOG_ERR("MQTT PUBCOMP error %d", evt->result);
			break;
		}

		LOG_INF("PUBCOMP packet id: %u",
				evt->param.pubcomp.message_id);

		break;

	case MQTT_EVT_PINGRESP:
		LOG_INF("PINGRESP packet");
		break;

	default:
		break;
	}
}

static char *get_mqtt_payload(enum mqtt_qos qos)
{

	static char payload[] = "DOORS:OPEN_QoSx";

	payload[strlen(payload) - 1] = '0' + qos;

	return payload;
}

static int publish(struct mqtt_client *client, enum mqtt_qos qos)
{
	struct mqtt_publish_param param;

	param.message.topic.qos = qos;
	param.message.topic.topic.utf8 = (uint8_t *)"TEST";
	param.message.topic.topic.size =
		strlen(param.message.topic.topic.utf8);
	param.message.payload.data = get_mqtt_payload(qos);
	param.message.payload.len =
		strlen(param.message.payload.data);
	param.message_id = sys_rand32_get();
	param.dup_flag = 0U;
	param.retain_flag = 0U;

	return mqtt_publish(client, &param);
}

/**@brief Resolves the configured hostname and
 * initializes the MQTT broker structure
 */
static int broker_init(void)
{

	int err;
	struct addrinfo *result;
	struct addrinfo *addr;
	struct addrinfo hints = {
		.ai_family = AF_INET,
		.ai_socktype = SOCK_STREAM};

	err = getaddrinfo(SERVER_ADDR, "8883", &hints, &result);
	if (err)
	{
		LOG_ERR("getaddrinfo failed: %d", err);
		return -ECHILD;
	}

	addr = result;

	/* Look for address of the broker. */
	while (addr != NULL)
	{
		/* IPv4 Address. */
		if (addr->ai_addrlen == sizeof(struct sockaddr_in))
		{
			struct sockaddr_in *broker4 =
				((struct sockaddr_in *)&broker);
			char ipv4_addr[NET_IPV4_ADDR_LEN];

			broker4->sin_addr.s_addr =
				((struct sockaddr_in *)addr->ai_addr)
					->sin_addr.s_addr;
			broker4->sin_family = AF_INET;
			broker4->sin_port = htons(SERVER_PORT);

			inet_ntop(AF_INET, &broker4->sin_addr.s_addr,
					  ipv4_addr, sizeof(ipv4_addr));
			LOG_INF("IPv4 Address found %s", ipv4_addr);

			break;
		}
		else
		{
			LOG_ERR("ai_addrlen = %u should be %u or %u",
					(unsigned int)addr->ai_addrlen,
					(unsigned int)sizeof(struct sockaddr_in),
					(unsigned int)sizeof(struct sockaddr_in6));
		}

		addr = addr->ai_next;
	}

	/* Free the address. */
	freeaddrinfo(result);

	return err;
}

static int resolve_broker_addr()
{

	struct sockaddr_in *broker4 =
		((struct sockaddr_in *)&broker);
	int ret;
	struct zsock_addrinfo *ai = NULL;

	const struct zsock_addrinfo hints = {
		.ai_family = AF_INET,
		.ai_socktype = SOCK_STREAM,
		.ai_protocol = 0,
	};

	ret = zsock_getaddrinfo(SERVER_ADDR, "8883", &hints, &ai);
	if (ret == 0)
	{
		char addr_str[INET_ADDRSTRLEN];

		memcpy(broker4, ai->ai_addr, MIN(ai->ai_addrlen, sizeof(struct sockaddr_storage)));

		zsock_inet_ntop(AF_INET, &broker4->sin_addr, addr_str, sizeof(addr_str));
		LOG_INF("Resolved: %s:%u", addr_str, htons(broker4->sin_port));
	}
	else
	{
		LOG_ERR("failed to resolve hostname err = %d (errno = %d)", ret, errno);
	}

	zsock_freeaddrinfo(ai);

	return ret;
}

static void client_init(struct mqtt_client *client)
{
	mqtt_client_init(client);
	 broker_init();
	//resolve_broker_addr();
	/* MQTT client configuration */
	client->broker = &broker;
	client->evt_cb = mqtt_evt_handler;
	client->client_id.utf8 = (uint8_t *)MQTT_CLIENTID;
	client->client_id.size = strlen(MQTT_CLIENTID);
	client->password = NULL;
	client->user_name = NULL;
	client->protocol_version = MQTT_VERSION_3_1_1;

	/* MQTT buffers configuration */
	client->rx_buf = rx_buffer;
	client->rx_buf_size = sizeof(rx_buffer);
	client->tx_buf = tx_buffer;
	client->tx_buf_size = sizeof(tx_buffer);

#if defined(CONFIG_MQTT_LIB_TLS)
	client->transport.type = MQTT_TRANSPORT_SECURE;
	struct mqtt_sec_config *tls_config = &client->transport.tls.config;

	tls_config->peer_verify = TLS_PEER_VERIFY_REQUIRED;
	tls_config->cipher_list = NULL;
	tls_config->sec_tag_list = m_sec_tags;
	tls_config->sec_tag_count = ARRAY_SIZE(m_sec_tags);
	tls_config->hostname = TLS_SNI_HOSTNAME;

	// tls_config->set_native_tls = true;
#else
	client->transport.type = MQTT_TRANSPORT_NON_SECURE;
#endif
}

void app_mqtt_init()
{

	int rc, i = 0;
#if defined(CONFIG_MQTT_LIB_TLS)
	rc = tls_init();
	LOG_INF("tls_init %d", rc);
#endif

	while (i++ < APP_CONNECT_TRIES && !connected)
	{

		LOG_INF("Initializing MQTT ");

		client_init(&client_ctx);

		rc = mqtt_connect(&client_ctx);
		if (rc != 0)
		{
			LOG_INF("mqtt_connect, %d", rc);
			k_msleep(1000);
			continue;
		}

		if (client_ctx.transport.type == MQTT_TRANSPORT_NON_SECURE)
		{
			fds[0].fd = client_ctx.transport.tcp.sock;
		}
#if defined(CONFIG_MQTT_LIB_TLS)
		else if (client_ctx.transport.type == MQTT_TRANSPORT_SECURE)
		{
			fds[0].fd = client_ctx.transport.tls.sock;
		}
#endif
		fds[0].events = ZSOCK_POLLIN;
		poll(fds, 1, 2000);

		mqtt_input(&client_ctx);

		if (!connected)
		{
			mqtt_abort(&client_ctx);
		}
	}

	while (connected)
	{
		poll(fds, 1, 2000);
		mqtt_input(&client_ctx);
		rc = mqtt_live(&client_ctx);
		if (rc != 0 && rc != -EAGAIN)
		{
			LOG_INF("mqtt_live, %d", rc);
		}
		else if (rc == 0)
		{
			rc = mqtt_input(&client_ctx);
			if (rc != 0)
			{
				LOG_INF("mqtt_input, %d", rc);
			}
		}

		rc = publish(&client_ctx, MQTT_QOS_0_AT_MOST_ONCE);
		LOG_INF("mqtt_publish, %d", rc);
	}
}

main file

#include <stdlib.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/devicetree.h>
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(Main);

#include <app_network.h>
#include <app_mqtt.h>
#include "app_aws.h"


int main(void)
{

int aws_client;
          LOG_INF("Main started .... ");
 /* Init network */
    app_net_init();
//aws_client = app_aws_client_init();
       while (true)
    {

        struct app_event evt = {0};
        app_event_manager_get(&evt);



        switch (evt.type)
        {

        case APP_EVENT_ETHERNET_READY:
            LOG_INF("Ethernet is Ready");

           app_mqtt_init();

            // if(!aws_client)
            // {
            //     app_aws_init();
            // }
            // else
            // {
            //  LOG_INF("aws client issue");
            // }
            break;
        default:
            break;
        }
    }

        return 0;
}

Finally my output

[00:00:00.382,110] <inf> eth_w5500: MAC ADDRESS: 2 8 dc 86 7 e2
[00:00:00.383,300] <inf> eth_w5500: W5500 Initialized
*** Booting nRF Connect SDK 3758bcbfa5cd ***
[00:00:00.384,521] <inf> Main: Main started .... 
[00:00:00.384,552] <inf> app_network: Network Initialization
[00:00:00.384,582] <inf> app_network: Start on eth_w5500@0: index=1
[00:00:00.384,613] <inf> app_network: Net management event: -536608761
[00:00:02.383,789] <inf> eth_w5500: eth_w5500@0: Link up
[00:00:02.383,911] <inf> app_network: LINK UP
[00:00:07.582,427] <inf> net_dhcpv4: Received: 192.168.1.95
[00:00:07.582,580] <inf> app_network: Your address: 192.168.1.95
[00:00:07.582,580] <inf> app_network: Lease time: 4294967295 seconds
[00:00:07.582,641] <inf> app_network: Subnet: 255.255.255.0
[00:00:07.582,672] <inf> app_network: Router: 192.168.1.1
[00:00:07.582,794] <inf> app_network: Network connectivity established
[00:00:07.582,855] <inf> Main: Ethernet is Ready
[00:00:07.582,885] <inf> app_mqtt: tls_init 0
[00:00:07.582,885] <inf> app_mqtt: Initializing MQTT 
[00:00:07.701,812] <inf> app_mqtt: IPv4 Address found 52.70.185.82
[00:00:07.935,333] <inf> app_mqtt: mqtt_connect, -22
[00:00:08.935,424] <inf> app_mqtt: Initializing MQTT 
[00:00:08.980,041] <inf> app_mqtt: IPv4 Address found 54.204.31.69
[00:00:09.204,101] <inf> app_mqtt: mqtt_connect, -22
[00:00:10.204,223] <inf> app_mqtt: Initializing MQTT 
[00:00:10.210,235] <inf> app_mqtt: IPv4 Address found 52.4.41.178
[00:00:10.432,830] <inf> app_mqtt: mqtt_connect, -22
[00:00:11.432,952] <inf> app_mqtt: Initializing MQTT 
[00:00:11.475,982] <inf> app_mqtt: IPv4 Address found 54.145.177.121
[00:00:11.689,270] <inf> app_mqtt: mqtt_connect, -22
[00:00:12.689,331] <inf> app_mqtt: Initializing MQTT 
[00:00:12.694,732] <inf> app_mqtt: IPv4 Address found 52.7.86.229
[00:00:12.908,233] <inf> app_mqtt: mqtt_connect, -22
[00:00:13.908,325] <inf> app_mqtt: Initializing MQTT 
[00:00:13.913,696] <inf> app_mqtt: IPv4 Address found 52.54.187.118
[00:00:14.137,512] <inf> app_mqtt: mqtt_connect, -22
[00:00:15.137,603] <inf> app_mqtt: Initializing MQTT 
[00:00:15.143,707] <inf> app_mqtt: IPv4 Address found 54.209.10.217
[00:00:15.367,218] <inf> app_mqtt: mqtt_connect, -22
[00:00:16.367,279] <inf> app_mqtt: Initializing MQTT 
[00:00:16.373,321] <inf> app_mqtt: IPv4 Address found 52.70.185.82
[00:00:16.605,560] <inf> app_mqtt: mqtt_connect, -22
[00:00:17.605,682] <inf> app_mqtt: Initializing MQTT 
[00:00:17.611,419] <inf> app_mqtt: IPv4 Address found 52.2.217.188
[00:00:17.833,465] <inf> app_mqtt: mqtt_connect, -22
[00:00:18.833,526] <inf> app_mqtt: Initializing MQTT 
[00:00:18.838,989] <inf> app_mqtt: IPv4 Address found 52.4.36.166
[00:00:19.060,577] <inf> app_mqtt: mqtt_connect, -22

[rnicolas]

Did you solve this?

[haseebzaib]

Ya I actually did, but I dont remember how if you want I can share the project with you and using that you can figure it out yourself lol

[rnicolas]

Ah, no, no need, at least for me. I'm dealing with an ESP32S3, and right now I'm just dealing to set the correct permissions in AWS.

[haseebzaib]

here is https://github.com/haseebzaib/ESP32_AWS_Fleet_Provisioning
This could be helpful