myrip.cpp

rip协议示范

#include "myrip.h"

void rp_inverse_ntoh()
{
  void * tempptr =  & current_rip_packet.command;
  unsigned short * temp = (unsigned short *)( tempptr );
  *temp = ntohs(* temp);
    for(int i=0; i < current_rip_count; i++)
      {
	current_rip_packet.rip_entries[i].metric = ntohl(current_rip_packet.rip_entries[i].metric);
      }
}

void rp_inverse_hton()
{
  void * tempptr =  & current_rip_packet.command;
  unsigned short * temp = (unsigned short *)( tempptr );
  //unsigned short * temp = (unsigned short *)( & current_rip_packet);
  *temp = htons(* temp);
  //current_rip_packet.version = htons(current_rip_packet.version);
    for(int i=0; i < current_rip_count; i++)
      {
	current_rip_packet.rip_entries[i].metric = htonl(current_rip_packet.rip_entries[i].metric);
      }
}

void print_routing_table()
{
  char 	buf[INET_ADDRSTRLEN];
  size_t	buf_len = sizeof(buf);
  const char*	buf_ptr;
  
  printf("--------current routing table----------------\n");
  for (int i = 0; i < current_route_count; i++)
    {
      printf("%dth re:\n", i);
      buf_ptr = inet_ntop(AF_INET, &routing_table[i].dest, buf, buf_len);
      printf("destination: %s ", buf);
      buf_ptr = inet_ntop(AF_INET, &routing_table[i].dest, buf, buf_len);
      printf("next: %s ", buf);
      printf("metric: %d\n\n", routing_table[i].metric);
    }
  printf("---------------------------------------------\n");
}


void print_message(const char* title, const char* content)
{
    printf("\n----------- %s ---------------\n", title);
    printf("- %s -\n", content);
    printf("---------- end of message -----------\n");
}

void print_rip_packet()
{
  printf("----------rip packet contains %d entries: -------------\n", current_rip_count);
  printf("command: %s ",((current_rip_packet.command == RIP_RESPONSE)?"RESPONSE":"REQUEST"));
  printf("version: %d\n",current_rip_packet.version);
  for(int i = 0; i < current_rip_count; i++)
    {
      printf("entry %d: ",i);
      printf("ip: %s ",inet_ntoa(current_rip_packet.rip_entries[i].ip));
      printf("metric: %d\n",current_rip_packet.rip_entries[i].metric);
    }
  printf("--------------------------------------------------------\n");
}

int check_rip_packet()
{
    if (current_rip_packet.version == 2)
	return RIP_CHECK_OK;
    if (current_rip_packet.version == 0)
	return RIP_CHECK_FAIL;

    //check mbz
    if (current_rip_packet.zero)
	return RIP_CHECK_FAIL;
    for (int i = 0; i < current_rip_count; i++)
    {
	if (current_rip_packet.rip_entries[i].zero1 ||
		current_rip_packet.rip_entries[i].zero2 ||
		current_rip_packet.rip_entries[i].zero3)
	{
	    return RIP_CHECK_FAIL;
	}

	return RIP_CHECK_OK;
    }
}

int calculate_rip_metric(int rip_entry_number)
{
  if (current_rip_packet.rip_entries[rip_entry_number].metric + 1 > RIP_INFINITY)
    return RIP_INFINITY;
  return current_rip_packet.rip_entries[rip_entry_number].metric + 1;	
}

void reset_rip_packet(int command)
{
    current_rip_count = 0;
    current_rip_packet.command = command;
    current_rip_packet.version = 1;
    current_rip_packet.zero = 0;
    for (int i = 0; i < RIP_MAX_ENTRY; i++)
    {
	current_rip_packet.rip_entries[0].family = 2;
	current_rip_packet.rip_entries[0].zero1 = 0;
	current_rip_packet.rip_entries[0].ip.s_addr = 0;
	current_rip_packet.rip_entries[0].zero2 = 0;
	current_rip_packet.rip_entries[0].zero3 = 0;
	current_rip_packet.rip_entries[0].metric = 0;
    }
}

void reset_routing_table()
{
    current_route_count = 0;
    for (int i = 0; i < ROUTE_MAX_ENTRY; i++)
    {
	routing_table[i].dest.s_addr = 0;
	routing_table[i].next.s_addr = 0;
	routing_table[i].metric = 0;
	routing_table[i].valid = 1;
	routing_table[i].timer = 0;
	routing_table[i].flag = 0;
    }
}

void init_routing_table()
{
    reset_routing_table();

    for (int i = 0; i < LOCAL_ROUTE_ENTRY; i++)
    {
      if (inet_pton(AF_INET, local_ip[i], &(routing_table[i].dest)) <= 0)
	{
	  printf("inet_pton error\n");
	}
      if (inet_pton(AF_INET, local_ip[i], &(routing_table[i].next)) <= 0)
	{
	  printf("inet_pton error\n");
	}

	routing_table[i].metric = 1;
	routing_table[i].timer = time(NULL);
	routing_table[i].valid = ROUTE_VALID;
	routing_table[i].flag = 0;
    }
    current_route_count = LOCAL_ROUTE_ENTRY;
}

void get_local_ip()
{
  char ac[80];
  if (gethostname(ac, sizeof(ac)) == -1) {
    // cerr << "Error " << WSAGetLastError() <<
    //  " when getting local host name." << endl;
    return ;
  }
  printf("Host name is %s, ", ac);
  
  struct hostent *phe = gethostbyname(ac);
  if (phe == 0) {
    //cerr << "Yow! Bad host lookup." << endl;
    return ;
  }
  
  for (int i = 0; phe->h_addr_list[i] != 0; ++i) {
    local_addr;
    memcpy(&local_addr, phe->h_addr_list[i], sizeof(struct in_addr));
    printf("Address %d: %s \n=======================================\n",i, inet_ntoa(local_addr));
  }
    
}

void init_all()
{
  get_local_ip();
  reset_rip_packet(RIP_RESPONSE);
  init_routing_table();
}

void gen_request_all()
{
    current_rip_count = 1;
    current_rip_packet.command = RIP_REQUEST;
    current_rip_packet.version = 1;
    current_rip_packet.zero = 0;
    current_rip_packet.rip_entries[0].family = 0;
    current_rip_packet.rip_entries[0].zero1 = 0;
    current_rip_packet.rip_entries[0].ip.s_addr = 0;
    current_rip_packet.rip_entries[0].zero2 = 0;
    current_rip_packet.rip_entries[0].zero3 = 0;
    current_rip_packet.rip_entries[0].metric = RIP_INFINITY;
}

void send_rip_packet_to(struct in_addr &dest_ip)
{
  printf("begin sending rip packet:\n");
  print_rip_packet();
  rp_inverse_hton();
    struct sockaddr_in addr;
    int addr_len = sizeof(sockaddr_in);
    bzero(&addr, addr_len);
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = htonl(dest_ip.s_addr);

    //addr.sin_port = htons(RIP_PORT);
    addr.sin_port = htons(RIP_PORT);
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    int val = 1;
    //bind(sockfd, (struct sockaddr*)&addr, sizeof(addr));
    setsockopt(sockfd, SOL_SOCKET, SO_BROADCAST, &val, sizeof(val));
    // reverseMessage();

    if (sendto(sockfd, &current_rip_packet, RIP_PACKET_HEAD+
	       current_rip_count*sizeof(rip_entry)
	       , 0, 
		(const struct sockaddr*)&addr, addr_len) < 0)
      printf("sent green in send_rip_packet_to\n");
    close(sockfd);
	return;

}

void broadcast_rip_packet()
{
  printf("begin broadcasting rip packet:\n");
  print_rip_packet();
  rp_inverse_hton();
    struct sockaddr_in addr;
    int addr_len = sizeof(struct sockaddr_in);

    bzero(&addr, addr_len);
    addr.sin_family = AF_INET;
    //inet_aton("59.66.132.170", &addr.sin_addr);
    addr.sin_addr.s_addr = htonl(INADDR_BROADCAST);
    //addr.sin_addr.s_addr=htonl(addr.sin_addr.s_addr);
    addr.sin_port = htons(520);
    //printf("sending rip packet...\n");
    
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    int val = 1;
    //bind(sockfd, (struct sockaddr*)&addr, sizeof(addr));
    setsockopt(sockfd, SOL_SOCKET, SO_BROADCAST, &val, sizeof(val));
    if (sendto(sockfd, &current_rip_packet, 
	       RIP_PACKET_HEAD+current_rip_count*sizeof(rip_entry),
	       //sizeof(current_rip_packet), 
	       0, (struct sockaddr*)&addr, addr_len) < 0)
    {
	printf("broadcast error in broadcast_rip_packet\n");
    }
    close(sockfd);
    return;
}

void receive_rip_packet()
{
  struct sockaddr_in addr;
    sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd < 0)
    {
	printf("open socket error in start_rip_daemon\n");
	exit(-1);
    }
    bzero(&addr, sizeof(struct sockaddr_in));
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    addr.sin_port = htons(RIP_PORT);
    if(bind(sockfd, (struct sockaddr *)&addr, sizeof(struct sockaddr_in)) < 0)
    {
	printf("bind error in start_rip\n");
	exit(-1);
    }
    //struct sockaddr_in addr;
    int addr_len = sizeof(sockaddr_in);
    int packet_len = 0;

    packet_len = recvfrom(sockfd, &current_rip_packet, RIP_PACKET_HEAD + RIP_MAX_PACKET, 0, 
	    (struct sockaddr*)&addr, (socklen_t*)&addr_len);
    if (packet_len < 0)
      {
	printf("rip packet bad!!!\n");
	return;
      }
    current_rip_count = (packet_len - RIP_PACKET_HEAD) / sizeof(rip_entry);
    //--------------inverse
    rp_inverse_ntoh();
    //--------------end inverse
    struct in_addr source_addr;
    source_addr.s_addr = addr.sin_addr.s_addr;
    //char * temptemp="000.000.000.000";
    //inet_ntop(AF_INET, &source_addr.s_addr, temptemp, sizeof(temptemp));
    //printf("-----------%s\n",inet_ntoa(source_addr));
    
   
    if((source_addr.s_addr != local_addr.s_addr))