/** * 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; }