routing.c

Go to the documentation of this file.

#include "main-header.h"
#include "routing.h"
#include "espressif/esp8266_flash.h"
#include "user_app_exe.h"
#include "forwarding.h"
#include "networkif.h"
 
static byte debug = 0;
static long last_run = 0;
static long last_announce_sent = 0;
 
static void routing_update(const struct command *com, uint8_t signal_indicator);
static void peer_update(int added, struct hostroute *host);
 
#define ROUTING_EVENT_LOOP_INTERVAL 30
#define ROUTING_ANNOUNCE_INTERVAL 120
 
#define HOSTROUTE_ENTRIES 40
 
#define MAX_ROUTE_AGE_SECONDS 600
static struct hostroute knownhosts[HOSTROUTE_ENTRIES];
 
static void r_on_new_node(struct hostroute *host);
const char *decisionname(int decision);
void routing_init() {
  memset(&knownhosts, 0, sizeof(knownhosts));
}
int is_device_online(int device) {
  if (device == SOURCE_WIFI) {
    return esp8266_is_enabled(); // for all but the first packet we should use this: esp_cloud_is_connected();
  } else if (device == SOURCE_SERIAL) {
    return 1;
  }
  return isonline_by_type(device);
}
 
void bridge_packet(struct command *com) {
  if (!config_get_flag(CONFIG_FLAGS_ROUTING_ENABLED)) {
    printf("bridging of packets disabled\r\n");
    return;
  }
 
  if (com->flags & COMFLAGS_FORWARDED) {
    printf("Not bridging packet. Flag FORWARDED is set already\r\n");
    return;
  }
  com->recipient = BROADCAST;
  com->flags = com->flags | COMFLAGS_FORWARDED;
  com->sourcedev = SOURCE_WIFI;
  send_command(com);
  int i;
 
  // radio is dodgy? try several times?
  for (i = 0; i < 5; i++) {
    com->sourcedev = SOURCE_RADIO;
    send_command(com);
    Delay(20);
  }
}
byte get_routing_debug() {
  return debug;
}
void set_routing_debug(byte b) {
  debug = b;
  printf("Routing debug set to %i\r\n", debug);
}
byte got_new_packet(struct command *com, uint8_t signal_indicator) {
  if (!is_command_valid(com)) {
    error_com(com);
    return 0;
  }
  if (debug) {
    printf("***** ROUTING DEBUG (new packet received) *****\r\n");
    command_print(com);
  }
  // we always 'remember' nodes (i.e. keep our routing tables uptodate)
  routing_update(com, signal_indicator);
 
  byte action = 0;
  long me = get_my_node_id();
  long r = com->recipient;
  long t = com->target;
 
  // never forward route-request replies! they MUST remain local.
  if (com->com == 12) {
    if ((r == BROADCAST) && (com->sender == CLOUD_SERVER)) {
      send_command_reply(com, COMFLAGS_ACK | COMFLAGS_SUCCESS);
    }
    free_command(com);
    return 0;
  }
  if (r == me) {
    // *** DEAL WITH PACKETS TO MYSELF (as recipient)*** //
    if (t == me) {
      // we are the target (as well as the recipient) - process locally
      process_command(com);
      action = 3;
    } else if (t == BROADCAST) {
      bridge_packet(com);
      process_command(com);
      action = 2;
    } else if (t == CLOUD_SERVER) {
      forward_packet(com);
      action = 1;
    } else {
      // we are recipient but not target, forward packet
      int e = forward_packet(com);
      if (e > 0) {
        routing_error(com, e);
      }
      action = 1;
    }
  } else if (r == BROADCAST) {
    // *** DEAL WITH BROADCASTS *** //
    if ((t == me) || (t == BROADCAST)) {
      process_command(com);
      action = 3;
    } else {
      // discard
      action = 0;
    }
  } else if (r == CLOUD_SERVER) {
    // *** DEAL WITH PACKETS TO SERVER (but not me as receipient) *** //
    // always discard ;-)
    action = 0;
  } else {
    // *** DEAL WITH PACKETS TO ANYONE (but not me as recipient) *** //
    // always discard ;-)
    action = 0;
  }
 
  // if cloud wanted us to forward it, tell it that we discarded it
  if ((action == 0) && (com->sender == CLOUD_SERVER) && (r == me)) {
    routing_error(com, 63);
  }
  printf("Routing decision completed: %s (%i) from %N to %N (via %N)\r\n", decisionname(action), (int)action, com->sender, com->target, com->recipient);
  free_command(com);
  return action;
}
 
const char *decisionname(int decision) {
  if (decision == 0) {
    return "discard";
  } else if (decision == 1) {
    return "forward";
  } else if (decision == 2) {
    return "bridge";
  } else if (decision == 3) {
    return "local";
  }
  return "?";
}
 
int routing_count_nodes() {
  int i;
  int res = 0;
 
  for (i = 0; i < HOSTROUTE_ENTRIES; i++) {
    if (knownhosts[i].host != 0) {
      res++;
    }
  }
  return res;
}
struct hostroute *routing_get_node_by_index(const int index) {
  int i;
  int res = 0;
 
  for (i = 0; i < HOSTROUTE_ENTRIES; i++) {
    if (knownhosts[i].host != 0) {
      if (res == index) {
        return &knownhosts[i];
      }
      res++;
    }
  }
  return NULL;
}
 
 
 
struct hostroute *routing_find_empty_slot() {
  int i;
 
  for (i = 0; i < HOSTROUTE_ENTRIES; i++) {
    if (knownhosts[i].host == 0) {
      return &knownhosts[i];
    }
  }
  return NULL;
}
 
static int is_older_than(long now, long actual, int maxage) {
  if (now >= actual) {
    return ((now - actual) > maxage) ? 1 : 0;
  }
  return 1;
}
 
void remove_stale_routes() {
  int i;
  long now = mculib_get_seconds_since_boot();
 
  for (i = 0; i < HOSTROUTE_ENTRIES; i++) {
    struct hostroute *host = &knownhosts[i];
    if (host->host == 0) {
      continue;
    }
    if (is_older_than(now, host->lastseen, MAX_ROUTE_AGE_SECONDS)) {
      peer_update(0, host);
      host->host = 0;
    }
  }
}
 
struct hostroute *routing_find_route(const long nodeid, const byte sourcedev) {
  int i;
 
  for (i = 0; i < HOSTROUTE_ENTRIES; i++) {
    if (knownhosts[i].device != sourcedev) {
      continue;
    }
    if (knownhosts[i].host == nodeid) {
      return &knownhosts[i];
    }
  }
 
  for (i = 0; i < HOSTROUTE_ENTRIES; i++) {
    if (knownhosts[i].device != sourcedev) {
      continue;
    }
    if (nodeid == CLOUD_SERVER) {
      if (knownhosts[i].hops_to_server > 0) {
        return &knownhosts[i];
      }
    }
  }
 
  return NULL;
}
struct hostroute *routing_find_host(const long nodeid) {
  int i;
  struct hostroute *res;
  struct hostroute *cur;
 
  res = NULL;
  for (i = 0; i < HOSTROUTE_ENTRIES; i++) {
    cur = &knownhosts[i];
#ifdef HACK_ROUTING
    // here's a hack to make debugging easier. this has no impact if device 0x0F4D0F84 isn't unavailable
    if ((cur->host == 0x0F4D0F84) && (is_device_online(cur->device))) {
      return cur;
    }
#endif
    if ((res != NULL) && (cur->lastseen < res->lastseen)) {
      continue;
    }
    if (cur->host == nodeid) {
      if (!is_device_online(cur->device)) {
        // this route isn't useful if the device it's on is offline
        continue;
      }
      res = cur;
    }
  }
 
  if ((res == NULL) && (nodeid == CLOUD_SERVER)) {
    for (i = 0; i < HOSTROUTE_ENTRIES; i++) {
      cur = &knownhosts[i];
      if ((res != NULL) && (cur->lastseen < res->lastseen)) {
        continue;
      }
      if (cur->hops_to_server > 0) {
        res = cur;
      }
    }
  }
 
  return res;
}
void routing_request_reply(const struct command *com) {
  int i;
  struct hostroute *host;
 
  for (i = 0; i < com->argctr; i++) {
    long nid = ascii_parse_hex((const byte *)get_arg((struct command *)com, i), 8, NULL);
    printf("Route request reply from %N for %N\r\n", com->sender, nid);
    host = routing_find_route(nid, com->sourcedev);
    if (host == NULL) {
      host = routing_find_empty_slot();
      if (host == NULL) {
        IPLOG("Routing table overflow!\r\n");
        return;
      }
      host->host = nid;
      host->nexthop = com->sender;
      host->device = com->sourcedev;
      host->lastseen = mculib_get_seconds_since_boot();
      IPLOG("New cat: %N on (%i)\r\n", (void *)host->host, host->device);
      r_on_new_node(host);
    }
  }
}
static void routing_update(const struct command *com, uint8_t signal_indicator) {
  struct hostroute *host;
 
  if ((com->com == 12) && (com->target == get_my_node_id())) {
    routing_request_reply(com);
  }
  host = routing_find_route(com->sender, com->sourcedev);
  if (host == NULL) {
    // no route and not an announce: ignore
    if (com->com != 23) {
      return;
    }
    host = routing_find_empty_slot();
    if (host == NULL) {
      IPLOG("Routing table overflow!\r\n");
      return;
    }
    host->host = com->sender;
    host->device = com->sourcedev;
    host->lastseen = mculib_get_seconds_since_boot();
    IPLOG("New cat: %N on (%i)\r\n", (void *)host->host, host->device);
    host->signal_indicator = signal_indicator;
    r_on_new_node(host);
  }
 
  host->signal_indicator = signal_indicator;
 
  if (com->sourcedev == SOURCE_WIFI) {
    host->nexthop = com->sender;         // no wifi multi-hop routing as of yet.
    host->device = com->sourcedev;
  } else if (com->sourcedev == SOURCE_SERIAL) {
    host->nexthop = com->sender;
    host->device = com->sourcedev;
  } else {
    if (com->sender != CLOUD_SERVER) {
      host->nexthop = com->sender;
    }
    host->device = com->sourcedev;
  }
  if (com->com == 23) {
    int b = atoi(get_arg(com, 0));
    host->hops_to_server = (byte)b;
    if (com->argctr > 1) {
      host->hosttype = atoi(get_arg(com, 1));
    }
    printf("Updated routing table entry host=%p\r\n", (void *)host->host);
  }
  host->lastseen = mculib_get_seconds_since_boot();
}
 
 
 
void routing_event_loop() {
  long now = mculib_get_seconds_since_boot();
 
  if (mculib_has_time_passed(ROUTING_EVENT_LOOP_INTERVAL, &last_run)) {
    print_node_id(config_get_ram_struct()->nodeid);
    remove_stale_routes();
  }
  int iv = ROUTING_ANNOUNCE_INTERVAL;
 
  if (esp8266_is_accespoint()) {
    iv = 2; // if accesspoint announce every 2 seconds
    //printf("Announce because we are accesspoint!\r\n");
  }
  if (mculib_has_time_passed(iv, &last_announce_sent)) {
    send_routing_update_now();
    last_announce_sent = now;
  }
}
 
void send_routing_update_now() {
  struct command *com;
 
  if (debug) {
    printf("routing: sending periodic announcements now\r\n");
  }
  if (esp8266_is_enabled()) {
    // wifi
    com = alloc_command();
    if (com == NULL) {
      return;
    }
    com->sourcedev = SOURCE_WIFI;
    com->com = 23;         // announce
    com->target = 0xFFFFFFFF;
    com->recipient = 0xFFFFFFFF;
    com->flags = COMFLAGS_ACK | COMFLAGS_SUCCESS;
    if (config_get_flag(CONFIG_FLAGS_POWER_SAVE)) {
      com->flags |= COMFLAGS_POWERSAVE;
      command_add_arg(com, "%i", 200); // tell others that we are quite far away from server. we're powersaving sometimes, so not a good router at all.
    } else {
      command_add_arg(com, "%i", (int)get_hops_to_server());
    }
    command_add_arg(com, "1");
    deliver_command(com, NULL);
  }
 
  // radio
  com = alloc_command();
  if (com == NULL) {
    return;
  }
  com->sourcedev = SOURCE_RADIO;
  com->com = 23;           // announce
  com->target = 0xFFFFFFFF;
  com->recipient = 0xFFFFFFFF;
  com->index = -1;
  com->flags = COMFLAGS_ACK | COMFLAGS_SUCCESS;
  if (config_get_flag(CONFIG_FLAGS_POWER_SAVE)) {
    command_add_arg(com, "%i", 200); // tell others that we are quite far away from server. we're powersaving sometimes, so not a good router at all.
  } else {
    command_add_arg(com, "%i", (int)get_hops_to_server());
  }
  command_add_arg(com, "1");
 
//TODO: replace with list of active network interfaces
  int xr = 0;
 
  if (isready_by_type(SOURCE_RADIO)) {
    com->sourcedev = SOURCE_RADIO;
    xr = send_command(com);
  }
  if (isready_by_type(SOURCE_LORA)) {
    com->sourcedev = SOURCE_LORA;
    xr = send_command(com);
  }
  if (xr != 0) {
    printf("Send_command failed: %i\r\n", xr);
  }
  free_command(com);
}
 
byte get_hops_to_server() {
  if (esp_cloud_is_connected()) {
    return 1;
  } else {
    //TODO implement indirect routes
    return 0;
  }
}
 
void routing_print_table() {
  int i;
  struct hostroute *host;
 
  long now = mculib_get_seconds_since_boot();
 
  printf("==== routing table ====\r\n");
  printf("Hops to cloud: %i\r\n", get_hops_to_server());
  for (i = 0; i < HOSTROUTE_ENTRIES; i++) {
    host = &knownhosts[i];
    if (host->host == 0) {
      continue;
    }
    printf("Host: %p, nexthop: %p, dev: %i, type: %i, server: %i, lastseen: %i secs, sigind: %i\r\n",
           (void *)host->host, (void *)host->nexthop,
           (int)host->device,
           (int)host->hosttype,
           (int)knownhosts[i].hops_to_server,
           (int)(now - host->lastseen),
           (int)host->signal_indicator
           );
  }
  printf("==== end routing table ====\r\n");
}
int send_command_one_arg(int command, long target, const byte *arg1, int arg1len) {
  struct command *com = alloc_command();
 
  if (com == NULL) {
    // in this case, if we have no spare commands, do nothing.
    // user will press button again. And it should not happen anyways
    return 1;
  }
  com->com = command;
  com->recipient = 0; // automatically determine dev & hop please
  com->target = target;
  com->flags = 0;
  // add some meta information about the button
  command_add_binary_arg(com, arg1len, arg1);
  // deliver it.
  // Callback is NULL, because it either gets delivered or not.
  // if not, there's little we can do about it anyways.
  deliver_command(com, NULL);
  return 0;
}
 
/*
 * \brief return a routing error message to sender, including the reason why we could not forward the packet
 */
void routing_error(struct command *f_com, int errorcode) {
  char tbuf[20];
  struct command *com = alloc_command();
 
  if (com == NULL) {
    return;
  }
  com->com = 51;                        // routing update (route-update)
  com->target = f_com->sender;
  snprintf(tbuf, sizeof(tbuf), "t=1");  // routing failure
  command_add_arg(com, tbuf);
  snprintf(tbuf, sizeof(tbuf), "fw=%i", errorcode);
  command_add_arg(com, tbuf);
  snprintf(tbuf, sizeof(tbuf), "rcpt=0x%N", f_com->recipient);
  command_add_arg(com, tbuf);
  snprintf(tbuf, sizeof(tbuf), "tgt=0x%N", f_com->target);
  command_add_arg(com, tbuf);
  snprintf(tbuf, sizeof(tbuf), "seq=%i", f_com->index);
  command_add_arg(com, tbuf);
  send_command(com); // try to deliver once. don't retry
  free_command(com);
}
 
/*
 * \brief tell server that we have a new peer or one was removed
 */
static void peer_update(int added, struct hostroute *host) {
  char tbuf[20];
  struct command *com = alloc_command();
 
  if (com == NULL) {
    return;
  }
  com->com = 51; // routing update (route-update)
  com->target = 1;
  if (added) {
    snprintf(tbuf, sizeof(tbuf), "t=2");        // peer added
  } else {
    snprintf(tbuf, sizeof(tbuf), "t=3");        // peer removed
  }
  command_add_arg(com, tbuf);
  snprintf(tbuf, sizeof(tbuf), "peer=0x%N", host->host);
  command_add_arg(com, tbuf);
  snprintf(tbuf, sizeof(tbuf), "device=%i", host->device);
  command_add_arg(com, tbuf);
  snprintf(tbuf, sizeof(tbuf), "sigind=%i", host->signal_indicator);
  command_add_arg(com, tbuf);
  send_command(com); // try to deliver once. don't retry
  free_command(com);
}
 
void r_on_new_node(struct hostroute *host) {
  if (user_app_executable()) {
    invoke_on_new_node(host);
  }
  peer_update(1, host);
}