#include <sys/ioctl.h>
#include <net/if.h>
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <linux/ethtool.h>
#include <linux/sockios.h>
#include <errno.h>
using namespace std;

int main()
{
    char buf[1024];
    ifconf ifc;
    ifreq *ifr;
    int sck;
    sck = socket(AF_INET, SOCK_DGRAM, 0);
    if (sck<0)
    {
        cout<<"Socket error."<<endl;
        return 1;
    }
    ifc.ifc_len = sizeof(buf);
    ifc.ifc_buf = buf;
    if (ioctl(sck, SIOCGIFCONF, &ifc) < 0)
    {
        cout<<"Ioctl error: SIOCGIFCONF"<<endl;
        return 1;
    }
    ifr = ifc.ifc_req;
    int nInterfaces = ifc.ifc_len / sizeof(ifreq);
    int i;
    for (i=0;i<nInterfaces;i++)
    {
        cout<<i+1<<"\t"<<ifr[i].ifr_name<<endl;
    }
    return 0;
}

cat > 1.c <<EOD; gcc -Wall -Werror 1.c -o 1 2> /dev/null; if [ $? = 0 ]; then echo "#define HAVE_SOCKADDR_SA_LEN 1" >> config.h; fi
#include <net/if.h>
int main(void)
{
  int          alpha;
  struct ifreq beta;

  alpha=beta.ifr_addr.sa_len;

  return 0;

} /* main() */
EOD
rm -f 1; cat > 1.c <<EOD; gcc -Wall -Werror 1.c -o 1; ./1
#include <net/if.h>
#include <netinet/in.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#include "config.h"

int
max(int ar_alpha,
    int ar_beta
   )
{
  if(ar_alpha>ar_beta)
  {
    return ar_alpha;
  }
  else
  {
    return ar_beta;
  }

} /* max() */

int
main(void)
{
  int            lo_buffer_index;
  int            lo_buffer_length;
  int            lo_entry_length;
  int            lo_family;
  int            lo_previous_length;
  int            lo_socket;

  char          *lo_info_buffer;

  struct ifreq  *lo_info_pointer;

  struct ifconf  lo_ifconf_buffer;

  lo_socket=socket(AF_INET,SOCK_DGRAM,0);

  if(lo_socket<0) { fprintf(stderr,"socket() fail\n"); exit(1); }

  lo_previous_length=0;
  lo_buffer_length  =sizeof(struct ifreq);

  for(;;)
  {
    lo_info_buffer=malloc(lo_buffer_length);

    if(lo_info_buffer==NULL) { fprintf(stderr,"malloc() fail\n"); exit(1); }

    lo_ifconf_buffer.ifc_len=lo_buffer_length;
    lo_ifconf_buffer.ifc_buf=lo_info_buffer;

    if(ioctl(lo_socket,SIOCGIFCONF,&lo_ifconf_buffer)<0)
    {
      if((errno!=EINVAL) || (lo_previous_length!=0))
      {
        fprintf(stderr,"ioctl(SIOCGIFCONF) fail\n"); exit(1);
      }

      /* Otherwise, increase the buffer size and try again. */
    }
    else
    {
      if(lo_ifconf_buffer.ifc_len==lo_previous_length)
      {
        break;
      }

      lo_previous_length=lo_ifconf_buffer.ifc_len;
    }

    free(lo_info_buffer);

    lo_buffer_length*=2;

    if(lo_buffer_length==0) { fprintf(stderr,"mem problem\n"); exit(1); }
  }

  for(lo_buffer_index=0;
      lo_buffer_index<lo_ifconf_buffer.ifc_len;
      lo_buffer_index+=lo_entry_length
     )
  {
    lo_info_pointer=(struct ifreq *)(lo_info_buffer+lo_buffer_index);

#if defined(HAVE_SOCKADDR_SA_LEN)
    lo_entry_length
    =
    max(sizeof(struct sockaddr),
        lo_info_pointer->ifr_addr.sa_len
       );
#else
    switch(((struct sockaddr_in*)(&lo_info_pointer->ifr_addr))->sin_family)
    {
#if defined(AF_INET6)
      case AF_INET6:
      {
        lo_entry_length=sizeof(struct sockaddr_in6);

        break;
      }
#endif
      case AF_INET:
      default:
      {
        lo_entry_length=sizeof(struct sockaddr);

        break;
      }
    }
#endif

    lo_family=((struct sockaddr_in*)(&lo_info_pointer->ifr_addr))->sin_family;

    if(ioctl(lo_socket,SIOCGIFFLAGS,lo_info_pointer))
    {
      continue;
    }

    printf("%s ",lo_info_pointer->ifr_name);

    switch(lo_family)
    {
      case AF_INET : printf("IPv4"                 ); break;
      case AF_INET6: printf("IPv6"                 ); break;
      default      : printf("neither IPv4 nor IPv6"); break;
    }

    printf("\n");
  }

  close(lo_socket);

  return 0;

} /* main() */
EOD