if (ioctl(skfd, SIOCGIFBRDADDR, &ifr) >= 0) ife->broadaddr = ifr.ifr_broadaddr;

    strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
    memset(&ife->netmask, 0, sizeof(struct sockaddr));
    if (ioctl(skfd, SIOCGIFNETMASK, &ifr) >= 0) ife->netmask = ifr.ifr_netmask;
  }

  close(skfd);
  return 0;
}

int if_readconf(void) {
  int numreqs = 30;
  struct ifconf ifc;
  struct ifreq *ifr;
  int n, err = -1;
  int skfd;

  ifc.ifc_buf = NULL;

  skfd = socket(AF_INET, SOCK_DGRAM, 0);
  if (skfd < 0) {
    fprintf(stderr, "error: no inet socket available");
    return -1;
  }

  for (;;) {
    ifc.ifc_len = sizeof(struct ifreq) * numreqs;
    ifc.ifc_buf = xrealloc(ifc.ifc_buf, ifc.ifc_len);

    if (ioctl_or_warn(skfd, SIOCGIFCONF, &ifc) < 0) {
      goto out;
    }
    if (ifc.ifc_len == sizeof(struct ifreq) * numreqs) {
      numreqs += 10;
      continue;
    }
    break;
  }

  ifr = ifc.ifc_req;
  for (n = 0; n < ifc.ifc_len; n += sizeof(struct ifreq)) {
    add_interface(ifr->ifr_name);
    ifr++;
  }
  err = 0;

 out:
  close(skfd);
  free(ifc.ifc_buf);
  return err;
}

int if_readlist_proc() {
  static int proc_read;

  FILE *fh;
  char buf[512];
  struct interface *ife;
  int err, procnetdev_vsn;
  proc_read = 1;

  fh = fopen(_PATH_PROCNET_DEV, "r");
  if (!fh) {
    fprintf(stderr, "warning: cannot open %s, limiting output", _PATH_PROCNET_DEV);
    return if_readconf();
  }
  fgets(buf, sizeof buf, fh);
  fgets(buf, sizeof buf, fh);

  procnetdev_vsn = procnetdev_version(buf);

  err = 0;
  while (fgets(buf, sizeof buf, fh)) {
    char *s, name[128];

    s = get_name(name, buf);
    ife = add_interface(name);
    get_dev_fields(s, ife, procnetdev_vsn);
    ife->statistics_valid = 1;
  }
  if (ferror(fh)) {
    fprintf(stderr, "read error: %s", _PATH_PROCNET_DEV);
    err = -1;
    proc_read = 0;
  }
  fclose(fh);
  return err;
}

int if_readlist(void) {
  int err = if_readlist_proc(NULL);
  if (!err) {
    err = if_readconf();
  }
  return err;
}

int ioctl_or_warn(int fd, int request, void *argp) {
  int ret;

  ret = ioctl(fd, request, argp);
  if (ret < 0) fprintf(stderr, "ioctl %#x failed", request);
  return ret;
}

struct interface *add_interface(char *name) {
  struct interface *ife, **nextp, *new;

  for (ife = int_last; ife; ife = ife->prev) {
    int n = strcmp(ife->name, name);

    if (n == 0) return ife;
    if (n < 0) break;
  }

  new = xzalloc(sizeof(*new));
  safe_strncpy(new->name, name, IFNAMSIZ);
  nextp = ife ? &ife->next : &int_list;
  new->prev = ife;
  new->next = *nextp;
  if (new->next) new->next->prev = new;
  else int_last = new;
  *nextp = new;
  return new;
}

void get_dev_fields(char *bp, struct interface *ife, int procnetdev_vsn) {
  memset(&ife->stats, 0, sizeof(struct user_net_device_stats));

  sscanf(bp, ss_fmt[procnetdev_vsn],
       &ife->stats.rx_bytes,
       &ife->stats.rx_packets,
       &ife->stats.rx_errors,
       &ife->stats.rx_dropped,
       &ife->stats.rx_fifo_errors,
       &ife->stats.rx_frame_errors,
       &ife->stats.rx_compressed,
       &ife->stats.rx_multicast,
       &ife->stats.tx_bytes,
       &ife->stats.tx_packets,
       &ife->stats.tx_errors,
       &ife->stats.tx_dropped,
       &ife->stats.tx_fifo_errors,
       &ife->stats.collisions,
       &ife->stats.tx_carrier_errors,
       &ife->stats.tx_compressed
       );

  if (procnetdev_vsn <= 1) {
    if (procnetdev_vsn == 0) {
      ife->stats.rx_bytes = 0;
      ife->stats.tx_bytes = 0;
    }
    ife->stats.rx_multicast = 0;
    ife->stats.rx_compressed = 0;
    ife->stats.tx_compressed = 0;
  }
}

char *get_name(char *name, char *p) {
  int namestart = 0, nameend = 0;

  while (isspace(p[namestart]))
    namestart++;
  nameend = namestart;
  while (p[nameend] && p[nameend] != ':' && !isspace(p[nameend]))
    nameend++;
  if (p[nameend] == ':') {
    if ((nameend - namestart) < IFNAMSIZ) {
      memcpy(name, &p[namestart], nameend - namestart);
      name[nameend - namestart] = '\0';
      p = &p[nameend];
    } else {
      name[0] = '\0';
    }
  } else {
    name[0] = '\0';
  }
  return p + 1;
}

/* memory functions */
void *xrealloc(void *ptr, size_t size) {
  ptr = realloc(ptr, size);
  if (ptr == NULL && size != 0) {
    fprintf(stderr, "cannot allocate memory");
    exit(1);
  }
  return ptr;
}

void *xmalloc(size_t size) {
  void *ptr = malloc(size);
  if (ptr == NULL && size != 0) {
    fprintf(stderr, "cannot allocate memory");
    exit(1);
  }
  return ptr;
}

void *xzalloc(size_t size) {
  void *ptr = xmalloc(size);
  memset(ptr, 0, size);
  return ptr;
}

char *safe_strncpy(char *dst, const char *src, size_t size) {
  if (!size) return dst;
  dst[--size] = '\0';
  return strncpy(dst, src, size);
}

char *xasprintf(const char *format, ...) {
  va_list p;
  int r;
  char *string_ptr;

  va_start(p, format);
  r = vasprintf(&string_ptr, format, p);
  va_end(p);

  if (r < 0) {
    fprintf(stderr, "cannot allocate memory");
    exit(1);
  }
  return string_ptr;
}

char * xstrdup(const char *s) {
  char *t;

  if (s == NULL)
    return NULL;

  t = strdup(s);

  if (t == NULL) {
    fprintf(stderr, "cannot allocate memory");
    exit(1);
  }
  return t;
}

inline int procnetdev_version(char *buf) {
  if (strstr(buf, "compressed")) return 2;
  if (strstr(buf, "bytes")) return 1;
  return 0;
}

const struct hwtype *get_hwntype(int type) {
  const struct hwtype *const *hwp;

  hwp = hwtypes;
  while (*hwp != NULL) {
    if ((*hwp)->type == type)
      return *hwp;
    hwp++;
  }
  return NULL;
}

const struct aftype *get_afntype(int af) {
  const struct aftype *const *afp;

  afp = aftypes;
  while (*afp != NULL) {
    if ((*afp)->af == af)
      return *afp;
    afp++;
  }
  return NULL;
}

char *print_ether(unsigned char *ptr) {
  static char *buff;

  free(buff);
  buff = xasprintf("%02X:%02X:%02X:%02X:%02X:%02X",
       (ptr[0] & 0377), (ptr[1] & 0377), (ptr[2] & 0377),
       (ptr[3] & 0377), (ptr[4] & 0377), (ptr[5] & 0377)
    );
  return buff;
}

const char *sprint_inet(struct sockaddr *sap, int numeric) {
  static char *buff;
  free(buff);

  if (sap->sa_family == 0xFFFF || sap->sa_family == 0) {
    return "*";
  }
  buff = inet_addr((struct sockaddr_in *) sap);
  return buff;
}

const char *sprint_unspec(struct sockaddr *sap, int numeric) {
  if (sap->sa_family == 0xFFFF || sap->sa_family == 0)
    return "*";
  return print_unspec((unsigned char *)sap->sa_data);
}

char *print_unspec(unsigned char *ptr) {
  static char *buff;

  char *pos;
  unsigned int i;

  if (!buff);
    buff = xmalloc(sizeof(struct sockaddr) * 3 + 1);
  pos = buff;
  for (i = 0; i < sizeof(struct sockaddr); i++) {
    sprintf(pos, "%02X-", (*ptr++ & 0377));
    pos += 3;
  }
  *--pos = '\0';
  return buff;
}

char *inet_addr(struct sockaddr_in *s_in) {
  uint32_t ad;
  if (s_in->sin_family != AF_INET) {
    errno = EAFNOSUPPORT;
    return NULL;
  }
  ad = s_in->sin_addr.s_addr;

  if (ad == INADDR_ANY) {
    return xstrdup("*");
  }

  return xstrdup((const char *) inet_ntoa(s_in->sin_addr));
}