#include <stdio.h>  //for printf
#include <stdlib.h> //for exit
#include <string.h> // for strcmp
#include <sys/socket.h> //for socket,address
#include <sys/types.h>
#include <netinet/in.h>
#include <linux/if_ether.h>
#include <net/if.h>
#include <sys/ioctl.h> //for ioctl
#include <pthread.h>
 
#define INTERFACE "eth0"
#define BUFFLEN 2048
#define UDPPORT 9001
#define REQUEST 0
#define RESPONSE 1
#define RESERVE 2 
#define z_print(fmt,args...) \
 printf("[%s %d]"fmt"\n",__FILE__,__LINE__,##args)
typedef struct {
 uint8_t version;
 uint8_t type;
 uint8_t len;
 uint16_t number;
 char data[255];
} datasend;
 
void* ch_hanlder();
uint8_t randvalue();

#include "zhao_sock.h"
 
int main(int argc,char *argv[])
{
	int sockfd;
	int len;
	int proto;
	int port_s;
	int port_d;
	char recvbuff[BUFFLEN];
	unsigned char type[4];
	unsigned char *ethhead = NULL;
	unsigned char *iphead = NULL;
	unsigned char *p = NULL;
	struct ifreq ifr;
	pthread_t thread_ch;
 
	pthread_create(&thread_ch,NULL,&ch_hanlder,NULL);
 
	sockfd = socket(PF_PACKET,SOCK_RAW,htons(ETH_P_ALL)); 
	if (sockfd < 0)
	{ 
		z_print("socket create error");
		exit(1);
	}
	strcpy(ifr.ifr_name,INTERFACE);
	if (ioctl(sockfd,SIOCGIFFLAGS,&ifr) == -1)
	{
		z_print("set PROMISC fail!\n");
		exit(1);
	}
	ifr.ifr_flags |= IFF_PROMISC;
	if (ioctl(sockfd,SIOCGIFFLAGS,&ifr) == -1)
	{
		z_print("set PROMISC fail!");
		exit(1);
	}
	while(1) 
	{
		len = recvfrom(sockfd,recvbuff,sizeof(recvbuff),0,NULL,NULL);
		if (len < 42)
		{
			z_print("receive error!");
			continue;
		}
		ethhead = recvbuff;  //frame head point
		p = ethhead;
		sprintf(type,"%02x%02x",p[12],p[13]);  //frame type
		if (strcmp(type,"0800") != 0)  //0800 is IP frame
		{
			if (strcmp(type,"0806") == 0)
				printf("protocol: ARP\n");
			else if (strcmp(type,"8035") == 0)
				printf("protocol: RARP\n");
			else
				printf("protocol: unknow\n");
			printf("MAC:%.2x:%.2x:%.2x:%.2x:%.2x:%.2x==>%.2x:%.2x:%.2x:%.2x:%.2x:%.2x\n\n", \
				p[6],p[7],p[8],p[9],p[10],p[11],p[0],p[1],p[2],p[3],p[4],p[5]);  //mac address
			continue;
		}
		iphead = ethhead + 14;  //ip head point
		p = iphead + 12; //ip address
		printf("IP:%d.%d.%d.%d==>%d.%d.%d.%d\n", \
			p[0],p[1],p[2],p[3],p[4],p[5],p[6],p[7]);
		proto = (iphead + 9)[0];  //ip protocol
		p = iphead + 20; //ip port 
		switch(proto)
		{
			case IPPROTO_ICMP:
			printf("protocol: ICMP\n");
			break;
			case IPPROTO_IGMP:
			printf("protocol: IGMP\n");
			break;
			case IPPROTO_IPIP:
			printf("protocol: IPIP\n");
			break;
			case IPPROTO_TCP:
			case IPPROTO_UDP:
			printf("protocol: %s\n",(proto == IPPROTO_TCP) ? "TCP":"UDP");
			port_s = (p[0]<<8)&0XFF00 | p[1]&0XFF;  //source port
			port_d = (p[2]<<8)&0XFF00 | p[3]&0XFF;  // dest port
			printf("source port:%u,",port_s);
			printf("dest port:%u\n",port_d);
			if (port_s == 80 || port_d == 80)
				printf("protocol: HTTP\n");
			else if (port_s == 67 || port_d == 67)
				printf("protocol: DHCP\n");
			else if (port_s == 21 || port_d == 21)
				printf("protocol: FTP\n");
			else if (port_s == 23 || port_d == 23)
				printf("protocol: TELNET\n");
			else if (port_s == 53 || port_d == 53)
				printf("protocol: DNS\n");
			else if (port_s == 137 || port_d == 137 || port_s == 138 || port_d == 138)
				printf("protocol: NetBIOS/SMB\n");
			else
				printf("protocol: other\n");
			break;
			case IPPROTO_RAW:
			printf("RAW\n");
			break;
			default:
			printf("protocol:unknow(%d)\n",proto);
		}
		printf("\n");
	}	
}
 
void* ch_hanlder()
{
	int sockfd;
	int len;
	int flag_close = 0;
	socklen_t addrlen;
	datasend msg_send;
	datasend msg_recv;
	struct sockaddr_in servaddr;
 
	memset(&msg_send,0,sizeof(datasend));
	memset(&msg_recv,0,sizeof(datasend));
	bzero(&servaddr, sizeof(servaddr));
 
	msg_send.version = 1;
	msg_send.type = RESPONSE;
	sprintf(msg_send.data,"%s","received!");
 
	sockfd = socket(AF_INET, SOCK_DGRAM, 0); 
 
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port = htons(UDPPORT);
 
	addrlen = sizeof(struct sockaddr_in);
	if (bind(sockfd, (struct sockaddr *)&servaddr, addrlen) == -1)
	{
		perror("bind error");
		exit(1);
	}
	while (1)
	{
		len = recvfrom(sockfd, &msg_recv, sizeof(datasend),0,(struct sockaddr*)&servaddr, &addrlen);
		printf("version:%3d\n",msg_recv.version);
		printf("type:%d\n",msg_recv.type);
		printf("len:%d\n",msg_recv.len);
		printf("number:%d\n",msg_recv.number);
		printf("data:%s\n",msg_recv.data);
		if (strcmp(msg_recv.data,"close") == 0)
		{
			sprintf(msg_send.data,"%s","close");
			flag_close = 1;
		}
		msg_send.number = msg_recv.number + 1;
		msg_send.len = randvalue();
		sendto(sockfd,&msg_send,sizeof(datasend),0,(struct sockaddr*)&servaddr,addrlen);
		if (flag_close)
			break;
	}
	return;
}
 
uint8_t randvalue()
{
	srand(time(0));
	return (rand() % 255);
}

#include "zhao_sock.h"
 
int main(int argc, char *argv[])
{
	int sockfd;
	int len;
	socklen_t addrlen;
	struct sockaddr_in cliaddr;
	FILE *fd;
	datasend msg_send;
	datasend msg_recv;
 
	fd = fopen("/root/zhao_log.txt","a");
	memset(&msg_send,0,sizeof(datasend));
	memset(&msg_recv,0,sizeof(datasend));
	bzero(&cliaddr, sizeof(cliaddr));
 
	msg_send.version = 1;
	msg_send.type = REQUEST;
	msg_send.number = 1;
	msg_send.len = randvalue();
	sockfd = socket(AF_INET, SOCK_DGRAM, 0);
 
	cliaddr.sin_family = AF_INET;
	cliaddr.sin_port = htons(UDPPORT);
	cliaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
 
	addrlen = sizeof(struct sockaddr_in);
 
	while (1)
	{
	printf("please input send msg:");
	scanf("%s",msg_send.data);
 
	sendto(sockfd,&msg_send,sizeof(datasend),0,(struct sockaddr*)&cliaddr,addrlen);
	len = recvfrom(sockfd, &msg_recv, sizeof(datasend),0,(struct sockaddr*)&cliaddr, &addrlen);
	msg_send.number = msg_recv.number + 1;
	msg_send.len = randvalue();
	printf("version:%3d\n",msg_recv.version);
	printf("type:%d\n",msg_recv.type);
	printf("len:%d\n",msg_recv.len);
	printf("number:%d\n",msg_recv.number);
	printf("data:%s\n",msg_recv.data);
 
	fprintf(fd,"version:%d\n",msg_recv.version);
	fprintf(fd,"type:%d\n",msg_recv.type);
	fprintf(fd,"len:%d\n",msg_recv.len);
	fprintf(fd,"number:%d\n",msg_recv.number);
	fprintf(fd,"data:%s\n",msg_recv.data);
	if (strcmp(msg_recv.data,"close") == 0)
		break;
	}
	fclose(fd);
	return 0;
}
 
uint8_t randvalue()
{
	srand(time(0)+1);
	return (rand() % 255);
}

#include <stdio.h>
#include <stdlib.h>
typedef struct node_t {
	int value;
	struct node_t *next;
} node;
#define LENGTH sizeof(node)
 
node *init_node(){
  int node_length,n=0;
  node *head=NULL;
  node *node_temp1,*node_temp2;
  node_temp2=(node *)malloc(LENGTH);
  printf("node length want to create:");
  scanf("%d",&node_length);
  if(node_length<1){
    printf("no node to create!");
    exit(0);
  }
  while(n<node_length){
    node_temp1=(node *)malloc(LENGTH);
 
    printf("input NO.%d value:",n+1);
    scanf("%d",&node_temp1->value);
    node_temp1->next=NULL;
    if(n==0)
      head=node_temp1;
    else
      node_temp2->next=node_temp1;
    node_temp2=node_temp1;
    n++;
  }
  return head;
}
 
node *insert_node(node *head){
  int insert_value;
  node *temp_node1=head;
  node *temp_node2=(node *)malloc(LENGTH);
  node *temp_node3=NULL;
  printf("insert value:");
  scanf("%d",&insert_value);
  while(temp_node1!=NULL){
    if(temp_node1->value<insert_value){
      temp_node3=temp_node1;
      temp_node1=temp_node1->next;
    }
    else
      break;
  }
  temp_node2->value=insert_value;
  if(temp_node3==NULL){/*locate the first node*/
    temp_node3=head;
    temp_node2->next=temp_node3;
    head=temp_node2;
  }
  else if(temp_node1!=NULL){  /*locate the medium of head,insert between temp3 and temp1*/    
    temp_node2->next=temp_node3->next;
    temp_node3->next=temp_node2;
  }else{  /*locate the end of head*/
    temp_node2->next=NULL;
    temp_node3->next=temp_node2;
  }
  return head;
}
 
node *delete_node(node *head){
  int del_value;
  node *temp_node1=head;
  node *temp_node2;
  printf("input the delete value:");
  scanf("%d",&del_value);
  if(head->value==del_value){ /* delete the head of node*/
    temp_node2=head;
    head=head->next;
    return head;
  }
 
  while(temp_node1!=NULL){
    if(temp_node1->value!=del_value){
      temp_node2=temp_node1;
      temp_node1=temp_node1->next;
    }
    else
      break;
  }
  if(temp_node1!=NULL){
    temp_node2->next=temp_node1->next;
    free(temp_node1);
  }else
    printf("not find what you want to delete!\n");
  return head;
}
 
void search_node(node *head){
  int search_value,n=1;
  node *temp_node=head;
  printf("insert the value which you find:");
  scanf("%d",&search_value);
  while(temp_node!=NULL){
    if(temp_node->value!=search_value){
      temp_node=temp_node->next;
      n++;
    }
    else
      break;
  }
  if(temp_node!=NULL)
    printf("finded what you want.\nthe %d node`s value:%d\n",n,temp_node->value);
  else
    printf("not find!\n");
}
 
void print_node(node *head){
  if(head==NULL){
    printf("blank node!create first please!\n");
    return;
  }
  node *temp_node=head; 
  do{
    printf("value:%d\n",temp_node->value);
    temp_node=temp_node->next;
  } while(temp_node!=NULL);
}
 
node *destroy_node(node *head){
  if(head==NULL){
    printf("blank node!create first please!\n");
    return;
  }
  node *temp_node;
  do{
    temp_node=head->next;
    free(head);
    head=temp_node;
  }while(head!=NULL);
  return head;
}
 
int main(){
  int options;
  node *head=NULL;
loop:
  printf("select options:\t1:create 2:insert 3:delete 4:find 5:print 6:destory 7:exit\ninput options:");
  scanf("%d",&options);
  switch(options){
    case 1:
      head=init_node();
      break;
    case 2:
      head=insert_node(head);
      break;
    case 3:
      head=delete_node(head);
      break;
    case 4:
      search_node(head);
      break;
    case 5:
      print_node(head);
      break;
    case 6:
      head=destroy_node(head);
      break;
    case 7:
      printf("byebye!");
      return 0;
    default:
      printf("invalid options!");
  }
  goto loop;
}

include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
 
#define BUFLEN 255
/*********************************************************************
*filename: mcastclient.c
*purpose: 演示组播编程的基本步骤，其实这就是一个基本的UDP客户端程序
*tidied by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言
*date time:2007-01-25 13:10:00
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Thanks to: Google.com
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！
*********************************************************************/
int main(int argc, char **argv)
{
struct sockaddr_in peeraddr, myaddr;
 
int sockfd;
char recmsg[BUFLEN + 1];
unsigned int socklen;
 
/* 创建 socket 用于UDP通讯 */
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0) {
printf("socket creating error\n");
exit(1);
}
socklen = sizeof(struct sockaddr_in);
 
/* 设置对方的端口和IP信息 */
memset(&peeraddr, 0, socklen);
peeraddr.sin_family = AF_INET;
if (argv[2])
peeraddr.sin_port = htons(atoi(argv[2]));
else
peeraddr.sin_port = htons(7838);
if (argv[1]) {
/* 注意这里设置的对方地址是指组播地址，而不是对方的实际IP地址 */
if (inet_pton(AF_INET, argv[1], &peeraddr.sin_addr) <= 0) {
printf("wrong group address!\n");
exit(0);
}
}
else {
printf("no group address!\n");
exit(0);
}
 
/* 设置自己的端口和IP信息 */
memset(&myaddr, 0, socklen);
myaddr.sin_family = AF_INET;
if (argv[4])
myaddr.sin_port = htons(atoi(argv[4]));
else
myaddr.sin_port = htons(23456);
 
#if 0
if(argv[3]){
if (inet_pton(AF_INET, argv[3], &myaddr.sin_addr) <= 0) {
printf("self ip address error!\n");
exit(0);
}
} 
else
#endif
 
  myaddr.sin_addr.s_addr = INADDR_ANY;
 
/* 绑定自己的端口和IP信息到socket上 */
if (bind
(sockfd, (struct sockaddr *) &myaddr,
sizeof(struct sockaddr_in)) == -1) {
printf("Bind error\n");
exit(0);
}
 
/* 循环接受用户输入的消息发送组播消息 */
for (;;) {
/* 接受用户输入 */
sleep(1);
bzero(recmsg, BUFLEN + 1);
strcpy(recmsg,"I will rock u!");
#if 0
if (fgets(recmsg, BUFLEN, stdin) == (char *) EOF)
 exit(0);
#endif 
 
/* 发送消息 */
if (sendto
(sockfd, recmsg, strlen(recmsg), 0,
(struct sockaddr *) &peeraddr,
sizeof(struct sockaddr_in)) < 0) {
printf("sendto error!\n");
exit(3);
}
printf("'%s' send ok\n", recmsg);
}
}

#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <netdb.h>
#include <errno.h>
 
#define BUFLEN 255
/*********************************************************************
*filename: mcastserver.c
*purpose: 演示组播编程的基本步骤，组播服务器端，关键在于加入组
*tidied by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言
*date time:2007-01-25 13:20:00
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Thanks to: Google.com
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！
*********************************************************************/
int main(int argc, char **argv)
{
struct sockaddr_in peeraddr;
struct in_addr ia;
int sockfd;
char recmsg[BUFLEN + 1];
unsigned int socklen, n;
struct hostent *group;
struct ip_mreq mreq;
 
/* 创建 socket 用于UDP通讯 */
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0) {
printf("socket creating err in udptalk\n");
exit(1);
}
 
/* 设置要加入组播的地址 */
bzero(&mreq, sizeof(struct ip_mreq));
if (argv[1]) {
if ((group = gethostbyname(argv[1])) == (struct hostent *) 0) {
perror("gethostbyname");
exit(errno);
}
} else {
printf
("you should give me a group address, 224.0.0.0-239.255.255.255\n");
exit(errno);
}
 
bcopy((void *) group->h_addr, (void *) &ia, group->h_length);
/* 设置组地址 */
bcopy(&ia, &mreq.imr_multiaddr.s_addr, sizeof(struct in_addr));
 
/* 设置发送组播消息的源主机的地址信息 */
mreq.imr_interface.s_addr = htonl(INADDR_ANY);
 
/* 把本机加入组播地址，即本机网卡作为组播成员，只有加入组才能收到组播消息 */
if (setsockopt
(sockfd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq,
sizeof(struct ip_mreq)) == -1) {
perror("setsockopt");
exit(-1);
}
 
socklen = sizeof(struct sockaddr_in);
memset(&peeraddr, 0, socklen);
peeraddr.sin_family = AF_INET;
if (argv[2])
peeraddr.sin_port = htons(atoi(argv[2]));
else
peeraddr.sin_port = htons(7838);
if (argv[1]) {
if (inet_pton(AF_INET, argv[1], &peeraddr.sin_addr) <= 0) {
printf("Wrong dest IP address!\n");
exit(0);
}
} else {
printf("no group address given, 224.0.0.0-239.255.255.255\n");
exit(errno);
}
 
/* 绑定自己的端口和IP信息到socket上 */
if (bind
(sockfd, (struct sockaddr *) &peeraddr,
sizeof(struct sockaddr_in)) == -1) {
printf("Bind error\n");
exit(0);
}
 
/* 循环接收网络上来的组播消息 */
for (;;) {
bzero(recmsg, BUFLEN + 1);
n = recvfrom(sockfd, recmsg, BUFLEN, 0,
(struct sockaddr *) &peeraddr, &socklen);
if (n < 0) {
printf("recvfrom err in udptalk!\n");
exit(4);
} else {
/* 成功接收到数据报 */
recmsg[n] = 0;
printf("peer:%s\n", recmsg);
}
}
}

#ifndef __NET_INF_H
#define __NET_INF_H
 
#include <net/if.h>
#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <netinet/in.h>
#include <sys/ioctl.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
 
#define IFI_NAME 16
#define IFI_HADDR 8
 
typedef struct ifi_info
{
  char ifi_name[IFI_NAME];
  u_char ifi_haddr[IFI_HADDR];
  u_short ifi_hlen;
  short ifi_flags;
  short ifi_myflags;
  struct sockaddr *ifi_addr;
  struct sockaddr *ifi_brdaddr;
  struct sockaddr *ifi_dstaddr;
  struct ifi_info *ifi_next;
}ifi_info;
 
#define IFI_ALIAS 1
 
struct ifi_info *get_ifi_info(int, int);
 
void free_ifi_info(struct ifi_info *);
 
#endif

#include "net_if.h"
 
ifi_info *get_ifi_info(int family, int doaliases)
{
  ifi_info *ifi, *ifihead, **ifipnext;
  int sockfd, len, lastlen, flags, myflags;
  char *ptr, *buf, lastname[IFNAMSIZ], *cptr;
  struct ifconf ifc;
  struct ifreq *ifr, ifrcopy;
  struct sockaddr_in *sinptr;
 
  if ((sockfd=socket(family, SOCK_DGRAM, 0))<0)
  {
    printf("socket error.\n");
    exit(1);
  }
 
  lastlen = 0;
 
  len = 10*sizeof(struct ifreq);
  while (1)
  {
    buf = (char*)malloc(len);
    ifc.ifc_len = len;
    ifc.ifc_buf = buf;
    if (ioctl(sockfd, SIOCGIFCONF, &ifc)<0)
    {
      if (errno!=EINVAL||lastlen!=0)
      {
        printf("ioctl error.\n");
      }
    }
    else
    {
      if (ifc.ifc_len == lastlen)
        break;
      lastlen = ifc.ifc_len;
    }
    len += 10*sizeof(struct ifreq);
    free(buf);
  }
 
  ifihead = NULL;
  ifipnext = &ifihead;
  lastname[0] = 0;
 
  for (ptr = buf; ptr<buf+ifc.ifc_len;)
  {
    ifr = (struct ifreq*)ptr;
#ifdef HAVE_SOCKADDR_SA_LEN
    len = sizeof(struct sockaddr)>ifr->ifr_addr.sa_len?sizeof(struct sockaddr):ifr->ifr_addr.sa_len;
#else
    switch (ifr->ifr_addr.sa_family)
    {
#ifdef IPV6
    case AF_INET6:
      len = sizeof(struct sockaddr_in6);
      break;
#endif
    case AF_INET:
    default:
      len = sizeof(struct sockaddr);
      break;
    }
#endif
 
    ptr += sizeof(ifr->ifr_name) + len;
 
    if (ifr->ifr_addr.sa_family != family)
      continue;
 
    myflags = 0;
    if ((cptr=strchr(ifr->ifr_name, ':'))!=NULL)
      *cptr = 0;
    if (strncmp(lastname, ifr->ifr_name, IFNAMSIZ)==0)
    {
      if (doaliases == 0)
        continue;
      myflags = IFI_ALIAS;
    }
 
    memcpy(lastname, ifr->ifr_name, IFNAMSIZ);
 
    ifrcopy = *ifr;
    ioctl(sockfd, SIOCGIFFLAGS, &ifrcopy);
    flags = ifrcopy.ifr_flags;
    if ((flags&IFF_UP)==0)
      continue;
    /*
    if ((flags&IFF_BROADCAST)==0)
      continue;
    */
    ifi = calloc(1, sizeof(struct ifi_info));
    *ifipnext = ifi;
    ifipnext = &ifi->ifi_next;
    ifi->ifi_flags = flags;
    ifi->ifi_myflags = myflags;
    memcpy(ifi->ifi_name, ifr->ifr_name, IFI_NAME);
    ifi->ifi_name[IFI_NAME-1] = '\0';
 
    switch (ifr->ifr_addr.sa_family)
    {
    case AF_INET:
      sinptr = (struct sockaddr_in *)&ifr->ifr_addr;
      if (ifi->ifi_addr == NULL)
      {
        ifi->ifi_addr = calloc(1, sizeof(struct sockaddr_in));
        memcpy(ifi->ifi_addr, sinptr, sizeof(struct sockaddr_in));
#ifdef SIOCGIFBRDADDR
        if (flags & IFF_BROADCAST)
        {
          ioctl(sockfd, SIOCGIFBRDADDR, &ifrcopy);
          sinptr = (struct sockaddr_in *)&ifrcopy.ifr_broadaddr;
          ifi->ifi_brdaddr = calloc(1, sizeof(struct sockaddr_in));
          memcpy(ifi->ifi_brdaddr, sinptr, sizeof(struct sockaddr_in));
        }
#endif
#ifdef SIOCGIFDSTADDR
        if (flags & IFF_POINTOPOINT)
        {
          ioctl(sockfd, SIOCGIFDSTADDR, &ifrcopy);
          sinptr = (struct sockaddr_in*)&ifrcopy.ifr_dstaddr;
          ifi->ifi_dstaddr = calloc(1, sizeof(struct sockaddr_in));
          memcpy(ifi->ifi_dstaddr, sinptr, sizeof(struct sockaddr_in));
        }
#endif
      }
      break;
    default:
      break;
    }
  }
  free(buf);
  return(ifihead);
}
 
void free_ifi_info(ifi_info *ifihead)
{
  ifi_info *ifi, *ifinext;
  for (ifi=ifihead; ifi!=NULL; ifi=ifinext)
  {
    if (ifi->ifi_addr!=NULL)
      free(ifi->ifi_addr);
 
    if (ifi->ifi_brdaddr!=NULL)
      free(ifi->ifi_brdaddr);
    if (ifi->ifi_dstaddr!=NULL)
      free(ifi->ifi_dstaddr);
    ifinext = ifi->ifi_next;
 
    free(ifi);
  }
 
}
 
char *sock_ntop(const struct sockaddr *sa, socklen_t salen)
{
  char portstr[7];
  static char str[128];
 
  switch (sa->sa_family)
  {
  case AF_INET:
    {
      struct sockaddr_in *sin = (struct sockaddr_in *)sa;
 
      if (inet_ntop(AF_INET, &sin->sin_addr, str, sizeof(str))==NULL)
        return NULL;
 
      if (ntohs(sin->sin_port)!=0)
      {
        snprintf(portstr, sizeof(portstr), ".%d", ntohs(sin->sin_port));
        strcat(str, portstr);
      }
      return str;
    }
    break;
  case AF_INET6:
    {
      struct sockaddr_in6 *sin = (struct sockaddr_in6 *)sa;
 
      if (inet_ntop(AF_INET6, &sin->sin6_addr, str, sizeof(str))==NULL)
        return NULL;
 
      if (ntohs(sin->sin6_port)!=0)
      {
        snprintf(portstr, sizeof(portstr), ".%d", ntohs(sin->sin6_port));
        strcat(str, portstr);
      }
      return str;
    }
    break;
  default:
    return NULL;
    break;
  }
 
 
}
 
int main(int argc, char *argv[])
{
  ifi_info *ifi, *ifihead;
  struct sockaddr *sa;
  u_char *ptr;
  int i, family, doaliases;
  if (argc!=3)
  {
    printf("usage: ./prifinfo <inet4 | inet 6> <doaliases>");
    exit(1);
  }
 
  if (strcmp(argv[1], "inet4") == 0)
    family = AF_INET;
#ifdef IPV6
  else if (strcmp(argv[1], "inet6") == 0)
    family =AF_INET6;
#endif
  else
  {
    printf("invalid <address-family>");
    exit(1);
  }
 
  doaliases = atoi(argv[2]);
 
  for(ifihead = ifi = get_ifi_info(family, doaliases);
      ifi!=NULL;ifi=ifi->ifi_next)
  {
    printf("%s:<", ifi->ifi_name);
    if (ifi->ifi_flags&IFF_UP) printf("UP");
    if (ifi->ifi_flags&IFF_BROADCAST) printf("BCAST");
    if (ifi->ifi_flags&IFF_MULTICAST) printf("MCAST");
    if (ifi->ifi_flags&IFF_LOOPBACK) printf("LOOP");
    if (ifi->ifi_flags&IFF_POINTOPOINT) printf("P2P");
    printf(">\n");
 
    if ((i=ifi->ifi_hlen)>0)
    {
      ptr = ifi->ifi_haddr;
      do
      {
        printf("%s%x", (i==ifi->ifi_hlen)?" ":":", *ptr++);
      }while(--i>0);
 
      printf("\n");
    }
 
    if ((sa=ifi->ifi_addr)!=NULL)
      printf(" IP addr: %s\n",
             sock_ntop(sa, sizeof(*sa)));
    if ((sa=ifi->ifi_brdaddr)!=NULL)
      printf(" broadcast addr: %s\n",
             sock_ntop(sa, sizeof(*sa)));
    if ((sa=ifi->ifi_dstaddr)!=NULL)
      printf(" destnation addr: %s\n",
             sock_ntop(sa, sizeof(*sa)));
  }
 
  free_ifi_info(ifihead);
 
  exit(0);
}

#ifndef __ZNET_H__
#define __ZNET_H__
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <net/if.h>
#include <sys/ioctl.h>
#include <ifaddrs.h>
 
#define	IFI_NAME	16			/* same as IFNAMSIZ in <net/if.h> */
#define	IFI_HADDR	 8			/* allow for 64-bit EUI-64 in future */
 
struct ifi_info {
  char    ifi_name[IFI_NAME];	/* interface name, null-terminated */
  short   ifi_index;			/* interface index */
  short   ifi_flags;			/* IFF_xxx constants from <net/if.h> */
  struct sockaddr  *ifi_addr;	/* primary address */
  struct sockaddr  *ifi_brdaddr;/* broadcast address */
  struct ifi_info  *ifi_next;	/* next of these structures */
};
 
struct ifi_info* get_ifi_info(int, int);
void free_ifi_info(struct ifi_info *);
 
#endif

#include "znet.h"
 
struct ifi_info* get_ifi_info(int family, int doaliases) {
	struct ifi_info		*ifi, *ifihead, **ifipnext,*p;
	struct sockaddr_in	*sinptr;
	struct sockaddr_in6	*sin6ptr;
	struct ifaddrs *ifas;
//	char addr[128];
	int sockfd;
 
	ifihead = NULL;
	ifipnext = &ifihead;
 
	if(getifaddrs(&ifas)!=0)
		return ;
 
	for(;ifas!=NULL;ifas=(*ifas).ifa_next) {	
		if (((*ifas).ifa_addr)->sa_family != family)
			continue;	// ignore if not desired address family
/*
		printf("%s %d\n",(*ifas).ifa_name,((*ifas).ifa_addr)->sa_family);
		if(((*ifas).ifa_addr)->sa_family!=AF_INET6)
			inet_ntop(AF_INET,&(((struct sockaddr_in *)((*ifas).ifa_addr))->sin_addr),addr,sizeof(addr));
		else
			inet_ntop(AF_INET6,&(((struct sockaddr_in6 *)((*ifas).ifa_addr))->sin6_addr),addr,sizeof(addr));
		printf("%s\t",addr);
		printf("\n");
*/		
		ifi = (struct ifi_info*)calloc(1,sizeof(struct ifi_info));
		*ifipnext = ifi;			
		ifipnext = &ifi->ifi_next;	
 
		ifi->ifi_flags = (*ifas).ifa_flags;
		memcpy(ifi->ifi_name, (*ifas).ifa_name, IFI_NAME);
		ifi->ifi_name[IFI_NAME-1] = '\0';
 
		switch (((*ifas).ifa_addr)->sa_family) {
			case AF_INET: 
				sinptr = (struct sockaddr_in *) (*ifas).ifa_addr;
				ifi->ifi_addr = (struct sockaddr*)calloc(1, sizeof(struct sockaddr_in));
				memcpy(ifi->ifi_addr, sinptr, sizeof(struct sockaddr_in));			
#ifdef	SIOCGIFBRDADDR
				if (ifi->ifi_flags & IFF_BROADCAST) {
					sinptr = (struct sockaddr_in *) (*ifas).ifa_broadaddr;
					ifi->ifi_brdaddr = (struct sockaddr*)calloc(1, sizeof(struct sockaddr_in));
					memcpy(ifi->ifi_brdaddr, sinptr, sizeof(struct sockaddr_in));
				}
#endif
				break; 
 
			case AF_INET6: 
				sin6ptr = (struct sockaddr_in6 *) (*ifas).ifa_addr;
				ifi->ifi_addr = (struct sockaddr*)calloc(1, sizeof(struct sockaddr_in6));
				memcpy(ifi->ifi_addr, sin6ptr, sizeof(struct sockaddr_in6));
				break; 
 
			default:
				break;
		}
	}
	freeifaddrs(ifas);	
 
	return(ifihead);	
}
 
int main(int argc, char *argv[]) {
	int family;
	if (argc!=2) {
	    printf("usage: ./znet <inet4 | inet 6>\n");
	    exit(1);
	}
	if (strcmp(argv[1], "inet4") == 0)
		family = AF_INET;
	else if (strcmp(argv[1], "inet6") == 0)
		family =AF_INET6;
	else {
    printf("invalid <address-family>\n");
    exit(1);
    	}
 
	char addr[128];
	struct ifi_info	*ifi, *ifihead;
	printf("name\tflag\tIP\t\tbroadcastaddr\n");
	for (ifihead = ifi = get_ifi_info(family,1); ifi != NULL; ifi = ifi->ifi_next) {
 
		printf("%s\t",ifi->ifi_name); 
		printf("%d\t",ifi->ifi_flags);
		if((ifi->ifi_addr)->sa_family!=AF_INET6)
			inet_ntop(AF_INET,&(((struct sockaddr_in *)(ifi->ifi_addr))->sin_addr),addr,sizeof(addr));
		else
			inet_ntop(AF_INET6,&(((struct sockaddr_in6 *)(ifi->ifi_addr))->sin6_addr),addr,sizeof(addr));
		printf("%s\t",addr);
#ifdef	SIOCGIFBRDADDR
		if ((ifi->ifi_flags & IFF_BROADCAST) && (ifi->ifi_addr)->sa_family!=AF_INET6) {
			inet_ntop(AF_INET,&(((struct sockaddr_in *) (ifi->ifi_brdaddr))->sin_addr),addr,sizeof(addr));
			printf("%s\t",addr);
		}
#endif			
		printf("\n+++++++++++++++++++++++++++++++++++++++++++\n");
	}
	return 0;
}