]> git.sommitrealweird.co.uk Git - quagga-debian.git/blob - tests/test-commands.c
18b3b50d79f280c2893e7e68d2d8249bd353d4ea
[quagga-debian.git] / tests / test-commands.c
1 /*
2  * Test code for lib/command.c
3  *
4  * Copyright (C) 2013 by Open Source Routing.
5  * Copyright (C) 2013 by Internet Systems Consortium, Inc. ("ISC")
6  *
7  * This program reads in a list of commandlines from stdin
8  * and calls all the public functions of lib/command.c for
9  * both the given command lines and fuzzed versions thereof.
10  *
11  * The output is currently not validated but only logged. It can
12  * be diffed to find regressions between versions.
13  *
14  * Quagga is free software; you can redistribute it and/or modify it
15  * under the terms of the GNU General Public License as published by the
16  * Free Software Foundation; either version 2, or (at your option) any
17  * later version.
18  *
19  * Quagga is distributed in the hope that it will be useful, but
20  * WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
22  * General Public License for more details.
23  *
24  * You should have received a copy of the GNU General Public License
25  * along with Quagga; see the file COPYING.  If not, write to the Free
26  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
27  * 02111-1307, USA.
28  */
29
30 #define REALLY_NEED_PLAIN_GETOPT 1
31
32 #include <zebra.h>
33
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <unistd.h>
37
38 #include "command.h"
39 #include "memory.h"
40 #include "vector.h"
41 #include "prng.h"
42
43 extern vector cmdvec;
44 extern struct cmd_node vty_node;
45 extern void test_init_cmd(void); /* provided in test-commands-defun.c */
46
47 struct thread_master *master; /* dummy for libzebra*/
48
49 static vector test_cmds;
50 static char test_buf[32768];
51
52 static struct cmd_node bgp_node =
53 {
54   BGP_NODE,
55   "%s(config-router)# ",
56 };
57
58 static struct cmd_node rip_node =
59 {
60   RIP_NODE,
61   "%s(config-router)# ",
62 };
63
64 static struct cmd_node isis_node =
65 {
66   ISIS_NODE,
67   "%s(config-router)# ",
68 };
69
70 static struct cmd_node interface_node =
71 {
72   INTERFACE_NODE,
73   "%s(config-if)# ",
74 };
75
76 static struct cmd_node rmap_node =
77 {
78   RMAP_NODE,
79   "%s(config-route-map)# "
80 };
81
82 static struct cmd_node zebra_node =
83 {
84   ZEBRA_NODE,
85   "%s(config-router)# "
86 };
87
88 static struct cmd_node bgp_vpnv4_node =
89 {
90   BGP_VPNV4_NODE,
91   "%s(config-router-af)# "
92 };
93
94 static struct cmd_node bgp_ipv4_node =
95 {
96   BGP_IPV4_NODE,
97   "%s(config-router-af)# "
98 };
99
100 static struct cmd_node bgp_ipv4m_node =
101 {
102   BGP_IPV4M_NODE,
103   "%s(config-router-af)# "
104 };
105
106 static struct cmd_node bgp_ipv6_node =
107 {
108   BGP_IPV6_NODE,
109   "%s(config-router-af)# "
110 };
111
112 static struct cmd_node bgp_ipv6m_node =
113 {
114   BGP_IPV6M_NODE,
115   "%s(config-router-af)# "
116 };
117
118 static struct cmd_node ospf_node =
119 {
120   OSPF_NODE,
121   "%s(config-router)# "
122 };
123
124 static struct cmd_node ripng_node =
125 {
126   RIPNG_NODE,
127   "%s(config-router)# "
128 };
129
130 static struct cmd_node ospf6_node =
131 {
132   OSPF6_NODE,
133   "%s(config-ospf6)# "
134 };
135
136 static struct cmd_node babel_node =
137 {
138   BABEL_NODE,
139   "%s(config-babel)# "
140 };
141
142 static struct cmd_node keychain_node =
143 {
144   KEYCHAIN_NODE,
145   "%s(config-keychain)# "
146 };
147
148 static struct cmd_node keychain_key_node =
149 {
150   KEYCHAIN_KEY_NODE,
151   "%s(config-keychain-key)# "
152 };
153
154 static int
155 test_callback(struct cmd_element *cmd, struct vty *vty, int argc, const char *argv[])
156 {
157   int offset;
158   int rv;
159   int i;
160
161   offset = 0;
162   rv = snprintf(test_buf, sizeof(test_buf), "'%s'", cmd->string);
163   if (rv < 0)
164     abort();
165
166   offset += rv;
167
168   for (i = 0; i < argc; i++)
169     {
170       rv = snprintf(test_buf + offset, sizeof(test_buf) - offset, "%s'%s'",
171                     (i == 0) ? ": " : ", ", argv[i]);
172       if (rv < 0)
173         abort();
174       offset += rv;
175     }
176
177   return CMD_SUCCESS;
178 }
179
180 static void
181 test_load(void)
182 {
183   char line[4096];
184
185   test_cmds = vector_init(VECTOR_MIN_SIZE);
186
187   while (fgets(line, sizeof(line), stdin) != NULL)
188     {
189       if (strlen(line))
190         line[strlen(line) - 1] = '\0';
191       if (line[0] == '#')
192         continue;
193       vector_set(test_cmds, XSTRDUP(MTYPE_STRVEC, line));
194     }
195 }
196
197 static void
198 test_init(void)
199 {
200   unsigned int node;
201   unsigned int i;
202   struct cmd_node *cnode;
203   struct cmd_element *cmd;
204
205   cmd_init(1);
206
207   install_node (&bgp_node, NULL);
208   install_node (&rip_node, NULL);
209   install_node (&interface_node, NULL);
210   install_node (&rmap_node, NULL);
211   install_node (&zebra_node, NULL);
212   install_node (&bgp_vpnv4_node, NULL);
213   install_node (&bgp_ipv4_node, NULL);
214   install_node (&bgp_ipv4m_node, NULL);
215   install_node (&bgp_ipv6_node, NULL);
216   install_node (&bgp_ipv6m_node, NULL);
217   install_node (&ospf_node, NULL);
218   install_node (&ripng_node, NULL);
219   install_node (&ospf6_node, NULL);
220   install_node (&babel_node, NULL);
221   install_node (&keychain_node, NULL);
222   install_node (&keychain_key_node, NULL);
223   install_node (&isis_node, NULL);
224   install_node (&vty_node, NULL);
225
226   test_init_cmd();
227
228   for (node = 0; node < vector_active(cmdvec); node++)
229     if ((cnode = vector_slot(cmdvec, node)) != NULL)
230       for (i = 0; i < vector_active(cnode->cmd_vector); i++)
231         if ((cmd = vector_slot(cnode->cmd_vector, i)) != NULL)
232           {
233             cmd->daemon = 0;
234             cmd->func = test_callback;
235           }
236   test_load();
237   vty_init_vtysh();
238 }
239
240 static void
241 test_terminate(void)
242 {
243   unsigned int i;
244
245   vty_terminate();
246   for (i = 0; i < vector_active(test_cmds); i++)
247     XFREE(MTYPE_STRVEC, vector_slot(test_cmds, i));
248   vector_free(test_cmds);
249   cmd_terminate();
250 }
251
252 static void
253 test_run(struct prng *prng, struct vty *vty, const char *cmd, unsigned int edit_dist, unsigned int node_index, int verbose)
254 {
255   const char *test_str;
256   vector vline;
257   int ret;
258   unsigned int i;
259   char **completions;
260   unsigned int j;
261   struct cmd_node *cnode;
262   vector descriptions;
263   int appended_null;
264   int no_match;
265
266   test_str = prng_fuzz(prng, cmd, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_:. /", edit_dist);
267   vline = cmd_make_strvec(test_str);
268
269   if (vline == NULL)
270     return;
271
272   appended_null = 0;
273   for (i = 0; i < vector_active(cmdvec); i++)
274     if ((cnode = vector_slot(cmdvec, i)) != NULL)
275       {
276         if (node_index != (unsigned int)-1 && i != node_index)
277           continue;
278
279         if (appended_null)
280           {
281             vector_unset(vline, vector_active(vline) - 1);
282             appended_null = 0;
283           }
284         vty->node = cnode->node;
285         test_buf[0] = '\0';
286         ret = cmd_execute_command(vline, vty, NULL, 0);
287         no_match = (ret == CMD_ERR_NO_MATCH);
288         if (verbose || !no_match)
289           printf("execute relaxed '%s'@%d: rv==%d%s%s\n",
290                  test_str,
291                  cnode->node,
292                  ret,
293                  (test_buf[0] != '\0') ? ", " : "",
294                  test_buf);
295
296         vty->node = cnode->node;
297         test_buf[0] = '\0';
298         ret = cmd_execute_command_strict(vline, vty, NULL);
299         if (verbose || !no_match)
300           printf("execute strict '%s'@%d: rv==%d%s%s\n",
301                  test_str,
302                  cnode->node,
303                  ret,
304                  (test_buf[0] != '\0') ? ", " : "",
305                  test_buf);
306
307         if (isspace((int) test_str[strlen(test_str) - 1]))
308           {
309             vector_set (vline, NULL);
310             appended_null = 1;
311           }
312
313         vty->node = cnode->node;
314         completions = cmd_complete_command(vline, vty, &ret);
315         if (verbose || !no_match)
316           printf("complete '%s'@%d: rv==%d\n",
317                  test_str,
318                  cnode->node,
319                  ret);
320         if (completions != NULL)
321           {
322             for (j = 0; completions[j] != NULL; j++)
323               {
324                 printf("  '%s'\n", completions[j]);
325                 XFREE(MTYPE_TMP, completions[j]);
326               }
327             XFREE(MTYPE_VECTOR_INDEX, completions);
328           }
329
330         vty->node = cnode->node;
331         descriptions = cmd_describe_command(vline, vty, &ret);
332         if (verbose || !no_match)
333           printf("describe '%s'@%d: rv==%d\n",
334                  test_str,
335                  cnode->node,
336                  ret);
337         if (descriptions != NULL)
338           {
339             for (j = 0; j < vector_active(descriptions); j++)
340               {
341                 struct cmd_token *cmd = vector_slot(descriptions, j);
342                 printf("  '%s' '%s'\n", cmd->cmd, cmd->desc);
343               }
344             vector_free(descriptions);
345           }
346       }
347   cmd_free_strvec(vline);
348 }
349
350 int
351 main(int argc, char **argv)
352 {
353   int opt;
354   struct prng *prng;
355   struct vty *vty;
356   unsigned int edit_distance;
357   unsigned int max_edit_distance;
358   unsigned int node_index;
359   int verbose;
360   unsigned int test_cmd;
361   unsigned int iteration;
362   unsigned int num_iterations;
363
364   max_edit_distance = 3;
365   node_index = -1;
366   verbose = 0;
367
368   while ((opt = getopt(argc, argv, "e:n:v")) != -1)
369     {
370       switch (opt)
371         {
372         case 'e':
373           max_edit_distance = atoi(optarg);
374           break;
375         case 'n':
376           node_index = atoi(optarg);
377           break;
378         case 'v':
379           verbose++;
380           break;
381         default:
382           fprintf(stderr, "Usage: %s [-e <edit_dist>] [-n <node_idx>] [-v]\n", argv[0]);
383           exit(1);
384           break;
385         }
386     }
387
388   test_init();
389   prng = prng_new(0);
390
391   vty = vty_new();
392   vty->type = VTY_TERM;
393
394   fprintf(stderr, "Progress:\n0/%u", vector_active(test_cmds));
395   for (test_cmd = 0; test_cmd < vector_active(test_cmds); test_cmd++)
396     {
397       for (edit_distance = 0;
398            edit_distance <= max_edit_distance;
399            edit_distance++)
400         {
401           num_iterations = 1 << edit_distance;
402           num_iterations *= num_iterations * num_iterations;
403
404           for (iteration = 0; iteration < num_iterations; iteration++)
405             test_run(prng, vty, vector_slot(test_cmds, test_cmd), edit_distance, node_index, verbose);
406         }
407       fprintf(stderr, "\r%u/%u", test_cmd + 1, vector_active(test_cmds));
408     }
409   fprintf(stderr, "\nDone.\n");
410
411   vty_close(vty);
412   prng_free(prng);
413   test_terminate();
414   return 0;
415 }