main.c

   1 /*
   2  *   This program is free software; you can redistribute it and/or modify
   3  *   it under the terms of the GNU General Public License as published by
   4  *   the Free Software Foundation; either version 2 of the License.
   5  *
   6  *   This program is distributed in the hope that it will be useful,
   7  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
   8  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   9  *   GNU General Public License for more details.
  10  *
  11  *   You should have received a copy of the GNU General Public License
  12  *   along with this program; if not, write to the Free Software
  13  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
  14  *
  15  *   Copyright (C) 2020 embedd.ch
  16  *   Copyright (C) 2020 Felix Fietkau <nbd@nbd.name>
  17  *   Copyright (C) 2020 John Crispin <john@phrozen.org>
  18  */
  19
  20 #include <unistd.h>
  21 #include <stdarg.h>
  22 #include <syslog.h>
  23
  24 #include <libubox/blobmsg_json.h>
  25
  26 #include "usteer.h"
  27 #include "event.h"
  28 #include "node.h"
  29
  30 struct ubus_context *ubus_ctx;
  31 struct usteer_config config = {};
  32 struct blob_attr *host_info_blob;
  33 uint64_t current_time;
  34 static int dump_time;
  35
  36 LIST_HEAD(node_handlers);
  37
  38 const char * const event_types[__EVENT_TYPE_MAX] = {
  39         [EVENT_TYPE_PROBE] = "probe",
  40         [EVENT_TYPE_AUTH] = "auth",
  41         [EVENT_TYPE_ASSOC] = "assoc",
  42 };
  43
  44 void log_msg(char *msg)
  45 {
  46         if (config.syslog)
  47                 syslog(LOG_INFO, "%s\n", msg);
  48         else
  49                 fprintf(stderr, "%s\n", msg);
  50 }
  51
  52 void debug_msg(int level, const char *func, int line, const char *format, ...)
  53 {
  54         va_list ap;
  55
  56         if (config.debug_level < level)
  57                 return;
  58
  59         if (!config.syslog)
  60                 fprintf(stderr, "[%s:%d] ", func, line);
  61
  62         va_start(ap, format);
  63         if (config.syslog)
  64                 vsyslog(level >= MSG_DEBUG ? LOG_DEBUG : LOG_INFO, format, ap);
  65         else
  66                 vfprintf(stderr, format, ap);
  67         va_end(ap);
  68
  69 }
  70
  71 void debug_msg_cont(int level, const char *format, ...)
  72 {
  73         va_list ap;
  74
  75         if (config.debug_level < level)
  76                 return;
  77
  78         va_start(ap, format);
  79         vfprintf(stderr, format, ap);
  80         va_end(ap);
  81 }
  82
  83 void usteer_init_defaults(void)
  84 {
  85         memset(&config, 0, sizeof(config));
  86
  87         config.sta_block_timeout = 30 * 1000;
  88         config.local_sta_timeout = 120 * 1000;
  89         config.measurement_report_timeout = 120 * 1000;
  90         config.local_sta_update = 1 * 1000;
  91         config.max_retry_band = 5;
  92         config.max_neighbor_reports = 8;
  93         config.seen_policy_timeout = 30 * 1000;
  94         config.band_steering_threshold = 5;
  95         config.load_balancing_threshold = 0;
  96         config.remote_update_interval = 1000;
  97         config.initial_connect_delay = 0;
  98         config.remote_node_timeout = 10;
  99
 100         config.steer_reject_timeout = 60000;
 101
 102         config.band_steering_interval = 120000;
 103         config.band_steering_min_snr = -60;
 104
 105         config.link_measurement_interval = 30000;
 106
 107         config.probe_steering = 0;
 108
 109         config.roam_kick_delay = 10000;
 110         config.roam_process_timeout = 5 * 1000;
 111         config.roam_scan_tries = 3;
 112         config.roam_scan_timeout = 0;
 113         config.roam_scan_interval = 10 * 1000;
 114         config.roam_trigger_interval = 60 * 1000;
 115
 116         config.min_snr_kick_delay = 5 * 1000;
 117
 118         config.load_kick_enabled = false;
 119         config.load_kick_threshold = 75;
 120         config.load_kick_delay = 10 * 1000;
 121         config.load_kick_min_clients = 10;
 122         config.load_kick_reason_code = 5; /* WLAN_REASON_DISASSOC_AP_BUSY */
 123
 124         config.debug_level = MSG_FATAL;
 125 }
 126
 127 void usteer_update_time(void)
 128 {
 129         struct timespec ts;
 130
 131         clock_gettime(CLOCK_MONOTONIC, &ts);
 132         current_time = (uint64_t) ts.tv_sec * 1000 + ts.tv_nsec / 1000000;
 133 }
 134
 135 static int usage(const char *prog)
 136 {
 137         fprintf(stderr, "Usage: %s [options]\n"
 138                 "Options:\n"
 139                 " -v:           Increase debug level (repeat for more messages):\n"
 140                 "               1: info messages\n"
 141                 "               2: debug messages\n"
 142                 "               3: verbose debug messages\n"
 143                 "               4: include network messages\n"
 144                 "               5: include extra testing messages\n"
 145                 " -i <name>:    Connect to other instances on interface <name>\n"
 146                 " -s:           Output log messages via syslog instead of stderr\n"
 147                 " -D <n>:       Do not daemonize, wait for <n> seconds and print\n"
 148                 "               remote hosts and nodes\n"
 149                 "\n", prog);
 150         return 1;
 151 }
 152
 153 static void
 154 usteer_dump_timeout(struct uloop_timeout *t)
 155 {
 156         struct usteer_remote_host *host;
 157         struct usteer_remote_node *rn;
 158         struct blob_buf b = {};
 159         char *str;
 160         void *c;
 161
 162         blob_buf_init(&b, 0);
 163
 164         c = blobmsg_open_table(&b, "hosts");
 165         avl_for_each_element(&remote_hosts, host, avl)
 166                 usteer_dump_host(&b, host);
 167         blobmsg_close_table(&b, c);
 168
 169         c = blobmsg_open_table(&b, "nodes");
 170         for_each_remote_node(rn)
 171                 usteer_dump_node(&b, &rn->node);
 172         blobmsg_close_table(&b, c);
 173
 174         str = blobmsg_format_json(b.head, true);
 175         blob_buf_free(&b);
 176
 177         puts(str);
 178         free(str);
 179
 180         uloop_end();
 181 }
 182
 183 int main(int argc, char **argv)
 184 {
 185         struct uloop_timeout dump_timer;
 186         int ch;
 187
 188         usteer_init_defaults();
 189
 190         while ((ch = getopt(argc, argv, "D:i:sv")) != -1) {
 191                 switch(ch) {
 192                 case 'v':
 193                         config.debug_level++;
 194                         break;
 195                 case 's':
 196                         config.syslog = true;
 197                         break;
 198                 case 'i':
 199                         usteer_interface_add(optarg);
 200                         break;
 201                 case 'D':
 202                         dump_time = atoi(optarg);
 203                         break;
 204                 default:
 205                         return usage(argv[0]);
 206                 }
 207         }
 208
 209         openlog("usteer", 0, LOG_USER);
 210
 211         config_set_event_log_types(NULL);
 212         usteer_update_time();
 213         uloop_init();
 214
 215         ubus_ctx = ubus_connect(NULL);
 216         if (!ubus_ctx) {
 217                 fprintf(stderr, "Failed to connect to ubus\n");
 218                 return -1;
 219         }
 220
 221         ubus_add_uloop(ubus_ctx);
 222         if (dump_time) {
 223                 dump_timer.cb = usteer_dump_timeout;
 224                 uloop_timeout_set(&dump_timer, dump_time * 1000);
 225         } else {
 226                 usteer_ubus_init(ubus_ctx);
 227                 usteer_local_nodes_init(ubus_ctx);
 228         }
 229         uloop_run();
 230
 231         uloop_done();
 232         return 0;
 233 }