src/ros.c

   1 /**
   2  * libmikrotik - src/ros.c
   3  * Copyright (C) 2009  Florian octo Forster
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License as published by the
   7  * Free Software Foundation; only version 2 of the License is applicable.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  17  *
  18  * Authors:
  19  *   Florian octo Forster <octo at verplant.org>
  20  **/
  21
  22 #ifndef _ISOC99_SOURCE
  23 # define _ISOC99_SOURCE
  24 #endif
  25
  26 #ifndef _POSIX_C_SOURCE
  27 # define _POSIX_C_SOURCE 200112L
  28 #endif
  29
  30 #include <stdlib.h>
  31 #include <stdio.h>
  32 #include <string.h>
  33 #include <errno.h>
  34 #include <termios.h>
  35 #include <getopt.h>
  36
  37 #include "routeros_api.h"
  38
  39 static const char *opt_username = "admin";
  40
  41 static int result_handler (ros_connection_t *c, const ros_reply_t *r, /* {{{ */
  42                 void *user_data)
  43 {
  44         unsigned int i;
  45
  46         if (r == NULL)
  47                 return (0);
  48
  49         printf ("Status: %s\n", ros_reply_status (r));
  50
  51         for (i = 0; /* true */; i++)
  52         {
  53                 const char *key;
  54                 const char *val;
  55
  56                 key = ros_reply_param_key_by_index (r, i);
  57                 val = ros_reply_param_val_by_index (r, i);
  58
  59                 if ((key == NULL) || (val == NULL))
  60                 {
  61                         if (key != NULL)
  62                                 fprintf (stderr, "val is NULL but key is %s!\n", key);
  63                         if (val != NULL)
  64                                 fprintf (stderr, "key is NULL but val is %s!\n", val);
  65                         break;
  66                 }
  67
  68                 printf ("  Param %u: %s = %s\n", i, key, val);
  69         }
  70
  71         printf ("===\n");
  72
  73         return (result_handler (c, ros_reply_next (r), user_data));
  74 } /* }}} int result_handler */
  75
  76 static void regtable_dump (const ros_registration_table_t *r) /* {{{ */
  77 {
  78         if (r == NULL)
  79                 return;
  80
  81         printf ("=== %s ===\n", r->interface);
  82         printf ("Rate:           %7g Mbps / %7g Mbps\n", r->rx_rate, r->tx_rate);
  83         printf ("Packets:        %12"PRIu64" / %12"PRIu64"\n",
  84                         r->rx_packets, r->tx_packets);
  85         printf ("Bytes:          %12"PRIu64" / %12"PRIu64"\n",
  86                         r->rx_bytes, r->tx_bytes);
  87         printf ("Frames          %12"PRIu64" / %12"PRIu64"\n",
  88                         r->rx_frames, r->tx_frames);
  89         printf ("Frame Bytes:    %12"PRIu64" / %12"PRIu64"\n",
  90                         r->rx_frame_bytes, r->tx_frame_bytes);
  91         printf ("HW Frames:      %12"PRIu64" / %12"PRIu64"\n",
  92                         r->rx_hw_frames, r->tx_hw_frames);
  93         printf ("HW Frame Bytes: %12"PRIu64" / %12"PRIu64"\n",
  94                         r->rx_hw_frame_bytes, r->tx_hw_frame_bytes);
  95         printf ("Quality:        %10g %% / %10g %%\n",
  96                         r->rx_ccq, r->tx_ccq);
  97         printf ("Signal str.:    %8g dBm / %8g dBm\n",
  98                 r->rx_signal_strength, r->tx_signal_strength);
  99         printf ("Signal / noise: %8g dBm\n", r->signal_to_noise);
 100         printf ("==========\n");
 101
 102         regtable_dump (r->next);
 103 } /* }}} void regtable_dump */
 104
 105 static int regtable_handler (ros_connection_t *c, /* {{{ */
 106                 const ros_registration_table_t *r, void *user_data)
 107 {
 108         regtable_dump (r);
 109         return (0);
 110 } /* }}} int regtable_handler */
 111
 112 static void interface_dump (const ros_interface_t *i) /* {{{ */
 113 {
 114         if (i == NULL)
 115                 return;
 116
 117         printf ("=== %s ===\n"
 118                         "Type:    %12s\n"
 119                         "Comment: %12s\n"
 120                         "Bytes:   %12"PRIu64" / %12"PRIu64"\n"
 121                         "Packets: %12"PRIu64" / %12"PRIu64"\n"
 122                         "Errors:  %12"PRIu64" / %12"PRIu64"\n"
 123                         "Drops:   %12"PRIu64" / %12"PRIu64"\n"
 124                         "MTU:     %12u\n"
 125                         "L2 MTU:  %12u\n"
 126                         "Running: %12s\n"
 127                         "Dynamic: %12s\n"
 128                         "Enabled: %12s\n"
 129                         "==========\n",
 130                         i->name, i->type, i->comment,
 131                         i->rx_bytes, i->tx_bytes,
 132                         i->rx_packets, i->tx_packets,
 133                         i->rx_errors, i->tx_errors,
 134                         i->rx_drops, i->tx_drops,
 135                         i->mtu, i->l2mtu,
 136                         i->running ? "true" : "false",
 137                         i->dynamic ? "true" : "false",
 138                         i->enabled ? "true" : "false");
 139
 140         interface_dump (i->next);
 141 } /* }}} void interface_dump */
 142
 143 static int interface_handler (ros_connection_t *c, /* {{{ */
 144                 const ros_interface_t *i, void *user_data)
 145 {
 146         interface_dump (i);
 147         return (0);
 148 } /* }}} int interface_handler */
 149
 150 static char *read_password (void) /* {{{ */
 151 {
 152         FILE *tty;
 153         struct termios old_flags;
 154         struct termios new_flags;
 155         int status;
 156         char buffer[1024];
 157         size_t buffer_len;
 158         char *passwd;
 159
 160         tty = fopen ("/dev/tty", "w+");
 161         if (tty == NULL)
 162         {
 163                 fprintf (stderr, "Unable to open /dev/tty: %s\n",
 164                                 strerror (errno));
 165                 return (NULL);
 166         }
 167
 168         fprintf (tty, "Password for user %s: ", opt_username);
 169         fflush (tty);
 170
 171         memset (&old_flags, 0, sizeof (old_flags));
 172         tcgetattr (fileno (tty), &old_flags);
 173         new_flags = old_flags;
 174         /* clear ECHO */
 175         new_flags.c_lflag &= ~ECHO;
 176         /* set ECHONL */
 177         new_flags.c_lflag |= ECHONL;
 178
 179         status = tcsetattr (fileno (tty), TCSANOW, &new_flags);
 180         if (status != 0)
 181         {
 182                 fprintf (stderr, "tcsetattr failed: %s\n", strerror (errno));
 183                 fclose (tty);
 184                 return (NULL);
 185         }
 186
 187         fgets (buffer, sizeof (buffer), tty);
 188         buffer[sizeof (buffer) - 1] = 0;
 189         buffer_len = strlen (buffer);
 190
 191         status = tcsetattr (fileno (tty), TCSANOW, &old_flags);
 192         if (status != 0)
 193                 fprintf (stderr, "tcsetattr failed: %s\n", strerror (errno));
 194
 195         fclose (tty);
 196         tty = NULL;
 197
 198         while ((buffer_len > 0) && ((buffer[buffer_len-1] == '\n') || (buffer[buffer_len-1] == '\r')))
 199         {
 200                 buffer_len--;
 201                 buffer[buffer_len] = 0;
 202         }
 203         if (buffer_len == 0)
 204                 return (NULL);
 205
 206         passwd = malloc (strlen (buffer) + 1);
 207         if (passwd == NULL)
 208                 return (NULL);
 209         memcpy (passwd, buffer, strlen (buffer) + 1);
 210         memset (buffer, 0, sizeof (buffer));
 211
 212         return (passwd);
 213 } /* }}} char *read_password */
 214
 215 static void exit_usage (void) /* {{{ */
 216 {
 217         printf ("Usage: ros [options] <host> <command> [args]\n");
 218         exit (EXIT_SUCCESS);
 219 } /* }}} void exit_usage */
 220
 221 int main (int argc, char **argv) /* {{{ */
 222 {
 223         ros_connection_t *c;
 224         char *passwd;
 225         const char *host;
 226         const char *command;
 227
 228         int option;
 229
 230         while ((option = getopt (argc, argv, "u:h?")) != -1)
 231         {
 232                 switch (option)
 233                 {
 234                         case 'u':
 235                                 opt_username = optarg;
 236                                 break;
 237
 238                         case 'h':
 239                         case '?':
 240                         default:
 241                                 exit_usage ();
 242                                 break;
 243                 }
 244         }
 245
 246         if ((argc - optind) < 2)
 247                 exit_usage ();
 248
 249         host = argv[optind];
 250         command = argv[optind+1];
 251
 252         passwd = read_password ();
 253         if (passwd == NULL)
 254                 exit (EXIT_FAILURE);
 255
 256         c = ros_connect (argv[optind], ROUTEROS_API_PORT,
 257                         opt_username, passwd);
 258         memset (passwd, 0, strlen (passwd));
 259         if (c == NULL)
 260         {
 261                 fprintf (stderr, "ros_connect failed: %s\n", strerror (errno));
 262                 exit (EXIT_FAILURE);
 263         }
 264
 265         if (command[0] == '/')
 266         {
 267                 ros_query (c, command,
 268                                 (size_t) (argc - (optind + 2)), (const char * const *) (argv + optind + 2),
 269                                 result_handler, /* user data = */ NULL);
 270         }
 271         else if (strcmp ("interface", command) == 0)
 272         {
 273                 ros_interface (c, interface_handler, /* user data = */ NULL);
 274         }
 275         else if (strcmp ("registration-table", command) == 0)
 276         {
 277                 ros_registration_table (c, regtable_handler, /* user data = */ NULL);
 278         }
 279         else
 280         {
 281                 fprintf (stderr, "Unknown built-in command %s. "
 282                                 "Are you missing a leading slash?\n", command);
 283         }
 284
 285         ros_disconnect (c);
 286
 287         return (0);
 288 } /* }}} int main */
 289
 290 /* vim: set ts=2 sw=2 noet fdm=marker : */