vlib: fix vector-as-C-string overflow

[vpp.git] / src / vlib / cli.c

diff --git a/src/vlib/cli.c b/src/vlib/cli.c
index ec27c48..467d1f7 100644 (file)
--- a/src/vlib/cli.c
+++ b/src/vlib/cli.c
@@ -210,29 +210,6 @@ unformat_vlib_cli_sub_command (unformat_input_t * i, va_list * args)
   vlib_cli_main_t *cm = &vm->cli_main;
   uword *match_bitmap, is_unique, index;
 
-  {
-    vlib_cli_sub_rule_t *sr;
-    vlib_cli_parse_rule_t *r;
-    vec_foreach (sr, c->sub_rules)
-    {
-      void **d;
-      r = vec_elt_at_index (cm->parse_rules, sr->rule_index);
-      vec_add2 (cm->parse_rule_data, d, 1);
-      vec_reset_length (d[0]);
-      if (r->data_size)
-       d[0] = _vec_resize (d[0],
-                           /* length increment */ 1,
-                           r->data_size,
-                           /* header_bytes */ 0,
-                           /* data align */ sizeof (uword));
-      if (unformat_user (i, r->unformat_function, vm, d[0]))
-       {
-         *result = vec_elt_at_index (cm->commands, sr->command_index);
-         return 1;
-       }
-    }
-  }
-
   match_bitmap = vlib_cli_sub_command_match (c, i);
   is_unique = clib_bitmap_count_set_bits (match_bitmap) == 1;
   index = ~0;
@@ -362,50 +339,12 @@ format_vlib_cli_command_help (u8 * s, va_list * args)
   return s;
 }
 
-static u8 *
-format_vlib_cli_parse_rule_name (u8 * s, va_list * args)
-{
-  vlib_cli_parse_rule_t *r = va_arg (*args, vlib_cli_parse_rule_t *);
-  return format (s, "<%U>", format_c_identifier, r->name);
-}
-
 static u8 *
 format_vlib_cli_path (u8 * s, va_list * args)
 {
   u8 *path = va_arg (*args, u8 *);
-  int i, in_rule;
-  in_rule = 0;
-  for (i = 0; i < vec_len (path); i++)
-    {
-      switch (path[i])
-       {
-       case '%':
-         in_rule = 1;
-         vec_add1 (s, '<');    /* start of <RULE> */
-         break;
 
-       case '_':
-         /* _ -> space in rules. */
-         vec_add1 (s, in_rule ? ' ' : '_');
-         break;
-
-       case ' ':
-         if (in_rule)
-           {
-             vec_add1 (s, '>');        /* end of <RULE> */
-             in_rule = 0;
-           }
-         vec_add1 (s, ' ');
-         break;
-
-       default:
-         vec_add1 (s, path[i]);
-         break;
-       }
-    }
-
-  if (in_rule)
-    vec_add1 (s, '>');         /* terminate <RULE> */
+  s = format (s, "%v", path);
 
   return s;
 }
@@ -415,13 +354,10 @@ all_subs (vlib_cli_main_t * cm, vlib_cli_command_t * subs, u32 command_index)
 {
   vlib_cli_command_t *c = vec_elt_at_index (cm->commands, command_index);
   vlib_cli_sub_command_t *sc;
-  vlib_cli_sub_rule_t *sr;
 
   if (c->function)
     vec_add1 (subs, c[0]);
 
-  vec_foreach (sr, c->sub_rules)
-    subs = all_subs (cm, subs, sr->command_index);
   vec_foreach (sc, c->sub_commands) subs = all_subs (cm, subs, sc->index);
 
   return subs;
@@ -484,17 +420,14 @@ vlib_cli_dispatch_sub_commands (vlib_main_t * vm,
        vlib_cli_output (vm, "%U", format_vlib_cli_command_help, c,
                         /* is_long */ 1);
 
-      else if (vec_len (c->sub_commands) + vec_len (c->sub_rules) == 0)
+      else if (vec_len (c->sub_commands) == 0)
        vlib_cli_output (vm, "%v: no sub-commands", c->path);
 
       else
        {
+         vlib_cli_sub_rule_t *sr, *subs = 0;
          vlib_cli_sub_command_t *sc;
-         vlib_cli_sub_rule_t *sr, *subs;
-
-         subs = vec_dup (c->sub_rules);
 
-         /* Add in rules if any. */
          vec_foreach (sc, c->sub_commands)
          {
            vec_add2 (subs, sr, 1);
@@ -508,25 +441,11 @@ vlib_cli_dispatch_sub_commands (vlib_main_t * vm,
          for (i = 0; i < vec_len (subs); i++)
            {
              vlib_cli_command_t *d;
-             vlib_cli_parse_rule_t *r;
 
              d = vec_elt_at_index (cm->commands, subs[i].command_index);
-             r =
-               subs[i].rule_index != ~0 ? vec_elt_at_index (cm->parse_rules,
-                                                            subs
-                                                            [i].rule_index) :
-               0;
-
-             if (r)
-               vlib_cli_output
-                 (vm, "  %-30U %U",
-                  format_vlib_cli_parse_rule_name, r,
-                  format_vlib_cli_command_help, d, /* is_long */ 0);
-             else
-               vlib_cli_output
-                 (vm, "  %-30v %U",
-                  subs[i].name,
-                  format_vlib_cli_command_help, d, /* is_long */ 0);
+             vlib_cli_output
+               (vm, "  %-30v %U", subs[i].name,
+                format_vlib_cli_command_help, d, /* is_long */ 0);
            }
 
          vec_free (subs);
@@ -639,7 +558,7 @@ vlib_cli_dispatch_sub_commands (vlib_main_t * vm,
                    u32 c;
                  } *ed;
                  ed = ELOG_DATA (&vm->elog_main, e);
-                 ed->c = elog_string (&vm->elog_main, c->path);
+                 ed->c = elog_string (&vm->elog_main, "%v", c->path);
                }
 
              if (!c->is_mp_safe)
@@ -665,12 +584,12 @@ vlib_cli_dispatch_sub_commands (vlib_main_t * vm,
                    u32 c, err;
                  } *ed;
                  ed = ELOG_DATA (&vm->elog_main, e);
-                 ed->c = elog_string (&vm->elog_main, c->path);
+                 ed->c = elog_string (&vm->elog_main, "%v", c->path);
                  if (c_error)
                    {
                      vec_add1 (c_error->what, 0);
-                     ed->err = elog_string (&vm->elog_main,
-                                            (char *) c_error->what);
+                     ed->err =
+                       elog_string (&vm->elog_main, (char *) c_error->what);
                      _vec_len (c_error->what) -= 1;
                    }
                  else
@@ -732,7 +651,6 @@ vlib_cli_input (vlib_main_t * vm,
                vlib_cli_output_function_t * function, uword function_arg)
 {
   vlib_process_t *cp = vlib_get_current_process (vm);
-  vlib_cli_main_t *cm = &vm->cli_main;
   clib_error_t *error;
   vlib_cli_output_function_t *save_function;
   uword save_function_arg;
@@ -746,9 +664,8 @@ vlib_cli_input (vlib_main_t * vm,
 
   do
     {
-      vec_reset_length (cm->parse_rule_data);
-      error = vlib_cli_dispatch_sub_commands (vm, &vm->cli_main, input,        /* parent */
-                                             0);
+      error = vlib_cli_dispatch_sub_commands (vm, &vm->cli_main, input,
+                                             /* parent */ 0);
     }
   while (!error && !unformat (input, "%U", unformat_eof));
 
@@ -1296,14 +1213,6 @@ add_sub_command (vlib_cli_main_t * cm, uword parent_index, uword child_index)
          return;
        }
 
-      q = hash_get_mem (cm->parse_rule_index_by_name, sub_name);
-      if (!q)
-       {
-         clib_error ("reference to unknown rule `%%%v' in path `%v'",
-                     sub_name, c->path);
-         return;
-       }
-
       hash_set_mem (p->sub_rule_index_by_name, sub_name,
                    vec_len (p->sub_rules));
       vec_add2 (p->sub_rules, sr, 1);
@@ -1492,6 +1401,8 @@ vlib_cli_register (vlib_main_t * vm, vlib_cli_command_t * c)
   return 0;
 }
 
+#if 0
+/* $$$ turn back on again someday, maybe */
 clib_error_t *
 vlib_cli_register_parse_rule (vlib_main_t * vm, vlib_cli_parse_rule_t * r_reg)
 {
@@ -1524,8 +1435,6 @@ vlib_cli_register_parse_rule (vlib_main_t * vm, vlib_cli_parse_rule_t * r_reg)
   return error;
 }
 
-#if 0
-/* $$$ turn back on again someday, maybe */
 static clib_error_t *vlib_cli_register_parse_rules (vlib_main_t * vm,
                                                    vlib_cli_parse_rule_t *
                                                    lo,