j3d1/open-ameba
1
0
Fork 0
mirror of https://github.com/drasko/open-ameba.git synced 2024-11-28 17:20:32 +00:00
Code Issues Projects Releases Packages Wiki Activity
open-ameba/RTL00_SDKV35a/component/common/api/at_cmd/atcmd_lwip.c
pvvx 494a7e1b39 update
2016-12-05 11:48:41 +03:00

2263 lines
56 KiB
C
Raw Blame History

#include <platform/platform_stdlib.h>
#include <platform_opts.h>
#ifdef CONFIG_AT_LWIP
#include <stdio.h>
#include "log_service.h"
#include "atcmd_wifi.h"
#include "atcmd_lwip.h"
#include "osdep_service.h"
#include "osdep_api.h"
#include "tcpip.h"
#include "lwip/tcp_impl.h"
#ifndef ATCMD_VER
#define ATVER_1 1
#define ATVER_2 2
#define ATCMD_VER ATVER_2
#if CONFIG_EXAMPLE_UART_ATCMD
#define ATCMD_VER ATVER_2
#else
#define ATCMD_VER ATVER_1
#endif
#endif
//#define MAX_BUFFER 256
#define MAX_BUFFER (LOG_SERVICE_BUFLEN)
#define ATCP_STACK_SIZE 512//2048
extern char log_buf[LOG_SERVICE_BUFLEN];
extern struct netif xnetif[NET_IF_NUM];
static unsigned char tx_buffer[MAX_BUFFER];
static unsigned char rx_buffer[MAX_BUFFER];
#if ATCMD_VER == ATVER_2
node node_pool[NUM_NS];
node* mainlist;
static int atcmd_lwip_auto_recv = FALSE;
volatile int atcmd_lwip_tt_mode = FALSE; //transparent transmission mode
xTaskHandle atcmd_lwip_tt_task = NULL;
xSemaphoreHandle atcmd_lwip_tt_sema = NULL;
volatile int atcmd_lwip_tt_datasize = 0;
volatile int atcmd_lwip_tt_lasttickcnt = 0;
#ifdef ERRNO
_WEAK int errno = 0; //LWIP errno
#endif
static void atcmd_lwip_receive_task(void *param);
int atcmd_lwip_start_autorecv_task(void);
int atcmd_lwip_is_autorecv_mode(void);
void atcmd_lwip_set_autorecv_mode(int enable);
int atcmd_lwip_start_tt_task(void);
int atcmd_lwip_is_tt_mode(void);
void atcmd_lwip_set_tt_mode(int enable);
int atcmd_lwip_write_info_to_flash(struct atcmd_lwip_conn_info *cur_conn, int enable);
#else //#if ATCMD_VER == ATVER_2
xTaskHandle server_task = NULL;
xTaskHandle client_task = NULL;
static int mode = 0;
static int local_port;
static int remote_port;
static char remote_addr[16];
static int packet_size;
static int sockfd, newsockfd;
static socklen_t client;
static struct sockaddr_in serv_addr, cli_addr;
static int opt = 1;
static int type; //TCP SERVER:1, TCP CLIENT: 2, UDP SERVER:3, UDP CLIENT: 4
static void init_transport_struct(void)
{
mode = 0;
local_port = 0;
remote_port = 0;
sockfd = -1;
newsockfd = -1;
packet_size = 0;
_memset(remote_addr, 0, sizeof(remote_addr));
_memset(&client, 0, sizeof(client));
_memset(&serv_addr, 0, sizeof(serv_addr));
}
void socket_close(void)
{
close(sockfd);
if(server_task != NULL)
{
vTaskDelete(server_task);
server_task = NULL;
}
if(client_task != NULL)
{
vTaskDelete(client_task);
client_task = NULL;
}
type = 0;
init_transport_struct();
}
#endif //#if ATCMD_VER == ATVER_2
static void server_start(void *param)
{
int s_mode;
int s_sockfd, s_newsockfd;
socklen_t s_client;
struct sockaddr_in s_serv_addr, s_cli_addr;
int s_local_port;
int error_no = 0;
int s_opt = 1;
#if ATCMD_VER == ATVER_2
node* ServerNodeUsed = (node*)param;
if(ServerNodeUsed){
s_mode = ServerNodeUsed->protocol;
s_local_port = ServerNodeUsed->port;
}
// else
//#endif
#else
{
s_mode = mode;
s_local_port = local_port;
s_opt = opt;
}
#endif
if(s_mode == NODE_MODE_UDP)
s_sockfd = socket(AF_INET,SOCK_DGRAM,0);
else
s_sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (s_sockfd == INVALID_SOCKET_ID) {
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,"ERROR opening socket");
error_no = 5;
goto err_exit;
}
if((setsockopt(s_sockfd, SOL_SOCKET, SO_REUSEADDR, (const char *)&s_opt, sizeof(s_opt))) < 0){
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,"ERROR on setting socket option");
error_no = 6;
goto err_exit;
}
memset((char *)&s_serv_addr, 0, sizeof(s_serv_addr));
s_serv_addr.sin_family = AF_INET;
s_serv_addr.sin_addr.s_addr = INADDR_ANY;
s_serv_addr.sin_port = htons(s_local_port);
if (bind(s_sockfd, (struct sockaddr *)&s_serv_addr,sizeof(s_serv_addr)) < 0) {
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,"ERROR on binding");
error_no = 7;
goto err_exit;
}
#if ATCMD_VER == ATVER_2
if(ServerNodeUsed != NULL) {
uint8_t *ip = (uint8_t *)LwIP_GetIP(&xnetif[0]);
ServerNodeUsed->sockfd = s_sockfd;
ServerNodeUsed->addr = ntohl(*((u32_t *)ip));
}
// else
//#endif
#else
{
sockfd = s_sockfd;
memcpy(&serv_addr, &s_serv_addr, sizeof(s_serv_addr));
}
#endif
if (s_mode == NODE_MODE_TCP){//TCP MODE
if(listen(s_sockfd , 5) < 0){
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,"ERROR on listening");
error_no = 8;
goto err_exit;
}
#if ATCMD_VER == ATVER_2
if(param != NULL) {
if(hang_node(ServerNodeUsed) < 0)
{
error_no = 9;
goto err_exit;
}else{
#if CONFIG_LOG_SERVICE_LOCK
log_service_lock();
#endif
at_printf("\r\n[ATPS] OK"
"\r\n[ATPS] con_id=%d",
ServerNodeUsed->con_id);
at_printf(STR_END_OF_ATCMD_RET);
#if CONFIG_LOG_SERVICE_LOCK
log_service_unlock();
#endif
}
}
#endif
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,"The TCP SERVER START OK!");
s_client = sizeof(s_cli_addr);
while(1){
if((s_newsockfd = accept(s_sockfd,(struct sockaddr *) &s_cli_addr,&s_client)) < 0){
#if ATCMD_VER == ATVER_2
if(param != NULL) {
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,
"[ATPS] ERROR:ERROR on accept");
}
// else
//#endif
#else
{
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,
"ERROR on accept");
}
#endif
error_no = 10;
goto err_exit;
}
else{
#if ATCMD_VER == ATVER_2
if(param != NULL) {
node* seednode = create_node(s_mode, NODE_ROLE_SEED);
if(seednode == NULL){
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,
"[ATPS]create node failed!");
error_no = 11;
goto err_exit;
}
seednode->sockfd = s_newsockfd;
seednode->port = ntohs(s_cli_addr.sin_port);
seednode->addr = ntohl(s_cli_addr.sin_addr.s_addr);
if(hang_seednode(ServerNodeUsed,seednode) < 0){
delete_node(seednode);
seednode = NULL;
}
else{
#if CONFIG_LOG_SERVICE_LOCK
log_service_lock();
#endif
at_printf("\r\n[ATPS] A client connected to server[%d]\r\n"
"con_id:%d,"
"seed,"
"tcp,"
"address:%s,"
"port:%d,"
"socket:%d",
ServerNodeUsed->con_id,
seednode->con_id,
inet_ntoa(s_cli_addr.sin_addr.s_addr),
ntohs(s_cli_addr.sin_port),
seednode->sockfd
);
at_printf(STR_END_OF_ATCMD_RET);
#if CONFIG_LOG_SERVICE_LOCK
log_service_unlock();
#endif
}
}
// else
//#endif
#else
{
newsockfd = s_newsockfd;
memcpy(&cli_addr, &s_cli_addr, sizeof(cli_addr));
client = s_client;
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,
"A client connected to this server :\r\n[PORT]: %d\r\n[IP]:%s",
ntohs(cli_addr.sin_port), inet_ntoa(cli_addr.sin_addr.s_addr));
}
#endif
}
}
}
else{
#if ATCMD_VER == ATVER_2
if(ServerNodeUsed != NULL) {
if(hang_node(ServerNodeUsed) < 0){
error_no = 12;
goto err_exit;
}
#if CONFIG_LOG_SERVICE_LOCK
log_service_lock();
#endif
at_printf("\r\n[ATPS] OK"
"\r\n[ATPS] con_id=%d",
ServerNodeUsed->con_id);
at_printf(STR_END_OF_ATCMD_RET);
#if CONFIG_LOG_SERVICE_LOCK
log_service_unlock();
#endif
//task will exit itself
ServerNodeUsed->handletask = NULL;
}
#endif
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,"The UDP SERVER START OK!");
}
goto exit;
err_exit:
#if ATCMD_VER == ATVER_2
if(ServerNodeUsed){
//task will exit itself if getting here
ServerNodeUsed->handletask = NULL;
delete_node(ServerNodeUsed);
}
//else
//#endif
#else
{
socket_close();
}
#endif
#if CONFIG_LOG_SERVICE_LOCK
log_service_lock();
#endif
at_printf("\r\n[ATPS] ERROR:%d", error_no);
at_printf(STR_END_OF_ATCMD_RET);
#if CONFIG_LOG_SERVICE_LOCK
log_service_unlock();
#endif
exit:
return;
}
static void client_start(void *param)
{
int c_mode;
int c_remote_port;
char c_remote_addr[16];
int c_sockfd;
struct sockaddr_in c_serv_addr;
int error_no = 0;
#if ATCMD_VER == ATVER_2
struct in_addr c_addr;
node * ClientNodeUsed = (node *)param;
if(ClientNodeUsed){
c_mode = ClientNodeUsed->protocol;
c_remote_port = ClientNodeUsed->port;
c_addr.s_addr = htonl(ClientNodeUsed->addr);
if(inet_ntoa_r(c_addr, c_remote_addr, sizeof(c_remote_addr))==NULL){
error_no = 6;
goto err_exit;
}
}
//else
//#endif
#else
{
c_mode = mode;
c_remote_port = remote_port;
memcpy(c_remote_addr, remote_addr, 16*sizeof(char));
}
#endif
if(c_mode == NODE_MODE_UDP)
c_sockfd = socket(AF_INET,SOCK_DGRAM,0);
else
c_sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (c_sockfd == INVALID_SOCKET_ID) {
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,"Failed to create sock_fd!");
error_no = 7;
goto err_exit;
}
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,"OK to create sock_fd!");
memset(&c_serv_addr, 0, sizeof(c_serv_addr));
c_serv_addr.sin_family = AF_INET;
c_serv_addr.sin_addr.s_addr = inet_addr(c_remote_addr);
c_serv_addr.sin_port = htons(c_remote_port);
#if ATCMD_VER == ATVER_2
if(ClientNodeUsed){
ClientNodeUsed->sockfd = c_sockfd;
}
//else
//#endif
#else
{
sockfd = c_sockfd;
memcpy(&serv_addr, &c_serv_addr, sizeof(c_serv_addr));
}
#endif
if (c_mode == NODE_MODE_TCP){//TCP MODE
if(connect(c_sockfd, (struct sockaddr *)&c_serv_addr, sizeof(c_serv_addr)) == 0){
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,"Connect to Server successful!");
#if ATCMD_VER == ATVER_2
if(ClientNodeUsed != NULL) {
if(hang_node(ClientNodeUsed) < 0){
error_no = 8;
goto err_exit;
}
#if CONFIG_LOG_SERVICE_LOCK
log_service_lock();
#endif
at_printf("\r\n[ATPC] OK\r\n[ATPC] con_id=%d",ClientNodeUsed->con_id);
at_printf(STR_END_OF_ATCMD_RET);
#if CONFIG_LOG_SERVICE_LOCK
log_service_unlock();
#endif
}
#endif
}else{
#if ATCMD_VER == ATVER_2
if(ClientNodeUsed != NULL) {
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,"[ATPC] ERROR:Connect to Server failed!");
}
//else
//#endif
#else
{
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,"Connect to Server failed!");
}
#endif
error_no = 9;
goto err_exit;
}
}
else{
#if ATCMD_VER == ATVER_2
if(ClientNodeUsed != NULL) {
if(ClientNodeUsed->local_port){
struct sockaddr_in addr;
memset(&addr, 0, sizeof(addr));
addr.sin_family=AF_INET;
addr.sin_port=htons(ClientNodeUsed->local_port);
addr.sin_addr.s_addr=htonl(INADDR_ANY) ;
if (bind(ClientNodeUsed->sockfd, (struct sockaddr *)&addr, sizeof(addr))<0) {
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,"bind sock error!");
error_no = 12;
goto err_exit;
}
}
if(hang_node(ClientNodeUsed) < 0){
error_no = 10;
goto err_exit;
}
#if CONFIG_LOG_SERVICE_LOCK
log_service_lock();
#endif
at_printf("\r\n[ATPC] OK\r\n[ATPC] con_id=%d",ClientNodeUsed->con_id);
at_printf(STR_END_OF_ATCMD_RET);
#if CONFIG_LOG_SERVICE_LOCK
log_service_unlock();
#endif
}
#endif
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,"UDP client starts successful!");
}
goto exit;
err_exit:
#if ATCMD_VER == ATVER_2
if(ClientNodeUsed)
{
delete_node(ClientNodeUsed);
}
//else
//#endif
#else
{
socket_close();
}
#endif
#if CONFIG_LOG_SERVICE_LOCK
log_service_lock();
#endif
at_printf("\r\n[ATPC] ERROR:%d", error_no);
at_printf(STR_END_OF_ATCMD_RET);
#if CONFIG_LOG_SERVICE_LOCK
log_service_unlock();
#endif
exit:
return;
}
static void client_start_task(void *param)
{
vTaskDelay(1000);
#if ATCMD_VER == ATVER_2
if(param){
client_start(param);
vTaskDelete(NULL);
return;
}
//#endif
#else
if(remote_addr == NULL){
printf("[ERROR] Please using ATP3 to input an valid remote IP address!\n");
vTaskDelete(client_task);
client_task = NULL;
}
else if(remote_port == 0){
printf("[ERROR] Please using ATP4 to input an valid remote PORT!\n");
vTaskDelete(client_task);
client_task = NULL;
}
else{
printf("\tStart Client\n\t[IP]: %s\n\t[PORT]:%d\n", remote_addr, remote_port);
client_start(param);
}
#endif
vTaskDelete(NULL);
}
static void server_start_task(void *param)
{
vTaskDelay(1000);
#if ATCMD_VER == ATVER_2
if(param != NULL){
server_start(param);
vTaskDelete(NULL);
return;
}
//#endif
#else
if(local_port == 0){
printf("[ERROR] Please using ATP2 to input an valid local PORT!\n");
vTaskDelete(server_task);
server_task = NULL;
}
else{
uint8_t *ip = (uint8_t *)LwIP_GetIP(&xnetif[0]);
printf("Start Server\n\t[IP]: %d.%d.%d.%d\n\t[PORT]:%d\n", ip[0], ip[1], ip[2], ip[3], local_port);
server_start(param);
}
#endif
vTaskDelete(NULL);
}
//AT Command function
#if ATCMD_VER == ATVER_1
void fATP1(void *arg){
if(!arg){
printf("[ATP1]Usage: ATP1=MODE\n\r");
goto exit;
}
mode = atoi((char*)arg);
printf("[ATP1]: _AT_TRANSPORT_MODE_ [%d]\n\r", mode);
exit:
return;
}
void fATP2(void *arg){
if(!arg){
printf("[ATP2]Usage: ATP2=LOCAL_PORT\n\r");
goto exit;
}
local_port = atoi((char*)arg);
printf("[ATP2]: _AT_TRANSPORT_LOCAL_PORT_ [%d]\n\r", local_port);
exit:
return;
}
void fATP3(void *arg){
if(!arg){
printf("[ATP3]Usage: ATP3=REMOTE_IP\n\r");
goto exit;
}
strcpy((char*)remote_addr, (char*)arg);
printf("[ATP3]: _AT_TRANSPORT_REMOTE_IP_ [%s]\n\r", remote_addr);
exit:
return;
}
void fATP4(void *arg){
if(!arg){
printf("[ATP4]Usage: ATP4=REMOTE_PORT\n\r");
goto exit;
}
remote_port = atoi((char*)arg);
printf("[ATP4]: _AT_TRANSPORT_REMOTE_PORT_ [%d]\n\r", remote_port);
exit:
return;
}
void fATP5(void *arg){
int server_status = 0;
if(!arg){
printf("[ATP5]Usage: ATP5=0/1(0:server disable; 1: server enable)\n\r");
goto exit;
}
server_status = atoi((char*)arg);
printf("[ATP5]: _AT_TRANSPORT_START_SERVER_ [%d]\n\r", server_status);
if(mode == 0){
if(server_status == 0){
socket_close();
type = 0;
}
else if(server_status == 1){
if(server_task == NULL)
{
if(xTaskCreate(server_start_task, ((const char*)"server_start_task"), ATCP_STACK_SIZE, NULL, ATCMD_LWIP_TASK_PRIORITY, &server_task) != pdPASS)
printf("[ATP5]ERROR: Create tcp server task failed.\r\n");
}
type = 1;
}
else
printf("[ATP5]ERROR: Just support two mode : 0 or 1\n\r");
}
else if(mode == 1){
if(server_status == 0){
socket_close();
type = 0;
}
else if(server_status == 1){
if(server_task == NULL)
{
if(xTaskCreate(server_start_task, ((const char*)"server_start_task"), ATCP_STACK_SIZE, NULL, ATCMD_LWIP_TASK_PRIORITY, &server_task) != pdPASS)
printf("[ATP5]ERROR: Create udp server task failed.\n");
}
type = 3;
}
else
printf("[ATP5]ERROR: Just support two mode : 0 or 1\n\r");
}
else
printf("[ATP5]Error: mode(TCP/UDP) can't be empty\n\r");
exit:
return;
}
void fATP6(void *arg){
int client_status = 0;
if(!arg){
printf("[ATP6]Usage: ATP6=0/1(0:Client disable; 1: Client enable)\n\r");
goto exit;
}
client_status = atoi((char*)arg);
printf("[ATP6]: _AT_TRANSPORT_START_CLIENT_ [%d]\n\r", client_status);
if(mode == 0){
if(client_status == 0){
socket_close();
type = 0;
}
else if(client_status == 1){
printf("[ATP6]TCP Client mode will start\n");
if(client_task == NULL)
{
if(xTaskCreate(client_start_task, ((const char*)"client_start_task"), ATCP_STACK_SIZE, NULL, ATCMD_LWIP_TASK_PRIORITY, &client_task) != pdPASS)
printf("[ATP6]ERROR: Create tcp client task failed.\n");
}
type = 2;
}
else
printf("[ATP6]ERROR: Just support two mode : 0 or 1\n\r");
}
else if(mode == 1){
if(client_status == 0){
socket_close();
type = 0;
}
else if(client_status == 1){
if(client_task == NULL)
{
if(xTaskCreate(client_start_task, ((const char*)"client_start_task"), ATCP_STACK_SIZE, NULL, ATCMD_LWIP_TASK_PRIORITY, &client_task) != pdPASS)
printf("[ATP6]ERROR: Create udp client task failed.\n");
}
type = 4;
}
else
printf("[ATP6]ERROR: Just support two mode : 0 or 1\n\r");
}
else
printf("[ATP6]Error: mode(TCP/UDP) can't be empty\n\r");
exit:
return;
}
void fATPZ(void *arg){
uint8_t *ip;
printf("\nThe current Transport settings:\n");
printf("==============================\n");
if(mode == 0)
printf(" Protocol: TCP\n");
else if(mode == 1)
printf(" Protocol: UDP\n");
ip = (uint8_t *)LwIP_GetIP(&xnetif[0]);
printf(" LOCAL_IP => %d.%d.%d.%d\n", ip[0], ip[1], ip[2], ip[3]);
printf(" LOCAL_PORT => %d\n", local_port);
printf(" REMOTE_IP => %s\n", remote_addr);
printf(" REMOTE_PORT => %d\n", remote_port);
// printf("\n\r");
}
void fATR0(void *arg){
if(packet_size <= 0){
packet_size = MAX_BUFFER;
printf("[ATR0]Notice: Didn't set the value of packet_size, will using the MAX_BUFFER: %d\n", MAX_BUFFER);
}
memset(rx_buffer, 0, MAX_BUFFER);
if(type == 1){//tcp server
if((read(newsockfd,rx_buffer,MAX_BUFFER)) > 0)
printf("[ATR0]Receive the data:%s\n with packet_size: %d\n", rx_buffer, packet_size);
else
printf("[ATR0]ERROR: Failed to receive data!\n");
close(newsockfd);
newsockfd = -1;
}
else{
if((read(sockfd,rx_buffer,MAX_BUFFER)) > 0)
printf("[ATR0]Receive the data:%s\n with packet_size: %d\n", rx_buffer, packet_size);
else
printf("[ATR0]ERROR: Failed to receive data!\n");
}
}
void fATR1(void *arg){
int size;
if(!arg){
printf("[ATR1]Usage: ATR1=packet_size(cannot exceed %d)\n\r", MAX_BUFFER);
goto exit;
}
size = atoi((char*)arg);
printf("[ATR1]: _AT_TRANSPORT_RECEIVE_PACKET_SIZE_ [%d]\n\r", size);
if(size < 1)
printf("[ATR1]Error: packet size need be larger than 0!\n\r");
else if(size > MAX_BUFFER)
printf("[ATR1]Error: packet size exceeds the MAX_BUFFER value: %d!\n\r", MAX_BUFFER);
else
packet_size = size;
exit:
return;
}
void fATRA(void *arg){
if(!arg){
printf("[ATRA]Usage: ATRA=[data](Data size cannot exceed the MAX_BUFFER SIZE: %d)\n\r", MAX_BUFFER);
return;
}
if(packet_size <= 0){
packet_size = MAX_BUFFER;
printf("[ATRA]Notice: Didn't set the value of packet_size, will using the MAX_BUFFER SIZE: %d\n", MAX_BUFFER);
}
int argc;
char *argv[MAX_ARGC] = {0};
if((argc = parse_param(arg, argv)) != 2){
printf("[ATRA]Usage: ATRA=[data](Data size cannot exceed the MAX_BUFFER SIZE: %d)\n\r", MAX_BUFFER);
goto exit;
}
else
printf("[ATRA]: _AT_TRANSPORT_WRITE_DATA_ [%s]\n\r", argv[1]);
memset(tx_buffer, 0, MAX_BUFFER);
memcpy(tx_buffer, argv[1], strlen(argv[1]));
if(type == 1){//tcp server
if((write(newsockfd,tx_buffer,strlen(tx_buffer))) > 0)
printf("[ATRA] Sending data:%s\n with packet_size:%d\n", tx_buffer, packet_size);
else
printf("[ATRA]ERROR: Failed to send data\n");
close(newsockfd);
newsockfd = -1;
}
else if(type == 4){//udp client
int ret = 0;
ret = sendto(sockfd, tx_buffer, strlen(tx_buffer), 0, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
printf("The value of ret is %d\n", ret);
}
else if(type == 3)
printf("The UDP Server mode not support Sending data service!\n");
else{
if((write(sockfd,tx_buffer, strlen(tx_buffer))) > 0)
printf("[ATRA] Sending data:%s\n with packet_size:%d\n", tx_buffer, packet_size);
else
printf("[ATRA]ERROR: Failed to send data\n");
}
exit:
return;
}
void fATRB(void *arg){
int size;
if(!arg){
printf("[ATRB]Usage: ATRB=packet_size(cannot exceed %d)\n\r", MAX_BUFFER);
goto exit;
}
size = atoi((char*)arg);
printf("[ATRB]: _AT_TRANSPORT_WRITE_PACKET_SIZE_ [%d]\n\r", size);
if(size < 1)
printf("[ATRB]Error: packet size need be larger than 0!\n\r");
else if(size > MAX_BUFFER)
printf("[ATRB]Error: packet size exceeds the MAX_BUFFER value: %d!\n\r", MAX_BUFFER);
else
packet_size = size;
exit:
return;
}
#endif
#if ATCMD_VER == ATVER_2
void fATP0(void *arg){
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,
"[ATP0]: _AT_TRANSPORT_ERRNO");
#ifdef ERRNO
at_printf("\r\n[ATP0] OK:%d", errno);
#else
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,"errno isn't enabled");
at_printf("\r\n[ATP0] ERROR");
#endif
}
void fATPC(void *arg){
int argc;
char* argv[MAX_ARGC] = {0};
node* clientnode = NULL;
int mode = 0;
int remote_port;
int local_port = 0;
//char remote_addr[DNS_MAX_NAME_LENGTH];
struct in_addr addr;
int error_no = 0;
#if LWIP_DNS
struct hostent *server_host;
#endif
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,
"[ATPC]: _AT_TRANSPORT_START_CLIENT");
if(atcmd_lwip_is_tt_mode() && mainlist->next){
error_no = 13;
goto err_exit;
}
argc = parse_param(arg, argv);
if(argc < 4){
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,
"[ATPC] Usage: ATPC=<TCP:0/UDP:1>,<REMOTE_IP>,<REMOTE_Port(1~65535)>,[<LOCAL_PORT>]");
error_no = 1;
goto err_exit;
}
mode = atoi((char*)argv[1]);//tcp or udp
//strcpy((char*)remote_addr, (char*)argv[2]);
remote_port = atoi((char*)argv[3]);
if (inet_aton(argv[2], &addr) == 0)
{
#if LWIP_DNS
server_host = gethostbyname(argv[2]);
if (server_host){
memcpy(&addr, server_host->h_addr, 4);
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,
"[ATPC] Found name '%s' = %s",
argv[2],
inet_ntoa(addr)
);
}
else
#endif
{
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,
"[ATPC] ERROR: Host '%s' not found.", argv[2]);
error_no = 2;
goto err_exit;
}
}
if(remote_port < 0 || remote_port > 65535) {
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,
"[ATPC] ERROR: remote port invalid");
error_no = 3;
goto err_exit;
}
if(argv[4]){
local_port = atoi((char*)argv[4]);
if(local_port < 0 || local_port > 65535) {
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,
"[ATPC] ERROR: local port invalid");
error_no = 11;
goto err_exit;
}
}
clientnode = create_node(mode, NODE_ROLE_CLIENT);
if(clientnode == NULL){
error_no = 4;
goto err_exit;
}
clientnode->port = remote_port;
clientnode->addr = ntohl(addr.s_addr);
clientnode->local_port = local_port;
if(xTaskCreate(client_start_task, ((const char*)"client_start_task"), ATCP_STACK_SIZE, clientnode, ATCMD_LWIP_TASK_PRIORITY, NULL) != pdPASS)
{
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,
"[ATPC] ERROR: Create tcp/udp client task failed.");
error_no = 5;
goto err_exit;
}
goto exit;
err_exit:
if(clientnode)
delete_node(clientnode);
at_printf("\r\n[ATPC] ERROR:%d", error_no);
exit:
return;
}
void fATPS(void *arg){
int argc;
char *argv[MAX_ARGC] = {0};
node* servernode = NULL;
int mode;
int local_port;
int error_no = 0;
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,
"[ATPS]: _AT_TRANSPORT_START_SERVER");
if(atcmd_lwip_is_tt_mode()){
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,
"[ATPS] ERROR: Server can only start when TT is disabled");
error_no = 13;
goto err_exit;
}
argc = parse_param(arg, argv);
if(argc != 3){
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,
"[ATPS] Usage: ATPS=[TCP:0/UDP:1],[Local port(1~65535)]");
error_no = 1;
goto err_exit;
}
mode = atoi((char*)argv[1]);
local_port = atoi((char*)argv[2]);
if(local_port < 0 || local_port > 65535){
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,
"[ATPS] Usage: ATPS=[TCP:0/UDP:1],[Local port]");
error_no = 2;
goto err_exit;
}
servernode = create_node(mode, NODE_ROLE_SERVER);
if(servernode == NULL){
error_no = 3;
goto err_exit;
}
servernode->port = local_port;
if(xTaskCreate(server_start_task, ((const char*)"server_start_task"), ATCP_STACK_SIZE, servernode, ATCMD_LWIP_TASK_PRIORITY, &servernode->handletask) != pdPASS)
{
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,
"[ATPS] ERROR: Create tcp/udp server task failed.");
error_no = 4;
goto err_exit;
}
goto exit;
err_exit:
if(servernode)
delete_node(servernode);
at_printf("\r\n[ATPS] ERROR:%d", error_no);
exit:
return;
}
void socket_close_all(void)
{
node *currNode = mainlist->next;
while(currNode)
{
delete_node(currNode);
currNode = mainlist->next;
}
currNode = NULL;
}
void fATPD(void *arg){
int con_id = INVALID_CON_ID;
int error_no = 0;
node *s_node;
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,
"[ATPD]: _AT_TRANSPORT_CLOSE_CONNECTION");
if(!arg){
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,
"[ATPD] Usage: ATPD=con_id or 0 (close all)");
error_no = 1;
goto exit;
}
con_id = atoi((char*)arg);
if(con_id == 0){
if(atcmd_lwip_is_autorecv_mode()){
atcmd_lwip_set_autorecv_mode(FALSE);
}
socket_close_all();
goto exit;
}
s_node = seek_node(con_id);
if(s_node == NULL){
error_no = 3;
goto exit;
}
delete_node(s_node);
exit:
s_node = NULL;
if(error_no)
at_printf("\r\n[ATPD] ERROR:%d", error_no);
else
at_printf("\r\n[ATPD] OK");
return;
}
int atcmd_lwip_send_data(node *curnode, u8 *data, u16 data_sz, struct sockaddr_in cli_addr){
int error_no = 0;
if((curnode->protocol == NODE_MODE_UDP) && (curnode->role == NODE_ROLE_SERVER))
{
if (sendto(curnode->sockfd, data, data_sz, 0, (struct sockaddr *)&cli_addr, sizeof(cli_addr)) <= 0 ){
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,
"[ATPT] ERROR:Failed to send data");
error_no = 5;
}
}else{
if(curnode->protocol == NODE_MODE_UDP) //UDP server
{
struct sockaddr_in serv_addr;
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(curnode->port);
serv_addr.sin_addr.s_addr = htonl(curnode->addr);
if(sendto( curnode->sockfd, data, data_sz, 0, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) <= 0){
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,
"[ATPT] ERROR:Failed to send data\n");
error_no = 6;
}
}else if(curnode->protocol == NODE_MODE_TCP)//TCP server
{
if(curnode->role == NODE_ROLE_SERVER){
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,
"[ATPT] ERROR: TCP Server must send data to the seed");
error_no = 7;
goto exit;
}
if((write(curnode->sockfd, data, data_sz)) <= 0){
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,
"[ATPT] ERROR:Failed to send data\n");
error_no = 8;
}
}
}
exit:
return error_no;
}
void fATPT(void *arg){
int argc;
char *argv[MAX_ARGC] = {0};
int con_id = INVALID_CON_ID;
int error_no = 0;
node* curnode = NULL;
struct sockaddr_in cli_addr;
int data_sz;
int data_pos = C_NUM_AT_CMD + C_NUM_AT_CMD_DLT+ strlen(arg) + 1;
u8 *data = (u8 *)log_buf + data_pos;
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,
"[ATPT]: _AT_TRANSPORT_SEND_DATA");
argc = parse_param(arg, argv);
if(argc != 3 && argc != 5) {
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,
"[ATPT] Usage: ATPT=<data_size>,"
"<con_id>[,<dst_ip>,<dst_port>]"
":<data>(MAX %d)",
MAX_BUFFER);
error_no = 1;
goto exit;
}
data_sz = atoi((char*)argv[1]);
if(data_sz > MAX_BUFFER){
error_no = 2;
goto exit;
}
con_id = atoi((char*)argv[2]);
curnode = seek_node(con_id);
if(curnode == NULL){
error_no = 3;
goto exit;
}
if((curnode->protocol == NODE_MODE_UDP)
&&(curnode->role == NODE_ROLE_SERVER))
{
char udp_clientaddr[16]={0};
strcpy((char*)udp_clientaddr, (char*)argv[3]);
cli_addr.sin_family = AF_INET;
cli_addr.sin_port = htons(atoi((char*)argv[4]));
if (inet_aton(udp_clientaddr , &cli_addr.sin_addr) == 0)
{
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,
"[ATPT]ERROR:inet_aton() failed");
error_no = 4;
goto exit;
}
}
error_no = atcmd_lwip_send_data(curnode, data, data_sz, cli_addr);
exit:
if(error_no)
at_printf("\r\n[ATPT] ERROR:%d,%d", error_no, con_id);
else
at_printf("\r\n[ATPT] OK,%d", con_id);
return;
}
void fATPR(void *arg){
int argc,con_id = INVALID_CON_ID;
char *argv[MAX_ARGC] = {0};
int error_no = 0;
int recv_size = 0;
int packet_size = 0;
node* curnode = NULL;
u8_t udp_clientaddr[16] = {0};
u16_t udp_clientport = 0;
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,
"[ATPR]: _AT_TRANSPORT_RECEIVE_DATA");
if(atcmd_lwip_is_autorecv_mode()){
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,
"[ATPR] ERROR: Receive changed to auto mode.");
error_no = 10;
goto exit;
}
argc = parse_param(arg, argv);
if( argc != 3){
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,
"[ATPR] Usage: ATPR =<con_id>,<Buffer Size>\n\r");
error_no = 1;
goto exit;
}
con_id = atoi((char*)argv[1]);
if(con_id <= 0 || con_id > NUM_NS){
error_no = 9;
goto exit;
}
packet_size = atoi((char*)argv[2]);
if(packet_size <= 0 || packet_size > MAX_BUFFER){
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,
"[ATPR] Recv Size(%d) exceeds MAX_BUFFER(%d)", packet_size,
MAX_BUFFER);
error_no = 2;
goto exit;
}
curnode = seek_node(con_id);
if(curnode == NULL){
error_no = 3;
goto exit;
}
if(curnode->protocol == NODE_MODE_TCP && curnode->role == NODE_ROLE_SERVER){
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,
"[ATPR] ERROR: TCP Server must receive data from the seed");
error_no = 6;
goto exit;
}
memset(rx_buffer, 0, MAX_BUFFER);
error_no = atcmd_lwip_receive_data(curnode, rx_buffer, ETH_MAX_MTU, &recv_size, udp_clientaddr, &udp_clientport);
exit:
if(error_no == 0){
if(curnode->protocol == NODE_MODE_UDP && curnode->role == NODE_ROLE_SERVER){
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,
"\r\n[ATPR] OK,%d,%d,%s,%d:", recv_size, con_id, udp_clientaddr, udp_clientport);
at_printf("\r\n[ATPR] OK,%d,%d,%s,%d:", recv_size, con_id, udp_clientaddr, udp_clientport);
}
else{
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,
"\r\n[ATPR] OK,%d,%d:", recv_size, con_id);
at_printf("\r\n[ATPR] OK,%d,%d:", recv_size, con_id);
}
if(recv_size)
at_print_data(rx_buffer, recv_size);
}
else
at_printf("\r\n[ATPR] ERROR:%d,%d", error_no, con_id);
return;
}
void fATPK(void *arg){
int argc;
int error_no = 0;
int enable = 0;
char *argv[MAX_ARGC] = {0};
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,
"[ATPK]: _AT_TRANSPORT_AUTO_RECV");
argc = parse_param(arg, argv);
if( argc < 2){
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,
"[ATPK] Usage: ATPK=<0/1>\n\r");
error_no = 1;
goto exit;
}
enable = atoi((char*)argv[1]);
if(enable){
if(atcmd_lwip_is_autorecv_mode()){
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS, "[ATPK] already enter auto receive mode");
}
else{
if(atcmd_lwip_start_autorecv_task())
error_no = 2;
}
}else{
if(atcmd_lwip_is_autorecv_mode())
atcmd_lwip_set_autorecv_mode(FALSE);
else{
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,"[ATPK] already leave auto receive mode");
}
}
exit:
if(error_no)
at_printf("\r\n[ATPK] ERROR:%d", error_no);
else
at_printf("\r\n[ATPK] OK");
return;
}
void fATPU(void *arg){
int argc;
int error_no = 0;
int enable = 0;
char *argv[MAX_ARGC] = {0};
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,
"[ATPU]: _AT_TRANSPORT_TT_MODE");
argc = parse_param(arg, argv);
if( argc < 2){
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,
"[ATPU] Usage: ATPU=<1>\n\r");
error_no = 1;
goto exit;
}
enable = atoi((char*)argv[1]);
if(enable){
if(!mainlist->next){
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR, "[ATPU] No conn found");
error_no = 2;
}else if(mainlist->next->role == NODE_ROLE_SERVER){
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR, "[ATPU] No TT mode for server");
error_no = 3;
}
else if(mainlist->next->next || mainlist->next->nextseed){
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR, "[ATPU] More than one conn found");
error_no = 4;
}
else{
if(atcmd_lwip_start_tt_task()){
error_no = 5;
}
}
}
exit:
if(error_no)
at_printf("\r\n[ATPU] ERROR:%d", error_no);
else
at_printf("\r\n[ATPU] OK");
return;
}
//ATPL=<enable>
void fATPL(void *arg)
{
int argc, error_no = 0;
char *argv[MAX_ARGC] = {0};
if(!arg){
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,
"\r\n[ATPL] Usage : ATPL=<enable>");
error_no = 1;
goto exit;
}
argc = parse_param(arg, argv);
if(argc != 2){
error_no = 2;
goto exit;
}
//ENABLE LWIP FAST CONNECT
if(argv[1] != NULL){
int enable = atoi(argv[1]);
struct atcmd_lwip_conn_info cur_conn = {0};
node *cur_node = mainlist->next;
if(enable && cur_node == NULL){
error_no = 3;
goto exit;
}
cur_conn.role = cur_node->role;
cur_conn.protocol = cur_node->protocol;
cur_conn.remote_addr = cur_node->addr;
cur_conn.remote_port = cur_node->port;
cur_conn.local_addr = cur_node->local_addr;
cur_conn.local_port = cur_node->local_port;
atcmd_lwip_write_info_to_flash(&cur_conn, enable);
}
exit:
if(error_no == 0)
at_printf("\r\n[ATPL] OK");
else
at_printf("\r\n[ATPL] ERROR:%d",error_no);
return;
}
extern void do_ping_call(char *ip, int loop, int count);
void fATPP(void *arg){
int count, argc = 0;
char buf[32] = {0};
char *argv[MAX_ARGC] = {0};
int con_id=INVALID_CON_ID;
int error_no = 0;
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,
"[ATPP]: _AT_TRANSPORT_PING");
if(!arg){
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,"[ATPP] Usage: ATPP=xxxx.xxxx.xxxx.xxxx[y/loop] or ATPP=[con_id],[y/loop]\n\r");
error_no = 1;
goto exit;
}
argc = parse_param(arg, argv);
if( strlen(argv[1]) < 3 )
{
node* curnode;
struct in_addr addr;
con_id = atoi( (char*)argv[1] );
curnode = seek_node(con_id);
if(curnode == NULL){
error_no = 2;
goto exit;
}
if( curnode->role == 1){ //ping remote server
addr.s_addr = htonl(curnode->addr);
inet_ntoa_r(addr, buf, sizeof(buf));
}else if( curnode->role == 0){//ping local server
strcpy(buf,SERVER);
}else if( curnode->role == 2){ //ping seed
strcpy(buf,(char*) curnode->addr);
}
}else
strcpy(buf, argv[1]);
if(argc == 2){
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,"[ATPP]Repeat Count: 5");
do_ping_call(buf, 0, 5); //Not loop, count=5
}else{
if(strcmp(argv[2], "loop") == 0){
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,"[ATPP]Repeat Count: %s", "loop");
do_ping_call(buf, 1, 0); //loop, no count
}else{
count = atoi(argv[2]);
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,"[ATPP]Repeat Count: %d", count);
do_ping_call(buf, 0, count); //Not loop, with count
}
}
exit:
if(error_no)
at_printf("\r\n[ATPP] ERROR:%d", error_no);
else
at_printf("\r\n[ATPP] OK");
return;
}
void fATPI(void *arg){
node* n = mainlist->next;
struct in_addr addr;
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,
"[ATPI]: _AT_TRANSPORT_CONNECTION_INFO");
while (n != NULL)
{
if(n->con_id == 0)
continue;
at_printf("\r\ncon_id:%d,", n->con_id);
if(n->role == 0)
at_printf("server,");
else
at_printf("client,");
if(n->protocol == 0)
at_printf("tcp,");
else
at_printf("udp,");
addr.s_addr = htonl(n->addr);
at_printf("address:%s,port:%d,socket:%d", inet_ntoa(addr) ,n->port, n->sockfd);
if(n->nextseed != NULL)
{
node* seed = n;
do{
seed = seed->nextseed;
at_printf("\r\ncon_id:%d,seed,", seed->con_id);
if(seed->protocol == 0)
at_printf("tcp,");
else
at_printf("udp,");
addr.s_addr = htonl(seed->addr);
at_printf("address:%s,port:%d,socket:%d", inet_ntoa(addr), seed->port, seed->sockfd);
}while (seed->nextseed != NULL);
}
n = n->next;
}
at_printf("\r\n[ATPI] OK");
return;
}
void init_node_pool(void){
int i;
memset(node_pool, 0, sizeof(node_pool));
for(i=0;i<NUM_NS;i++){
node_pool[i].con_id = INVALID_CON_ID;
}
}
node* create_node(int mode, s8_t role){
int i;
SYS_ARCH_DECL_PROTECT(lev);
for (i = 0; i < NUM_NS; ++i) {
SYS_ARCH_PROTECT(lev);
if (node_pool[i].con_id == INVALID_CON_ID) {
node_pool[i].con_id = i;
SYS_ARCH_UNPROTECT(lev);
node_pool[i].sockfd = INVALID_SOCKET_ID;
node_pool[i].protocol = mode; // 0:TCP, 1:UDP
node_pool[i].role = role; // 0:server, 1:client, 2:SEED
node_pool[i].addr = 0;
node_pool[i].port = -1;
node_pool[i].handletask = NULL;
node_pool[i].next = NULL;
node_pool[i].nextseed = NULL;
return &node_pool[i];
}
SYS_ARCH_UNPROTECT(lev);
}
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR, "No con_id available");
return NULL;
}
void delete_node(node *n)
{
node *currNode, *prevNode, *currSeed, *precvSeed;
if(n == NULL)
return;
SYS_ARCH_DECL_PROTECT(lev);
SYS_ARCH_PROTECT(lev);
//need to remove it from mainlist first
for(currNode = mainlist; currNode != NULL; prevNode = currNode, currNode = currNode->next )
{
if(currNode == n){
prevNode->next = currNode->next;
}
if(currNode->role != NODE_ROLE_SERVER)
continue;
precvSeed = currNode;
currSeed = currNode->nextseed;
while (currSeed != NULL)
{
if(currSeed == n){
precvSeed->nextseed = n->nextseed;
}
precvSeed = currSeed;
currSeed = currSeed->nextseed;
}
}
SYS_ARCH_UNPROTECT(lev);
if(n->role == NODE_ROLE_SERVER){
//node may have seed if it's under server mode
while(n->nextseed != NULL){
currSeed = n->nextseed;
// only tcp seed has its own socket, udp seed uses its server's
// so delete udp seed can't close socket which is used by server
if(currSeed->protocol == NODE_MODE_TCP && currSeed->sockfd != INVALID_SOCKET_ID){
close(currSeed->sockfd);
currSeed->sockfd = INVALID_SOCKET_ID;
}
// no task created for seed
//if(s->handletask != NULL)
// vTaskDelete(s->handletask);
n->nextseed = currSeed->nextseed;
currSeed->con_id = INVALID_CON_ID;
};
}
if(!((n->protocol == NODE_MODE_UDP)&&(n->role == NODE_ROLE_SEED))){
if(n->sockfd != INVALID_SOCKET_ID){
close(n->sockfd);
n->sockfd = INVALID_SOCKET_ID;
}
}
//task will exit itself in fail case
if(n->handletask){
vTaskDelete(n->handletask);
n->handletask = NULL;
}
n->con_id = INVALID_CON_ID;
return;
}
int hang_node(node* insert_node)
{
node* n = mainlist;
SYS_ARCH_DECL_PROTECT(lev);
SYS_ARCH_PROTECT(lev);
while (n->next != NULL)
{
n = n->next;
if(insert_node->role == NODE_ROLE_SERVER) //need to check for server in case that two conns are binded to same port, because SO_REUSEADDR is enabled
{
if( (n->port == insert_node->port) && ((n->addr== insert_node->addr) && (n->role == insert_node->role) && (n->protocol == insert_node->protocol) ) ){
SYS_ARCH_UNPROTECT(lev);
struct in_addr addr;
addr.s_addr = htonl(insert_node->addr);
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,
"This conn(IP:%s PORT:%d) already exist",
inet_ntoa(addr),insert_node->port);
return -1;
}
}
}
n->next = insert_node;
SYS_ARCH_UNPROTECT(lev);
return 0;
}
int hang_seednode(node* main_node ,node* insert_node)
{
node* n = main_node;
SYS_ARCH_DECL_PROTECT(lev);
SYS_ARCH_PROTECT(lev);
while (n->nextseed != NULL)
{
n = n->nextseed;
if( (n->port == insert_node->port) && (n->addr == insert_node->addr)){
SYS_ARCH_UNPROTECT(lev);
struct in_addr addr;
addr.s_addr = htonl(insert_node->addr);
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,
"This seed IP:%s PORT:%d already exist",
inet_ntoa(addr),insert_node->port);
return -1;
}
}
n->nextseed = insert_node;
SYS_ARCH_UNPROTECT(lev);
return 0;
}
node *seek_node(int con_id)
{
node* n = mainlist;
while (n->next != NULL)
{
n = n->next;
if(n->con_id == con_id)
return n;
if(n->nextseed != NULL)
{
node* seed = n;
do{
seed = seed->nextseed;
if(seed->con_id == con_id)
return seed;
}while (seed->nextseed != NULL);
}
}
return NULL;
}
node *tryget_node(int n)
{
SYS_ARCH_DECL_PROTECT(lev);
if ((n <= 0) || (n > NUM_NS)) {
return NULL;
}
SYS_ARCH_PROTECT(lev);
if (node_pool[n].con_id == INVALID_CON_ID || node_pool[n].sockfd == INVALID_SOCKET_ID) {
SYS_ARCH_UNPROTECT(lev);
return NULL;
}
SYS_ARCH_UNPROTECT(lev);
return &node_pool[n];
}
int atcmd_lwip_receive_data(node *curnode, u8 *buffer, u16 buffer_size, int *recv_size,
u8_t *udp_clientaddr, u16_t *udp_clientport){
struct timeval tv;
fd_set readfds;
int error_no = 0, ret = 0, size = 0;
FD_ZERO(&readfds);
FD_SET(curnode->sockfd, &readfds);
tv.tv_sec = RECV_SELECT_TIMEOUT_SEC;
tv.tv_usec = RECV_SELECT_TIMEOUT_USEC;
ret = select(curnode->sockfd + 1, &readfds, NULL, NULL, &tv);
if(!((ret > 0)&&(FD_ISSET(curnode->sockfd, &readfds))))
{
//AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,
// "[ATPR] No receive event for con_id %d", curnode->con_id);
goto exit;
}
if(curnode->protocol == NODE_MODE_UDP) //udp server receive from client
{
if(curnode->role == NODE_ROLE_SERVER){
//node * clinode;
struct sockaddr_in client_addr;
u32_t addr_len = sizeof(struct sockaddr_in);
memset((char *) &client_addr, 0, sizeof(client_addr));
if ((size = recvfrom(curnode->sockfd, buffer, buffer_size, 0, (struct sockaddr *) &client_addr, &addr_len)) > 0){
//at_printf("[ATPR]:%d,%s,%d,%s\r\n with packet_size: %d\r\n",con_id, inet_ntoa(client_addr.sin_addr.s_addr), ntohs(client_addr.sin_port), rx_buffer, packet_size);
//at_printf("\r\nsize: %d\r\n", recv_size);
//at_printf("%s", rx_buffer);
}
else{
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,
"[ATPR] ERROR:Failed to receive data");
error_no = 4;
}
#if 0
clinode = create_node(NODE_MODE_UDP, NODE_ROLE_SEED);
clinode->sockfd = curnode->sockfd;
clinode->addr = ntohl(client_addr.sin_addr.s_addr);
clinode->port = ntohs(client_addr.sin_port);
if(hang_seednode(curnode,clinode) < 0){
delete_node(clinode);
clinode = NULL;
}
#else
inet_ntoa_r(client_addr.sin_addr.s_addr, (char *)udp_clientaddr, 16);
*udp_clientport = ntohs(client_addr.sin_port);
#endif
}
else{
struct sockaddr_in serv_addr;
u32_t addr_len = sizeof(struct sockaddr_in);
memset((char *) &serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(curnode->port);
serv_addr.sin_addr.s_addr = htonl(curnode->addr);
if ((size = recvfrom(curnode->sockfd, buffer, buffer_size, 0, (struct sockaddr *) &serv_addr, &addr_len)) > 0){
//at_printf("[ATPR]:%d,%s,%d,%s\r\n with packet_size: %d\r\n",con_id, inet_ntoa(serv_addr.sin_addr.s_addr), ntohs(serv_addr.sin_port), rx_buffer, packet_size);
//at_printf("\r\nsize: %d\r\n", recv_size);
//at_printf("%s", rx_buffer);
}
else{
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,
"[ATPR] ERROR:Failed to receive data");
error_no = 5;
}
}
}
else{
#if 0
if(curnode->role == NODE_ROLE_SERVER){
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,
"[ATPR] ERROR: TCP Server must receive data from the seed");
error_no = 6;
}
#endif
//receive from seed or server
if((size = read(curnode->sockfd,buffer,buffer_size)) > 0)
{
//struct in_addr addr;
//addr.s_addr = htonl(curnode->addr);
//at_printf("[ATPR]:%d,%s,%d,%s\r\n with packet_size: %d\r\n",con_id, inet_ntoa(addr), curnode->port, rx_buffer, packet_size);
//at_printf("\r\nsize: %d\r\n", recv_size);
//at_printf("%s", rx_buffer);
}
else{
if(size == 0){
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,
"[ATPR] ERROR:Connection is closed!");
error_no = 7;
}
else{
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,
"[ATPR] ERROR:Failed to receive data!");
error_no = 8;
}
}
}
exit:
if(error_no == 0)
*recv_size = size;
else{
close(curnode->sockfd);
curnode->sockfd = INVALID_SOCKET_ID;
}
return error_no;
}
static void atcmd_lwip_receive_task(void *param)
{
int i;
int packet_size = ETH_MAX_MTU;
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,
"Enter auto receive mode");
while(atcmd_lwip_is_autorecv_mode())
{
for (i = 0; i < NUM_NS; ++i) {
node* curnode = NULL;
int error_no = 0;
int recv_size = 0;
u8_t udp_clientaddr[16] = {0};
u16_t udp_clientport = 0;
curnode = tryget_node(i);
if(curnode == NULL)
continue;
if(curnode->protocol == NODE_MODE_TCP && curnode->role == NODE_ROLE_SERVER){
//TCP Server must receive data from the seed
continue;
}
error_no = atcmd_lwip_receive_data(curnode, rx_buffer, packet_size, &recv_size, udp_clientaddr, &udp_clientport);
if(atcmd_lwip_is_tt_mode()){
if((error_no == 0) && recv_size){
rx_buffer[recv_size] = '\0';
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,"Recv[%d]:%s", recv_size, rx_buffer);
at_print_data(rx_buffer, recv_size);
rtw_msleep_os(20);
}
continue;
}
if(error_no == 0){
if(recv_size){
#if CONFIG_LOG_SERVICE_LOCK
log_service_lock();
#endif
if(curnode->protocol == NODE_MODE_UDP && curnode->role == NODE_ROLE_SERVER){
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,
"\r\n[ATPR] OK,%d,%d,%s,%d:", recv_size, curnode->con_id, udp_clientaddr, udp_clientport);
at_printf("\r\n[ATPR] OK,%d,%d,%s,%d:", recv_size, curnode->con_id, udp_clientaddr, udp_clientport);
}
else{
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,
"\r\n[ATPR] OK,%d,%d:",
recv_size,
curnode->con_id);
at_printf("\r\n[ATPR] OK,%d,%d:", recv_size, curnode->con_id);
}
at_print_data(rx_buffer, recv_size);
at_printf(STR_END_OF_ATCMD_RET);
#if CONFIG_LOG_SERVICE_LOCK
log_service_unlock();
#endif
}
}
else{
#if CONFIG_LOG_SERVICE_LOCK
log_service_lock();
#endif
at_printf("\r\n[ATPR] ERROR:%d,%d", error_no, curnode->con_id);
at_printf(STR_END_OF_ATCMD_RET);
#if CONFIG_LOG_SERVICE_LOCK
log_service_unlock();
#endif
}
}
}
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,
"Leave auto receive mode");
vTaskDelete(NULL);
}
int atcmd_lwip_start_autorecv_task(void){
atcmd_lwip_set_autorecv_mode(TRUE);
if(xTaskCreate(atcmd_lwip_receive_task, ((const char*)"atcmd_lwip_receive_task"), ATCP_STACK_SIZE, NULL, ATCMD_LWIP_TASK_PRIORITY, NULL) != pdPASS)
{
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,
"ERROR: Create receive task failed.");
atcmd_lwip_set_autorecv_mode(FALSE);
return -1;
}
return 0;
}
int atcmd_lwip_is_tt_mode(void){
return (atcmd_lwip_tt_mode == TRUE);
}
void atcmd_lwip_set_tt_mode(int enable){
atcmd_lwip_tt_mode = enable;
}
int atcmd_lwip_is_autorecv_mode(void){
return (atcmd_lwip_auto_recv == TRUE);
}
void atcmd_lwip_set_autorecv_mode(int enable){
atcmd_lwip_auto_recv = enable;
}
static void _tt_wait_rx_complete(){
s32 tick_current = rtw_get_current_time();
while(rtw_systime_to_ms(tick_current -atcmd_lwip_tt_lasttickcnt) < ATCMD_LWIP_TT_MAX_DELAY_TIME_MS ){
rtw_msleep_os(5);
tick_current = rtw_get_current_time();
}
}
static void atcmd_lwip_tt_handler(void* param)
{
struct sockaddr_in cli_addr;
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,
"Enter TT data mode");
while(RtlDownSema((_Sema *)&atcmd_lwip_tt_sema) == _SUCCESS) {
_lock lock;
_irqL irqL;
int tt_size = 0;
_tt_wait_rx_complete();
rtw_enter_critical(&lock, &irqL);
if((atcmd_lwip_tt_datasize >= 4) && (memcmp(log_buf, "----", 4) == 0)){
atcmd_lwip_set_tt_mode(FALSE);
atcmd_lwip_tt_datasize = 0;
rtw_exit_critical(&lock, &irqL);
break;
}
rtw_memcpy(tx_buffer, log_buf, atcmd_lwip_tt_datasize);
tt_size = atcmd_lwip_tt_datasize;
atcmd_lwip_tt_datasize = 0;
rtw_exit_critical(&lock, &irqL);
tx_buffer[tt_size] = '\0';
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,"Send[%d]:%s", tt_size, tx_buffer);
atcmd_lwip_send_data(mainlist->next, tx_buffer, tt_size, cli_addr);
}
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,
"Leave TT data mode");
RtlFreeSema((_Sema *)&atcmd_lwip_tt_sema);
atcmd_lwip_set_autorecv_mode(FALSE);
at_printf(STR_END_OF_ATCMD_RET); //mark return to command mode
vTaskDelete(NULL);
}
int atcmd_lwip_start_tt_task(void){
RtlInitSema((_Sema *)&atcmd_lwip_tt_sema, 0);
atcmd_lwip_set_tt_mode(TRUE);
if(xTaskCreate(atcmd_lwip_tt_handler, ((const char*)"tt_hdl"), ATCP_STACK_SIZE, NULL, ATCMD_LWIP_TASK_PRIORITY, &atcmd_lwip_tt_task) != pdPASS){
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,
"ERROR: Create tt task failed.");
goto err_exit;
}
RtlMsleepOS(20);
if(atcmd_lwip_is_autorecv_mode() != 1){
if(atcmd_lwip_start_autorecv_task()){
vTaskDelete(atcmd_lwip_tt_task);
goto err_exit;
}
}
return 0;
err_exit:
atcmd_lwip_set_tt_mode(FALSE);
return -1;
}
void atcmd_lwip_erase_info(void){
atcmd_update_partition_info(AT_PARTITION_LWIP, AT_PARTITION_ERASE, NULL, 0);
}
int atcmd_lwip_write_info_to_flash(struct atcmd_lwip_conn_info *cur_conn, int enable)
{
struct atcmd_lwip_conf read_data = {0};
int i = 0, found = 0;
atcmd_update_partition_info(AT_PARTITION_LWIP, AT_PARTITION_READ, (u8 *) &read_data, sizeof(struct atcmd_lwip_conf));
//fake that the conn exists already when disabling or there is no active conn on this moment
if(enable == 0){
atcmd_lwip_erase_info();
goto exit;
}
if(read_data.conn_num < 0 || read_data.conn_num > ATCMD_LWIP_CONN_STORE_MAX_NUM){
read_data.conn_num = 0;
read_data.last_index = -1;
}
for(i = 0; i < read_data.conn_num; i++){
if(memcmp((u8 *)cur_conn, (u8 *)&read_data.conn[i], sizeof(struct atcmd_lwip_conn_info)) == 0) {
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,
"the same profile found in flash");
found = 1;
break;
}
}
if(!found){
read_data.last_index++;
if(read_data.last_index >= ATCMD_LWIP_CONN_STORE_MAX_NUM)
read_data.last_index -= ATCMD_LWIP_CONN_STORE_MAX_NUM;
memcpy((u8 *)&read_data.conn[read_data.last_index], (u8 *)cur_conn, sizeof(struct atcmd_lwip_conn_info));
read_data.conn_num++;
if(read_data.conn_num > ATCMD_LWIP_CONN_STORE_MAX_NUM)
read_data.conn_num = ATCMD_LWIP_CONN_STORE_MAX_NUM;
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,
"not the same proto/addr/port, write new profile to flash");
}
if(!found || read_data.enable != enable){
read_data.enable = enable;
atcmd_update_partition_info(AT_PARTITION_LWIP, AT_PARTITION_WRITE, (u8 *) &read_data, sizeof(struct atcmd_lwip_conf));
}
exit:
return 0;
}
int atcmd_lwip_read_info_from_flash(u8 *read_data, u32 read_len)
{
atcmd_update_partition_info(AT_PARTITION_LWIP, AT_PARTITION_READ, read_data, read_len);
return 0;
}
int atcmd_lwip_auto_connect(void)
{
struct atcmd_lwip_conf read_data = {0};
struct atcmd_lwip_conn_info *re_conn;
node* re_node = NULL;
int i, error_no = 0;
int last_index;
atcmd_lwip_read_info_from_flash((u8 *)&read_data, sizeof(struct atcmd_lwip_conf));
if(read_data.enable == 0){
error_no = 1;
goto exit;
}
if(read_data.conn_num > ATCMD_LWIP_CONN_STORE_MAX_NUM || read_data.conn_num <= 0){
error_no = 2;
goto exit;
}
last_index = read_data.last_index;
for(i = 0; i < read_data.conn_num; i++){
re_conn = &read_data.conn[last_index];
last_index ++;
if(last_index >= ATCMD_LWIP_CONN_STORE_MAX_NUM)
last_index -= ATCMD_LWIP_CONN_STORE_MAX_NUM;
re_node = create_node(re_conn->protocol, re_conn->role);
if(re_node == NULL){
error_no = 3;
break;
}
re_node->addr = re_conn->remote_addr;
re_node->port = re_conn->remote_port;
re_node->local_addr = re_conn->local_addr;
re_node->local_port = re_conn->local_port;
if(re_node->protocol == NODE_MODE_UDP)
re_node->sockfd = socket(AF_INET,SOCK_DGRAM,0);
else
re_node->sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (re_node->sockfd == INVALID_SOCKET_ID) {
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,"Failed to create sock_fd!");
error_no = 4;
break;
}
struct in_addr addr;
addr.s_addr = htonl(re_node->addr);
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,
"\r\nTry connect: %d,%d,%s,%d",
re_node->sockfd, re_node->protocol,
inet_ntoa(addr), re_node->port);
if(re_node->role == NODE_ROLE_SERVER){
//TODO: start server here
goto exit;
}
if (re_node->protocol == NODE_MODE_TCP){//TCP MODE
struct sockaddr_in c_serv_addr;
memset(&c_serv_addr, 0, sizeof(c_serv_addr));
c_serv_addr.sin_family = AF_INET;
c_serv_addr.sin_addr.s_addr = htonl(re_node->addr);
c_serv_addr.sin_port = htons(re_node->port);
if(connect(re_node->sockfd, (struct sockaddr *)&c_serv_addr, sizeof(c_serv_addr)) == 0){
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,"Connect to Server successful!");
if(hang_node(re_node) < 0){
error_no = 5;
}
break;
}else{
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,"Connect to Server failed(%d)!", errno);
error_no = 6;
delete_node(re_node);
re_node = NULL;
continue; //try next conn
}
}
else{
if(re_node->local_port){
struct sockaddr_in addr;
memset(&addr, 0, sizeof(addr));
addr.sin_family=AF_INET;
addr.sin_port=htons(re_node->local_port);
addr.sin_addr.s_addr=htonl(INADDR_ANY) ;
if (bind(re_node->sockfd, (struct sockaddr *)&addr, sizeof(addr))<0) {
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ERROR,"bind sock error!");
error_no = 7;
delete_node(re_node);
re_node = NULL;
continue;
}
}
if(hang_node(re_node) < 0){
error_no = 8;
}
AT_DBG_MSG(AT_FLAG_LWIP, AT_DBG_ALWAYS,"UDP client starts successful!");
break;
}
}
exit:
if(re_node && error_no)
delete_node(re_node);
return error_no;
}
int atcmd_lwip_restore_from_flash(void){
int ret = -1;
if(atcmd_lwip_auto_connect() == 0){
if(atcmd_lwip_start_tt_task() == 0)
ret = 0;
}
return ret;
}
#endif
//------------------------------------------------------------ Add pvvx Lwip Info
/* Get one byte from the 4-byte address */
#define ip4_addr1(ipaddr) (((u8_t*)(ipaddr))[0])
#define ip4_addr2(ipaddr) (((u8_t*)(ipaddr))[1])
#define ip4_addr3(ipaddr) (((u8_t*)(ipaddr))[2])
#define ip4_addr4(ipaddr) (((u8_t*)(ipaddr))[3])
/* These are cast to u16_t, with the intent that they are often arguments
* to printf using the U16_F format from cc.h. */
#define ip4_addr1_16(ipaddr) ((u16_t)ip4_addr1(ipaddr))
#define ip4_addr2_16(ipaddr) ((u16_t)ip4_addr2(ipaddr))
#define ip4_addr3_16(ipaddr) ((u16_t)ip4_addr3(ipaddr))
#define ip4_addr4_16(ipaddr) ((u16_t)ip4_addr4(ipaddr))
#define IP2STR(ipaddr) ip4_addr1_16(ipaddr), \
ip4_addr2_16(ipaddr), \
ip4_addr3_16(ipaddr), \
ip4_addr4_16(ipaddr)
#define IPSTR "%d.%d.%d.%d"
extern const char * const tcp_state_str[];
/*
static const char * const tcp_state_str[] = {
"CLOSED",
"LISTEN",
"SYN_SENT",
"SYN_RCVD",
"ESTABLISHED",
"FIN_WAIT_1",
"FIN_WAIT_2",
"CLOSE_WAIT",
"CLOSING",
"LAST_ACK",
"TIME_WAIT"
};
*/
/******************************************************************************
* FunctionName : debug
* Parameters :
* Returns :
*******************************************************************************/
void print_udp_pcb(void)
{
struct udp_pcb *pcb;
bool prt_none = true;
rtl_printf("UDP pcbs:\n");
for(pcb = udp_pcbs; pcb != NULL; pcb = pcb->next) {
rtl_printf("flg:%02x\t" IPSTR ":%d\t" IPSTR ":%d\trecv:%p\n", pcb->flags, IP2STR(&pcb->local_ip), pcb->local_port, IP2STR(&pcb->remote_ip), pcb->remote_port, pcb->recv );
prt_none = false;
}
if(prt_none) rtl_printf("none\n");
}
/******************************************************************************
* FunctionName : debug
* Parameters :
* Returns :
*******************************************************************************/
void print_tcp_pcb(void)
{
struct tcp_pcb *pcb;
rtl_printf("Active PCB states:\n");
bool prt_none = true;
for(pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) {
rtl_printf("Port %d|%d\tflg:%02x\ttmr:%p\t%s\n", pcb->local_port, pcb->remote_port, pcb->flags, pcb->tmr, tcp_state_str[pcb->state]);
prt_none = false;
}
if(prt_none) rtl_printf("none\n");
rtl_printf("Listen PCB states:\n");
prt_none = true;
for(pcb = (struct tcp_pcb *)tcp_listen_pcbs.pcbs; pcb != NULL; pcb = pcb->next) {
rtl_printf("Port %d|%d\tflg:%02x\ttmr:%p\t%s\n", pcb->local_port, pcb->remote_port, pcb->flags, pcb->tmr, tcp_state_str[pcb->state]);
prt_none = false;
}
if(prt_none) rtl_printf("none\n");
rtl_printf("TIME-WAIT PCB states:\n");
prt_none = true;
for(pcb = tcp_tw_pcbs; pcb != NULL; pcb = pcb->next) {
rtl_printf("Port %d|%d\tflg:%02x\ttmr:%p\t%s\n", pcb->local_port, pcb->remote_port, pcb->flags, pcb->tmr, tcp_state_str[pcb->state]);
prt_none = false;
}
if(prt_none) rtl_printf("none\n");
}
/******************************************************************************
* FunctionName : debug
* Parameters :
* Returns :
*******************************************************************************/
void print_netif(int inum)
{
rtl_printf("Net Info[%d]: " IPSTR, inum, IP2STR(&xnetif[inum].ip_addr));
rtl_printf(", " IPSTR ", " IPSTR "\n", IP2STR(&xnetif[inum].netmask), IP2STR(&xnetif[inum].gw));
}
/******************************************************************************
* FunctionName : debug
* Parameters :
* Returns :
*******************************************************************************/
//------------------------------------------------------------------------------
void fATPx(void *arg) // Info Lwip
{
printf("=== LwIP Info ===\n");
print_netif(0);
print_netif(1);
print_udp_pcb();
print_tcp_pcb();
}
//------------------------------------------------------------ Add pvvx end
#if CONFIG_TRANSPORT
log_item_t at_transport_items[ ] = {
#if ATCMD_VER == ATVER_1
{"ATP1", fATP1,},//mode TCP=0,UDP=1
{"ATP2", fATP2,},//LOCAL PORT
{"ATP3", fATP3,},//REMOTE IP
{"ATP4", fATP4,},//REMOTE PORT
{"ATP5", fATP5,},//START SERVER
{"ATP6", fATP6,},//START CLIENT
{"ATP?", fATPZ,},//SETTING
{"ATR0", fATR0,},//READ DATA
{"ATR1", fATR1,},//SET PACKET SIZE
{"ATRA", fATRA,},//WRITE DATA
{"ATRB", fATRB,},//SET WRITE PACKET SIZE
#endif
#if ATCMD_VER == ATVER_2
{"ATP0", fATP0,},//query errno if defined
{"ATPS", fATPS,},//Create Server
{"ATPD", fATPD,},//Close Server/Client connection
{"ATPC", fATPC,},//Create Client
{"ATPT", fATPT,},//WRITE DATA
{"ATPR", fATPR,},//READ DATA
{"ATPK", fATPK,},//Auto recv
{"ATPP", fATPP,},//PING
{"ATPI", fATPI,},//printf connection status
{"ATPU", fATPU,}, //transparent transmission mode
{"ATPL", fATPL,}, //lwip auto reconnect setting
#endif
{"ATP?", fATPx,}, //Lwip pcb Info
};
#if ATCMD_VER == ATVER_2
void print_tcpip_at(void *arg){
int index;
int cmd_len = 0;
cmd_len = sizeof(at_transport_items)/sizeof(at_transport_items[0]);
for(index = 0; index < cmd_len; index++)
at_printf("\r\n%s", at_transport_items[index].log_cmd);
}
#endif
void at_transport_init(void)
{
#if ATCMD_VER == ATVER_2
init_node_pool();
mainlist = create_node(-1,-1);
#endif
log_service_add_table(at_transport_items, sizeof(at_transport_items)/sizeof(at_transport_items[0]));
}
log_module_init(at_transport_init);
#endif
#endif //#ifdef CONFIG_AT_LWIP
Reference in a new issue View git blame Copy permalink