Beispiel #1
0
//这个函数打开TCP端口SON_PORT, 等待来自本地SIP进程的进入连接. 
//在本地SIP进程连接之后, 这个函数持续接收来自SIP进程的sendpkt_arg_t结构, 并将报文发送到重叠网络中的下一跳. 
//如果下一跳的节点ID为BROADCAST_NODEID, 报文应发送到所有邻居节点.
void waitSIP() {
	int listenfd, connfd;
	int option = 1;
	struct sockaddr_in caddr, saddr;
	if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0){
		printf("Listen is Wrong !!!!!!!\n");
		exit(2);
	}
	if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &option, sizeof(option)) < 0){
		printf("Error!!!!!\n");
		exit(2);
	}

	memset(&saddr, 0, sizeof(saddr));
	saddr.sin_family = AF_INET;
	saddr.sin_addr.s_addr = htonl(INADDR_ANY);
	saddr.sin_port = htons(SON_PORT);
	bind(listenfd, (struct sockaddr*)&saddr, sizeof(saddr));
	listen(listenfd, 2);
	
	socklen_t len = sizeof(caddr);
	connfd = accept(listenfd, (struct sockaddr*)&caddr, &len);
	close(listenfd);
	
	sip_conn = connfd;
	sip_pkt_t* pkt = (sip_pkt_t *)malloc(sizeof(sip_pkt_t));
	int *nextNode = (int *)malloc(sizeof(int));
	while(1){
		if(getpktToSend(pkt, nextNode,sip_conn) > 0){
			if(*nextNode == BROADCAST_NODEID){
				int j = 0;
				while(j < neighNum){
					sendpkt(pkt, nt[j].conn);
					j ++;
				}
			}
			else{
				int j = 0;
				while(j < neighNum){
					if(*nextNode == nt[j].nodeID){
						sendpkt(pkt, nt[j].conn);
						j ++;
					}
				}
			}
		}
	}
}
Beispiel #2
0
//这个函数打开TCP端口SON_PORT, 等待来自本地SIP进程的进入连接. 
//在本地SIP进程连接之后, 这个函数持续接收来自SIP进程的sendpkt_arg_t结构, 并将报文发送到重叠网络中的下一跳. 
//如果下一跳的节点ID为BROADCAST_NODEID, 报文应发送到所有邻居节点.
void waitSIP() {
    struct sockaddr_in servaddr, cliaddr;
    socklen_t cliaddr_len;
    int listenfd;

    listenfd = socket(AF_INET, SOCK_STREAM, 0);

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(SON_PORT);

    bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
    listen(listenfd, 20);

    sip_conn = accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);

    //recv pkt from sip and send
    sip_pkt_t pkt;
    int nextNode, conn;
    while(1){
        if(getpktToSend(&pkt,&nextNode,sip_conn) == 1){
            if (pkt.header.type == SIP){
                if((conn = getConnByID(nextNode)) >= 0){
                    if(sendpkt(&pkt,conn) < 0)
                        printf("Error in send pkt to Nbr\n");
                } else {
                    printf("Wrong Node id nextNode = %d\n",nextNode);
                }
            } else if (pkt.header.type == ROUTE_UPDATE){
                int nbr_num = topology_getNbrNum();
                int i;
                for (i = 0; i < nbr_num; i++){
                    if (nt[i].conn >= 0 && sendpkt(&pkt, nt[i].conn) < 0){
                        printf("Error in send route update pkt to Nbr\n");
                    }
                }
            }
        }
    }
    printf("Error in getpktToSend\n");
}
Beispiel #3
0
//这个函数打开TCP端口SON_PORT, 等待来自本地SIP进程的进入连接. 
//在本地SIP进程连接之后, 这个函数持续接收来自SIP进程的sendpkt_arg_t结构, 并将报文发送到重叠网络中的下一跳. 
//如果下一跳的节点ID为BROADCAST_NODEID, 报文应发送到所有邻居节点.
void waitSIP() {
	int sockfd;
	struct sockaddr_in cli_addr, serv_addr;
	socklen_t clilen;
	if((sockfd = socket(AF_INET, SOCK_STREAM, 0))<0) {
		perror("Error create socket\n");
		exit(-1);
	}
	const int one = 1;	//port可以立即重新使用
	setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
	
	serv_addr.sin_family=AF_INET;
	serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	serv_addr.sin_port = htons(SON_PORT);
	if(bind(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr))<0) {
		perror("Error bind\n");
		exit(-1);
	}
	listen(sockfd, MAX_NODE_NUM);
	clilen = sizeof(cli_addr);
	while(1) {
		sip_conn = accept(sockfd, (struct sockaddr*)&cli_addr, &clilen);
		sip_pkt_t* sip_pkt;
		int next;
		while(1) {
			sip_pkt = (sip_pkt_t*)malloc(sizeof(sip_pkt_t));
			memset(sip_pkt, 0, sizeof(sip_pkt_t));
			if(getpktToSend(sip_pkt, &next, sip_conn)>0) {
				if(next == BROADCAST_NODEID) {
					int nbrnum = topology_getNbrNum();
					int i = 0;
					for(i=0; i<nbrnum; i++) {
						//if(nt[i].conn > 0) {
							sendpkt(sip_pkt, nt[i].conn);
						//}
						//else {
							//printf("sendpkt conn<0, id: %d\n", nt[i].nodeID);
						//}
					}
				}
				else {
					if(sip_pkt->header.type == SIP) {
						printf("Receive stcp packet!\n");
					}
					int nbrnum = topology_getNbrNum();
					int i = 0;
					for(i=0; i<nbrnum; i++) {
						if(next == nt[i].nodeID) {
							printf("send message to node %d\n", next);
							sendpkt(sip_pkt, nt[i].conn);
							break;
						}
					}
				}
			}
			else {
				free(sip_pkt);
				close(sip_conn);
				break;
			}
			free(sip_pkt);
		}
	}
	return;
}
Beispiel #4
0
//这个函数打开TCP端口SON_PORT, 等待来自本地SIP进程的进入连接. 
//在本地SIP进程连接之后, 这个函数持续接收来自SIP进程的sendpkt_arg_t结构, 并将报文发送到重叠网络中的下一跳. 
//如果下一跳的节点ID为BROADCAST_NODEID, 报文应发送到所有邻居节点.
void waitSIP() {
	//你需要编写这里的代码.
	int nbrNum = topology_getNbrNum();
	int listenfd=0;
	struct sockaddr_in servaddr,cliaddr;
	socklen_t clilen;
	if ((listenfd=socket(AF_INET, SOCK_STREAM,0))<0) 
	{
		puts("create socket error!");
	}
	servaddr.sin_family=AF_INET;
	servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
	servaddr.sin_port=htons(SON_PORT);
	const int on = 1;
	setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on));
	bind(listenfd,(struct sockaddr *)&servaddr, sizeof(servaddr));
	puts("SON Wait For SIP Server Init Success!");	
	listen(listenfd,1);
	while(1){
	sip_conn=accept(listenfd,(struct sockaddr *)&cliaddr,&clilen);
	puts("Accept SIP Process!");
	int nextNode=0;
	sip_pkt_t* recv_seg=malloc(sizeof(sip_pkt_t));
	memset(recv_seg,0,sizeof(sip_pkt_t));
	while (1){
		if (getpktToSend(recv_seg,&nextNode,sip_conn)!=1)
			//continue;
			break;
		if (nextNode==BROADCAST_NODEID){
			//char *flags=malloc(nbrNum);
			//memset(flags,0,nbrNum);
			for (int i=0;i<nbrNum;i++)
			{
				if (sendpkt(recv_seg,nt[i].conn)==-1) {
					//flags[i]=1;
				}
			}/*
			for (int i=0;i<nbrNum;i++) {
				if (flags[i]==1) {
					forwardpktToSIP(build_failpkt(nt[i].nodeID),sip_conn);
				}
			}
			free(flags);*/
		}
		else{
			for (int i=0;i<nbrNum;i++)
			{
				if (nt[i].nodeID==nextNode)
				{
					if (sendpkt(recv_seg,nt[i].conn)==-1) {
						//forwardpktToSIP(build_failpkt(nt[i].nodeID),sip_conn);
					}
					break;
				}
			}
		}
	}
	printf("####SIP stop!! listening for next SIP\n");
	close(sip_conn);
	}
}
Beispiel #5
0
//这个函数打开TCP端口SON_PORT, 等待来自本地SIP进程的进入连接. 
//在本地SIP进程连接之后, 这个函数持续接收来自SIP进程的sendpkt_arg_t结构, 并将报文发送到重叠网络中的下一跳. 
//如果下一跳的节点ID为BROADCAST_NODEID, 报文应发送到所有邻居节点.
void waitSIP() {
	int listenfd;
	socklen_t clilen;
	clilen = sizeof(struct sockaddr_in);
	struct sockaddr_in cliaddr, servaddr;
	memset(&cliaddr, 0, sizeof(cliaddr));
	memset(&servaddr, 0, sizeof(servaddr));

	listenfd = socket(AF_INET, SOCK_STREAM, 0);
	
	servaddr.sin_family = AF_INET;
	// servaddr.sin_addr.s_addr = INADDR_ANY;
	inet_aton("127.0.0.1", &servaddr.sin_addr);
	servaddr.sin_port = htons(SON_PORT);

	const int on = 1;
	setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(const int));
	bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
	listen(listenfd, MAX_NODE_NUM);

	while (1) {
		// wait for sip connection
		memset(&cliaddr, 0, sizeof(struct sockaddr));
		sip_conn = accept(listenfd, (struct sockaddr *)&cliaddr, &clilen);
		if (sip_conn == -1) {
			print_pos();
			printf("ERROR: accept sip connection failed\n");
			sleep(1);
			continue;
		}

		/* recv from sip and son forward start here */
//		print_pos();
//		printf("MSG: sip access ok, sip_conn = %d, begin to convey sip->son\n", sip_conn);
		sip_pkt_t tmp;
		int nNode, result;
		while (1){
			memset(&tmp, 0, sizeof(sip_pkt_t));
			result = getpktToSend(&tmp, &nNode, sip_conn);
			if(result == -1) {
				print_pos();
				printf("ERROR: get pkt from sip failed\nMSG: Break loop wait another sip connect\n");
				sleep(1);
				break;
			}
			// print_pos();
			// printf("MSG: get sip_pkt_t to send ok, send to nbr...\n");
			// if broad cast, send to every neighbor
			if (nNode == BROADCAST_NODEID){
				int ct = topology_getNbrNum();
				int i;
				for (i = 0; i < ct; i++){
					// print_pos();
					// printf("MSG: broadcast send to socket %d\n", nt[i].conn);
					result = sendpkt(&tmp, nt[i].conn);
					if (result == -1){
						print_pos();
						printf("ERROR: send pkt to broadcast failed\n");
						continue;
					}
				}
//				printf("MSG: send sip_pkt_t to broadcast ok\n");
			} else{	// others, send to next hop
				int destConn = getConnByNode(nNode);
				if (destConn == -1) {
					print_pos();
					printf("ERROR: conn not set up\n");
				}
				result = sendpkt(&tmp, destConn);
				if (result == -1){
					printf("ERROR: send pkt to next node failed\n");
					continue;
				}
//				printf("MSG: send sip_pkt_t to nbr ok, socket=%d\n", destConn);
			}
		}
	}
}
Beispiel #6
0
//这个函数打开TCP端口SON_PORT, 等待来自本地SIP进程的进入连接. 
//在本地SIP进程连接之后, 这个函数持续接收来自SIP进程的sendpkt_arg_t结构, 并将报文发送到重叠网络中的下一跳. 
//如果下一跳的节点ID为BROADCAST_NODEID, 报文应发送到所有邻居节点.
void waitSIP() {
    socklen_t clilen;
    int listenfd;
    //char buf[MAXLINE];
    struct sockaddr_in cliaddr,servaddr;
    listenfd = socket(AF_INET,SOCK_STREAM,0);
    memset(&servaddr, 0, sizeof(struct sockaddr_in));
    servaddr.sin_family=AF_INET;
    servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
    servaddr.sin_port=htons(SON_PORT);
    bind(listenfd,(struct sockaddr *)&servaddr,sizeof(servaddr));
    listen(listenfd,MAX_NODE_NUM);//开始监听
    clilen = sizeof(cliaddr);
    int connfd = accept(listenfd,(struct sockaddr *)&cliaddr,&clilen);
    sip_conn = connfd;
    printf("IP linked\n");
    while(1)
    {
        sip_pkt_t* pkt = (sip_pkt_t*)malloc(sizeof(sip_pkt_t));
        memset(pkt,0,sizeof(sip_pkt_t));
        int nextNode = 0;
    // 如果成功接收sendpkt_arg_t结构, 返回1, 否则返回-1.
        if(getpktToSend(pkt,&nextNode,sip_conn)==1)
        {
            printf("in son ready to send:%d\n",pkt->header.src_nodeID);
            if(nextNode == BROADCAST_NODEID)
            {
                int i = 0;
                for(i = 0 ;i <topology_getNbrNum();i++)
                {
                    printf("send to everyone!\n");
                    if(nt[i].conn == -1)
                    {
                        printf("%d sleep no more send to him\n",nt[i].nodeID);
                        continue;
                    }
                    if(sendpkt(pkt, nt[i].conn) == 1)
                    {
                        printf("send to nextnode sucess! %d\n",nt[i].conn);
                    }
                    else
                    {
                        printf("send fail %d",i);
                    }
                }
            
            }
            else
            {
                int i = 0;
            for(i = 0 ;i <topology_getNbrNum();i++)
            {
                if(nextNode == nt[i].nodeID)
                {
                    break;
                }
            }
            if(i == topology_getNbrNum())
            {
                printf("cant find next node!\n");
                exit(0);
                
            }
            if(nt[i].conn == -1)
            {
                printf("%d sleep no more send to him\n",nt[i].nodeID);
                continue;
            }
            // 如果报文发送成功, 返回1, 否则返回-1.
            if(sendpkt(pkt, nt[i].conn) == 1)
            {
                printf("send to nextnode sucess!\n");
            }
            else
            {
                printf("send to nextnode fail\n");
            }
            }
        }
        else
        {
            printf("SIP stop!!!!!!!!!!!!!!!\n");
            break;
        }
   
        
    }
}