quagga.try1.c

wifi 无线网络路由协议OLSR linux下C代码

    puts("Error: programmer is an idiot");
    printf ("DEBUG: maxlen = %d, packet_length = %d\n", maxlen, length);
    return maxlen;
  }

  if (packet[2] - 1 < ZEBRA_MESSAGE_MAX && foo[packet[2] - 1]) { 
    if (!(ret = foo[packet[2] - 1] (packet + 3, length - 3))) 
      return length;
    else printf ("DEBUG: Parse error: %d\n", ret);
  }
  else
    printf ("Unknown packet type: %d\n", packet[2]);

  puts ("Quagga: RECIVED PACKET FROM ZEBRA THAT I CAN'T PARSE");

  return length;
}


static int parse_interface_add (char *opt, size_t len) {
  //todo
  return 0;
}


static int parse_interface_delete (char *opt, size_t len) {
  //todo
  return 0;
}


static int parse_interface_address_add (char *opt, size_t len) {
  
  //todo
  return 0;
}

static int parse_interface_up (char *opt, size_t len) {
  
  //todo
  return 0;
}

static int parse_interface_down (char *opt, size_t len) {
  
  //todo
  return 0;
}


static int parse_interface_address_delete (char *opt, size_t  len) {
  //todo
  return 0;
}


/* Parse an ipv4-route-packet recived from zebra
 */
static int parse_ipv4_route (char *opt, size_t len, struct ipv4_route *r) {
  //  puts ("DEBUG: parse_ipv4_route");
  if (len < 4) return -1;
  
  r->type = *opt++;
  r->flags = *opt++;
  r->message = *opt++;
  r->prefixlen = *opt++;
  len -= 4;
  r->prefix = 0;
  
  if ((int)len < r->prefixlen/8 + (r->prefixlen % 8 ? 1 : 0)) return -1;
  
  memcpy (&r->prefix, opt, r->prefixlen/8 + (r->prefixlen % 8 ? 1 : 0));
  opt += r->prefixlen/8 + (r->prefixlen % 8 ? 1 : 0);
  
  if (r->message & ZAPI_MESSAGE_NEXTHOP) {
    if (len < 1) return -1;
    r->nh_count = *opt++;
    if (len < sizeof (uint32_t) * r->nh_count) return -1;
    r->nexthops = olsr_malloc (sizeof (uint32_t) * r->nh_count, 
			       "quagga: parse_ipv4_route_add");
    memcpy (r->nexthops, opt, sizeof (uint32_t) * r->nh_count);
    opt += sizeof (uint32_t) * r->nh_count;
    len -= sizeof (uint32_t) * r->nh_count + 1;
  }

  if (r->message & ZAPI_MESSAGE_IFINDEX) {
    if (len < 1) return -2;
    r->ind_num = *opt++;
    if (len < sizeof (uint32_t) * r->ind_num) return -3;
    r->index = olsr_malloc (sizeof (uint32_t) * r->ind_num,
			    "quagga: parse_ipv4_route_add");
    memcpy (r->index, opt, r->ind_num * sizeof (uint32_t));
    opt += sizeof (uint32_t) * r->ind_num;
    len -= sizeof (uint32_t) * r->ind_num;
  }

  if (r->message & ZAPI_MESSAGE_DISTANCE)
    // todo
    ;

  if (r->message & ZAPI_MESSAGE_METRIC) {
    if (len < sizeof (uint32_t)) return -4;
    memcpy (&r->metric, opt, sizeof (uint32_t));
  }

  return 0;
}


static int ipv4_route_add (char *opt, size_t len) {

  struct ipv4_route r;
  int f;
  
  //  puts ("DEBUG: ipv4_route_add");
  
  f = parse_ipv4_route (opt, len, &r);
  if (f < 0) {
    printf ("parse-error: %d\n",f);
    return f;
  }
  
  add_hna4_route (r);
  return 0;
}

static int ipv4_route_delete (char *opt, size_t len) {
  struct ipv4_route r;
  int f;
  
  f = parse_ipv4_route (opt, len, &r);
  if (f < 0) return f;

  return delete_hna4_route (r);
  // OK, now delete that foo
  
}

static int parse_ipv6_route_add (char *opt, size_t len) {
  //todo
  return 0;
}


/* start redistribution FROM zebra */
int zebra_redistribute (unsigned char type) {

  return zebra_send_command (ZEBRA_REDISTRIBUTE_ADD, &type, 1);
  
  
}  


/* end redistribution FROM zebra */
int zebra_disable_redistribute (unsigned char type) {
  
  return zebra_send_command (ZEBRA_REDISTRIBUTE_DELETE, &type, 1);

}
  
static uint32_t prefixlentomask (uint8_t prefix) {
  uint32_t mask;
  mask = 0xffffffff<<(32-prefix);
  mask = ntohl(mask);
  return mask;
}

int add_hna4_route (struct ipv4_route r) {
  union olsr_ip_addr net, mask;
  
#ifdef MY_DEBUG
  dump_ipv4_route(r, "add_hna4_route");
#endif

  mask.v4 = prefixlentomask(r.prefixlen);
  net.v4 = r.prefix;


#ifdef OLSR_PLUGIN
  add_local_hna4_entry(&net, &mask);
#endif
  free_ipv4_route(r);
  return 0;
}

int delete_hna4_route (struct ipv4_route r) {

  union olsr_ip_addr net, mask;

#ifdef MY_DEBUG
  dump_ipv4_route(r, "delete_hna4_route");
#endif

  mask.v4 = prefixlentomask(r.prefixlen);
  net.v4 = r.prefix;

#ifdef OLSR_PLUGIN
  return remove_local_hna4_entry(&net, &mask) ? 0 : -1;
#endif
  
  free_ipv4_route(r);
  return 0;

}

static void free_ipv4_route (struct ipv4_route r) {

  if(r.message&ZAPI_MESSAGE_IFINDEX && r.ind_num) free(r.index);
  if(r.message&ZAPI_MESSAGE_NEXTHOP && r.nh_count) free(r.nexthops);

}
 
void zebra_clear_routes(void) {

  struct ipv4_route *t;

  t = quagga_routes;
  while (t) {
    zebra_delete_v4_route(*t);
    t=t->next;
  }
  zebra_free_ipv4_route_table(quagga_routes);

  quagga_routes = NULL;
}


void zebra_update_hna (void* f) {
  
  struct ipv4_route *a = zebra_create_ipv4_route_table();
  update_olsr_zebra_routes(a, quagga_routes);
  zebra_free_ipv4_route_table(quagga_routes);

  quagga_routes = a;

}

static struct ipv4_route *zebra_create_ipv4_route_table (void) {

  struct ipv4_route *r = 0, *t = 0 /* make compiler happy */;
  int i;
  struct hna_entry *e;
  struct hna_net *n;

  for (i = 0; i < HASHSIZE; i++) {
    e = hna_set[i].next;
    for(;e != &hna_set[i];e = e->next) {
      n = e->networks.next;
      for(;n != &e->networks; n = n->next) {
	if (!r) {
	  r = zebra_create_ipv4_route_table_entry(n->A_network_addr.v4, 
						  n->A_netmask.v4,
						  e->A_gateway_addr.v4);
	  t = r;
	}
	else {
	  t->next = zebra_create_ipv4_route_table_entry(n->A_network_addr.v4, 
							n->A_netmask.v4,
							e->A_gateway_addr.v4);
	  t = t->next;
	}
      }
    }
  }
  
  return r;
  
}


static struct ipv4_route *zebra_create_ipv4_route_table_entry (uint32_t addr, 
							       uint32_t mask,
							       uint32_t gw) {
  
  struct ipv4_route *r;
  

  r = olsr_malloc (sizeof *r,"zebra_create_ipv4_route_table_entry");
  memset (r, 0, sizeof *r);
  r->prefix = addr;
  r->prefixlen = masktoprefixlen (mask);
  r->message |= ZAPI_MESSAGE_NEXTHOP;
  r->nh_count = 1;
  r->nexthops = olsr_malloc (sizeof (uint32_t), "zebra_create_ipv4_route_table_entry"); 
  *r->nexthops = gw;
  r->next = NULL;

  return r;
}

static uint8_t masktoprefixlen (uint32_t mask) {
  
  
  uint8_t prefixlen = 0;
  while (mask & (1 << ++prefixlen && prefixlen < 32);
  return prefixlen;

}

static void update_olsr_zebra_routes (struct ipv4_route *a, 
				      struct ipv4_route *r) {
  
  struct ipv4_route *t;

  if (!r) {
    puts("no quagga_routing_table aviable");
    for (;a;a = a->next) {
      dump_ipv4_route (*a, "adding this route");
      //      zebra_add_v4_route(*r);
    }
    return;
  }

  while (a) {
    for (t = r; t; t = t->next) {
      if (a->prefix == t->prefix) 
	if (a->prefixlen == t->prefixlen)
	  if (*a->nexthops == *t->nexthops) {
	    goto foo;
	  }
    }
    dump_ipv4_route (*a, "adding this route");
    //zebra_add_v4_route(*a);
  foo:
    a = a->next;
  }

  while (r) {
    for (t = a; t; t = t->next) {
      if (r->prefix == t->prefix) 
	if (r->prefixlen == t->prefixlen)
	  if (*r->nexthops == *t->nexthops) {
	    goto bar;
	  }
    }
    dump_ipv4_route (*r, "deleting this route");
    //zebra_delete_v4_route(*r);
  bar:
    r = r->next;
  }

}


static void zebra_free_ipv4_route_table (struct ipv4_route *r) {
  struct ipv4_route *n;
  if (!r) return;
  while ((n = r->next)) {
    if (r->message & ZAPI_MESSAGE_NEXTHOP) free (r->nexthops);
    if (r->message & ZAPI_MESSAGE_IFINDEX) free (r->index);
    free(r);
    r = n;
  }
}