#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
int main()
{
	char ip[] = "192.168.1.1/24";
	uint8_t *ipPrint = NULL;
	uint32_t ipAddr;
	uint32_t *ipPtr = &ipAddr;
	uint32_t mask = 0;
	uint32_t value = 0;
	uint32_t i = 0, j = 0;
	uint8_t *ptr = NULL;
	struct in_addr in;
	ptr = strtok(ip, "/");
	inet_aton(ptr, (struct in_addr *)ipPtr);
 
	ptr = strtok(NULL, "/");
	value = atoi(ptr);
 
	for(i = 0; i<value; i++)
	{
		j = value-i-1;
		mask |= 1<<j;
	}
	printf("%.8x\n%.8x\n",ipAddr,mask);
	in.s_addr = ipAddr;
	ipPrint = inet_ntoa(in);
	printf("%s\n",ipPrint);
	in.s_addr = mask;
	ipPrint = inet_ntoa(in);
	printf("%s\n",ipPrint);
	return 0;
}

#ifndef _ZHASH_H_
#define _ZHASH_H_
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
#define MAXHASHSIZE	16	
#define ETH_ALEN	6
typedef struct _hashentry
{
    void *key;
    void *ipaddr;
    void *mac;
    struct _hashentry *next;
}hashentry;
 
typedef struct _hashtable
{
    unsigned int (*gethash)(void *);
    int (*compare)(void *,void *);
    int hashsize;
    int count;
    hashentry **hashlist;
}hashtable;
typedef enum bool_t {
    FALSE = 0,
    TRUE
}bool;
hashtable *hash_create_t(unsigned int (*keyfunc)(void *),
		       int (*comparefunc)(void *,void *),
	  	       int size);
void hash_insert(void *key, void *ipaddr, void *mac, hashtable *tab);
unsigned int lh_strhash(void *src);
int equal_str(void *k1, void *k2);
void hash_print(hashtable *tab);
//void help();
#define hash_create(size)	hash_create_t(lh_strhash,equal_str,size) 
#define hashindex(key, tab)	((tab->gethash)(key)) % (tab->hashsize)
#endif

#include "zhash.h"
 
unsigned int lh_strhash(void * src)
{
    int i, l;
    unsigned long ret = 0;
    unsigned short *s;
    char *str = (char *)src;
    if (str == NULL)
	return(0);
    l = (strlen(str) + 1) / 2;
    s = (unsigned short *)str;
 
    for (i = 0; i < l; i++)
	ret ^= s[i]<<(i&0x0f);
    return(ret);
}
 
int equal_str(void *k1, void *k2)
{
    return (0 == strcmp((char *)k1, (char *)k2));
}
hashentry *hlist_new(void *key, void *ipaddr, void *mac)
{
    hashentry *new = (hashentry *)malloc(sizeof(hashentry));
 
    new->key = key; 
    new->ipaddr = ipaddr;
    new->mac = mac;
    new->next = NULL;
    return new;
}
 
void hlist_append(hashentry **root, void *key, void *ipaddr, void *mac)
{
    hashentry *new, *pos;
    new = hlist_new(key, ipaddr, mac);
    if(*root == NULL)
    {
	*root = new;
    }
    else
    {
	pos = *root;
	while(pos->next != NULL)
	    pos = pos->next;
	pos->next = new;
    }
}
bool hlist_update(hashentry *root, void *key,void *ipaddr,void *mac,int (*compare)(void *,void *))
{
    hashentry *pos;
    for(pos = root; pos != NULL; pos = pos->next)
    {
	if(compare(key,pos->key))
	{
//	    free(pos->ipaddr);
//	    free(pos->mac);
	    pos->ipaddr = ipaddr;
	    pos->mac = mac;
//	    free(key);
	    return TRUE;
	}
    }
    return FALSE;
}
 
void hash_insert(void *key, void *ipaddr, void *mac, hashtable *tab)
{
    unsigned int index = hashindex(key, tab);
    hashentry *root = tab->hashlist[index];
    if(!(hlist_update(root, key, ipaddr, mac, tab->compare)))
    {
	hlist_append(&tab->hashlist[index],key,ipaddr, mac);
	tab->count++;
    }
}
 
hashtable *hash_create_t(unsigned int (*keyfunc)(void *),
			int (*comparefunc)(void *,void *),
			int size)
{
    int i;
    int len = sizeof(hashentry *) * size;
    hashtable *tab = (hashtable *)malloc(sizeof(hashtable));
    memset (tab, 0, sizeof(hashtable *));
 
    tab->hashlist = (hashentry**)malloc(len);
    if(tab->hashlist == NULL)
    {
	free(tab);
	return NULL;
    }
    memset(tab->hashlist,0,len);
 
    for(i = 0; i<size; i++)
    {
	tab->hashlist[i] = NULL;
    }
    tab->gethash = keyfunc;
    tab->compare = comparefunc;
    tab->hashsize = size;
    tab->count = 0;
 
    return tab;
}
 
void hash_print(hashtable *tab)
{
    int i;
    int *p;
    hashentry *temp;
    printf("index\t%-20s\t%-20s\n","mac","ipaddr");
    for(i = 0; i < MAXHASHSIZE; i++)
    {
	temp = tab->hashlist[i];
	if(temp == NULL)
	    printf("%-d\t%-20s\t%-20s\n",i,"NULL","NULL");
	else
	    printf("%d\t",i);
	while(temp != NULL)
	{
	    p = (int *)(temp->mac);
	    printf("%.2x:%.2x:%.2x:%.2x:%.2x:%.2x\t",p[0],p[1],p[2],p[3],p[4],p[5]);
	    p = (int *)(temp->ipaddr);
	    const char *format = (temp->next == NULL)?("%d.%d.%d.%d\n"):("%d.%d.%d.%d -->\n\t");
	    printf(format,p[0],p[1],p[2],p[3]);
	    temp = temp->next;
	}
    }
}
/*
void help()
{
    printf("command: \n");
    printf("  -insert\n");
    printf("\t--usage: insert mac ipaddr  eg. insert 00:11:22:33:44:55 192.168.0.1\n");
    printf("\t--description: insert mac,ip to hash table,mac divided by \":\",and ip by \".\"\n");
    printf("  -del\n");
    printf("\t--usage:del key  eg.del 4455\n");
    printf("\t--description: delete from hash table,key is the last 16 bits of mac\n");
    printf("  -print\n");
    printf("\t--usage: print\n");
    printf("\t--description: print all over the hash table\n");
}*/

#include "zhash.h"
 
int main(int argc, char **argv)
{
    hashtable *tab = hash_create(MAXHASHSIZE);
    unsigned int mac[ETH_ALEN]={0x00,0x68,0x30,0x3b,0x2a,0x56};
    unsigned int ipaddr[4]={0xC0,0xA8,0x01,0x01};
    unsigned int mac1[ETH_ALEN]={0x00,0x69,0x30,0x3b,0x2a,0x42};
    unsigned int ipaddr1[4]={0xC0,0xA8,0x01,0x02};
    char key[5];
//    char key1[5];
    memset(key,0,5);
//    memset(key1,0,5);
    sprintf(key,"%.2x%.2x",mac[4],mac[5]);
    hash_insert((void *)key,(void *)ipaddr,(void *)mac,tab);
    sprintf(key,"%.2x%.2x",mac1[4],mac1[5]);
    hash_insert((void *)key,(void *)ipaddr1,(void *)mac1,tab);
    hash_print(tab);
    return 0;
}

CC = gcc
CFLAGS = -Wall -g 
TARGET = zhash
SOURCE = \
zhash.c \
test.c
OBJS = $(SOURCE:%.c=%.o)
 
%.o:%.c
	$(CC) $(CFLAGS) -c $< -o $@
 
$(TARGET):$(OBJS)
	$(CC) $(OBJS) -o $@ 
 
clean:
	@echo "cleanning object..."
	-rm zhash *.o
	@echo "clean finished!"
.PHONY:clean

 
#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;
}