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 #if !__GNUC__
  40 # define __attribute__(x) /**/
  41 #endif
  42
  43 static const char *opt_username = "admin";
  44
  45 static int result_handler (ros_connection_t *c, const ros_reply_t *r, /* {{{ */
  46                 void *user_data)
  47 {
  48         unsigned int i;
  49
  50         if (r == NULL)
  51                 return (0);
  52
  53         printf ("Status: %s\n", ros_reply_status (r));
  54
  55         for (i = 0; /* true */; i++)
  56         {
  57                 const char *key;
  58                 const char *val;
  59
  60                 key = ros_reply_param_key_by_index (r, i);
  61                 val = ros_reply_param_val_by_index (r, i);
  62
  63                 if ((key == NULL) || (val == NULL))
  64                 {
  65                         if (key != NULL)
  66                                 fprintf (stderr, "val is NULL but key is %s!\n", key);
  67                         if (val != NULL)
  68                                 fprintf (stderr, "key is NULL but val is %s!\n", val);
  69                         break;
  70                 }
  71
  72                 printf ("  Param %u: %s = %s\n", i, key, val);
  73         }
  74
  75         printf ("===\n");
  76
  77         return (result_handler (c, ros_reply_next (r), user_data));
  78 } /* }}} int result_handler */
  79
  80 static void regtable_dump (const ros_registration_table_t *r) /* {{{ */
  81 {
  82         if (r == NULL)
  83                 return;
  84
  85         printf ("=== %s / %s ===\n", r->interface, r->radio_name);
  86         printf ("Mode:           %12s\n",
  87                         r->ap ? (r->wds ? "AP with WDS" : "Access point") : "Station");
  88         printf ("Rate:           %7g Mbps / %7g Mbps\n", r->rx_rate, r->tx_rate);
  89         printf ("Packets:        %12"PRIu64" / %12"PRIu64"\n",
  90                         r->rx_packets, r->tx_packets);
  91         printf ("Bytes:          %12"PRIu64" / %12"PRIu64"\n",
  92                         r->rx_bytes, r->tx_bytes);
  93         printf ("Frames          %12"PRIu64" / %12"PRIu64"\n",
  94                         r->rx_frames, r->tx_frames);
  95         printf ("Frame Bytes:    %12"PRIu64" / %12"PRIu64"\n",
  96                         r->rx_frame_bytes, r->tx_frame_bytes);
  97         printf ("HW Frames:      %12"PRIu64" / %12"PRIu64"\n",
  98                         r->rx_hw_frames, r->tx_hw_frames);
  99         printf ("HW Frame Bytes: %12"PRIu64" / %12"PRIu64"\n",
 100                         r->rx_hw_frame_bytes, r->tx_hw_frame_bytes);
 101         printf ("Quality:        %10g %% / %10g %%\n",
 102                         r->rx_ccq, r->tx_ccq);
 103         printf ("Signal str.:    %8g dBm / %8g dBm\n",
 104                 r->rx_signal_strength, r->tx_signal_strength);
 105         printf ("Signal / noise: %8g dBm\n", r->signal_to_noise);
 106         printf ("==========\n");
 107
 108         regtable_dump (r->next);
 109 } /* }}} void regtable_dump */
 110
 111 static int regtable_handler (__attribute__((unused)) ros_connection_t *c, /* {{{ */
 112                 const ros_registration_table_t *r,
 113                 __attribute__((unused)) void *user_data)
 114 {
 115         regtable_dump (r);
 116         return (0);
 117 } /* }}} int regtable_handler */
 118
 119 static void interface_dump (const ros_interface_t *i) /* {{{ */
 120 {
 121         if (i == NULL)
 122                 return;
 123
 124         printf ("=== %s ===\n"
 125                         "Type:    %12s\n"
 126                         "Comment: %12s\n"
 127                         "Bytes:   %12"PRIu64" / %12"PRIu64"\n"
 128                         "Packets: %12"PRIu64" / %12"PRIu64"\n"
 129                         "Errors:  %12"PRIu64" / %12"PRIu64"\n"
 130                         "Drops:   %12"PRIu64" / %12"PRIu64"\n"
 131                         "MTU:     %12u\n"
 132                         "L2 MTU:  %12u\n"
 133                         "Running: %12s\n"
 134                         "Dynamic: %12s\n"
 135                         "Enabled: %12s\n"
 136                         "==========\n",
 137                         i->name, i->type, i->comment,
 138                         i->rx_bytes, i->tx_bytes,
 139                         i->rx_packets, i->tx_packets,
 140                         i->rx_errors, i->tx_errors,
 141                         i->rx_drops, i->tx_drops,
 142                         i->mtu, i->l2mtu,
 143                         i->running ? "true" : "false",
 144                         i->dynamic ? "true" : "false",
 145                         i->enabled ? "true" : "false");
 146
 147         interface_dump (i->next);
 148 } /* }}} void interface_dump */
 149
 150 static int interface_handler (__attribute__((unused)) ros_connection_t *c, /* {{{ */
 151                 const ros_interface_t *i,
 152                 __attribute__((unused)) void *user_data)
 153 {
 154         interface_dump (i);
 155         return (0);
 156 } /* }}} int interface_handler */
 157
 158 static int system_resource_handler (__attribute__((unused)) ros_connection_t *c, /* {{{ */
 159                 const ros_system_resource_t *r, __attribute__((unused)) void *user_data)
 160 {
 161         uint64_t used_memory;
 162         uint64_t used_hdd_space;
 163
 164         if (r == NULL)
 165                 return (EINVAL);
 166
 167         used_memory = r->total_memory - r->free_memory;
 168         used_hdd_space = r->total_hdd_space - r->free_hdd_space;
 169
 170         printf ("====== System resources ======\n"
 171                         "RouterOS version:  %11s\n"
 172                         "Architecture name: %11s\n"
 173                         "Board name:    %15s\n"
 174                         "CPU model:     %15s\n"
 175                         "CPU count:     %15u\n"
 176                         "CPU load:      %15u\n"
 177                         "CPU frequency: %11"PRIu64" MHz\n"
 178                         "Memory free:   %9"PRIu64" kByte (%4.1f %%)\n"
 179                         "Memory used:   %9"PRIu64" kByte (%4.1f %%)\n"
 180                         "Memory total:  %9"PRIu64" kByte\n"
 181                         "Space free:    %9"PRIu64" kByte (%4.1f %%)\n"
 182                         "Space used:    %9"PRIu64" kByte (%4.1f %%)\n"
 183                         "Space total:   %9"PRIu64" kByte\n"
 184                         "Sectors written: %13"PRIu64" (%"PRIu64")\n"
 185                         "Bad blocks:    %15"PRIu64"\n"
 186                         "==============================\n",
 187                         r->version,
 188                         r->architecture_name, r->board_name,
 189                         r->cpu_model, r->cpu_count, r->cpu_load, r->cpu_frequency,
 190                         r->free_memory,
 191                         100.0 * (((double) r->free_memory) / ((double) r->total_memory)),
 192                         used_memory,
 193                         100.0 * (((double) used_memory) / ((double) r->total_memory)),
 194                         r->total_memory,
 195                         r->free_hdd_space,
 196                         100.0 * (((double) r->free_hdd_space) / ((double) r->total_hdd_space)),
 197                         used_hdd_space,
 198                         100.0 * (((double) used_hdd_space) / ((double) r->total_hdd_space)),
 199                         r->total_hdd_space,
 200                         r->write_sect_since_reboot,
 201                         r->write_sect_total,
 202                         r->bad_blocks);
 203
 204         return (0);
 205 } /* }}} int system_resource_handler */
 206
 207 static char *read_password (void) /* {{{ */
 208 {
 209         FILE *tty;
 210         struct termios old_flags;
 211         struct termios new_flags;
 212         int status;
 213         char buffer[1024];
 214         size_t buffer_len;
 215         char *passwd;
 216
 217         tty = fopen ("/dev/tty", "w+");
 218         if (tty == NULL)
 219         {
 220                 fprintf (stderr, "Unable to open /dev/tty: %s\n",
 221                                 strerror (errno));
 222                 return (NULL);
 223         }
 224
 225         fprintf (tty, "Password for user %s: ", opt_username);
 226         fflush (tty);
 227
 228         memset (&old_flags, 0, sizeof (old_flags));
 229         tcgetattr (fileno (tty), &old_flags);
 230         new_flags = old_flags;
 231         /* clear ECHO */
 232         new_flags.c_lflag &= ~ECHO;
 233         /* set ECHONL */
 234         new_flags.c_lflag |= ECHONL;
 235
 236         status = tcsetattr (fileno (tty), TCSANOW, &new_flags);
 237         if (status != 0)
 238         {
 239                 fprintf (stderr, "tcsetattr failed: %s\n", strerror (errno));
 240                 fclose (tty);
 241                 return (NULL);
 242         }
 243
 244         fgets (buffer, sizeof (buffer), tty);
 245         buffer[sizeof (buffer) - 1] = 0;
 246         buffer_len = strlen (buffer);
 247
 248         status = tcsetattr (fileno (tty), TCSANOW, &old_flags);
 249         if (status != 0)
 250                 fprintf (stderr, "tcsetattr failed: %s\n", strerror (errno));
 251
 252         fclose (tty);
 253         tty = NULL;
 254
 255         while ((buffer_len > 0) && ((buffer[buffer_len-1] == '\n') || (buffer[buffer_len-1] == '\r')))
 256         {
 257                 buffer_len--;
 258                 buffer[buffer_len] = 0;
 259         }
 260         if (buffer_len == 0)
 261                 return (NULL);
 262
 263         passwd = malloc (strlen (buffer) + 1);
 264         if (passwd == NULL)
 265                 return (NULL);
 266         memcpy (passwd, buffer, strlen (buffer) + 1);
 267         memset (buffer, 0, sizeof (buffer));
 268
 269         return (passwd);
 270 } /* }}} char *read_password */
 271
 272 static void exit_usage (void) /* {{{ */
 273 {
 274         printf ("Usage: ros [options] <host> <command> [args]\n");
 275         exit (EXIT_SUCCESS);
 276 } /* }}} void exit_usage */
 277
 278 int main (int argc, char **argv) /* {{{ */
 279 {
 280         ros_connection_t *c;
 281         char *passwd;
 282         const char *host;
 283         const char *command;
 284
 285         int option;
 286
 287         while ((option = getopt (argc, argv, "u:h?")) != -1)
 288         {
 289                 switch (option)
 290                 {
 291                         case 'u':
 292                                 opt_username = optarg;
 293                                 break;
 294
 295                         case 'h':
 296                         case '?':
 297                         default:
 298                                 exit_usage ();
 299                                 break;
 300                 }
 301         }
 302
 303         if ((argc - optind) < 2)
 304                 exit_usage ();
 305
 306         host = argv[optind];
 307         command = argv[optind+1];
 308
 309         passwd = read_password ();
 310         if (passwd == NULL)
 311                 exit (EXIT_FAILURE);
 312
 313         c = ros_connect (argv[optind], ROUTEROS_API_PORT,
 314                         opt_username, passwd);
 315         memset (passwd, 0, strlen (passwd));
 316         if (c == NULL)
 317         {
 318                 fprintf (stderr, "ros_connect failed: %s\n", strerror (errno));
 319                 exit (EXIT_FAILURE);
 320         }
 321
 322         if (command[0] == '/')
 323         {
 324                 ros_query (c, command,
 325                                 (size_t) (argc - (optind + 2)), (const char * const *) (argv + optind + 2),
 326                                 result_handler, /* user data = */ NULL);
 327         }
 328         else if (strcmp ("interface", command) == 0)
 329         {
 330                 ros_interface (c, interface_handler, /* user data = */ NULL);
 331         }
 332         else if (strcmp ("registration-table", command) == 0)
 333         {
 334                 ros_registration_table (c, regtable_handler, /* user data = */ NULL);
 335         }
 336         else if (strcmp ("system-resource", command) == 0)
 337         {
 338                 ros_system_resource (c, system_resource_handler, /* user data = */ NULL);
 339         }
 340         else
 341         {
 342                 fprintf (stderr, "Unknown built-in command %s. "
 343                                 "Are you missing a leading slash?\n", command);
 344         }
 345
 346         ros_disconnect (c);
 347
 348         return (0);
 349 } /* }}} int main */
 350
 351 /* vim: set ts=2 sw=2 noet fdm=marker : */