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]);
}
}
