Ip object delete error with two interfaces

Question

Hello, 
 
 I got an error sometimes when I disable all my IP stack while trying to delete the IP object. The error code is NX_SOCKETS_BOUND. 
 I don't understand why I got this, i disable and delete all the ip services first though... 
 
 void net_stop_all() { net_wifi_close(); net_http_server_stop(); net_dhcp_server_stop(); net_dhcp_client_stop(); net_ip_stop(); 
 } 
 
 void net_wifi_close() { if(wifi_on) { do { result = g_sf_wifi0.p_api->close(g_sf_wifi0.p_ctrl); tx_thread_sleep (50); } while(result != SSP_SUCCESS && result != SSP_ERR_NOT_OPEN); wifi_on = 0; } } 
 
 void net_http_server_stop() { if(http_server_initialized) { result = nx_http_server_stop(&g_http_server0); tx_thread_sleep (50); result = nx_http_server_delete(&g_http_server0); tx_thread_sleep (50); memset(&g_http_server0, 0, sizeof(g_http_server0)); http_server_initialized = 0; } } 
 void net_dhcp_server_stop() { if(dhcp_server_initialized) { result = nx_dhcp_server_stop(&g_dhcp_server0); tx_thread_sleep (50); result = nx_dhcp_server_delete(&g_dhcp_server0); tx_thread_sleep (50); memset(&g_dhcp_server0, 0, sizeof(g_dhcp_server0)); //result = g_wifi_stack.dhcpServerStop(g_wifi_stack_ctrl); dhcp_server_initialized = 0; } 
 } 
 void net_dhcp_client_stop() { if(wdhcp_client_on) { /* Start the DHCP Client on the secondary interface. */ result = nx_dhcp_interface_stop(&g_dhcp_client1, 0); tx_thread_sleep (50); result = nx_dhcp_interface_disable(&g_dhcp_client1, 0); tx_thread_sleep (50); wdhcp_client_on = 0; } if(edhcp_client_on) { result = nx_dhcp_interface_stop(&g_dhcp_client1, 1); tx_thread_sleep (50); result = nx_dhcp_interface_disable(&g_dhcp_client1, 1); tx_thread_sleep (50); edhcp_client_on = 0; } if(dhcp_client_initialized) { result = nx_dhcp_stop(&g_dhcp_client1); tx_thread_sleep (50); result = nx_dhcp_delete(&g_dhcp_client1); tx_thread_sleep (50); memset(&g_dhcp_client1, 0, sizeof(g_dhcp_client1)); dhcp_client_initialized = 0; } } 
 
 void net_ip_stop() { if(ip_initialized) { do{ result = nx_ip_delete(&g_ip1); tx_thread_sleep (50); memset(&g_ip1, 0, sizeof(g_ip1)); } while(result != 0); result = nx_packet_pool_delete(&g_packet_pool0); tx_thread_sleep (50); memset(&g_packet_pool0, 0, sizeof(g_packet_pool0)); ip_initialized = 0; } } 
 
 Sorry for the bad code format, i don't know how to make the code look better here :s 
 
 thanks in advance for any tips :) 
 
 Have a nice day, 
 
 Cl&eacute;ment.

JanetC · Accepted Answer

Hi Clement 
 
I checked with our development team and the reason for not checking the status return on the socket delete calls in nx_dhcp_delete(), etc, is that these functions first unbind the socket and clean up suspensions etc before deleting them. Anyway, if there are still sockets existing, the code can check for them directly by checking the values of : 
 
ip_ptr -> nx_ip_tcp_created_sockets_ptr -> nx_tcp_socket_name 
 
and 
 
ip_ptr -> nx_ip_udp_created_sockets_ptr -> nx_udp_socket_name 
 
So hopefully the custom http client socket is the hold up and deleting it will resolve your issue. 
 
Regards, 
Janet

JanetC · Answer

I take it the nx_ip_delete is still complaining of NX_SOCKETS_BOUND still. I copied the text above into a source code editor and found a few things missing/wrong. I tagged my comments with 'jlc'. Hopefully the formatting is preserved so it will be easier to read the code. 
 Try this and see if it resolves the problem. I will run a simple program using this code and see if I run into problems with nx_ip_delete. 
 Janet

Fullscreen 
 clement.txt 
 Download 
 
 uint32_t get_request_netx(ULONG host, uint32_t port, char *message, char *buffer_rcv) 
{
NX_PACKET *pkt;
UINT status = 0;
ULONG bytes_rcv = 0;
ULONG ip_status;
static NX_TCP_SOCKET sock;
static int have_connection = 0;

/* Ensure the IP instance has been initialized. */
status = nx_ip_interface_status_check(&g_ip1, 1, NX_IP_INITIALIZE_DONE, &ip_status, 100);//ip_connector
if(status != 0)
 status = nx_ip_interface_status_check(&g_ip1, 0, NX_IP_INITIALIZE_DONE, &ip_status, 100);//ip_connector

if (have_connection == 0 && status == 0) 
{
 // Create TCP Socket
 status = nx_tcp_socket_create(&g_ip1, &sock, "_Get_Request",
 NX_IP_NORMAL, NX_FRAGMENT_OKAY, NX_IP_TIME_TO_LIVE, 4096, NX_NULL, NX_NULL);//ip_connector
 if (status != NX_SUCCESS)
 {
 tx_event_flags_set(&eguard_event_flags, SEND_CLOUD_COMPLETE, TX_OR);
 return 'A';
 }

 // Socket bind
 status = nx_tcp_client_socket_bind(&sock, NX_ANY_PORT, NX_WAIT_FOREVER);
 if (status != NX_SUCCESS)
 {
 status = nx_tcp_socket_delete(&sock);
 tx_event_flags_set(&eguard_event_flags, SEND_CLOUD_COMPLETE, TX_OR);
 return 'B';
 }

 // Socket connect
 status = nx_tcp_client_socket_connect(&sock, host, (UINT)port, 100);
 if (status == NX_SUCCESS)
 {
 have_connection = 1;
 }
 else
 {
 nx_tcp_client_socket_unbind(&sock);
 nx_tcp_socket_delete(&sock);
 tx_event_flags_set(&eguard_event_flags, SEND_CLOUD_COMPLETE, TX_OR);
 return 'C';
 }
}

if (have_connection != 0)
{
 status = nx_packet_allocate(&g_packet_pool0, &pkt, NX_TCP_PACKET, NX_WAIT_FOREVER);
 if(status != NX_SUCCESS)
 {
 nx_tcp_socket_disconnect(&sock, 200);
 nx_tcp_client_socket_unbind(&sock);
 nx_tcp_socket_delete(&sock);
 tx_event_flags_set(&eguard_event_flags, SEND_CLOUD_COMPLETE, TX_OR);
 return 'G';
 }

 status = nx_packet_data_append(pkt, message, strlen(message), &g_packet_pool0, NX_WAIT_FOREVER);
 
 // Send data request
 status = nx_tcp_socket_send(&sock, pkt, 400);
 if (status == NX_SUCCESS)
 {
 NX_PACKET *pkt_rcv;
 char *p = buffer_rcv;
 
 status = nx_tcp_socket_receive(&sock, &pkt_rcv, 200);
 if (status == NX_SUCCESS)
 {
 status = nx_packet_data_retrieve(pkt_rcv, p, &bytes_rcv);
 if (status == NX_SUCCESS)
 {
 // ok!... or not
 }
 else
 { 
 // jlc missing unbind!
 // jlc missing packet releaes
 status = nx_tcp_socket_delete(&sock);
 tx_event_flags_set(&eguard_event_flags, SEND_CLOUD_COMPLETE, TX_OR);
 return 'F';
 }
 }
 else
 {
 // jlc missing unbind!
 status = nx_tcp_socket_delete(&sock);
 tx_event_flags_set(&eguard_event_flags, SEND_CLOUD_COMPLETE, TX_OR);
 return 'E';
 }

 // jlc do not release packet after a successful send. NetX/ NetX Duo does that automatically
 status = nx_packet_release(pkt_rcv);
 }
 else
 {
 // jlc missing packet release (unsuccessful socket send)
 tx_event_flags_set(&eguard_event_flags, SEND_CLOUD_COMPLETE, TX_OR);
 return 'D';
 }

 
}
else
{
 nx_packet_release(pkt); // jlc packet has not been allocated yet. no need to release
 nx_tcp_socket_disconnect(&sock, 200);
 nx_tcp_client_socket_unbind(&sock);
 tx_event_flags_set(&eguard_event_flags, SEND_CLOUD_COMPLETE, TX_OR);
 return 'D';
}

status = nx_tcp_socket_disconnect(&sock, 100);
status = nx_tcp_client_socket_unbind(&sock);
status = nx_tcp_socket_delete(&sock);
have_connection = 0;

tx_event_flags_set(&eguard_event_flags, SEND_CLOUD_COMPLETE, TX_OR);
return (uint32_t)bytes_rcv;

}

JanetC · Answer

Hi Clement 
 I created a simple project in e2 studio (an IP instance, a TCP socket, ethernet driver, packet pool) and ran your test file. I commented out the flag calls because I don't need to use them for just testing socket and IP handling by Net X Duo. So a couple places packets were not released where they should be, and a couple more places where sockets were not disconnected and unbound/deleted. 
 I think you could make the code easier to follow by this general logic: 
 call netx api. 
 if status not successful 
 { 
 log an error 
 close socket 
 return error status 
 } 
 call next api. 
 If you check for successful status, that leads to highly indented code which makes tracking packet leaks and improperly closed sockets more difficult. 
 Also general rule, you only need to release packets if nx_tcp_socket_send or nx_packet_data_append fails. Also after you have successfully received a packet from the socket, and are done with it, you need to release it. All other times NetX takes care of releasing the packet. 
 Attached is my thread entry.c file with additional comments:

Fullscreen 
 clement_101819.txt 
 Download 
 
 #include "new_thread0.h"
#include "nx_api.h"
\
extern VOID (*g_sf_el_nx)(NX_IP_DRIVER *driver_req_ptr) ;

/* New Thread entry function */
void new_thread0_entry(void)
{

 UINT status;

 UINT errors = 0;

#ifndef NX_DISABLE_PACKET_CHAIN
 status = 0xFFFFFFFF;
#endif


 //status = nx_ip_interface_capability_set(&g_ip0, 0, NX_INTERFACE_CAPABILITY_ICMPV4_TX_CHECKSUM);

 status = nx_ip_fragment_enable(&g_ip0);

 /* Spin while netx duo processes IPv6 packets. */
 while(1)
 tx_thread_sleep (100);

 status = nx_ip_interface_detach(&g_ip0, 0);

 if (status)
 errors++;

 tx_thread_sleep (100);

 status = nx_ip_interface_attach(&g_ip0,"name", IP_ADDRESS(192,2,2,66), 0xFFFFFF00, g_sf_el_nx);
 if (status)
 errors++;

}