Annotation of embedaddon/quagga/lib/command.c, revision 1.1.1.1
1.1 misho 1: /*
2: Command interpreter routine for virtual terminal [aka TeletYpe]
3: Copyright (C) 1997, 98, 99 Kunihiro Ishiguro
4:
5: This file is part of GNU Zebra.
6:
7: GNU Zebra is free software; you can redistribute it and/or modify
8: it under the terms of the GNU General Public License as published
9: by the Free Software Foundation; either version 2, or (at your
10: option) any later version.
11:
12: GNU Zebra is distributed in the hope that it will be useful, but
13: WITHOUT ANY WARRANTY; without even the implied warranty of
14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15: General Public License for more details.
16:
17: You should have received a copy of the GNU General Public License
18: along with GNU Zebra; see the file COPYING. If not, write to the
19: Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20: Boston, MA 02111-1307, USA. */
21:
22: #include <zebra.h>
23:
24:
25: #include "memory.h"
26: #include "log.h"
27: #include <lib/version.h>
28: #include "thread.h"
29: #include "vector.h"
30: #include "vty.h"
31: #include "command.h"
32: #include "workqueue.h"
33:
34: /* Command vector which includes some level of command lists. Normally
35: each daemon maintains each own cmdvec. */
36: vector cmdvec = NULL;
37:
38: struct desc desc_cr;
39: char *command_cr = NULL;
40:
41: /* Host information structure. */
42: struct host host;
43:
44: /* Standard command node structures. */
45: static struct cmd_node auth_node =
46: {
47: AUTH_NODE,
48: "Password: ",
49: };
50:
51: static struct cmd_node view_node =
52: {
53: VIEW_NODE,
54: "%s> ",
55: };
56:
57: static struct cmd_node restricted_node =
58: {
59: RESTRICTED_NODE,
60: "%s$ ",
61: };
62:
63: static struct cmd_node auth_enable_node =
64: {
65: AUTH_ENABLE_NODE,
66: "Password: ",
67: };
68:
69: static struct cmd_node enable_node =
70: {
71: ENABLE_NODE,
72: "%s# ",
73: };
74:
75: static struct cmd_node config_node =
76: {
77: CONFIG_NODE,
78: "%s(config)# ",
79: 1
80: };
81:
82: /* Default motd string. */
83: static const char *default_motd =
84: "\r\n\
85: Hello, this is " QUAGGA_PROGNAME " (version " QUAGGA_VERSION ").\r\n\
86: " QUAGGA_COPYRIGHT "\r\n\
87: \r\n";
88:
89:
90: static const struct facility_map {
91: int facility;
92: const char *name;
93: size_t match;
94: } syslog_facilities[] =
95: {
96: { LOG_KERN, "kern", 1 },
97: { LOG_USER, "user", 2 },
98: { LOG_MAIL, "mail", 1 },
99: { LOG_DAEMON, "daemon", 1 },
100: { LOG_AUTH, "auth", 1 },
101: { LOG_SYSLOG, "syslog", 1 },
102: { LOG_LPR, "lpr", 2 },
103: { LOG_NEWS, "news", 1 },
104: { LOG_UUCP, "uucp", 2 },
105: { LOG_CRON, "cron", 1 },
106: #ifdef LOG_FTP
107: { LOG_FTP, "ftp", 1 },
108: #endif
109: { LOG_LOCAL0, "local0", 6 },
110: { LOG_LOCAL1, "local1", 6 },
111: { LOG_LOCAL2, "local2", 6 },
112: { LOG_LOCAL3, "local3", 6 },
113: { LOG_LOCAL4, "local4", 6 },
114: { LOG_LOCAL5, "local5", 6 },
115: { LOG_LOCAL6, "local6", 6 },
116: { LOG_LOCAL7, "local7", 6 },
117: { 0, NULL, 0 },
118: };
119:
120: static const char *
121: facility_name(int facility)
122: {
123: const struct facility_map *fm;
124:
125: for (fm = syslog_facilities; fm->name; fm++)
126: if (fm->facility == facility)
127: return fm->name;
128: return "";
129: }
130:
131: static int
132: facility_match(const char *str)
133: {
134: const struct facility_map *fm;
135:
136: for (fm = syslog_facilities; fm->name; fm++)
137: if (!strncmp(str,fm->name,fm->match))
138: return fm->facility;
139: return -1;
140: }
141:
142: static int
143: level_match(const char *s)
144: {
145: int level ;
146:
147: for ( level = 0 ; zlog_priority [level] != NULL ; level ++ )
148: if (!strncmp (s, zlog_priority[level], 2))
149: return level;
150: return ZLOG_DISABLED;
151: }
152:
153: /* This is called from main when a daemon is invoked with -v or --version. */
154: void
155: print_version (const char *progname)
156: {
157: printf ("%s version %s\n", progname, QUAGGA_VERSION);
158: printf ("%s\n", QUAGGA_COPYRIGHT);
159: }
160:
161:
162: /* Utility function to concatenate argv argument into a single string
163: with inserting ' ' character between each argument. */
164: char *
165: argv_concat (const char **argv, int argc, int shift)
166: {
167: int i;
168: size_t len;
169: char *str;
170: char *p;
171:
172: len = 0;
173: for (i = shift; i < argc; i++)
174: len += strlen(argv[i])+1;
175: if (!len)
176: return NULL;
177: p = str = XMALLOC(MTYPE_TMP, len);
178: for (i = shift; i < argc; i++)
179: {
180: size_t arglen;
181: memcpy(p, argv[i], (arglen = strlen(argv[i])));
182: p += arglen;
183: *p++ = ' ';
184: }
185: *(p-1) = '\0';
186: return str;
187: }
188:
189: /* Install top node of command vector. */
190: void
191: install_node (struct cmd_node *node,
192: int (*func) (struct vty *))
193: {
194: vector_set_index (cmdvec, node->node, node);
195: node->func = func;
196: node->cmd_vector = vector_init (VECTOR_MIN_SIZE);
197: }
198:
199: /* Compare two command's string. Used in sort_node (). */
200: static int
201: cmp_node (const void *p, const void *q)
202: {
203: const struct cmd_element *a = *(struct cmd_element * const *)p;
204: const struct cmd_element *b = *(struct cmd_element * const *)q;
205:
206: return strcmp (a->string, b->string);
207: }
208:
209: static int
210: cmp_desc (const void *p, const void *q)
211: {
212: const struct desc *a = *(struct desc * const *)p;
213: const struct desc *b = *(struct desc * const *)q;
214:
215: return strcmp (a->cmd, b->cmd);
216: }
217:
218: /* Sort each node's command element according to command string. */
219: void
220: sort_node ()
221: {
222: unsigned int i, j;
223: struct cmd_node *cnode;
224: vector descvec;
225: struct cmd_element *cmd_element;
226:
227: for (i = 0; i < vector_active (cmdvec); i++)
228: if ((cnode = vector_slot (cmdvec, i)) != NULL)
229: {
230: vector cmd_vector = cnode->cmd_vector;
231: qsort (cmd_vector->index, vector_active (cmd_vector),
232: sizeof (void *), cmp_node);
233:
234: for (j = 0; j < vector_active (cmd_vector); j++)
235: if ((cmd_element = vector_slot (cmd_vector, j)) != NULL
236: && vector_active (cmd_element->strvec))
237: {
238: descvec = vector_slot (cmd_element->strvec,
239: vector_active (cmd_element->strvec) - 1);
240: qsort (descvec->index, vector_active (descvec),
241: sizeof (void *), cmp_desc);
242: }
243: }
244: }
245:
246: /* Breaking up string into each command piece. I assume given
247: character is separated by a space character. Return value is a
248: vector which includes char ** data element. */
249: vector
250: cmd_make_strvec (const char *string)
251: {
252: const char *cp, *start;
253: char *token;
254: int strlen;
255: vector strvec;
256:
257: if (string == NULL)
258: return NULL;
259:
260: cp = string;
261:
262: /* Skip white spaces. */
263: while (isspace ((int) *cp) && *cp != '\0')
264: cp++;
265:
266: /* Return if there is only white spaces */
267: if (*cp == '\0')
268: return NULL;
269:
270: if (*cp == '!' || *cp == '#')
271: return NULL;
272:
273: /* Prepare return vector. */
274: strvec = vector_init (VECTOR_MIN_SIZE);
275:
276: /* Copy each command piece and set into vector. */
277: while (1)
278: {
279: start = cp;
280: while (!(isspace ((int) *cp) || *cp == '\r' || *cp == '\n') &&
281: *cp != '\0')
282: cp++;
283: strlen = cp - start;
284: token = XMALLOC (MTYPE_STRVEC, strlen + 1);
285: memcpy (token, start, strlen);
286: *(token + strlen) = '\0';
287: vector_set (strvec, token);
288:
289: while ((isspace ((int) *cp) || *cp == '\n' || *cp == '\r') &&
290: *cp != '\0')
291: cp++;
292:
293: if (*cp == '\0')
294: return strvec;
295: }
296: }
297:
298: /* Free allocated string vector. */
299: void
300: cmd_free_strvec (vector v)
301: {
302: unsigned int i;
303: char *cp;
304:
305: if (!v)
306: return;
307:
308: for (i = 0; i < vector_active (v); i++)
309: if ((cp = vector_slot (v, i)) != NULL)
310: XFREE (MTYPE_STRVEC, cp);
311:
312: vector_free (v);
313: }
314:
315: /* Fetch next description. Used in cmd_make_descvec(). */
316: static char *
317: cmd_desc_str (const char **string)
318: {
319: const char *cp, *start;
320: char *token;
321: int strlen;
322:
323: cp = *string;
324:
325: if (cp == NULL)
326: return NULL;
327:
328: /* Skip white spaces. */
329: while (isspace ((int) *cp) && *cp != '\0')
330: cp++;
331:
332: /* Return if there is only white spaces */
333: if (*cp == '\0')
334: return NULL;
335:
336: start = cp;
337:
338: while (!(*cp == '\r' || *cp == '\n') && *cp != '\0')
339: cp++;
340:
341: strlen = cp - start;
342: token = XMALLOC (MTYPE_STRVEC, strlen + 1);
343: memcpy (token, start, strlen);
344: *(token + strlen) = '\0';
345:
346: *string = cp;
347:
348: return token;
349: }
350:
351: /* New string vector. */
352: static vector
353: cmd_make_descvec (const char *string, const char *descstr)
354: {
355: int multiple = 0;
356: const char *sp;
357: char *token;
358: int len;
359: const char *cp;
360: const char *dp;
361: vector allvec;
362: vector strvec = NULL;
363: struct desc *desc;
364:
365: cp = string;
366: dp = descstr;
367:
368: if (cp == NULL)
369: return NULL;
370:
371: allvec = vector_init (VECTOR_MIN_SIZE);
372:
373: while (1)
374: {
375: while (isspace ((int) *cp) && *cp != '\0')
376: cp++;
377:
378: if (*cp == '(')
379: {
380: multiple = 1;
381: cp++;
382: }
383: if (*cp == ')')
384: {
385: multiple = 0;
386: cp++;
387: }
388: if (*cp == '|')
389: {
390: if (! multiple)
391: {
392: fprintf (stderr, "Command parse error!: %s\n", string);
393: exit (1);
394: }
395: cp++;
396: }
397:
398: while (isspace ((int) *cp) && *cp != '\0')
399: cp++;
400:
401: if (*cp == '(')
402: {
403: multiple = 1;
404: cp++;
405: }
406:
407: if (*cp == '\0')
408: return allvec;
409:
410: sp = cp;
411:
412: while (! (isspace ((int) *cp) || *cp == '\r' || *cp == '\n' || *cp == ')' || *cp == '|') && *cp != '\0')
413: cp++;
414:
415: len = cp - sp;
416:
417: token = XMALLOC (MTYPE_STRVEC, len + 1);
418: memcpy (token, sp, len);
419: *(token + len) = '\0';
420:
421: desc = XCALLOC (MTYPE_DESC, sizeof (struct desc));
422: desc->cmd = token;
423: desc->str = cmd_desc_str (&dp);
424:
425: if (multiple)
426: {
427: if (multiple == 1)
428: {
429: strvec = vector_init (VECTOR_MIN_SIZE);
430: vector_set (allvec, strvec);
431: }
432: multiple++;
433: }
434: else
435: {
436: strvec = vector_init (VECTOR_MIN_SIZE);
437: vector_set (allvec, strvec);
438: }
439: vector_set (strvec, desc);
440: }
441: }
442:
443: /* Count mandantory string vector size. This is to determine inputed
444: command has enough command length. */
445: static int
446: cmd_cmdsize (vector strvec)
447: {
448: unsigned int i;
449: int size = 0;
450: vector descvec;
451: struct desc *desc;
452:
453: for (i = 0; i < vector_active (strvec); i++)
454: if ((descvec = vector_slot (strvec, i)) != NULL)
455: {
456: if ((vector_active (descvec)) == 1
457: && (desc = vector_slot (descvec, 0)) != NULL)
458: {
459: if (desc->cmd == NULL || CMD_OPTION (desc->cmd))
460: return size;
461: else
462: size++;
463: }
464: else
465: size++;
466: }
467: return size;
468: }
469:
470: /* Return prompt character of specified node. */
471: const char *
472: cmd_prompt (enum node_type node)
473: {
474: struct cmd_node *cnode;
475:
476: cnode = vector_slot (cmdvec, node);
477: return cnode->prompt;
478: }
479:
480: /* Install a command into a node. */
481: void
482: install_element (enum node_type ntype, struct cmd_element *cmd)
483: {
484: struct cmd_node *cnode;
485:
486: /* cmd_init hasn't been called */
487: if (!cmdvec)
488: return;
489:
490: cnode = vector_slot (cmdvec, ntype);
491:
492: if (cnode == NULL)
493: {
494: fprintf (stderr, "Command node %d doesn't exist, please check it\n",
495: ntype);
496: exit (1);
497: }
498:
499: vector_set (cnode->cmd_vector, cmd);
500:
501: if (cmd->strvec == NULL)
502: cmd->strvec = cmd_make_descvec (cmd->string, cmd->doc);
503:
504: cmd->cmdsize = cmd_cmdsize (cmd->strvec);
505: }
506:
507: static const unsigned char itoa64[] =
508: "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
509:
510: static void
511: to64(char *s, long v, int n)
512: {
513: while (--n >= 0)
514: {
515: *s++ = itoa64[v&0x3f];
516: v >>= 6;
517: }
518: }
519:
520: static char *
521: zencrypt (const char *passwd)
522: {
523: char salt[6];
524: struct timeval tv;
525: char *crypt (const char *, const char *);
526:
527: gettimeofday(&tv,0);
528:
529: to64(&salt[0], random(), 3);
530: to64(&salt[3], tv.tv_usec, 3);
531: salt[5] = '\0';
532:
533: return crypt (passwd, salt);
534: }
535:
536: /* This function write configuration of this host. */
537: static int
538: config_write_host (struct vty *vty)
539: {
540: if (host.name)
541: vty_out (vty, "hostname %s%s", host.name, VTY_NEWLINE);
542:
543: if (host.encrypt)
544: {
545: if (host.password_encrypt)
546: vty_out (vty, "password 8 %s%s", host.password_encrypt, VTY_NEWLINE);
547: if (host.enable_encrypt)
548: vty_out (vty, "enable password 8 %s%s", host.enable_encrypt, VTY_NEWLINE);
549: }
550: else
551: {
552: if (host.password)
553: vty_out (vty, "password %s%s", host.password, VTY_NEWLINE);
554: if (host.enable)
555: vty_out (vty, "enable password %s%s", host.enable, VTY_NEWLINE);
556: }
557:
558: if (zlog_default->default_lvl != LOG_DEBUG)
559: {
560: vty_out (vty, "! N.B. The 'log trap' command is deprecated.%s",
561: VTY_NEWLINE);
562: vty_out (vty, "log trap %s%s",
563: zlog_priority[zlog_default->default_lvl], VTY_NEWLINE);
564: }
565:
566: if (host.logfile && (zlog_default->maxlvl[ZLOG_DEST_FILE] != ZLOG_DISABLED))
567: {
568: vty_out (vty, "log file %s", host.logfile);
569: if (zlog_default->maxlvl[ZLOG_DEST_FILE] != zlog_default->default_lvl)
570: vty_out (vty, " %s",
571: zlog_priority[zlog_default->maxlvl[ZLOG_DEST_FILE]]);
572: vty_out (vty, "%s", VTY_NEWLINE);
573: }
574:
575: if (zlog_default->maxlvl[ZLOG_DEST_STDOUT] != ZLOG_DISABLED)
576: {
577: vty_out (vty, "log stdout");
578: if (zlog_default->maxlvl[ZLOG_DEST_STDOUT] != zlog_default->default_lvl)
579: vty_out (vty, " %s",
580: zlog_priority[zlog_default->maxlvl[ZLOG_DEST_STDOUT]]);
581: vty_out (vty, "%s", VTY_NEWLINE);
582: }
583:
584: if (zlog_default->maxlvl[ZLOG_DEST_MONITOR] == ZLOG_DISABLED)
585: vty_out(vty,"no log monitor%s",VTY_NEWLINE);
586: else if (zlog_default->maxlvl[ZLOG_DEST_MONITOR] != zlog_default->default_lvl)
587: vty_out(vty,"log monitor %s%s",
588: zlog_priority[zlog_default->maxlvl[ZLOG_DEST_MONITOR]],VTY_NEWLINE);
589:
590: if (zlog_default->maxlvl[ZLOG_DEST_SYSLOG] != ZLOG_DISABLED)
591: {
592: vty_out (vty, "log syslog");
593: if (zlog_default->maxlvl[ZLOG_DEST_SYSLOG] != zlog_default->default_lvl)
594: vty_out (vty, " %s",
595: zlog_priority[zlog_default->maxlvl[ZLOG_DEST_SYSLOG]]);
596: vty_out (vty, "%s", VTY_NEWLINE);
597: }
598:
599: if (zlog_default->facility != LOG_DAEMON)
600: vty_out (vty, "log facility %s%s",
601: facility_name(zlog_default->facility), VTY_NEWLINE);
602:
603: if (zlog_default->record_priority == 1)
604: vty_out (vty, "log record-priority%s", VTY_NEWLINE);
605:
606: if (zlog_default->timestamp_precision > 0)
607: vty_out (vty, "log timestamp precision %d%s",
608: zlog_default->timestamp_precision, VTY_NEWLINE);
609:
610: if (host.advanced)
611: vty_out (vty, "service advanced-vty%s", VTY_NEWLINE);
612:
613: if (host.encrypt)
614: vty_out (vty, "service password-encryption%s", VTY_NEWLINE);
615:
616: if (host.lines >= 0)
617: vty_out (vty, "service terminal-length %d%s", host.lines,
618: VTY_NEWLINE);
619:
620: if (host.motdfile)
621: vty_out (vty, "banner motd file %s%s", host.motdfile, VTY_NEWLINE);
622: else if (! host.motd)
623: vty_out (vty, "no banner motd%s", VTY_NEWLINE);
624:
625: return 1;
626: }
627:
628: /* Utility function for getting command vector. */
629: static vector
630: cmd_node_vector (vector v, enum node_type ntype)
631: {
632: struct cmd_node *cnode = vector_slot (v, ntype);
633: return cnode->cmd_vector;
634: }
635:
636: #if 0
637: /* Filter command vector by symbol. This function is not actually used;
638: * should it be deleted? */
639: static int
640: cmd_filter_by_symbol (char *command, char *symbol)
641: {
642: int i, lim;
643:
644: if (strcmp (symbol, "IPV4_ADDRESS") == 0)
645: {
646: i = 0;
647: lim = strlen (command);
648: while (i < lim)
649: {
650: if (! (isdigit ((int) command[i]) || command[i] == '.' || command[i] == '/'))
651: return 1;
652: i++;
653: }
654: return 0;
655: }
656: if (strcmp (symbol, "STRING") == 0)
657: {
658: i = 0;
659: lim = strlen (command);
660: while (i < lim)
661: {
662: if (! (isalpha ((int) command[i]) || command[i] == '_' || command[i] == '-'))
663: return 1;
664: i++;
665: }
666: return 0;
667: }
668: if (strcmp (symbol, "IFNAME") == 0)
669: {
670: i = 0;
671: lim = strlen (command);
672: while (i < lim)
673: {
674: if (! isalnum ((int) command[i]))
675: return 1;
676: i++;
677: }
678: return 0;
679: }
680: return 0;
681: }
682: #endif
683:
684: /* Completion match types. */
685: enum match_type
686: {
687: no_match,
688: extend_match,
689: ipv4_prefix_match,
690: ipv4_match,
691: ipv6_prefix_match,
692: ipv6_match,
693: range_match,
694: vararg_match,
695: partly_match,
696: exact_match
697: };
698:
699: static enum match_type
700: cmd_ipv4_match (const char *str)
701: {
702: const char *sp;
703: int dots = 0, nums = 0;
704: char buf[4];
705:
706: if (str == NULL)
707: return partly_match;
708:
709: for (;;)
710: {
711: memset (buf, 0, sizeof (buf));
712: sp = str;
713: while (*str != '\0')
714: {
715: if (*str == '.')
716: {
717: if (dots >= 3)
718: return no_match;
719:
720: if (*(str + 1) == '.')
721: return no_match;
722:
723: if (*(str + 1) == '\0')
724: return partly_match;
725:
726: dots++;
727: break;
728: }
729: if (!isdigit ((int) *str))
730: return no_match;
731:
732: str++;
733: }
734:
735: if (str - sp > 3)
736: return no_match;
737:
738: strncpy (buf, sp, str - sp);
739: if (atoi (buf) > 255)
740: return no_match;
741:
742: nums++;
743:
744: if (*str == '\0')
745: break;
746:
747: str++;
748: }
749:
750: if (nums < 4)
751: return partly_match;
752:
753: return exact_match;
754: }
755:
756: static enum match_type
757: cmd_ipv4_prefix_match (const char *str)
758: {
759: const char *sp;
760: int dots = 0;
761: char buf[4];
762:
763: if (str == NULL)
764: return partly_match;
765:
766: for (;;)
767: {
768: memset (buf, 0, sizeof (buf));
769: sp = str;
770: while (*str != '\0' && *str != '/')
771: {
772: if (*str == '.')
773: {
774: if (dots == 3)
775: return no_match;
776:
777: if (*(str + 1) == '.' || *(str + 1) == '/')
778: return no_match;
779:
780: if (*(str + 1) == '\0')
781: return partly_match;
782:
783: dots++;
784: break;
785: }
786:
787: if (!isdigit ((int) *str))
788: return no_match;
789:
790: str++;
791: }
792:
793: if (str - sp > 3)
794: return no_match;
795:
796: strncpy (buf, sp, str - sp);
797: if (atoi (buf) > 255)
798: return no_match;
799:
800: if (dots == 3)
801: {
802: if (*str == '/')
803: {
804: if (*(str + 1) == '\0')
805: return partly_match;
806:
807: str++;
808: break;
809: }
810: else if (*str == '\0')
811: return partly_match;
812: }
813:
814: if (*str == '\0')
815: return partly_match;
816:
817: str++;
818: }
819:
820: sp = str;
821: while (*str != '\0')
822: {
823: if (!isdigit ((int) *str))
824: return no_match;
825:
826: str++;
827: }
828:
829: if (atoi (sp) > 32)
830: return no_match;
831:
832: return exact_match;
833: }
834:
835: #define IPV6_ADDR_STR "0123456789abcdefABCDEF:.%"
836: #define IPV6_PREFIX_STR "0123456789abcdefABCDEF:.%/"
837: #define STATE_START 1
838: #define STATE_COLON 2
839: #define STATE_DOUBLE 3
840: #define STATE_ADDR 4
841: #define STATE_DOT 5
842: #define STATE_SLASH 6
843: #define STATE_MASK 7
844:
845: #ifdef HAVE_IPV6
846:
847: static enum match_type
848: cmd_ipv6_match (const char *str)
849: {
850: int state = STATE_START;
851: int colons = 0, nums = 0, double_colon = 0;
852: const char *sp = NULL;
853: struct sockaddr_in6 sin6_dummy;
854: int ret;
855:
856: if (str == NULL)
857: return partly_match;
858:
859: if (strspn (str, IPV6_ADDR_STR) != strlen (str))
860: return no_match;
861:
862: /* use inet_pton that has a better support,
863: * for example inet_pton can support the automatic addresses:
864: * ::1.2.3.4
865: */
866: ret = inet_pton(AF_INET6, str, &sin6_dummy.sin6_addr);
867:
868: if (ret == 1)
869: return exact_match;
870:
871: while (*str != '\0')
872: {
873: switch (state)
874: {
875: case STATE_START:
876: if (*str == ':')
877: {
878: if (*(str + 1) != ':' && *(str + 1) != '\0')
879: return no_match;
880: colons--;
881: state = STATE_COLON;
882: }
883: else
884: {
885: sp = str;
886: state = STATE_ADDR;
887: }
888:
889: continue;
890: case STATE_COLON:
891: colons++;
892: if (*(str + 1) == ':')
893: state = STATE_DOUBLE;
894: else
895: {
896: sp = str + 1;
897: state = STATE_ADDR;
898: }
899: break;
900: case STATE_DOUBLE:
901: if (double_colon)
902: return no_match;
903:
904: if (*(str + 1) == ':')
905: return no_match;
906: else
907: {
908: if (*(str + 1) != '\0')
909: colons++;
910: sp = str + 1;
911: state = STATE_ADDR;
912: }
913:
914: double_colon++;
915: nums++;
916: break;
917: case STATE_ADDR:
918: if (*(str + 1) == ':' || *(str + 1) == '\0')
919: {
920: if (str - sp > 3)
921: return no_match;
922:
923: nums++;
924: state = STATE_COLON;
925: }
926: if (*(str + 1) == '.')
927: state = STATE_DOT;
928: break;
929: case STATE_DOT:
930: state = STATE_ADDR;
931: break;
932: default:
933: break;
934: }
935:
936: if (nums > 8)
937: return no_match;
938:
939: if (colons > 7)
940: return no_match;
941:
942: str++;
943: }
944:
945: #if 0
946: if (nums < 11)
947: return partly_match;
948: #endif /* 0 */
949:
950: return exact_match;
951: }
952:
953: static enum match_type
954: cmd_ipv6_prefix_match (const char *str)
955: {
956: int state = STATE_START;
957: int colons = 0, nums = 0, double_colon = 0;
958: int mask;
959: const char *sp = NULL;
960: char *endptr = NULL;
961:
962: if (str == NULL)
963: return partly_match;
964:
965: if (strspn (str, IPV6_PREFIX_STR) != strlen (str))
966: return no_match;
967:
968: while (*str != '\0' && state != STATE_MASK)
969: {
970: switch (state)
971: {
972: case STATE_START:
973: if (*str == ':')
974: {
975: if (*(str + 1) != ':' && *(str + 1) != '\0')
976: return no_match;
977: colons--;
978: state = STATE_COLON;
979: }
980: else
981: {
982: sp = str;
983: state = STATE_ADDR;
984: }
985:
986: continue;
987: case STATE_COLON:
988: colons++;
989: if (*(str + 1) == '/')
990: return no_match;
991: else if (*(str + 1) == ':')
992: state = STATE_DOUBLE;
993: else
994: {
995: sp = str + 1;
996: state = STATE_ADDR;
997: }
998: break;
999: case STATE_DOUBLE:
1000: if (double_colon)
1001: return no_match;
1002:
1003: if (*(str + 1) == ':')
1004: return no_match;
1005: else
1006: {
1007: if (*(str + 1) != '\0' && *(str + 1) != '/')
1008: colons++;
1009: sp = str + 1;
1010:
1011: if (*(str + 1) == '/')
1012: state = STATE_SLASH;
1013: else
1014: state = STATE_ADDR;
1015: }
1016:
1017: double_colon++;
1018: nums += 1;
1019: break;
1020: case STATE_ADDR:
1021: if (*(str + 1) == ':' || *(str + 1) == '.'
1022: || *(str + 1) == '\0' || *(str + 1) == '/')
1023: {
1024: if (str - sp > 3)
1025: return no_match;
1026:
1027: for (; sp <= str; sp++)
1028: if (*sp == '/')
1029: return no_match;
1030:
1031: nums++;
1032:
1033: if (*(str + 1) == ':')
1034: state = STATE_COLON;
1035: else if (*(str + 1) == '.')
1036: state = STATE_DOT;
1037: else if (*(str + 1) == '/')
1038: state = STATE_SLASH;
1039: }
1040: break;
1041: case STATE_DOT:
1042: state = STATE_ADDR;
1043: break;
1044: case STATE_SLASH:
1045: if (*(str + 1) == '\0')
1046: return partly_match;
1047:
1048: state = STATE_MASK;
1049: break;
1050: default:
1051: break;
1052: }
1053:
1054: if (nums > 11)
1055: return no_match;
1056:
1057: if (colons > 7)
1058: return no_match;
1059:
1060: str++;
1061: }
1062:
1063: if (state < STATE_MASK)
1064: return partly_match;
1065:
1066: mask = strtol (str, &endptr, 10);
1067: if (*endptr != '\0')
1068: return no_match;
1069:
1070: if (mask < 0 || mask > 128)
1071: return no_match;
1072:
1073: /* I don't know why mask < 13 makes command match partly.
1074: Forgive me to make this comments. I Want to set static default route
1075: because of lack of function to originate default in ospf6d; sorry
1076: yasu
1077: if (mask < 13)
1078: return partly_match;
1079: */
1080:
1081: return exact_match;
1082: }
1083:
1084: #endif /* HAVE_IPV6 */
1085:
1086: #define DECIMAL_STRLEN_MAX 10
1087:
1088: static int
1089: cmd_range_match (const char *range, const char *str)
1090: {
1091: char *p;
1092: char buf[DECIMAL_STRLEN_MAX + 1];
1093: char *endptr = NULL;
1094: unsigned long min, max, val;
1095:
1096: if (str == NULL)
1097: return 1;
1098:
1099: val = strtoul (str, &endptr, 10);
1100: if (*endptr != '\0')
1101: return 0;
1102:
1103: range++;
1104: p = strchr (range, '-');
1105: if (p == NULL)
1106: return 0;
1107: if (p - range > DECIMAL_STRLEN_MAX)
1108: return 0;
1109: strncpy (buf, range, p - range);
1110: buf[p - range] = '\0';
1111: min = strtoul (buf, &endptr, 10);
1112: if (*endptr != '\0')
1113: return 0;
1114:
1115: range = p + 1;
1116: p = strchr (range, '>');
1117: if (p == NULL)
1118: return 0;
1119: if (p - range > DECIMAL_STRLEN_MAX)
1120: return 0;
1121: strncpy (buf, range, p - range);
1122: buf[p - range] = '\0';
1123: max = strtoul (buf, &endptr, 10);
1124: if (*endptr != '\0')
1125: return 0;
1126:
1127: if (val < min || val > max)
1128: return 0;
1129:
1130: return 1;
1131: }
1132:
1133: /* Make completion match and return match type flag. */
1134: static enum match_type
1135: cmd_filter_by_completion (char *command, vector v, unsigned int index)
1136: {
1137: unsigned int i;
1138: const char *str;
1139: struct cmd_element *cmd_element;
1140: enum match_type match_type;
1141: vector descvec;
1142: struct desc *desc;
1143:
1144: match_type = no_match;
1145:
1146: /* If command and cmd_element string does not match set NULL to vector */
1147: for (i = 0; i < vector_active (v); i++)
1148: if ((cmd_element = vector_slot (v, i)) != NULL)
1149: {
1150: if (index >= vector_active (cmd_element->strvec))
1151: vector_slot (v, i) = NULL;
1152: else
1153: {
1154: unsigned int j;
1155: int matched = 0;
1156:
1157: descvec = vector_slot (cmd_element->strvec, index);
1158:
1159: for (j = 0; j < vector_active (descvec); j++)
1160: if ((desc = vector_slot (descvec, j)))
1161: {
1162: str = desc->cmd;
1163:
1164: if (CMD_VARARG (str))
1165: {
1166: if (match_type < vararg_match)
1167: match_type = vararg_match;
1168: matched++;
1169: }
1170: else if (CMD_RANGE (str))
1171: {
1172: if (cmd_range_match (str, command))
1173: {
1174: if (match_type < range_match)
1175: match_type = range_match;
1176:
1177: matched++;
1178: }
1179: }
1180: #ifdef HAVE_IPV6
1181: else if (CMD_IPV6 (str))
1182: {
1183: if (cmd_ipv6_match (command))
1184: {
1185: if (match_type < ipv6_match)
1186: match_type = ipv6_match;
1187:
1188: matched++;
1189: }
1190: }
1191: else if (CMD_IPV6_PREFIX (str))
1192: {
1193: if (cmd_ipv6_prefix_match (command))
1194: {
1195: if (match_type < ipv6_prefix_match)
1196: match_type = ipv6_prefix_match;
1197:
1198: matched++;
1199: }
1200: }
1201: #endif /* HAVE_IPV6 */
1202: else if (CMD_IPV4 (str))
1203: {
1204: if (cmd_ipv4_match (command))
1205: {
1206: if (match_type < ipv4_match)
1207: match_type = ipv4_match;
1208:
1209: matched++;
1210: }
1211: }
1212: else if (CMD_IPV4_PREFIX (str))
1213: {
1214: if (cmd_ipv4_prefix_match (command))
1215: {
1216: if (match_type < ipv4_prefix_match)
1217: match_type = ipv4_prefix_match;
1218: matched++;
1219: }
1220: }
1221: else
1222: /* Check is this point's argument optional ? */
1223: if (CMD_OPTION (str) || CMD_VARIABLE (str))
1224: {
1225: if (match_type < extend_match)
1226: match_type = extend_match;
1227: matched++;
1228: }
1229: else if (strncmp (command, str, strlen (command)) == 0)
1230: {
1231: if (strcmp (command, str) == 0)
1232: match_type = exact_match;
1233: else
1234: {
1235: if (match_type < partly_match)
1236: match_type = partly_match;
1237: }
1238: matched++;
1239: }
1240: }
1241: if (!matched)
1242: vector_slot (v, i) = NULL;
1243: }
1244: }
1245: return match_type;
1246: }
1247:
1248: /* Filter vector by command character with index. */
1249: static enum match_type
1250: cmd_filter_by_string (char *command, vector v, unsigned int index)
1251: {
1252: unsigned int i;
1253: const char *str;
1254: struct cmd_element *cmd_element;
1255: enum match_type match_type;
1256: vector descvec;
1257: struct desc *desc;
1258:
1259: match_type = no_match;
1260:
1261: /* If command and cmd_element string does not match set NULL to vector */
1262: for (i = 0; i < vector_active (v); i++)
1263: if ((cmd_element = vector_slot (v, i)) != NULL)
1264: {
1265: /* If given index is bigger than max string vector of command,
1266: set NULL */
1267: if (index >= vector_active (cmd_element->strvec))
1268: vector_slot (v, i) = NULL;
1269: else
1270: {
1271: unsigned int j;
1272: int matched = 0;
1273:
1274: descvec = vector_slot (cmd_element->strvec, index);
1275:
1276: for (j = 0; j < vector_active (descvec); j++)
1277: if ((desc = vector_slot (descvec, j)))
1278: {
1279: str = desc->cmd;
1280:
1281: if (CMD_VARARG (str))
1282: {
1283: if (match_type < vararg_match)
1284: match_type = vararg_match;
1285: matched++;
1286: }
1287: else if (CMD_RANGE (str))
1288: {
1289: if (cmd_range_match (str, command))
1290: {
1291: if (match_type < range_match)
1292: match_type = range_match;
1293: matched++;
1294: }
1295: }
1296: #ifdef HAVE_IPV6
1297: else if (CMD_IPV6 (str))
1298: {
1299: if (cmd_ipv6_match (command) == exact_match)
1300: {
1301: if (match_type < ipv6_match)
1302: match_type = ipv6_match;
1303: matched++;
1304: }
1305: }
1306: else if (CMD_IPV6_PREFIX (str))
1307: {
1308: if (cmd_ipv6_prefix_match (command) == exact_match)
1309: {
1310: if (match_type < ipv6_prefix_match)
1311: match_type = ipv6_prefix_match;
1312: matched++;
1313: }
1314: }
1315: #endif /* HAVE_IPV6 */
1316: else if (CMD_IPV4 (str))
1317: {
1318: if (cmd_ipv4_match (command) == exact_match)
1319: {
1320: if (match_type < ipv4_match)
1321: match_type = ipv4_match;
1322: matched++;
1323: }
1324: }
1325: else if (CMD_IPV4_PREFIX (str))
1326: {
1327: if (cmd_ipv4_prefix_match (command) == exact_match)
1328: {
1329: if (match_type < ipv4_prefix_match)
1330: match_type = ipv4_prefix_match;
1331: matched++;
1332: }
1333: }
1334: else if (CMD_OPTION (str) || CMD_VARIABLE (str))
1335: {
1336: if (match_type < extend_match)
1337: match_type = extend_match;
1338: matched++;
1339: }
1340: else
1341: {
1342: if (strcmp (command, str) == 0)
1343: {
1344: match_type = exact_match;
1345: matched++;
1346: }
1347: }
1348: }
1349: if (!matched)
1350: vector_slot (v, i) = NULL;
1351: }
1352: }
1353: return match_type;
1354: }
1355:
1356: /* Check ambiguous match */
1357: static int
1358: is_cmd_ambiguous (char *command, vector v, int index, enum match_type type)
1359: {
1360: unsigned int i;
1361: unsigned int j;
1362: const char *str = NULL;
1363: struct cmd_element *cmd_element;
1364: const char *matched = NULL;
1365: vector descvec;
1366: struct desc *desc;
1367:
1368: for (i = 0; i < vector_active (v); i++)
1369: if ((cmd_element = vector_slot (v, i)) != NULL)
1370: {
1371: int match = 0;
1372:
1373: descvec = vector_slot (cmd_element->strvec, index);
1374:
1375: for (j = 0; j < vector_active (descvec); j++)
1376: if ((desc = vector_slot (descvec, j)))
1377: {
1378: enum match_type ret;
1379:
1380: str = desc->cmd;
1381:
1382: switch (type)
1383: {
1384: case exact_match:
1385: if (!(CMD_OPTION (str) || CMD_VARIABLE (str))
1386: && strcmp (command, str) == 0)
1387: match++;
1388: break;
1389: case partly_match:
1390: if (!(CMD_OPTION (str) || CMD_VARIABLE (str))
1391: && strncmp (command, str, strlen (command)) == 0)
1392: {
1393: if (matched && strcmp (matched, str) != 0)
1394: return 1; /* There is ambiguous match. */
1395: else
1396: matched = str;
1397: match++;
1398: }
1399: break;
1400: case range_match:
1401: if (cmd_range_match (str, command))
1402: {
1403: if (matched && strcmp (matched, str) != 0)
1404: return 1;
1405: else
1406: matched = str;
1407: match++;
1408: }
1409: break;
1410: #ifdef HAVE_IPV6
1411: case ipv6_match:
1412: if (CMD_IPV6 (str))
1413: match++;
1414: break;
1415: case ipv6_prefix_match:
1416: if ((ret = cmd_ipv6_prefix_match (command)) != no_match)
1417: {
1418: if (ret == partly_match)
1419: return 2; /* There is incomplete match. */
1420:
1421: match++;
1422: }
1423: break;
1424: #endif /* HAVE_IPV6 */
1425: case ipv4_match:
1426: if (CMD_IPV4 (str))
1427: match++;
1428: break;
1429: case ipv4_prefix_match:
1430: if ((ret = cmd_ipv4_prefix_match (command)) != no_match)
1431: {
1432: if (ret == partly_match)
1433: return 2; /* There is incomplete match. */
1434:
1435: match++;
1436: }
1437: break;
1438: case extend_match:
1439: if (CMD_OPTION (str) || CMD_VARIABLE (str))
1440: match++;
1441: break;
1442: case no_match:
1443: default:
1444: break;
1445: }
1446: }
1447: if (!match)
1448: vector_slot (v, i) = NULL;
1449: }
1450: return 0;
1451: }
1452:
1453: /* If src matches dst return dst string, otherwise return NULL */
1454: static const char *
1455: cmd_entry_function (const char *src, const char *dst)
1456: {
1457: /* Skip variable arguments. */
1458: if (CMD_OPTION (dst) || CMD_VARIABLE (dst) || CMD_VARARG (dst) ||
1459: CMD_IPV4 (dst) || CMD_IPV4_PREFIX (dst) || CMD_RANGE (dst))
1460: return NULL;
1461:
1462: /* In case of 'command \t', given src is NULL string. */
1463: if (src == NULL)
1464: return dst;
1465:
1466: /* Matched with input string. */
1467: if (strncmp (src, dst, strlen (src)) == 0)
1468: return dst;
1469:
1470: return NULL;
1471: }
1472:
1473: /* If src matches dst return dst string, otherwise return NULL */
1474: /* This version will return the dst string always if it is
1475: CMD_VARIABLE for '?' key processing */
1476: static const char *
1477: cmd_entry_function_desc (const char *src, const char *dst)
1478: {
1479: if (CMD_VARARG (dst))
1480: return dst;
1481:
1482: if (CMD_RANGE (dst))
1483: {
1484: if (cmd_range_match (dst, src))
1485: return dst;
1486: else
1487: return NULL;
1488: }
1489:
1490: #ifdef HAVE_IPV6
1491: if (CMD_IPV6 (dst))
1492: {
1493: if (cmd_ipv6_match (src))
1494: return dst;
1495: else
1496: return NULL;
1497: }
1498:
1499: if (CMD_IPV6_PREFIX (dst))
1500: {
1501: if (cmd_ipv6_prefix_match (src))
1502: return dst;
1503: else
1504: return NULL;
1505: }
1506: #endif /* HAVE_IPV6 */
1507:
1508: if (CMD_IPV4 (dst))
1509: {
1510: if (cmd_ipv4_match (src))
1511: return dst;
1512: else
1513: return NULL;
1514: }
1515:
1516: if (CMD_IPV4_PREFIX (dst))
1517: {
1518: if (cmd_ipv4_prefix_match (src))
1519: return dst;
1520: else
1521: return NULL;
1522: }
1523:
1524: /* Optional or variable commands always match on '?' */
1525: if (CMD_OPTION (dst) || CMD_VARIABLE (dst))
1526: return dst;
1527:
1528: /* In case of 'command \t', given src is NULL string. */
1529: if (src == NULL)
1530: return dst;
1531:
1532: if (strncmp (src, dst, strlen (src)) == 0)
1533: return dst;
1534: else
1535: return NULL;
1536: }
1537:
1538: /* Check same string element existence. If it isn't there return
1539: 1. */
1540: static int
1541: cmd_unique_string (vector v, const char *str)
1542: {
1543: unsigned int i;
1544: char *match;
1545:
1546: for (i = 0; i < vector_active (v); i++)
1547: if ((match = vector_slot (v, i)) != NULL)
1548: if (strcmp (match, str) == 0)
1549: return 0;
1550: return 1;
1551: }
1552:
1553: /* Compare string to description vector. If there is same string
1554: return 1 else return 0. */
1555: static int
1556: desc_unique_string (vector v, const char *str)
1557: {
1558: unsigned int i;
1559: struct desc *desc;
1560:
1561: for (i = 0; i < vector_active (v); i++)
1562: if ((desc = vector_slot (v, i)) != NULL)
1563: if (strcmp (desc->cmd, str) == 0)
1564: return 1;
1565: return 0;
1566: }
1567:
1568: static int
1569: cmd_try_do_shortcut (enum node_type node, char* first_word) {
1570: if ( first_word != NULL &&
1571: node != AUTH_NODE &&
1572: node != VIEW_NODE &&
1573: node != AUTH_ENABLE_NODE &&
1574: node != ENABLE_NODE &&
1575: node != RESTRICTED_NODE &&
1576: 0 == strcmp( "do", first_word ) )
1577: return 1;
1578: return 0;
1579: }
1580:
1581: /* '?' describe command support. */
1582: static vector
1583: cmd_describe_command_real (vector vline, struct vty *vty, int *status)
1584: {
1585: unsigned int i;
1586: vector cmd_vector;
1587: #define INIT_MATCHVEC_SIZE 10
1588: vector matchvec;
1589: struct cmd_element *cmd_element;
1590: unsigned int index;
1591: int ret;
1592: enum match_type match;
1593: char *command;
1594:
1595: /* Set index. */
1596: if (vector_active (vline) == 0)
1597: {
1598: *status = CMD_ERR_NO_MATCH;
1599: return NULL;
1600: }
1601: else
1602: index = vector_active (vline) - 1;
1603:
1604: /* Make copy vector of current node's command vector. */
1605: cmd_vector = vector_copy (cmd_node_vector (cmdvec, vty->node));
1606:
1607: /* Prepare match vector */
1608: matchvec = vector_init (INIT_MATCHVEC_SIZE);
1609:
1610: /* Filter commands. */
1611: /* Only words precedes current word will be checked in this loop. */
1612: for (i = 0; i < index; i++)
1613: if ((command = vector_slot (vline, i)))
1614: {
1615: match = cmd_filter_by_completion (command, cmd_vector, i);
1616:
1617: if (match == vararg_match)
1618: {
1619: struct cmd_element *cmd_element;
1620: vector descvec;
1621: unsigned int j, k;
1622:
1623: for (j = 0; j < vector_active (cmd_vector); j++)
1624: if ((cmd_element = vector_slot (cmd_vector, j)) != NULL
1625: && (vector_active (cmd_element->strvec)))
1626: {
1627: descvec = vector_slot (cmd_element->strvec,
1628: vector_active (cmd_element->strvec) - 1);
1629: for (k = 0; k < vector_active (descvec); k++)
1630: {
1631: struct desc *desc = vector_slot (descvec, k);
1632: vector_set (matchvec, desc);
1633: }
1634: }
1635:
1636: vector_set (matchvec, &desc_cr);
1637: vector_free (cmd_vector);
1638:
1639: return matchvec;
1640: }
1641:
1642: if ((ret = is_cmd_ambiguous (command, cmd_vector, i, match)) == 1)
1643: {
1644: vector_free (cmd_vector);
1645: vector_free (matchvec);
1646: *status = CMD_ERR_AMBIGUOUS;
1647: return NULL;
1648: }
1649: else if (ret == 2)
1650: {
1651: vector_free (cmd_vector);
1652: vector_free (matchvec);
1653: *status = CMD_ERR_NO_MATCH;
1654: return NULL;
1655: }
1656: }
1657:
1658: /* Prepare match vector */
1659: /* matchvec = vector_init (INIT_MATCHVEC_SIZE); */
1660:
1661: /* Make sure that cmd_vector is filtered based on current word */
1662: command = vector_slot (vline, index);
1663: if (command)
1664: match = cmd_filter_by_completion (command, cmd_vector, index);
1665:
1666: /* Make description vector. */
1667: for (i = 0; i < vector_active (cmd_vector); i++)
1668: if ((cmd_element = vector_slot (cmd_vector, i)) != NULL)
1669: {
1670: vector strvec = cmd_element->strvec;
1671:
1672: /* if command is NULL, index may be equal to vector_active */
1673: if (command && index >= vector_active (strvec))
1674: vector_slot (cmd_vector, i) = NULL;
1675: else
1676: {
1677: /* Check if command is completed. */
1678: if (command == NULL && index == vector_active (strvec))
1679: {
1680: if (!desc_unique_string (matchvec, command_cr))
1681: vector_set (matchvec, &desc_cr);
1682: }
1683: else
1684: {
1685: unsigned int j;
1686: vector descvec = vector_slot (strvec, index);
1687: struct desc *desc;
1688:
1689: for (j = 0; j < vector_active (descvec); j++)
1690: if ((desc = vector_slot (descvec, j)))
1691: {
1692: const char *string;
1693:
1694: string = cmd_entry_function_desc (command, desc->cmd);
1695: if (string)
1696: {
1697: /* Uniqueness check */
1698: if (!desc_unique_string (matchvec, string))
1699: vector_set (matchvec, desc);
1700: }
1701: }
1702: }
1703: }
1704: }
1705: vector_free (cmd_vector);
1706:
1707: if (vector_slot (matchvec, 0) == NULL)
1708: {
1709: vector_free (matchvec);
1710: *status = CMD_ERR_NO_MATCH;
1711: return NULL;
1712: }
1713:
1714: *status = CMD_SUCCESS;
1715: return matchvec;
1716: }
1717:
1718: vector
1719: cmd_describe_command (vector vline, struct vty *vty, int *status)
1720: {
1721: vector ret;
1722:
1723: if ( cmd_try_do_shortcut(vty->node, vector_slot(vline, 0) ) )
1724: {
1725: enum node_type onode;
1726: vector shifted_vline;
1727: unsigned int index;
1728:
1729: onode = vty->node;
1730: vty->node = ENABLE_NODE;
1731: /* We can try it on enable node, cos' the vty is authenticated */
1732:
1733: shifted_vline = vector_init (vector_count(vline));
1734: /* use memcpy? */
1735: for (index = 1; index < vector_active (vline); index++)
1736: {
1737: vector_set_index (shifted_vline, index-1, vector_lookup(vline, index));
1738: }
1739:
1740: ret = cmd_describe_command_real (shifted_vline, vty, status);
1741:
1742: vector_free(shifted_vline);
1743: vty->node = onode;
1744: return ret;
1745: }
1746:
1747:
1748: return cmd_describe_command_real (vline, vty, status);
1749: }
1750:
1751:
1752: /* Check LCD of matched command. */
1753: static int
1754: cmd_lcd (char **matched)
1755: {
1756: int i;
1757: int j;
1758: int lcd = -1;
1759: char *s1, *s2;
1760: char c1, c2;
1761:
1762: if (matched[0] == NULL || matched[1] == NULL)
1763: return 0;
1764:
1765: for (i = 1; matched[i] != NULL; i++)
1766: {
1767: s1 = matched[i - 1];
1768: s2 = matched[i];
1769:
1770: for (j = 0; (c1 = s1[j]) && (c2 = s2[j]); j++)
1771: if (c1 != c2)
1772: break;
1773:
1774: if (lcd < 0)
1775: lcd = j;
1776: else
1777: {
1778: if (lcd > j)
1779: lcd = j;
1780: }
1781: }
1782: return lcd;
1783: }
1784:
1785: /* Command line completion support. */
1786: static char **
1787: cmd_complete_command_real (vector vline, struct vty *vty, int *status)
1788: {
1789: unsigned int i;
1790: vector cmd_vector = vector_copy (cmd_node_vector (cmdvec, vty->node));
1791: #define INIT_MATCHVEC_SIZE 10
1792: vector matchvec;
1793: struct cmd_element *cmd_element;
1794: unsigned int index;
1795: char **match_str;
1796: struct desc *desc;
1797: vector descvec;
1798: char *command;
1799: int lcd;
1800:
1801: if (vector_active (vline) == 0)
1802: {
1803: vector_free (cmd_vector);
1804: *status = CMD_ERR_NO_MATCH;
1805: return NULL;
1806: }
1807: else
1808: index = vector_active (vline) - 1;
1809:
1810: /* First, filter by preceeding command string */
1811: for (i = 0; i < index; i++)
1812: if ((command = vector_slot (vline, i)))
1813: {
1814: enum match_type match;
1815: int ret;
1816:
1817: /* First try completion match, if there is exactly match return 1 */
1818: match = cmd_filter_by_completion (command, cmd_vector, i);
1819:
1820: /* If there is exact match then filter ambiguous match else check
1821: ambiguousness. */
1822: if ((ret = is_cmd_ambiguous (command, cmd_vector, i, match)) == 1)
1823: {
1824: vector_free (cmd_vector);
1825: *status = CMD_ERR_AMBIGUOUS;
1826: return NULL;
1827: }
1828: /*
1829: else if (ret == 2)
1830: {
1831: vector_free (cmd_vector);
1832: *status = CMD_ERR_NO_MATCH;
1833: return NULL;
1834: }
1835: */
1836: }
1837:
1838: /* Prepare match vector. */
1839: matchvec = vector_init (INIT_MATCHVEC_SIZE);
1840:
1841: /* Now we got into completion */
1842: for (i = 0; i < vector_active (cmd_vector); i++)
1843: if ((cmd_element = vector_slot (cmd_vector, i)))
1844: {
1845: const char *string;
1846: vector strvec = cmd_element->strvec;
1847:
1848: /* Check field length */
1849: if (index >= vector_active (strvec))
1850: vector_slot (cmd_vector, i) = NULL;
1851: else
1852: {
1853: unsigned int j;
1854:
1855: descvec = vector_slot (strvec, index);
1856: for (j = 0; j < vector_active (descvec); j++)
1857: if ((desc = vector_slot (descvec, j)))
1858: {
1859: if ((string =
1860: cmd_entry_function (vector_slot (vline, index),
1861: desc->cmd)))
1862: if (cmd_unique_string (matchvec, string))
1863: vector_set (matchvec, XSTRDUP (MTYPE_TMP, string));
1864: }
1865: }
1866: }
1867:
1868: /* We don't need cmd_vector any more. */
1869: vector_free (cmd_vector);
1870:
1871: /* No matched command */
1872: if (vector_slot (matchvec, 0) == NULL)
1873: {
1874: vector_free (matchvec);
1875:
1876: /* In case of 'command \t' pattern. Do you need '?' command at
1877: the end of the line. */
1878: if (vector_slot (vline, index) == '\0')
1879: *status = CMD_ERR_NOTHING_TODO;
1880: else
1881: *status = CMD_ERR_NO_MATCH;
1882: return NULL;
1883: }
1884:
1885: /* Only one matched */
1886: if (vector_slot (matchvec, 1) == NULL)
1887: {
1888: match_str = (char **) matchvec->index;
1889: vector_only_wrapper_free (matchvec);
1890: *status = CMD_COMPLETE_FULL_MATCH;
1891: return match_str;
1892: }
1893: /* Make it sure last element is NULL. */
1894: vector_set (matchvec, NULL);
1895:
1896: /* Check LCD of matched strings. */
1897: if (vector_slot (vline, index) != NULL)
1898: {
1899: lcd = cmd_lcd ((char **) matchvec->index);
1900:
1901: if (lcd)
1902: {
1903: int len = strlen (vector_slot (vline, index));
1904:
1905: if (len < lcd)
1906: {
1907: char *lcdstr;
1908:
1909: lcdstr = XMALLOC (MTYPE_STRVEC, lcd + 1);
1910: memcpy (lcdstr, matchvec->index[0], lcd);
1911: lcdstr[lcd] = '\0';
1912:
1913: /* match_str = (char **) &lcdstr; */
1914:
1915: /* Free matchvec. */
1916: for (i = 0; i < vector_active (matchvec); i++)
1917: {
1918: if (vector_slot (matchvec, i))
1919: XFREE (MTYPE_STRVEC, vector_slot (matchvec, i));
1920: }
1921: vector_free (matchvec);
1922:
1923: /* Make new matchvec. */
1924: matchvec = vector_init (INIT_MATCHVEC_SIZE);
1925: vector_set (matchvec, lcdstr);
1926: match_str = (char **) matchvec->index;
1927: vector_only_wrapper_free (matchvec);
1928:
1929: *status = CMD_COMPLETE_MATCH;
1930: return match_str;
1931: }
1932: }
1933: }
1934:
1935: match_str = (char **) matchvec->index;
1936: vector_only_wrapper_free (matchvec);
1937: *status = CMD_COMPLETE_LIST_MATCH;
1938: return match_str;
1939: }
1940:
1941: char **
1942: cmd_complete_command (vector vline, struct vty *vty, int *status)
1943: {
1944: char **ret;
1945:
1946: if ( cmd_try_do_shortcut(vty->node, vector_slot(vline, 0) ) )
1947: {
1948: enum node_type onode;
1949: vector shifted_vline;
1950: unsigned int index;
1951:
1952: onode = vty->node;
1953: vty->node = ENABLE_NODE;
1954: /* We can try it on enable node, cos' the vty is authenticated */
1955:
1956: shifted_vline = vector_init (vector_count(vline));
1957: /* use memcpy? */
1958: for (index = 1; index < vector_active (vline); index++)
1959: {
1960: vector_set_index (shifted_vline, index-1, vector_lookup(vline, index));
1961: }
1962:
1963: ret = cmd_complete_command_real (shifted_vline, vty, status);
1964:
1965: vector_free(shifted_vline);
1966: vty->node = onode;
1967: return ret;
1968: }
1969:
1970:
1971: return cmd_complete_command_real (vline, vty, status);
1972: }
1973:
1974: /* return parent node */
1975: /* MUST eventually converge on CONFIG_NODE */
1976: enum node_type
1977: node_parent ( enum node_type node )
1978: {
1979: enum node_type ret;
1980:
1981: assert (node > CONFIG_NODE);
1982:
1983: switch (node)
1984: {
1985: case BGP_VPNV4_NODE:
1986: case BGP_IPV4_NODE:
1987: case BGP_IPV4M_NODE:
1988: case BGP_IPV6_NODE:
1989: case BGP_IPV6M_NODE:
1990: ret = BGP_NODE;
1991: break;
1992: case KEYCHAIN_KEY_NODE:
1993: ret = KEYCHAIN_NODE;
1994: break;
1995: default:
1996: ret = CONFIG_NODE;
1997: }
1998:
1999: return ret;
2000: }
2001:
2002: /* Execute command by argument vline vector. */
2003: static int
2004: cmd_execute_command_real (vector vline, struct vty *vty,
2005: struct cmd_element **cmd)
2006: {
2007: unsigned int i;
2008: unsigned int index;
2009: vector cmd_vector;
2010: struct cmd_element *cmd_element;
2011: struct cmd_element *matched_element;
2012: unsigned int matched_count, incomplete_count;
2013: int argc;
2014: const char *argv[CMD_ARGC_MAX];
2015: enum match_type match = 0;
2016: int varflag;
2017: char *command;
2018:
2019: /* Make copy of command elements. */
2020: cmd_vector = vector_copy (cmd_node_vector (cmdvec, vty->node));
2021:
2022: for (index = 0; index < vector_active (vline); index++)
2023: if ((command = vector_slot (vline, index)))
2024: {
2025: int ret;
2026:
2027: match = cmd_filter_by_completion (command, cmd_vector, index);
2028:
2029: if (match == vararg_match)
2030: break;
2031:
2032: ret = is_cmd_ambiguous (command, cmd_vector, index, match);
2033:
2034: if (ret == 1)
2035: {
2036: vector_free (cmd_vector);
2037: return CMD_ERR_AMBIGUOUS;
2038: }
2039: else if (ret == 2)
2040: {
2041: vector_free (cmd_vector);
2042: return CMD_ERR_NO_MATCH;
2043: }
2044: }
2045:
2046: /* Check matched count. */
2047: matched_element = NULL;
2048: matched_count = 0;
2049: incomplete_count = 0;
2050:
2051: for (i = 0; i < vector_active (cmd_vector); i++)
2052: if ((cmd_element = vector_slot (cmd_vector, i)))
2053: {
2054: if (match == vararg_match || index >= cmd_element->cmdsize)
2055: {
2056: matched_element = cmd_element;
2057: #if 0
2058: printf ("DEBUG: %s\n", cmd_element->string);
2059: #endif
2060: matched_count++;
2061: }
2062: else
2063: {
2064: incomplete_count++;
2065: }
2066: }
2067:
2068: /* Finish of using cmd_vector. */
2069: vector_free (cmd_vector);
2070:
2071: /* To execute command, matched_count must be 1. */
2072: if (matched_count == 0)
2073: {
2074: if (incomplete_count)
2075: return CMD_ERR_INCOMPLETE;
2076: else
2077: return CMD_ERR_NO_MATCH;
2078: }
2079:
2080: if (matched_count > 1)
2081: return CMD_ERR_AMBIGUOUS;
2082:
2083: /* Argument treatment */
2084: varflag = 0;
2085: argc = 0;
2086:
2087: for (i = 0; i < vector_active (vline); i++)
2088: {
2089: if (varflag)
2090: argv[argc++] = vector_slot (vline, i);
2091: else
2092: {
2093: vector descvec = vector_slot (matched_element->strvec, i);
2094:
2095: if (vector_active (descvec) == 1)
2096: {
2097: struct desc *desc = vector_slot (descvec, 0);
2098:
2099: if (CMD_VARARG (desc->cmd))
2100: varflag = 1;
2101:
2102: if (varflag || CMD_VARIABLE (desc->cmd) || CMD_OPTION (desc->cmd))
2103: argv[argc++] = vector_slot (vline, i);
2104: }
2105: else
2106: argv[argc++] = vector_slot (vline, i);
2107: }
2108:
2109: if (argc >= CMD_ARGC_MAX)
2110: return CMD_ERR_EXEED_ARGC_MAX;
2111: }
2112:
2113: /* For vtysh execution. */
2114: if (cmd)
2115: *cmd = matched_element;
2116:
2117: if (matched_element->daemon)
2118: return CMD_SUCCESS_DAEMON;
2119:
2120: /* Execute matched command. */
2121: return (*matched_element->func) (matched_element, vty, argc, argv);
2122: }
2123:
2124: int
2125: cmd_execute_command (vector vline, struct vty *vty, struct cmd_element **cmd,
2126: int vtysh) {
2127: int ret, saved_ret, tried = 0;
2128: enum node_type onode, try_node;
2129:
2130: onode = try_node = vty->node;
2131:
2132: if ( cmd_try_do_shortcut(vty->node, vector_slot(vline, 0) ) )
2133: {
2134: vector shifted_vline;
2135: unsigned int index;
2136:
2137: vty->node = ENABLE_NODE;
2138: /* We can try it on enable node, cos' the vty is authenticated */
2139:
2140: shifted_vline = vector_init (vector_count(vline));
2141: /* use memcpy? */
2142: for (index = 1; index < vector_active (vline); index++)
2143: {
2144: vector_set_index (shifted_vline, index-1, vector_lookup(vline, index));
2145: }
2146:
2147: ret = cmd_execute_command_real (shifted_vline, vty, cmd);
2148:
2149: vector_free(shifted_vline);
2150: vty->node = onode;
2151: return ret;
2152: }
2153:
2154:
2155: saved_ret = ret = cmd_execute_command_real (vline, vty, cmd);
2156:
2157: if (vtysh)
2158: return saved_ret;
2159:
2160: /* This assumes all nodes above CONFIG_NODE are childs of CONFIG_NODE */
2161: while ( ret != CMD_SUCCESS && ret != CMD_WARNING
2162: && vty->node > CONFIG_NODE )
2163: {
2164: try_node = node_parent(try_node);
2165: vty->node = try_node;
2166: ret = cmd_execute_command_real (vline, vty, cmd);
2167: tried = 1;
2168: if (ret == CMD_SUCCESS || ret == CMD_WARNING)
2169: {
2170: /* succesfull command, leave the node as is */
2171: return ret;
2172: }
2173: }
2174: /* no command succeeded, reset the vty to the original node and
2175: return the error for this node */
2176: if ( tried )
2177: vty->node = onode;
2178: return saved_ret;
2179: }
2180:
2181: /* Execute command by argument readline. */
2182: int
2183: cmd_execute_command_strict (vector vline, struct vty *vty,
2184: struct cmd_element **cmd)
2185: {
2186: unsigned int i;
2187: unsigned int index;
2188: vector cmd_vector;
2189: struct cmd_element *cmd_element;
2190: struct cmd_element *matched_element;
2191: unsigned int matched_count, incomplete_count;
2192: int argc;
2193: const char *argv[CMD_ARGC_MAX];
2194: int varflag;
2195: enum match_type match = 0;
2196: char *command;
2197:
2198: /* Make copy of command element */
2199: cmd_vector = vector_copy (cmd_node_vector (cmdvec, vty->node));
2200:
2201: for (index = 0; index < vector_active (vline); index++)
2202: if ((command = vector_slot (vline, index)))
2203: {
2204: int ret;
2205:
2206: match = cmd_filter_by_string (vector_slot (vline, index),
2207: cmd_vector, index);
2208:
2209: /* If command meets '.VARARG' then finish matching. */
2210: if (match == vararg_match)
2211: break;
2212:
2213: ret = is_cmd_ambiguous (command, cmd_vector, index, match);
2214: if (ret == 1)
2215: {
2216: vector_free (cmd_vector);
2217: return CMD_ERR_AMBIGUOUS;
2218: }
2219: if (ret == 2)
2220: {
2221: vector_free (cmd_vector);
2222: return CMD_ERR_NO_MATCH;
2223: }
2224: }
2225:
2226: /* Check matched count. */
2227: matched_element = NULL;
2228: matched_count = 0;
2229: incomplete_count = 0;
2230: for (i = 0; i < vector_active (cmd_vector); i++)
2231: if (vector_slot (cmd_vector, i) != NULL)
2232: {
2233: cmd_element = vector_slot (cmd_vector, i);
2234:
2235: if (match == vararg_match || index >= cmd_element->cmdsize)
2236: {
2237: matched_element = cmd_element;
2238: matched_count++;
2239: }
2240: else
2241: incomplete_count++;
2242: }
2243:
2244: /* Finish of using cmd_vector. */
2245: vector_free (cmd_vector);
2246:
2247: /* To execute command, matched_count must be 1. */
2248: if (matched_count == 0)
2249: {
2250: if (incomplete_count)
2251: return CMD_ERR_INCOMPLETE;
2252: else
2253: return CMD_ERR_NO_MATCH;
2254: }
2255:
2256: if (matched_count > 1)
2257: return CMD_ERR_AMBIGUOUS;
2258:
2259: /* Argument treatment */
2260: varflag = 0;
2261: argc = 0;
2262:
2263: for (i = 0; i < vector_active (vline); i++)
2264: {
2265: if (varflag)
2266: argv[argc++] = vector_slot (vline, i);
2267: else
2268: {
2269: vector descvec = vector_slot (matched_element->strvec, i);
2270:
2271: if (vector_active (descvec) == 1)
2272: {
2273: struct desc *desc = vector_slot (descvec, 0);
2274:
2275: if (CMD_VARARG (desc->cmd))
2276: varflag = 1;
2277:
2278: if (varflag || CMD_VARIABLE (desc->cmd) || CMD_OPTION (desc->cmd))
2279: argv[argc++] = vector_slot (vline, i);
2280: }
2281: else
2282: argv[argc++] = vector_slot (vline, i);
2283: }
2284:
2285: if (argc >= CMD_ARGC_MAX)
2286: return CMD_ERR_EXEED_ARGC_MAX;
2287: }
2288:
2289: /* For vtysh execution. */
2290: if (cmd)
2291: *cmd = matched_element;
2292:
2293: if (matched_element->daemon)
2294: return CMD_SUCCESS_DAEMON;
2295:
2296: /* Now execute matched command */
2297: return (*matched_element->func) (matched_element, vty, argc, argv);
2298: }
2299:
2300: /* Configration make from file. */
2301: int
2302: config_from_file (struct vty *vty, FILE *fp)
2303: {
2304: int ret;
2305: vector vline;
2306:
2307: while (fgets (vty->buf, VTY_BUFSIZ, fp))
2308: {
2309: vline = cmd_make_strvec (vty->buf);
2310:
2311: /* In case of comment line */
2312: if (vline == NULL)
2313: continue;
2314: /* Execute configuration command : this is strict match */
2315: ret = cmd_execute_command_strict (vline, vty, NULL);
2316:
2317: /* Try again with setting node to CONFIG_NODE */
2318: while (ret != CMD_SUCCESS && ret != CMD_WARNING
2319: && ret != CMD_ERR_NOTHING_TODO && vty->node != CONFIG_NODE)
2320: {
2321: vty->node = node_parent(vty->node);
2322: ret = cmd_execute_command_strict (vline, vty, NULL);
2323: }
2324:
2325: cmd_free_strvec (vline);
2326:
2327: if (ret != CMD_SUCCESS && ret != CMD_WARNING
2328: && ret != CMD_ERR_NOTHING_TODO)
2329: return ret;
2330: }
2331: return CMD_SUCCESS;
2332: }
2333:
2334: /* Configration from terminal */
2335: DEFUN (config_terminal,
2336: config_terminal_cmd,
2337: "configure terminal",
2338: "Configuration from vty interface\n"
2339: "Configuration terminal\n")
2340: {
2341: if (vty_config_lock (vty))
2342: vty->node = CONFIG_NODE;
2343: else
2344: {
2345: vty_out (vty, "VTY configuration is locked by other VTY%s", VTY_NEWLINE);
2346: return CMD_WARNING;
2347: }
2348: return CMD_SUCCESS;
2349: }
2350:
2351: /* Enable command */
2352: DEFUN (enable,
2353: config_enable_cmd,
2354: "enable",
2355: "Turn on privileged mode command\n")
2356: {
2357: /* If enable password is NULL, change to ENABLE_NODE */
2358: if ((host.enable == NULL && host.enable_encrypt == NULL) ||
2359: vty->type == VTY_SHELL_SERV)
2360: vty->node = ENABLE_NODE;
2361: else
2362: vty->node = AUTH_ENABLE_NODE;
2363:
2364: return CMD_SUCCESS;
2365: }
2366:
2367: /* Disable command */
2368: DEFUN (disable,
2369: config_disable_cmd,
2370: "disable",
2371: "Turn off privileged mode command\n")
2372: {
2373: if (vty->node == ENABLE_NODE)
2374: vty->node = VIEW_NODE;
2375: return CMD_SUCCESS;
2376: }
2377:
2378: /* Down vty node level. */
2379: DEFUN (config_exit,
2380: config_exit_cmd,
2381: "exit",
2382: "Exit current mode and down to previous mode\n")
2383: {
2384: switch (vty->node)
2385: {
2386: case VIEW_NODE:
2387: case ENABLE_NODE:
2388: case RESTRICTED_NODE:
2389: if (vty_shell (vty))
2390: exit (0);
2391: else
2392: vty->status = VTY_CLOSE;
2393: break;
2394: case CONFIG_NODE:
2395: vty->node = ENABLE_NODE;
2396: vty_config_unlock (vty);
2397: break;
2398: case INTERFACE_NODE:
2399: case ZEBRA_NODE:
2400: case BGP_NODE:
2401: case RIP_NODE:
2402: case RIPNG_NODE:
2403: case OSPF_NODE:
2404: case OSPF6_NODE:
2405: case ISIS_NODE:
2406: case KEYCHAIN_NODE:
2407: case MASC_NODE:
2408: case RMAP_NODE:
2409: case VTY_NODE:
2410: vty->node = CONFIG_NODE;
2411: break;
2412: case BGP_VPNV4_NODE:
2413: case BGP_IPV4_NODE:
2414: case BGP_IPV4M_NODE:
2415: case BGP_IPV6_NODE:
2416: case BGP_IPV6M_NODE:
2417: vty->node = BGP_NODE;
2418: break;
2419: case KEYCHAIN_KEY_NODE:
2420: vty->node = KEYCHAIN_NODE;
2421: break;
2422: default:
2423: break;
2424: }
2425: return CMD_SUCCESS;
2426: }
2427:
2428: /* quit is alias of exit. */
2429: ALIAS (config_exit,
2430: config_quit_cmd,
2431: "quit",
2432: "Exit current mode and down to previous mode\n")
2433:
2434: /* End of configuration. */
2435: DEFUN (config_end,
2436: config_end_cmd,
2437: "end",
2438: "End current mode and change to enable mode.")
2439: {
2440: switch (vty->node)
2441: {
2442: case VIEW_NODE:
2443: case ENABLE_NODE:
2444: case RESTRICTED_NODE:
2445: /* Nothing to do. */
2446: break;
2447: case CONFIG_NODE:
2448: case INTERFACE_NODE:
2449: case ZEBRA_NODE:
2450: case RIP_NODE:
2451: case RIPNG_NODE:
2452: case BGP_NODE:
2453: case BGP_VPNV4_NODE:
2454: case BGP_IPV4_NODE:
2455: case BGP_IPV4M_NODE:
2456: case BGP_IPV6_NODE:
2457: case BGP_IPV6M_NODE:
2458: case RMAP_NODE:
2459: case OSPF_NODE:
2460: case OSPF6_NODE:
2461: case ISIS_NODE:
2462: case KEYCHAIN_NODE:
2463: case KEYCHAIN_KEY_NODE:
2464: case MASC_NODE:
2465: case VTY_NODE:
2466: vty_config_unlock (vty);
2467: vty->node = ENABLE_NODE;
2468: break;
2469: default:
2470: break;
2471: }
2472: return CMD_SUCCESS;
2473: }
2474:
2475: /* Show version. */
2476: DEFUN (show_version,
2477: show_version_cmd,
2478: "show version",
2479: SHOW_STR
2480: "Displays zebra version\n")
2481: {
2482: vty_out (vty, "Quagga %s (%s).%s", QUAGGA_VERSION, host.name?host.name:"",
2483: VTY_NEWLINE);
2484: vty_out (vty, "%s%s", QUAGGA_COPYRIGHT, VTY_NEWLINE);
2485:
2486: return CMD_SUCCESS;
2487: }
2488:
2489: /* Help display function for all node. */
2490: DEFUN (config_help,
2491: config_help_cmd,
2492: "help",
2493: "Description of the interactive help system\n")
2494: {
2495: vty_out (vty,
2496: "Quagga VTY provides advanced help feature. When you need help,%s\
2497: anytime at the command line please press '?'.%s\
2498: %s\
2499: If nothing matches, the help list will be empty and you must backup%s\
2500: until entering a '?' shows the available options.%s\
2501: Two styles of help are provided:%s\
2502: 1. Full help is available when you are ready to enter a%s\
2503: command argument (e.g. 'show ?') and describes each possible%s\
2504: argument.%s\
2505: 2. Partial help is provided when an abbreviated argument is entered%s\
2506: and you want to know what arguments match the input%s\
2507: (e.g. 'show me?'.)%s%s", VTY_NEWLINE, VTY_NEWLINE, VTY_NEWLINE,
2508: VTY_NEWLINE, VTY_NEWLINE, VTY_NEWLINE, VTY_NEWLINE, VTY_NEWLINE,
2509: VTY_NEWLINE, VTY_NEWLINE, VTY_NEWLINE, VTY_NEWLINE, VTY_NEWLINE);
2510: return CMD_SUCCESS;
2511: }
2512:
2513: /* Help display function for all node. */
2514: DEFUN (config_list,
2515: config_list_cmd,
2516: "list",
2517: "Print command list\n")
2518: {
2519: unsigned int i;
2520: struct cmd_node *cnode = vector_slot (cmdvec, vty->node);
2521: struct cmd_element *cmd;
2522:
2523: for (i = 0; i < vector_active (cnode->cmd_vector); i++)
2524: if ((cmd = vector_slot (cnode->cmd_vector, i)) != NULL
2525: && !(cmd->attr == CMD_ATTR_DEPRECATED
2526: || cmd->attr == CMD_ATTR_HIDDEN))
2527: vty_out (vty, " %s%s", cmd->string,
2528: VTY_NEWLINE);
2529: return CMD_SUCCESS;
2530: }
2531:
2532: /* Write current configuration into file. */
2533: DEFUN (config_write_file,
2534: config_write_file_cmd,
2535: "write file",
2536: "Write running configuration to memory, network, or terminal\n"
2537: "Write to configuration file\n")
2538: {
2539: unsigned int i;
2540: int fd;
2541: struct cmd_node *node;
2542: char *config_file;
2543: char *config_file_tmp = NULL;
2544: char *config_file_sav = NULL;
2545: int ret = CMD_WARNING;
2546: struct vty *file_vty;
2547:
2548: /* Check and see if we are operating under vtysh configuration */
2549: if (host.config == NULL)
2550: {
2551: vty_out (vty, "Can't save to configuration file, using vtysh.%s",
2552: VTY_NEWLINE);
2553: return CMD_WARNING;
2554: }
2555:
2556: /* Get filename. */
2557: config_file = host.config;
2558:
2559: config_file_sav =
2560: XMALLOC (MTYPE_TMP, strlen (config_file) + strlen (CONF_BACKUP_EXT) + 1);
2561: strcpy (config_file_sav, config_file);
2562: strcat (config_file_sav, CONF_BACKUP_EXT);
2563:
2564:
2565: config_file_tmp = XMALLOC (MTYPE_TMP, strlen (config_file) + 8);
2566: sprintf (config_file_tmp, "%s.XXXXXX", config_file);
2567:
2568: /* Open file to configuration write. */
2569: fd = mkstemp (config_file_tmp);
2570: if (fd < 0)
2571: {
2572: vty_out (vty, "Can't open configuration file %s.%s", config_file_tmp,
2573: VTY_NEWLINE);
2574: goto finished;
2575: }
2576:
2577: /* Make vty for configuration file. */
2578: file_vty = vty_new ();
2579: file_vty->fd = fd;
2580: file_vty->type = VTY_FILE;
2581:
2582: /* Config file header print. */
2583: vty_out (file_vty, "!\n! Zebra configuration saved from vty\n! ");
2584: vty_time_print (file_vty, 1);
2585: vty_out (file_vty, "!\n");
2586:
2587: for (i = 0; i < vector_active (cmdvec); i++)
2588: if ((node = vector_slot (cmdvec, i)) && node->func)
2589: {
2590: if ((*node->func) (file_vty))
2591: vty_out (file_vty, "!\n");
2592: }
2593: vty_close (file_vty);
2594:
2595: if (unlink (config_file_sav) != 0)
2596: if (errno != ENOENT)
2597: {
2598: vty_out (vty, "Can't unlink backup configuration file %s.%s", config_file_sav,
2599: VTY_NEWLINE);
2600: goto finished;
2601: }
2602: if (link (config_file, config_file_sav) != 0)
2603: {
2604: vty_out (vty, "Can't backup old configuration file %s.%s", config_file_sav,
2605: VTY_NEWLINE);
2606: goto finished;
2607: }
2608: sync ();
2609: if (unlink (config_file) != 0)
2610: {
2611: vty_out (vty, "Can't unlink configuration file %s.%s", config_file,
2612: VTY_NEWLINE);
2613: goto finished;
2614: }
2615: if (link (config_file_tmp, config_file) != 0)
2616: {
2617: vty_out (vty, "Can't save configuration file %s.%s", config_file,
2618: VTY_NEWLINE);
2619: goto finished;
2620: }
2621: sync ();
2622:
2623: if (chmod (config_file, CONFIGFILE_MASK) != 0)
2624: {
2625: vty_out (vty, "Can't chmod configuration file %s: %s (%d).%s",
2626: config_file, safe_strerror(errno), errno, VTY_NEWLINE);
2627: goto finished;
2628: }
2629:
2630: vty_out (vty, "Configuration saved to %s%s", config_file,
2631: VTY_NEWLINE);
2632: ret = CMD_SUCCESS;
2633:
2634: finished:
2635: unlink (config_file_tmp);
2636: XFREE (MTYPE_TMP, config_file_tmp);
2637: XFREE (MTYPE_TMP, config_file_sav);
2638: return ret;
2639: }
2640:
2641: ALIAS (config_write_file,
2642: config_write_cmd,
2643: "write",
2644: "Write running configuration to memory, network, or terminal\n")
2645:
2646: ALIAS (config_write_file,
2647: config_write_memory_cmd,
2648: "write memory",
2649: "Write running configuration to memory, network, or terminal\n"
2650: "Write configuration to the file (same as write file)\n")
2651:
2652: ALIAS (config_write_file,
2653: copy_runningconfig_startupconfig_cmd,
2654: "copy running-config startup-config",
2655: "Copy configuration\n"
2656: "Copy running config to... \n"
2657: "Copy running config to startup config (same as write file)\n")
2658:
2659: /* Write current configuration into the terminal. */
2660: DEFUN (config_write_terminal,
2661: config_write_terminal_cmd,
2662: "write terminal",
2663: "Write running configuration to memory, network, or terminal\n"
2664: "Write to terminal\n")
2665: {
2666: unsigned int i;
2667: struct cmd_node *node;
2668:
2669: if (vty->type == VTY_SHELL_SERV)
2670: {
2671: for (i = 0; i < vector_active (cmdvec); i++)
2672: if ((node = vector_slot (cmdvec, i)) && node->func && node->vtysh)
2673: {
2674: if ((*node->func) (vty))
2675: vty_out (vty, "!%s", VTY_NEWLINE);
2676: }
2677: }
2678: else
2679: {
2680: vty_out (vty, "%sCurrent configuration:%s", VTY_NEWLINE,
2681: VTY_NEWLINE);
2682: vty_out (vty, "!%s", VTY_NEWLINE);
2683:
2684: for (i = 0; i < vector_active (cmdvec); i++)
2685: if ((node = vector_slot (cmdvec, i)) && node->func)
2686: {
2687: if ((*node->func) (vty))
2688: vty_out (vty, "!%s", VTY_NEWLINE);
2689: }
2690: vty_out (vty, "end%s",VTY_NEWLINE);
2691: }
2692: return CMD_SUCCESS;
2693: }
2694:
2695: /* Write current configuration into the terminal. */
2696: ALIAS (config_write_terminal,
2697: show_running_config_cmd,
2698: "show running-config",
2699: SHOW_STR
2700: "running configuration\n")
2701:
2702: /* Write startup configuration into the terminal. */
2703: DEFUN (show_startup_config,
2704: show_startup_config_cmd,
2705: "show startup-config",
2706: SHOW_STR
2707: "Contentes of startup configuration\n")
2708: {
2709: char buf[BUFSIZ];
2710: FILE *confp;
2711:
2712: confp = fopen (host.config, "r");
2713: if (confp == NULL)
2714: {
2715: vty_out (vty, "Can't open configuration file [%s]%s",
2716: host.config, VTY_NEWLINE);
2717: return CMD_WARNING;
2718: }
2719:
2720: while (fgets (buf, BUFSIZ, confp))
2721: {
2722: char *cp = buf;
2723:
2724: while (*cp != '\r' && *cp != '\n' && *cp != '\0')
2725: cp++;
2726: *cp = '\0';
2727:
2728: vty_out (vty, "%s%s", buf, VTY_NEWLINE);
2729: }
2730:
2731: fclose (confp);
2732:
2733: return CMD_SUCCESS;
2734: }
2735:
2736: /* Hostname configuration */
2737: DEFUN (config_hostname,
2738: hostname_cmd,
2739: "hostname WORD",
2740: "Set system's network name\n"
2741: "This system's network name\n")
2742: {
2743: if (!isalpha((int) *argv[0]))
2744: {
2745: vty_out (vty, "Please specify string starting with alphabet%s", VTY_NEWLINE);
2746: return CMD_WARNING;
2747: }
2748:
2749: if (host.name)
2750: XFREE (MTYPE_HOST, host.name);
2751:
2752: host.name = XSTRDUP (MTYPE_HOST, argv[0]);
2753: return CMD_SUCCESS;
2754: }
2755:
2756: DEFUN (config_no_hostname,
2757: no_hostname_cmd,
2758: "no hostname [HOSTNAME]",
2759: NO_STR
2760: "Reset system's network name\n"
2761: "Host name of this router\n")
2762: {
2763: if (host.name)
2764: XFREE (MTYPE_HOST, host.name);
2765: host.name = NULL;
2766: return CMD_SUCCESS;
2767: }
2768:
2769: /* VTY interface password set. */
2770: DEFUN (config_password, password_cmd,
2771: "password (8|) WORD",
2772: "Assign the terminal connection password\n"
2773: "Specifies a HIDDEN password will follow\n"
2774: "dummy string \n"
2775: "The HIDDEN line password string\n")
2776: {
2777: /* Argument check. */
2778: if (argc == 0)
2779: {
2780: vty_out (vty, "Please specify password.%s", VTY_NEWLINE);
2781: return CMD_WARNING;
2782: }
2783:
2784: if (argc == 2)
2785: {
2786: if (*argv[0] == '8')
2787: {
2788: if (host.password)
2789: XFREE (MTYPE_HOST, host.password);
2790: host.password = NULL;
2791: if (host.password_encrypt)
2792: XFREE (MTYPE_HOST, host.password_encrypt);
2793: host.password_encrypt = XSTRDUP (MTYPE_HOST, argv[1]);
2794: return CMD_SUCCESS;
2795: }
2796: else
2797: {
2798: vty_out (vty, "Unknown encryption type.%s", VTY_NEWLINE);
2799: return CMD_WARNING;
2800: }
2801: }
2802:
2803: if (!isalnum ((int) *argv[0]))
2804: {
2805: vty_out (vty,
2806: "Please specify string starting with alphanumeric%s", VTY_NEWLINE);
2807: return CMD_WARNING;
2808: }
2809:
2810: if (host.password)
2811: XFREE (MTYPE_HOST, host.password);
2812: host.password = NULL;
2813:
2814: if (host.encrypt)
2815: {
2816: if (host.password_encrypt)
2817: XFREE (MTYPE_HOST, host.password_encrypt);
2818: host.password_encrypt = XSTRDUP (MTYPE_HOST, zencrypt (argv[0]));
2819: }
2820: else
2821: host.password = XSTRDUP (MTYPE_HOST, argv[0]);
2822:
2823: return CMD_SUCCESS;
2824: }
2825:
2826: ALIAS (config_password, password_text_cmd,
2827: "password LINE",
2828: "Assign the terminal connection password\n"
2829: "The UNENCRYPTED (cleartext) line password\n")
2830:
2831: /* VTY enable password set. */
2832: DEFUN (config_enable_password, enable_password_cmd,
2833: "enable password (8|) WORD",
2834: "Modify enable password parameters\n"
2835: "Assign the privileged level password\n"
2836: "Specifies a HIDDEN password will follow\n"
2837: "dummy string \n"
2838: "The HIDDEN 'enable' password string\n")
2839: {
2840: /* Argument check. */
2841: if (argc == 0)
2842: {
2843: vty_out (vty, "Please specify password.%s", VTY_NEWLINE);
2844: return CMD_WARNING;
2845: }
2846:
2847: /* Crypt type is specified. */
2848: if (argc == 2)
2849: {
2850: if (*argv[0] == '8')
2851: {
2852: if (host.enable)
2853: XFREE (MTYPE_HOST, host.enable);
2854: host.enable = NULL;
2855:
2856: if (host.enable_encrypt)
2857: XFREE (MTYPE_HOST, host.enable_encrypt);
2858: host.enable_encrypt = XSTRDUP (MTYPE_HOST, argv[1]);
2859:
2860: return CMD_SUCCESS;
2861: }
2862: else
2863: {
2864: vty_out (vty, "Unknown encryption type.%s", VTY_NEWLINE);
2865: return CMD_WARNING;
2866: }
2867: }
2868:
2869: if (!isalnum ((int) *argv[0]))
2870: {
2871: vty_out (vty,
2872: "Please specify string starting with alphanumeric%s", VTY_NEWLINE);
2873: return CMD_WARNING;
2874: }
2875:
2876: if (host.enable)
2877: XFREE (MTYPE_HOST, host.enable);
2878: host.enable = NULL;
2879:
2880: /* Plain password input. */
2881: if (host.encrypt)
2882: {
2883: if (host.enable_encrypt)
2884: XFREE (MTYPE_HOST, host.enable_encrypt);
2885: host.enable_encrypt = XSTRDUP (MTYPE_HOST, zencrypt (argv[0]));
2886: }
2887: else
2888: host.enable = XSTRDUP (MTYPE_HOST, argv[0]);
2889:
2890: return CMD_SUCCESS;
2891: }
2892:
2893: ALIAS (config_enable_password,
2894: enable_password_text_cmd,
2895: "enable password LINE",
2896: "Modify enable password parameters\n"
2897: "Assign the privileged level password\n"
2898: "The UNENCRYPTED (cleartext) 'enable' password\n")
2899:
2900: /* VTY enable password delete. */
2901: DEFUN (no_config_enable_password, no_enable_password_cmd,
2902: "no enable password",
2903: NO_STR
2904: "Modify enable password parameters\n"
2905: "Assign the privileged level password\n")
2906: {
2907: if (host.enable)
2908: XFREE (MTYPE_HOST, host.enable);
2909: host.enable = NULL;
2910:
2911: if (host.enable_encrypt)
2912: XFREE (MTYPE_HOST, host.enable_encrypt);
2913: host.enable_encrypt = NULL;
2914:
2915: return CMD_SUCCESS;
2916: }
2917:
2918: DEFUN (service_password_encrypt,
2919: service_password_encrypt_cmd,
2920: "service password-encryption",
2921: "Set up miscellaneous service\n"
2922: "Enable encrypted passwords\n")
2923: {
2924: if (host.encrypt)
2925: return CMD_SUCCESS;
2926:
2927: host.encrypt = 1;
2928:
2929: if (host.password)
2930: {
2931: if (host.password_encrypt)
2932: XFREE (MTYPE_HOST, host.password_encrypt);
2933: host.password_encrypt = XSTRDUP (MTYPE_HOST, zencrypt (host.password));
2934: }
2935: if (host.enable)
2936: {
2937: if (host.enable_encrypt)
2938: XFREE (MTYPE_HOST, host.enable_encrypt);
2939: host.enable_encrypt = XSTRDUP (MTYPE_HOST, zencrypt (host.enable));
2940: }
2941:
2942: return CMD_SUCCESS;
2943: }
2944:
2945: DEFUN (no_service_password_encrypt,
2946: no_service_password_encrypt_cmd,
2947: "no service password-encryption",
2948: NO_STR
2949: "Set up miscellaneous service\n"
2950: "Enable encrypted passwords\n")
2951: {
2952: if (! host.encrypt)
2953: return CMD_SUCCESS;
2954:
2955: host.encrypt = 0;
2956:
2957: if (host.password_encrypt)
2958: XFREE (MTYPE_HOST, host.password_encrypt);
2959: host.password_encrypt = NULL;
2960:
2961: if (host.enable_encrypt)
2962: XFREE (MTYPE_HOST, host.enable_encrypt);
2963: host.enable_encrypt = NULL;
2964:
2965: return CMD_SUCCESS;
2966: }
2967:
2968: DEFUN (config_terminal_length, config_terminal_length_cmd,
2969: "terminal length <0-512>",
2970: "Set terminal line parameters\n"
2971: "Set number of lines on a screen\n"
2972: "Number of lines on screen (0 for no pausing)\n")
2973: {
2974: int lines;
2975: char *endptr = NULL;
2976:
2977: lines = strtol (argv[0], &endptr, 10);
2978: if (lines < 0 || lines > 512 || *endptr != '\0')
2979: {
2980: vty_out (vty, "length is malformed%s", VTY_NEWLINE);
2981: return CMD_WARNING;
2982: }
2983: vty->lines = lines;
2984:
2985: return CMD_SUCCESS;
2986: }
2987:
2988: DEFUN (config_terminal_no_length, config_terminal_no_length_cmd,
2989: "terminal no length",
2990: "Set terminal line parameters\n"
2991: NO_STR
2992: "Set number of lines on a screen\n")
2993: {
2994: vty->lines = -1;
2995: return CMD_SUCCESS;
2996: }
2997:
2998: DEFUN (service_terminal_length, service_terminal_length_cmd,
2999: "service terminal-length <0-512>",
3000: "Set up miscellaneous service\n"
3001: "System wide terminal length configuration\n"
3002: "Number of lines of VTY (0 means no line control)\n")
3003: {
3004: int lines;
3005: char *endptr = NULL;
3006:
3007: lines = strtol (argv[0], &endptr, 10);
3008: if (lines < 0 || lines > 512 || *endptr != '\0')
3009: {
3010: vty_out (vty, "length is malformed%s", VTY_NEWLINE);
3011: return CMD_WARNING;
3012: }
3013: host.lines = lines;
3014:
3015: return CMD_SUCCESS;
3016: }
3017:
3018: DEFUN (no_service_terminal_length, no_service_terminal_length_cmd,
3019: "no service terminal-length [<0-512>]",
3020: NO_STR
3021: "Set up miscellaneous service\n"
3022: "System wide terminal length configuration\n"
3023: "Number of lines of VTY (0 means no line control)\n")
3024: {
3025: host.lines = -1;
3026: return CMD_SUCCESS;
3027: }
3028:
3029: DEFUN_HIDDEN (do_echo,
3030: echo_cmd,
3031: "echo .MESSAGE",
3032: "Echo a message back to the vty\n"
3033: "The message to echo\n")
3034: {
3035: char *message;
3036:
3037: vty_out (vty, "%s%s", ((message = argv_concat(argv, argc, 0)) ? message : ""),
3038: VTY_NEWLINE);
3039: if (message)
3040: XFREE(MTYPE_TMP, message);
3041: return CMD_SUCCESS;
3042: }
3043:
3044: DEFUN (config_logmsg,
3045: config_logmsg_cmd,
3046: "logmsg "LOG_LEVELS" .MESSAGE",
3047: "Send a message to enabled logging destinations\n"
3048: LOG_LEVEL_DESC
3049: "The message to send\n")
3050: {
3051: int level;
3052: char *message;
3053:
3054: if ((level = level_match(argv[0])) == ZLOG_DISABLED)
3055: return CMD_ERR_NO_MATCH;
3056:
3057: zlog(NULL, level, "%s", ((message = argv_concat(argv, argc, 1)) ? message : ""));
3058: if (message)
3059: XFREE(MTYPE_TMP, message);
3060: return CMD_SUCCESS;
3061: }
3062:
3063: DEFUN (show_logging,
3064: show_logging_cmd,
3065: "show logging",
3066: SHOW_STR
3067: "Show current logging configuration\n")
3068: {
3069: struct zlog *zl = zlog_default;
3070:
3071: vty_out (vty, "Syslog logging: ");
3072: if (zl->maxlvl[ZLOG_DEST_SYSLOG] == ZLOG_DISABLED)
3073: vty_out (vty, "disabled");
3074: else
3075: vty_out (vty, "level %s, facility %s, ident %s",
3076: zlog_priority[zl->maxlvl[ZLOG_DEST_SYSLOG]],
3077: facility_name(zl->facility), zl->ident);
3078: vty_out (vty, "%s", VTY_NEWLINE);
3079:
3080: vty_out (vty, "Stdout logging: ");
3081: if (zl->maxlvl[ZLOG_DEST_STDOUT] == ZLOG_DISABLED)
3082: vty_out (vty, "disabled");
3083: else
3084: vty_out (vty, "level %s",
3085: zlog_priority[zl->maxlvl[ZLOG_DEST_STDOUT]]);
3086: vty_out (vty, "%s", VTY_NEWLINE);
3087:
3088: vty_out (vty, "Monitor logging: ");
3089: if (zl->maxlvl[ZLOG_DEST_MONITOR] == ZLOG_DISABLED)
3090: vty_out (vty, "disabled");
3091: else
3092: vty_out (vty, "level %s",
3093: zlog_priority[zl->maxlvl[ZLOG_DEST_MONITOR]]);
3094: vty_out (vty, "%s", VTY_NEWLINE);
3095:
3096: vty_out (vty, "File logging: ");
3097: if ((zl->maxlvl[ZLOG_DEST_FILE] == ZLOG_DISABLED) ||
3098: !zl->fp)
3099: vty_out (vty, "disabled");
3100: else
3101: vty_out (vty, "level %s, filename %s",
3102: zlog_priority[zl->maxlvl[ZLOG_DEST_FILE]],
3103: zl->filename);
3104: vty_out (vty, "%s", VTY_NEWLINE);
3105:
3106: vty_out (vty, "Protocol name: %s%s",
3107: zlog_proto_names[zl->protocol], VTY_NEWLINE);
3108: vty_out (vty, "Record priority: %s%s",
3109: (zl->record_priority ? "enabled" : "disabled"), VTY_NEWLINE);
3110: vty_out (vty, "Timestamp precision: %d%s",
3111: zl->timestamp_precision, VTY_NEWLINE);
3112:
3113: return CMD_SUCCESS;
3114: }
3115:
3116: DEFUN (config_log_stdout,
3117: config_log_stdout_cmd,
3118: "log stdout",
3119: "Logging control\n"
3120: "Set stdout logging level\n")
3121: {
3122: zlog_set_level (NULL, ZLOG_DEST_STDOUT, zlog_default->default_lvl);
3123: return CMD_SUCCESS;
3124: }
3125:
3126: DEFUN (config_log_stdout_level,
3127: config_log_stdout_level_cmd,
3128: "log stdout "LOG_LEVELS,
3129: "Logging control\n"
3130: "Set stdout logging level\n"
3131: LOG_LEVEL_DESC)
3132: {
3133: int level;
3134:
3135: if ((level = level_match(argv[0])) == ZLOG_DISABLED)
3136: return CMD_ERR_NO_MATCH;
3137: zlog_set_level (NULL, ZLOG_DEST_STDOUT, level);
3138: return CMD_SUCCESS;
3139: }
3140:
3141: DEFUN (no_config_log_stdout,
3142: no_config_log_stdout_cmd,
3143: "no log stdout [LEVEL]",
3144: NO_STR
3145: "Logging control\n"
3146: "Cancel logging to stdout\n"
3147: "Logging level\n")
3148: {
3149: zlog_set_level (NULL, ZLOG_DEST_STDOUT, ZLOG_DISABLED);
3150: return CMD_SUCCESS;
3151: }
3152:
3153: DEFUN (config_log_monitor,
3154: config_log_monitor_cmd,
3155: "log monitor",
3156: "Logging control\n"
3157: "Set terminal line (monitor) logging level\n")
3158: {
3159: zlog_set_level (NULL, ZLOG_DEST_MONITOR, zlog_default->default_lvl);
3160: return CMD_SUCCESS;
3161: }
3162:
3163: DEFUN (config_log_monitor_level,
3164: config_log_monitor_level_cmd,
3165: "log monitor "LOG_LEVELS,
3166: "Logging control\n"
3167: "Set terminal line (monitor) logging level\n"
3168: LOG_LEVEL_DESC)
3169: {
3170: int level;
3171:
3172: if ((level = level_match(argv[0])) == ZLOG_DISABLED)
3173: return CMD_ERR_NO_MATCH;
3174: zlog_set_level (NULL, ZLOG_DEST_MONITOR, level);
3175: return CMD_SUCCESS;
3176: }
3177:
3178: DEFUN (no_config_log_monitor,
3179: no_config_log_monitor_cmd,
3180: "no log monitor [LEVEL]",
3181: NO_STR
3182: "Logging control\n"
3183: "Disable terminal line (monitor) logging\n"
3184: "Logging level\n")
3185: {
3186: zlog_set_level (NULL, ZLOG_DEST_MONITOR, ZLOG_DISABLED);
3187: return CMD_SUCCESS;
3188: }
3189:
3190: static int
3191: set_log_file(struct vty *vty, const char *fname, int loglevel)
3192: {
3193: int ret;
3194: char *p = NULL;
3195: const char *fullpath;
3196:
3197: /* Path detection. */
3198: if (! IS_DIRECTORY_SEP (*fname))
3199: {
3200: char cwd[MAXPATHLEN+1];
3201: cwd[MAXPATHLEN] = '\0';
3202:
3203: if (getcwd (cwd, MAXPATHLEN) == NULL)
3204: {
3205: zlog_err ("config_log_file: Unable to alloc mem!");
3206: return CMD_WARNING;
3207: }
3208:
3209: if ( (p = XMALLOC (MTYPE_TMP, strlen (cwd) + strlen (fname) + 2))
3210: == NULL)
3211: {
3212: zlog_err ("config_log_file: Unable to alloc mem!");
3213: return CMD_WARNING;
3214: }
3215: sprintf (p, "%s/%s", cwd, fname);
3216: fullpath = p;
3217: }
3218: else
3219: fullpath = fname;
3220:
3221: ret = zlog_set_file (NULL, fullpath, loglevel);
3222:
3223: if (p)
3224: XFREE (MTYPE_TMP, p);
3225:
3226: if (!ret)
3227: {
3228: vty_out (vty, "can't open logfile %s\n", fname);
3229: return CMD_WARNING;
3230: }
3231:
3232: if (host.logfile)
3233: XFREE (MTYPE_HOST, host.logfile);
3234:
3235: host.logfile = XSTRDUP (MTYPE_HOST, fname);
3236:
3237: return CMD_SUCCESS;
3238: }
3239:
3240: DEFUN (config_log_file,
3241: config_log_file_cmd,
3242: "log file FILENAME",
3243: "Logging control\n"
3244: "Logging to file\n"
3245: "Logging filename\n")
3246: {
3247: return set_log_file(vty, argv[0], zlog_default->default_lvl);
3248: }
3249:
3250: DEFUN (config_log_file_level,
3251: config_log_file_level_cmd,
3252: "log file FILENAME "LOG_LEVELS,
3253: "Logging control\n"
3254: "Logging to file\n"
3255: "Logging filename\n"
3256: LOG_LEVEL_DESC)
3257: {
3258: int level;
3259:
3260: if ((level = level_match(argv[1])) == ZLOG_DISABLED)
3261: return CMD_ERR_NO_MATCH;
3262: return set_log_file(vty, argv[0], level);
3263: }
3264:
3265: DEFUN (no_config_log_file,
3266: no_config_log_file_cmd,
3267: "no log file [FILENAME]",
3268: NO_STR
3269: "Logging control\n"
3270: "Cancel logging to file\n"
3271: "Logging file name\n")
3272: {
3273: zlog_reset_file (NULL);
3274:
3275: if (host.logfile)
3276: XFREE (MTYPE_HOST, host.logfile);
3277:
3278: host.logfile = NULL;
3279:
3280: return CMD_SUCCESS;
3281: }
3282:
3283: ALIAS (no_config_log_file,
3284: no_config_log_file_level_cmd,
3285: "no log file FILENAME LEVEL",
3286: NO_STR
3287: "Logging control\n"
3288: "Cancel logging to file\n"
3289: "Logging file name\n"
3290: "Logging level\n")
3291:
3292: DEFUN (config_log_syslog,
3293: config_log_syslog_cmd,
3294: "log syslog",
3295: "Logging control\n"
3296: "Set syslog logging level\n")
3297: {
3298: zlog_set_level (NULL, ZLOG_DEST_SYSLOG, zlog_default->default_lvl);
3299: return CMD_SUCCESS;
3300: }
3301:
3302: DEFUN (config_log_syslog_level,
3303: config_log_syslog_level_cmd,
3304: "log syslog "LOG_LEVELS,
3305: "Logging control\n"
3306: "Set syslog logging level\n"
3307: LOG_LEVEL_DESC)
3308: {
3309: int level;
3310:
3311: if ((level = level_match(argv[0])) == ZLOG_DISABLED)
3312: return CMD_ERR_NO_MATCH;
3313: zlog_set_level (NULL, ZLOG_DEST_SYSLOG, level);
3314: return CMD_SUCCESS;
3315: }
3316:
3317: DEFUN_DEPRECATED (config_log_syslog_facility,
3318: config_log_syslog_facility_cmd,
3319: "log syslog facility "LOG_FACILITIES,
3320: "Logging control\n"
3321: "Logging goes to syslog\n"
3322: "(Deprecated) Facility parameter for syslog messages\n"
3323: LOG_FACILITY_DESC)
3324: {
3325: int facility;
3326:
3327: if ((facility = facility_match(argv[0])) < 0)
3328: return CMD_ERR_NO_MATCH;
3329:
3330: zlog_set_level (NULL, ZLOG_DEST_SYSLOG, zlog_default->default_lvl);
3331: zlog_default->facility = facility;
3332: return CMD_SUCCESS;
3333: }
3334:
3335: DEFUN (no_config_log_syslog,
3336: no_config_log_syslog_cmd,
3337: "no log syslog [LEVEL]",
3338: NO_STR
3339: "Logging control\n"
3340: "Cancel logging to syslog\n"
3341: "Logging level\n")
3342: {
3343: zlog_set_level (NULL, ZLOG_DEST_SYSLOG, ZLOG_DISABLED);
3344: return CMD_SUCCESS;
3345: }
3346:
3347: ALIAS (no_config_log_syslog,
3348: no_config_log_syslog_facility_cmd,
3349: "no log syslog facility "LOG_FACILITIES,
3350: NO_STR
3351: "Logging control\n"
3352: "Logging goes to syslog\n"
3353: "Facility parameter for syslog messages\n"
3354: LOG_FACILITY_DESC)
3355:
3356: DEFUN (config_log_facility,
3357: config_log_facility_cmd,
3358: "log facility "LOG_FACILITIES,
3359: "Logging control\n"
3360: "Facility parameter for syslog messages\n"
3361: LOG_FACILITY_DESC)
3362: {
3363: int facility;
3364:
3365: if ((facility = facility_match(argv[0])) < 0)
3366: return CMD_ERR_NO_MATCH;
3367: zlog_default->facility = facility;
3368: return CMD_SUCCESS;
3369: }
3370:
3371: DEFUN (no_config_log_facility,
3372: no_config_log_facility_cmd,
3373: "no log facility [FACILITY]",
3374: NO_STR
3375: "Logging control\n"
3376: "Reset syslog facility to default (daemon)\n"
3377: "Syslog facility\n")
3378: {
3379: zlog_default->facility = LOG_DAEMON;
3380: return CMD_SUCCESS;
3381: }
3382:
3383: DEFUN_DEPRECATED (config_log_trap,
3384: config_log_trap_cmd,
3385: "log trap "LOG_LEVELS,
3386: "Logging control\n"
3387: "(Deprecated) Set logging level and default for all destinations\n"
3388: LOG_LEVEL_DESC)
3389: {
3390: int new_level ;
3391: int i;
3392:
3393: if ((new_level = level_match(argv[0])) == ZLOG_DISABLED)
3394: return CMD_ERR_NO_MATCH;
3395:
3396: zlog_default->default_lvl = new_level;
3397: for (i = 0; i < ZLOG_NUM_DESTS; i++)
3398: if (zlog_default->maxlvl[i] != ZLOG_DISABLED)
3399: zlog_default->maxlvl[i] = new_level;
3400: return CMD_SUCCESS;
3401: }
3402:
3403: DEFUN_DEPRECATED (no_config_log_trap,
3404: no_config_log_trap_cmd,
3405: "no log trap [LEVEL]",
3406: NO_STR
3407: "Logging control\n"
3408: "Permit all logging information\n"
3409: "Logging level\n")
3410: {
3411: zlog_default->default_lvl = LOG_DEBUG;
3412: return CMD_SUCCESS;
3413: }
3414:
3415: DEFUN (config_log_record_priority,
3416: config_log_record_priority_cmd,
3417: "log record-priority",
3418: "Logging control\n"
3419: "Log the priority of the message within the message\n")
3420: {
3421: zlog_default->record_priority = 1 ;
3422: return CMD_SUCCESS;
3423: }
3424:
3425: DEFUN (no_config_log_record_priority,
3426: no_config_log_record_priority_cmd,
3427: "no log record-priority",
3428: NO_STR
3429: "Logging control\n"
3430: "Do not log the priority of the message within the message\n")
3431: {
3432: zlog_default->record_priority = 0 ;
3433: return CMD_SUCCESS;
3434: }
3435:
3436: DEFUN (config_log_timestamp_precision,
3437: config_log_timestamp_precision_cmd,
3438: "log timestamp precision <0-6>",
3439: "Logging control\n"
3440: "Timestamp configuration\n"
3441: "Set the timestamp precision\n"
3442: "Number of subsecond digits\n")
3443: {
3444: if (argc != 1)
3445: {
3446: vty_out (vty, "Insufficient arguments%s", VTY_NEWLINE);
3447: return CMD_WARNING;
3448: }
3449:
3450: VTY_GET_INTEGER_RANGE("Timestamp Precision",
3451: zlog_default->timestamp_precision, argv[0], 0, 6);
3452: return CMD_SUCCESS;
3453: }
3454:
3455: DEFUN (no_config_log_timestamp_precision,
3456: no_config_log_timestamp_precision_cmd,
3457: "no log timestamp precision",
3458: NO_STR
3459: "Logging control\n"
3460: "Timestamp configuration\n"
3461: "Reset the timestamp precision to the default value of 0\n")
3462: {
3463: zlog_default->timestamp_precision = 0 ;
3464: return CMD_SUCCESS;
3465: }
3466:
3467: DEFUN (banner_motd_file,
3468: banner_motd_file_cmd,
3469: "banner motd file [FILE]",
3470: "Set banner\n"
3471: "Banner for motd\n"
3472: "Banner from a file\n"
3473: "Filename\n")
3474: {
3475: if (host.motdfile)
3476: XFREE (MTYPE_HOST, host.motdfile);
3477: host.motdfile = XSTRDUP (MTYPE_HOST, argv[0]);
3478:
3479: return CMD_SUCCESS;
3480: }
3481:
3482: DEFUN (banner_motd_default,
3483: banner_motd_default_cmd,
3484: "banner motd default",
3485: "Set banner string\n"
3486: "Strings for motd\n"
3487: "Default string\n")
3488: {
3489: host.motd = default_motd;
3490: return CMD_SUCCESS;
3491: }
3492:
3493: DEFUN (no_banner_motd,
3494: no_banner_motd_cmd,
3495: "no banner motd",
3496: NO_STR
3497: "Set banner string\n"
3498: "Strings for motd\n")
3499: {
3500: host.motd = NULL;
3501: if (host.motdfile)
3502: XFREE (MTYPE_HOST, host.motdfile);
3503: host.motdfile = NULL;
3504: return CMD_SUCCESS;
3505: }
3506:
3507: /* Set config filename. Called from vty.c */
3508: void
3509: host_config_set (char *filename)
3510: {
3511: if (host.config)
3512: XFREE (MTYPE_HOST, host.config);
3513: host.config = XSTRDUP (MTYPE_HOST, filename);
3514: }
3515:
3516: void
3517: install_default (enum node_type node)
3518: {
3519: install_element (node, &config_exit_cmd);
3520: install_element (node, &config_quit_cmd);
3521: install_element (node, &config_end_cmd);
3522: install_element (node, &config_help_cmd);
3523: install_element (node, &config_list_cmd);
3524:
3525: install_element (node, &config_write_terminal_cmd);
3526: install_element (node, &config_write_file_cmd);
3527: install_element (node, &config_write_memory_cmd);
3528: install_element (node, &config_write_cmd);
3529: install_element (node, &show_running_config_cmd);
3530: }
3531:
3532: /* Initialize command interface. Install basic nodes and commands. */
3533: void
3534: cmd_init (int terminal)
3535: {
3536: command_cr = XSTRDUP(MTYPE_STRVEC, "<cr>");
3537: desc_cr.cmd = command_cr;
3538: desc_cr.str = XSTRDUP(MTYPE_STRVEC, "");
3539:
3540: /* Allocate initial top vector of commands. */
3541: cmdvec = vector_init (VECTOR_MIN_SIZE);
3542:
3543: /* Default host value settings. */
3544: host.name = NULL;
3545: host.password = NULL;
3546: host.enable = NULL;
3547: host.logfile = NULL;
3548: host.config = NULL;
3549: host.lines = -1;
3550: host.motd = default_motd;
3551: host.motdfile = NULL;
3552:
3553: /* Install top nodes. */
3554: install_node (&view_node, NULL);
3555: install_node (&enable_node, NULL);
3556: install_node (&auth_node, NULL);
3557: install_node (&auth_enable_node, NULL);
3558: install_node (&restricted_node, NULL);
3559: install_node (&config_node, config_write_host);
3560:
3561: /* Each node's basic commands. */
3562: install_element (VIEW_NODE, &show_version_cmd);
3563: if (terminal)
3564: {
3565: install_element (VIEW_NODE, &config_list_cmd);
3566: install_element (VIEW_NODE, &config_exit_cmd);
3567: install_element (VIEW_NODE, &config_quit_cmd);
3568: install_element (VIEW_NODE, &config_help_cmd);
3569: install_element (VIEW_NODE, &config_enable_cmd);
3570: install_element (VIEW_NODE, &config_terminal_length_cmd);
3571: install_element (VIEW_NODE, &config_terminal_no_length_cmd);
3572: install_element (VIEW_NODE, &show_logging_cmd);
3573: install_element (VIEW_NODE, &echo_cmd);
3574:
3575: install_element (RESTRICTED_NODE, &config_list_cmd);
3576: install_element (RESTRICTED_NODE, &config_exit_cmd);
3577: install_element (RESTRICTED_NODE, &config_quit_cmd);
3578: install_element (RESTRICTED_NODE, &config_help_cmd);
3579: install_element (RESTRICTED_NODE, &config_enable_cmd);
3580: install_element (RESTRICTED_NODE, &config_terminal_length_cmd);
3581: install_element (RESTRICTED_NODE, &config_terminal_no_length_cmd);
3582: install_element (RESTRICTED_NODE, &echo_cmd);
3583: }
3584:
3585: if (terminal)
3586: {
3587: install_default (ENABLE_NODE);
3588: install_element (ENABLE_NODE, &config_disable_cmd);
3589: install_element (ENABLE_NODE, &config_terminal_cmd);
3590: install_element (ENABLE_NODE, ©_runningconfig_startupconfig_cmd);
3591: }
3592: install_element (ENABLE_NODE, &show_startup_config_cmd);
3593: install_element (ENABLE_NODE, &show_version_cmd);
3594:
3595: if (terminal)
3596: {
3597: install_element (ENABLE_NODE, &config_terminal_length_cmd);
3598: install_element (ENABLE_NODE, &config_terminal_no_length_cmd);
3599: install_element (ENABLE_NODE, &show_logging_cmd);
3600: install_element (ENABLE_NODE, &echo_cmd);
3601: install_element (ENABLE_NODE, &config_logmsg_cmd);
3602:
3603: install_default (CONFIG_NODE);
3604: }
3605:
3606: install_element (CONFIG_NODE, &hostname_cmd);
3607: install_element (CONFIG_NODE, &no_hostname_cmd);
3608:
3609: if (terminal)
3610: {
3611: install_element (CONFIG_NODE, &password_cmd);
3612: install_element (CONFIG_NODE, &password_text_cmd);
3613: install_element (CONFIG_NODE, &enable_password_cmd);
3614: install_element (CONFIG_NODE, &enable_password_text_cmd);
3615: install_element (CONFIG_NODE, &no_enable_password_cmd);
3616:
3617: install_element (CONFIG_NODE, &config_log_stdout_cmd);
3618: install_element (CONFIG_NODE, &config_log_stdout_level_cmd);
3619: install_element (CONFIG_NODE, &no_config_log_stdout_cmd);
3620: install_element (CONFIG_NODE, &config_log_monitor_cmd);
3621: install_element (CONFIG_NODE, &config_log_monitor_level_cmd);
3622: install_element (CONFIG_NODE, &no_config_log_monitor_cmd);
3623: install_element (CONFIG_NODE, &config_log_file_cmd);
3624: install_element (CONFIG_NODE, &config_log_file_level_cmd);
3625: install_element (CONFIG_NODE, &no_config_log_file_cmd);
3626: install_element (CONFIG_NODE, &no_config_log_file_level_cmd);
3627: install_element (CONFIG_NODE, &config_log_syslog_cmd);
3628: install_element (CONFIG_NODE, &config_log_syslog_level_cmd);
3629: install_element (CONFIG_NODE, &config_log_syslog_facility_cmd);
3630: install_element (CONFIG_NODE, &no_config_log_syslog_cmd);
3631: install_element (CONFIG_NODE, &no_config_log_syslog_facility_cmd);
3632: install_element (CONFIG_NODE, &config_log_facility_cmd);
3633: install_element (CONFIG_NODE, &no_config_log_facility_cmd);
3634: install_element (CONFIG_NODE, &config_log_trap_cmd);
3635: install_element (CONFIG_NODE, &no_config_log_trap_cmd);
3636: install_element (CONFIG_NODE, &config_log_record_priority_cmd);
3637: install_element (CONFIG_NODE, &no_config_log_record_priority_cmd);
3638: install_element (CONFIG_NODE, &config_log_timestamp_precision_cmd);
3639: install_element (CONFIG_NODE, &no_config_log_timestamp_precision_cmd);
3640: install_element (CONFIG_NODE, &service_password_encrypt_cmd);
3641: install_element (CONFIG_NODE, &no_service_password_encrypt_cmd);
3642: install_element (CONFIG_NODE, &banner_motd_default_cmd);
3643: install_element (CONFIG_NODE, &banner_motd_file_cmd);
3644: install_element (CONFIG_NODE, &no_banner_motd_cmd);
3645: install_element (CONFIG_NODE, &service_terminal_length_cmd);
3646: install_element (CONFIG_NODE, &no_service_terminal_length_cmd);
3647:
3648: install_element (VIEW_NODE, &show_thread_cpu_cmd);
3649: install_element (ENABLE_NODE, &show_thread_cpu_cmd);
3650: install_element (RESTRICTED_NODE, &show_thread_cpu_cmd);
3651:
3652: install_element (ENABLE_NODE, &clear_thread_cpu_cmd);
3653: install_element (VIEW_NODE, &show_work_queues_cmd);
3654: install_element (ENABLE_NODE, &show_work_queues_cmd);
3655: }
3656: srand(time(NULL));
3657: }
3658:
3659: void
3660: cmd_terminate ()
3661: {
3662: unsigned int i, j, k, l;
3663: struct cmd_node *cmd_node;
3664: struct cmd_element *cmd_element;
3665: struct desc *desc;
3666: vector cmd_node_v, cmd_element_v, desc_v;
3667:
3668: if (cmdvec)
3669: {
3670: for (i = 0; i < vector_active (cmdvec); i++)
3671: if ((cmd_node = vector_slot (cmdvec, i)) != NULL)
3672: {
3673: cmd_node_v = cmd_node->cmd_vector;
3674:
3675: for (j = 0; j < vector_active (cmd_node_v); j++)
3676: if ((cmd_element = vector_slot (cmd_node_v, j)) != NULL &&
3677: cmd_element->strvec != NULL)
3678: {
3679: cmd_element_v = cmd_element->strvec;
3680:
3681: for (k = 0; k < vector_active (cmd_element_v); k++)
3682: if ((desc_v = vector_slot (cmd_element_v, k)) != NULL)
3683: {
3684: for (l = 0; l < vector_active (desc_v); l++)
3685: if ((desc = vector_slot (desc_v, l)) != NULL)
3686: {
3687: if (desc->cmd)
3688: XFREE (MTYPE_STRVEC, desc->cmd);
3689: if (desc->str)
3690: XFREE (MTYPE_STRVEC, desc->str);
3691:
3692: XFREE (MTYPE_DESC, desc);
3693: }
3694: vector_free (desc_v);
3695: }
3696:
3697: cmd_element->strvec = NULL;
3698: vector_free (cmd_element_v);
3699: }
3700:
3701: vector_free (cmd_node_v);
3702: }
3703:
3704: vector_free (cmdvec);
3705: cmdvec = NULL;
3706: }
3707:
3708: if (command_cr)
3709: XFREE(MTYPE_STRVEC, command_cr);
3710: if (desc_cr.str)
3711: XFREE(MTYPE_STRVEC, desc_cr.str);
3712: if (host.name)
3713: XFREE (MTYPE_HOST, host.name);
3714: if (host.password)
3715: XFREE (MTYPE_HOST, host.password);
3716: if (host.password_encrypt)
3717: XFREE (MTYPE_HOST, host.password_encrypt);
3718: if (host.enable)
3719: XFREE (MTYPE_HOST, host.enable);
3720: if (host.enable_encrypt)
3721: XFREE (MTYPE_HOST, host.enable_encrypt);
3722: if (host.logfile)
3723: XFREE (MTYPE_HOST, host.logfile);
3724: if (host.motdfile)
3725: XFREE (MTYPE_HOST, host.motdfile);
3726: if (host.config)
3727: XFREE (MTYPE_HOST, host.config);
3728: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to command.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / lib