release/src/router/shared/misc.c

   1 /*
   2
   3         Tomato Firmware
   4         Copyright (C) 2006-2009 Jonathan Zarate
   5
   6 */
   7 #include <string.h>
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <unistd.h>
  11 #include <fcntl.h>
  12 #include <sys/stat.h>
  13 #include <stdarg.h>
  14 #include <syslog.h>
  15 #include <sys/ioctl.h>
  16 #include <net/if.h>
  17 #include <sys/socket.h>
  18 #include <arpa/inet.h>
  19 #include <sys/sysinfo.h>
  20 #include <sys/types.h>
  21
  22 #include <bcmnvram.h>
  23 #include <bcmdevs.h>
  24 #include <wlutils.h>
  25
  26 #include "shutils.h"
  27 #include "shared.h"
  28
  29 #if 0
  30 #define _dprintf        cprintf
  31 #else
  32 #define _dprintf(args...)       do { } while(0)
  33 #endif
  34
  35
  36 int get_wan_proto(void)
  37 {
  38         const char *names[] = { // order must be synced with def at shared.h
  39                 "static",
  40                 "dhcp",
  41                 "l2tp",
  42                 "pppoe",
  43                 "pptp",
  44                 NULL
  45         };
  46         int i;
  47         const char *p;
  48
  49         p = nvram_safe_get("wan_proto");
  50         for (i = 0; names[i] != NULL; ++i) {
  51                 if (strcmp(p, names[i]) == 0) return i + 1;
  52         }
  53         return WP_DISABLED;
  54 }
  55
  56 int using_dhcpc(void)
  57 {
  58         switch (get_wan_proto()) {
  59         case WP_DHCP:
  60         case WP_L2TP:
  61                 return 1;
  62         }
  63         return 0;
  64 }
  65
  66 int wl_client(void)
  67 {
  68         return ((nvram_match("wl_mode", "sta")) || (nvram_match("wl_mode", "wet")));
  69 }
  70
  71 void notice_set(const char *path, const char *format, ...)
  72 {
  73         char p[256];
  74         char buf[2048];
  75         va_list args;
  76
  77         va_start(args, format);
  78         vsnprintf(buf, sizeof(buf), format, args);
  79         va_end(args);
  80
  81         mkdir("/var/notice", 0755);
  82         snprintf(p, sizeof(p), "/var/notice/%s", path);
  83         f_write_string(p, buf, 0, 0);
  84         if (buf[0]) syslog(LOG_INFO, "notice[%s]: %s", path, buf);
  85 }
  86
  87
  88 //      #define _x_dprintf(args...)     syslog(LOG_DEBUG, args);
  89 #define _x_dprintf(args...)     do { } while (0);
  90
  91 int check_wanup(void)
  92 {
  93         int up = 0;
  94         int proto;
  95         char buf1[64];
  96         char buf2[64];
  97         const char *name;
  98     int f;
  99     struct ifreq ifr;
 100
 101         proto = get_wan_proto();
 102         if (proto == WP_DISABLED) return 0;
 103
 104         if ((proto == WP_PPTP) || (proto == WP_L2TP) || (proto == WP_PPPOE)) {
 105                 if (f_read_string("/tmp/ppp/link", buf1, sizeof(buf1)) > 0) {
 106                                 // contains the base name of a file in /var/run/ containing pid of a daemon
 107                                 snprintf(buf2, sizeof(buf2), "/var/run/%s.pid", buf1);
 108                                 if (f_read_string(buf2, buf1, sizeof(buf1)) > 0) {
 109                                         name = psname(atoi(buf1), buf2, sizeof(buf2));
 110                                         if (proto == WP_PPPOE) {
 111                                                 if (strcmp(name, "pppoecd") == 0) up = 1;
 112                                         }
 113                                         else {
 114                                                 if (strcmp(name, "pppd") == 0) up = 1;
 115                                         }
 116                                 }
 117                                 else {
 118                                         _dprintf("%s: error reading %s\n", __FUNCTION__, buf2);
 119                                 }
 120                         if (!up) {
 121                                 unlink("/tmp/ppp/link");
 122                                 _x_dprintf("required daemon not found, assuming link is dead\n");
 123                         }
 124                 }
 125                 else {
 126                         _x_dprintf("%s: error reading %s\n", __FUNCTION__, "/tmp/ppp/link");
 127                 }
 128         }
 129         else if (!nvram_match("wan_ipaddr", "0.0.0.0")) {
 130                 up = 1;
 131         }
 132         else {
 133                 _x_dprintf("%s: default !up\n", __FUNCTION__);
 134         }
 135
 136         if ((up) && ((f = socket(AF_INET, SOCK_DGRAM, 0)) >= 0)) {
 137                 strlcpy(ifr.ifr_name, nvram_safe_get("wan_iface"), sizeof(ifr.ifr_name));
 138                 if (ioctl(f, SIOCGIFFLAGS, &ifr) < 0) {
 139                         up = 0;
 140                         _x_dprintf("%s: SIOCGIFFLAGS\n", __FUNCTION__);
 141                 }
 142                 close(f);
 143                 if ((ifr.ifr_flags & IFF_UP) == 0) {
 144                         up = 0;
 145                         _x_dprintf("%s: !IFF_UP\n", __FUNCTION__);
 146                 }
 147         }
 148
 149         return up;
 150 }
 151
 152
 153 const dns_list_t *get_dns(void)
 154 {
 155         static dns_list_t dns;
 156         char s[512];
 157         int n;
 158         int i, j;
 159         struct in_addr ia;
 160         char d[4][22];
 161         unsigned short port;
 162         char *c;
 163
 164         dns.count = 0;
 165
 166         strlcpy(s, nvram_safe_get("wan_dns"), sizeof(s));
 167         if ((nvram_get_int("dns_addget")) || (s[0] == 0)) {
 168                 n = strlen(s);
 169                 snprintf(s + n, sizeof(s) - n, " %s", nvram_safe_get("wan_get_dns"));
 170         }
 171
 172         n = sscanf(s, "%21s %21s %21s %21s", d[0], d[1], d[2], d[3]);
 173         for (i = 0; i < n; ++i) {
 174                 port = 53;
 175
 176                 if ((c = strchr(d[i], ':')) != NULL) {
 177                         *c++ = 0;
 178                         if (((j = atoi(c)) < 1) || (j > 0xFFFF)) continue;
 179                         port = j;
 180                 }
 181
 182                 if (inet_pton(AF_INET, d[i], &ia) > 0) {
 183                         for (j = dns.count - 1; j >= 0; --j) {
 184                                 if ((dns.dns[j].addr.s_addr == ia.s_addr) && (dns.dns[j].port == port)) break;
 185                         }
 186                         if (j < 0) {
 187                                 dns.dns[dns.count].port = port;
 188                                 dns.dns[dns.count++].addr.s_addr = ia.s_addr;
 189                                 if (dns.count == 3) break;
 190                         }
 191                 }
 192         }
 193
 194         return &dns;
 195 }
 196
 197 // -----------------------------------------------------------------------------
 198
 199 void set_action(int a)
 200 {
 201         int r = 3;
 202         while (f_write("/var/lock/action", &a, sizeof(a), 0, 0) != sizeof(a)) {
 203                 sleep(1);
 204                 if (--r == 0) return;
 205         }
 206         if (a != ACT_IDLE) sleep(2);
 207 }
 208
 209 int check_action(void)
 210 {
 211         int a;
 212         int r = 3;
 213
 214         while (f_read("/var/lock/action", &a, sizeof(a)) != sizeof(a)) {
 215                 sleep(1);
 216                 if (--r == 0) return ACT_UNKNOWN;
 217         }
 218         return a;
 219 }
 220
 221 int wait_action_idle(int n)
 222 {
 223         while (n-- > 0) {
 224                 if (check_action() == ACT_IDLE) return 1;
 225                 sleep(1);
 226         }
 227         return 0;
 228 }
 229
 230 // -----------------------------------------------------------------------------
 231
 232 const char *get_wanip(void)
 233 {
 234         const char *p;
 235
 236         if (!check_wanup()) return "0.0.0.0";
 237         switch (get_wan_proto()) {
 238         case WP_DISABLED:
 239                 return "0.0.0.0";
 240         case WP_PPTP:
 241                 p = "pptp_get_ip";
 242                 break;
 243         case WP_L2TP:
 244                 p = "l2tp_get_ip";
 245                 break;
 246         default:
 247                 p = "wan_ipaddr";
 248                 break;
 249         }
 250         return nvram_safe_get(p);
 251 }
 252
 253 long get_uptime(void)
 254 {
 255         struct sysinfo si;
 256         sysinfo(&si);
 257         return si.uptime;
 258 }
 259
 260 int get_radio(void)
 261 {
 262         uint32 n;
 263
 264         return (wl_ioctl(nvram_safe_get("wl_ifname"), WLC_GET_RADIO, &n, sizeof(n)) == 0) &&
 265                 ((n & WL_RADIO_SW_DISABLE)  == 0);
 266 }
 267
 268 void set_radio(int on)
 269 {
 270         uint32 n;
 271
 272 #ifndef WL_BSS_INFO_VERSION
 273 #error WL_BSS_INFO_VERSION
 274 #endif
 275
 276 #if WL_BSS_INFO_VERSION >= 108
 277         n = on ? (WL_RADIO_SW_DISABLE << 16) : ((WL_RADIO_SW_DISABLE << 16) | 1);
 278         wl_ioctl(nvram_safe_get("wl_ifname"), WLC_SET_RADIO, &n, sizeof(n));
 279         if (!on) {
 280                 led(LED_WLAN, 0);
 281                 led(LED_DIAG, 0);
 282         }
 283 #else
 284         n = on ? 0 : WL_RADIO_SW_DISABLE;
 285         wl_ioctl(nvram_safe_get("wl_ifname"), WLC_SET_RADIO, &n, sizeof(n));
 286         if (!on) {
 287                 led(LED_DIAG, 0);
 288         }
 289 #endif
 290 }
 291
 292 int nvram_get_int(const char *key)
 293 {
 294         return atoi(nvram_safe_get(key));
 295 }
 296
 297 /*
 298 long nvram_xget_long(const char *name, long min, long max, long def)
 299 {
 300         const char *p;
 301         char *e;
 302         long n;
 303
 304         p = nvram_get(name);
 305         if ((p != NULL) && (*p != 0)) {
 306                 n = strtol(p, &e, 0);
 307                 if ((e != p) && ((*e == 0) || (*e == ' ')) && (n > min) && (n < max)) {
 308                         return n;
 309                 }
 310         }
 311         return def;
 312 }
 313 */
 314
 315 int nvram_get_file(const char *key, const char *fname, int max)
 316 {
 317         int n;
 318         char *p;
 319         char *b;
 320         int r;
 321
 322         r = 0;
 323         p = nvram_safe_get(key);
 324         n = strlen(p);
 325         if (n <= max) {
 326                 if ((b = malloc(base64_decoded_len(n) + 128)) != NULL) {
 327                         n = base64_decode(p, b, n);
 328                         if (n > 0) r = (f_write(fname, b, n, 0, 0644) == n);
 329                         free(b);
 330                 }
 331         }
 332         return r;
 333 /*
 334         char b[2048];
 335         int n;
 336         char *p;
 337
 338         p = nvram_safe_get(key);
 339         n = strlen(p);
 340         if (n <= max) {
 341                 n = base64_decode(p, b, n);
 342                 if (n > 0) return (f_write(fname, b, n, 0, 0700) == n);
 343         }
 344         return 0;
 345 */
 346 }
 347
 348 int nvram_set_file(const char *key, const char *fname, int max)
 349 {
 350         char *in;
 351         char *out;
 352         long len;
 353         int n;
 354         int r;
 355
 356         if ((len = f_size(fname)) > max) return 0;
 357         max = (int)len;
 358         r = 0;
 359         if (f_read_alloc(fname, &in, max) == max) {
 360                 if ((out = malloc(base64_encoded_len(max) + 128)) != NULL) {
 361                         n = base64_encode(in, out, max);
 362                         out[n] = 0;
 363                         nvram_set(key, out);
 364                         free(out);
 365                         r = 1;
 366                 }
 367                 free(in);
 368         }
 369         return r;
 370 /*
 371         char a[2048];
 372         char b[4096];
 373         int n;
 374
 375         if (((n = f_read(fname, &a, sizeof(a))) > 0) && (n <= max)) {
 376                 n = base64_encode(a, b, n);
 377                 b[n] = 0;
 378                 nvram_set(key, b);
 379                 return 1;
 380         }
 381         return 0;
 382 */
 383 }
 384
 385 int nvram_contains_word(const char *key, const char *word)
 386 {
 387         return (find_word(nvram_safe_get(key), word) != NULL);
 388 }
 389
 390 int nvram_is_empty(const char *key)
 391 {
 392         char *p;
 393         return (((p = nvram_get(key)) == NULL) || (*p == 0));
 394 }
 395
 396 void nvram_commit_x(void)
 397 {
 398         if (!nvram_get_int("debug_nocommit")) nvram_commit();
 399 }
 400
 401 int connect_timeout(int fd, const struct sockaddr *addr, socklen_t len, int timeout)
 402 {
 403         fd_set fds;
 404         struct timeval tv;
 405         int flags;
 406         int n;
 407         int r;
 408
 409         if (((flags = fcntl(fd, F_GETFL, 0)) < 0) ||
 410                 (fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0)) {
 411                 _dprintf("%s: error in F_*ETFL %d\n", __FUNCTION__, fd);
 412                 return -1;
 413         }
 414
 415         if (connect(fd, addr, len) < 0) {
 416 //              _dprintf("%s: connect %d = <0\n", __FUNCTION__, fd);
 417
 418                 if (errno != EINPROGRESS) {
 419                         _dprintf("%s: error in connect %d errno=%d\n", __FUNCTION__, fd, errno);
 420                         return -1;
 421                 }
 422
 423                 while (1) {
 424                         tv.tv_sec = timeout;
 425                         tv.tv_usec = 0;
 426                         FD_ZERO(&fds);
 427                         FD_SET(fd, &fds);
 428                         r = select(fd + 1, NULL, &fds, NULL, &tv);
 429                         if (r == 0) {
 430                                 _dprintf("%s: timeout in select %d\n", __FUNCTION__, fd);
 431                                 return -1;
 432                         }
 433                         else if (r < 0) {
 434                                 if (errno != EINTR) {
 435                                         _dprintf("%s: error in select %d\n", __FUNCTION__, fd);
 436                                         return -1;
 437                                 }
 438                                 // loop
 439                         }
 440                         else {
 441                                 r = 0;
 442                                 n = sizeof(r);
 443                                 if ((getsockopt(fd, SOL_SOCKET, SO_ERROR, &r, &n) < 0) || (r != 0)) {
 444                                         _dprintf("%s: error in SO_ERROR %d\n", __FUNCTION__, fd);
 445                                         return -1;
 446                                 }
 447                                 break;
 448                         }
 449                 }
 450         }
 451
 452         if (fcntl(fd, F_SETFL, flags) < 0) {
 453                 _dprintf("%s: error in F_*ETFL %d\n", __FUNCTION__, fd);
 454                 return -1;
 455         }
 456
 457 //      _dprintf("%s: OK %d\n", __FUNCTION__, fd);
 458         return 0;
 459 }
 460
 461 /*
 462 int time_ok(void)
 463 {
 464         return time(0) > Y2K;
 465 }
 466 */