src/client/lldpcli.c

   1 /* -*- mode: c; c-file-style: "openbsd" -*- */
   2 /*
   3  * Copyright (c) 2008 Vincent Bernat <bernat@luffy.cx>
   4  *
   5  * Permission to use, copy, modify, and/or distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  16  */
  17
  18
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <unistd.h>
  22 #include <time.h>
  23 #include <errno.h>
  24 #include <string.h>
  25 #include <sys/types.h>
  26 #include <sys/stat.h>
  27 #include <sys/socket.h>
  28 #include <sys/un.h>
  29 #include <arpa/inet.h>
  30 #include <libgen.h>
  31 #include <dirent.h>
  32 #include <signal.h>
  33 #include <sys/queue.h>
  34
  35 #include "client.h"
  36
  37 #ifdef HAVE___PROGNAME
  38 extern const char       *__progname;
  39 #else
  40 # define __progname "lldpcli"
  41 #endif
  42
  43 /* Global for completion */
  44 static struct cmd_node *root = NULL;
  45 const char *ctlname = NULL;
  46
  47 static int
  48 is_lldpctl(const char *name)
  49 {
  50         static int last_result = -1;
  51         if (last_result == -1 && name) {
  52                 char *basec = strdup(name);
  53                 if (!basec) return 0;
  54                 char *bname = basename(basec);
  55                 last_result = (!strcmp(bname, "lldpctl"));
  56                 free(basec);
  57         }
  58         return (last_result == -1)?0:last_result;
  59 }
  60
  61 static void
  62 usage()
  63 {
  64         fprintf(stderr, "Usage:   %s [OPTIONS ...] [COMMAND ...]\n", __progname);
  65         fprintf(stderr, "Version: %s\n", PACKAGE_STRING);
  66
  67         fprintf(stderr, "\n");
  68
  69         fprintf(stderr, "-d          Enable more debugging information.\n");
  70         fprintf(stderr, "-u socket   Specify the Unix-domain socket used for communication with lldpd(8).\n");
  71         fprintf(stderr, "-f format   Choose output format (plain, keyvalue or xml).\n");
  72         if (!is_lldpctl(NULL))
  73                 fprintf(stderr, "-c conf     Read the provided configuration file.\n");
  74
  75         fprintf(stderr, "\n");
  76
  77         fprintf(stderr, "see manual page lldpcli(8) for more information\n");
  78         exit(1);
  79 }
  80
  81 static int
  82 is_privileged()
  83 {
  84         /* Check we can access the control socket with read/write
  85          * privileges. The `access()` function uses the real UID and real GID,
  86          * therefore we don't have to mangle with our identity. */
  87         return (ctlname && access(ctlname, R_OK|W_OK) == 0);
  88 }
  89
  90 static char*
  91 prompt()
  92 {
  93 #define CESC "\033"
  94         int privileged = is_privileged();
  95         if (isatty(STDIN_FILENO)) {
  96                 if (privileged)
  97                         return "[lldpcli] # ";
  98                 return "[lldpcli] $ ";
  99         }
 100         return "";
 101 }
 102
 103 static int must_exit = 0;
 104 /**
 105  * Exit the interpreter.
 106  */
 107 static int
 108 cmd_exit(struct lldpctl_conn_t *conn, struct writer *w,
 109     struct cmd_env *env, void *arg)
 110 {
 111         log_info("lldpctl", "quit lldpcli");
 112         must_exit = 1;
 113         return 1;
 114 }
 115
 116 /**
 117  * Send an "update" request.
 118  */
 119 static int
 120 cmd_update(struct lldpctl_conn_t *conn, struct writer *w,
 121     struct cmd_env *env, void *arg)
 122 {
 123         log_info("lldpctl", "ask for global update");
 124
 125         lldpctl_atom_t *config = lldpctl_get_configuration(conn);
 126         if (config == NULL) {
 127                 log_warnx("lldpctl", "unable to get configuration from lldpd. %s",
 128                     lldpctl_last_strerror(conn));
 129                 return 0;
 130         }
 131         if (lldpctl_atom_set_int(config,
 132                 lldpctl_k_config_tx_interval, -1) == NULL) {
 133                 log_warnx("lldpctl", "unable to ask lldpd for immediate retransmission. %s",
 134                     lldpctl_last_strerror(conn));
 135                 lldpctl_atom_dec_ref(config);
 136                 return 0;
 137         }
 138         log_info("lldpctl", "immediate retransmission requested successfuly");
 139         lldpctl_atom_dec_ref(config);
 140         return 1;
 141 }
 142
 143 /**
 144  * Pause or resume execution of lldpd.
 145  *
 146  * @param conn    The connection to lldpd.
 147  * @param pause   1 if we want to pause lldpd, 0 otherwise
 148  * @return 1 on success, 0 on error
 149  */
 150 static int
 151 cmd_pause_resume(lldpctl_conn_t *conn, int pause)
 152 {
 153         lldpctl_atom_t *config = lldpctl_get_configuration(conn);
 154         if (config == NULL) {
 155                 log_warnx("lldpctl", "unable to get configuration from lldpd. %s",
 156                     lldpctl_last_strerror(conn));
 157                 return 0;
 158         }
 159         if (lldpctl_atom_get_int(config, lldpctl_k_config_paused) == pause) {
 160                 log_debug("lldpctl", "lldpd is already %s",
 161                     pause?"paused":"resumed");
 162                 lldpctl_atom_dec_ref(config);
 163                 return 1;
 164         }
 165         if (lldpctl_atom_set_int(config,
 166                 lldpctl_k_config_paused, pause) == NULL) {
 167                 log_warnx("lldpctl", "unable to ask lldpd to %s operations. %s",
 168                     pause?"pause":"resume",
 169                     lldpctl_last_strerror(conn));
 170                 lldpctl_atom_dec_ref(config);
 171                 return 0;
 172         }
 173         log_info("lldpctl", "lldpd should %s operations",
 174             pause?"pause":"resume");
 175         lldpctl_atom_dec_ref(config);
 176         return 1;
 177 }
 178 static int
 179 cmd_pause(struct lldpctl_conn_t *conn, struct writer *w,
 180     struct cmd_env *env, void *arg) {
 181         (void)w; (void)env;
 182         return cmd_pause_resume(conn, 1);
 183 }
 184 static int
 185 cmd_resume(struct lldpctl_conn_t *conn, struct writer *w,
 186     struct cmd_env *env, void *arg) {
 187         (void)w; (void)env;
 188         return cmd_pause_resume(conn, 0);
 189 }
 190
 191
 192 #ifdef HAVE_LIBREADLINE
 193 static int
 194 _cmd_complete(int all)
 195 {
 196         char **argv = NULL;
 197         int argc = 0;
 198         int rc = 1;
 199         size_t len = strlen(rl_line_buffer);
 200         char *line = malloc(len + 2);
 201         if (!line) return -1;
 202         strlcpy(line, rl_line_buffer, len + 2);
 203         line[rl_point]   = 2;   /* empty character, will force a word */
 204         line[rl_point+1] = 0;
 205
 206         if (tokenize_line(line, &argc, &argv) != 0)
 207                 goto end;
 208
 209         char *compl = commands_complete(root, argc, (const char **)argv, all, is_privileged());
 210         if (compl && strlen(argv[argc-1]) < strlen(compl)) {
 211                 if (rl_insert_text(compl + strlen(argv[argc-1])) < 0) {
 212                         free(compl);
 213                         goto end;
 214                 }
 215                 free(compl);
 216                 rc = 0;
 217                 goto end;
 218         }
 219         /* No completion or several completion available. */
 220         free(compl);
 221         fprintf(stderr, "\n");
 222         rl_forced_update_display();
 223         rc = 0;
 224 end:
 225         free(line);
 226         tokenize_free(argc, argv);
 227         return rc;
 228 }
 229
 230 static int
 231 cmd_complete(int count, int ch)
 232 {
 233         return _cmd_complete(0);
 234 }
 235
 236 static int
 237 cmd_help(int count, int ch)
 238 {
 239         return _cmd_complete(1);
 240 }
 241 #else
 242 static char*
 243 readline(const char *p)
 244 {
 245         static char line[2048];
 246         fprintf(stderr, "%s", p);
 247         fflush(stderr);
 248         if (fgets(line, sizeof(line) - 2, stdin) == NULL)
 249                 return NULL;
 250         return line;
 251 }
 252 #endif
 253
 254 /**
 255  * Execute a tokenized command and display its output.
 256  *
 257  * @param conn The connection to lldpd.
 258  * @param fmt  Output format.
 259  * @param argc Number of arguments.
 260  * @param argv Array of arguments.
 261  * @return 0 if an error occurred, 1 otherwise
 262  */
 263 static int
 264 cmd_exec(lldpctl_conn_t *conn, const char *fmt, int argc, const char **argv)
 265 {
 266         /* Init output formatter */
 267         struct writer *w;
 268
 269         if      (strcmp(fmt, "plain")    == 0) w = txt_init(stdout);
 270         else if (strcmp(fmt, "keyvalue") == 0) w = kv_init(stdout);
 271 #ifdef USE_XML
 272         else if (strcmp(fmt, "xml")      == 0) w = xml_init(stdout);
 273 #endif
 274 #ifdef USE_JSON
 275         else if (strcmp(fmt, "json")     == 0) w = json_init(stdout);
 276 #endif
 277         else w = txt_init(stdout);
 278
 279         /* Execute command */
 280         int rc = commands_execute(conn, w,
 281             root, argc, argv, is_privileged());
 282         if (rc != 0) {
 283                 log_info("lldpctl", "an error occurred while executing last command");
 284                 w->finish(w);
 285                 return 0;
 286         }
 287         w->finish(w);
 288         return 1;
 289 }
 290
 291 /**
 292  * Execute a command line and display its output.
 293  *
 294  * @param conn The connection to lldpd.
 295  * @param fmt  Output format.
 296  * @param line Line to execute.
 297  * @return -1 if an error occurred, 0 if nothing was executed. 1 otherwise.
 298  */
 299 static int
 300 parse_and_exec(lldpctl_conn_t *conn, const char *fmt, const char *line)
 301 {
 302         int cargc = 0; char **cargv = NULL;
 303         int n;
 304         log_debug("lldpctl", "tokenize command line");
 305         n = tokenize_line(line, &cargc, &cargv);
 306         switch (n) {
 307         case -1:
 308                 log_warnx("lldpctl", "internal error while tokenizing");
 309                 return -1;
 310         case 1:
 311                 log_warnx("lldpctl", "unmatched quotes");
 312                 return -1;
 313         }
 314         if (cargc != 0)
 315                 n = cmd_exec(conn, fmt, cargc, (const char **)cargv);
 316         tokenize_free(cargc, cargv);
 317         return (cargc == 0)?0:
 318             (n == 0)?-1:
 319             1;
 320 }
 321
 322 static struct cmd_node*
 323 register_commands()
 324 {
 325         root = commands_root();
 326         register_commands_show(root);
 327         register_commands_watch(root);
 328         commands_privileged(commands_new(
 329                 commands_new(root, "update", "Update information and send LLDPU on all ports",
 330                     NULL, NULL, NULL),
 331                 NEWLINE, "Update information and send LLDPU on all ports",
 332                 NULL, cmd_update, NULL));
 333         register_commands_configure(root);
 334         commands_new(root, "help", "Get help on a possible command",
 335             NULL, cmd_store_env_and_pop, "help");
 336         commands_new(
 337                 commands_new(root, "pause", "Pause lldpd operations", NULL, NULL, NULL),
 338                 NEWLINE, "Pause lldpd operations", NULL, cmd_pause, NULL);
 339         commands_new(
 340                 commands_new(root, "resume", "Resume lldpd operations", NULL, NULL, NULL),
 341                 NEWLINE, "Resume lldpd operations", NULL, cmd_resume, NULL);
 342         commands_new(
 343                 commands_new(root, "exit", "Exit interpreter", NULL, NULL, NULL),
 344                 NEWLINE, "Exit interpreter", NULL, cmd_exit, NULL);
 345         return root;
 346 }
 347
 348 struct input {
 349         TAILQ_ENTRY(input) next;
 350         char *name;
 351 };
 352 TAILQ_HEAD(inputs, input);
 353 static int
 354 filter(const struct dirent *dir)
 355 {
 356         if (strlen(dir->d_name) < 5) return 0;
 357         if (strcmp(dir->d_name + strlen(dir->d_name) - 5, ".conf")) return 0;
 358         return 1;
 359 }
 360
 361 /**
 362  * Append a new input file/directory to the list of inputs.
 363  *
 364  * @param arg       Directory or file name to add.
 365  * @param inputs    List of inputs
 366  * @param acceptdir 1 if we accept a directory, 0 otherwise
 367  */
 368 static void
 369 input_append(const char *arg, struct inputs *inputs, int acceptdir)
 370 {
 371         struct stat statbuf;
 372         if (stat(arg, &statbuf) == -1) {
 373                 log_info("lldpctl", "cannot find configuration file/directory %s",
 374                     arg);
 375                 return;
 376         }
 377
 378         if (!S_ISDIR(statbuf.st_mode)) {
 379                 struct input *input = malloc(sizeof(struct input));
 380                 if (!input) {
 381                         log_warn("lldpctl", "not enough memory to process %s",
 382                             arg);
 383                         return;
 384                 }
 385                 log_debug("lldpctl", "input: %s", arg);
 386                 input->name = strdup(arg);
 387                 TAILQ_INSERT_TAIL(inputs, input, next);
 388                 return;
 389         }
 390         if (!acceptdir) {
 391                 log_debug("lldpctl", "skip directory %s",
 392                     arg);
 393                 return;
 394         }
 395
 396         struct dirent **namelist = NULL;
 397         int n = scandir(arg, &namelist, filter, alphasort);
 398         if (n < 0) {
 399                 log_warnx("lldpctl", "unable to read directory %s",
 400                     arg);
 401                 return;
 402         }
 403         for (int i=0; i < n; i++) {
 404                 char *fullname;
 405                 if (asprintf(&fullname, "%s/%s", arg, namelist[i]->d_name) != -1) {
 406                         input_append(fullname, inputs, 0);
 407                         free(fullname);
 408                 }
 409                 free(namelist[i]);
 410         }
 411         free(namelist);
 412 }
 413
 414 int
 415 main(int argc, char *argv[])
 416 {
 417         int ch, debug = 1, rc = EXIT_FAILURE;
 418         const char *fmt = "plain";
 419         lldpctl_conn_t *conn = NULL;
 420         const char *options = is_lldpctl(argv[0])?"hdvf:":"hdsvf:c:u:";
 421
 422         int gotinputs = 0;
 423         struct inputs inputs;
 424         TAILQ_INIT(&inputs);
 425
 426         ctlname = lldpctl_get_default_transport();
 427
 428         signal(SIGHUP, SIG_IGN);
 429
 430         /* Initialize logging */
 431         while ((ch = getopt(argc, argv, options)) != -1) {
 432                 switch (ch) {
 433                 case 'd': debug++; break;
 434                 case 's': debug--; break;
 435                 }
 436         }
 437         log_init(debug, __progname);
 438
 439         /* Get and parse command line options */
 440         optind = 1;
 441         while ((ch = getopt(argc, argv, options)) != -1) {
 442                 switch (ch) {
 443                 case 'd': break;
 444                 case 's': break;
 445                 case 'h':
 446                         usage();
 447                         break;
 448                 case 'u':
 449                         ctlname = optarg;
 450                         break;
 451                 case 'v':
 452                         fprintf(stdout, "%s\n", PACKAGE_VERSION);
 453                         exit(0);
 454                         break;
 455                 case 'f':
 456                         fmt = optarg;
 457                         break;
 458                 case 'c':
 459                         gotinputs = 1;
 460                         input_append(optarg, &inputs, 1);
 461                         break;
 462                 default:
 463                         usage();
 464                 }
 465         }
 466
 467         /* Register commands */
 468         root = register_commands();
 469
 470         /* Make a connection */
 471         log_debug("lldpctl", "connect to lldpd");
 472         conn = lldpctl_new_name(ctlname, NULL, NULL, NULL);
 473         if (conn == NULL) goto end;
 474
 475         /* Process file inputs */
 476         while (gotinputs && !TAILQ_EMPTY(&inputs)) {
 477                 /* coverity[use_after_free]
 478                    TAILQ_REMOVE does the right thing */
 479                 struct input *first = TAILQ_FIRST(&inputs);
 480                 log_debug("lldpctl", "process: %s", first->name);
 481                 FILE *file = fopen(first->name, "r");
 482                 if (file) {
 483                         size_t len;
 484                         char *line;
 485                         while ((line = fgetln(file, &len))) {
 486                                 line = strndup(line, len);
 487                                 if (line[len - 1] == '\n') {
 488                                         line[len - 1] = '\0';
 489                                         parse_and_exec(conn, fmt, line);
 490                                 }
 491                                 free(line);
 492                         }
 493                         fclose(file);
 494                 } else {
 495                         log_warn("lldpctl", "unable to open %s",
 496                             first->name);
 497                 }
 498                 TAILQ_REMOVE(&inputs, first, next);
 499                 free(first->name);
 500                 free(first);
 501         }
 502
 503         /* Process additional arguments. First if we are lldpctl (interfaces) */
 504         if (is_lldpctl(NULL)) {
 505                 char *line = NULL;
 506                 for (int i = optind; i < argc; i++) {
 507                         char *prev = line;
 508                         if (asprintf(&line, "%s%s%s",
 509                                 prev?prev:"show neigh ports ", argv[i],
 510                                 (i == argc - 1)?" details":",") == -1) {
 511                                 log_warnx("lldpctl", "not enough memory to build list of interfaces");
 512                                 free(prev);
 513                                 goto end;
 514                         }
 515                         free(prev);
 516                 }
 517                 if (line == NULL && (line = strdup("show neigh details")) == NULL) {
 518                         log_warnx("lldpctl", "not enough memory to build command line");
 519                         goto end;
 520                 }
 521                 log_debug("lldpctl", "execute %s", line);
 522                 if (parse_and_exec(conn, fmt, line) != -1)
 523                         rc = EXIT_SUCCESS;
 524                 free(line);
 525                 goto end;
 526         }
 527
 528         /* Then, if we are regular lldpcli (command line) */
 529         if (optind < argc) {
 530                 const char **cargv;
 531                 int cargc;
 532                 cargv = &((const char **)argv)[optind];
 533                 cargc = argc - optind;
 534                 if (cmd_exec(conn, fmt, cargc, cargv) != -1)
 535                         rc = EXIT_SUCCESS;
 536                 goto end;
 537         }
 538
 539         if (gotinputs) {
 540                 rc = EXIT_SUCCESS;
 541                 goto end;
 542         }
 543
 544         /* Interactive session */
 545 #ifdef HAVE_LIBREADLINE
 546         rl_bind_key('?',  cmd_help);
 547         rl_bind_key('\t', cmd_complete);
 548 #endif
 549         const char *line;
 550         do {
 551                 if ((line = readline(prompt()))) {
 552                         int n = parse_and_exec(conn, fmt, line);
 553                         (void)n;
 554 #ifdef HAVE_READLINE_HISTORY
 555                         if (n != 0) add_history(line);
 556 #endif
 557                 }
 558         } while (!must_exit && line != NULL);
 559         rc = EXIT_SUCCESS;
 560
 561 end:
 562         while (!TAILQ_EMPTY(&inputs)) {
 563                 /* coverity[use_after_free]
 564                    TAILQ_REMOVE does the right thing */
 565                 struct input *first = TAILQ_FIRST(&inputs);
 566                 TAILQ_REMOVE(&inputs, first, next);
 567                 free(first->name);
 568                 free(first);
 569         }
 570         if (conn) lldpctl_release(conn);
 571         if (root) commands_free(root);
 572         return rc;
 573 }