1129 » C http://www.vi1129.com 学无止境 我心飞翔 Mon, 05 Jul 2010 15:30:18 +0000 http://wordpress.org/?v=2.8.6 en hourly 1 C hash table code http://www.vi1129.com/2010/04/c-hash-table-code/ http://www.vi1129.com/2010/04/c-hash-table-code/#comments Fri, 16 Apr 2010 08:25:43 +0000 keykey http://www.vi1129.com/?p=680 This code modified from internet,insert IP and MAC to hashtable. Key is the last 16bit of MAC.

too busy without search and delete function, you can add them if your interested.

?Download zhash.h1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 #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;

继续阅读

关联文章:
  1. 使用setitimer和signal创建一个计时器
  2. 使用原始套接字SOCK_RAW捕捉网络数据包并简单分析
  3. 自写一则单链表小程序
]]> This code modified from internet,insert IP and MAC to hashtable. Key is the last 16bit of MAC.

too busy without search and delete function, you can add them if your interested.

?Download zhash.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

#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
?Download zhash.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

#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");
}*/
?Download test.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

#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;
}
?Download makefile
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

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

关联文章:

  1. 使用setitimer和signal创建一个计时器
  2. 使用原始套接字SOCK_RAW捕捉网络数据包并简单分析
  3. 自写一则单链表小程序

]]> http://www.vi1129.com/2010/04/c-hash-table-code/feed/ 4 使用原始套接字SOCK_RAW捕捉网络数据包并简单分析 http://www.vi1129.com/2010/03/sock_raw-dump/ http://www.vi1129.com/2010/03/sock_raw-dump/#comments Fri, 05 Mar 2010 04:44:32 +0000 keykey http://www.vi1129.com/?p=663 协议的分析需要参考前一篇文章以太网帧格式，IP包头，TCP头格式说明。

抓取网络上的数据包需要设置网卡为混杂模式，调用recvfrom在创建的SOCK_RAW类型的socket上接收来自kernel的信息，然后再按照帧格式，IP头，TCP头格式，指针移动到相应位置并分析。

附上的小程序由于其他原因还在UDP9001端口监听了来自客户端的消息，这与本文无关。

?Download zhao_sock.h1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30   #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

继续阅读

关联文章:
  1. C hash table code
  2. 自写一则单链表小程序
  3. 使用setitimer和signal创建一个计时器
]]> 协议的分析需要参考前一篇文章以太网帧格式，IP包头，TCP头格式说明。

抓取网络上的数据包需要设置网卡为混杂模式，调用recvfrom在创建的SOCK_RAW类型的socket上接收来自kernel的信息，然后再按照帧格式，IP头，TCP头格式，指针移动到相应位置并分析。

附上的小程序由于其他原因还在UDP9001端口监听了来自客户端的消息，这与本文无关。

?Download zhao_sock.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

 
#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();
?Download zhao_sock.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

#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);
}
?Download zhao_sock_send.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

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

关联文章:

  1. C hash table code
  2. 自写一则单链表小程序
  3. 使用setitimer和signal创建一个计时器

]]> http://www.vi1129.com/2010/03/sock_raw-dump/feed/ 1 自写一则单链表小程序 http://www.vi1129.com/2010/02/node/ http://www.vi1129.com/2010/02/node/#comments Mon, 22 Feb 2010 10:22:17 +0000 keykey http://www.vi1129.com/?p=639 发现很多公司面试都喜欢考链表，实际项目中尽管需要自己写链表的时候比较少，但还是会经常用到，链表是一种常用的数据结构。有必要整理一下自己的思路，索性写了一个。包括了链表的初始化，插入，删除，查找，销毁，打印等基本功能，当然考虑了头尾中间等位置情况。仓促完成的简单代码，bug比较多，链表中只存储了一个整形的变量，没有做数据类型的判断，有时候会段错误也难免。已知的一个问题就是创建的链表在有销毁前如果再创建一个的话，会造成内存泄露，因为之前的链表没有销毁头指针便指向了新的位置，旧链表就永远找不到哦。这些问题留在以后实际用到的时候再考虑吧，应付面试这个足矣！

?Download node.c1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 #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

继续阅读

关联文章:
  1. 使用原始套接字SOCK_RAW捕捉网络数据包并简单分析
  2. ioctl及getifaddrs读取IPv4,IPv6网卡信息
  3. C hash table code
]]> 发现很多公司面试都喜欢考链表，实际项目中尽管需要自己写链表的时候比较少，但还是会经常用到，链表是一种常用的数据结构。有必要整理一下自己的思路，索性写了一个。包括了链表的初始化，插入，删除，查找，销毁，打印等基本功能，当然考虑了头尾中间等位置情况。仓促完成的简单代码，bug比较多，链表中只存储了一个整形的变量，没有做数据类型的判断，有时候会段错误也难免。已知的一个问题就是创建的链表在有销毁前如果再创建一个的话，会造成内存泄露，因为之前的链表没有销毁头指针便指向了新的位置，旧链表就永远找不到哦。这些问题留在以后实际用到的时候再考虑吧，应付面试这个足矣！

?Download node.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172

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

关联文章:

  1. 使用原始套接字SOCK_RAW捕捉网络数据包并简单分析
  2. ioctl及getifaddrs读取IPv4,IPv6网卡信息
  3. C hash table code

]]> http://www.vi1129.com/2010/02/node/feed/ 1 ioctl及getifaddrs读取IPv4,IPv6网卡信息 http://www.vi1129.com/2010/01/ioctl-getifaddrs-ipv46/ http://www.vi1129.com/2010/01/ioctl-getifaddrs-ipv46/#comments Wed, 20 Jan 2010 09:14:30 +0000 keykey http://www.vi1129.com/?p=617 使用ioctl的SIOCGIFCONF可以读取所有网卡信息。ioctl调用后返回指向ifconf的结构链表，其中包含了指向ifreq的结构指针。ifconf及ifreq定义在net/if.h中。

《UNIX网络编程》中提供了get_ifi_info函数的实现方法，使用这种方式来获取网络信息。在LINUX下，这种方式不能获得IPV6的网卡信息。《UNIX网络编程》中有如下描述：

在支持IPV6的系统中，没有关于对SIOCGIFCONF请求是否返回IPV6地址的标准。我们给支持IPV6的新系统增加了一个case语句， 这是为了预防万一。问题在于ifreq中的联合把返回的地址定义成一个通用的16字节套接口地址结构，适合16字节的IPV4 socket_in结构，但对于24字节的IPV6 socket_in6结构太小了。如果返回IPV6地址，将可能破环现有的在每个ifreq结构中采用固定大小的套接口地址结构的代码。

经测试，在fedor6-2.6.18kernel中无法返回ipv6地址，事实上，返回的地址簇总是AF_INET,而并非AF_INET6。 这种方法的实现代码如下： net_if.h

?View Code C1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 #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

继续阅读

关联文章:
  1. 使用原始套接字SOCK_RAW捕捉网络数据包并简单分析
  2. 自写一则单链表小程序
  3. 一种IP改变唤醒SNMP TRAP的实现源码
]]> 使用ioctl的SIOCGIFCONF可以读取所有网卡信息。ioctl调用后返回指向ifconf的结构链表，其中包含了指向ifreq的结构指针。ifconf及ifreq定义在net/if.h中。

《UNIX网络编程》中提供了get_ifi_info函数的实现方法，使用这种方式来获取网络信息。在LINUX下，这种方式不能获得IPV6的网卡信息。《UNIX网络编程》中有如下描述：

在支持IPV6的系统中，没有关于对SIOCGIFCONF请求是否返回IPV6地址的标准。我们给支持IPV6的新系统增加了一个case语句， 这是为了预防万一。问题在于ifreq中的联合把返回的地址定义成一个通用的16字节套接口地址结构，适合16字节的IPV4 socket_in结构，但对于24字节的IPV6 socket_in6结构太小了。如果返回IPV6地址，将可能破环现有的在每个ifreq结构中采用固定大小的套接口地址结构的代码。

经测试，在fedor6-2.6.18kernel中无法返回ipv6地址，事实上，返回的地址簇总是AF_INET,而并非AF_INET6。
这种方法的实现代码如下：

net_if.h

?View Code C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

#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

net_if.c

?View Code C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263

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

使用gcc net_if.c -o net_if -DIPV6编译，在IPV4模式下运行输出为：

[root@localhost net_if]./net_if inet4 1
lo:
IP addr: 127.0.0.1
eth1:
IP addr: 192.168.1.2
broadcast addr: 192.168.1.255
eth0:
IP addr: 192.168.125.99
broadcast addr: 192.168.125.255

执行./net_if inet6 1在输出为空。

第二种方式是使用getifaddrs函数获取，需要包含ifaddrs.h头文件，这种方式可以获得IPV6地址，改写的《UNIX网络编程》中的get_ifi_info函数如下所示：

znet.h

?View Code C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#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

znet.c

?View Code C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

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

这段代码输出如下：

[root@localhost net_if]./znet inet4
name flag IP broadcastaddr
lo 73 127.0.0.1
++++++++++++++++++++++++++++++
eth1 4099 192.168.1.2 192.168.1.255
++++++++++++++++++++++++++++++
eth0 4163 192.168.125.99 192.168.125.255
++++++++++++++++++++++++++++++
[root@localhost net_if]./znet inet6
name flag IP broadcastaddr
lo 73 ::1
++++++++++++++++++++++++++++++
eth1 4163 2001:250:1800:1::1
++++++++++++++++++++++++++++++
eth0 4163 2001:250:1888:1::1
++++++++++++++++++++++++++++++

关联文章:

  1. 使用原始套接字SOCK_RAW捕捉网络数据包并简单分析
  2. 自写一则单链表小程序
  3. 一种IP改变唤醒SNMP TRAP的实现源码

]]> http://www.vi1129.com/2010/01/ioctl-getifaddrs-ipv46/feed/ 0 关于const与指针搭配使用的一点记录 http://www.vi1129.com/2010/01/const-ptr/ http://www.vi1129.com/2010/01/const-ptr/#comments Sat, 09 Jan 2010 05:26:22 +0000 keykey http://www.vi1129.com/?p=601 const限定符指定了一个变量为只读变量，是不允许被改变的，因此const变量在定义时就必须初始化。 const在与指针搭配时，使用将变的复杂和微妙。简单的说const搭配指针就会出现以下三种情况：

指向const变量(对象)的指针 const指针 指向const变量(对象)的const指针

1.指向const变量(对象)的指针 指针指向了const变量，例如 const int *ptr或者int const *ptr，这两种写法含义一样，这表示const限定了ptr所指向的数据类型，而并非ptr本身。即ptr本身并不是const.可以对ptr重新赋值，无需在定义时初始化。 指向const变量的指针可以指向一个const变量，也可以指向一个非const变量，当然指针类型与变量类型要一致。不管指向了一个const变量还是非const变量，任何企图通过这个指针去修改变量的值都会导致编译错误。同时，const变量只能赋给指向const变量的指针，赋给一个普通变量也是不允许的。 如（代码仅供理解const,不要刻意追求是否正确可执行）：

const int *ptr; int *ptr_1; const int a=12; const int b=13; int c=14; ptr=&a;/*指向const变量*/ ptr=&b;/*重新赋值指向const变量*/ *ptr=20;/*error,不能通过ptr修改*/ ptr=&c;/*重新赋值指向非const变量*/ ptr_1=&c;/*普通指针指向普通变量*/ ptr_1=&a;/*error，普通指针不能指向const变量*/

《C++ Primer》中对此有详细的解释，尽管不能通过指向const对象的指针去修改基础对象，然而如果该指针指向的是一个非const对象，可以用其他方法修改所指的对象。如下的例子：

const int *ptr; int *ptr_1; int c=14; ptr=&c; printf(”c=%d\n”,*ptr); ptr_1=&c; *ptr_1=18/*通过非指向const的指针修改*/ printf(”c=%d\n”,*ptr);

输出结果可以看到两次输出是不一样的。对此，《C++ Primer》中说，如果把指向const的指针理解为“自以为指向const的指针”，这可能会对理解有所帮助。

2.const指针

int a=12; int *const ptr=&a

这意味着ptr这个指针被定义成const变量，必须在定义时初始化，并不能重新对ptr赋值，即不能将ptr再指向其他变量。但是，*ptr=13，这样的操作完全取决与a是不是一个const变量，在这个例子中不是，所以*ptr=13是正确的，假如a这样定义，const int a=12,*ptr=13会导致错误。

3.指向const变量(对象)的const指针

const int a=12; const int *const ptr=&a;

这就意味着ptr不能被重新赋值，因为它是const指针，定义时需初始化；同时不能通过ptr修改a，因为a也是const变量。

4.有趣的typedef

typedef string *pstring; const pstring cstr;

这时，cstr是一个指向string类型的const指针，而不是一个指向const string的普通指针。因为const pstring cstr;,const修饰的是pstring这个类型，而这个类型是一个string指针。其实：

string s; typedef string *pstring; /*以下三个定义相同，都是指向string的const指针*/ const pstring cstr1=&a; pstring const cstr2=&a; string *const cstr3=&a;

5.记忆方法 记忆方法其实很简单，只需看清const和*的位置就可以，const在前，则是指向const变量的指针，如：

const int *ptr;int const *ptr;

*在前，则是const指针，如：

int *const ptr;

两个const，则是指向const的const指针了，如：

const int *const ptr;

关联文章:strftime和strptime使用 C

继续阅读

关联文章:
  1. strftime和strptime使用
  2. C hash table code
  3. MD5应用的一点理解及Linux实现源码
]]> const限定符指定了一个变量为只读变量，是不允许被改变的，因此const变量在定义时就必须初始化。
const在与指针搭配时，使用将变的复杂和微妙。简单的说const搭配指针就会出现以下三种情况：

  • 指向const变量(对象)的指针
  • const指针
  • 指向const变量(对象)的const指针

1.指向const变量(对象)的指针
指针指向了const变量，例如 const int *ptr或者int const *ptr，这两种写法含义一样，这表示const限定了ptr所指向的数据类型，而并非ptr本身。即ptr本身并不是const.可以对ptr重新赋值，无需在定义时初始化。
指向const变量的指针可以指向一个const变量，也可以指向一个非const变量，当然指针类型与变量类型要一致。不管指向了一个const变量还是非const变量，任何企图通过这个指针去修改变量的值都会导致编译错误。同时，const变量只能赋给指向const变量的指针，赋给一个普通变量也是不允许的。
如（代码仅供理解const,不要刻意追求是否正确可执行）：

const int *ptr;
int *ptr_1;
const int a=12;
const int b=13;
int c=14;
ptr=&a;/*指向const变量*/
ptr=&b;/*重新赋值指向const变量*/
*ptr=20;/*error,不能通过ptr修改*/
ptr=&c;/*重新赋值指向非const变量*/
ptr_1=&c;/*普通指针指向普通变量*/
ptr_1=&a;/*error，普通指针不能指向const变量*/

《C++ Primer》中对此有详细的解释，尽管不能通过指向const对象的指针去修改基础对象，然而如果该指针指向的是一个非const对象，可以用其他方法修改所指的对象。如下的例子：

const int *ptr;
int *ptr_1;
int c=14;
ptr=&c;
printf(”c=%d\n”,*ptr);
ptr_1=&c;
*ptr_1=18/*通过非指向const的指针修改*/
printf(”c=%d\n”,*ptr);

输出结果可以看到两次输出是不一样的。对此，《C++ Primer》中说，如果把指向const的指针理解为“自以为指向const的指针”，这可能会对理解有所帮助。

2.const指针

int a=12;
int *const ptr=&a

这意味着ptr这个指针被定义成const变量，必须在定义时初始化，并不能重新对ptr赋值，即不能将ptr再指向其他变量。但是，*ptr=13，这样的操作完全取决与a是不是一个const变量，在这个例子中不是，所以*ptr=13是正确的，假如a这样定义，const int a=12,*ptr=13会导致错误。

3.指向const变量(对象)的const指针

const int a=12;
const int *const ptr=&a;

这就意味着ptr不能被重新赋值，因为它是const指针，定义时需初始化；同时不能通过ptr修改a，因为a也是const变量。

4.有趣的typedef

typedef string *pstring;
const pstring cstr;

这时，cstr是一个指向string类型的const指针，而不是一个指向const string的普通指针。因为const pstring cstr;,const修饰的是pstring这个类型，而这个类型是一个string指针。其实：

string s;
typedef string *pstring;
/*以下三个定义相同，都是指向string的const指针*/
const pstring cstr1=&a;
pstring const cstr2=&a;
string *const cstr3=&a;

5.记忆方法
记忆方法其实很简单，只需看清const和*的位置就可以，const在前，则是指向const变量的指针，如：

const int *ptr;int const *ptr;

*在前，则是const指针，如：

int *const ptr;

两个const，则是指向const的const指针了，如：

const int *const ptr;

关联文章:

  1. strftime和strptime使用
  2. C hash table code
  3. MD5应用的一点理解及Linux实现源码

]]> http://www.vi1129.com/2010/01/const-ptr/feed/ 6 Linux多线程(1) http://www.vi1129.com/2010/01/mutithread-1/ http://www.vi1129.com/2010/01/mutithread-1/#comments Mon, 04 Jan 2010 07:41:45 +0000 keykey http://www.vi1129.com/?p=588 学习参考《linux高级程序设计卷一》

GNU/Linux 实现了 POSIX 标准线程 API。所有线程函数和数据类型都在<pthread.h>头文件中声明。这些线程相关的函数没有被包含在 C 标准库中，而是在libpthread 中，所以当链接程序的时候需在命令行中加入 -lpthread 以确保能正确链接。

1.创建线程

创建线程使用pthread_create函数，函数原型：

int pthread_create(pthread_t *thread,const pthread_attr_t *attr,void *(*start_routine)(void *),void *arg)

参数解释: a.一个指向pthread_t 类型变量的指针，新线程的线程 ID 将存储在这里。 b.一个指向线程属性（thread attribute）对象的指针，这个对象控制着新线程与程序其它部分交互的具体细节。如果传递NULL 作为线程属性，新线程将被赋予一组默认线程属性。 c.一个指向线程函数的指针。这是一个普通的函数指针，类型如下：void* (*) (void*)。 d.一个线程参数，类型void*，不论你传递什么值作为这个参数，当线程开始执行的时候，它都会被直接传递给新的线程。

函数 pthread_create 会在调用后立刻返回，原线程会继续执行之后的指令。同时，新线程开始执行线程函数。Linux 异步调度这两个线程，因此你的程序不能依赖两个线程得到执行的特定先后顺序。

1.1线程参数传递

pthread_create的第四个参数为第三个参数（线程将要执行的函数）的参数，通常的做法是给线程函数定义一个结构以包含线程函数所期待的实际参数序列，给线程函数定义一个结构以包含线程函数所期待的实际参数序列。

1.2等待线程

因为线程共享了主线程的数据，尤其是当给线程传递了参数时，主线程必须等待线程执行完成后才可以退出，严格的说主线程必须在线程执行完成之前确保参数的完整，因为通常这些参数是在主线程中定义的。这类似于局部变量（当生命期结束的时候自动释放）和堆上分配的对象（通过free或者C++的delete手工释放）。务必确保这个变量不会被释放（甚至在其它线程中也不行！），直到你确定这个线程不会再使用它。 使用pthread_join(pthread_t thread,void **retval)，强制主线程等待线程退出。

一个例子–主线程创建两个线程，一个输出x，另一个输出o。

?View Code C1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 #include <stdio.h> #include <pthread.h>   /* print_function 的参数 */ struct char_print_parms { /* 用于输出的字符 */ char character; /* 输出的次数 */ int count; }; /* 按照 PARAMETERS 提供的数据，输出一定数量的字符到stderr。 PARAMETERS 是一个指向 struct char_print_parms 的指针 */ void* char_print (void* parameters) { /*

继续阅读

关联文章:
  1. C hash table code
  2. 使用原始套接字SOCK_RAW捕捉网络数据包并简单分析
  3. MD5应用的一点理解及Linux实现源码
]]> 学习参考《linux高级程序设计卷一》

GNU/Linux 实现了 POSIX 标准线程 API。所有线程函数和数据类型都在<pthread.h>头文件中声明。这些线程相关的函数没有被包含在 C 标准库中，而是在libpthread 中，所以当链接程序的时候需在命令行中加入 -lpthread 以确保能正确链接。

1.创建线程

创建线程使用pthread_create函数，函数原型：

int pthread_create(pthread_t *thread,const pthread_attr_t *attr,void *(*start_routine)(void *),void *arg)

参数解释:
a.一个指向pthread_t 类型变量的指针，新线程的线程 ID 将存储在这里。
b.一个指向线程属性（thread attribute）对象的指针，这个对象控制着新线程与程序其它部分交互的具体细节。如果传递NULL 作为线程属性，新线程将被赋予一组默认线程属性。
c.一个指向线程函数的指针。这是一个普通的函数指针，类型如下：void* (*) (void*)。
d.一个线程参数，类型void*，不论你传递什么值作为这个参数，当线程开始执行的时候，它都会被直接传递给新的线程。

函数 pthread_create 会在调用后立刻返回，原线程会继续执行之后的指令。同时，新线程开始执行线程函数。Linux 异步调度这两个线程，因此你的程序不能依赖两个线程得到执行的特定先后顺序。

1.1线程参数传递

pthread_create的第四个参数为第三个参数（线程将要执行的函数）的参数，通常的做法是给线程函数定义一个结构以包含线程函数所期待的实际参数序列，给线程函数定义一个结构以包含线程函数所期待的实际参数序列。

1.2等待线程

因为线程共享了主线程的数据，尤其是当给线程传递了参数时，主线程必须等待线程执行完成后才可以退出，严格的说主线程必须在线程执行完成之前确保参数的完整，因为通常这些参数是在主线程中定义的。这类似于局部变量（当生命期结束的时候自动释放）和堆上分配的对象（通过free或者C++的delete手工释放）。务必确保这个变量不会被释放（甚至在其它线程中也不行！），直到你确定这个线程不会再使用它。
使用pthread_join(pthread_t thread,void **retval)，强制主线程等待线程退出。

一个例子–主线程创建两个线程，一个输出x，另一个输出o。

?View Code C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

#include <stdio.h> 
#include <pthread.h>
 
/* print_function 的参数 */
struct char_print_parms
{
/* 用于输出的字符 */
char character;
/* 输出的次数 */
int count;
};
/* 按照 PARAMETERS 提供的数据，输出一定数量的字符到stderr。
PARAMETERS 是一个指向 struct char_print_parms 的指针 */
void* char_print (void* parameters)
{
/* 将参数指针转换为正确的类型 */
struct char_print_parms* p = (struct char_print_parms*) parameters;
int i;
for (i = 0; i &lt; p-&gt;count; ++i)
fputc (p-&gt;character, stderr);
return NULL;
}
/* 主程序 */
 
int main ()
{
pthread_t thread1_id;
pthread_t thread2_id;
struct char_print_parms thread1_args;
struct char_print_parms thread2_args;
/* 创建一个输出 30000 个 x 的线程 */
hread1_args.character = 'x';
thread1_args.count = 30000;
prhread_create (&amp;thread1_id, NULL, &amp;char_print, &amp;thread1_args);
 
/* 创建一个输出 20000 个 o 的线程 */
thread2_args.character = 'o';
thread2_args.count = 20000;
pthread_create (&amp;thread2_id, NULL, &amp;char_print, &amp;thread2_args);
/* 确保第一个线程结束 */
pthread_join (thread1_id, NULL);
/* 确保第二个线程结束 */
pthread_join (thread2_id, NULL);
/* 现在我们可以安全地返回 */
return 0;
}

1.3 线程取消

在一个线程中以另一个线程ID作为参数调用pthread_cancel可以取消另一个线程。但是，线程可能运行在一段不可分割的代码中，必须全部得到执行或者干脆不执行。例如，线程可能分配一些资源，使用并稍后释放它们。如果线程在中途被取消，它可能没有机会释放那些被分配的资源，从而导致资源的泄漏。为防止这种情况发生，一个线程可以控制自身是否可以被取消，以及何时允许取消操作。

线程可以调用pthread_setcancelstate和pthread_setcanceltype来决定自身是否允许被其他线程取消，及取消方式（PTHREAD_CANCEL_DEFERRED和PTHREAD_CANCEL_ASYNCHRONOUS）。

关联文章:

  1. C hash table code
  2. 使用原始套接字SOCK_RAW捕捉网络数据包并简单分析
  3. MD5应用的一点理解及Linux实现源码

]]> http://www.vi1129.com/2010/01/mutithread-1/feed/ 1 带有#和##符号的函数式宏展开步骤 http://www.vi1129.com/2009/12/macro-expand/ http://www.vi1129.com/2009/12/macro-expand/#comments Mon, 21 Dec 2009 04:47:59 +0000 keykey http://www.vi1129.com/?p=549 在函数式宏定义中，#运算符用于创建字符串，#运算符后面应该跟一个形参（中间可以有空格或Tab），s将被作为一个字符串替换，并且s中的多个空格或tab将被替换为一个空格。 #define STR(s) # s STR(hello world) 预处理后变为”hello world” 。 ##运算符把前后两个预处理Token连接成一个预处理Token，和#运算符不同，##运算符不仅限于函数式宏定义，变量式宏定义也可以用。 先列出一个例子，当然这不是一段可执行的程序，甚至编译不了，只是为了说明宏展开的步骤问题，事实上这样的宏定义很多地方都能见到。

#define _sh(x) p_f(”n”,#x,”=%d, or %d\n”,n##x,alt[x]) #define sh(x) _sh(x) #define NA 26 _sh(NA) sh(NA)

可能发现第二行的定义有些多余，但结果却是截然不同的。 使用cpp命令做一下预处理就可以看到_sh(NA)和sh(NA)展开的不同，以下为展开结果。

p_f(”n”,”NA”,”=%d, or %d\n”,nNA,alt[26]) p_f(”n”,”26″,”=%d, or %d\n”,n26,alt[26])

下边分别说一下_sh(NA)和sh(NA)的展开步骤

_sh(NA)展开的步骤如下： 1.#x要替换成”NA”。 2.n##x要替换成nNA。 3.除了带#和##运算符的参数之外，其它参数在替换之前要对实参本身做充分的展开，所以应该先把NA展开成26再替换到alt[x]中x的位置。换言之，带有#和##的不会再进行二次替换。 4.现在展开成了p_f(”n” “NA” “=%d, or %d\n”,nNA,alt[26])，所有参数都替换完了，这时编译器会再扫描一遍，再找出可以展开的宏定义来展开，假设NA或alt是变量式宏定义，这时会进一步展开,但经#或##替换的除外，所以”NA”并没有成为”26“，nNA也没有被替换为n26。

sh(NA)展开的步骤如下： 1.用_sh(NA)替换sh(NA),并扫描，发现NA可以再展开，展开为_sh(26) 2. 展开_sh(26)为p_f(”n”,”26″,”=%d, or %d\n”,n26,alt[26])

所以，当期望宏替换为变量式宏的值而不是这个宏名，并且有#或者##在使用时，就要格外注意了，需要再加一条看似废话的宏定义。

另外，关于带有可变参数的函数在宏定义时，除了可以使用__VA_ARGS__来替代可变参数外，也可以使用##来连接。如下的两个宏定义是类似的

#define vprint(fmt, …) log_z(__FILE__,__LINE__,fmt,__VA_ARGS__) #define vprint(fmt,args…) log_z(__FILE__,__LINE__,fmt,## args)

这个宏常用在日志函数中，调用vprint函数就加入了文件名和行号，方便debug,也可以加入__DATE__,__TIME__等等预定义变量，log_z函数实现如下

void log_z(char *fn,int ln,const char

继续阅读

关联文章:
  1. 为你的程序增加一个带文件名和行号的打印函数
  2. 使用原始套接字SOCK_RAW捕捉网络数据包并简单分析
  3. C hash table code
]]> 在函数式宏定义中，#运算符用于创建字符串，#运算符后面应该跟一个形参（中间可以有空格或Tab），s将被作为一个字符串替换，并且s中的多个空格或tab将被替换为一个空格。
#define STR(s) # s
STR(hello world)
预处理后变为”hello world” 。
##运算符把前后两个预处理Token连接成一个预处理Token，和#运算符不同，##运算符不仅限于函数式宏定义，变量式宏定义也可以用。
先列出一个例子，当然这不是一段可执行的程序，甚至编译不了，只是为了说明宏展开的步骤问题，事实上这样的宏定义很多地方都能见到。

#define _sh(x) p_f(”n”,#x,”=%d, or %d\n”,n##x,alt[x])
#define sh(x) _sh(x)
#define NA 26
_sh(NA)
sh(NA)

可能发现第二行的定义有些多余，但结果却是截然不同的。
使用cpp命令做一下预处理就可以看到_sh(NA)和sh(NA)展开的不同，以下为展开结果。

p_f(”n”,”NA”,”=%d, or %d\n”,nNA,alt[26])
p_f(”n”,”26″,”=%d, or %d\n”,n26,alt[26])

下边分别说一下_sh(NA)和sh(NA)的展开步骤

_sh(NA)展开的步骤如下：
1.#x要替换成”NA”。
2.n##x要替换成nNA。
3.除了带#和##运算符的参数之外，其它参数在替换之前要对实参本身做充分的展开，所以应该先把NA展开成26再替换到alt[x]中x的位置。换言之，带有#和##的不会再进行二次替换。
4.现在展开成了p_f(”n” “NA” “=%d, or %d\n”,nNA,alt[26])，所有参数都替换完了，这时编译器会再扫描一遍，再找出可以展开的宏定义来展开，假设NA或alt是变量式宏定义，这时会进一步展开,但经#或##替换的除外，所以”NA”并没有成为”26“，nNA也没有被替换为n26。

sh(NA)展开的步骤如下：
1.用_sh(NA)替换sh(NA),并扫描，发现NA可以再展开，展开为_sh(26)
2. 展开_sh(26)为p_f(”n”,”26″,”=%d, or %d\n”,n26,alt[26])

所以，当期望宏替换为变量式宏的值而不是这个宏名，并且有#或者##在使用时，就要格外注意了，需要再加一条看似废话的宏定义。

另外，关于带有可变参数的函数在宏定义时，除了可以使用__VA_ARGS__来替代可变参数外，也可以使用##来连接。如下的两个宏定义是类似的

#define vprint(fmt, …) log_z(__FILE__,__LINE__,fmt,__VA_ARGS__)
#define vprint(fmt,args…) log_z(__FILE__,__LINE__,fmt,## args)

这个宏常用在日志函数中，调用vprint函数就加入了文件名和行号，方便debug,也可以加入__DATE__,__TIME__等等预定义变量，log_z函数实现如下

void log_z(char *fn,int ln,const char *fmt, …)
{
va_list ap;
char buf[4096];
va_start(ap,fmt);
vsnprintf(buf,4096,fmt,ap);
printf(”[%s %d]“,fn,ln);
printf(buf);
printf(”\n”);
}

另一个更加简单有效的增加行号的做法是这样定义的

#define vprint(fmt,args…) printf(”[%s %d]“fmt,__FILE__,__LINE__,##args)

关联文章:

  1. 为你的程序增加一个带文件名和行号的打印函数
  2. 使用原始套接字SOCK_RAW捕捉网络数据包并简单分析
  3. C hash table code

]]> http://www.vi1129.com/2009/12/macro-expand/feed/ 1 静态库/动态库的编译和使用方法学习记录 http://www.vi1129.com/2009/12/make-lib/ http://www.vi1129.com/2009/12/make-lib/#comments Tue, 01 Dec 2009 08:49:32 +0000 keykey http://www.vi1129.com/?p=437 本文参考资料：《Linux编程一站式学习》 版权 © 2008, 2009 宋劲杉, 北京亚嵌教育研究中心 部分内容摘自此文

有时候需要把一组代码编译成一个库，这个库在很多项目中都要用到，例如libc就是这样一个库，我们在不同的程序中都会用到libc中的库函数（例如printf），也会用到libc中的变量。 学习中用到的一个简单的小程序，程序将字符a,b,c压入堆栈stack[512],随后再倒序输出，打印出cba。为了使用到的gcc命令更具有意义，特意将程序分开在了几个C文件中，最后将几个.o文件链接为可执行文件。 stack.c

?View Code Cchar stack[512]; int top = -1;

pop.c

?View Code Cextern int top; extern char stack[512]; char pop(void) { return stack[top--]; }

push.c

?View Code Cextern int top; extern char stack[512]; void push(char c) { stack[++top]=c; }

empty.c

?View Code Cextern int top; int is_empty(void) { return top == -1; }

stack.h

?View Code C#ifdef STACK_H #define STACK_H extern void push(char); extern char pop(void); extern int is_empty(void); #endif

main.c

?View Code C#include<stdio.h> #include "stack.h" int main(void) { push('a'); push('b'); push('c'); while(!is_empty()) putchar(pop()); putchar('\n'); return 0; }

整个程序放在/root/ctest/stack下，文件结构如下:

[root@localhost stack]pwd /root/ctest/stack [root@localhost stack]tree . |– main.c `–

继续阅读

关联文章:
  1. C hash table code
  2. 为你的程序增加一个带文件名和行号的打印函数
  3. 递归程序的困扰
]]> 本文参考资料：《Linux编程一站式学习》 版权 © 2008, 2009 宋劲杉, 北京亚嵌教育研究中心
部分内容摘自此文

有时候需要把一组代码编译成一个库，这个库在很多项目中都要用到，例如libc就是这样一个库，我们在不同的程序中都会用到libc中的库函数（例如printf），也会用到libc中的变量。
学习中用到的一个简单的小程序，程序将字符a,b,c压入堆栈stack[512],随后再倒序输出，打印出cba。为了使用到的gcc命令更具有意义，特意将程序分开在了几个C文件中，最后将几个.o文件链接为可执行文件。
stack.c

?View Code C
char stack[512];
int top = -1;

pop.c

?View Code C
extern int top;
extern char stack[512];
char pop(void)
{
return stack[top--];
}

push.c

?View Code C
extern int top;
extern char stack[512];
void push(char c)
{
stack[++top]=c;
}


empty.c

?View Code C
extern int top;
int is_empty(void)
{
return top == -1;
}

stack.h

?View Code C
#ifdef STACK_H
#define STACK_H
extern void push(char);
extern char pop(void);
extern int is_empty(void);
#endif

main.c

?View Code C
#include<stdio.h>
#include "stack.h"
int main(void)
{
push('a');
push('b');
push('c');
while(!is_empty())
putchar(pop());
putchar('\n');
return 0;
}

整个程序放在/root/ctest/stack下，文件结构如下:

[root@localhost stack]pwd
/root/ctest/stack
[root@localhost stack]tree
.
|– main.c
`– stack
|– empty.c
|– pop.c
|– push.c
|– stack.c
|– stack.h

我将除了main.c外的其他文件放入stack目录中，并准备将stack目录下的所有东西打包为库文件，也就是将几个函数打包。

静态库

进入stack目录编译并生成libstack.a文件，再编译main.c，生成可执行文件main:

[root@localhost]pwd
/root/ctest/stack/stack
[root@localhost]gcc -c empty.c pop.c push.c stack.c
[root@localhost]ar rs libstack.a empty.o pop.o push.o stack.o
ar:creating libstack.a
[root@localhost]cd ..
[root@localhost]gcc main.c -Lstack -lstack -Istack -omain
[root@localhost]./main
cba

最后的文件结构就变成了:

[root@localhost stack]pwd
/root/ctest/stack
[root@localhost stack]tree
.
|– main
|– main.c
`– stack
|– empty.c
|– empty.o
|– libstack.a
|– pop.c
|– pop.o
|– push.c
|– push.o
|– stack.c
|– stack.h
|– stack.o

库文件名都是以lib开头的，静态库以.a作为后缀，表示Archive。ar命令类似于tar命令，起一个打包的作用，但是把目标文件打包成静态库只能用ar命令而不能用tar命令。选项r表示将后面的文件列表添加到文件包，如果文件包不存在就创建它，如果文件包中已有同名文件就替换成新的。s是专用于生成静态库的，表示为静态库创建索引，这个索引被链接器使用。
gcc的-L参数指定了库文件的路径，-Lstack就是当前目录下的stack目录了，如果库文件在当前目录，用-L.就好；-lstack指定库文件名，正如刚才所说的库文件都是以lib开头，所以这里的参数库名不要加lib，也不要扩展名.a或.so(动态库)，-Istack，如果你仔细看程序了会发现main.c里的#include “stack.h”，stack.h在stack目录里，所以-Istack就指定了头文件的位置，当然如果这样写#include “stack/stack.h”的话，就不需要-Istack了。
另外，gcc使用-print-search-dirs参数可以查看你的gcc会在哪些目录里去查找库文件，除非你将刚才的libstack.a放在了这些位置，否则-L参数不可少。

动态库

动态库的区别与静态库，简单的说程序在运行时才会去查找库文件，而不是像静态库一样在链接时就将整个库连接到了可执行文件中，所以一般来说，使用动态库的可执行文件要比使用静态库的体积小。
删除刚才产生的库文件，目标文件，可执行文件，只留下源码，执行下边的命令重新生成动态库及可执行文件:

[root@localhost]pwd
/root/ctest/stack
[root@localhost]cd stack
[root@localhost]gcc -c -fPIC *.c
[root@localhost]gcc -shared -Wl,-soname,libstack.so.1 -o libstack.so.1.0 *.o

这样,名为 libstack.so.1.0的动态库已经生成，但是链接是gcc只认识名为libstack.so的库文件，为什么要加版本号呢，还有-Wl参数指定了libstack.so.1，这又是什么?我们在系统的库文件目录里会看到很多的符号链接，这样做有什么意义？稍后解释。

现在需要创建一个符号链接:

[root@localhost]ln -s libstack.so.1.0 libstack.so

再编译main.c，生成可执行文件:

[root@localhost]cd ..
[root@localhost]gcc main.c -Lstack -lstack -Istack -o main

如果没有创建符号链接，在编译main.c的时候就会收到 /usr/bin/ld:can not find -lstack错误，链接器找不到stack库文件。
这个时候执行main会发生一个错误error while loading shared libraries: libstack.so: cannot open shared object file: No such file or directory。动态库没有找到。
生成的动态库在/root/ctest/stack/stack目录下，我们在编译链接时指定的库的位置，但是运行时需要这个库文件，系统并不会找到/root/ctest/stack/stack里去。
用ldd命令就可以看到缺少了哪些库：

[root@localhost]ldd main
linux-gate.so.1 => (0×00a4d000)
libstack.so => not found
libc.so.6 => /lib/libc.so.6 (0×00563000)
/lib/ld-linux.so.2 (0×00546000)

通过查看ld.so(8)的Man Page可以找到几种解决方法，这里使用其中一种。
修改/etc/ld.so.conf,其中加上库文件的路径/root/ctest/stack/stack/,执行ldconfig生成cache文件/etc/ld.so.cache:

[root@localhost]echo /root/ctest/stack/stack >> /etc/ld.so.conf
[root@localhost]ldconfig

这时libstack.so.1就产生了，标准的libstack.so其实应该链接到这个文件上来。
此时的main便可以执行:

[root@localhost]./main
cba

现在的文件结构应该是:

[root@localhost stack]pwd
/root/ctest/stack
[root@localhost stack]tree
.
|– main
|– main.c
`– stack
|– empty.c
|– empty.o
|– libstack.so -> libstack.so.1.0
|– libstack.so.1 -> libstack.so.1.0
|– libstack.so.1.0
|– pop.c
|– pop.o
|– push.c
|– push.o
|– stack.c
|– stack.h
|– stack.o

可以将libstack.so删除，重新创建为指向libstack.so.1的链接，这是标准的做法。

[参考资料]共享库的命名惯例

按照共享库的命名惯例，每个共享库有三个文件名：real name、soname和linker name。真正的库文件（而不是符号链接）的名字是real name，包含完整的共享库版本号。例如上面的libcap.so.1.10、libc-2.8.90.so等。

soname是一个符号链接的名字，只包含共享库的主版本号，主版本号一致即可保证库函数的接口一致，因此应用程序的.dynamic段只记录共享库的soname，只要soname一致，这个共享库就可以用。例如上面的libcap.so.1和libcap.so.2是两个主版本号不同的libcap，有些应用程序依赖于libcap.so.1，有些应用程序依赖于libcap.so.2，但对于依赖libcap.so.1的应用程序来说，真正的库文件不管是libcap.so.1.10还是libcap.so.1.11都可以用，所以使用共享库可以很方便地升级库文件而不需要重新编译应用程序，这是静态库所没有的优点。注意libc的版本编号有一点特殊，libc-2.8.90.so的主版本号是6而不是2或2.8。

linker name仅在编译链接时使用，gcc的-L选项应该指定linker name所在的目录。有的linker name是库文件的一个符号链接，有的linker name是一段链接脚本。例如上面的libc.so就是一个linker name，它是一段链接脚本.

$ cat /usr/lib/libc.so
/* GNU ld script
Use the shared library, but some functions are only in
the static library, so try that secondarily. */
OUTPUT_FORMAT(elf32-i386)
GROUP ( /lib/libc.so.6 /usr/lib/libc_nonshared.a AS_NEEDED ( /lib/ld-linux.so.2 ) )

重新编译我们的libstack，指定它的soname：

$ gcc -shared -Wl,-soname,libstack.so.1 -o libstack.so.1.0 stack.o push.o pop.o is_empty.o

这样编译生成的库文件是libstack.so.1.0，是real name，但这个库文件中记录了它的soname是libstack.so.1：

$ readelf -a libstack.so.1.0
……
Dynamic section at offset 0xf10 contains 22 entries:
Tag Type Name/Value
0×00000001 (NEEDED) Shared library: [libc.so.6]
0×0000000e (SONAME) Library soname: [libstack.so.1]
……

如果把libstack.so.1.0所在的目录加入/etc/ld.so.conf中，然后运行ldconfig命令，ldconfig会自动创建一个soname的符号链接：

$ sudo ldconfig
$ ls -l libstack*
lrwxrwxrwx 1 root root 15 2009-01-21 17:52 libstack.so.1 -> libstack.so.1.0
-rwxr-xr-x 1 djkings djkings 10142 2009-01-21 17:49 libstack.so.1.0但这样编译链接main.c却会报错：

$ gcc main.c -L. -lstack -Istack -o main
/usr/bin/ld: cannot find -lstack

collect2: ld returned 1 exit status注意，要做这个实验，你得把先前编译的libstack共享库、静态库都删掉，如果先前拷到/lib或者/usr/lib下了也删掉，只留下libstack.so.1.0和libstack.so.1，这样你会发现编译器不认这两个名字，因为编译器只认linker name。可以先创建一个linker name的符号链接，然后再编译就没问题了：

$ ln -s libstack.so.1.0 libstack.so
$ gcc main.c -L. -lstack -Istack -o main

关联文章:

  1. C hash table code
  2. 为你的程序增加一个带文件名和行号的打印函数
  3. 递归程序的困扰

]]> http://www.vi1129.com/2009/12/make-lib/feed/ 1 递归程序的困扰 http://www.vi1129.com/2009/11/recursion/ http://www.vi1129.com/2009/11/recursion/#comments Tue, 24 Nov 2009 05:58:02 +0000 keykey http://www.vi1129.com/?p=420 很久没有写过递归程序，今天被一个小小的递归给困扰了。请教了CSDN的大哥们后，终于想明白了。

?View Code C1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 #include <stdio.c> #define LEN 3   char buf[LEN]={'a','b','c'};   void print_backward(int pos) { if (pos == LEN) return; print_backward(pos+1); putchar(buf[pos]); }   int main(void) { print_backward(0); putchar('\n');   return 0; }

其实挺简单的，就是return是return到上次调用的，加上main里的调用，一共调用了4次，第4次时pos=3，直接返回到第三次，第三次就执行了 putchar(buf[pos]);，而此时pos=2，也就是执行了 putchar(buf[2]);，依次类推，分别输出了buf[1],buf[0]，最后返回到了Main函数。 递归很强大，有时候很费解，这样的写法还是要学会的。

关联文章:静态库/动态库的编译和使用方法学习记录 C hash table code Linux多线程(1)

关联文章:
  1. 静态库/动态库的编译和使用方法学习记录
  2. C hash table code
  3. Linux多线程(1)
]]> 很久没有写过递归程序，今天被一个小小的递归给困扰了。请教了CSDN的大哥们后，终于想明白了。

?View Code C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

#include <stdio.c>
#define LEN 3
 
char buf[LEN]={'a','b','c'};
 
void print_backward(int pos)
{
  if (pos == LEN)
    return;
  print_backward(pos+1);
  putchar(buf[pos]);
}
 
int main(void)
{
  print_backward(0);
  putchar('\n');
 
  return 0;
}

其实挺简单的，就是return是return到上次调用的，加上main里的调用，一共调用了4次，第4次时pos=3，直接返回到第三次，第三次就执行了 putchar(buf[pos]);，而此时pos=2，也就是执行了 putchar(buf[2]);，依次类推，分别输出了buf[1],buf[0]，最后返回到了Main函数。
递归很强大，有时候很费解，这样的写法还是要学会的。

关联文章:

  1. 静态库/动态库的编译和使用方法学习记录
  2. C hash table code
  3. Linux多线程(1)

]]> http://www.vi1129.com/2009/11/recursion/feed/ 14 MD5应用的一点理解及Linux实现源码 http://www.vi1129.com/2009/11/linux-md5/ http://www.vi1129.com/2009/11/linux-md5/#comments Thu, 12 Nov 2009 07:47:26 +0000 keykey http://www.vi1129.com/?p=306 MD5的全称是Message-Digest Algorithm 5（信息-摘要算法），相关的标准是RFC1321,MD5的算法描述可以查看这份RFC或者自己google，这里就不提这些概念性的问题了。

需要说明的是MD5加密是单向不可逆的，也就是说没有办法把已经加密的密文还原为明文。所以最常见的应用在于用户名密码在数据库中的保存，一般的做法是将密码用MD5加密后将密文存入数据库，用户登陆时再将用户输入的明文密码做MD5运算后与数据库进行密文比照，密文比照不符则证明密码输入错误了。所以如果密码丢失了就只能重置，没有人会知道数据库中保存的密文所对应的明文。网上有看到说破解，这个不想做过多研究，仅凭一点经验理解，基本知道只要明文设置的复杂一些，解密几乎是不可能的事情。

最近在做UDP传输过程中的MD5校验，即是将所传输的数据（大约10KB的字串）进行MD5运算，然后把10KB的数据和32位长的MD5值一并发向客户端，客户端收到后再对所收到的10KB字串做MD5运算，与传输过来的MD5值比对，就可知道收到的数据是否有误需要丢弃或通知重传了。或许传输过来的MD5也会有误，不知道这样的问题IETF是怎么考虑的，知道的麻烦告知。

以下是自己整理的一份对字符串MD5加密的源码，留备记录。 md5.h

?View Code C#ifndef MD5_H #define MD5_H   #ifdef __alpha typedef unsigned int uint32; #else typedef unsigned long uint32; #endif   struct MD5Context { uint32 buf[4]; uint32 bits[2]; unsigned char in[64]; };   void MD5Init(struct MD5Context *context); void MD5Update(struct MD5Context *context, unsigned char const *buf, unsigned len); void MD5Final(unsigned char digest[16], struct MD5Context *context); void MD5Transform(uint32 buf[4], uint32 const in[16]);   /* * This is needed to make

继续阅读

关联文章:
  1. C hash table code
  2. Linux多线程(1)
  3. 使用setitimer和signal创建一个计时器
]]> MD5的全称是Message-Digest Algorithm 5（信息-摘要算法），相关的标准是RFC1321,MD5的算法描述可以查看这份RFC或者自己google，这里就不提这些概念性的问题了。

需要说明的是MD5加密是单向不可逆的，也就是说没有办法把已经加密的密文还原为明文。所以最常见的应用在于用户名密码在数据库中的保存，一般的做法是将密码用MD5加密后将密文存入数据库，用户登陆时再将用户输入的明文密码做MD5运算后与数据库进行密文比照，密文比照不符则证明密码输入错误了。所以如果密码丢失了就只能重置，没有人会知道数据库中保存的密文所对应的明文。网上有看到说破解，这个不想做过多研究，仅凭一点经验理解，基本知道只要明文设置的复杂一些，解密几乎是不可能的事情。

最近在做UDP传输过程中的MD5校验，即是将所传输的数据（大约10KB的字串）进行MD5运算，然后把10KB的数据和32位长的MD5值一并发向客户端，客户端收到后再对所收到的10KB字串做MD5运算，与传输过来的MD5值比对，就可知道收到的数据是否有误需要丢弃或通知重传了。或许传输过来的MD5也会有误，不知道这样的问题IETF是怎么考虑的，知道的麻烦告知。

以下是自己整理的一份对字符串MD5加密的源码，留备记录。

md5.h

?View Code C
#ifndef MD5_H
#define MD5_H
 
#ifdef __alpha
typedef unsigned int uint32;
#else
typedef unsigned long uint32;
#endif
 
struct MD5Context {
	uint32 buf[4];
	uint32 bits[2];
	unsigned char in[64];
};
 
void MD5Init(struct MD5Context *context);
void MD5Update(struct MD5Context *context, unsigned char const *buf,
	       unsigned len);
void MD5Final(unsigned char digest[16], struct MD5Context *context);
void MD5Transform(uint32 buf[4], uint32 const in[16]);
 
/*
 * This is needed to make RSAREF happy on some MS-DOS compilers.
 */
typedef struct MD5Context MD5_CTX;
 
#endif /* !MD5_H */

md5.c

?View Code C
/*
 * This code implements the MD5 message-digest algorithm.
 * The algorithm is due to Ron Rivest.  This code was
 * written by Colin Plumb in 1993, no copyright is claimed.
 * This code is in the public domain; do with it what you wish.
 *
 * Equivalent code is available from RSA Data Security, Inc.
 * This code has been tested against that, and is equivalent,
 * except that you don't need to include two pages of legalese
 * with every copy.
 *
 * To compute the message digest of a chunk of bytes, declare an
 * MD5Context structure, pass it to MD5Init, call MD5Update as
 * needed on buffers full of bytes, and then call MD5Final, which
 * will fill a supplied 16-byte array with the digest.
 */
#include <string.h>		/* for memcpy() */
#include "md5.h"
 
#ifndef HIGHFIRST
#define byteReverse(buf, len)	/* Nothing */
#else
void byteReverse(unsigned char *buf, unsigned longs);
 
#ifndef ASM_MD5
/*
 * Note: this code is harmless on little-endian machines.
 */
void byteReverse(unsigned char *buf, unsigned longs)
{
    uint32 t;
    do {
	t = (uint32) ((unsigned) buf[3] << 8 | buf[2]) << 16 |
	    ((unsigned) buf[1] << 8 | buf[0]);
	*(uint32 *) buf = t;
	buf += 4;
    } while (--longs);
}
#endif
#endif
 
/*
 * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
 * initialization constants.
 */
void MD5Init(struct MD5Context *ctx)
{
    ctx->buf[0] = 0x67452301;
    ctx->buf[1] = 0xefcdab89;
    ctx->buf[2] = 0x98badcfe;
    ctx->buf[3] = 0x10325476;
 
    ctx->bits[0] = 0;
    ctx->bits[1] = 0;
}
 
/*
 * Update context to reflect the concatenation of another buffer full
 * of bytes.
 */
void MD5Update(struct MD5Context *ctx, unsigned char const *buf, unsigned len)
{
    uint32 t;
 
    /* Update bitcount */
 
    t = ctx->bits[0];
    if ((ctx->bits[0] = t + ((uint32) len << 3)) < t)
	ctx->bits[1]++;		/* Carry from low to high */
    ctx->bits[1] += len >> 29;
 
    t = (t >> 3) & 0x3f;	/* Bytes already in shsInfo->data */
 
    /* Handle any leading odd-sized chunks */
 
    if (t) {
	unsigned char *p = (unsigned char *) ctx->in + t;
 
	t = 64 - t;
	if (len < t) {
	    memcpy(p, buf, len);
	    return;
	}
	memcpy(p, buf, t);
	byteReverse(ctx->in, 16);
	MD5Transform(ctx->buf, (uint32 *) ctx->in);
	buf += t;
	len -= t;
    }
    /* Process data in 64-byte chunks */
 
    while (len >= 64) {
	memcpy(ctx->in, buf, 64);
	byteReverse(ctx->in, 16);
	MD5Transform(ctx->buf, (uint32 *) ctx->in);
	buf += 64;
	len -= 64;
    }
 
    /* Handle any remaining bytes of data. */
 
    memcpy(ctx->in, buf, len);
}
 
/*
 * Final wrapup - pad to 64-byte boundary with the bit pattern 
 * 1 0* (64-bit count of bits processed, MSB-first)
 */
void MD5Final(unsigned char digest[16], struct MD5Context *ctx)
{
    unsigned count;
    unsigned char *p;
 
    /* Compute number of bytes mod 64 */
    count = (ctx->bits[0] >> 3) & 0x3F;
 
    /* Set the first char of padding to 0x80.  This is safe since there is
       always at least one byte free */
    p = ctx->in + count;
    *p++ = 0x80;
 
    /* Bytes of padding needed to make 64 bytes */
    count = 64 - 1 - count;
 
    /* Pad out to 56 mod 64 */
    if (count < 8) {
	/* Two lots of padding:  Pad the first block to 64 bytes */
	memset(p, 0, count);
	byteReverse(ctx->in, 16);
	MD5Transform(ctx->buf, (uint32 *) ctx->in);
 
	/* Now fill the next block with 56 bytes */
	memset(ctx->in, 0, 56);
    } else {
	/* Pad block to 56 bytes */
	memset(p, 0, count - 8);
    }
    byteReverse(ctx->in, 14);
 
    /* Append length in bits and transform */
    ((uint32 *) ctx->in)[14] = ctx->bits[0];
    ((uint32 *) ctx->in)[15] = ctx->bits[1];
 
    MD5Transform(ctx->buf, (uint32 *) ctx->in);
    byteReverse((unsigned char *) ctx->buf, 4);
    memcpy(digest, ctx->buf, 16);
    memset(ctx, 0, sizeof(ctx));	/* In case it's sensitive */
}
 
#ifndef ASM_MD5
 
/* The four core functions - F1 is optimized somewhat */
 
/* #define F1(x, y, z) (x & y | ~x & z) */
#define F1(x, y, z) (z ^ (x & (y ^ z)))
#define F2(x, y, z) F1(z, x, y)
#define F3(x, y, z) (x ^ y ^ z)
#define F4(x, y, z) (y ^ (x | ~z))
 
/* This is the central step in the MD5 algorithm. */
#define MD5STEP(f, w, x, y, z, data, s) \
	( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )
 
/*
 * The core of the MD5 algorithm, this alters an existing MD5 hash to
 * reflect the addition of 16 longwords of new data.  MD5Update blocks
 * the data and converts bytes into longwords for this routine.
 */
void MD5Transform(uint32 buf[4], uint32 const in[16])
{
    register uint32 a, b, c, d;
 
    a = buf[0];
    b = buf[1];
    c = buf[2];
    d = buf[3];
 
    MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
    MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
    MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
    MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
    MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
    MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
    MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
    MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
    MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
    MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
    MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
    MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
    MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
    MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
    MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
    MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
 
    MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
    MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
    MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
    MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
    MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
    MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
    MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
    MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
    MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
    MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
    MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
    MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
    MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
    MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
    MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
    MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
 
    MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
    MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
    MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
    MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
    MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
    MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
    MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
    MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
    MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
    MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
    MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
    MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
    MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
    MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
    MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
    MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
 
    MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
    MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
    MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
    MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
    MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
    MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
    MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
    MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
    MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
    MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
    MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
    MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
    MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
    MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
    MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
    MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
 
    buf[0] += a;
    buf[1] += b;
    buf[2] += c;
    buf[3] += d;
}
 
#endif

md5test.c

?View Code C
#include <stdio.h>
#include <string.h>
#include "md5.h"
 
void md5str(char* str){
	int i;
	unsigned char chappassword[16];
	unsigned int len=strlen(str);
	MD5_CTX context;
	MD5Init(&context);
	MD5Update(&context,(const unsigned char*)str,len);
 
	MD5Final(chappassword,&context);
	for(i=0;i<16;i++)
		printf("%02x",chappassword[i]);
	printf("\n");
}
int main(){
	char* password="hello";
	md5str(password);
}

关联文章:

  1. C hash table code
  2. Linux多线程(1)
  3. 使用setitimer和signal创建一个计时器

]]> http://www.vi1129.com/2009/11/linux-md5/feed/ 0