route_command.c

#include "main-header.h"
#include "routing.h"
#include "route_command.h"
 
static void route_command_list_routes(struct command *com);
static void route_command_clear_routes(struct command *com);
static void route_command_add_route(struct command *com);
static void route_command_remove_route(struct command *com);
static struct route *find_route(long target, long longsource, byte device, byte needsonline);
#define MAX_ROUTING_ENTRIES 30
static struct route routes[MAX_ROUTING_ENTRIES];
 
static byte debug = 0;
void routing_command_debug(byte b) {
  debug = b;
}
 
void routing_command_init() {
  memset(&routes, 0, sizeof(routes));
}
/*
 * if we have no route to a target, we sliently drop the packet
 * a route can have a source, target or both. "Any" is also valid for both.
 * we can say, for example:
 * "any packets from server to nodeX, please send via device 'radio' with nodeY being the next hop"
 * or:  "any packets from nodeX to server, please send via device 'wifi' to server"
 * the command has multiple functions:
 * 1) list routes
 * 2) add route
 * 3) delete route
 * 4) clear routes (except routes to the sender of the packet)
 */
void route_command(struct command *com) {
  long nid = ascii_parse_hex((const byte *)get_arg((struct command *)com, 0), 8, NULL);
 
  if (nid == 1) {
    route_command_list_routes(com);
    return;
  } else if (nid == 2) {
    route_command_add_route(com);
    return;
  } else if (nid == 3) {
    route_command_remove_route(com);
    return;
  } else if (nid == 4) {
    route_command_clear_routes(com);
    return;
  } else {
    send_command_reply(com, COMFLAGS_ACK);
  }
}
static void route_command_list_routes(struct command *com) {
  send_command_reply(com, COMFLAGS_ACK | COMFLAGS_SUCCESS);
}
static void route_command_clear_routes(struct command *com) {
  memset(&routes, 0, sizeof(routes));
  send_command_reply(com, COMFLAGS_ACK | COMFLAGS_SUCCESS);
}
int parse_route_command(struct command *com, struct route *r) {
  if (com->argctr != 6) { // plus type
    return 1;
  }
  r->target = ascii_parse_hex((const uint8_t *)get_arg(com, 1), strlen(get_arg(com, 1)), NULL);
  r->source = ascii_parse_hex((const uint8_t *)get_arg(com, 2), strlen(get_arg(com, 2)), NULL);
  r->sendto = ascii_parse_hex((const uint8_t *)get_arg(com, 3), strlen(get_arg(com, 3)), NULL);
  r->out_device = ascii_parse_hex((const uint8_t *)get_arg(com, 4), strlen(get_arg(com, 4)), NULL);
  r->match_device = ascii_parse_hex((const uint8_t *)get_arg(com, 5), strlen(get_arg(com, 5)), NULL);
  return 0;
}
 
// find a free entry in our routing table
static struct route *find_free_entry() {
  int i;
 
  for (i = 0; i < MAX_ROUTING_ENTRIES; i++) {
    if (routes[i].used == 0) {
      return &routes[i];
    }
  }
  if (debug) {
    printf("[route_command] no free routing table slot available\r\n");
  }
  return NULL;
}
 
static void route_command_add_route(struct command *com) {
  struct route *r = find_free_entry();
 
  if (r == NULL) {
    send_command_reply(com, COMFLAGS_SUCCESS);
  }
  int err = parse_route_command(com, r);
 
  if (err) {
    send_command_reply(com, COMFLAGS_SUCCESS);
    return;
  }
  struct route *nr = find_route(r->target, r->source, r->match_device, 0);
 
  if (nr == NULL) {
    send_command_reply(com, COMFLAGS_ACK | COMFLAGS_SUCCESS);
    r->used = 1;
    printf("[route_command] route added to %N via %N on %i\r\n", r->target, r->sendto, r->out_device);
    return;
  }
  nr->target = r->target;
  nr->match_device = r->match_device;
  nr->out_device = r->out_device;
  nr->source = r->source;
  nr->sendto = r->sendto;
  printf("[route_command] route updated to %N via %N on %i\r\n", nr->target, nr->sendto, nr->out_device);
 
  send_command_reply(com, COMFLAGS_ACK | COMFLAGS_SUCCESS);
}
static void route_command_remove_route(struct command *com) {
  send_command_reply(com, COMFLAGS_ACK | COMFLAGS_SUCCESS);
}
 
static struct route *find_route(long target, long source, byte device, byte needsonline) {
  int i;
 
  for (i = 0; i < MAX_ROUTING_ENTRIES; i++) {
    struct route *r = &routes[i];
    if (r->used == 0) {
      continue;
    }
    if (
      (r->target == target) &&
      (r->source == source) &&
      (r->match_device == device)) {
      if ((needsonline) && (!is_device_online(r->out_device))) {
        continue;
      }
      return r;
    }
  }
  return NULL;
}
 
 
struct route *get_configured_route(struct command *com) {
  struct route *r = find_route(com->target, com->sender, com->sourcedev, 1);
 
  if (r != NULL) {
    if (debug) {
      printf("[route_command] route to %N via %N on %i\r\n", com->target, r->sendto, r->out_device);
    }
    return r;
  }
 
  r = find_route(com->target, 0, com->sourcedev, 1);
  if (r != NULL) {
    if (debug) {
      printf("[route_command] route to %N via %N on %i\r\n", com->target, r->sendto, r->out_device);
    }
    return r;
  }
 
  r = find_route(com->target, com->sender, 0, 1);
  if (r != NULL) {
    if (debug) {
      printf("[route_command] route to %N via %N on %i\r\n", com->target, r->sendto, r->out_device);
    }
    return r;
  }
 
  r = find_route(com->target, 0, 0, 1);
  if (r != NULL) {
    if (debug) {
      printf("[route_command] route to %N via %N on %i\r\n", com->target, r->sendto, r->out_device);
    }
    return r;
  }
 
  if (debug) {
    printf("[route_command] no route to %N\r\n", com->target);
  }
  return NULL;
}
 
void print_forwarding_table() {
  int i;
 
  printf("target  | source | match_device | nexthop | out_device\r\n");
  for (i = 0; i < MAX_ROUTING_ENTRIES; i++) {
    struct route *r = &routes[i];
    if (r->used == 0) {
      continue;
    }
    printf("%N %N %i      %N %i\r\n", r->target, r->source, r->match_device, r->sendto, r->out_device);
  }
  printf("Routing list complete\r\n");
}