Kyungwan Han submitted ifconfig.

1 files changed, 1504 insertions, 0 deletions

diff --git a/toys/pending/ifconfig.c b/toys/pending/ifconfig.c
new file mode 100644
index 00000000..bbd1ece0
--- /dev/null
+++ b/toys/pending/ifconfig.c
@@ -0,0 +1,1504 @@
+/* ifconfig.c - Configure network interface.
+ *
+ * Copyright 2012 Ranjan Kumar <ranjankumar.bth@gmail.com>, Kyungwan Han <asura321@gamil.com>
+ * Reviewed by Kyungsu Kim, Kyungwan Han <asura321@gamil.com>
+ *
+ * Not in SUSv4.
+ *
+USE_IFCONFIG(NEWTOY(ifconfig, "?a", TOYFLAG_BIN))
+config IFCONFIG
+  bool "ifconfig"
+  default y
+  help
+    usage: ifconfig [-a] interface [address]
+
+    Configure network interface.
+
+    [add ADDRESS[/PREFIXLEN]]
+    [del ADDRESS[/PREFIXLEN]]
+    [[-]broadcast [ADDRESS]] [[-]pointopoint [ADDRESS]]
+    [netmask ADDRESS] [dstaddr ADDRESS]
+    [outfill NN] [keepalive NN]
+    [hw ether|infiniband ADDRESS] [metric NN] [mtu NN]
+    [[-]trailers] [[-]arp] [[-]allmulti]
+    [multicast] [[-]promisc] [txqueuelen NN] [[-]dynamic]
+    [mem_start NN] [io_addr NN] [irq NN]
+    [up|down] ...    
+*/
+
+#define FOR_ifconfig
+#include "toys.h"
+#include "toynet.h"
+#include <net/route.h>
+#include <stddef.h>
+#include <sys/un.h>
+#include <net/if.h>
+#include <net/if_arp.h>
+#include <net/ethernet.h>
+#include <alloca.h>
+
+#define TRUE ((int) 1)
+#define HTTP_DEFAULT_PORT 80
+#define FTP_DEFAULT_PORT 21
+
+#ifndef MAX_PORT_VALUE
+#define MAX_PORT_VALUE 65535
+#endif
+
+typedef struct sockaddr_with_len {
+  union {
+    struct sockaddr sock;
+    struct sockaddr_in sock_in;
+    struct sockaddr_in6 sock_in6;
+  }sock_u;
+  socklen_t socklen;
+}sockaddr_with_len;
+
+//Function Declaration.
+int get_hostname(const char *, struct sockaddr_in *);
+int get_addrinfo(const char *, struct sockaddr_in6 *);
+void get_flag_value(char **, int);
+void display_routes(int, int);
+unsigned getport(const char *, const char *, unsigned);
+void setport(struct sockaddr *, unsigned);
+int connect_to_stream(const sockaddr_with_len *);
+unsigned get_strtou(const char *, char **, int);
+char *address_to_name(const struct sockaddr *);
+sockaddr_with_len *get_sockaddr(const char *, int, sa_family_t);
+
+//Structure Declaration
+typedef struct _proc_net_dev_info {
+  char        ifrname[IFNAMSIZ]; //interface name.
+  unsigned long long   receive_bytes; //total bytes received
+  unsigned long long   receive_packets; //total packets received
+  unsigned long     receive_errors; //bad packets received
+  unsigned long     receive_drop; //no space in linux buffers
+  unsigned long     receive_fifo; //receiver fifo overrun
+  unsigned long     receive_frame; //received frame alignment error
+  unsigned long     receive_compressed;
+  unsigned long     receive_multicast; //multicast packets received
+
+  unsigned long long   transmit_bytes; //total bytes transmitted
+  unsigned long long   transmit_packets; //total packets transmitted
+  unsigned long     transmit_errors; //packet transmit problems
+  unsigned long     transmit_drop; //no space available in linux
+  unsigned long     transmit_fifo;
+  unsigned long     transmit_colls;
+  unsigned long     transmit_carrier;
+  unsigned long     transmit_compressed; //num_tr_compressed;
+}PROC_NET_DEV_INFO;
+
+//man netdevice
+typedef struct _iface_list {
+  int    hw_type;
+  short   ifrflags; //used for addr, broadcast, and mask.
+  short   ifaddr; //if set print ifraddr, irrdstaddr, ifrbroadaddr and ifrnetmask.
+  struct sockaddr ifraddr;
+  struct sockaddr ifrdstaddr;
+  struct sockaddr ifrbroadaddr;
+  struct sockaddr ifrnetmask;
+  struct sockaddr ifrhwaddr;
+  int    ifrmtu;
+  int   ifrmetric;
+  PROC_NET_DEV_INFO dev_info;
+  int   txqueuelen;
+  struct ifmap ifrmap;
+  struct  _iface_list *next; //, *prev;
+}IFACE_LIST;
+
+
+#define HW_NAME_LEN 20
+#define HW_TITLE_LEN 30
+
+typedef struct _hw_info {
+  char hw_name[HW_NAME_LEN];
+  char hw_title[HW_TITLE_LEN];
+  int     hw_addrlen;
+}HW_INFO;
+
+static const char *const field_format[] = {
+  "%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"
+};
+
+#define PROC_NET_DEV "/proc/net/dev"
+#define PROC_NET_IFINET6 "/proc/net/if_inet6"
+#define NO_RANGE -1
+#define IO_MAP_INDEX 0x100
+
+static int show_iface(char *iface_name);
+static void print_ip6_addr(IFACE_LIST *l_ptr);
+static void clear_list(void);
+
+//from /net/if.h
+static char *iface_flags_str[] = {
+      "UP",
+      "BROADCAST",
+      "DEBUG",
+      "LOOPBACK",
+      "POINTOPOINT",
+      "NOTRAILERS",
+      "RUNNING",
+      "NOARP",
+      "PROMISC",
+      "ALLMULTI",
+      "MASTER",
+      "SLAVE",
+      "MULTICAST",
+      "PORTSEL",
+      "AUTOMEDIA",
+      "DYNAMIC",
+      NULL
+};
+//from /usr/include/linux/netdevice.h
+#ifdef IFF_PORTSEL
+//Media selection options.
+# ifndef IF_PORT_UNKNOWN
+enum {
+    IF_PORT_UNKNOWN = 0,
+    IF_PORT_10BASE2,
+    IF_PORT_10BASET,
+    IF_PORT_AUI,
+    IF_PORT_100BASET,
+    IF_PORT_100BASETX,
+    IF_PORT_100BASEFX
+};
+# endif
+#endif
+
+//from kernel header ipv6.h
+#define IPV6_ADDR_ANY 0x0000U
+#define IPV6_ADDR_LOOPBACK  0x0010U
+#define IPV6_ADDR_LINKLOCAL  0x0020U
+#define IPV6_ADDR_SITELOCAL  0x0040U
+#define IPV6_ADDR_COMPATv4  0x0080U
+
+//==================================================================================
+//for the param settings.
+
+//for ipv6 add/del
+struct ifreq_inet6 {
+  struct in6_addr ifrinte6_addr;
+  uint32_t ifrinet6_prefixlen;
+  int ifrinet6_ifindex;
+};
+
+#ifndef SIOCSKEEPALIVE
+# define SIOCSKEEPALIVE  (SIOCDEVPRIVATE)        /* Set keepalive timeout in sec */
+# define SIOCGKEEPALIVE  (SIOCDEVPRIVATE+1)        /* Get keepalive timeout */
+#endif
+
+#ifndef SIOCSOUTFILL
+# define SIOCSOUTFILL  (SIOCDEVPRIVATE+2)        /* Set outfill timeout */
+# define SIOCGOUTFILL  (SIOCDEVPRIVATE+3)        /* Get outfill timeout */
+#endif
+
+#ifndef INFINIBAND_ALEN
+# define INFINIBAND_ALEN 20
+#endif
+
+static void set_data(int sockfd, struct ifreq *ifre, char *kval, int request, const char *req_name);
+static void set_flags(int sockfd, struct ifreq *ifre, int arg_flag, int flag); //verify
+static void set_mtu(int sockfd, struct ifreq *ifre, const char *mtu); //verify
+static void set_metric(int sockfd, struct ifreq *ifre, const char *metric); //verify
+static void set_qlen(int sockfd, struct ifreq *ifre, const char *qlen); //verify
+static void set_address(int sockfd, const char *host_name, struct ifreq *ifre, int request, const char *req_name);
+static void set_hw_address(int sockfd, char ***argv, struct ifreq *ifre, int request, const char *req_name);
+static void set_ipv6_addr(int sockfd, struct ifreq *ifre, const char *ipv6_addr, int request, const char *req_name);
+static void set_memstart(int sockfd, struct ifreq *ifre, const char *start_addr, int request, const char *req_name);
+static void set_ioaddr(int sockfd, struct ifreq *ifre, const char *baddr, int request, const char *req_name);
+static void set_irq(int sockfd, struct ifreq *ifre, const char *irq_val, int request, const char *req_name);
+
+char *omit_whitespace(const char *s)
+{
+  while(*s == ' ' || (unsigned char)(*s - 9) <= (13 - 9)) s++;
+  return (char *) s;
+}
+
+char *safe_strncpy(char *dst, const char *src, size_t size)
+{
+  if(!size) return dst;
+  dst[--size] = '\0';
+  return strncpy(dst, src, size);
+}
+
+/*
+ * used to get the host name from the given ip.
+ */
+int get_hostname(const char *ipstr, struct sockaddr_in *sockin)
+{
+  struct hostent *host;
+  sockin->sin_family = AF_INET;
+  sockin->sin_port = 0;
+
+  if(strcmp(ipstr, "default") == 0) {
+    sockin->sin_addr.s_addr = INADDR_ANY;
+    return 1;
+  }
+
+  if(inet_aton(ipstr, &sockin->sin_addr)) return 0;
+
+  host = gethostbyname(ipstr);
+  if(host == NULL) return -1;
+  memcpy(&sockin->sin_addr, host->h_addr_list[0], sizeof(struct in_addr));
+  return 0;
+}
+
+/*
+ * used to extract the address info from the given ip.
+ */
+int get_addrinfo(const char *ip, struct sockaddr_in6 *sock_in6)
+{
+  struct addrinfo hints, *result;
+  int status = 0;
+
+  memset(&hints, 0, sizeof(struct addrinfo));
+  hints.ai_family = AF_INET6;
+  if((status = getaddrinfo(ip, NULL, &hints, &result)) != 0) {
+    perror_msg("getaddrinfo: %s", gai_strerror(status));
+    return -1;
+  }
+  if(result) {
+    memcpy(sock_in6, result->ai_addr, sizeof(*sock_in6));
+    freeaddrinfo(result);
+  }
+  return 0;
+}
+
+/*
+ * used to get the flag values for route command.
+ */
+void get_flag_value(char **flagstr, int flags)
+{
+  int i = 0;
+  char *str = *flagstr;
+  static const char flagchars[] = "GHRDMDAC";
+  static const unsigned flagarray[] = {
+    RTF_GATEWAY,
+    RTF_HOST,
+    RTF_REINSTATE,
+    RTF_DYNAMIC,
+    RTF_MODIFIED,
+    RTF_DEFAULT,
+    RTF_ADDRCONF,
+    RTF_CACHE
+  };
+  *str++ = 'U';
+  while( (*str = flagchars[i]) != 0) {
+    if(flags & flagarray[i++]) ++str;
+  }
+}
+
+/*
+ * extract inet4 route info from /proc/net/route file and display it.
+ */
+void display_routes(int is_more_info, int notresolve)
+{
+#define IPV4_MASK (RTF_GATEWAY|RTF_HOST|RTF_REINSTATE|RTF_DYNAMIC|RTF_MODIFIED)
+  unsigned long dest, gate, mask;
+  int flags, ref, use, metric, mss, win, irtt;
+  char iface[64]={0,};
+  char buf[BUFSIZ] = {0,};
+  char *flag_val = xzalloc(10); //there are 9 flags "UGHRDMDAC" for route.
+
+  FILE *fp = xfopen("/proc/net/route", "r");
+
+  xprintf("Kernel IP routing table\n"
+                   "Destination     Gateway         Genmask         Flags %s Iface\n",
+  	                        is_more_info ? "  MSS Window  irtt" : "Metric Ref    Use");
+  fgets(buf, BUFSIZ, fp); //skip 1st line.
+  while(fgets(buf, BUFSIZ, fp)) {
+     int nitems = 0;
+     char *destip = NULL, *gateip = NULL, *maskip = NULL;
+     memset(flag_val, 0, 10);
+
+     nitems = sscanf(buf, "%63s%lx%lx%X%d%d%d%lx%d%d%d\n",
+                 iface, &dest, &gate, &flags, &ref, &use, &metric, &mask, &mss, &win, &irtt);
+     if(nitems != 11) {//EOF with no (nonspace) chars read...
+       if((nitems < 0) && feof(fp)) break;
+      perror_exit("fscanf");
+    }
+    //skip down interfaces...
+    if(!(flags & RTF_UP)) continue;
+
+    //For Destination
+    if(dest){
+      if(inet_ntop(AF_INET, &dest, buf, BUFSIZ) > 0) destip = xstrdup(buf);
+    }
+    else {
+      if(!notresolve) destip = xstrdup("default");
+      else destip = xstrdup("0.0.0.0");
+    }
+    //For Gateway
+    if(gate){
+      if(inet_ntop(AF_INET, &gate, buf, BUFSIZ) > 0) gateip = xstrdup(buf);
+    }
+    else {
+      if(!notresolve) gateip = xstrdup("*");
+      else gateip = xstrdup("0.0.0.0");
+    }
+    //For Mask
+    if(inet_ntop(AF_INET, &mask, buf, BUFSIZ) > 0) maskip = xstrdup(buf);
+
+    //Get flag Values
+    get_flag_value(&flag_val, (flags & IPV4_MASK));
+    if(flags & RTF_REJECT) flag_val[0] = '!';
+    xprintf("%-15.15s %-15.15s %-16s%-6s", destip, gateip, maskip, flag_val);
+    if(destip) free(destip);
+    if(gateip) free(gateip);
+    if(maskip) free(maskip);
+    if(is_more_info) xprintf("%5d %-5d %6d %s\n", mss, win, irtt, iface);
+    else xprintf("%-6d %-2d %7d %s\n", metric, ref, use, iface);
+  }//end of while...
+  fclose(fp);
+  if(flag_val) free(flag_val);
+#undef IPV4_MASK
+  return;
+}
+
+/*
+ * verify the host is local unix path.
+ * if so, set the swl input param accordingly.
+ */
+static int is_host_unix(const char *host, sockaddr_with_len **swl)
+{
+  if(strncmp(host, "local:", 6) == 0) {
+    struct sockaddr_un *sockun;
+    *swl = xzalloc(sizeof(struct sockaddr_with_len));
+    (*swl)->socklen = sizeof(struct sockaddr_un);
+    (*swl)->sock_u.sock.sa_family = AF_UNIX;
+    sockun = (struct sockaddr_un *)&(*swl)->sock_u.sock;
+    safe_strncpy(sockun->sun_path, host + 6, sizeof(sockun->sun_path));
+    return 1;
+  }
+  return 0;
+}
+
+/*
+ * validate the input param (host) for valid ipv6 ip and extract port number (if there).
+ */
+static void get_host_and_port(char **host, int *port)
+{
+  char *ch_ptr;
+  const char *org_host = *host;
+  if(*host[0] == '[') {
+    (*host)++;
+    ch_ptr = strchr(*host, ']');
+    if(!ch_ptr || (ch_ptr[1] != ':' && ch_ptr[1] != '\0'))
+      error_exit("bad address '%s'", org_host);
+  }
+  else {
+    ch_ptr = strrchr(*host, ':');
+    //There is more than one ':' like "::1"
+    if(ch_ptr && strchr(*host, ':') != ch_ptr)
+      ch_ptr = NULL;
+  }
+  if(ch_ptr) { //pointer to ":" or "]:"
+    int size = ch_ptr - (*host) + 1;
+    safe_strncpy(*host, *host, size);
+    if(*ch_ptr != ':') {
+      ch_ptr++; //skip ']'
+      //[nn] without port
+      if(*ch_ptr == '\0')
+        return;
+    }
+    ch_ptr++; //skip ':' to get the port number.
+    *port = get_strtou(ch_ptr, NULL, 10);
+    if(errno || (unsigned)*port > MAX_PORT_VALUE)
+      error_exit("bad port spec '%s'", org_host);
+   }
+  return;
+}
+
+/*
+ * used to extract the address info from the given host ip
+ * and update the swl param accordingly.
+ */
+static int get_socket_stream(const char *host, sa_family_t af, sockaddr_with_len **swl)
+{
+  struct addrinfo hints;
+  struct addrinfo *result, *rp;
+  int status = 0;
+
+  memset(&hints, 0 , sizeof(struct addrinfo));
+  hints.ai_family = af;
+  hints.ai_socktype = SOCK_STREAM;
+
+  if((status = getaddrinfo(host, NULL, &hints, &result)) != 0) {
+    perror_exit("bad address '%s' : %s", host, gai_strerror(status));
+    return status;
+  }
+
+  for(rp = result; rp != NULL; rp = rp->ai_next) {
+    if( (rp->ai_family == AF_INET) || (rp->ai_family == AF_INET6)) {
+      *swl = xmalloc(sizeof(struct sockaddr_with_len));
+      (*swl)->socklen = rp->ai_addrlen;
+      memcpy(&((*swl)->sock_u.sock), rp->ai_addr, rp->ai_addrlen);
+      break;
+    }
+  }
+  freeaddrinfo(result);
+  return ((!rp)? -1: status);
+}
+
+/*
+ * use to get the socket address with the given host ip.
+ */
+sockaddr_with_len *get_sockaddr(const char *host, int port, sa_family_t af)
+{
+  sockaddr_with_len *swl = NULL;
+  int status = 0;
+
+  //for unix
+  int is_unix = is_host_unix(host, &swl);
+  if(is_unix && swl) return swl;
+
+  //[IPV6_ip]:port_num
+  if(host[0] == '[' || strrchr(host, ':')) get_host_and_port((char **)&host, &port);
+
+  //for the socket streams.
+  status = get_socket_stream(host, af, &swl);
+  if(status) return NULL;
+
+  setport(&swl->sock_u.sock, htons(port));
+  return swl;
+}
+
+/*
+ * get the numeric hostname and service name, for a given socket address.
+ */
+char *address_to_name(const struct sockaddr *sock)
+{
+  //man page of getnameinfo.
+  char hbuf[NI_MAXHOST] = {0,}, sbuf[NI_MAXSERV] = {0,};
+  int status = 0;
+  if(sock->sa_family == AF_INET) {
+    socklen_t len = sizeof(struct sockaddr_in);
+    if((status = getnameinfo(sock, len, hbuf, sizeof(hbuf), sbuf, sizeof(sbuf), NI_NUMERICHOST | NI_NUMERICSERV)) == 0)
+      return xmsprintf("%s:%s", hbuf, sbuf);
+    else {
+      fprintf(stderr, "getnameinfo: %s\n", gai_strerror(status));
+      return NULL;
+    }
+  }
+  else if(sock->sa_family == AF_INET6) {
+    socklen_t len = sizeof(struct sockaddr_in6);
+    if((status = getnameinfo(sock, len, hbuf, sizeof(hbuf), sbuf, sizeof(sbuf), NI_NUMERICHOST | NI_NUMERICSERV)) == 0) {
+      //verification for resolved hostname.
+      if(strchr(hbuf, ':')) return xmsprintf("[%s]:%s", hbuf, sbuf);
+      else return xmsprintf("%s:%s", hbuf, sbuf);
+    }
+    else {
+      fprintf(stderr, "getnameinfo: %s\n", gai_strerror(status));
+      return NULL;
+    }
+  }
+  else if(sock->sa_family == AF_UNIX) {
+    struct sockaddr_un *sockun = (void*)sock;
+    return xmsprintf("local:%.*s", (int) sizeof(sockun->sun_path), sockun->sun_path);
+  }
+  else
+    return NULL;
+}
+
+/*
+ * used to set the port number for ipv4 / ipv6 addresses.
+ */
+void setport(struct sockaddr *sock, unsigned port_num)
+{
+  //for ipv4
+  if(sock->sa_family == AF_INET) {
+    struct sockaddr_in *sock_in = (void*)sock;
+    sock_in->sin_port = port_num;
+  }
+  //for ipv6
+  else if(sock->sa_family == AF_INET6) {
+    struct sockaddr_in6 *sock_in6 = (void*)sock;
+    sock_in6->sin6_port = port_num;
+  }
+  return;
+}
+
+/*
+ * used to get the port number for ftp and http.
+ */
+unsigned getport(const char *port, const char *protocol, unsigned defport)
+{
+#define RANGE_STR "Port Number should be in [1-65535] range"
+  long v;
+  char *endptr = NULL;
+
+  unsigned portnum = defport;
+  if(port) {
+    errno = 0;
+    v = strtol(port, &endptr, 10);
+    if((v > 0) && (!*endptr)) {//for numeric like 123
+      portnum = v;
+      if(portnum > MAX_PORT_VALUE) error_exit("Invalid Port Number '%s' "RANGE_STR, port);
+    }
+    else if((v == 0) && (endptr != NULL)) {
+      switch(defport) {
+        case FTP_DEFAULT_PORT:
+          if(strcmp(endptr, "ftp") == 0) portnum = defport; //for "ftp" string.
+          else goto ERROR_EXIT;
+          break;
+        case HTTP_DEFAULT_PORT:
+          if(strcmp(endptr, "http") == 0) portnum = defport;//for "HTTP" string.
+          else goto ERROR_EXIT;
+          break;
+        default:
+ERROR_EXIT:
+          error_exit("Invalid Port");
+          break;
+      }
+    }
+    else perror_exit("Invalid Port Number: '%s' "RANGE_STR, port);
+  }
+#undef RANGE_STR
+  return (uint16_t)portnum;
+}
+
+/*
+ * used to connect with the socket.
+ */
+int connect_to_stream(const sockaddr_with_len *swl)
+{
+  int sockfd;
+  if((sockfd = socket(swl->sock_u.sock.sa_family, SOCK_STREAM, 0)) < 0)
+    perror_exit("cannot open control socket");
+  if(connect(sockfd, &swl->sock_u.sock, swl->socklen) < 0) {
+    close(sockfd);
+    perror_exit("can't connect to remote host");
+  }
+  return sockfd;
+}
+
+/*
+ * used to converts string into int and validate the input str for invalid int value or out-of-range.
+ */
+unsigned get_strtou(const char *str, char **endp, int base)
+{
+  unsigned long uli;
+  char *endptr;
+
+  if(!isalnum(str[0])) {
+    errno = ERANGE;
+    return UINT_MAX;
+  }
+  errno = 0;
+  uli = strtoul(str, &endptr, base);
+  if(uli > UINT_MAX) {
+    errno = ERANGE;
+    return UINT_MAX;
+  }
+
+  if(endp) *endp = endptr;
+  if(endptr[0]) {
+    if(isalnum(endptr[0]) || errno) { //"123abc" or out-of-range
+      errno = ERANGE;
+      return UINT_MAX;
+    }
+    errno = EINVAL;
+  }
+  return uli;
+}
+
+
+IFACE_LIST *iface_list_head;
+
+/*
+ * display help info and exit from application.
+ */
+static void show_help(void)
+{
+  char **arg = xzalloc(sizeof(char*) *3);
+  arg[0] = "help";
+  arg[1] = xstrdup(toys.which->name);
+  toy_exec(arg);
+}
+
+void ifconfig_main(void)
+{
+  char **argv = toys.optargs;
+
+  if(argv[0] && (strcmp(argv[0], "--help") == 0))
+    show_help();
+  
+  //"ifconfig" / "ifconfig eth0"
+  if(!argv[0] || !argv[1]) { //one or no argument
+    toys.exitval = show_iface(argv[0]);
+    //free allocated memory.
+    clear_list();
+    return;
+  }
+
+  //set ifconfig params.
+  {
+    struct ifreq ifre;
+    int sockfd = 0;
+    //get interface name
+    memset(&ifre, 0, sizeof(struct ifreq));
+    strncpy(ifre.ifr_name, *argv, IFNAMSIZ);
+    ifre.ifr_name[IFNAMSIZ-1] = 0;
+    if((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
+      perror_exit("cannot open control socket\n", 1);
+
+    while(*++argv != NULL) {
+      /* flags settings */
+      if(strcmp(argv[0], "up") == 0)
+        set_flags(sockfd, &ifre, IFF_UP | IFF_RUNNING, 0);
+      else if(strcmp(argv[0], "down") == 0)
+        set_flags(sockfd, &ifre, 0, IFF_UP);
+
+      else if(strcmp(argv[0], "arp") == 0)
+        set_flags(sockfd, &ifre, 0, IFF_NOARP);
+      else if(strcmp(argv[0], "-arp") == 0)
+        set_flags(sockfd, &ifre, IFF_NOARP, 0);
+      else if(strcmp(argv[0], "trailers") == 0)
+        set_flags(sockfd, &ifre, 0, IFF_NOTRAILERS);
+      else if(strcmp(argv[0], "-trailers") == 0)
+        set_flags(sockfd, &ifre, IFF_NOTRAILERS, 0);
+
+      else if(strcmp(argv[0], "promisc") == 0)
+        set_flags(sockfd, &ifre, IFF_PROMISC, 0);
+      else if(strcmp(argv[0], "-promisc") == 0)
+        set_flags(sockfd, &ifre, 0, IFF_PROMISC);
+      else if(strcmp(argv[0], "allmulti") == 0)
+        set_flags(sockfd, &ifre, IFF_ALLMULTI, 0);
+      else if(strcmp(argv[0], "-allmulti") == 0)
+        set_flags(sockfd, &ifre, 0, IFF_ALLMULTI);
+      else if(strcmp(argv[0], "multicast") == 0)
+        set_flags(sockfd, &ifre, IFF_MULTICAST, 0);
+      else if(strcmp(argv[0], "-multicast") == 0)
+        set_flags(sockfd, &ifre, 0, IFF_MULTICAST);
+      else if(strcmp(argv[0], "dynamic") == 0)
+        set_flags(sockfd, &ifre, IFF_DYNAMIC, 0);
+      else if(strcmp(argv[0], "-dynamic") == 0)
+        set_flags(sockfd, &ifre, 0, IFF_DYNAMIC);
+      else if(strcmp(argv[0], "-pointopoint") == 0)
+        set_flags(sockfd, &ifre, 0, IFF_POINTOPOINT);
+      /*value setup */
+      else if(strcmp(argv[0], "pointopoint") == 0) {
+        if(*++argv == NULL) {
+          errno = EINVAL;
+          show_help();
+        }
+        set_address(sockfd, *argv, &ifre, SIOCSIFDSTADDR, "SIOCSIFDSTADDR");
+        set_flags(sockfd, &ifre, IFF_POINTOPOINT, 0);
+      }
+      else if(strcmp(argv[0], "netmask") == 0) {
+        if(*++argv == NULL) {
+          errno = EINVAL;
+          show_help();
+        }
+        set_address(sockfd, *argv, &ifre, SIOCSIFNETMASK, "SIOCSIFNETMASK");
+      }
+      else if(strcmp(argv[0], "-broadcast") == 0) {
+        set_flags(sockfd, &ifre, 0, IFF_BROADCAST);
+      }
+      else if(strcmp(argv[0], "broadcast") == 0) {
+        if(*++argv == NULL) {
+          errno = EINVAL;
+          show_help();
+        }
+        set_address(sockfd, *argv, &ifre, SIOCSIFBRDADDR, "SIOCSIFBRDADDR");
+        set_flags(sockfd, &ifre, IFF_BROADCAST, 0);
+      }
+      else if(strcmp(argv[0], "dstaddr") == 0) {
+        if(*++argv == NULL) {
+          errno = EINVAL;
+          show_help();
+        }
+        set_address(sockfd, *argv, &ifre, SIOCSIFDSTADDR, "SIOCSIFDSTADDR");
+      }
+      else if(strcmp(argv[0], "hw") == 0) {
+        if(*++argv == NULL) {
+          errno = EINVAL;
+          show_help();
+        }
+        set_hw_address(sockfd, &argv, &ifre, SIOCSIFHWADDR, "SIOCSIFHWADDR");
+      }
+      else if(strcmp(argv[0], "mtu") == 0) {
+        if(*++argv == NULL) {
+          errno = EINVAL;
+          show_help();
+        }
+        set_mtu(sockfd, &ifre, argv[0]);
+      }//end of mtu
+      else if(strcmp(argv[0], "metric") == 0) {
+        if(*++argv == NULL) {
+          errno = EINVAL;
+          show_help();
+        }
+        set_metric(sockfd, &ifre, argv[0]);
+      }//end of metric
+      else if(strcmp(argv[0], "txqueuelen") == 0) {
+        if(*++argv == NULL) {
+          errno = EINVAL;
+          show_help();
+        }
+        set_qlen(sockfd, &ifre, argv[0]);
+      }//end of txqueuelen
+      else if(strcmp(argv[0], "keepalive") == 0) {
+        if(*++argv == NULL) {
+          errno = EINVAL;
+          show_help();
+        }
+        set_data(sockfd, &ifre, argv[0], SIOCSKEEPALIVE, "SIOCSKEEPALIVE");
+      }//end of keepalive
+      else if(strcmp(argv[0], "outfill") == 0) {
+        if(*++argv == NULL) {
+          errno = EINVAL;
+          show_help();
+        }
+        set_data(sockfd, &ifre, argv[0], SIOCSOUTFILL, "SIOCSOUTFILL");
+      }//end of outfill
+      else if(strcmp(argv[0], "add") == 0) {
+        if(*++argv == NULL) {
+          errno = EINVAL;
+          show_help();
+        }
+        set_ipv6_addr(sockfd, &ifre, argv[0], SIOCSIFADDR, "SIOCSIFADDR");
+      }//end of add ipv6 addr
+      else if(strcmp(argv[0], "del") == 0) {
+        if(*++argv == NULL) {
+          errno = EINVAL;
+          show_help();
+        }
+        set_ipv6_addr(sockfd, &ifre, argv[0], SIOCDIFADDR, "SIOCDIFADDR");
+      }//end of del ipv6 addr
+      else if(strcmp(argv[0], "mem_start") == 0) {
+        if(*++argv == NULL) {
+          errno = EINVAL;
+          show_help();
+        }
+        set_memstart(sockfd, &ifre, argv[0], SIOCSIFMAP, "SIOCSIFMAP");
+      }//end of mem_start
+      else if(strcmp(argv[0], "io_addr") == 0) {
+        if(*++argv == NULL) {
+          errno = EINVAL;
+          show_help();
+        }
+        set_ioaddr(sockfd, &ifre, argv[0], SIOCSIFMAP, "SIOCSIFMAP");
+      }//end of io_addr
+      else if(strcmp(argv[0], "irq") == 0) {
+        if(*++argv == NULL) {
+          errno = EINVAL;
+          show_help();
+        }
+        set_irq(sockfd, &ifre, argv[0], SIOCSIFMAP, "SIOCSIFMAP");
+      }//end of irq
+      else {
+        if(isdigit(argv[0][0]) || (strcmp(argv[0], "default") == 0)) {
+          char *iface_name = ifre.ifr_name;
+          short int is_colon = 0;
+          set_address(sockfd, *argv, &ifre, SIOCSIFADDR, "SIOCSIFADDR");
+          while(*iface_name) {
+            if(*iface_name == ':') {
+              is_colon = 1;
+              break;
+            }
+            iface_name++;
+          }
+          //if the interface name is not an alias; set the flag and continue.
+          if(!is_colon)
+            set_flags(sockfd, &ifre, IFF_UP | IFF_RUNNING, 0);
+        }
+        else if((strcmp(argv[0], "inet") == 0) || (strcmp(argv[0], "inet6") == 0))
+          continue;
+        else {
+          errno = EINVAL;
+          show_help();
+        }
+      }//set ip for an interface.
+
+    }//end of while.
+    if(sockfd > 0)
+      close(sockfd);
+  }
+  return;
+}//End of main function.
+
+
+static void set_flags(int sockfd, struct ifreq *ifre, int set_flag, int reset_flag)
+{
+  if(ioctl(sockfd, SIOCGIFFLAGS, ifre) < 0)
+    perror_exit("SIOCGIFFLAGS");
+  ifre->ifr_flags = (ifre->ifr_flags & (~reset_flag)) | set_flag;
+  if(ioctl(sockfd, SIOCSIFFLAGS, ifre) < 0)
+    perror_exit("SIOCSIFFLAGS");
+  return;
+}
+
+static void set_data(int sockfd, struct ifreq *ifre, char *kval, int request, const char *req_name)
+{
+  unsigned long val = xstrtoul(kval, NULL, 0);
+  char *ptr;
+  ptr = ((char *) ifre) + offsetof(struct ifreq, ifr_data);
+  (*(__caddr_t *)ptr) = (__caddr_t)val;
+
+  if(ioctl(sockfd, request, ifre) < 0) {
+    perror_exit((char *)req_name);
+  }
+  return;
+}
+static void set_mtu(int sockfd, struct ifreq *ifre, const char *mtu)
+{
+  ifre->ifr_mtu = strtoul(mtu, NULL, 0);
+  if(ioctl(sockfd, SIOCSIFMTU, ifre) < 0)
+    perror_exit("SIOCSIFMTU");
+  return;
+}
+
+static void set_metric(int sockfd, struct ifreq *ifre, const char *metric)
+{
+  ifre->ifr_metric = strtoul(metric, NULL, 0);
+  if(ioctl(sockfd, SIOCSIFMETRIC, ifre) < 0)
+    perror_exit("SIOCSIFMETRIC");
+  return;
+}
+
+static void set_qlen(int sockfd, struct ifreq *ifre, const char *qlen)
+{
+  ifre->ifr_qlen = strtoul(qlen, NULL, 0);
+  if(ioctl(sockfd, SIOCSIFTXQLEN, ifre) < 0)
+    perror_exit("SIOCSIFTXQLEN");
+  return;
+}
+
+static void set_ipv6_addr(int sockfd, struct ifreq *ifre, const char *ipv6_addr, int request, const char *req_name)
+{
+  char *prefix;
+  int plen = 0;
+  sockaddr_with_len *swl = NULL;
+
+  prefix = strchr(ipv6_addr, '/');
+  if(prefix) {
+    plen = get_int_value(prefix + 1, 0, 128);
+    *prefix = '\0';
+  }
+  swl = get_sockaddr(ipv6_addr, 0, AF_INET6);
+  if(!swl) error_exit("error in resolving host name");
+    int sockfd6;
+    struct ifreq_inet6 ifre6;
+    memcpy((char *) &ifre6.ifrinte6_addr,
+        (char *) &(swl->sock_u.sock_in6.sin6_addr),
+        sizeof(struct in6_addr));
+    //Create a channel to the NET kernel.
+    if( (sockfd6 = socket(AF_INET6, SOCK_DGRAM, 0)) < 0)
+      perror_exit("AF_INET6 SOCK_DGRAM", 0);
+    if(ioctl(sockfd6, SIOGIFINDEX, ifre) < 0)
+      perror_exit("SIOGIFINDEX");
+    ifre6.ifrinet6_ifindex = ifre->ifr_ifindex;
+    ifre6.ifrinet6_prefixlen = plen;
+
+    if(ioctl(sockfd6, request, &ifre6) < 0)
+      perror_exit((char *)req_name);
+    if(swl != NULL) {
+      free(swl);
+      swl = NULL;
+    }
+  return;
+}
+
+static void set_address(int sockfd, const char *host_name, struct ifreq *ifre, int request, const char *req_name)
+{
+  struct sockaddr_in sock_in;
+  sockaddr_with_len *swl = NULL;
+  sock_in.sin_family = AF_INET;
+  sock_in.sin_port = 0;
+
+  //Default 0.0.0.0
+  if(strcmp(host_name, "default") == 0)
+    sock_in.sin_addr.s_addr = INADDR_ANY;
+  else {
+    swl = get_sockaddr(host_name, 0, AF_INET);
+    if(!swl) error_exit("error in resolving host name");
+
+    sock_in.sin_addr = swl->sock_u.sock_in.sin_addr;
+  }
+  memcpy((char *)&ifre->ifr_addr, (char *) &sock_in, sizeof(struct sockaddr));
+  if(ioctl(sockfd, request, ifre) < 0)
+    perror_exit((char *)req_name);
+
+  if(swl != NULL) {
+    free(swl);
+    swl = NULL;
+  }
+  return;
+}
+
+static int hex_to_binary(const char *hw_addr, struct sockaddr *sock, int count)
+{
+  int i = 0, j = 0;
+  unsigned char nib_val;
+  unsigned char ch;
+
+  char *ptr = (char *) sock->sa_data;
+  if(count == ETH_ALEN)
+    sock->sa_family = ARPHRD_ETHER;
+  else if(count == INFINIBAND_ALEN)
+    sock->sa_family = ARPHRD_INFINIBAND;
+  else
+    return -1;
+  //e.g. hw_addr "62:2D:A6:9E:2D:BE"
+  for(; *hw_addr && (i < count); i++) {
+    if(*hw_addr == ':')
+      hw_addr++;
+    j = nib_val = 0;
+    for(;j < 2; j++) {
+      ch = *hw_addr;
+      //0-9 = 10 chars.
+      if(((unsigned char)(ch - '0')) < 10)
+        ch = (ch - '0');
+      //a-f = 6 chars.
+      else if(((unsigned char)((ch) - 'a')) < 6)
+        ch = (ch - ('a'-10));
+      //A-F = 6 chars.
+      else if(((unsigned char)((ch) - 'A')) < 6)
+        ch = (ch - ('A'-10));
+      else if(j && (ch == ':' || ch == 0))
+        break;
+      else
+        return -1;
+      hw_addr++;
+      nib_val <<= 4;
+      nib_val += ch;
+    }
+    *ptr++ = nib_val;
+  }
+  if(*hw_addr)
+    return -1;
+  return 0;
+}
+
+static void set_hw_address(int sockfd, char ***argv, struct ifreq *ifre, int request, const char *req_name)
+{
+  int hw_class = 0;
+  char *hw_addr;
+  struct sockaddr sock;
+  char *ptr;
+  char *hw_class_strings[] = {
+      "ether",
+      "infiniband",
+      NULL
+  };
+
+  if(strcmp(hw_class_strings[0], **argv) == 0)
+    hw_class = 1;
+  else if(strcmp(hw_class_strings[1], **argv) == 0)
+    hw_class = 2;
+  if(!hw_class || !(*argv += 1))
+    show_help();
+
+  memset(&sock, 0, sizeof(struct sockaddr));
+  hw_addr = **argv;
+  if(hw_class == 1) {
+    if(hex_to_binary(hw_addr, &sock, ETH_ALEN))
+      error_exit("invalid hw-addr %s", hw_addr);
+  }
+  else {
+    if(hex_to_binary(hw_addr, &sock, INFINIBAND_ALEN))
+      error_exit("invalid hw-addr %s", hw_addr);
+  }
+  ptr = (char *)&sock;
+  memcpy( ((char *) ifre) + offsetof(struct ifreq, ifr_hwaddr), ptr, sizeof(struct sockaddr));
+  if(ioctl(sockfd, request, ifre) < 0)
+    perror_exit((char *)req_name);
+  return;
+}
+
+static void set_memstart(int sockfd, struct ifreq *ifre, const char *start_addr, int request, const char *req_name)
+{
+  unsigned long mem_start = strtoul(start_addr, NULL, 0);
+
+  if(ioctl(sockfd, SIOCGIFMAP, ifre) < 0)
+    perror_exit("SIOCGIFMAP");
+  ifre->ifr_map.mem_start = mem_start;
+  if(ioctl(sockfd, request, ifre) < 0)
+    perror_exit((char *)req_name);
+  return;
+}
+
+static void set_ioaddr(int sockfd, struct ifreq *ifre, const char *baddr, int request, const char *req_name)
+{
+  unsigned short int base_addr = strtoul(baddr, NULL, 0);
+  if(ioctl(sockfd, SIOCGIFMAP, ifre) < 0)
+    perror_exit("SIOCGIFMAP");
+  ifre->ifr_map.base_addr = base_addr;
+  if(ioctl(sockfd, request, ifre) < 0)
+    perror_exit((char *)req_name);
+  return;
+}
+
+static void set_irq(int sockfd, struct ifreq *ifre, const char *irq_val, int request, const char *req_name)
+{
+  unsigned short int irq = strtoul(irq_val, NULL, 0);
+  char *ptr;
+  struct ifmap *map;
+
+  if(ioctl(sockfd, SIOCGIFMAP, ifre) < 0)
+    perror_exit("SIOCGIFMAP");
+
+  ptr = ((char *) ifre) + offsetof(struct ifreq, ifr_map);
+  map = (struct ifmap *)ptr;
+  map->irq = irq;
+  if(ioctl(sockfd, request, ifre) < 0)
+    perror_exit((char *)req_name);
+  return;
+}
+
+/* Display ifconfig info. */
+static void get_proc_info(char *buff, IFACE_LIST *l_ptr, int version)
+{
+  char *name;
+  memset(&l_ptr->dev_info, 0, sizeof(PROC_NET_DEV_INFO));
+
+  buff = omit_whitespace(buff);
+  name = strsep(&buff, ":");
+  if(!buff)
+    error_exit("error in getting the device name:");
+
+  if(strlen(name) < (IFNAMSIZ)) {
+    strncpy(l_ptr->dev_info.ifrname, name, IFNAMSIZ-1);
+    l_ptr->dev_info.ifrname[IFNAMSIZ-1] = '\0';
+  }
+  else {
+    l_ptr->dev_info.ifrname[0] = '\0';
+  }
+
+  sscanf(buff, field_format[version],
+      &l_ptr->dev_info.receive_bytes,
+      &l_ptr->dev_info.receive_packets,
+      &l_ptr->dev_info.receive_errors,
+      &l_ptr->dev_info.receive_drop,
+      &l_ptr->dev_info.receive_fifo,
+      &l_ptr->dev_info.receive_frame,
+      &l_ptr->dev_info.receive_compressed,
+      &l_ptr->dev_info.receive_multicast,
+      &l_ptr->dev_info.transmit_bytes,
+      &l_ptr->dev_info.transmit_packets,
+      &l_ptr->dev_info.transmit_errors,
+      &l_ptr->dev_info.transmit_drop,
+      &l_ptr->dev_info.transmit_fifo,
+      &l_ptr->dev_info.transmit_colls,
+      &l_ptr->dev_info.transmit_carrier,
+      &l_ptr->dev_info.transmit_compressed
+    );
+
+  if(version == 0)
+    l_ptr->dev_info.receive_bytes = l_ptr->dev_info.transmit_bytes = 0;
+  if(version == 1)
+    l_ptr->dev_info.receive_multicast = l_ptr->dev_info.receive_compressed = l_ptr->dev_info.transmit_compressed = 0;
+  return;
+}
+
+static void add_iface_to_list(IFACE_LIST *newnode)
+{
+  IFACE_LIST *head_ref = iface_list_head;
+
+  if((head_ref == NULL) || strcmp(newnode->dev_info.ifrname, head_ref->dev_info.ifrname) < 0) {
+    newnode->next = head_ref;
+    head_ref = newnode;
+  }
+  else {
+    IFACE_LIST *current = head_ref;
+    while(current->next != NULL && (strcmp(current->next->dev_info.ifrname, newnode->dev_info.ifrname)) < 0)
+      current = current->next;
+    newnode->next = current->next;
+    current->next = newnode;
+  }
+  iface_list_head = head_ref;
+  return;
+}
+
+static int get_device_info(IFACE_LIST *l_ptr)
+{
+  struct ifreq ifre;
+  char *ifrname = l_ptr->dev_info.ifrname;
+  int sokfd;
+
+  sokfd = socket(AF_INET, SOCK_DGRAM, 0);
+  if(sokfd < 0)
+    return sokfd;
+  strncpy(ifre.ifr_name, ifrname, IFNAMSIZ);
+  if(ioctl(sokfd, SIOCGIFFLAGS, &ifre) < 0) {
+    close(sokfd);
+    return NO_RANGE;
+  }
+  l_ptr->ifrflags = ifre.ifr_flags;
+
+  strncpy(ifre.ifr_name, ifrname, IFNAMSIZ);
+  if(ioctl(sokfd, SIOCGIFHWADDR, &ifre) >= 0)
+    memcpy(l_ptr->ifrhwaddr.sa_data, ifre.ifr_hwaddr.sa_data, sizeof(l_ptr->ifrhwaddr.sa_data));
+
+  l_ptr->hw_type = ifre.ifr_hwaddr.sa_family;
+
+  strncpy(ifre.ifr_name, ifrname, IFNAMSIZ);
+  if(ioctl(sokfd, SIOCGIFMETRIC, &ifre) >= 0)
+    l_ptr->ifrmetric = ifre.ifr_metric;
+
+  strncpy(ifre.ifr_name, ifrname, IFNAMSIZ);
+  if(ioctl(sokfd, SIOCGIFMTU, &ifre) >= 0)
+    l_ptr->ifrmtu = ifre.ifr_mtu;
+
+#ifdef SIOCGIFMAP
+  strncpy(ifre.ifr_name, ifrname, IFNAMSIZ);
+  if(ioctl(sokfd, SIOCGIFMAP, &ifre) == 0)
+    l_ptr->ifrmap = ifre.ifr_map;
+#endif
+
+  strncpy(ifre.ifr_name, ifrname, IFNAMSIZ);
+  l_ptr->txqueuelen = NO_RANGE;
+  if(ioctl(sokfd, SIOCGIFTXQLEN, &ifre) >= 0)
+    l_ptr->txqueuelen = ifre.ifr_qlen;
+
+  strncpy(ifre.ifr_name, ifrname, IFNAMSIZ);
+  ifre.ifr_addr.sa_family = AF_INET;
+
+  if(ioctl(sokfd, SIOCGIFADDR, &ifre) == 0) {
+    l_ptr->ifaddr = 1;
+    l_ptr->ifraddr = ifre.ifr_addr;
+    strncpy(ifre.ifr_name, ifrname, IFNAMSIZ);
+    if(ioctl(sokfd, SIOCGIFDSTADDR, &ifre) >= 0)
+      l_ptr->ifrdstaddr = ifre.ifr_dstaddr;
+
+    strncpy(ifre.ifr_name, ifrname, IFNAMSIZ);
+    if(ioctl(sokfd, SIOCGIFBRDADDR, &ifre) >= 0)
+      l_ptr->ifrbroadaddr = ifre.ifr_broadaddr;
+
+    strncpy(ifre.ifr_name, ifrname, IFNAMSIZ);
+    if(ioctl(sokfd, SIOCGIFNETMASK, &ifre) >= 0)
+      l_ptr->ifrnetmask = ifre.ifr_netmask;
+  }
+  close(sokfd);
+  return 0;
+}
+
+static void get_ifconfig_info(void)
+{
+  IFACE_LIST *l_ptr;
+  char buff[BUFSIZ] = {0,};
+  int version_num = 0;
+
+  FILE *fp = fopen(PROC_NET_DEV, "r");
+  if(fp == NULL)
+	  return;
+
+  fgets(buff, sizeof(buff), fp); //skip 1st header line.
+  fgets(buff, sizeof(buff), fp); //skip 2nd header line.
+
+  if(strstr(buff, "compressed"))
+    version_num = 2;
+  else if(strstr(buff, "bytes"))
+    version_num = 1;
+  else
+    version_num = 0;
+
+  while(fgets(buff, BUFSIZ, fp)) {
+    l_ptr = xzalloc(sizeof(IFACE_LIST));
+    get_proc_info(buff, l_ptr, version_num);
+    add_iface_to_list(l_ptr);
+    errno = 0;
+    if(get_device_info(l_ptr) < 0) {
+      const char *errstr = strerror(errno);
+      fclose(fp);
+      fp = NULL;
+      clear_list();
+      perror_exit("%s: error getting interface info: %s", l_ptr->dev_info.ifrname, errstr);
+    }
+  }//end of while.
+  fclose(fp);
+  fp = NULL;
+  return;
+}
+
+static void get_hw_info(int hw_type, HW_INFO *hw_info)
+{
+#define HW_UNSPEC -1
+  switch(hw_type) {
+    case ARPHRD_LOOPBACK: //Loopback device.
+      strncpy(hw_info->hw_name, "loop", HW_NAME_LEN);
+      strncpy(hw_info->hw_title, "Local Loopback", HW_TITLE_LEN);
+      hw_info->hw_addrlen = 0;
+      break;
+    case ARPHRD_ETHER: //Ethernet
+      strncpy(hw_info->hw_name, "ether", HW_NAME_LEN);
+      strncpy(hw_info->hw_title, "Ethernet", HW_TITLE_LEN);
+      hw_info->hw_addrlen = ETH_ALEN;
+      break;
+    case ARPHRD_PPP: //ARPHRD_PPP
+      strncpy(hw_info->hw_name, "ppp", HW_NAME_LEN);
+      strncpy(hw_info->hw_title, "Point-to-Point Protocol", HW_TITLE_LEN);
+      hw_info->hw_addrlen = 0;
+      break;
+    case ARPHRD_INFINIBAND: //InfiniBand
+      strncpy(hw_info->hw_name, "infiniband", HW_NAME_LEN);
+      strncpy(hw_info->hw_title, "InfiniBand", HW_TITLE_LEN);
+      hw_info->hw_addrlen = 20;
+      break;
+    case ARPHRD_SIT: //sit0 device - IPv6-in-IPv4
+      strncpy(hw_info->hw_name, "sit", HW_NAME_LEN);
+      strncpy(hw_info->hw_title, "IPv6-in-IPv4", HW_TITLE_LEN);
+      hw_info->hw_addrlen = 0;
+      break;
+    case HW_UNSPEC: //UNSPEC
+      strncpy(hw_info->hw_name, "unspec", HW_NAME_LEN);
+      strncpy(hw_info->hw_title, "UNSPEC", HW_TITLE_LEN);
+      hw_info->hw_addrlen = 0;
+      break;
+    default:
+      break;
+  }
+#undef HW_UNSPEC
+  return;
+}
+
+static void print_hw_addr(int hw_type, HW_INFO hw_info, IFACE_LIST *l_ptr)
+{
+  unsigned char *address = (unsigned char *) l_ptr->ifrhwaddr.sa_data;
+  if(!address || (hw_info.hw_addrlen == 0))
+    return;
+  xprintf("HWaddr ");
+  if(hw_type == ARPHRD_ETHER)
+    xprintf("%02X:%02X:%02X:%02X:%02X:%02X", address[0], address[1], address[2],
+                         address[3], address[4], address[5]);
+  return;
+}
+
+static const char *get_ip_addr(struct sockaddr *skaddr)
+{
+  static char *ip_str = NULL;
+  struct sockaddr_in *sin;
+
+  if(skaddr->sa_family == 0xFFFF || skaddr->sa_family == 0)
+    return "[NOT SET]";
+  sin = (struct sockaddr_in *)skaddr;
+  if(sin->sin_family != AF_INET) {
+    errno = EAFNOSUPPORT;
+    return NULL;
+  }
+  if( (ip_str = inet_ntoa(sin->sin_addr)) != NULL)
+    return ip_str;
+
+  return NULL;
+}
+
+static void print_ip_addr(IFACE_LIST *l_ptr)
+{
+  const char *af_name;
+  int af = l_ptr->ifraddr.sa_family;
+  if(af == AF_INET)
+    af_name = "inet";
+  else if(af == AF_INET6)
+    af_name = "inet6";
+  else if(af == AF_UNSPEC)
+    af_name = "unspec";
+
+  xprintf("%10s%s addr:%s ", " ", af_name, get_ip_addr(&l_ptr->ifraddr));
+  if(l_ptr->ifrflags & IFF_POINTOPOINT)
+    xprintf(" P-t-P:%s ", get_ip_addr(&l_ptr->ifrdstaddr));
+  if(l_ptr->ifrflags & IFF_BROADCAST)
+    xprintf(" Bcast:%s ", get_ip_addr(&l_ptr->ifrbroadaddr));
+  xprintf(" Mask:%s\n", get_ip_addr(&l_ptr->ifrnetmask));
+  return;
+}
+
+static void print_iface_flags(IFACE_LIST *l_ptr)
+{
+  if(l_ptr->ifrflags != 0) {
+    unsigned short mask = 1;
+    char **str = iface_flags_str;
+    for(; *str != NULL; str++) {
+      if(l_ptr->ifrflags & mask)
+        xprintf("%s ", *str);
+      mask = mask << 1;
+    }
+  }
+  else
+    xprintf("[NO FLAGS] ");
+  return;
+}
+
+static void print_media(IFACE_LIST *l_ptr)
+{
+#ifdef IFF_PORTSEL
+  if(l_ptr->ifrflags & IFF_PORTSEL) {
+    xprintf("Media:");
+    if(l_ptr->ifrmap.port == IF_PORT_UNKNOWN)
+      xprintf("%s", "unknown");
+    else if(l_ptr->ifrmap.port == IF_PORT_10BASE2)
+      xprintf("%s", "10base2");
+    else if(l_ptr->ifrmap.port == IF_PORT_10BASET)
+      xprintf("%s", "10baseT");
+    else if(l_ptr->ifrmap.port == IF_PORT_AUI)
+      xprintf("%s", "AUI");
+    else if(l_ptr->ifrmap.port == IF_PORT_100BASET)
+      xprintf("%s", "100baseT");
+    else if(l_ptr->ifrmap.port == IF_PORT_100BASETX)
+      xprintf("%s", "100baseTX");
+    else if(l_ptr->ifrmap.port == IF_PORT_100BASEFX)
+      xprintf("%s", "100baseFX");
+    if(l_ptr->ifrflags & IFF_AUTOMEDIA)
+      xprintf("(auto)");
+  }
+#endif
+  return;
+}
+
+static void print_ip6_addr(IFACE_LIST *l_ptr)
+{
+  char iface_name[IFNAMSIZ] = {0,};
+  char buf[BUFSIZ] = {0,};
+  int plen, scope;
+
+  FILE *fp = fopen(PROC_NET_IFINET6, "r");
+  if(fp == NULL)
+	  return;
+
+  while(fgets(buf, BUFSIZ, fp)) {
+    int nitems = 0;
+    char ipv6_addr[40] = {0,};
+    nitems = sscanf(buf, "%32s %*08x %02x %02x %*02x %16s\n",
+        ipv6_addr+7, &plen, &scope, iface_name);
+    if(nitems != 4) {
+      if((nitems < 0) && feof(fp))
+        break;
+      perror_exit("sscanf");
+    }
+    if(strcmp(l_ptr->dev_info.ifrname,iface_name) == 0) {
+      int i = 0;
+      struct sockaddr_in6 sock_in6;
+      int len = sizeof(ipv6_addr) / (sizeof ipv6_addr[0]);
+      char *ptr = ipv6_addr+7;
+      while((i < len-2) && (*ptr)) {
+        ipv6_addr[i++] = *ptr++;
+        //put ':' after 4th bit
+        if(!((i+1) % 5))
+          ipv6_addr[i++] = ':';
+      }
+      ipv6_addr[i+1] = '\0';
+      if(inet_pton(AF_INET6, ipv6_addr, (struct sockaddr *) &sock_in6.sin6_addr) > 0) {
+        sock_in6.sin6_family = AF_INET6;
+        memset(buf, 0, (sizeof(buf) /sizeof(buf[0])));
+        if(inet_ntop(AF_INET6, &sock_in6.sin6_addr, buf, BUFSIZ) > 0) {
+          xprintf("%10sinet6 addr: %s/%d", " ", buf, plen);
+          xprintf(" Scope:");
+          if(scope == IPV6_ADDR_ANY) xprintf(" Global");
+          else if(scope == IPV6_ADDR_LOOPBACK) xprintf(" Host");
+          else if(scope == IPV6_ADDR_LINKLOCAL) xprintf(" Link");
+          else if(scope == IPV6_ADDR_SITELOCAL) xprintf(" Site");
+          else if(scope == IPV6_ADDR_COMPATv4) xprintf(" Compat");
+          else xprintf("Unknown");
+          xprintf("\n");
+        }
+      }
+    }
+  }//end of  while.
+  fclose(fp);
+  fp = NULL;
+  return;
+}
+
+static void display_ifconfig(IFACE_LIST *l_ptr)
+{
+  HW_INFO hw_info;
+  int hw_type = l_ptr->hw_type;
+
+  memset(&hw_info, 0, sizeof(HW_INFO));
+
+  get_hw_info(hw_type, &hw_info);
+  xprintf("%-9s Link encap:%s  ", l_ptr->dev_info.ifrname, hw_info.hw_title);
+  print_hw_addr(hw_type, hw_info, l_ptr);
+
+  print_media(l_ptr);
+
+  xprintf("\n");
+  if(l_ptr->ifaddr)
+    print_ip_addr(l_ptr); //print addr, p-p addr, broadcast addr and mask addr.
+
+  //for ipv6 to do.
+  print_ip6_addr(l_ptr);
+  xprintf("%10s", " ");
+  //print flags
+  print_iface_flags(l_ptr);
+  if(!l_ptr->ifrmetric)
+    l_ptr->ifrmetric = 1;
+  xprintf(" MTU:%d  Metric:%d", l_ptr->ifrmtu, l_ptr->ifrmetric);
+  xprintf("\n%10s", " ");
+  xprintf("RX packets:%llu errors:%lu dropped:%lu overruns:%lu frame:%lu\n",
+      l_ptr->dev_info.receive_packets, l_ptr->dev_info.receive_errors,
+      l_ptr->dev_info.receive_drop, l_ptr->dev_info.receive_fifo,
+      l_ptr->dev_info.receive_frame);
+  //Dummy types for non ARP hardware.
+  if((hw_type == ARPHRD_CSLIP) || (hw_type == ARPHRD_CSLIP6))
+    xprintf("%10scompressed:%lu\n", " ", l_ptr->dev_info.receive_compressed);
+  xprintf("%10sTX packets:%llu errors:%lu dropped:%lu overruns:%lu carrier:%lu\n", " ",
+      l_ptr->dev_info.transmit_packets, l_ptr->dev_info.transmit_errors,
+      l_ptr->dev_info.transmit_drop, l_ptr->dev_info.transmit_fifo,
+      l_ptr->dev_info.transmit_carrier);
+  xprintf("%10scollisions:%lu ", " ", l_ptr->dev_info.transmit_colls);
+  //Dummy types for non ARP hardware.
+  if((hw_type == ARPHRD_CSLIP) || (hw_type == ARPHRD_CSLIP6))
+    xprintf("compressed:%lu ", l_ptr->dev_info.transmit_compressed);
+  if(l_ptr->txqueuelen != NO_RANGE)
+    xprintf("txqueuelen:%d ", l_ptr->txqueuelen);
+
+  xprintf("\n%10s", " ");
+  xprintf("RX bytes:%llu ", l_ptr->dev_info.receive_bytes);
+  xprintf("TX bytes:%llu\n", l_ptr->dev_info.transmit_bytes);
+  if(l_ptr->ifrmap.irq || l_ptr->ifrmap.mem_start || l_ptr->ifrmap.dma || l_ptr->ifrmap.base_addr) {
+    xprintf("%10s", " ");
+    if(l_ptr->ifrmap.irq)
+      xprintf("Interrupt:%d ", l_ptr->ifrmap.irq);
+    if(l_ptr->ifrmap.base_addr >= IO_MAP_INDEX)
+      xprintf("Base address:0x%lx ", l_ptr->ifrmap.base_addr);
+    if(l_ptr->ifrmap.mem_start)
+      xprintf("Memory:%lx-%lx ", l_ptr->ifrmap.mem_start, l_ptr->ifrmap.mem_end);
+    if(l_ptr->ifrmap.dma)
+      xprintf("DMA chan:%x ", l_ptr->ifrmap.dma);
+    xprintf("\n");
+  }
+  xprintf("\n");
+  return;
+}
+
+static int show_iface(char *iface_name)
+{
+  get_ifconfig_info();
+  if(iface_name) {
+    IFACE_LIST *l_ptr;
+    int is_dev_found = 0;
+    for(l_ptr = iface_list_head; l_ptr; l_ptr = l_ptr->next) {
+      if(strcmp(l_ptr->dev_info.ifrname, iface_name) == 0) {
+        is_dev_found = 1;
+        display_ifconfig(l_ptr);
+        break;
+      }
+    }
+    if(!is_dev_found) {
+      error_msg("%s: error getting interface info.", iface_name);
+      return 1;
+    }
+  }
+  else {
+    IFACE_LIST *l_ptr;
+    for(l_ptr = iface_list_head; l_ptr; l_ptr = l_ptr->next) {
+      if((l_ptr->ifrflags & IFF_UP) || (toys.optflags & FLAG_a))
+        display_ifconfig(l_ptr);
+    }
+  }
+  return 0;
+}
+
+static void clear_list(void)
+{
+  IFACE_LIST *temp_ptr;
+  while(iface_list_head != NULL) {
+    temp_ptr = iface_list_head->next;
+    free(iface_list_head);
+    iface_list_head = temp_ptr;
+  }
+  return;
+}