/**
* tcp connnect callback
*/
static err_t net_tcp_connect_cb(void *arg, struct tcp_pcb *pcb, err_t err)
{
struct tls_netconn *conn;
err_t err_ret = ERR_OK;
conn = (struct tls_netconn *)arg;
pcb = conn->pcb.tcp;
if ((conn->proto == TLS_NETCONN_TCP) && (err == ERR_OK)) {
TLS_DBGPRT_INFO("net_tcp_connect_cb =====> state : %d\n", pcb->state);
conn->state = NETCONN_STATE_CONNECTED;
net_send_event_to_hostif(conn, NET_EVENT_TCP_CONNECTED);
} else {
TLS_DBGPRT_INFO("the err is =%d\n", err);
}
if(conn->skd != NULL && conn->skd->connf != NULL)
{
err_ret = conn->skd->connf(conn->skt_num, err);
if(err_ret == ERR_ABRT)
tcp_abort(pcb);
return err_ret;
}
return err;
}
static void sys_net_status_changed(u8 status)
{
#if TLS_CONFIG_TLS_DEBUG
struct tls_ethif * ethif;
#endif
switch(status)
{
case NETIF_WIFI_JOIN_SUCCESS:
TLS_DBGPRT_INFO("join net success\n");
tls_sys_net_up();
break;
case NETIF_WIFI_JOIN_FAILED:
TLS_DBGPRT_INFO("join net failed\n");
tls_sys_connect_failed();
break;
case NETIF_WIFI_DISCONNECTED:
TLS_DBGPRT_INFO("net disconnected\n");
tls_sys_net_down();
break;
case NETIF_IP_NET_UP:
#if TLS_CONFIG_TLS_DEBUG
ethif = tls_netif_get_ethif();
TLS_DBGPRT_INFO("net up ==> ip = %d.%d.%d.%d\n",ip4_addr1(ðif->ip_addr.addr),ip4_addr2(ðif->ip_addr.addr),
ip4_addr3(ðif->ip_addr.addr),ip4_addr4(ðif->ip_addr.addr));
#endif
break;
default:
break;
}
}
/**
* Send data on a TCP pcb
*/
static void net_do_write(void *ctx)
{
struct tls_net_msg *net_msg = (struct tls_net_msg *)ctx;
struct tls_netconn *conn = net_msg->conn;
struct tls_netconn *server_conn = NULL;
//TLS_DBGPRT_INFO("s=%d,p=0x%x\n", conn->state, conn->pcb.tcp);
#if 0
if (ERR_IS_FATAL(conn->last_err)) {
net_msg->err = conn->last_err;
}
#endif
if (conn->proto == TLS_NETCONN_TCP) {
#if LWIP_TCP
if (conn->state != NETCONN_STATE_CONNECTED) {
/* netconn is connecting, closing or in blocking write */
net_msg->err = ERR_INPROGRESS;
} else if (conn->pcb.tcp != NULL) {
conn->write_state = true;
//conn->write_offset = 0;
net_msg->err = net_skt_tcp_send(net_msg);
/* for both cases: if do_writemore was called, don't ACK the APIMSG
since do_writemore ACKs it! */
} else {
net_msg->err = ERR_CONN;
TLS_DBGPRT_INFO("==>err=%d\n", net_msg->err);
}
if(conn->client && conn->idle_time > 0)
{
TLS_DBGPRT_INFO("conn->skt_num=%d, conn->client=%d\n", conn->skt_num, conn->client);
// server_conn = dl_list_first(&conn->list, struct tls_netconn, list);
server_conn = get_server_conn(conn);
TLS_DBGPRT_INFO("server_conn=%p\n", server_conn);
if(server_conn)
{
conn->idle_time = server_conn->idle_time;
TLS_DBGPRT_INFO("update conn->idle_time %d\n", conn->idle_time);
}
}
#else /* LWIP_TCP */
net_msg->err = ERR_VAL;
#endif /* LWIP_TCP */
#if (LWIP_UDP || LWIP_RAW)
} else {
net_msg->err = ERR_VAL;
#endif /* (LWIP_UDP || LWIP_RAW) */
}
//tls_mem_free(net_msg->dataptr);
//if(net_msg->err != ERR_OK)
{
//TLS_DBGPRT_INFO("conn->proto=%d, err=%d\n", conn->proto, net_msg->err);
//TLS_DBGPRT_INFO("free net_msg->dataptr=%p\n", net_msg->dataptr);
sys_sem_signal(conn->op_completed);
}
#if 0
tls_mem_free(net_msg);
#endif
}
void disp_version_info(void)
{
TLS_DBGPRT_INFO("\n\n");
TLS_DBGPRT_INFO("****************************************************************\n");
TLS_DBGPRT_INFO("* *\n");
TLS_DBGPRT_INFO("* Copyright (C) 2014 WinnerMicro Co. Ltd. *\n");
TLS_DBGPRT_INFO("* All rights reserved. *\n");
TLS_DBGPRT_INFO("* WinnerMicro Firmwire Version: %d.%d.%d *\n",
FirmWareVer[1], FirmWareVer[2], FirmWareVer[3]);
TLS_DBGPRT_INFO("* WinnerMicro Hardware Version: %d.%d.%d.%d.%d *\n",
HwVer[1], HwVer[2], HwVer[3],HwVer[4],HwVer[5]);
TLS_DBGPRT_INFO("* *\n");
TLS_DBGPRT_INFO("* WinnerMicro Wi-Fi Lib Version: %d.%d.%d *\n",
WiFiVer[0], WiFiVer[1], WiFiVer[2]);
TLS_DBGPRT_INFO("****************************************************************\n");
}
void tls_cmd_init_socket_cfg(void)
{
int timeout = 0, host_len;
struct tls_param_socket remote_socket_cfg;
tls_param_get(TLS_PARAM_ID_DEFSOCKET, &remote_socket_cfg, FALSE);
/* read default socket params */
socket_cfg.proto = remote_socket_cfg.protocol;
socket_cfg.client = remote_socket_cfg.client_or_server ? 0 : 1;
socket_cfg.port = remote_socket_cfg.port_num;
TLS_DBGPRT_INFO("socket_cfg.proto = %d, socket_cfg.client = %d, socket_cfg.port = %d\n", socket_cfg.proto, socket_cfg.client, socket_cfg.port);
host_len = strlen((char *)remote_socket_cfg.host);
if (socket_cfg.client) {
/* host name */
if (host_len){
MEMCPY(socket_cfg.host,
remote_socket_cfg.host, host_len);
string_to_ipaddr((char *)remote_socket_cfg.host, &socket_cfg.ip_addr[0]);
}
} else if (!socket_cfg.client && socket_cfg.proto == 0) {
if (strtodec(&timeout, (char *)remote_socket_cfg.host)<0){
timeout = 0;
}
socket_cfg.timeout = timeout;
} else
;
}
/**
* Start create UDP connection
*/
static err_t net_udp_start(struct tls_netconn *conn)
{
struct udp_pcb *udppcb;
u16 localportnum = conn->localport;
if(localportnum == 0)
{
localportnum = conn->port;
}
udppcb = udp_new();
if(udppcb == NULL) {
return ERR_MEM;
}
conn->pcb.udp = udppcb;
if (udp_bind(udppcb, IP_ADDR_ANY, localportnum)!= ERR_OK){
TLS_DBGPRT_INFO("udp connect failed\n");
return ERR_CONN;
}
/* Set a receive callback for the upcb */
udp_recv(udppcb, net_udp_recv_cb, conn);
return ERR_OK;
}
static void net_tcp_err_cb(void *arg, err_t err)
{
struct tls_netconn *conn = (struct tls_netconn *)arg;
struct tcp_pcb *pcb = conn->pcb.tcp;
u8 event = NET_EVENT_TCP_CONNECT_FAILED;
TLS_DBGPRT_INFO("tcp err = %d\n", err);
if (pcb) {
tcp_arg(pcb, NULL);
tcp_sent(pcb, NULL);
tcp_recv(pcb, NULL);
tcp_err(pcb, NULL);
if (!conn->client) {
tcp_accept(pcb, NULL);
}
if(err == ERR_OK)
{
tcp_close(pcb);
}
if(conn->state != NETCONN_STATE_NONE)
{
conn->state = NETCONN_STATE_NONE;
event = NET_EVENT_TCP_DISCONNECT;
}
net_send_event_to_hostif(conn, event);
if(conn->skd->errf != NULL)
{
conn->skd->errf(conn->skt_num, err);
}
conn->pcb.tcp = NULL;
net_free_socket(conn);
}
}
static void net_send_event_to_hostif(struct tls_netconn *conn,
int event)
{
struct tls_socket_desc *skt_desc = conn->skd;
TLS_DBGPRT_INFO("skt_desc->state_changed: 0x%x, event=%d\n", skt_desc->state_changed, event);
if(skt_desc->state_changed)
{
skt_desc->state_changed(conn->skt_num, event, conn->state);
}
}
int tls_uart_set_baud_rate(struct tls_uart_port *port,
u32 baudrate)
{
int index;
u32 value;
index = tls_uart_check_baudrate(baudrate);
if (index < 0)
return WM_FAILED;
TLS_DBGPRT_INFO("ubdiv_frac = 0x%x\n", baud_rates[index].ubdiv_frac);
value = baud_rates[index].ubdiv | (baud_rates[index].ubdiv_frac << 16);
TLS_DBGPRT_INFO("value = 0x%x\n", value);
port->regs->UR_BD = value;
port->opts.baudrate = baudrate;
TLS_DBGPRT_INFO("UR_BR = 0x%x\n", port->regs->UR_BD);
return WM_SUCCESS;
}
static void net_free_socket(struct tls_netconn *conn)
{
int index;
u32 cpu_sr;
if(conn == NULL || conn->used == false)
return;
TLS_DBGPRT_INFO("conn ptr = 0x%x\n", conn);
if (NULL != conn->op_completed)
sys_sem_free(conn->op_completed);
conn->used = false;
if(conn->client && conn->list.prev != NULL && conn->list.prev != &conn->list)
{
TLS_DBGPRT_INFO("del from list.\n");
cpu_sr = tls_os_set_critical();
dl_list_del(&conn->list);
tls_os_release_critical(cpu_sr);
}
index = conn->skt_num - 1;//TLS_MAX_NETCONN_NUM -
tls_mem_free(conn);
cpu_sr = tls_os_set_critical();
conn = NULL;
p_net_conn[index] = NULL;
tls_os_release_critical(cpu_sr);
}
static struct tls_netconn *net_alloc_socket(struct tls_netconn *conn)
{
int sock=-1, i=0, j=0;
u32 cpu_sr;
struct tls_netconn * conn_t = NULL;
for (i = 0; i < TLS_MAX_NETCONN_NUM; i++)
{
if(p_net_conn[i] == NULL)
{
sock = i;
break;
}
}
if (i == TLS_MAX_NETCONN_NUM){
return NULL;
}
if(conn != NULL)
{
j = dl_list_len(&conn->list);
if(j>=4)
{
sock = -1;
}
}
if(sock < 0)
return NULL;
cpu_sr = tls_os_set_critical();
conn_t = tls_mem_alloc(sizeof(struct tls_netconn));
tls_os_release_critical(cpu_sr);
if (NULL != conn_t) {
p_net_conn[sock] = conn_t;
memset(conn_t, 0, sizeof(struct tls_netconn));
conn_t->used = true;
conn_t->state = NETCONN_STATE_NONE;
conn_t->skt_num = sock + 1;//TLS_MAX_NETCONN_NUM +
dl_list_init(&conn_t->list);
if (sys_sem_new(&conn_t->op_completed, 0) != ERR_OK) {
net_free_socket(conn_t);
}
}
TLS_DBGPRT_INFO("net_alloc_socket conn ptr = 0x%x\n", conn_t);
return conn_t;
// return NULL;
}
static void do_create_connect(void *ctx)
{
struct tls_net_msg *net_msg = (struct tls_net_msg *)ctx;
struct tls_netconn *conn;
err_t err;
//TLS_DBGPRT_INFO("=====>\n");
conn = net_msg->conn;
TLS_DBGPRT_INFO("conn ptr = 0x%x, conn->skt_num=%d, conn->client=%d\n", conn, conn->skt_num, conn->client);
switch (conn->proto) {
case TLS_NETCONN_UDP:
err = net_udp_start(conn);
if (err != ERR_OK){
conn->state = NETCONN_STATE_NONE;
net_send_event_to_hostif(conn, NET_EVENT_UDP_START_FAILED);
net_free_socket(conn);
}else{
conn->state = NETCONN_STATE_CONNECTED;
net_send_event_to_hostif(conn, NET_EVENT_UDP_START);
}
break;
case TLS_NETCONN_TCP:
err = net_tcp_start(conn);
if (err != ERR_OK){
conn->state = NETCONN_STATE_NONE;
net_send_event_to_hostif(conn, NET_EVENT_TCP_CONNECT_FAILED);
net_free_socket(conn);
}else{
if (!conn->client){
net_send_event_to_hostif(conn, NET_EVENT_TCP_CONNECTED);
}
//conn->state = NETCONN_STATE_CONNECTED;
}
break;
default:
/* Unsupported netconn type, e.g. protocol disabled */
break;
}
tls_mem_free(net_msg);
return;
}
void disp_task_stat_info(void)
{
OS_TCB *ptcb;
INT8U prio;
INT8U str[3] [8] = {"PEND", "TO", "ABORT"};
for (prio = 0u; prio <= OS_TASK_IDLE_PRIO; prio++) {
ptcb = OSTCBPrioTbl[prio];
if (ptcb != (OS_TCB *)0) { /* Make sure task 'ptcb' is ... */
if (ptcb != OS_TCB_RESERVED) { /* ... still valid. */
#if OS_TASK_PROFILE_EN > 0u
TLS_DBGPRT_INFO("task %d TCB Stack used %d bytes, %d(total), Base:0x%x, Status:%s\n",
prio,
ptcb->OSTCBStkCount, ptcb->OSTCBStkSize*sizeof(u32), ptcb->OSTCBStkBase, str[ptcb->OSTCBStat]);
#endif
}
}
}
}
static err_t net_skt_tcp_send(struct tls_net_msg *net_msg)
{
struct tcp_pcb *pcb = net_msg->conn->pcb.tcp;
err_t err;
/*
When tcp error occured, lwip will delete the pcb and sometimes GSKT.
This function maybe registered by GSKT_TimerSend, so we must check if GSKT has been delted!!!
*/
err = tcp_write(pcb, net_msg->dataptr, net_msg->len, TCP_WRITE_FLAG_COPY);
if (err == ERR_OK){
//sys_sem_signal(net_msg->conn->op_completed);
tcp_output(pcb);
}
else
{
TLS_DBGPRT_INFO("err:%d\n", err);
}
return err;
}
static void net_tcp_close_connect(struct tls_netconn *conn)
{
err_t err;
if (NULL == conn->pcb.tcp){
return;
}
/* Set back some callback pointers */
tcp_arg(conn->pcb.tcp, NULL);
if (conn->pcb.tcp->state == LISTEN) {
tcp_accept(conn->pcb.tcp, NULL);
} else {
/* some callbacks have to be reset if tcp_close is not successful */
tcp_recv(conn->pcb.tcp, NULL);
tcp_accept(conn->pcb.tcp, NULL);
tcp_sent(conn->pcb.tcp, NULL);
tcp_poll(conn->pcb.tcp, NULL, 4);
tcp_err(conn->pcb.tcp, NULL);
}
err = tcp_close(conn->pcb.tcp);
if (err)
err = tcp_shutdown(conn->pcb.tcp, 1, 1);
if (err == ERR_OK) {
/* Closing succeeded */
TLS_DBGPRT_INFO("tcp %d closed\n", conn->skt_num);
conn->state = NETCONN_STATE_NONE;
/* Set back some callback pointers as conn is going away */
conn->pcb.tcp = NULL;
net_free_socket(conn);
/* Trigger select() in socket layer. Make sure everybody notices activity
on the connection, error first! */
} else {
/* Closing failed, restore some of the callbacks */
/* Closing of listen pcb will never fail! */
LWIP_ASSERT("Closing a listen pcb may not fail!", (conn->pcb.tcp->state != LISTEN));
//tcp_sent(conn->pcb.tcp, net_tcp_sent_cb);
tcp_poll(conn->pcb.tcp, net_tcp_poll_cb, 4);
tcp_err(conn->pcb.tcp, net_tcp_err_cb);
tcp_arg(conn->pcb.tcp, conn);
/* don't restore recv callback: we don't want to receive any more data */
}
}
/**
* Receive callback function for UDP netconns.
*/
static void net_udp_recv_cb(void *arg, struct udp_pcb *pcb,
struct pbuf *p, ip_addr_t *srcaddr, u16_t port)
{
struct tls_netconn *conn;
u32 datalen = 0;
//TLS_DBGPRT_INFO("=====>\n");
LWIP_UNUSED_ARG(pcb); /* only used for asserts... */
LWIP_ASSERT("recv_udp must have a pcb argument", pcb != NULL);
LWIP_ASSERT("recv_udp must have an argument", arg != NULL);
conn = (struct tls_netconn *)arg;
LWIP_ASSERT("recv_udp: recv for wrong pcb!", conn->pcb.udp == pcb);
if (conn == NULL || pcb == NULL) {
TLS_DBGPRT_INFO("if (conn == NULL || pcb == NULL) \n");
if (p != NULL)
pbuf_free(p);
return;
}
if(conn->skd->recvf != NULL)
{
datalen = p->tot_len;
conn->skd->recvf(conn->skt_num, p, ERR_OK);
tls_net_set_sourceip(srcaddr->addr);
if (conn->skd->recvwithipf != NULL){
conn->skd->recvwithipf(conn->skt_num, datalen, (u8 *)(&(srcaddr->addr)), port, ERR_OK);
}
}
else
{
if (p){
pbuf_free(p);
p = NULL;
}
}
return;
}
void tls_uart_isr(void *data)
{
struct tls_uart_port *port = (struct tls_uart_port *)data;
struct tls_uart_circ_buf *recv = &port->recv;
u32 intr_src;
u32 rx_fifocnt;
u32 fifos;
u8 ch;
u8 escapefifocnt = 0;
/* check interrupt status */
intr_src = port->regs->UR_INTS;
/* clear uart interrupt */
port->regs->UR_INTS = intr_src;
if ((intr_src & UART_RX_INT_FLAG) && (0 == (port->regs->UR_INTM &UIS_RX_FIFO) ))
{
rx_fifocnt = (port->regs->UR_FIFOS >> 6) & 0x3F;
tls_rx_len += rx_fifocnt;
escapefifocnt = rx_fifocnt;
while(rx_fifocnt-- > 0)
{
ch = (u8)port->regs->UR_RXW;
/* break, stop bit error parity error, not include overrun err */
if(intr_src & UART_RX_ERR_INT_FLAG)
{
port->regs->UR_INTS |= UART_RX_ERR_INT_FLAG;
TLS_DBGPRT_INFO("\nrx err=%x,c=%d,ch=%x\n",intr_src,rx_fifocnt,ch);
/* not insert to buffer */
continue;
}
//if (CIRC_SPACE(recv->head, recv->tail, TLS_UART_RX_BUF_SIZE) == 0)
if (CIRC_SPACE(recv->head, recv->tail, TLS_UART_RX_BUF_SIZE) <= 2)
{
port->icount.buf_overrun++;
TLS_DBGPRT_INFO("\nrx buf overrun int_src=%x\n",intr_src);
if(TLS_UART_FLOW_CTRL_HARDWARE == port->fcStatus)
{
tls_set_uart_rx_status(port->uart_no,TLS_UART_RX_DISABLE);
rx_fifocnt = 0; //如果有硬件流控，关闭接收，把最后一个字符放进环形buffer中
}
else
break;
}
/* insert the character into the buffer */
recv->buf[recv->head] = ch;
recv->head = (recv->head + 1) & (TLS_UART_RX_BUF_SIZE - 1);
port->icount.rx++;
/* process escape char "+++" ，"+++"是一个比较特殊的字符串，用于系统中透传模式的退出*/
if(ch == '+') {
port->plus_char_cnt++;
if(port->plus_char_cnt == 3)
{
if(escapefifocnt != 3)port->plus_char_cnt = 0;
}
} else {
port->plus_char_cnt = 0;
}
}
if(port->ifusermode && 3 == port->plus_char_cnt) //如果是user模式，收到+++退出该模式
{
tls_uart_disable_user_mode();
}
if(port->rx_callback != NULL)
port->rx_callback((char *)(recv->buf + recv->tail), (u16)port->icount.rx);
if(port->ifusermode) //用户模式下把buffer内容传出去，每次从头开始，避免环形buffer tail>head
{
memset(recv->buf, 0, port->icount.rx);
recv->tail = 0;
recv->head = 0;
port->icount.rx = 0;
}
}
/*****************************************************************************
* Function Name // task_start
* Descriptor // before create multi_task, we create a task_start task
* // in this example, this task display the cpu usage
* Input
* Output
* Return
****************************************************************************/
void task_start (void *data)
{
extern void CreateUserTask(void);
extern void RestoreParamToDefault(void);
int err;
u8 mac_addr[6];
u8 tx_gain[12];
u8 errstatus;
tls_irq_init();
/* initial os ticker */
tls_os_timer_init();
#if OS_TASK_STAT_EN > 0
/* Initialize uC/OS-II's statistics */
OSStatInit();
#endif
tls_spi_slave_sel(SPI_SLAVE_FLASH);
tls_spi_init();
tls_fls_init();
tls_fls_gd25qxx_drv_install();
tls_restore_param_from_backup();
RestoreParamToDefault();
//tls_param_to_default();
err = tls_param_init();
if (err) {
TLS_DBGPRT_INFO("read spi param err\n");
}
tls_fwup_init();
/* ¶ÁÈ¡efuseÖеÄmacµØÖ· */
tls_get_mac_addr(mac_addr);
tls_get_tx_gain(tx_gain);
TLS_DBGPRT_INFO("tx gain ");
TLS_DBGPRT_DUMP(&tx_gain[0], 12);
TLS_DBGPRT_INFO("mac addr ");
TLS_DBGPRT_DUMP(&mac_addr[0], 6);
if(tls_wl_init(tx_gain, &mac_addr[0]) == NULL){
TLS_DBGPRT_INFO("wl driver initial failured\n");
}
if (wpa_supplicant_init(mac_addr)) {
TLS_DBGPRT_INFO("supplicant initial failured\n");
}
tls_ethernet_init();
tls_sys_init();
#if TLS_CONFIG_HOSTIF
tls_hostif_init();
#endif
#if (TLS_CONFIG_HOSTIF && TLS_CONFIG_HS_SPI)
tls_hspi_init();
#endif
#if (TLS_CONFIG_HOSTIF &&TLS_CONFIG_UART)
tls_uart_init();
#endif
tls_sys_auto_mode_run();
tls_netif_add_status_event(tls_main_net_status_changed);
BLINKTIMER = OSTmrCreate(0, 10, 2, BlinkTimerProc, NULL, NULL, &errstatus);
if (BLINKTIMER){
OSTmrStart(BLINKTIMER, &errstatus);
}
tls_wifi_one_shot_init();
disp_version_info();
/* User start here */
CreateUserTask();
for (;;)
{
tls_os_time_delay(0x10000000);
}
}
/**
* Start create TCP connection
*/
static err_t net_tcp_start(struct tls_netconn *conn)
{
struct tcp_pcb *pcb;
err_t err;
u16 localportnum = conn->localport;
//TLS_DBGPRT_INFO("=====>\n");
conn->pcb.tcp = tcp_new();
pcb = conn->pcb.tcp;
if (pcb == NULL) {
TLS_DBGPRT_INFO("could not allocate tcp pcb\n");
return ERR_VAL;
}
tcp_arg(pcb, conn);
if (conn->client) {
TLS_DBGPRT_INFO("pcb = 0x%x, conn->addr = 0x%x, port = %d, localport=%d\n",
pcb, conn->addr.addr, conn->port, conn->localport);
tcp_err(pcb, net_tcp_err_cb);
tcp_recv(pcb, net_tcp_recv_cb);
//tcp_nagle_disable(pcb);
if (pcb->recv != NULL) {
TLS_DBGPRT_INFO("pcb->recv != NULL\n");
}
//tcp_sent(pcb, net_tcp_sent_cb);
tcp_poll(pcb, net_tcp_poll_cb, 4);
ip_set_option(pcb, SOF_KEEPALIVE);
if(localportnum > 0 && localportnum <= 0xFFFF)
{
err = tcp_bind(pcb, IP_ADDR_ANY, localportnum);
if (err != ERR_OK)
{
TLS_DBGPRT_INFO("tcp bind failed %d\n", err);
return err;
}
}
err = tcp_connect(pcb, &conn->addr, conn->port, net_tcp_connect_cb);
if (err != ERR_OK) {
TLS_DBGPRT_INFO("tcp connect failed %d\n", err);
return err;
}
if (conn->localport == 0){
conn->localport = pcb->local_port;
}
} else {
TLS_DBGPRT_INFO("pcb ptr = 0x%x, conn->port = %d\n",
pcb, conn->port);
err = tcp_bind(pcb, IP_ADDR_ANY, conn->port);
if (err != ERR_OK) {
TLS_DBGPRT_INFO("tcp bind failed %d\n", err);
return err;
}
conn->pcb.tcp = tcp_listen(pcb);
//ip_set_option(conn->pcb.tcp, SOF_KEEPALIVE);
if (conn->pcb.tcp == NULL) {
/* create tcp sever failed */
TLS_DBGPRT_INFO("tcp listen failed\n");
return ERR_VAL;
}
tcp_arg(conn->pcb.tcp, conn);
tcp_accept(conn->pcb.tcp, net_tcp_accept_cb);
}
return ERR_OK;
}
UINT32 http_fwup(HTTPParameters ClientParams)
{
INT32 nRetCode;
UINT32 nSize,nTotal = 0;
CHAR* Buffer;
HTTP_SESSION_HANDLE pHTTP;
CHAR token[32];
UINT32 content_length=0, size=32;
struct pbuf *p;
do
{
Buffer = (CHAR*)tls_mem_alloc(HTTP_CLIENT_BUFFER_SIZE);
if(Buffer == NULL)
return HTTP_CLIENT_ERROR_NO_MEMORY;
memset(Buffer, 0, HTTP_CLIENT_BUFFER_SIZE);
TLS_DBGPRT_INFO("\nHTTP Client v1.0\n\n");
// Open the HTTP request handle
pHTTP = HTTPClientOpenRequest(0);
if(!pHTTP)
{
nRetCode = HTTP_CLIENT_ERROR_INVALID_HANDLE;
break;
}
// Set the Verb
nRetCode = HTTPClientSetVerb(pHTTP,VerbGet);
if(nRetCode != HTTP_CLIENT_SUCCESS)
{
break;
}
#if TLS_CONFIG_HTTP_CLIENT_AUTH
// Set authentication
if(ClientParams.AuthType != AuthSchemaNone)
{
if((nRetCode = HTTPClientSetAuth(pHTTP,ClientParams.AuthType,NULL)) != HTTP_CLIENT_SUCCESS)
{
break;
}
// Set authentication
if((nRetCode = HTTPClientSetCredentials(pHTTP,ClientParams.UserName,ClientParams.Password)) != HTTP_CLIENT_SUCCESS)
{
break;
}
}
#endif //TLS_CONFIG_HTTP_CLIENT_AUTH
#if TLS_CONFIG_HTTP_CLIENT_PROXY
// Use Proxy server
if(ClientParams.UseProxy == TRUE)
{
if((nRetCode = HTTPClientSetProxy(pHTTP,ClientParams.ProxyHost,ClientParams.ProxyPort,NULL,NULL)) != HTTP_CLIENT_SUCCESS)
{
break;
}
}
#endif //TLS_CONFIG_HTTP_CLIENT_PROXY
if((nRetCode = HTTPClientSendRequest(pHTTP,ClientParams.Uri,NULL,0,FALSE,0,0)) != HTTP_CLIENT_SUCCESS)
{
break;
}
// Retrieve the the headers and analyze them
if((nRetCode = HTTPClientRecvResponse(pHTTP,3)) != HTTP_CLIENT_SUCCESS)
{
break;
}
memset(token, 0, 32);
if((nRetCode = HTTPClientFindFirstHeader(pHTTP, "content-length", token, &size)) != HTTP_CLIENT_SUCCESS)
{
HTTPClientFindCloseHeader(pHTTP);
break;
}
HTTPClientFindCloseHeader(pHTTP);
content_length = atol(strstr(token,":")+1);
nRetCode = socket_fwup_accept(0, ERR_OK);
if(nRetCode != ERR_OK)
break;
// Get the data until we get an error or end of stream code
while(nRetCode == HTTP_CLIENT_SUCCESS || nRetCode != HTTP_CLIENT_EOS)
{
// Set the size of our buffer
nSize = HTTP_CLIENT_BUFFER_SIZE - 4;
// Get the data
nRetCode = HTTPClientReadData(pHTTP,Buffer+3,nSize,0,&nSize);
if(nRetCode != HTTP_CLIENT_SUCCESS && nRetCode != HTTP_CLIENT_EOS)
break;
while (1) {
p = pbuf_alloc(PBUF_TRANSPORT, nSize + 3, PBUF_REF);
if (p != NULL) {
break;
} else {
/* delay 1 ticks */
tls_os_time_delay(1);
}
}
if(nTotal == 0)
*Buffer = SOCKET_FWUP_START;
else if(nRetCode == HTTP_CLIENT_EOS)
*Buffer = SOCKET_FWUP_END;
else
*Buffer = SOCKET_FWUP_DATA;
*(Buffer+1) = (nSize>>8) & 0xFF;
*(Buffer+2) = nSize & 0xFF;
p->payload = Buffer;
p->len = p->tot_len = nSize + 3;
nTotal += nSize;
if(content_length)
printf("Download %%%d\n", nTotal*100/content_length);
nRetCode = socket_fwup_recv(0, p, ERR_OK);
if(nRetCode != ERR_OK)
break;
}
} while(0); // Run only once
tls_mem_free(Buffer);
if(pHTTP)
HTTPClientCloseRequest(&pHTTP);
if(ClientParams.Verbose == TRUE)
{
printf("\n\nHTTP Client terminated %d (got %d kb)\n\n",nRetCode,(nTotal/ 1024));
}
if(nRetCode)
socket_fwup_err(0, nRetCode);
return nRetCode;
}
/**
* Receive callback function for TCP connect.
*/
static err_t net_tcp_recv_cb(void *arg,
struct tcp_pcb *pcb, struct pbuf *p, err_t err)
{
struct tls_netconn *conn;
struct tls_netconn *server_conn = NULL;
err_t err_ret = ERR_OK;
u16 datalen = 0;
#if (RAW_SOCKET_USE_CUSTOM_PBUF)
struct raw_sk_pbuf_custom *pcr = NULL;
struct pbuf *newpbuf = NULL;
#endif
struct pbuf *p_tmp,*p_next;
// TLS_DBGPRT_INFO("net_tcp_recv_cb err=%d\n", err);
LWIP_UNUSED_ARG(pcb);
LWIP_ASSERT("must have a pcb argument", pcb != NULL);
LWIP_ASSERT("must have an argument", arg != NULL);
conn = (struct tls_netconn *)arg;
LWIP_ASSERT("tcp recv for wrong pcb!", conn->pcb.tcp == pcb);
if (err) {
/* tcp is disconnect */
TLS_DBGPRT_INFO("err code = %d\n", err);
err_ret = err;
#if 0
if (conn->pcb.tcp != NULL) {
tcp_arg(conn->pcb.tcp, NULL);
tcp_accept(conn->pcb.tcp, NULL);
tcp_recv(conn->pcb.tcp, NULL);
tcp_sent(conn->pcb.tcp, NULL);
tcp_poll(conn->pcb.tcp, NULL, 4);
tcp_err(conn->pcb.tcp, NULL);
tcp_close(conn->pcb.tcp);
conn->state = NETCONN_STATE_NONE;
net_send_event_to_hostif(conn, NET_EVENT_TCP_DISCONNECT);
conn->pcb.tcp = NULL;
net_free_socket(conn);
}
#endif
if(conn->skd != NULL && conn->skd->recvf != NULL)
{
TLS_DBGPRT_INFO("conn->skd->recvf to call.");
err_ret = conn->skd->recvf(conn->skt_num, p, err);
if(err_ret == ERR_ABRT)
tcp_abort(pcb);
}
if (p){
pbuf_free(p);
p = NULL;
}
return err_ret;
}
if (pcb == NULL ||conn == NULL) {//p == NULL ||
TLS_DBGPRT_INFO("pcb = 0x%x, p = 0x%x\n", pcb ,p);
return ERR_VAL;
}
if(p == NULL)
{
TLS_DBGPRT_ERR("received 0\n");
net_tcp_err_cb(conn, ERR_OK);
return ERR_OK;
}
#if 0//(RAW_SOCKET_USE_CUSTOM_PBUF)
pcr = raw_sk_alloc_pbuf_custom();
if(pcr == NULL)
{
return ERR_MEM;
}
//newpbuf = pbuf_alloced_custom(PBUF_RAW, p->tot_len, PBUF_REF, &pcr->pc, p->payload, p->tot_len);
//使用上面的函数，当pbuf是链表结构时会被截断导致应用层拷贝数据出错
newpbuf = &(pcr->pc);
newpbuf->len = 0;
newpbuf->payload = NULL;
newpbuf->tot_len = p->tot_len;
newpbuf->next = p;
newpbuf->flags = PBUF_FLAG_IS_CUSTOM;
newpbuf->type = PBUF_REF;
newpbuf->ref =1;
if (newpbuf == NULL) {
raw_sk_free_pbuf_custom(pcr);
return ERR_MEM;
}
pcr->original = p;
pcr->param = pcb;
pcr->pc.custom_free_function = raw_sk_free_pbuf_custom_fn;
#endif
#if !RAW_SOCKET_USE_CUSTOM_PBUF
tcp_recved(pcb, p->tot_len);
#endif
if(conn->client && conn->idle_time > 0)
{
TLS_DBGPRT_INFO("conn->skt_num=%d, conn->client=%d\n", conn->skt_num, conn->client);
// server_conn = dl_list_first(&conn->list, struct tls_netconn, list);
server_conn = get_server_conn(conn);
TLS_DBGPRT_INFO("server_conn=%p\n", server_conn);
if(server_conn)
{
conn->idle_time = server_conn->idle_time;
TLS_DBGPRT_INFO("update conn->idle_time %d\n", conn->idle_time);
}
}
if(conn->skd->recvf != NULL)
{
tls_net_set_sourceip(pcb->remote_ip.addr);
datalen = p->tot_len;
p_next = p;
for(p_tmp = p; p_tmp != NULL; )
{
p_next = p_tmp->next;
p_tmp->next = NULL; //把后面的pbuf截断
if(p_next != NULL)
printf("\npbufcat p next=%d\n",p_next);
#if (RAW_SOCKET_USE_CUSTOM_PBUF)
pcr = raw_sk_alloc_pbuf_custom();
if(pcr == NULL)
{
return ERR_MEM;
}
newpbuf = pbuf_alloced_custom(PBUF_RAW, p_tmp->len, PBUF_REF, &pcr->pc, p_tmp->payload, p_tmp->len);
if (newpbuf == NULL) {
raw_sk_free_pbuf_custom(pcr);
return ERR_MEM;
}
pcr->original = p_tmp;
pcr->param = pcb;
pcr->pc.custom_free_function = raw_sk_free_pbuf_custom_fn;
conn->skd->recvf(conn->skt_num, newpbuf, ERR_OK);
#else
conn->skd->recvf(conn->skt_num, p_tmp, ERR_OK);
#endif
p_tmp = p_next;
}
if (conn->skd->recvwithipf != NULL){
conn->skd->recvwithipf(conn->skt_num, datalen, (u8 *)(&(pcb->remote_ip.addr)), pcb->remote_port, ERR_OK);
}
}
else
{
#if 0//(RAW_SOCKET_USE_CUSTOM_PBUF)
raw_sk_free_pbuf_custom(pcr);
#endif
if (p)
pbuf_free(p);
}
return err_ret;
}
static err_t net_tcp_poll_cb(void *arg, struct tcp_pcb *pcb)
{
err_t err_ret = ERR_OK;
struct tls_netconn *conn = (struct tls_netconn *)arg;
struct tls_netconn *server_conn = NULL;
//TLS_DBGPRT_INFO("net_tcp_poll_cb start\n");
if (conn == NULL || pcb == NULL) {
return ERR_CLSD;
}
if (conn->write_state && (conn->state == NETCONN_STATE_CONNECTED)) {
//net_do_writemore(conn);
} else if (conn->state == NETCONN_STATE_CLOSED) {
net_tcp_close_connect(conn);
} else {
if ((pcb->state == CLOSE_WAIT) || (pcb->state == CLOSED)) {
if (conn->pcb.tcp != NULL) {
tcp_arg(conn->pcb.tcp, NULL);
tcp_accept(conn->pcb.tcp, NULL);
tcp_recv(conn->pcb.tcp, NULL);
tcp_sent(conn->pcb.tcp, NULL);
tcp_poll(conn->pcb.tcp, NULL, 4);
tcp_err(conn->pcb.tcp, NULL);
tcp_close(conn->pcb.tcp);
conn->state = NETCONN_STATE_NONE;
net_send_event_to_hostif(conn, NET_EVENT_TCP_DISCONNECT);
conn->pcb.tcp = NULL;
net_free_socket(conn);
}
}
}
if (conn){
if(conn->client && conn->idle_time > 0)
{
TLS_DBGPRT_INFO("conn->skt_num=%d, conn->client=%d\n", conn->skt_num, conn->client);
// server_conn = dl_list_first(&conn->list, struct tls_netconn, list);
server_conn = get_server_conn(conn);
if(server_conn)
{
--conn->idle_time;
if(conn->idle_time == 0)
{
tcp_abort(pcb);
//tls_socket_close(conn->skt_num);
TLS_DBGPRT_INFO("update conn->idle_time %d\n", conn->idle_time);
return ERR_ABRT;
}
}
}
if((conn->skd) != NULL && (conn->skd->pollf) != NULL)
{
err_ret = conn->skd->pollf(conn->skt_num);
if(err_ret == ERR_ABRT)
tcp_abort(pcb);
return err_ret;
}
}
return ERR_OK;
}
