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 <netinet/in.h>
  18 #include <sys/socket.h>
  19 #include <arpa/inet.h>
  20 #include <ifaddrs.h>
  21 #include <sys/sysinfo.h>
  22 #include <sys/types.h>
  23 #include <sys/wait.h>
  24
  25 #include <bcmnvram.h>
  26 #include <bcmdevs.h>
  27 #include <wlutils.h>
  28
  29 #include "shutils.h"
  30 #include "shared.h"
  31
  32
  33 int get_wan_proto(void)
  34 {
  35         const char *names[] = { // order must be synced with def at shared.h
  36                 "static",
  37                 "dhcp",
  38                 "l2tp",
  39                 "pppoe",
  40                 "pptp",
  41                 NULL
  42         };
  43         int i;
  44         const char *p;
  45
  46         p = nvram_safe_get("wan_proto");
  47         for (i = 0; names[i] != NULL; ++i) {
  48                 if (strcmp(p, names[i]) == 0) return i + 1;
  49         }
  50         return WP_DISABLED;
  51 }
  52
  53 #ifdef TCONFIG_IPV6
  54 int get_ipv6_service(void)
  55 {
  56         const char *names[] = { // order must be synced with def at shared.h
  57                 "native",       // IPV6_NATIVE
  58                 "native-pd",    // IPV6_NATIVE_DHCP
  59                 "6to4",         // IPV6_ANYCAST_6TO4
  60                 "sit",          // IPV6_6IN4
  61                 "other",        // IPV6_MANUAL
  62                 NULL
  63         };
  64         int i;
  65         const char *p;
  66
  67         p = nvram_safe_get("ipv6_service");
  68         for (i = 0; names[i] != NULL; ++i) {
  69                 if (strcmp(p, names[i]) == 0) return i + 1;
  70         }
  71         return IPV6_DISABLED;
  72 }
  73
  74 const char *ipv6_router_address(struct in6_addr *in6addr)
  75 {
  76         char *p;
  77         struct in6_addr addr;
  78         static char addr6[INET6_ADDRSTRLEN];
  79
  80         addr6[0] = '\0';
  81
  82         if ((p = nvram_get("ipv6_rtr_addr")) && *p) {
  83                 inet_pton(AF_INET6, p, &addr);
  84         }
  85         else if ((p = nvram_get("ipv6_prefix")) && *p) {
  86                 inet_pton(AF_INET6, p, &addr);
  87                 addr.s6_addr16[7] = htons(0x0001);
  88         }
  89         else {
  90                 return addr6;
  91         }
  92
  93         inet_ntop(AF_INET6, &addr, addr6, sizeof(addr6));
  94         if (in6addr)
  95                 memcpy(in6addr, &addr, sizeof(addr));
  96
  97         return addr6;
  98 }
  99 #endif
 100
 101 int using_dhcpc(void)
 102 {
 103         switch (get_wan_proto()) {
 104         case WP_DHCP:
 105                 return 1;
 106         case WP_L2TP:
 107         case WP_PPTP:
 108                 return nvram_get_int("pptp_dhcp");
 109         }
 110         return 0;
 111 }
 112
 113 int wl_client(int unit, int subunit)
 114 {
 115         char *mode = nvram_safe_get(wl_nvname("mode", unit, subunit));
 116
 117         return ((strcmp(mode, "sta") == 0) || (strcmp(mode, "wet") == 0));
 118 }
 119
 120 int foreach_wif(int include_vifs, void *param,
 121         int (*func)(int idx, int unit, int subunit, void *param))
 122 {
 123         char ifnames[256];
 124         char name[64], ifname[64], *next = NULL;
 125         int unit = -1, subunit = -1;
 126         int i;
 127         int ret = 0;
 128
 129         snprintf(ifnames, sizeof(ifnames), "%s %s %s %s %s %s %s %s %s %s",
 130                 nvram_safe_get("lan_ifnames"),
 131                 nvram_safe_get("lan1_ifnames"),
 132                 nvram_safe_get("lan2_ifnames"),
 133                 nvram_safe_get("lan3_ifnames"),
 134                 nvram_safe_get("wan_ifnames"),
 135                 nvram_safe_get("wl_ifname"),
 136                 nvram_safe_get("wl0_ifname"),
 137                 nvram_safe_get("wl0_vifs"),
 138                 nvram_safe_get("wl1_ifname"),
 139                 nvram_safe_get("wl1_vifs"));
 140         remove_dups(ifnames, sizeof(ifnames));
 141
 142         i = 0;
 143         foreach(name, ifnames, next) {
 144                 if (nvifname_to_osifname(name, ifname, sizeof(ifname)) != 0)
 145                         continue;
 146
 147                 if (wl_probe(ifname) || wl_ioctl(ifname, WLC_GET_INSTANCE, &unit, sizeof(unit)))
 148                         continue;
 149
 150                 // Convert eth name to wl name
 151                 if (osifname_to_nvifname(name, ifname, sizeof(ifname)) != 0)
 152                         continue;
 153
 154                 // Slave intefaces have a '.' in the name
 155                 if (strchr(ifname, '.') && !include_vifs)
 156                         continue;
 157
 158                 if (get_ifname_unit(ifname, &unit, &subunit) < 0)
 159                         continue;
 160
 161                 ret |= func(i++, unit, subunit, param);
 162         }
 163         return ret;
 164 }
 165
 166 void notice_set(const char *path, const char *format, ...)
 167 {
 168         char p[256];
 169         char buf[2048];
 170         va_list args;
 171
 172         va_start(args, format);
 173         vsnprintf(buf, sizeof(buf), format, args);
 174         va_end(args);
 175
 176         mkdir("/var/notice", 0755);
 177         snprintf(p, sizeof(p), "/var/notice/%s", path);
 178         f_write_string(p, buf, 0, 0);
 179         if (buf[0]) syslog(LOG_INFO, "notice[%s]: %s", path, buf);
 180 }
 181
 182
 183 //      #define _x_dprintf(args...)     syslog(LOG_DEBUG, args);
 184 #define _x_dprintf(args...)     do { } while (0);
 185
 186 int check_wanup(void)
 187 {
 188         int up = 0;
 189         int proto;
 190         char buf1[64];
 191         char buf2[64];
 192         const char *name;
 193         int f;
 194         struct ifreq ifr;
 195
 196         proto = get_wan_proto();
 197         if (proto == WP_DISABLED)
 198         {
 199                 if (nvram_match("boardrev", "0x11")) { // Ovislink 1600GL - led "connected" off
 200                         led(LED_WHITE,LED_OFF);
 201                 }
 202                  return 0;
 203         }
 204
 205         if ((proto == WP_PPTP) || (proto == WP_L2TP) || (proto == WP_PPPOE)) {
 206                 if (f_read_string("/tmp/ppp/link", buf1, sizeof(buf1)) > 0) {
 207                                 // contains the base name of a file in /var/run/ containing pid of a daemon
 208                                 snprintf(buf2, sizeof(buf2), "/var/run/%s.pid", buf1);
 209                                 if (f_read_string(buf2, buf1, sizeof(buf1)) > 0) {
 210                                         name = psname(atoi(buf1), buf2, sizeof(buf2));
 211                                         if (strcmp(name, "pppd") == 0) up = 1;
 212                                 }
 213                                 else {
 214                                         _dprintf("%s: error reading %s\n", __FUNCTION__, buf2);
 215                                 }
 216                         if (!up) {
 217                                 unlink("/tmp/ppp/link");
 218                                 _x_dprintf("required daemon not found, assuming link is dead\n");
 219                         }
 220                 }
 221                 else {
 222                         _x_dprintf("%s: error reading %s\n", __FUNCTION__, "/tmp/ppp/link");
 223                 }
 224         }
 225         else if (!nvram_match("wan_ipaddr", "0.0.0.0")) {
 226                 up = 1;
 227         }
 228         else {
 229                 _x_dprintf("%s: default !up\n", __FUNCTION__);
 230         }
 231
 232         if ((up) && ((f = socket(AF_INET, SOCK_DGRAM, 0)) >= 0)) {
 233                 strlcpy(ifr.ifr_name, nvram_safe_get("wan_iface"), sizeof(ifr.ifr_name));
 234                 if (ioctl(f, SIOCGIFFLAGS, &ifr) < 0) {
 235                         up = 0;
 236                         _x_dprintf("%s: SIOCGIFFLAGS\n", __FUNCTION__);
 237                 }
 238                 close(f);
 239                 if ((ifr.ifr_flags & IFF_UP) == 0) {
 240                         up = 0;
 241                         _x_dprintf("%s: !IFF_UP\n", __FUNCTION__);
 242                 }
 243         }
 244         if (nvram_match("boardrev", "0x11")) { // Ovislink 1600GL - led "connected" on
 245                 led(LED_WHITE,up);
 246         }
 247
 248         return up;
 249 }
 250
 251
 252 const dns_list_t *get_dns(void)
 253 {
 254         static dns_list_t dns;
 255         char s[512];
 256         int n;
 257         int i, j;
 258         struct in_addr ia;
 259         char d[7][22];
 260         unsigned short port;
 261         char *c;
 262
 263         dns.count = 0;
 264
 265         strlcpy(s, nvram_safe_get("wan_dns"), sizeof(s));
 266         if ((nvram_get_int("dns_addget")) || (s[0] == 0)) {
 267                 n = strlen(s);
 268                 snprintf(s + n, sizeof(s) - n, " %s", nvram_safe_get("wan_get_dns"));
 269         }
 270
 271         n = sscanf(s, "%21s %21s %21s %21s %21s %21s %21s", d[0], d[1], d[2], d[3], d[4], d[5], d[6]);
 272         for (i = 0; i < n; ++i) {
 273                 port = 53;
 274
 275                 if ((c = strchr(d[i], ':')) != NULL) {
 276                         *c++ = 0;
 277                         if (((j = atoi(c)) < 1) || (j > 0xFFFF)) continue;
 278                         port = j;
 279                 }
 280
 281                 if (inet_pton(AF_INET, d[i], &ia) > 0) {
 282                         for (j = dns.count - 1; j >= 0; --j) {
 283                                 if ((dns.dns[j].addr.s_addr == ia.s_addr) && (dns.dns[j].port == port)) break;
 284                         }
 285                         if (j < 0) {
 286                                 dns.dns[dns.count].port = port;
 287                                 dns.dns[dns.count++].addr.s_addr = ia.s_addr;
 288                                 if (dns.count == 6) break;
 289                         }
 290                 }
 291         }
 292
 293         return &dns;
 294 }
 295
 296 // -----------------------------------------------------------------------------
 297
 298 void set_action(int a)
 299 {
 300         int r = 3;
 301         while (f_write("/var/lock/action", &a, sizeof(a), 0, 0) != sizeof(a)) {
 302                 sleep(1);
 303                 if (--r == 0) return;
 304         }
 305         if (a != ACT_IDLE) sleep(2);
 306 }
 307
 308 int check_action(void)
 309 {
 310         int a;
 311         int r = 3;
 312
 313         while (f_read("/var/lock/action", &a, sizeof(a)) != sizeof(a)) {
 314                 sleep(1);
 315                 if (--r == 0) return ACT_UNKNOWN;
 316         }
 317         return a;
 318 }
 319
 320 int wait_action_idle(int n)
 321 {
 322         while (n-- > 0) {
 323                 if (check_action() == ACT_IDLE) return 1;
 324                 sleep(1);
 325         }
 326         return 0;
 327 }
 328
 329 // -----------------------------------------------------------------------------
 330
 331 const wanface_list_t *get_wanfaces(void)
 332 {
 333         static wanface_list_t wanfaces;
 334         char *ip, *iface;
 335         int proto;
 336
 337         wanfaces.count = 0;
 338
 339         switch ((proto = get_wan_proto())) {
 340                 case WP_PPTP:
 341                 case WP_L2TP:
 342                         while (wanfaces.count < 2) {
 343                                 if (wanfaces.count == 0) {
 344                                         ip = nvram_safe_get("ppp_get_ip");
 345                                         iface = nvram_safe_get("wan_iface");
 346                                         if (!(*iface)) iface = "ppp+";
 347                                 }
 348                                 else /* if (wanfaces.count == 1) */ {
 349                                         ip = nvram_safe_get("wan_ipaddr");
 350                                         if ((!(*ip) || strcmp(ip, "0.0.0.0") == 0) && (wanfaces.count > 0))
 351                                                 iface = "";
 352                                         else
 353                                                 iface = nvram_safe_get("wan_ifname");
 354                                 }
 355                                 strlcpy(wanfaces.iface[wanfaces.count].ip, ip, sizeof(wanfaces.iface[0].ip));
 356                                 strlcpy(wanfaces.iface[wanfaces.count].name, iface, IFNAMSIZ);
 357                                 ++wanfaces.count;
 358                         }
 359                         break;
 360                 default:
 361                         ip = (proto == WP_DISABLED) ? "0.0.0.0" : nvram_safe_get("wan_ipaddr");
 362                         if (proto == WP_PPPOE) {
 363                                 iface = nvram_safe_get("wan_iface");
 364                                 if (!(*iface)) iface = "ppp+";
 365                         }
 366                         else {
 367                                 iface = nvram_safe_get("wan_ifname");
 368                         }
 369                         strlcpy(wanfaces.iface[wanfaces.count].ip, ip, sizeof(wanfaces.iface[0].ip));
 370                         strlcpy(wanfaces.iface[wanfaces.count++].name, iface, IFNAMSIZ);
 371                         break;
 372         }
 373
 374         return &wanfaces;
 375 }
 376
 377 const char *get_wanface(void)
 378 {
 379         return (*get_wanfaces()).iface[0].name;
 380 }
 381
 382 #ifdef TCONFIG_IPV6
 383 const char *get_wan6face(void)
 384 {
 385         switch (get_ipv6_service()) {
 386         case IPV6_NATIVE:
 387         case IPV6_NATIVE_DHCP:
 388                 return get_wanface();
 389         case IPV6_ANYCAST_6TO4:
 390                 return "v6to4";
 391         case IPV6_6IN4:
 392                 return "v6in4";
 393         }
 394         return nvram_safe_get("ipv6_ifname");
 395 }
 396 #endif
 397
 398 const char *get_wanip(void)
 399 {
 400         if (!check_wanup()) return "0.0.0.0";
 401
 402         return (*get_wanfaces()).iface[0].ip;
 403 }
 404
 405 const char *getifaddr(char *ifname, int family, int linklocal)
 406 {
 407         static char buf[INET6_ADDRSTRLEN];
 408         void *addr = NULL;
 409         struct ifaddrs *ifap, *ifa;
 410
 411         if (getifaddrs(&ifap) != 0) {
 412                 _dprintf("getifaddrs failed: %s\n", strerror(errno));
 413                 return NULL;
 414         }
 415
 416         for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
 417                 if ((ifa->ifa_addr == NULL) ||
 418                     (strncmp(ifa->ifa_name, ifname, IFNAMSIZ) != 0) ||
 419                     (ifa->ifa_addr->sa_family != family))
 420                         continue;
 421
 422 #ifdef TCONFIG_IPV6
 423                 if (ifa->ifa_addr->sa_family == AF_INET6) {
 424                         struct sockaddr_in6 *s6 = (struct sockaddr_in6 *)(ifa->ifa_addr);
 425                         if (IN6_IS_ADDR_LINKLOCAL(&s6->sin6_addr) ^ linklocal)
 426                                 continue;
 427                         addr = (void *)&(s6->sin6_addr);
 428                 }
 429                 else
 430 #endif
 431                 {
 432                         struct sockaddr_in *s = (struct sockaddr_in *)(ifa->ifa_addr);
 433                         addr = (void *)&(s->sin_addr);
 434                 }
 435
 436                 if ((addr) && inet_ntop(ifa->ifa_addr->sa_family, addr, buf, sizeof(buf)) != NULL) {
 437                         freeifaddrs(ifap);
 438                         return buf;
 439                 }
 440         }
 441
 442         freeifaddrs(ifap);
 443         return NULL;
 444 }
 445
 446 // -----------------------------------------------------------------------------
 447
 448 long get_uptime(void)
 449 {
 450         struct sysinfo si;
 451         sysinfo(&si);
 452         return si.uptime;
 453 }
 454
 455 char *wl_nvname(const char *nv, int unit, int subunit)
 456 {
 457         static char tmp[128];
 458         char prefix[] = "wlXXXXXXXXXX_";
 459
 460         if (unit < 0)
 461                 strcpy(prefix, "wl_");
 462         else if (subunit > 0)
 463                 snprintf(prefix, sizeof(prefix), "wl%d.%d_", unit, subunit);
 464         else
 465                 snprintf(prefix, sizeof(prefix), "wl%d_", unit);
 466         return strcat_r(prefix, nv, tmp);
 467 }
 468
 469 int get_radio(int unit)
 470 {
 471         uint32 n;
 472
 473         return (wl_ioctl(nvram_safe_get(wl_nvname("ifname", unit, 0)), WLC_GET_RADIO, &n, sizeof(n)) == 0) &&
 474                 ((n & WL_RADIO_SW_DISABLE)  == 0);
 475 }
 476
 477 void set_radio(int on, int unit)
 478 {
 479         uint32 n;
 480
 481 #ifndef WL_BSS_INFO_VERSION
 482 #error WL_BSS_INFO_VERSION
 483 #endif
 484
 485 #if WL_BSS_INFO_VERSION >= 108
 486         n = on ? (WL_RADIO_SW_DISABLE << 16) : ((WL_RADIO_SW_DISABLE << 16) | 1);
 487         wl_ioctl(nvram_safe_get(wl_nvname("ifname", unit, 0)), WLC_SET_RADIO, &n, sizeof(n));
 488         if (!on) {
 489                 led(LED_WLAN, 0);
 490                 led(LED_DIAG, 0);
 491         }
 492 #else
 493         n = on ? 0 : WL_RADIO_SW_DISABLE;
 494         wl_ioctl(nvram_safe_get(wl_nvname("ifname", unit, 0)), WLC_SET_RADIO, &n, sizeof(n));
 495         if (!on) {
 496                 led(LED_DIAG, 0);
 497         }
 498 #endif
 499 }
 500
 501 // -----------------------------------------------------------------------------
 502
 503 int mtd_getinfo(const char *mtdname, int *part, int *size)
 504 {
 505         FILE *f;
 506         char s[256];
 507         char t[256];
 508         int r;
 509
 510         r = 0;
 511         if ((strlen(mtdname) < 128) && (strcmp(mtdname, "pmon") != 0)) {
 512                 sprintf(t, "\"%s\"", mtdname);
 513                 if ((f = fopen("/proc/mtd", "r")) != NULL) {
 514                         while (fgets(s, sizeof(s), f) != NULL) {
 515                                 if ((sscanf(s, "mtd%d: %x", part, size) == 2) && (strstr(s, t) != NULL)) {
 516                                         // don't accidentally mess with bl (0)
 517                                         if (*part > 0) r = 1;
 518                                         break;
 519                                 }
 520                         }
 521                         fclose(f);
 522                 }
 523         }
 524         if (!r) {
 525                 *size = 0;
 526                 *part = -1;
 527         }
 528         return r;
 529 }
 530
 531 // -----------------------------------------------------------------------------
 532
 533 int nvram_get_int(const char *key)
 534 {
 535         return atoi(nvram_safe_get(key));
 536 }
 537
 538 /*
 539 long nvram_xget_long(const char *name, long min, long max, long def)
 540 {
 541         const char *p;
 542         char *e;
 543         long n;
 544
 545         p = nvram_get(name);
 546         if ((p != NULL) && (*p != 0)) {
 547                 n = strtol(p, &e, 0);
 548                 if ((e != p) && ((*e == 0) || (*e == ' ')) && (n > min) && (n < max)) {
 549                         return n;
 550                 }
 551         }
 552         return def;
 553 }
 554 */
 555
 556 int nvram_get_file(const char *key, const char *fname, int max)
 557 {
 558         int n;
 559         char *p;
 560         char *b;
 561         int r;
 562
 563         r = 0;
 564         p = nvram_safe_get(key);
 565         n = strlen(p);
 566         if (n <= max) {
 567                 if ((b = malloc(base64_decoded_len(n) + 128)) != NULL) {
 568                         n = base64_decode(p, b, n);
 569                         if (n > 0) r = (f_write(fname, b, n, 0, 0644) == n);
 570                         free(b);
 571                 }
 572         }
 573         return r;
 574 /*
 575         char b[2048];
 576         int n;
 577         char *p;
 578
 579         p = nvram_safe_get(key);
 580         n = strlen(p);
 581         if (n <= max) {
 582                 n = base64_decode(p, b, n);
 583                 if (n > 0) return (f_write(fname, b, n, 0, 0700) == n);
 584         }
 585         return 0;
 586 */
 587 }
 588
 589 int nvram_set_file(const char *key, const char *fname, int max)
 590 {
 591         char *in;
 592         char *out;
 593         long len;
 594         int n;
 595         int r;
 596
 597         if ((len = f_size(fname)) > max) return 0;
 598         max = (int)len;
 599         r = 0;
 600         if (f_read_alloc(fname, &in, max) == max) {
 601                 if ((out = malloc(base64_encoded_len(max) + 128)) != NULL) {
 602                         n = base64_encode(in, out, max);
 603                         out[n] = 0;
 604                         nvram_set(key, out);
 605                         free(out);
 606                         r = 1;
 607                 }
 608                 free(in);
 609         }
 610         return r;
 611 /*
 612         char a[2048];
 613         char b[4096];
 614         int n;
 615
 616         if (((n = f_read(fname, &a, sizeof(a))) > 0) && (n <= max)) {
 617                 n = base64_encode(a, b, n);
 618                 b[n] = 0;
 619                 nvram_set(key, b);
 620                 return 1;
 621         }
 622         return 0;
 623 */
 624 }
 625
 626 int nvram_contains_word(const char *key, const char *word)
 627 {
 628         return (find_word(nvram_safe_get(key), word) != NULL);
 629 }
 630
 631 int nvram_is_empty(const char *key)
 632 {
 633         char *p;
 634         return (((p = nvram_get(key)) == NULL) || (*p == 0));
 635 }
 636
 637 void nvram_commit_x(void)
 638 {
 639         if (!nvram_get_int("debug_nocommit")) nvram_commit();
 640 }
 641
 642 int connect_timeout(int fd, const struct sockaddr *addr, socklen_t len, int timeout)
 643 {
 644         fd_set fds;
 645         struct timeval tv;
 646         int flags;
 647         int n;
 648         int r;
 649
 650         if (((flags = fcntl(fd, F_GETFL, 0)) < 0) ||
 651                 (fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0)) {
 652                 _dprintf("%s: error in F_*ETFL %d\n", __FUNCTION__, fd);
 653                 return -1;
 654         }
 655
 656         if (connect(fd, addr, len) < 0) {
 657 //              _dprintf("%s: connect %d = <0\n", __FUNCTION__, fd);
 658
 659                 if (errno != EINPROGRESS) {
 660                         _dprintf("%s: error in connect %d errno=%d\n", __FUNCTION__, fd, errno);
 661                         return -1;
 662                 }
 663
 664                 while (1) {
 665                         tv.tv_sec = timeout;
 666                         tv.tv_usec = 0;
 667                         FD_ZERO(&fds);
 668                         FD_SET(fd, &fds);
 669                         r = select(fd + 1, NULL, &fds, NULL, &tv);
 670                         if (r == 0) {
 671                                 _dprintf("%s: timeout in select %d\n", __FUNCTION__, fd);
 672                                 return -1;
 673                         }
 674                         else if (r < 0) {
 675                                 if (errno != EINTR) {
 676                                         _dprintf("%s: error in select %d\n", __FUNCTION__, fd);
 677                                         return -1;
 678                                 }
 679                                 // loop
 680                         }
 681                         else {
 682                                 r = 0;
 683                                 n = sizeof(r);
 684                                 if ((getsockopt(fd, SOL_SOCKET, SO_ERROR, &r, &n) < 0) || (r != 0)) {
 685                                         _dprintf("%s: error in SO_ERROR %d\n", __FUNCTION__, fd);
 686                                         return -1;
 687                                 }
 688                                 break;
 689                         }
 690                 }
 691         }
 692
 693         if (fcntl(fd, F_SETFL, flags) < 0) {
 694                 _dprintf("%s: error in F_*ETFL %d\n", __FUNCTION__, fd);
 695                 return -1;
 696         }
 697
 698 //      _dprintf("%s: OK %d\n", __FUNCTION__, fd);
 699         return 0;
 700 }
 701
 702 void chld_reap(int sig)
 703 {
 704         while (waitpid(-1, NULL, WNOHANG) > 0) {}
 705 }
 706
 707 /*
 708 int time_ok(void)
 709 {
 710         return time(0) > Y2K;
 711 }
 712 */