2001-03-06 00:48:59 +00:00
|
|
|
/*
|
2004-03-15 08:29:22 +00:00
|
|
|
* stolen from net-tools-1.59 and stripped down for busybox by
|
2003-07-14 21:21:08 +00:00
|
|
|
* Erik Andersen <andersen@codepoet.org>
|
2001-10-24 05:00:29 +00:00
|
|
|
*
|
|
|
|
* Heavily modified by Manuel Novoa III Mar 12, 2001
|
|
|
|
*
|
|
|
|
* Added print_bytes_scaled function to reduce code size.
|
|
|
|
* Added some (potentially) missing defines.
|
|
|
|
* Improved display support for -a and for a named interface.
|
|
|
|
*
|
|
|
|
* -----------------------------------------------------------
|
|
|
|
*
|
2001-03-06 00:48:59 +00:00
|
|
|
* ifconfig This file contains an implementation of the command
|
|
|
|
* that either displays or sets the characteristics of
|
|
|
|
* one or more of the system's networking interfaces.
|
|
|
|
*
|
2004-08-26 21:45:21 +00:00
|
|
|
* Version: $Id: interface.c,v 1.25 2004/08/26 21:45:21 andersen Exp $
|
2001-03-06 00:48:59 +00:00
|
|
|
*
|
|
|
|
* Author: Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
|
|
|
|
* and others. Copyright 1993 MicroWalt Corporation
|
|
|
|
*
|
2006-06-03 21:23:20 +00:00
|
|
|
* Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
|
2001-03-06 00:48:59 +00:00
|
|
|
*
|
|
|
|
* Patched to support 'add' and 'del' keywords for INET(4) addresses
|
|
|
|
* by Mrs. Brisby <mrs.brisby@nimh.org>
|
|
|
|
*
|
|
|
|
* {1.34} - 19980630 - Arnaldo Carvalho de Melo <acme@conectiva.com.br>
|
|
|
|
* - gettext instead of catgets for i18n
|
2004-03-15 08:29:22 +00:00
|
|
|
* 10/1998 - Andi Kleen. Use interface list primitives.
|
|
|
|
* 20001008 - Bernd Eckenfels, Patch from RH for setting mtu
|
2001-03-06 00:48:59 +00:00
|
|
|
* (default AF was wrong)
|
2001-03-12 09:57:59 +00:00
|
|
|
*/
|
|
|
|
|
2001-11-10 11:22:46 +00:00
|
|
|
#include "inet_common.h"
|
2001-03-06 00:48:59 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <unistd.h>
|
2001-11-10 11:22:46 +00:00
|
|
|
#include <fcntl.h>
|
|
|
|
#include <ctype.h>
|
|
|
|
#include <sys/ioctl.h>
|
2003-07-22 08:56:55 +00:00
|
|
|
#include <sys/types.h>
|
2001-11-10 11:22:46 +00:00
|
|
|
#include <net/if.h>
|
|
|
|
#include <net/if_arp.h>
|
2006-04-05 16:21:37 +00:00
|
|
|
#include "busybox.h"
|
2001-03-06 00:48:59 +00:00
|
|
|
|
2003-08-29 11:34:08 +00:00
|
|
|
#ifdef CONFIG_FEATURE_IPV6
|
|
|
|
# define HAVE_AFINET6 1
|
|
|
|
#else
|
|
|
|
# undef HAVE_AFINET6
|
|
|
|
#endif
|
|
|
|
|
2001-03-06 00:48:59 +00:00
|
|
|
#define _PATH_PROCNET_DEV "/proc/net/dev"
|
2002-07-03 11:46:38 +00:00
|
|
|
#define _PATH_PROCNET_IFINET6 "/proc/net/if_inet6"
|
2001-03-06 00:48:59 +00:00
|
|
|
|
|
|
|
#if HAVE_AFINET6
|
|
|
|
|
|
|
|
#ifndef _LINUX_IN6_H
|
|
|
|
/*
|
|
|
|
* This is in linux/include/net/ipv6.h.
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct in6_ifreq {
|
2002-08-22 19:35:36 +00:00
|
|
|
struct in6_addr ifr6_addr;
|
2003-08-29 11:34:08 +00:00
|
|
|
uint32_t ifr6_prefixlen;
|
2002-08-22 19:35:36 +00:00
|
|
|
unsigned int ifr6_ifindex;
|
2001-03-06 00:48:59 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
#endif /* HAVE_AFINET6 */
|
2001-03-06 00:48:59 +00:00
|
|
|
|
2001-03-12 09:57:59 +00:00
|
|
|
/* Defines for glibc2.0 users. */
|
|
|
|
#ifndef SIOCSIFTXQLEN
|
|
|
|
#define SIOCSIFTXQLEN 0x8943
|
|
|
|
#define SIOCGIFTXQLEN 0x8942
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* ifr_qlen is ifru_ivalue, but it isn't present in 2.0 kernel headers */
|
|
|
|
#ifndef ifr_qlen
|
|
|
|
#define ifr_qlen ifr_ifru.ifru_mtu
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef HAVE_TXQUEUELEN
|
|
|
|
#define HAVE_TXQUEUELEN 1
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef IFF_DYNAMIC
|
2002-08-22 19:35:36 +00:00
|
|
|
#define IFF_DYNAMIC 0x8000 /* dialup device with changing addresses */
|
2001-03-12 09:57:59 +00:00
|
|
|
#endif
|
|
|
|
|
2001-03-06 00:48:59 +00:00
|
|
|
/* This structure defines protocol families and their handlers. */
|
|
|
|
struct aftype {
|
2002-08-22 19:35:36 +00:00
|
|
|
const char *name;
|
|
|
|
const char *title;
|
|
|
|
int af;
|
|
|
|
int alen;
|
|
|
|
char *(*print) (unsigned char *);
|
|
|
|
char *(*sprint) (struct sockaddr *, int numeric);
|
|
|
|
int (*input) (int type, char *bufp, struct sockaddr *);
|
|
|
|
void (*herror) (char *text);
|
|
|
|
int (*rprint) (int options);
|
|
|
|
int (*rinput) (int typ, int ext, char **argv);
|
|
|
|
|
|
|
|
/* may modify src */
|
|
|
|
int (*getmask) (char *src, struct sockaddr * mask, char *name);
|
|
|
|
|
|
|
|
int fd;
|
|
|
|
char *flag_file;
|
2001-03-06 00:48:59 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/* Display an Internet socket address. */
|
|
|
|
static char *INET_sprint(struct sockaddr *sap, int numeric)
|
|
|
|
{
|
2002-08-22 19:35:36 +00:00
|
|
|
static char buff[128];
|
2001-03-06 00:48:59 +00:00
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
if (sap->sa_family == 0xFFFF || sap->sa_family == 0)
|
2006-05-29 04:37:28 +00:00
|
|
|
return safe_strncpy(buff, "[NONE SET]", sizeof(buff));
|
2001-03-06 00:48:59 +00:00
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
if (INET_rresolve(buff, sizeof(buff), (struct sockaddr_in *) sap,
|
|
|
|
numeric, 0xffffff00) != 0)
|
|
|
|
return (NULL);
|
2001-03-06 00:48:59 +00:00
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
return (buff);
|
2001-03-06 00:48:59 +00:00
|
|
|
}
|
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
static struct aftype inet_aftype = {
|
2006-06-20 15:52:52 +00:00
|
|
|
.name = "inet",
|
|
|
|
.title = "DARPA Internet",
|
|
|
|
.af = AF_INET,
|
2006-06-20 21:13:29 +00:00
|
|
|
.alen = 4,
|
2006-06-20 15:52:52 +00:00
|
|
|
.sprint = INET_sprint,
|
|
|
|
.fd = -1
|
2001-03-06 00:48:59 +00:00
|
|
|
};
|
|
|
|
|
2002-07-03 11:46:38 +00:00
|
|
|
#if HAVE_AFINET6
|
|
|
|
|
|
|
|
/* Display an Internet socket address. */
|
|
|
|
/* dirty! struct sockaddr usually doesn't suffer for inet6 addresses, fst. */
|
|
|
|
static char *INET6_sprint(struct sockaddr *sap, int numeric)
|
|
|
|
{
|
2002-08-22 19:35:36 +00:00
|
|
|
static char buff[128];
|
|
|
|
|
|
|
|
if (sap->sa_family == 0xFFFF || sap->sa_family == 0)
|
2006-05-29 04:37:28 +00:00
|
|
|
return safe_strncpy(buff, "[NONE SET]", sizeof(buff));
|
2002-08-22 19:35:36 +00:00
|
|
|
if (INET6_rresolve
|
|
|
|
(buff, sizeof(buff), (struct sockaddr_in6 *) sap, numeric) != 0)
|
2006-05-29 04:37:28 +00:00
|
|
|
return safe_strncpy(buff, "[UNKNOWN]", sizeof(buff));
|
2002-08-22 19:35:36 +00:00
|
|
|
return (buff);
|
2002-07-03 11:46:38 +00:00
|
|
|
}
|
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
static struct aftype inet6_aftype = {
|
2006-06-20 15:52:52 +00:00
|
|
|
.name = "inet6",
|
|
|
|
.title = "IPv6",
|
|
|
|
.af = AF_INET6,
|
|
|
|
.alen = sizeof(struct in6_addr),
|
|
|
|
.sprint = INET6_sprint,
|
|
|
|
.fd = -1
|
2002-07-03 11:46:38 +00:00
|
|
|
};
|
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
#endif /* HAVE_AFINET6 */
|
2002-07-03 11:46:38 +00:00
|
|
|
|
2001-03-06 00:48:59 +00:00
|
|
|
/* Display an UNSPEC address. */
|
|
|
|
static char *UNSPEC_print(unsigned char *ptr)
|
|
|
|
{
|
2002-08-22 19:35:36 +00:00
|
|
|
static char buff[sizeof(struct sockaddr) * 3 + 1];
|
|
|
|
char *pos;
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
pos = buff;
|
|
|
|
for (i = 0; i < sizeof(struct sockaddr); i++) {
|
|
|
|
/* careful -- not every libc's sprintf returns # bytes written */
|
|
|
|
sprintf(pos, "%02X-", (*ptr++ & 0377));
|
|
|
|
pos += 3;
|
|
|
|
}
|
|
|
|
/* Erase trailing "-". Works as long as sizeof(struct sockaddr) != 0 */
|
|
|
|
*--pos = '\0';
|
|
|
|
return (buff);
|
2001-03-06 00:48:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Display an UNSPEC socket address. */
|
|
|
|
static char *UNSPEC_sprint(struct sockaddr *sap, int numeric)
|
|
|
|
{
|
2002-08-22 19:35:36 +00:00
|
|
|
static char buf[64];
|
2001-03-06 00:48:59 +00:00
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
if (sap->sa_family == 0xFFFF || sap->sa_family == 0)
|
2006-05-29 04:37:28 +00:00
|
|
|
return safe_strncpy(buf, "[NONE SET]", sizeof(buf));
|
2006-01-30 22:30:41 +00:00
|
|
|
return (UNSPEC_print((unsigned char *)sap->sa_data));
|
2001-03-06 00:48:59 +00:00
|
|
|
}
|
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
static struct aftype unspec_aftype = {
|
|
|
|
"unspec", "UNSPEC", AF_UNSPEC, 0,
|
|
|
|
UNSPEC_print, UNSPEC_sprint, NULL, NULL,
|
|
|
|
NULL,
|
2001-03-06 00:48:59 +00:00
|
|
|
};
|
|
|
|
|
2005-10-20 09:48:28 +00:00
|
|
|
static struct aftype * const aftypes[] = {
|
2002-08-22 19:35:36 +00:00
|
|
|
&inet_aftype,
|
2001-03-06 00:48:59 +00:00
|
|
|
#if HAVE_AFINET6
|
2002-08-22 19:35:36 +00:00
|
|
|
&inet6_aftype,
|
2001-03-06 00:48:59 +00:00
|
|
|
#endif
|
2002-08-22 19:35:36 +00:00
|
|
|
&unspec_aftype,
|
|
|
|
NULL
|
2001-03-06 00:48:59 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/* Check our protocol family table for this family. */
|
2001-03-12 09:57:59 +00:00
|
|
|
static struct aftype *get_afntype(int af)
|
2001-03-06 00:48:59 +00:00
|
|
|
{
|
2005-10-20 09:48:28 +00:00
|
|
|
struct aftype * const *afp;
|
2001-03-06 00:48:59 +00:00
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
afp = aftypes;
|
|
|
|
while (*afp != NULL) {
|
|
|
|
if ((*afp)->af == af)
|
|
|
|
return (*afp);
|
|
|
|
afp++;
|
|
|
|
}
|
|
|
|
return (NULL);
|
2001-03-06 00:48:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Check our protocol family table for this family and return its socket */
|
2001-03-12 09:57:59 +00:00
|
|
|
static int get_socket_for_af(int af)
|
2001-03-06 00:48:59 +00:00
|
|
|
{
|
2005-10-20 09:48:28 +00:00
|
|
|
struct aftype * const *afp;
|
2001-03-06 00:48:59 +00:00
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
afp = aftypes;
|
|
|
|
while (*afp != NULL) {
|
|
|
|
if ((*afp)->af == af)
|
|
|
|
return (*afp)->fd;
|
|
|
|
afp++;
|
|
|
|
}
|
|
|
|
return -1;
|
2001-03-06 00:48:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
struct user_net_device_stats {
|
2002-08-22 19:35:36 +00:00
|
|
|
unsigned long long rx_packets; /* total packets received */
|
|
|
|
unsigned long long tx_packets; /* total packets transmitted */
|
|
|
|
unsigned long long rx_bytes; /* total bytes received */
|
|
|
|
unsigned long long tx_bytes; /* total bytes transmitted */
|
|
|
|
unsigned long rx_errors; /* bad packets received */
|
|
|
|
unsigned long tx_errors; /* packet transmit problems */
|
|
|
|
unsigned long rx_dropped; /* no space in linux buffers */
|
|
|
|
unsigned long tx_dropped; /* no space available in linux */
|
|
|
|
unsigned long rx_multicast; /* multicast packets received */
|
|
|
|
unsigned long rx_compressed;
|
|
|
|
unsigned long tx_compressed;
|
|
|
|
unsigned long collisions;
|
|
|
|
|
|
|
|
/* detailed rx_errors: */
|
|
|
|
unsigned long rx_length_errors;
|
|
|
|
unsigned long rx_over_errors; /* receiver ring buff overflow */
|
|
|
|
unsigned long rx_crc_errors; /* recved pkt with crc error */
|
|
|
|
unsigned long rx_frame_errors; /* recv'd frame alignment error */
|
|
|
|
unsigned long rx_fifo_errors; /* recv'r fifo overrun */
|
|
|
|
unsigned long rx_missed_errors; /* receiver missed packet */
|
|
|
|
/* detailed tx_errors */
|
|
|
|
unsigned long tx_aborted_errors;
|
|
|
|
unsigned long tx_carrier_errors;
|
|
|
|
unsigned long tx_fifo_errors;
|
|
|
|
unsigned long tx_heartbeat_errors;
|
|
|
|
unsigned long tx_window_errors;
|
2001-03-06 00:48:59 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct interface {
|
2002-08-22 19:35:36 +00:00
|
|
|
struct interface *next, *prev;
|
|
|
|
char name[IFNAMSIZ]; /* interface name */
|
|
|
|
short type; /* if type */
|
|
|
|
short flags; /* various flags */
|
|
|
|
int metric; /* routing metric */
|
|
|
|
int mtu; /* MTU value */
|
|
|
|
int tx_queue_len; /* transmit queue length */
|
|
|
|
struct ifmap map; /* hardware setup */
|
|
|
|
struct sockaddr addr; /* IP address */
|
|
|
|
struct sockaddr dstaddr; /* P-P IP address */
|
|
|
|
struct sockaddr broadaddr; /* IP broadcast address */
|
|
|
|
struct sockaddr netmask; /* IP network mask */
|
|
|
|
int has_ip;
|
|
|
|
char hwaddr[32]; /* HW address */
|
|
|
|
int statistics_valid;
|
|
|
|
struct user_net_device_stats stats; /* statistics */
|
|
|
|
int keepalive; /* keepalive value for SLIP */
|
|
|
|
int outfill; /* outfill value for SLIP */
|
2001-03-06 00:48:59 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
int interface_opt_a = 0; /* show all interfaces */
|
2001-03-12 09:57:59 +00:00
|
|
|
|
2001-03-06 00:48:59 +00:00
|
|
|
static struct interface *int_list, *int_last;
|
2002-08-22 19:35:36 +00:00
|
|
|
static int skfd = -1; /* generic raw socket desc. */
|
2001-03-06 00:48:59 +00:00
|
|
|
|
|
|
|
|
2001-03-12 09:57:59 +00:00
|
|
|
static int sockets_open(int family)
|
2001-03-06 00:48:59 +00:00
|
|
|
{
|
2005-10-20 09:48:28 +00:00
|
|
|
struct aftype * const *aft;
|
2002-08-22 19:35:36 +00:00
|
|
|
int sfd = -1;
|
|
|
|
static int force = -1;
|
|
|
|
|
|
|
|
if (force < 0) {
|
|
|
|
force = 0;
|
2006-05-19 11:54:02 +00:00
|
|
|
if (get_linux_version_code() < KERNEL_VERSION(2,1,0))
|
2002-08-22 19:35:36 +00:00
|
|
|
force = 1;
|
|
|
|
if (access("/proc/net", R_OK))
|
|
|
|
force = 1;
|
2001-03-06 00:48:59 +00:00
|
|
|
}
|
2002-08-22 19:35:36 +00:00
|
|
|
for (aft = aftypes; *aft; aft++) {
|
|
|
|
struct aftype *af = *aft;
|
|
|
|
int type = SOCK_DGRAM;
|
|
|
|
|
|
|
|
if (af->af == AF_UNSPEC)
|
|
|
|
continue;
|
|
|
|
if (family && family != af->af)
|
|
|
|
continue;
|
|
|
|
if (af->fd != -1) {
|
|
|
|
sfd = af->fd;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
/* Check some /proc file first to not stress kmod */
|
|
|
|
if (!family && !force && af->flag_file) {
|
|
|
|
if (access(af->flag_file, R_OK))
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
af->fd = socket(af->af, type, 0);
|
|
|
|
if (af->fd >= 0)
|
|
|
|
sfd = af->fd;
|
|
|
|
}
|
2002-11-28 10:20:45 +00:00
|
|
|
if (sfd < 0) {
|
2006-05-29 04:37:28 +00:00
|
|
|
bb_error_msg("No usable address families found.");
|
2002-11-28 10:20:45 +00:00
|
|
|
}
|
2002-08-22 19:35:36 +00:00
|
|
|
return sfd;
|
2001-03-06 00:48:59 +00:00
|
|
|
}
|
|
|
|
|
2005-05-03 21:30:26 +00:00
|
|
|
#ifdef CONFIG_FEATURE_CLEAN_UP
|
|
|
|
static void sockets_close(void)
|
|
|
|
{
|
2005-10-20 09:48:28 +00:00
|
|
|
struct aftype * const *aft;
|
2005-05-03 21:30:26 +00:00
|
|
|
for (aft = aftypes; *aft != NULL; aft++) {
|
|
|
|
struct aftype *af = *aft;
|
|
|
|
if( af->fd != -1 ) {
|
|
|
|
close(af->fd);
|
|
|
|
af->fd = -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2001-03-06 00:48:59 +00:00
|
|
|
/* like strcmp(), but knows about numbers */
|
2004-07-23 01:49:46 +00:00
|
|
|
static int nstrcmp(const char *a, const char *b)
|
2001-03-06 00:48:59 +00:00
|
|
|
{
|
2004-07-23 01:49:46 +00:00
|
|
|
const char *a_ptr = a;
|
|
|
|
const char *b_ptr = b;
|
2002-08-22 19:35:36 +00:00
|
|
|
|
|
|
|
while (*a == *b) {
|
2004-07-23 01:49:46 +00:00
|
|
|
if (*a == '\0') {
|
2002-08-22 19:35:36 +00:00
|
|
|
return 0;
|
2004-07-23 01:49:46 +00:00
|
|
|
}
|
|
|
|
if (!isdigit(*a) && isdigit(*(a+1))) {
|
|
|
|
a_ptr = a+1;
|
|
|
|
b_ptr = b+1;
|
|
|
|
}
|
2001-03-06 00:48:59 +00:00
|
|
|
a++;
|
2002-08-22 19:35:36 +00:00
|
|
|
b++;
|
|
|
|
}
|
2004-07-23 01:49:46 +00:00
|
|
|
|
|
|
|
if (isdigit(*a) && isdigit(*b)) {
|
|
|
|
return atoi(a_ptr) > atoi(b_ptr) ? 1 : -1;
|
2001-03-06 00:48:59 +00:00
|
|
|
}
|
2002-08-22 19:35:36 +00:00
|
|
|
return *a - *b;
|
2001-03-06 00:48:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct interface *add_interface(char *name)
|
|
|
|
{
|
2002-08-22 19:35:36 +00:00
|
|
|
struct interface *ife, **nextp, *new;
|
|
|
|
|
|
|
|
for (ife = int_last; ife; ife = ife->prev) {
|
|
|
|
int n = nstrcmp(ife->name, name);
|
|
|
|
|
|
|
|
if (n == 0)
|
|
|
|
return ife;
|
|
|
|
if (n < 0)
|
|
|
|
break;
|
|
|
|
}
|
2006-05-29 06:43:55 +00:00
|
|
|
|
|
|
|
new = xzalloc(sizeof(*new));
|
2002-08-22 19:35:36 +00:00
|
|
|
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;
|
2001-03-06 00:48:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int if_readconf(void)
|
|
|
|
{
|
2002-08-22 19:35:36 +00:00
|
|
|
int numreqs = 30;
|
|
|
|
struct ifconf ifc;
|
|
|
|
struct ifreq *ifr;
|
|
|
|
int n, err = -1;
|
|
|
|
int skfd2;
|
|
|
|
|
|
|
|
/* SIOCGIFCONF currently seems to only work properly on AF_INET sockets
|
|
|
|
(as of 2.1.128) */
|
|
|
|
skfd2 = get_socket_for_af(AF_INET);
|
|
|
|
if (skfd2 < 0) {
|
2003-03-19 09:13:01 +00:00
|
|
|
bb_perror_msg(("warning: no inet socket available"));
|
2002-08-22 19:35:36 +00:00
|
|
|
/* Try to soldier on with whatever socket we can get hold of. */
|
|
|
|
skfd2 = sockets_open(0);
|
|
|
|
if (skfd2 < 0)
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
ifc.ifc_buf = NULL;
|
|
|
|
for (;;) {
|
|
|
|
ifc.ifc_len = sizeof(struct ifreq) * numreqs;
|
|
|
|
ifc.ifc_buf = xrealloc(ifc.ifc_buf, ifc.ifc_len);
|
|
|
|
|
|
|
|
if (ioctl(skfd2, SIOCGIFCONF, &ifc) < 0) {
|
|
|
|
perror("SIOCGIFCONF");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (ifc.ifc_len == sizeof(struct ifreq) * numreqs) {
|
|
|
|
/* assume it overflowed and try again */
|
|
|
|
numreqs += 10;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
break;
|
2001-03-06 00:48:59 +00:00
|
|
|
}
|
2002-08-22 19:35:36 +00:00
|
|
|
|
|
|
|
ifr = ifc.ifc_req;
|
|
|
|
for (n = 0; n < ifc.ifc_len; n += sizeof(struct ifreq)) {
|
|
|
|
add_interface(ifr->ifr_name);
|
|
|
|
ifr++;
|
2001-03-06 00:48:59 +00:00
|
|
|
}
|
2002-08-22 19:35:36 +00:00
|
|
|
err = 0;
|
|
|
|
|
|
|
|
out:
|
|
|
|
free(ifc.ifc_buf);
|
|
|
|
return err;
|
2001-03-06 00:48:59 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 19:39:00 +00:00
|
|
|
static char *get_name(char *name, char *p)
|
2001-03-06 00:48:59 +00:00
|
|
|
{
|
2006-06-20 21:13:29 +00:00
|
|
|
/* Extract <name> from nul-terminated p where p matches
|
|
|
|
<name>: after leading whitespace.
|
2004-08-12 16:52:00 +00:00
|
|
|
If match is not made, set name empty and return unchanged p */
|
2006-06-20 21:13:29 +00:00
|
|
|
int namestart=0, nameend=0;
|
2004-08-12 16:52:00 +00:00
|
|
|
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 {
|
|
|
|
/* Interface name too large */
|
|
|
|
name[0]='\0';
|
2002-08-22 19:35:36 +00:00
|
|
|
}
|
2004-08-12 16:52:00 +00:00
|
|
|
} else {
|
2006-06-20 21:13:29 +00:00
|
|
|
/* trailing ':' not found - return empty */
|
2004-08-12 16:52:00 +00:00
|
|
|
name[0]='\0';
|
2001-03-06 00:48:59 +00:00
|
|
|
}
|
2004-08-26 21:45:21 +00:00
|
|
|
return p + 1;
|
2001-03-06 00:48:59 +00:00
|
|
|
}
|
|
|
|
|
2003-08-02 00:04:18 +00:00
|
|
|
/* If scanf supports size qualifiers for %n conversions, then we can
|
|
|
|
* use a modified fmt that simply stores the position in the fields
|
|
|
|
* having no associated fields in the proc string. Of course, we need
|
|
|
|
* to zero them again when we're done. But that is smaller than the
|
|
|
|
* old approach of multiple scanf occurrences with large numbers of
|
|
|
|
* args. */
|
|
|
|
|
2006-01-19 14:51:17 +00:00
|
|
|
/* static const char * const ss_fmt[] = { */
|
2006-03-29 22:34:47 +00:00
|
|
|
/* "%lln%llu%lu%lu%lu%lu%ln%ln%lln%llu%lu%lu%lu%lu%lu", */
|
|
|
|
/* "%llu%llu%lu%lu%lu%lu%ln%ln%llu%llu%lu%lu%lu%lu%lu", */
|
|
|
|
/* "%llu%llu%lu%lu%lu%lu%lu%lu%llu%llu%lu%lu%lu%lu%lu%lu" */
|
2003-08-02 00:04:18 +00:00
|
|
|
/* }; */
|
|
|
|
|
|
|
|
/* Lie about the size of the int pointed to for %n. */
|
|
|
|
#if INT_MAX == LONG_MAX
|
2005-10-20 09:48:28 +00:00
|
|
|
static const char * const ss_fmt[] = {
|
2006-03-29 22:34:47 +00:00
|
|
|
"%n%llu%u%u%u%u%n%n%n%llu%u%u%u%u%u",
|
|
|
|
"%llu%llu%u%u%u%u%n%n%llu%llu%u%u%u%u%u",
|
|
|
|
"%llu%llu%u%u%u%u%u%u%llu%llu%u%u%u%u%u%u"
|
2003-08-02 00:04:18 +00:00
|
|
|
};
|
|
|
|
#else
|
2005-10-20 09:48:28 +00:00
|
|
|
static const char * const ss_fmt[] = {
|
2006-03-29 22:34:47 +00:00
|
|
|
"%n%llu%lu%lu%lu%lu%n%n%n%llu%lu%lu%lu%lu%lu",
|
|
|
|
"%llu%llu%lu%lu%lu%lu%n%n%llu%llu%lu%lu%lu%lu%lu",
|
|
|
|
"%llu%llu%lu%lu%lu%lu%lu%lu%llu%llu%lu%lu%lu%lu%lu%lu"
|
2003-08-02 00:04:18 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static void get_dev_fields(char *bp, struct interface *ife, int procnetdev_vsn)
|
2001-03-06 00:48:59 +00:00
|
|
|
{
|
2003-08-02 00:04:18 +00:00
|
|
|
memset(&ife->stats, 0, sizeof(struct user_net_device_stats));
|
|
|
|
|
|
|
|
sscanf(bp, ss_fmt[procnetdev_vsn],
|
|
|
|
&ife->stats.rx_bytes, /* missing for 0 */
|
|
|
|
&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, /* missing for <= 1 */
|
|
|
|
&ife->stats.rx_multicast, /* missing for <= 1 */
|
|
|
|
&ife->stats.tx_bytes, /* missing for 0 */
|
|
|
|
&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 /* missing for <= 1 */
|
|
|
|
);
|
|
|
|
|
|
|
|
if (procnetdev_vsn <= 1) {
|
|
|
|
if (procnetdev_vsn == 0) {
|
|
|
|
ife->stats.rx_bytes = 0;
|
|
|
|
ife->stats.tx_bytes = 0;
|
|
|
|
}
|
2002-08-22 19:35:36 +00:00
|
|
|
ife->stats.rx_multicast = 0;
|
2003-08-02 00:04:18 +00:00
|
|
|
ife->stats.rx_compressed = 0;
|
|
|
|
ife->stats.tx_compressed = 0;
|
2002-08-22 19:35:36 +00:00
|
|
|
}
|
2001-03-06 00:48:59 +00:00
|
|
|
}
|
|
|
|
|
2001-03-12 09:57:59 +00:00
|
|
|
static inline int procnetdev_version(char *buf)
|
2001-03-06 00:48:59 +00:00
|
|
|
{
|
2002-08-22 19:35:36 +00:00
|
|
|
if (strstr(buf, "compressed"))
|
|
|
|
return 2;
|
2003-08-02 00:04:18 +00:00
|
|
|
if (strstr(buf, "bytes"))
|
|
|
|
return 1;
|
|
|
|
return 0;
|
2001-03-06 00:48:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int if_readlist_proc(char *target)
|
|
|
|
{
|
2002-08-22 19:35:36 +00:00
|
|
|
static int proc_read;
|
|
|
|
FILE *fh;
|
|
|
|
char buf[512];
|
|
|
|
struct interface *ife;
|
2003-08-02 00:04:18 +00:00
|
|
|
int err, procnetdev_vsn;
|
2002-08-22 19:35:36 +00:00
|
|
|
|
|
|
|
if (proc_read)
|
|
|
|
return 0;
|
|
|
|
if (!target)
|
|
|
|
proc_read = 1;
|
|
|
|
|
|
|
|
fh = fopen(_PATH_PROCNET_DEV, "r");
|
|
|
|
if (!fh) {
|
2006-05-29 04:37:28 +00:00
|
|
|
bb_perror_msg("Warning: cannot open %s. Limited output.", _PATH_PROCNET_DEV);
|
2001-03-06 00:48:59 +00:00
|
|
|
return if_readconf();
|
2002-08-22 19:35:36 +00:00
|
|
|
}
|
|
|
|
fgets(buf, sizeof buf, fh); /* eat line */
|
|
|
|
fgets(buf, sizeof buf, fh);
|
|
|
|
|
|
|
|
procnetdev_vsn = procnetdev_version(buf);
|
2001-03-06 00:48:59 +00:00
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
err = 0;
|
|
|
|
while (fgets(buf, sizeof buf, fh)) {
|
James Petterson writes:
I've found a possible bug in libbb/interface.c, in function
if_readlist_proc(). This function calls get_name(), and passes
as an argument 'name', a buffer of 16 bytes (IFNAMSIZ). The
function get_name(), however, may use more than 16 bytes,
when it is searching for aliases. Even if you don't have an
alias interface, you can run into trouble if the interface
has received more than 99999999 bytes, in which case the
space between the interface name and the rx stats
disappears, as in the /proc/net/dev example below:
wan0.200:264573315 462080 ...
In this case get_name() correctly identifies the interface name
as "wan0.200", but to do that it uses 18 bytes of the 'name'
buffer, which could lead to an unpredictable error.
A simple solution would be to increase the size of the buffer:
2003-07-28 06:37:04 +00:00
|
|
|
char *s, name[128];
|
2001-03-06 00:48:59 +00:00
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
s = get_name(name, buf);
|
|
|
|
ife = add_interface(name);
|
2003-08-02 00:04:18 +00:00
|
|
|
get_dev_fields(s, ife, procnetdev_vsn);
|
2002-08-22 19:35:36 +00:00
|
|
|
ife->statistics_valid = 1;
|
|
|
|
if (target && !strcmp(target, name))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (ferror(fh)) {
|
|
|
|
perror(_PATH_PROCNET_DEV);
|
|
|
|
err = -1;
|
|
|
|
proc_read = 0;
|
|
|
|
}
|
|
|
|
fclose(fh);
|
|
|
|
return err;
|
2001-03-06 00:48:59 +00:00
|
|
|
}
|
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
static int if_readlist(void)
|
|
|
|
{
|
|
|
|
int err = if_readlist_proc(NULL);
|
|
|
|
|
|
|
|
if (!err)
|
|
|
|
err = if_readconf();
|
|
|
|
return err;
|
|
|
|
}
|
2001-03-06 00:48:59 +00:00
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
static int for_all_interfaces(int (*doit) (struct interface *, void *),
|
|
|
|
void *cookie)
|
2001-03-06 00:48:59 +00:00
|
|
|
{
|
2002-08-22 19:35:36 +00:00
|
|
|
struct interface *ife;
|
2001-03-06 00:48:59 +00:00
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
if (!int_list && (if_readlist() < 0))
|
|
|
|
return -1;
|
|
|
|
for (ife = int_list; ife; ife = ife->next) {
|
|
|
|
int err = doit(ife, cookie);
|
|
|
|
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
return 0;
|
2001-03-06 00:48:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Fetch the interface configuration from the kernel. */
|
2001-03-12 09:57:59 +00:00
|
|
|
static int if_fetch(struct interface *ife)
|
2001-03-06 00:48:59 +00:00
|
|
|
{
|
2002-08-22 19:35:36 +00:00
|
|
|
struct ifreq ifr;
|
|
|
|
int fd;
|
|
|
|
char *ifname = ife->name;
|
2001-03-06 00:48:59 +00:00
|
|
|
|
|
|
|
strcpy(ifr.ifr_name, ifname);
|
2002-08-22 19:35:36 +00:00
|
|
|
if (ioctl(skfd, SIOCGIFFLAGS, &ifr) < 0)
|
|
|
|
return (-1);
|
|
|
|
ife->flags = ifr.ifr_flags;
|
|
|
|
|
|
|
|
strcpy(ifr.ifr_name, ifname);
|
|
|
|
if (ioctl(skfd, SIOCGIFHWADDR, &ifr) < 0)
|
|
|
|
memset(ife->hwaddr, 0, 32);
|
2001-03-06 00:48:59 +00:00
|
|
|
else
|
2002-08-22 19:35:36 +00:00
|
|
|
memcpy(ife->hwaddr, ifr.ifr_hwaddr.sa_data, 8);
|
|
|
|
|
|
|
|
ife->type = ifr.ifr_hwaddr.sa_family;
|
|
|
|
|
|
|
|
strcpy(ifr.ifr_name, ifname);
|
|
|
|
if (ioctl(skfd, SIOCGIFMETRIC, &ifr) < 0)
|
|
|
|
ife->metric = 0;
|
|
|
|
else
|
|
|
|
ife->metric = ifr.ifr_metric;
|
|
|
|
|
2001-03-06 00:48:59 +00:00
|
|
|
strcpy(ifr.ifr_name, ifname);
|
2002-08-22 19:35:36 +00:00
|
|
|
if (ioctl(skfd, SIOCGIFMTU, &ifr) < 0)
|
|
|
|
ife->mtu = 0;
|
2001-03-06 00:48:59 +00:00
|
|
|
else
|
2002-08-22 19:35:36 +00:00
|
|
|
ife->mtu = ifr.ifr_mtu;
|
|
|
|
|
2005-05-03 21:30:26 +00:00
|
|
|
#ifdef SIOCGIFMAP
|
2002-08-22 19:35:36 +00:00
|
|
|
strcpy(ifr.ifr_name, ifname);
|
2005-05-03 21:30:26 +00:00
|
|
|
if (ioctl(skfd, SIOCGIFMAP, &ifr) == 0)
|
|
|
|
ife->map = ifr.ifr_map;
|
2002-08-22 19:35:36 +00:00
|
|
|
else
|
2005-05-03 21:30:26 +00:00
|
|
|
#endif
|
2002-08-22 19:35:36 +00:00
|
|
|
memset(&ife->map, 0, sizeof(struct ifmap));
|
2001-03-06 00:48:59 +00:00
|
|
|
|
|
|
|
#ifdef HAVE_TXQUEUELEN
|
2002-08-22 19:35:36 +00:00
|
|
|
strcpy(ifr.ifr_name, ifname);
|
|
|
|
if (ioctl(skfd, SIOCGIFTXQLEN, &ifr) < 0)
|
|
|
|
ife->tx_queue_len = -1; /* unknown value */
|
|
|
|
else
|
|
|
|
ife->tx_queue_len = ifr.ifr_qlen;
|
2001-03-06 00:48:59 +00:00
|
|
|
#else
|
2002-08-22 19:35:36 +00:00
|
|
|
ife->tx_queue_len = -1; /* unknown value */
|
2001-03-06 00:48:59 +00:00
|
|
|
#endif
|
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
/* IPv4 address? */
|
|
|
|
fd = get_socket_for_af(AF_INET);
|
|
|
|
if (fd >= 0) {
|
|
|
|
strcpy(ifr.ifr_name, ifname);
|
|
|
|
ifr.ifr_addr.sa_family = AF_INET;
|
|
|
|
if (ioctl(fd, SIOCGIFADDR, &ifr) == 0) {
|
|
|
|
ife->has_ip = 1;
|
|
|
|
ife->addr = ifr.ifr_addr;
|
|
|
|
strcpy(ifr.ifr_name, ifname);
|
|
|
|
if (ioctl(fd, SIOCGIFDSTADDR, &ifr) < 0)
|
|
|
|
memset(&ife->dstaddr, 0, sizeof(struct sockaddr));
|
|
|
|
else
|
|
|
|
ife->dstaddr = ifr.ifr_dstaddr;
|
|
|
|
|
|
|
|
strcpy(ifr.ifr_name, ifname);
|
|
|
|
if (ioctl(fd, SIOCGIFBRDADDR, &ifr) < 0)
|
|
|
|
memset(&ife->broadaddr, 0, sizeof(struct sockaddr));
|
|
|
|
else
|
|
|
|
ife->broadaddr = ifr.ifr_broadaddr;
|
|
|
|
|
|
|
|
strcpy(ifr.ifr_name, ifname);
|
|
|
|
if (ioctl(fd, SIOCGIFNETMASK, &ifr) < 0)
|
|
|
|
memset(&ife->netmask, 0, sizeof(struct sockaddr));
|
|
|
|
else
|
|
|
|
ife->netmask = ifr.ifr_netmask;
|
|
|
|
} else
|
|
|
|
memset(&ife->addr, 0, sizeof(struct sockaddr));
|
|
|
|
}
|
2001-03-06 00:48:59 +00:00
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
return 0;
|
2001-03-06 00:48:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-03-12 09:57:59 +00:00
|
|
|
static int do_if_fetch(struct interface *ife)
|
2002-08-22 19:35:36 +00:00
|
|
|
{
|
|
|
|
if (if_fetch(ife) < 0) {
|
|
|
|
char *errmsg;
|
|
|
|
|
|
|
|
if (errno == ENODEV) {
|
|
|
|
/* Give better error message for this case. */
|
2006-05-29 04:37:28 +00:00
|
|
|
errmsg = "Device not found";
|
2002-08-22 19:35:36 +00:00
|
|
|
} else {
|
|
|
|
errmsg = strerror(errno);
|
|
|
|
}
|
2006-05-29 04:37:28 +00:00
|
|
|
bb_error_msg("%s: error fetching interface information: %s",
|
2002-08-22 19:35:36 +00:00
|
|
|
ife->name, errmsg);
|
|
|
|
return -1;
|
2001-03-06 00:48:59 +00:00
|
|
|
}
|
2002-08-22 19:35:36 +00:00
|
|
|
return 0;
|
2001-03-06 00:48:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* This structure defines hardware protocols and their handlers. */
|
|
|
|
struct hwtype {
|
2006-01-19 14:51:17 +00:00
|
|
|
const char * const name;
|
2002-08-22 19:35:36 +00:00
|
|
|
const char *title;
|
|
|
|
int type;
|
|
|
|
int alen;
|
|
|
|
char *(*print) (unsigned char *);
|
|
|
|
int (*input) (char *, struct sockaddr *);
|
|
|
|
int (*activate) (int fd);
|
|
|
|
int suppress_null_addr;
|
2001-03-06 00:48:59 +00:00
|
|
|
};
|
|
|
|
|
2005-10-20 09:48:28 +00:00
|
|
|
static const struct hwtype unspec_hwtype = {
|
2002-08-22 19:35:36 +00:00
|
|
|
"unspec", "UNSPEC", -1, 0,
|
|
|
|
UNSPEC_print, NULL, NULL
|
2001-03-06 00:48:59 +00:00
|
|
|
};
|
|
|
|
|
2005-10-20 09:48:28 +00:00
|
|
|
static const struct hwtype loop_hwtype = {
|
2002-08-22 19:35:36 +00:00
|
|
|
"loop", "Local Loopback", ARPHRD_LOOPBACK, 0,
|
|
|
|
NULL, NULL, NULL
|
2001-03-06 00:48:59 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#include <net/if_arp.h>
|
2003-01-14 08:54:08 +00:00
|
|
|
|
2005-03-04 01:10:56 +00:00
|
|
|
#if (__GLIBC__ >=2 && __GLIBC_MINOR >= 1) || defined(_NEWLIB_VERSION)
|
2003-01-14 08:54:08 +00:00
|
|
|
#include <net/ethernet.h>
|
|
|
|
#else
|
2001-03-06 00:48:59 +00:00
|
|
|
#include <linux/if_ether.h>
|
2003-01-14 08:54:08 +00:00
|
|
|
#endif
|
2001-03-06 00:48:59 +00:00
|
|
|
|
|
|
|
/* Display an Ethernet address in readable format. */
|
|
|
|
static char *pr_ether(unsigned char *ptr)
|
|
|
|
{
|
2002-08-22 19:35:36 +00:00
|
|
|
static char buff[64];
|
2001-03-06 00:48:59 +00:00
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
snprintf(buff, sizeof(buff), "%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);
|
2001-03-06 00:48:59 +00:00
|
|
|
}
|
|
|
|
|
2005-10-20 09:48:28 +00:00
|
|
|
static const struct hwtype ether_hwtype = {
|
2002-08-22 19:35:36 +00:00
|
|
|
"ether", "Ethernet", ARPHRD_ETHER, ETH_ALEN,
|
|
|
|
pr_ether, NULL /* UNUSED in_ether */ , NULL
|
2001-03-06 00:48:59 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#include <net/if_arp.h>
|
|
|
|
|
2005-10-20 09:48:28 +00:00
|
|
|
static const struct hwtype ppp_hwtype = {
|
2002-08-22 19:35:36 +00:00
|
|
|
"ppp", "Point-Point Protocol", ARPHRD_PPP, 0,
|
|
|
|
NULL, NULL, NULL /* UNUSED do_ppp */ , 0
|
2001-03-06 00:48:59 +00:00
|
|
|
};
|
|
|
|
|
2005-10-20 09:48:28 +00:00
|
|
|
static const struct hwtype * const hwtypes[] = {
|
2002-08-22 19:35:36 +00:00
|
|
|
&loop_hwtype,
|
|
|
|
ðer_hwtype,
|
|
|
|
&ppp_hwtype,
|
|
|
|
&unspec_hwtype,
|
|
|
|
NULL
|
2001-03-06 00:48:59 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#ifdef IFF_PORTSEL
|
2003-08-02 00:04:18 +00:00
|
|
|
static const char * const if_port_text[] = {
|
|
|
|
/* Keep in step with <linux/netdevice.h> */
|
|
|
|
"unknown",
|
|
|
|
"10base2",
|
|
|
|
"10baseT",
|
|
|
|
"AUI",
|
|
|
|
"100baseT",
|
|
|
|
"100baseTX",
|
|
|
|
"100baseFX",
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
#endif
|
2001-03-06 00:48:59 +00:00
|
|
|
|
|
|
|
/* Check our hardware type table for this type. */
|
2005-10-20 09:48:28 +00:00
|
|
|
static const struct hwtype *get_hwntype(int type)
|
2001-03-06 00:48:59 +00:00
|
|
|
{
|
2005-10-20 09:48:28 +00:00
|
|
|
const struct hwtype * const *hwp;
|
2001-03-06 00:48:59 +00:00
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
hwp = hwtypes;
|
|
|
|
while (*hwp != NULL) {
|
|
|
|
if ((*hwp)->type == type)
|
|
|
|
return (*hwp);
|
|
|
|
hwp++;
|
|
|
|
}
|
|
|
|
return (NULL);
|
2001-03-06 00:48:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* return 1 if address is all zeros */
|
2005-10-20 09:48:28 +00:00
|
|
|
static int hw_null_address(const struct hwtype *hw, void *ap)
|
2001-03-06 00:48:59 +00:00
|
|
|
{
|
2002-08-22 19:35:36 +00:00
|
|
|
unsigned int i;
|
|
|
|
unsigned char *address = (unsigned char *) ap;
|
|
|
|
|
|
|
|
for (i = 0; i < hw->alen; i++)
|
|
|
|
if (address[i])
|
|
|
|
return 0;
|
|
|
|
return 1;
|
2001-03-06 00:48:59 +00:00
|
|
|
}
|
|
|
|
|
2003-08-02 00:04:18 +00:00
|
|
|
static const char TRext[] = "\0\0\0Ki\0Mi\0Gi\0Ti";
|
2001-03-12 09:57:59 +00:00
|
|
|
|
|
|
|
static void print_bytes_scaled(unsigned long long ull, const char *end)
|
|
|
|
{
|
|
|
|
unsigned long long int_part;
|
|
|
|
const char *ext;
|
2003-08-02 00:04:18 +00:00
|
|
|
unsigned int frac_part;
|
2001-03-12 09:57:59 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
frac_part = 0;
|
|
|
|
ext = TRext;
|
|
|
|
int_part = ull;
|
2003-08-02 00:04:18 +00:00
|
|
|
i = 4;
|
|
|
|
do {
|
2001-03-12 09:57:59 +00:00
|
|
|
if (int_part >= 1024) {
|
2003-08-02 00:04:18 +00:00
|
|
|
frac_part = ((((unsigned int) int_part) & (1024-1)) * 10) / 1024;
|
2001-03-12 09:57:59 +00:00
|
|
|
int_part /= 1024;
|
2003-08-02 00:04:18 +00:00
|
|
|
ext += 3; /* KiB, MiB, GiB, TiB */
|
2001-03-12 09:57:59 +00:00
|
|
|
}
|
2003-08-02 00:04:18 +00:00
|
|
|
--i;
|
|
|
|
} while (i);
|
2001-03-12 09:57:59 +00:00
|
|
|
|
2006-03-29 22:34:47 +00:00
|
|
|
printf("X bytes:%llu (%llu.%u %sB)%s", ull, int_part, frac_part, ext, end);
|
2001-03-12 09:57:59 +00:00
|
|
|
}
|
|
|
|
|
2003-08-02 00:04:18 +00:00
|
|
|
static const char * const ife_print_flags_strs[] = {
|
|
|
|
"UP ",
|
|
|
|
"BROADCAST ",
|
|
|
|
"DEBUG ",
|
|
|
|
"LOOPBACK ",
|
|
|
|
"POINTOPOINT ",
|
|
|
|
"NOTRAILERS ",
|
|
|
|
"RUNNING ",
|
|
|
|
"NOARP ",
|
|
|
|
"PROMISC ",
|
|
|
|
"ALLMULTI ",
|
|
|
|
"SLAVE ",
|
|
|
|
"MASTER ",
|
|
|
|
"MULTICAST ",
|
|
|
|
#ifdef HAVE_DYNAMIC
|
|
|
|
"DYNAMIC "
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
|
|
|
static const unsigned short ife_print_flags_mask[] = {
|
|
|
|
IFF_UP,
|
|
|
|
IFF_BROADCAST,
|
|
|
|
IFF_DEBUG,
|
|
|
|
IFF_LOOPBACK,
|
|
|
|
IFF_POINTOPOINT,
|
|
|
|
IFF_NOTRAILERS,
|
|
|
|
IFF_RUNNING,
|
|
|
|
IFF_NOARP,
|
|
|
|
IFF_PROMISC,
|
|
|
|
IFF_ALLMULTI,
|
|
|
|
IFF_SLAVE,
|
|
|
|
IFF_MASTER,
|
|
|
|
IFF_MULTICAST,
|
|
|
|
#ifdef HAVE_DYNAMIC
|
|
|
|
IFF_DYNAMIC
|
|
|
|
#endif
|
|
|
|
0
|
|
|
|
};
|
|
|
|
|
2001-03-12 09:57:59 +00:00
|
|
|
static void ife_print(struct interface *ptr)
|
2001-03-06 00:48:59 +00:00
|
|
|
{
|
2002-08-22 19:35:36 +00:00
|
|
|
struct aftype *ap;
|
2005-10-20 09:48:28 +00:00
|
|
|
const struct hwtype *hw;
|
2002-08-22 19:35:36 +00:00
|
|
|
int hf;
|
|
|
|
int can_compress = 0;
|
2001-03-06 00:48:59 +00:00
|
|
|
|
|
|
|
#if HAVE_AFINET6
|
2002-08-22 19:35:36 +00:00
|
|
|
FILE *f;
|
|
|
|
char addr6[40], devname[20];
|
|
|
|
struct sockaddr_in6 sap;
|
|
|
|
int plen, scope, dad_status, if_idx;
|
|
|
|
char addr6p[8][5];
|
2001-03-06 00:48:59 +00:00
|
|
|
#endif
|
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
ap = get_afntype(ptr->addr.sa_family);
|
|
|
|
if (ap == NULL)
|
|
|
|
ap = get_afntype(0);
|
2001-03-06 00:48:59 +00:00
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
hf = ptr->type;
|
2001-03-06 00:48:59 +00:00
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
if (hf == ARPHRD_CSLIP || hf == ARPHRD_CSLIP6)
|
|
|
|
can_compress = 1;
|
2001-03-06 00:48:59 +00:00
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
hw = get_hwntype(hf);
|
|
|
|
if (hw == NULL)
|
|
|
|
hw = get_hwntype(-1);
|
2001-03-06 00:48:59 +00:00
|
|
|
|
2006-05-29 04:37:28 +00:00
|
|
|
printf("%-9.9s Link encap:%s ", ptr->name, hw->title);
|
2004-03-15 08:29:22 +00:00
|
|
|
/* For some hardware types (eg Ash, ATM) we don't print the
|
2002-08-22 19:35:36 +00:00
|
|
|
hardware address if it's null. */
|
|
|
|
if (hw->print != NULL && (!(hw_null_address(hw, ptr->hwaddr) &&
|
|
|
|
hw->suppress_null_addr)))
|
2006-05-29 04:37:28 +00:00
|
|
|
printf("HWaddr %s ", hw->print((unsigned char *)ptr->hwaddr));
|
2001-03-06 00:48:59 +00:00
|
|
|
#ifdef IFF_PORTSEL
|
2002-08-22 19:35:36 +00:00
|
|
|
if (ptr->flags & IFF_PORTSEL) {
|
2006-05-29 04:37:28 +00:00
|
|
|
printf("Media:%s", if_port_text[ptr->map.port] /* [0] */);
|
2002-08-22 19:35:36 +00:00
|
|
|
if (ptr->flags & IFF_AUTOMEDIA)
|
2006-05-29 04:37:28 +00:00
|
|
|
printf("(auto)");
|
2002-08-22 19:35:36 +00:00
|
|
|
}
|
2001-03-06 00:48:59 +00:00
|
|
|
#endif
|
2002-08-22 19:35:36 +00:00
|
|
|
printf("\n");
|
2001-03-06 00:48:59 +00:00
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
if (ptr->has_ip) {
|
2006-05-29 04:37:28 +00:00
|
|
|
printf(" %s addr:%s ", ap->name,
|
2002-08-22 19:35:36 +00:00
|
|
|
ap->sprint(&ptr->addr, 1));
|
|
|
|
if (ptr->flags & IFF_POINTOPOINT) {
|
2006-05-29 04:37:28 +00:00
|
|
|
printf(" P-t-P:%s ", ap->sprint(&ptr->dstaddr, 1));
|
2002-08-22 19:35:36 +00:00
|
|
|
}
|
|
|
|
if (ptr->flags & IFF_BROADCAST) {
|
2006-05-29 04:37:28 +00:00
|
|
|
printf(" Bcast:%s ", ap->sprint(&ptr->broadaddr, 1));
|
2002-08-22 19:35:36 +00:00
|
|
|
}
|
2006-05-29 04:37:28 +00:00
|
|
|
printf(" Mask:%s\n", ap->sprint(&ptr->netmask, 1));
|
2001-03-06 00:48:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#if HAVE_AFINET6
|
|
|
|
|
2002-07-03 11:46:38 +00:00
|
|
|
#define IPV6_ADDR_ANY 0x0000U
|
|
|
|
|
|
|
|
#define IPV6_ADDR_UNICAST 0x0001U
|
|
|
|
#define IPV6_ADDR_MULTICAST 0x0002U
|
|
|
|
#define IPV6_ADDR_ANYCAST 0x0004U
|
|
|
|
|
|
|
|
#define IPV6_ADDR_LOOPBACK 0x0010U
|
|
|
|
#define IPV6_ADDR_LINKLOCAL 0x0020U
|
|
|
|
#define IPV6_ADDR_SITELOCAL 0x0040U
|
2002-08-22 19:35:36 +00:00
|
|
|
|
2002-07-03 11:46:38 +00:00
|
|
|
#define IPV6_ADDR_COMPATv4 0x0080U
|
2002-08-22 19:35:36 +00:00
|
|
|
|
2002-07-03 11:46:38 +00:00
|
|
|
#define IPV6_ADDR_SCOPE_MASK 0x00f0U
|
2002-08-22 19:35:36 +00:00
|
|
|
|
2002-07-03 11:46:38 +00:00
|
|
|
#define IPV6_ADDR_MAPPED 0x1000U
|
2002-08-22 19:35:36 +00:00
|
|
|
#define IPV6_ADDR_RESERVED 0x2000U /* reserved address space */
|
|
|
|
|
|
|
|
if ((f = fopen(_PATH_PROCNET_IFINET6, "r")) != NULL) {
|
|
|
|
while (fscanf
|
|
|
|
(f, "%4s%4s%4s%4s%4s%4s%4s%4s %02x %02x %02x %02x %20s\n",
|
|
|
|
addr6p[0], addr6p[1], addr6p[2], addr6p[3], addr6p[4],
|
|
|
|
addr6p[5], addr6p[6], addr6p[7], &if_idx, &plen, &scope,
|
|
|
|
&dad_status, devname) != EOF) {
|
|
|
|
if (!strcmp(devname, ptr->name)) {
|
|
|
|
sprintf(addr6, "%s:%s:%s:%s:%s:%s:%s:%s",
|
|
|
|
addr6p[0], addr6p[1], addr6p[2], addr6p[3],
|
|
|
|
addr6p[4], addr6p[5], addr6p[6], addr6p[7]);
|
|
|
|
inet_pton(AF_INET6, addr6,
|
|
|
|
(struct sockaddr *) &sap.sin6_addr);
|
|
|
|
sap.sin6_family = AF_INET6;
|
2006-05-29 04:37:28 +00:00
|
|
|
printf(" inet6 addr: %s/%d",
|
2002-08-22 19:35:36 +00:00
|
|
|
inet6_aftype.sprint((struct sockaddr *) &sap, 1),
|
|
|
|
plen);
|
2006-05-29 04:37:28 +00:00
|
|
|
printf(" Scope:");
|
2002-08-22 19:35:36 +00:00
|
|
|
switch (scope & IPV6_ADDR_SCOPE_MASK) {
|
|
|
|
case 0:
|
2006-05-29 04:37:28 +00:00
|
|
|
printf("Global");
|
2002-08-22 19:35:36 +00:00
|
|
|
break;
|
|
|
|
case IPV6_ADDR_LINKLOCAL:
|
2006-05-29 04:37:28 +00:00
|
|
|
printf("Link");
|
2002-08-22 19:35:36 +00:00
|
|
|
break;
|
|
|
|
case IPV6_ADDR_SITELOCAL:
|
2006-05-29 04:37:28 +00:00
|
|
|
printf("Site");
|
2002-08-22 19:35:36 +00:00
|
|
|
break;
|
|
|
|
case IPV6_ADDR_COMPATv4:
|
2006-05-29 04:37:28 +00:00
|
|
|
printf("Compat");
|
2002-08-22 19:35:36 +00:00
|
|
|
break;
|
|
|
|
case IPV6_ADDR_LOOPBACK:
|
2006-05-29 04:37:28 +00:00
|
|
|
printf("Host");
|
2002-08-22 19:35:36 +00:00
|
|
|
break;
|
|
|
|
default:
|
2006-05-29 04:37:28 +00:00
|
|
|
printf("Unknown");
|
2002-08-22 19:35:36 +00:00
|
|
|
}
|
|
|
|
printf("\n");
|
|
|
|
}
|
2001-03-06 00:48:59 +00:00
|
|
|
}
|
2002-08-22 19:35:36 +00:00
|
|
|
fclose(f);
|
2001-03-06 00:48:59 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
printf(" ");
|
|
|
|
/* DONT FORGET TO ADD THE FLAGS IN ife_print_short, too */
|
2003-08-02 00:04:18 +00:00
|
|
|
|
|
|
|
if (ptr->flags == 0) {
|
2006-05-29 04:37:28 +00:00
|
|
|
printf("[NO FLAGS] ");
|
2003-08-02 00:04:18 +00:00
|
|
|
} else {
|
|
|
|
int i = 0;
|
|
|
|
do {
|
|
|
|
if (ptr->flags & ife_print_flags_mask[i]) {
|
2006-05-29 04:37:28 +00:00
|
|
|
printf(ife_print_flags_strs[i]);
|
2003-08-02 00:04:18 +00:00
|
|
|
}
|
|
|
|
} while (ife_print_flags_mask[++i]);
|
|
|
|
}
|
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
/* DONT FORGET TO ADD THE FLAGS IN ife_print_short */
|
2006-05-29 04:37:28 +00:00
|
|
|
printf(" MTU:%d Metric:%d", ptr->mtu, ptr->metric ? ptr->metric : 1);
|
2001-03-06 00:48:59 +00:00
|
|
|
#ifdef SIOCSKEEPALIVE
|
2002-08-22 19:35:36 +00:00
|
|
|
if (ptr->outfill || ptr->keepalive)
|
2006-05-29 04:37:28 +00:00
|
|
|
printf(" Outfill:%d Keepalive:%d", ptr->outfill, ptr->keepalive);
|
2001-03-06 00:48:59 +00:00
|
|
|
#endif
|
2002-08-22 19:35:36 +00:00
|
|
|
printf("\n");
|
2001-03-06 00:48:59 +00:00
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
/* If needed, display the interface statistics. */
|
|
|
|
|
|
|
|
if (ptr->statistics_valid) {
|
|
|
|
/* XXX: statistics are currently only printed for the primary address,
|
|
|
|
* not for the aliases, although strictly speaking they're shared
|
|
|
|
* by all addresses.
|
|
|
|
*/
|
|
|
|
printf(" ");
|
|
|
|
|
2006-03-29 22:34:47 +00:00
|
|
|
printf("RX packets:%llu errors:%lu dropped:%lu overruns:%lu frame:%lu\n",
|
2002-08-22 19:35:36 +00:00
|
|
|
ptr->stats.rx_packets, ptr->stats.rx_errors,
|
|
|
|
ptr->stats.rx_dropped, ptr->stats.rx_fifo_errors,
|
|
|
|
ptr->stats.rx_frame_errors);
|
|
|
|
if (can_compress)
|
2006-03-29 22:34:47 +00:00
|
|
|
printf(" compressed:%lu\n",
|
2002-08-22 19:35:36 +00:00
|
|
|
ptr->stats.rx_compressed);
|
|
|
|
printf(" ");
|
2006-03-29 22:34:47 +00:00
|
|
|
printf("TX packets:%llu errors:%lu dropped:%lu overruns:%lu carrier:%lu\n",
|
2002-08-22 19:35:36 +00:00
|
|
|
ptr->stats.tx_packets, ptr->stats.tx_errors,
|
|
|
|
ptr->stats.tx_dropped, ptr->stats.tx_fifo_errors,
|
|
|
|
ptr->stats.tx_carrier_errors);
|
2006-03-30 13:38:19 +00:00
|
|
|
printf(" collisions:%lu ", ptr->stats.collisions);
|
2002-08-22 19:35:36 +00:00
|
|
|
if (can_compress)
|
2006-03-29 22:34:47 +00:00
|
|
|
printf("compressed:%lu ", ptr->stats.tx_compressed);
|
2002-08-22 19:35:36 +00:00
|
|
|
if (ptr->tx_queue_len != -1)
|
2006-03-29 22:34:47 +00:00
|
|
|
printf("txqueuelen:%d ", ptr->tx_queue_len);
|
2002-08-22 19:35:36 +00:00
|
|
|
printf("\n R");
|
|
|
|
print_bytes_scaled(ptr->stats.rx_bytes, " T");
|
|
|
|
print_bytes_scaled(ptr->stats.tx_bytes, "\n");
|
2001-03-06 00:48:59 +00:00
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
}
|
2001-03-06 00:48:59 +00:00
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
if ((ptr->map.irq || ptr->map.mem_start || ptr->map.dma ||
|
|
|
|
ptr->map.base_addr)) {
|
|
|
|
printf(" ");
|
|
|
|
if (ptr->map.irq)
|
2006-05-29 04:37:28 +00:00
|
|
|
printf("Interrupt:%d ", ptr->map.irq);
|
2004-03-15 08:29:22 +00:00
|
|
|
if (ptr->map.base_addr >= 0x100) /* Only print devices using it for
|
2002-08-22 19:35:36 +00:00
|
|
|
I/O maps */
|
2006-05-29 04:37:28 +00:00
|
|
|
printf("Base address:0x%lx ",
|
2002-08-22 19:35:36 +00:00
|
|
|
(unsigned long) ptr->map.base_addr);
|
|
|
|
if (ptr->map.mem_start) {
|
2006-05-29 04:37:28 +00:00
|
|
|
printf("Memory:%lx-%lx ", ptr->map.mem_start,
|
2002-08-22 19:35:36 +00:00
|
|
|
ptr->map.mem_end);
|
|
|
|
}
|
|
|
|
if (ptr->map.dma)
|
2006-05-29 04:37:28 +00:00
|
|
|
printf("DMA chan:%x ", ptr->map.dma);
|
2002-08-22 19:35:36 +00:00
|
|
|
printf("\n");
|
2001-03-06 00:48:59 +00:00
|
|
|
}
|
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-03-12 09:57:59 +00:00
|
|
|
static int do_if_print(struct interface *ife, void *cookie)
|
2001-03-06 00:48:59 +00:00
|
|
|
{
|
2002-08-22 19:35:36 +00:00
|
|
|
int *opt_a = (int *) cookie;
|
|
|
|
int res;
|
|
|
|
|
|
|
|
res = do_if_fetch(ife);
|
|
|
|
if (res >= 0) {
|
|
|
|
if ((ife->flags & IFF_UP) || *opt_a)
|
|
|
|
ife_print(ife);
|
|
|
|
}
|
|
|
|
return res;
|
2001-03-06 00:48:59 +00:00
|
|
|
}
|
|
|
|
|
2001-03-12 09:57:59 +00:00
|
|
|
static struct interface *lookup_interface(char *name)
|
2001-03-06 00:48:59 +00:00
|
|
|
{
|
2002-08-22 19:35:36 +00:00
|
|
|
struct interface *ife = NULL;
|
2001-03-06 00:48:59 +00:00
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
if (if_readlist_proc(name) < 0)
|
|
|
|
return NULL;
|
|
|
|
ife = add_interface(name);
|
|
|
|
return ife;
|
2001-03-06 00:48:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* for ipv4 add/del modes */
|
|
|
|
static int if_print(char *ifname)
|
|
|
|
{
|
2002-08-22 19:35:36 +00:00
|
|
|
int res;
|
2001-03-06 00:48:59 +00:00
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
if (!ifname) {
|
|
|
|
res = for_all_interfaces(do_if_print, &interface_opt_a);
|
|
|
|
} else {
|
|
|
|
struct interface *ife;
|
2001-03-06 00:48:59 +00:00
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
ife = lookup_interface(ifname);
|
|
|
|
res = do_if_fetch(ife);
|
|
|
|
if (res >= 0)
|
|
|
|
ife_print(ife);
|
|
|
|
}
|
|
|
|
return res;
|
2001-03-06 00:48:59 +00:00
|
|
|
}
|
|
|
|
|
2006-05-11 02:35:55 +00:00
|
|
|
int display_interfaces(char *ifname);
|
2001-03-12 09:57:59 +00:00
|
|
|
int display_interfaces(char *ifname)
|
2001-03-06 00:48:59 +00:00
|
|
|
{
|
2002-08-22 19:35:36 +00:00
|
|
|
int status;
|
2001-03-06 00:48:59 +00:00
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
/* Create a channel to the NET kernel. */
|
|
|
|
if ((skfd = sockets_open(0)) < 0) {
|
2003-03-19 09:13:01 +00:00
|
|
|
bb_perror_msg_and_die("socket");
|
2002-08-22 19:35:36 +00:00
|
|
|
}
|
2001-03-06 00:48:59 +00:00
|
|
|
|
2002-08-22 19:35:36 +00:00
|
|
|
/* Do we have to show the current setup? */
|
|
|
|
status = if_print(ifname);
|
2005-05-03 21:30:26 +00:00
|
|
|
#ifdef CONFIG_FEATURE_CLEAN_UP
|
|
|
|
sockets_close();
|
|
|
|
#endif
|
2002-08-22 19:35:36 +00:00
|
|
|
exit(status < 0);
|
2001-03-06 00:48:59 +00:00
|
|
|
}
|