1129 » 程序人生 http://www.vi1129.com 学无止境 我心飞翔 Mon, 05 Jul 2010 15:30:18 +0000 http://wordpress.org/?v=2.8.6 en hourly 1 UNIX常用的IP表示掩码方式转换为字符串的程序实现方法 http://www.vi1129.com/2010/05/unix%e5%b8%b8%e7%94%a8%e7%9a%84ip%e8%a1%a8%e7%a4%ba%e6%8e%a9%e7%a0%81%e6%96%b9%e5%bc%8f%e8%bd%ac%e6%8d%a2%e4%b8%ba%e5%ad%97%e7%ac%a6%e4%b8%b2%e7%9a%84%e7%a8%8b%e5%ba%8f%e5%ae%9e%e7%8e%b0%e6%96%b9/ http://www.vi1129.com/2010/05/unix%e5%b8%b8%e7%94%a8%e7%9a%84ip%e8%a1%a8%e7%a4%ba%e6%8e%a9%e7%a0%81%e6%96%b9%e5%bc%8f%e8%bd%ac%e6%8d%a2%e4%b8%ba%e5%ad%97%e7%ac%a6%e4%b8%b2%e7%9a%84%e7%a8%8b%e5%ba%8f%e5%ae%9e%e7%8e%b0%e6%96%b9/#comments Fri, 21 May 2010 11:22:02 +0000 keykey http://www.vi1129.com/2010/05/unix%e5%b8%b8%e7%94%a8%e7%9a%84ip%e8%a1%a8%e7%a4%ba%e6%8e%a9%e7%a0%81%e6%96%b9%e5%bc%8f%e8%bd%ac%e6%8d%a2%e4%b8%ba%e5%ad%97%e7%ac%a6%e4%b8%b2%e7%9a%84%e7%a8%8b%e5%ba%8f%e5%ae%9e%e7%8e%b0%e6%96%b9/ 一种IP的表示方式为192.168.1.1/24，其数字24的含义为24位掩码，即掩码为255.255.255.0，程序中读入的类似192.168.1.1/24的字符串可能需要转换为IP地址和掩码两个字符串保存或处理，即将192.168.1.1/24转换为192.168.1.1和255.255.255.0，一种程序的实现方法如下

?View Code C#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

继续阅读

No related posts.]]> 一种IP的表示方式为192.168.1.1/24，其数字24的含义为24位掩码，即掩码为255.255.255.0，程序中读入的类似192.168.1.1/24的字符串可能需要转换为IP地址和掩码两个字符串保存或处理，即将192.168.1.1/24转换为192.168.1.1和255.255.255.0，一种程序的实现方法如下

?View Code C
#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;
}

No related posts.

]]> http://www.vi1129.com/2010/05/unix%e5%b8%b8%e7%94%a8%e7%9a%84ip%e8%a1%a8%e7%a4%ba%e6%8e%a9%e7%a0%81%e6%96%b9%e5%bc%8f%e8%bd%ac%e6%8d%a2%e4%b8%ba%e5%ad%97%e7%ac%a6%e4%b8%b2%e7%9a%84%e7%a8%8b%e5%ba%8f%e5%ae%9e%e7%8e%b0%e6%96%b9/feed/ 0 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/be-carefuf-coding/ http://www.vi1129.com/2009/12/be-carefuf-coding/#comments Mon, 28 Dec 2009 03:27:52 +0000 keykey http://www.vi1129.com/?p=573 一个很简单的说法早都知道，那就是内存泄漏，或者说访问了未申请的内存空间会产生不可预料的错误。 之前就遇到一个问题，在我机器上编译的二进制程序运行出错，除了在我的机器以外，在同事的机器上运行一样出错。意外的是同事拿走我的源码在他机器上编译后的二进制程序，除了在他自己的机器上运行正常，在我机器上运行同样不会出错。 最后是找啊找，找啊找。发现了一个用来存储一条SQL语句的char型数组被声明成了128字节长，事实上这条SQL语句在某些情况下会超出128字节，这样的错误找起来真是累人，改大了一点后，一切正常了。 不幸的是就在上周，又遇到了类似的错误，还是费了半天劲，发现是一个两位数的负数被放到了一个char型的数组中，而这个数组只有2字节长，天那，如果吸取了上次的教训，就不用花好几个小时来找这样让人头疼的错误了。话说回来，在一个char型数组中放置一个数字，还是个负数，用起来还要进行转换，岂不是很麻烦。 哦，忘了，是因为要用char型而从int转换过去的。无语。 为什么不可预料的错误在某个机器上100%出错，而在另一个机器上100%没错（虽然我没尝试100次），也行这只能用不可预料来解释了。

细心一点吧，这样的问题应该在写的时候就应该避免，编译器不会帮我们这个忙。

No related posts.

No related posts.]]> 一个很简单的说法早都知道，那就是内存泄漏，或者说访问了未申请的内存空间会产生不可预料的错误。
之前就遇到一个问题，在我机器上编译的二进制程序运行出错，除了在我的机器以外，在同事的机器上运行一样出错。意外的是同事拿走我的源码在他机器上编译后的二进制程序，除了在他自己的机器上运行正常，在我机器上运行同样不会出错。
最后是找啊找，找啊找。发现了一个用来存储一条SQL语句的char型数组被声明成了128字节长，事实上这条SQL语句在某些情况下会超出128字节，这样的错误找起来真是累人，改大了一点后，一切正常了。
不幸的是就在上周，又遇到了类似的错误，还是费了半天劲，发现是一个两位数的负数被放到了一个char型的数组中，而这个数组只有2字节长，天那，如果吸取了上次的教训，就不用花好几个小时来找这样让人头疼的错误了。话说回来，在一个char型数组中放置一个数字，还是个负数，用起来还要进行转换，岂不是很麻烦。 哦，忘了，是因为要用char型而从int转换过去的。无语。
为什么不可预料的错误在某个机器上100%出错，而在另一个机器上100%没错（虽然我没尝试100次），也行这只能用不可预料来解释了。

细心一点吧，这样的问题应该在写的时候就应该避免，编译器不会帮我们这个忙。

No related posts.

]]> http://www.vi1129.com/2009/12/be-carefuf-coding/feed/ 7 利用sudo为PHP批特权 http://www.vi1129.com/2009/12/sudo/ http://www.vi1129.com/2009/12/sudo/#comments Wed, 23 Dec 2009 10:44:45 +0000 keykey http://www.vi1129.com/?p=571 有时候需要在web上执行一些特殊的终端命令。例如ps，为了在web上显示出当前的进程列表，因为我经常做一些系统方面的编程，所以有时候就不得不做这些高危险性的事情。用下边的方法就可以允许php用exec，system等函数来执行这些终端命令。 键入命令visudo,打开sudoers文件，编辑该文件 注释掉Defaults requiretty一行，并在文件末尾追加Apache ALL=NOPASSWD:/bin/ps 这样，在php中就可以用类似这样的语句去执行ps命令exec(”/usr/bin/sudo /bin/ps -e”); ，当然，ps的参数可以随意指定，和在终端下使用一样。需要注意的是这里使用的是apache服务器，不同的web服务器该方法应该不能混用。 不允许php来执行的命令有很多，比如chkconfig,想开启或关闭一个服务，这些只有root才能做的事情，普通用户都是没有权限的，跟何况要php去做。所以同样的会带来安全问题，总之慎用就好。

记之，与大家分享，以备后用。

No related posts.

No related posts.]]> 有时候需要在web上执行一些特殊的终端命令。例如ps，为了在web上显示出当前的进程列表，因为我经常做一些系统方面的编程，所以有时候就不得不做这些高危险性的事情。用下边的方法就可以允许php用exec，system等函数来执行这些终端命令。
键入命令visudo,打开sudoers文件，编辑该文件
注释掉Defaults requiretty一行，并在文件末尾追加Apache ALL=NOPASSWD:/bin/ps
这样，在php中就可以用类似这样的语句去执行ps命令exec(”/usr/bin/sudo /bin/ps -e”); ，当然，ps的参数可以随意指定，和在终端下使用一样。需要注意的是这里使用的是apache服务器，不同的web服务器该方法应该不能混用。
不允许php来执行的命令有很多，比如chkconfig,想开启或关闭一个服务，这些只有root才能做的事情，普通用户都是没有权限的，跟何况要php去做。所以同样的会带来安全问题，总之慎用就好。

记之，与大家分享，以备后用。

No related posts.

]]> http://www.vi1129.com/2009/12/sudo/feed/ 4 带有#和##符号的函数式宏展开步骤 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