//每个listen_to_neighbor线程持续接收来自一个邻居的报文. 它将接收到的报文转发给SIP进程.
//所有的listen_to_neighbor线程都是在到邻居的TCP连接全部建立之后启动的.
void* listen_to_neighbor(void* arg) {
while(1)
{
sip_pkt_t* pkt = (sip_pkt_t*)malloc(sizeof(sip_pkt_t));
memset(pkt,0,sizeof(sip_pkt_t));
if(recvpkt(pkt, nt[*((int *)arg)].conn) != -1)
forwardpktToSIP(pkt,sip_conn);
else
{
//sip_pkt_t* pkt = (sip_pkt_t*)malloc(sizeof(sip_pkt_t));
memset(pkt,0,sizeof(sip_pkt_t));
pkt->header.src_nodeID = topology_getMyNodeID();
//printf("send neb my iD : %d\n",pkt->header.src_nodeID);
pkt->header.dest_nodeID = nt[*((int *)arg)].nodeID;
pkt->header.length = 0;
pkt->header.type = SLEEP;
forwardpktToSIP(pkt,sip_conn);
nt[*((int *)arg)].conn = -1;
return 0;
}
printf("send packet to IP\n");
}
return 0;
}
//每个listen_to_neighbor线程持续接收来自一个邻居的报文. 它将接收到的报文转发给SIP进程.
//所有的listen_to_neighbor线程都是在到邻居的TCP连接全部建立之后启动的.
void* listen_to_neighbor(void* arg) {
int i = *(int *)arg;
int conn = nt[i].conn;
sip_pkt_t* sip_pkt;
while(1) {
sip_pkt = (sip_pkt_t*)malloc(sizeof(sip_pkt_t));
memset(sip_pkt, 0, sizeof(sip_pkt_t));
if(recvpkt(sip_pkt, conn) > 0) {
if(sip_pkt->header.type == SIP ) {
printf("receive stcp packet from node %d\n", sip_pkt->header.src_nodeID);
}
forwardpktToSIP(sip_pkt, sip_conn);
}
else {
//nt[i].conn = -1; wait for next connection
close(conn);
socklen_t clilen;
struct sockaddr_in cli_addr;
clilen = sizeof(cli_addr);
conn = accept(listenfd, (struct sockaddr*)&cli_addr, &clilen);
int node = topology_getNodeIDfromip(&cli_addr.sin_addr);
nt_addconn(nt, node, conn);
}
free(sip_pkt);
}
}
//每个listen_to_neighbor线程持续接收来自一个邻居的报文. 它将接收到的报文转发给SIP进程.
//所有的listen_to_neighbor线程都是在到邻居的TCP连接全部建立之后启动的.
void* listen_to_neighbor(void* arg) {
int index = *(int *)arg;
// printf("MSG: listen to neighbor node=%d\n", nt[index].nodeID);
sip_pkt_t tmp;
if (nt[index].conn == -1) {
print_pos();
printf("ERROR: connect not set for node %d\n", nt[index].nodeID);
pthread_exit(NULL);
}
while (1) {
memset(&tmp, 0, sizeof(sip_pkt_t));
// recv a pkt from son
// print_pos();
// printf("MSG: prepare to recvpkt from socket=%d\n", nt[index].conn);
int result;
result = recvpkt(&tmp, nt[index].conn);
if (result == -1){
print_pos();
printf("ERROR: recvpkt from neighbor node=%d socket=%d failed\n", nt[index].nodeID, nt[index].conn);
sleep(1);
}
// else printf("MSG: recvpkt sip_pkt_t ok, send to sip...\n");
// forward the pkt to sip
result = forwardpktToSIP(&tmp, sip_conn);
if (result == -1){
print_pos();
printf("ERROR: forward pkt to sip failed\n");
}
// else printf("MSG: send to sip ok\n");
}
pthread_exit(NULL);
}
//每个listen_to_neighbor线程持续接收来自一个邻居的报文. 它将接收到的报文转发给SIP进程.
//所有的listen_to_neighbor线程都是在到邻居的TCP连接全部建立之后启动的.
void* listen_to_neighbor(void* arg) {
sip_pkt_t* pkt = (sip_pkt_t *)malloc(sizeof(sip_pkt_t));
while(1){
memset(pkt, 0, sizeof(sip_pkt_t));
if(recvpkt(pkt,nt[*(int *)arg].conn) > 0)
forwardpktToSIP(pkt, sip_conn);
else
pthread_exit(NULL);
}
}
//每个listen_to_neighbor线程持续接收来自一个邻居的报文. 它将接收到的报文转发给SIP进程.
//所有的listen_to_neighbor线程都是在到邻居的TCP连接全部建立之后启动的.
void* listen_to_neighbor(void* arg) {
//你需要编写这里的代码.
int now=(*(int*)arg);
sip_pkt_t* data=malloc(sizeof(sip_pkt_t));
memset(data,0,sizeof(sip_pkt_t));
while (1){
if (recvpkt(data,nt[now].conn)<0)
{
close(nt[now].conn);
//forwardpktToSIP(build_failpkt(nt[now].nodeID),sip_conn);
break;
}
forwardpktToSIP(data,sip_conn);
}
free(data);
}
//每个listen_to_neighbor线程持续接收来自一个邻居的报文. 它将接收到的报文转发给SIP进程.
//所有的listen_to_neighbor线程都是在到邻居的TCP连接全部建立之后启动的.
void* listen_to_neighbor(void* arg) {
nbr_entry_t currNbr = nt[*(int *)arg];
int conn = currNbr.conn;
sip_pkt_t pkt;
while(1){
if (recvpkt(&pkt,conn) == 1){
printf("recv a pkt from nbr %d\n",currNbr.nodeID);
if(forwardpktToSIP(&pkt,sip_conn) < 0)
printf("Error in send pkt to SIP\n");
} else {
printf("Error when try to recvpkt from neighbor\n");
printf("connect lost, exit\n");
close(nt[*(int *)arg].conn);
nt[*(int *)arg].conn = -1;
break;
}
}
printf("Error in recvpkt\n");
return 0;
}
