void tcp_timer(void) { int i; dprintf("tcp_timer!\n"); for (i = 0; i < TCP_MAX_OPENSOCKETS; i++) { if (tcp_sockets[i].id == TCP_SKID_INVAL) continue; if (tcp_sockets[i].state == STATE_CLOSED) continue; if (tcp_sockets[i].state == STATE_TIME_WAIT) { if ((RimGetTicks() - tcp_sockets[i].lastchange) > TIME_WAIT_DELAY) tcp_changestate(tcp_sockets+i, STATE_CLOSED); } if (tcp_sockets[i].txqueue) tcp_send_data(tcp_sockets+i, NULL, 0); } return; }
//////////////////////////////发送函数//////////////////////////////////// static void send_download_blacklist_data(char* recv_buf, int* precv_len) { p16_tcp_blacklist_package blacklist_package; memcpy(blacklist_package.guide_code,"HST",3); blacklist_package.cmd_code = 0xDA;//下载黑名单 get_order_array_by_int(0, blacklist_package.machine_addr, 2); blacklist_package.package_len = 2+10;//机器地址+数据包长度 get_blacklist_data(&blacklist_package.data); int send_len = 0; char send_buff[2048] = {0}; pack_tcp_blacklist_data(&blacklist_package, send_buff, &send_len); if(send_len>0) { //打印发送数据 LOG((LOG_DEBUG,"黑名单发送的串打印:")); p16dump_hex(LOG_DEBUG,send_buff,send_len); int ret = 0; ret = tcp_send_data(send_buff, send_len, recv_buf, precv_len); if(ret) { //tcp发送错误 return; } } }
static err_t atcp_poll(void *arg, struct tcp_pcb *pcb) { struct ttcp* _ttcp = arg; if ((_ttcp) && (_ttcp->left>0)) ++tcp_poll_retries; if (tcp_poll_retries > 4) { WARN("ARD TCP [%p] arg=%p retries=%d\n", pcb, arg, tcp_poll_retries); tcp_poll_retries = 0; tcp_abort(pcb); atcp_init_pend_flags(); return ERR_ABRT; } WARN("ARD TCP [%p-%p] arg=%p retries=%d pend.close:%d\n", (_ttcp)?_ttcp->tpcb:0, pcb, arg, tcp_poll_retries, pending_close); if (_ttcp) tcp_send_data(_ttcp); if (pending_close) { err_t err = tcp_close(pcb); if (err == ERR_MEM) { pending_close = true; } else { atcp_init_pend_flags(); } INFO_TCP("ARD TCP [%p-%p] try to close pending:%d\n", pcb, (_ttcp)?_ttcp->tpcb:0, pending_close); } return ERR_OK; }
static int send_rt_transdtl_data(char* recv_buf, int* precv_len) { p16_tcp_rt_package package; memset(&package,0,sizeof package); memcpy(package.guide_code,"HST",3); package.cmd_code = 0xD2;//实时交易流水 get_order_array_by_int(0,package.machine_addr,2);//机器地址暂时设为0 int ret = 0; ret = get_rt_transdtl_data(&package.data); if(ret) { LOG((LOG_DEBUG,"尝试发送实时流水失败,原因=%d",ret)); return -1; } //数据包长度为机器地址加数据信息包长度 package.package_len = sizeof(package.data) + sizeof(package.machine_addr); int send_len = 0; char send_buff[2048] = {0}; pack_tcp_rt_transdtl_data(&package, send_buff, &send_len); if(send_len>0) { //打印发送数据 LOG((LOG_DEBUG,"实时流水发送的串打印:")); p16dump_hex(LOG_DEBUG,send_buff,send_len); int ret = 0; ret = tcp_send_data(send_buff, send_len, recv_buf, precv_len); } return 0; }
void publish_tcp_data(void* data) { tcp_pub_t* conn = (tcp_pub_t*)data; int size,bytes_io; char buf[MAX_BUFF]; int client = conn->client; // get the header size bytes_io = recv(client, &size, sizeof(size), 0); if(bytes_io<0) return; // get the header bytes_io = recv(client, buf, size, 0); if(bytes_io<=0 || !verify_ros_header(conn->pub,buf, size)) return; memset(buf ,0,MAX_BUFF); size = gen_tcp_header_for(conn->pub,buf); // send then header first bytes_io = send(client, buf, size, 0); if(bytes_io<0) return; do { // send a loop data // wait for data to be available while(conn->pub->data_ok == TOPIC_DATA_NOK && conn->pub->status && stros_ok()); // mark topic as read pthread_mutex_lock (&node_mux); conn->pub->data_ok = TOPIC_DATA_NOK; pthread_mutex_unlock(&node_mux); bytes_io = tcp_send_data(conn->pub,client); }while(stros_ok() && conn->pub->status && bytes_io != -1); //LOG("Send to client %s\n", conn->pub->topic); //rpc_dummy_response(conn->client); }
/* * Send a SYN-ACK to destip, from port srcport to port dstport, acking seqnum. * * XXX this only does passive opens, not active opens. * * XXX make this use the queue and tcp_txenqueue(). */ static int tcp_send_syn(struct tcp_socket *sk) { tcp_txenqueue(sk, TCPBIT_SYN, sk->snd_nxt /*ntohl(hdr->seqnum)*/, NULL, 0); tcp_send_data(sk, NULL, 0); return 0; }
static int tcp_send_fin(struct tcp_socket *sk) { tcp_txenqueue(sk, TCPBIT_FIN, sk->snd_nxt, NULL, 0); tcp_send_data(sk, NULL, 0); return 0; }
static int tcp_echo_handler(struct tcp_socket *sk, const unsigned char *data, int datalen) { dprintf("tcp: echo: echoing %d bytes\n", datalen); tcp_send_data(sk, data, datalen); /* echo it! */ return 1; }
static int tcp_telnet_handler(struct tcp_socket *sk, const unsigned char *data, int datalen) { dprintf("tcp: telnet: got %d bytes\n", datalen); if (sk->protflags & TCP_TELNET_LOGGED_IN) { if (data[0] == '\r') { tcp_send_data(sk, "mid@rim:~$ \r\n", 13); return 1; } return 0; } else { tcp_send_data(sk, loginprompt, strlen(loginprompt)); return 1; } return 0; }
/** * Only used in TCP mode. */ static err_t tcp_connect_cb(void *arg, struct tcp_pcb *tpcb, err_t err) { struct ttcp* ttcp = arg; printk("TTCP [%p]: connect\n", ttcp); ttcp->start_time = timer_get_ms(); #if 0 tcp_sent(tpcb, tcp_sent_cb); #endif tcp_send_data(ttcp); return ERR_OK; }
static int send_batch_transdtl_data(char* recv_buf, int* precv_len) { int ret = 0; char send_buff[2048];//最终发送的数组 p16_tcp_batch_package batch_package; uint32 send_len; memset(&batch_package,0,sizeof batch_package); batch_package.data.tcp_transdtl_cnt = MAX_TCP_TRANSDTL_CNT; ret = get_batch_transdtl_data(batch_package.data.tcp_transdtl_list, &batch_package.data.tcp_transdtl_cnt); if(ret) { LOG((LOG_DEBUG,"批量上传getdata失败")); return -1; } if(batch_package.data.tcp_transdtl_cnt>0) { memset(send_buff,0,2048); memcpy(batch_package.guide_code,"HST",3); batch_package.cmd_code = 0xDB;//批量上传交易流水 get_order_array_by_int(0,batch_package.machine_addr,2); //数据包长度为机器地址加数据信息包长度 batch_package.package_len = sizeof(batch_package.machine_addr)+ sizeof(batch_package.data.tcp_transdtl_cnt) + sizeof(p16_tcp_transdtl)*batch_package.data.tcp_transdtl_cnt; LOG((LOG_DEBUG,"批量流水package_len=%d",batch_package.package_len)); send_len = 0; pack_tcp_batch_data(&batch_package, send_buff, &send_len);//由于不是每次都是最大发送条数 if(send_len>0) { //打印发送数据 LOG((LOG_DEBUG,"send_len=%d,send_buff:",send_len)); p16dump_hex(LOG_DEBUG,send_buff,send_len); ret = tcp_send_data(send_buff, send_len, recv_buf, precv_len); /* //分析recv_buf p16_recv_batch_transdtl_package recv_batch_package; parse_recv_data(recv_buf,1,&recv_batch_package); if(recv_batch_package.ret_code > 0)//?? { LOG((LOG_ERROR,"上传失败")); } */ } } return 0; }
/** * Only used in TCP mode. * Called by lwip when there is new space available in the TCP send buffer */ static err_t tcp_sent_cb(void *arg, struct tcp_pcb *pcb, u16_t len) { struct ttcp *ttcp = arg; if (ttcp->left > 0) { tcp_send_data(ttcp); if (ttcp->verbose) { printk("."); if (ttcp->print_cnt % 80 == 0) printk("\n"); ttcp->print_cnt++; } } else if (pcb->snd_queuelen == 0) { ttcp_done(ttcp, 0); } return ERR_OK; }
static void send_heart_data(char* recv_buf, int* precv_len) { p16_tcp_heart_package heart_package; memcpy(heart_package.guide_code,"HST",3); heart_package.cmd_code = 0xD5;//心跳 get_order_array_by_int(0,heart_package.machine_addr,2);//机器地址暂时设为0 //数据包长度为机器地址加数据信息包长度 heart_package.package_len = 9 + 2; get_heart_data(&heart_package.data); int send_len = 0; char send_buff[2048] = {0}; pack_tcp_heart_data(&heart_package, send_buff, &send_len); if(send_len>0) { //打印发送数据 LOG((LOG_DEBUG,"心跳发送的串打印:")); p16dump_hex(LOG_DEBUG,send_buff,send_len); int ret = 0; ret = tcp_send_data(send_buff, send_len, recv_buf, precv_len); } }
static err_t tcp_data_sent(void *arg, struct tcp_pcb *pcb, u16_t len) { struct ttcp *_ttcp; LWIP_UNUSED_ARG(len); _ttcp = arg; tcp_poll_retries = 0; if (_ttcp) _ttcp->buff_sent = 1; INFO_TCP("Packet sent pcb:%p len:%d dur:%d left:%d count:%d\n", pcb, len, timer_get_ms() - startTime, (_ttcp)?(_ttcp->left):0, isDataSentCount); isDataSentCount = 0; if ((_ttcp)&&(_ttcp->left > 0)) { tcp_send_data(_ttcp); } return ERR_OK; }
static err_t atcp_poll_conn(void *arg, struct tcp_pcb *pcb) { struct ttcp* _ttcp = arg; ++tcp_poll_retries; if (tcp_poll_retries > 8) { WARN("ARD TCP [%p-%p] arg=%p retries=%d\n", pcb, _ttcp->tpcb, arg, tcp_poll_retries); tcp_poll_retries = 0; tcp_abort(pcb); return ERR_ABRT; } WARN("ARD TCP [%p-%p] arg=%p retries=%d pend.close:%d conn:%d\n", (_ttcp)?_ttcp->tpcb:0, pcb, arg, tcp_poll_retries, pending_close, _connected); if ((_ttcp)&&(_connected)) tcp_send_data(_ttcp); if (pending_close) { err_t err = tcp_close(pcb); if (err == ERR_MEM) { pending_close = true; } else { cleanSockState_cb(_ttcp); if (_ttcp->payload) free(_ttcp->payload); free(_ttcp); pending_close = false; } INFO_TCP("ARD TCP [%p-%p] try to close pending:%d\n", pcb, (_ttcp)?_ttcp->tpcb:0, pending_close); } return ERR_OK; }
/** * Only used in TCP mode. * Scheduled by tcp_send_data(). tcp_sent() is not used for performance reasons. */ static void tcp_timeout_cb(void *ctx) { struct ttcp *ttcp = ctx; if (ttcp->left > 0) { tcp_send_data(ttcp); if (ttcp->verbose) { printk("."); if (ttcp->print_cnt % 80 == 0) printk("\n"); ttcp->print_cnt++; } return; } /* all sent - empty queue */ if (ttcp->tpcb->snd_queuelen) ttcp->tid = timer_sched_timeout_cb(0, TIMEOUT_ONESHOT, tcp_timeout_cb, ttcp); else ttcp_done(ttcp, 0); }
int sendTcpData(void* p, uint8_t* buf, uint16_t len) { INFO_TCP("buf:%p len:%d\n", buf, len); DUMP_TCP(buf,len); struct ttcp* _ttcp = (struct ttcp*) p; if (_ttcp==NULL) { WARN("ttcp == NULL!\n"); return WL_FAILURE; } INFO_TCP_VER("CLI> p=%p _ttcp=%p state(tpcb):%d state(lpcb):%d\n", p, ((struct ttcp*) p)->tpcb, ((struct ttcp*) p)->tpcb->state, ((struct ttcp*) p)->lpcb->state); if ((_ttcp != NULL) && (_ttcp->tpcb != NULL) && (buf != NULL) && (len != 0) && (_ttcp->payload != NULL)) { if (_ttcp->tpcb->state == ESTABLISHED || _ttcp->tpcb->state == CLOSE_WAIT || _ttcp->tpcb->state == SYN_SENT || _ttcp->tpcb->state == SYN_RCVD) { memcpy(_ttcp->payload, buf, len); _ttcp->payload[len]='\0'; INFO_TCP_VER("%s\n", _ttcp->payload); _ttcp->left = len; tcp_sent(_ttcp->tpcb, tcp_data_sent); tcp_send_data(_ttcp); return WL_SUCCESS; } } //printk("Write failure _ttcp=%p _ttcp->tpcb=%p buf=%p len=%d\n", _ttcp, _ttcp->tpcb, buf, len); return WL_FAILURE; }
static int tcp_http_handler(struct tcp_socket *sk, const unsigned char *data, int datalen) { char request[64]; char *req = request; dprintf("tcp: http: got %d bytes\n", datalen); if (datalen <= 5) /* minimum HTTP request */ return 0; if (datalen > sizeof(request)-1) datalen = sizeof(request)-1; memcpy(req, data, datalen); req[datalen] = '\0'; if (strncmp(req, "GET ", 4) == 0) { req += 4; if (index(req, ' ')) *(index(req, ' ')) = '\0'; dprintf("tcp: http: req = %s\n", req); if ((strcmp(req, "/") == 0) || (strncmp(req, "/index", 6) == 0)) { tcp_send_data(sk, httpindex, strlen(httpindex)); tcp_send_fin(sk); tcp_changestate(sk, STATE_FIN_WAIT_1); return 1; } } return 0; }
static void http_control_process(int soc_handler,char event,char *srcipaddr,unsigned short srcport, unsigned short data_index, unsigned short data_len) { int resp; switch(event) { case TCP_EVENT_CONN_REQ: if (debug_http) printf("Connection Request from IP: %d.%d.%d.%d - Port: %d\n", *srcipaddr,*(srcipaddr+1),*(srcipaddr+2),*(srcipaddr+3),srcport); resp = tcp_conn_accept(soc_handler); if (resp == TCP_SOCKET_ERROR) printf("Accept Error: no free socket available\n"); else { if (debug_http) printf("Socket %d created\n", resp); } break; case TCP_EVENT_ESTABLISHED: if (debug_http) printf("Connection Established with IP: %d.%d.%d.%d - Port: %d\n", *srcipaddr,*(srcipaddr+1),*(srcipaddr+2),*(srcipaddr+3),srcport); break; case TCP_EVENT_DATA: if (debug_http) printf("Event: Data Available from IP: %d.%d.%d.%d - Port: %d\n", *srcipaddr,*(srcipaddr+1),*(srcipaddr+2),*(srcipaddr+3),srcport); resp = HTTP_process(data_index, data_len); file_index[soc_handler-1] = resp; if (debug_http_file) { if (resp == -2) printf("Serving: 501 Command Not Implemented!\n"); else if (resp == -1) printf("Serving: 404 Page Not Found!\n"); else printf("Serving file %s\n", filesystem[resp].filename); printf("Serving size %d\r\n", filesystem[resp].filesize); } if (tcp_send_data(soc_handler, create_content) == TCP_SOCKET_ERROR) printf("Error sending data: TCP already have data to send!\r\n"); break; case TCP_EVENT_SEND_COMPLETED: tcp_conn_close(soc_handler); break; case TCP_EVENT_CONN_CLOSED: tcp_socket_close(soc_handler); if (debug_http) printf("Socket %d closed\n", soc_handler); break; case TCP_EVENT_RESET: if (debug_http) printf("Error: Socket %d was Reset\r\n", soc_handler); tcp_conn_close(soc_handler); break; case TCP_EVENT_rTOUT: tcp_conn_close(soc_handler); printf("Error: Socket %d Timed Out\r\n", soc_handler); break; case TCP_EVENT_cTOUT: printf("Error: Connection in socket %d Timed Out\r\n", soc_handler); break; case TCP_EVENT_CLOSE_REQ: tcp_conn_close(soc_handler); break; default: printf("Unknown Event: %d\n",event); break; } }
/** * @brief tcp_receiv callback * @param arg: argument to be passed to receive callback * @param tpcb: tcp connection control block * @param err: receive error code * @retval err_t: retuned error */ static err_t tcp_echoclient_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err) { struct echoclient *es; err_t ret_err; int i; LWIP_ASSERT("arg != NULL",arg != NULL); es = (struct echoclient *)arg; /* if we receive an empty tcp frame from server => close connection */ if (p == NULL) { /* remote host closed connection */ es->state = ES_CLOSING; g_net_state = ES_CLOSING; if(es->p_tx == NULL) { /* we're done sending, close connection */ tcp_echoclient_connection_close(tpcb, es); } else { /* send remaining data*/ tcp_echoclient_send(tpcb, es); } ret_err = ERR_OK; } /* else : a non empty frame was received from echo server but for some reason err != ERR_OK */ else if(err != ERR_OK) { /* free received pbuf*/ pbuf_free(p); ret_err = err; } else if(es->state == ES_CONNECTED) { /* increment message count */ //message_count++; /* Acknowledge data reception */ tcp_recved(tpcb, p->tot_len); memcpy(recev_buf,p->payload,p->tot_len); for(i=0;i<p->tot_len;i++) printf("%c",recev_buf[i]); if(g_net_state==1) { sprintf((char*)data, "sending tcp client message %d\r\n",cnt++); tcp_send_data(data,strlen(data)); } pbuf_free(p); //tcp_echoclient_connection_close(tpcb, es); ret_err = ERR_OK; } /* data received when connection already closed */ else { /* Acknowledge data reception */ tcp_recved(tpcb, p->tot_len); /* free pbuf and do nothing */ pbuf_free(p); ret_err = ERR_OK; } return ret_err; }
int create_signal_cli_thread(int index, int sockfd, struct sockaddr_in *cli_addr) { char newipconnect[20] = {0}; //打印客户端ip// inet_ntop(AF_INET, (void *) & (cli_addr->sin_addr), newipconnect, 16); PRINTF("sockfd =%d ip =%s\n", sockfd, newipconnect); int nPos = 0; int nLen = 0; int cli_num = 0; char send_buf[256] = {0}; char user_id[8] = {0}; char dtype[16] = {0}; unsigned int cur_time = 0; GetDeviceType(dtype); nPos = GetNullClientData_new(index); cli_num = read_client_num(index); PRINTF("GetNullClientData_new[%d] = %d\n", index, nPos); nLen = sizeof(struct sockaddr_in); if(-1 == nPos || cli_num >= 6) { //需要告警上报 package_head_msg(send_buf, 30087, dtype, "0", user_id); tcp_send_data(sockfd, send_buf); ERR_PRN("ERROR: max client error\n"); close(sockfd); sockfd = -1; } else { int nSize = 0; int result; client_msg_arg_t *arg = malloc(sizeof(client_msg_arg_t)); /* set client used */ PRINTF("index : [%d]pos =%d,sockfd =%d\n", index, nPos, sockfd); SETCLIUSED_NEW(index, nPos, TRUE); SETCLILOGIN_NEW(index, nPos, TRUE); SETSOCK_NEW(index, nPos, sockfd); cur_time = getCurrentTime(); SETCONNECTTIME_NEW(index, nPos, cur_time); nSize = 1; if((setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (void *)&nSize, sizeof(nSize))) == -1) { perror("setsockopt failed"); } nSize = 0; nLen = sizeof(nLen); result = getsockopt(sockfd, SOL_SOCKET, SO_SNDBUF, &nSize , &nLen); if(result) { ERR_PRN("getsockopt() errno:%d socket:%d result:%d\n", errno, sockfd, result); } nSize = 1; PRINTF("Clent:%s connected,nPos:%d socket:%d!\n", newipconnect, nPos, sockfd); //Create ClientMsg task! arg->pos = nPos; arg->index = index; result = pthread_create(&cli_pthread_id[index][nPos], NULL, (void *)recv_client_msg_thread, (void *)arg); if(result) { close(sockfd); sockfd = -1; ERR_PRN("creat pthread ClientMsg error = %d!\n" , errno); return 0; } sem_wait(&g_new_tcp_lock[index]); } }