stp_cli.c

快速生成树协议的源代码

  set_bridge_cfg_value (br_prio, BR_CFG_PRIO);

  return 0;
}

static int cli_br_maxage (int argc, char** argv)
{
  long      value = 20L;

  value = strtoul(argv[1], 0, 10);
  set_bridge_cfg_value (value, BR_CFG_AGE);
  return 0;
}

static int cli_br_fdelay (int argc, char** argv)
{
  long      value = 15L;

  value = strtoul(argv[1], 0, 10);
  set_bridge_cfg_value (value, BR_CFG_DELAY);
  return 0;
}

static int cli_br_fvers (int argc, char** argv)
{
  long      value = 2L;

  switch (argv[1][0]) {
      case '0':
      case '1':
      case 'f':
      case 'F':
        value = 0L;
        printf ("Accepted 'force_slow'\n");
        break;
      case '2':
      case 'r':
      case 'R':
        printf ("Accepted 'rapid'\n");
        value = 2L;
        break;
      default:
        printf ("Invalid argument '%s'\n", argv[1]);
        return 0;
  }
  
  set_bridge_cfg_value (value, BR_CFG_FORCE_VER);
  return 0;
}

static void
set_rstp_port_cfg_value (int port_index,
                         unsigned long value,
                         unsigned long val_mask)
{
  UID_STP_PORT_CFG_T uid_cfg;
  int           rc, detail;
  char          *val_name;

  if (port_index > 0) {
    BitmapClear(&uid_cfg.port_bmp);
    BitmapSetBit(&uid_cfg.port_bmp, port_index - 1);
    detail = 1;
  } else {
    BitmapSetAllBits(&uid_cfg.port_bmp);
    detail = 0;
  }

  uid_cfg.field_mask = val_mask;
  switch (val_mask) {
    case PT_CFG_MCHECK:
      val_name = "mcheck";
      break;
    case PT_CFG_COST:
      uid_cfg.admin_port_path_cost = value;
      val_name = "path cost";
      break;
    case PT_CFG_PRIO:
      uid_cfg.port_priority = value;
      val_name = "priority";
      break;
    case PT_CFG_P2P:
      uid_cfg.admin_point2point = (ADMIN_P2P_T) value;
      val_name = "p2p flag";
      break;
    case PT_CFG_EDGE:
      uid_cfg.admin_edge = value;
      val_name = "adminEdge";
      break;
    case PT_CFG_NON_STP:
      uid_cfg.admin_non_stp = value;
      val_name = "adminNonStp";
      break;
#ifdef STP_DBG
    case PT_CFG_DBG_SKIP_TX:
      uid_cfg.skip_tx = value;
      val_name = "skip tx";
      break;
    case PT_CFG_DBG_SKIP_RX:
      uid_cfg.skip_rx = value;
      val_name = "skip rx";
      break;
#endif
    case PT_CFG_STATE:
    default:
      printf ("Invalid value mask 0X%lx\n", val_mask);
      return;
  }

  rc = STP_IN_set_port_cfg (0, &uid_cfg);
  if (0 != rc) {
    printf ("can't change rstp port[s] %s: %s\n",
           val_name, STP_IN_get_error_explanation (rc));
  } else {
    printf ("changed rstp port[s] %s\n", val_name);
  }

  /* show_rstp_port (&uid_cfg.port_bmp, 0); */
}

static int cli_prt_prio (int argc, char** argv)
{
  int port_index = 0;
  unsigned long value = 128;

  if ('a' != argv[1][0])
    port_index = strtoul(argv[1], 0, 10);

  value = strtoul(argv[2], 0, 10);
  set_rstp_port_cfg_value (port_index, value, PT_CFG_PRIO);
  return 0;
}

static int cli_prt_pcost (int argc, char** argv)
{
  int port_index = 0;
  unsigned long value = 0;

  if ('a' != argv[1][0])
    port_index = strtoul(argv[1], 0, 10);

  value = strtoul(argv[2], 0, 10);
  set_rstp_port_cfg_value (port_index, value, PT_CFG_COST);
  return 0;
}

static int cli_prt_mcheck (int argc, char** argv)
{
  int port_index = 0;

  if ('a' != argv[1][0])
    port_index = strtoul(argv[1], 0, 10);
  set_rstp_port_cfg_value (port_index, 0, PT_CFG_MCHECK);
  return 0;
}

static int get_bool_arg (int narg, int argc, char** argv,
                         unsigned long* value)
{
  switch (argv[narg][0]) {
    case 'y':
    case 'Y':
      *value = 1;
      break;
    case 'n':
    case 'N':
      *value = 0;
      break;
    default:
      printf ("Invalid Bollean parameter '%s'\n", argv[narg]);
      return -1;
  }
  return 0;
}

static int cli_prt_edge (int argc, char** argv)
{
  int port_index = 0;
  unsigned long value = 1;

  if ('a' != argv[1][0])
    port_index = strtoul(argv[1], 0, 10);

  if (0 != get_bool_arg (2, argc, argv, &value))
    return 0;

  set_rstp_port_cfg_value (port_index, value, PT_CFG_EDGE);
  return 0;
}

static int cli_prt_non_stp (int argc, char** argv)
{
  int port_index = 0;
  unsigned long value = 0;

  if ('a' != argv[1][0])
    port_index = strtoul(argv[1], 0, 10);

  if (0 != get_bool_arg (2, argc, argv, &value))
    return 0;

  set_rstp_port_cfg_value (port_index, value, PT_CFG_NON_STP);
  return 0;
}

static int cli_prt_p2p (int argc, char** argv)
{
  int port_index = 0;
  unsigned long value = P2P_FORCE_TRUE;

  if ('a' != argv[1][0])
    port_index = strtoul(argv[1], 0, 10);

  switch (argv[2][0]) {
      case 'y':
      case 'Y':
        value = P2P_FORCE_TRUE;
        break;
      case 'n':
      case 'N':
        value = P2P_FORCE_FALSE;
        break;
      case 'a':
      case 'A':
        value = P2P_AUTO;
        break;
      default:
        printf ("Invalid parameter '%s'\n", argv[2]);
        return 0;
  }

  set_rstp_port_cfg_value (port_index, (ADMIN_P2P_T) value, PT_CFG_P2P);
  return 0;
}

#ifdef STP_DBG
static int cli_trace (int argc, char** argv)
{
  BITMAP_T ports_bitmap;
  int port_index;

  if ('a' == argv[1][0]) {
    BitmapSetAllBits(&ports_bitmap);
  } else {
    port_index = strtoul(argv[1], 0, 10);
    BitmapClear(&ports_bitmap);
    BitmapSetBit(&ports_bitmap, port_index - 1);
  }

  STP_IN_dbg_set_port_trace (argv[2],
                             argv[3][0] != 'n' && argv[3][0] != 'N',
                             0, &ports_bitmap,
                             1);
  return 0;
}

/****
  PARAM_NUMBER("port number", 1, NUMBER_OF_PORTS, "all")
  PARAM_ENUM("receive or/and transmit")
    PARAM_ENUM_SEL("rx", "receive")
    PARAM_ENUM_SEL("tx", "transmit")
    PARAM_ENUM_DEFAULT("all")
  PARAM_NUMBER("number of BPDU to skip", 0, 10000, "1")
****/
static int cli_skip (int argc, char** argv)
{
  int port_index = 0, to_skip;

  if ('a' != argv[1][0])
    port_index = strtoul(argv[1], 0, 10);

  to_skip = atoi (argv[3]);

  if ('a' == argv[2][0] || 'r' == argv[2][0]) {
    set_rstp_port_cfg_value (port_index, to_skip, PT_CFG_DBG_SKIP_RX);
  }

  if ('a' == argv[2][0] || 't' == argv[2][0]) {
    set_rstp_port_cfg_value (port_index, to_skip, PT_CFG_DBG_SKIP_TX);
  }
  return 0;
}

static int cli_sleep (int argc, char** argv)
{
  int delay = atoi (argv[1]);
  sleep (delay);
  return 0;
}

#endif

static CMD_DSCR_T lang[] = {
  THE_COMMAND("enable", "enable rstp")
  THE_FUNC(cli_enable)

  THE_COMMAND("disable", "disable rstp")
  THE_FUNC(cli_disable)

  THE_COMMAND("show bridge", "get bridge config")
  THE_FUNC(cli_br_get_cfg)

  THE_COMMAND("show port", "get port config")
  PARAM_NUMBER("port number on bridge", 1, NUMBER_OF_PORTS, "all")
  THE_FUNC(cli_pr_get_cfg)

  THE_COMMAND("bridge priority", "set bridge priority")
  PARAM_NUMBER("priority", MIN_BR_PRIO, MAX_BR_PRIO, "0x8000")
  THE_FUNC(cli_br_prio)

  THE_COMMAND("bridge maxage", "set bridge maxAge")
  PARAM_NUMBER("maxAge", MIN_BR_MAXAGE, MAX_BR_MAXAGE, "20")
  THE_FUNC(cli_br_maxage)

  THE_COMMAND("bridge fdelay", "set bridge forwardDelay")
  PARAM_NUMBER("forwardDelay", MIN_BR_FWDELAY, MAX_BR_FWDELAY, "15")
  THE_FUNC(cli_br_fdelay)

  THE_COMMAND("bridge forseVersion", "set bridge forseVersion")
  PARAM_BOOL("forseVersion", "forse slow", "regular", "no")
  THE_FUNC(cli_br_fvers)

  THE_COMMAND("port priority", "set port priority")
  PARAM_NUMBER("port number", 1, NUMBER_OF_PORTS, "all")
  PARAM_NUMBER("priority", MIN_PORT_PRIO, MAX_PORT_PRIO, "128")
  THE_FUNC(cli_prt_prio)

  THE_COMMAND("port pcost", "set port path cost")
  PARAM_NUMBER("port number", 1, NUMBER_OF_PORTS, "all")
  PARAM_NUMBER("path cost (0- for auto)", 0, 200000000, 0)
  THE_FUNC(cli_prt_pcost)

  THE_COMMAND("port mcheck", "set port mcheck")
  PARAM_NUMBER("port number", 1, NUMBER_OF_PORTS, "all")
  THE_FUNC(cli_prt_mcheck)

  THE_COMMAND("port edge", "set port adminEdge")
  PARAM_NUMBER("port number", 1, NUMBER_OF_PORTS, "all")
  PARAM_BOOL("adminEdge", "Edge", "noEdge", "Y")
  THE_FUNC(cli_prt_edge)

  THE_COMMAND("port nonStp", "set port adminNonStp")
  PARAM_NUMBER("port number", 1, NUMBER_OF_PORTS, "all")
  PARAM_BOOL("adminEdge", "Doesn't participate", "Paricipates", "n")
  THE_FUNC(cli_prt_non_stp)

  THE_COMMAND("port p2p", "set port adminPoit2Point")
  PARAM_NUMBER("port number", 1, NUMBER_OF_PORTS, "all")
  PARAM_ENUM("adminPoit2Point")
    PARAM_ENUM_SEL("y", "forcePointToPoint")
    PARAM_ENUM_SEL("n", "forcePointToMultiPoint")
    PARAM_ENUM_SEL("a", "autoPointToPoint")
    PARAM_ENUM_DEFAULT("a")
  THE_FUNC(cli_prt_p2p)

#ifdef STP_DBG
  THE_COMMAND("trace", "set port trace")
  PARAM_NUMBER("port number", 1, NUMBER_OF_PORTS, "all")
  PARAM_ENUM("state machine name")
    PARAM_ENUM_SEL("info", "info")
    PARAM_ENUM_SEL("roletrns", "roletrns")
    PARAM_ENUM_SEL("sttrans", "sttrans")
    PARAM_ENUM_SEL("topoch", "topoch")
    PARAM_ENUM_SEL("migrate", "migrate")
    PARAM_ENUM_SEL("transmit", "transmit")
    PARAM_ENUM_SEL("p2p", "p2p")
    PARAM_ENUM_SEL("edge", "edge")
    PARAM_ENUM_SEL("pcost", "pcost")
    PARAM_ENUM_DEFAULT("all")
  PARAM_BOOL("enable/disable", "trace it", "don't trace it", "n")
  THE_FUNC(cli_trace)

  THE_COMMAND("skip", "skip BPDU processing")
  PARAM_NUMBER("port number", 1, NUMBER_OF_PORTS, "all")
  PARAM_ENUM("receive or/and transmit")
    PARAM_ENUM_SEL("rx", "receive")
    PARAM_ENUM_SEL("tx", "transmit")
    PARAM_ENUM_DEFAULT("all")
  PARAM_NUMBER("number of BPDU to skip", 0, 10000, "1")
  THE_FUNC(cli_skip)

  THE_COMMAND("sleep", "sleep")
  PARAM_NUMBER("delay in sec.", 1, 4000, "4")
  THE_FUNC(cli_sleep)
#endif
  
  END_OF_LANG
};

int stp_cli_init (void)
{
   I_am_a_stupid_hub = 0;
   cli_register_language (lang);
   return 0;
}