自己写了个ifconfig玩

Arthur.Echo

功能简单，就是为了前边提的“如何察看网卡信息？”而进行的学习
可用的命令：
myifconfig
myifconfig all
myifconfig eth0
myifconfig eth0 set
myifconfig eth0 up
myifconfig eth0 down
有很多毛病，比如说当一个网卡没有被配制IP的时候会出现错误

1. #include <sys/ioctl.h>
   
2. #include <net/if.h>
   
3. #include <sys/socket.h>
   
4. #include <sys/types.h>
   
5. #include <stdio.h>
   
6. #include <netinet/in.h>
   
7. 
   
8. int info_list(int all);
   
9. 
   
10. int get_interface_info(char * interface_name);
    
11. int set_interface(char * interface_name);
    
12. 
    
13. int get_ipaddr(char * interface_name);
    
14. int get_mac(char * interface_name);
    
15. int get_netmask(char * interface_name);
    
16. int get_broadcast(char * interface_name);
    
17. int set_ipaddr(char * interface_name,char * ip);
    
18. int set_mac(char * interface_name,char * mac);
    
19. int set_netmask(char * interface_name,char * netmask);
    
20. int set_broadcast(char * interface_name,char * broadcast);
    
21. 
    
22. int interface_up(char * interface_name);
    
23. int interface_down(char * interface_name);
    
24. 
    
25. int usage();
    
26. 
    
27. 
    
28. int main(int argc,char * argv[])
    
29. {
    
30.    if(argc == 1)
    
31.    {
    
32.       info_list(0);
    
33.       return 0;
    
34.    }
    
35. 
    
36.    if(argc == 2)
    
37.    {
    
38.       if(strcmp(argv[1],"all") == 0)
    
39.       {
    
40.           info_list(1);
    
41.           return 0;
    
42.       }
    
43. 
    
44.       get_interface_info(argv[1]);
    
45. 
    
46.       return 0;
    
47.    }
    
48. 
    
49.    if(argc == 3)
    
50.    {
    
51.       if(strcmp(argv[2],"set") == 0)
    
52.       {
    
53.           set_interface(argv[1]);
    
54.           return 0;
    
55.       }
    
56.       if(strcmp(argv[2],"up") == 0)
    
57.       {
    
58.           interface_up(argv[1]);
    
59.           return 0;
    
60.       }
    
61.       if(strcmp(argv[2],"down") == 0)
    
62.       {
    
63.           interface_down(argv[1]);
    
64.           return 0;
    
65.       }
    
66. 
    
67.       usage();
    
68. 
    
69.       return 0;
    
70.    }
    
71. 
    
72.    usage();
    
73. 
    
74.    return 0;
    
75. }
    
76. 
    
77. 
    
78. int info_list(int all)
    
79. {  
    
80.    int len;
    
81.    char *ifreq_pointer;
    
82.    len = 10*sizeof(struct ifreq);
    
83.    ifreq_pointer = (char *)malloc(len);
    
84. 
    
85.    struct ifconf get_info;
    
86.    get_info.ifc_len = len;
    
87.    get_info.ifc_ifcu.ifcu_buf = ifreq_pointer;
    
88. 
    
89.    int sockfd;
    
90.    sockfd = socket(PF_INET,SOCK_STREAM,0);
    
91.    ioctl(sockfd,SIOCGIFCONF,&get_info);
    
92. 
    
93.    int count;
    
94.    count = get_info.ifc_len / sizeof(struct ifreq);
    
95.    
    
96.    struct sockaddr_in * return_sockaddr;
    
97. 
    
98.    struct ifreq * result = (struct ifreq *)ifreq_pointer;
    
99.    int i = 0;
    
100.    if(all == 1)
     
101.    for(i;i<count;i++)
     
102.    {
     
103.        printf("%s\n",result[i].ifr_name);
     
104.        get_ipaddr(result[i].ifr_name);
     
105.        get_mac(result[i].ifr_name);
     
106.        get_netmask(result[i].ifr_name);
     
107.        get_broadcast(result[i].ifr_name);
     
108.    }
     
109.    else
     
110.    {
     
111.        struct ifreq tmp;
     
112.        int s;
     
113.        if((s = socket(PF_INET,SOCK_STREAM,0)) < 0)
     
114.        {
     
115.           perror("Socket");
     
116.           exit(-1);
     
117.        }
     
118. 
     
119.        for(i;i<count;i++)
     
120.        {
     
121.           strcpy(tmp.ifr_name,result[i].ifr_name);
     
122.           if(ioctl(s,SIOCGIFFLAGS,&tmp) < 0)
     
123.           {
     
124.               perror("ioctl");
     
125.               exit(-1);
     
126.           }
     
127.           if((tmp.ifr_ifru.ifru_flags & IFF_UP) == 0)
     
128.               continue;
     
129.           printf("%s\n",tmp.ifr_name);
     
130.           get_ipaddr(tmp.ifr_name);
     
131.           get_mac(tmp.ifr_name);
     
132.           get_netmask(tmp.ifr_name);
     
133.           get_broadcast(tmp.ifr_name);         
     
134.        }
     
135.    }
     
136. 
     
137.    exit(0);
     
138. }
     
139. 
     
140. int get_ipaddr(char * interface_name)
     
141. {
     
142.     int s;
     
143.     if((s = socket(PF_INET,SOCK_STREAM,0)) < 0)
     
144.     {
     
145.        perror("Socket");
     
146.        return -1;
     
147.     }
     
148. 
     
149.     struct ifreq ifr;
     
150.     strcpy(ifr.ifr_name,interface_name);
     
151. 
     
152.     if(ioctl(s,SIOCGIFADDR,&ifr) < 0)
     
153.     {
     
154.        perror("ioctl");
     
155.        return -1;
     
156.     }
     
157. 
     
158.     struct sockaddr_in * ptr;
     
159.     ptr = (struct sockaddr_in *)&ifr.ifr_ifru.ifru_addr;
     
160. 
     
161.     printf("        IP:%s\n",inet_ntoa(ptr->sin_addr));
     
162. 
     
163.     return 0;
     
164. }
     
165. 
     
166. 
     
167. int get_mac(char * interface_name)
     
168. {   
     
169.     if(strcmp(interface_name,"lo") == 0)
     
170.     {
     
171.         return 0;
     
172.     }
     
173. 
     
174.     int s;
     
175.    
     
176.     if((s = socket(PF_INET,SOCK_STREAM,0)) < 0)
     
177.     {
     
178.         perror("Socket");
     
179.         return -1;
     
180.     }
     
181. 
     
182.     struct ifreq ifr;
     
183.    
     
184.     strcpy(ifr.ifr_name,interface_name);
     
185. 
     
186.     if(ioctl(s,SIOCGIFHWADDR,&ifr) != 0)
     
187.     {
     
188.         perror("ioctl");
     
189.         return -1;
     
190.     }
     
191. 
     
192.     u_char * ptr;
     
193.     ptr =(u_char *)&ifr.ifr_ifru.ifru_hwaddr.sa_data[0];
     
194.     printf("        MAC:%02x-%02x-%02x-%02x-%02x-%02x\n",*ptr,*(ptr+1),*(ptr+2),*(ptr+3),*(ptr+4),*(ptr+5));
     
195.    
     
196.     return 0;
     
197. }
     
198. 
     
199. 
     
200. int get_netmask(char * interface_name)
     
201. {
     
202.     int s;
     
203.    
     
204.     if((s = socket(PF_INET,SOCK_STREAM,0)) < 0)
     
205.     {
     
206.        perror("Socket");
     
207.        return -1;
     
208.     }
     
209. 
     
210.     struct ifreq ifr;
     
211.     strcpy(ifr.ifr_name,interface_name);
     
212. 
     
213.     if(ioctl(s,SIOCGIFNETMASK,&ifr) < 0)
     
214.     {
     
215.        perror("ioctl");
     
216.        return -1;
     
217.     }
     
218. 
     
219.     struct sockaddr_in * ptr;
     
220.     ptr = (struct sockaddr_in *)&ifr.ifr_ifru.ifru_netmask;
     
221.    
     
222.     printf("        Netmask:%s\n",inet_ntoa(ptr->sin_addr));
     
223.   
     
224.     return 0;
     
225. }
     
226. 
     
227. 
     
228. int get_broadcast(char * interface_name)
     
229. {
     
230.     int s;
     
231. 
     
232.     if((s = socket(PF_INET,SOCK_STREAM,0)) < 0)
     
233.     {
     
234.        perror("Socket");
     
235.        return -1;
     
236.     }
     
237. 
     
238.     struct ifreq ifr;
     
239.     strcpy(ifr.ifr_name,interface_name);
     
240. 
     
241.     if(ioctl(s,SIOCGIFBRDADDR,&ifr) < 0)
     
242.     {
     
243.        perror("ioctl");
     
244.        return -1;
     
245.     }
     
246. 
     
247.     struct sockaddr_in * ptr;
     
248.     ptr = (struct sockaddr_in *)&ifr.ifr_ifru.ifru_broadaddr;
     
249. 
     
250.     printf("        Broadcast:%s\n",inet_ntoa(ptr->sin_addr));
     
251. 
     
252.     return 0;
     
253. 
     
254. }
     
255. 
     
256. int get_interface_info(char * interface_name)
     
257. {
     
258.     get_ipaddr(interface_name);
     
259.     get_mac(interface_name);
     
260.     get_netmask(interface_name);
     
261.     get_broadcast(interface_name);
     
262. 
     
263.     return 0;
     
264. }
     
265. 
     
266. 
     
267. int set_interface(char * interface_name)
     
268. {
     
269.     char ip[18];
     
270.     char mac_addr[20];
     
271.     char netmask[18];
     
272.     char broadcast[18];
     
273. 
     
274.     printf("Change ");
     
275.     get_ipaddr(interface_name);
     
276.     printf("To:  ");
     
277.     fgets(ip,17,stdin);
     
278.     if(strcmp(ip,"\n") == 0)
     
279.        goto set_mac;
     
280.     set_ipaddr(interface_name,ip);
     
281. 
     
282. set_mac:
     
283.     printf("Change ");
     
284.     get_mac(interface_name);
     
285.     printf("To:  ");
     
286.     fgets(mac_addr,19,stdin);
     
287.     if(strcmp(mac_addr,"\n") == 0)
     
288.         goto set_netmask;
     
289.     set_mac(interface_name,mac_addr);
     
290. 
     
291. set_netmask:
     
292.     printf("Change ");
     
293.     get_netmask(interface_name);
     
294.     printf("To:  ");
     
295.     fgets(netmask,17,stdin);
     
296.     if(strcmp(netmask,"\n") == 0)
     
297.         goto set_broadcast;
     
298.     set_netmask(interface_name,netmask);
     
299. 
     
300. set_broadcast:
     
301.     printf("Change ");
     
302.     get_broadcast(interface_name);
     
303.     printf("To:  ");
     
304.     fgets(broadcast,17,stdin);
     
305.     if(strcmp(broadcast,"\n") == 0)
     
306.         return 0;
     
307.     set_broadcast(interface_name,broadcast);
     
308. 
     
309.     return 0;
     
310. }
     
311. 
     
312. 
     
313. int interface_up(char * interface_name)
     
314. {
     
315.     int s;
     
316. 
     
317.     if((s = socket(PF_INET,SOCK_STREAM,0)) < 0)
     
318.     {
     
319.         perror("Socket");
     
320.         return -1;
     
321.     }
     
322. 
     
323.     struct ifreq ifr;
     
324.     strcpy(ifr.ifr_name,interface_name);
     
325. 
     
326.     short flag;
     
327.     flag = IFF_UP;
     
328.     if(ioctl(s,SIOCGIFFLAGS,&ifr) < 0)
     
329.     {
     
330.         perror("ioctl");
     
331.         return -1;
     
332.     }
     
333. 
     
334.     ifr.ifr_ifru.ifru_flags |= flag;
     
335. 
     
336.     if(ioctl(s,SIOCSIFFLAGS,&ifr) < 0)
     
337.     {
     
338.         perror("ioctl");
     
339.         return -1;
     
340.     }
     
341. 
     
342.     return 0;
     
343. 
     
344. }
     
345. 
     
346. 
     
347. int interface_down(char * interface_name)
     
348. {
     
349.     if(strcmp(interface_name,"lo") == 0)
     
350.     {
     
351.         printf("You can't pull down interface lo\n");
     
352.         return 0;
     
353.     }
     
354. 
     
355.     int s;
     
356. 
     
357.     if((s = socket(PF_INET,SOCK_STREAM,0)) < 0)
     
358.     {
     
359.         perror("Socket");
     
360.         return -1;
     
361.     }
     
362. 
     
363.     struct ifreq ifr;
     
364.     strcpy(ifr.ifr_name,interface_name);
     
365.    
     
366.     short flag;
     
367.     flag = ~IFF_UP;
     
368.     if(ioctl(s,SIOCGIFFLAGS,&ifr) < 0)
     
369.     {
     
370.         perror("ioctl");
     
371.         return -1;
     
372.     }
     
373. 
     
374.     ifr.ifr_ifru.ifru_flags &= flag;
     
375. 
     
376.     if(ioctl(s,SIOCSIFFLAGS,&ifr) < 0)
     
377.     {
     
378.         perror("ioctl");
     
379.         return -1;
     
380.     }
     
381. 
     
382.     return 0;
     
383. }
     
384. 
     
385. int set_ipaddr(char * interface_name,char * ip)
     
386. {
     
387.      int s;
     
388.      
     
389.      if((s = socket(PF_INET,SOCK_STREAM,0)) < 0)
     
390.     {
     
391.         perror("Socket");
     
392.         return -1;
     
393.     }
     
394. 
     
395.     struct ifreq ifr;
     
396.     strcpy(ifr.ifr_name,interface_name);
     
397. 
     
398.     struct sockaddr_in addr;
     
399.     bzero(&addr,sizeof(struct sockaddr_in));
     
400.     addr.sin_family = PF_INET;
     
401.     inet_aton(ip,&addr.sin_addr);
     
402. 
     
403.     memcpy(&ifr.ifr_ifru.ifru_addr,&addr,sizeof(struct sockaddr_in));
     
404. 
     
405.     if(ioctl(s,SIOCSIFADDR,&ifr) < 0)
     
406.     {
     
407.         perror("ioctl");
     
408.         return -1;
     
409.     }
     
410. 
     
411.     return 0;
     
412. }
     
413. 
     
414. int set_mac(char * interface_name,char * mac_addr)
     
415. {
     
416.    int s;
     
417.    if((s = socket(PF_INET,SOCK_STREAM,0)) < 0)
     
418.    {
     
419.       perror("Socket");
     
420.       return -1;
     
421.    }
     
422.    
     
423.    struct ifreq ifr;
     
424.    strcpy(ifr.ifr_name,interface_name);
     
425. 
     
426.    if(ioctl(s,SIOCGIFHWADDR,&ifr) < 0)
     
427.    {
     
428.       perror("ioctl");
     
429.       return -1;
     
430.    }
     
431. 
     
432.    sa_family_t get_family;
     
433.    get_family = ifr.ifr_ifru.ifru_hwaddr.sa_family;
     
434.    
     
435.    interface_down(interface_name);
     
436. 
     
437.    bzero(&ifr,sizeof(struct ifreq));
     
438.    strcpy(ifr.ifr_name,interface_name);
     
439.    ifr.ifr_ifru.ifru_hwaddr.sa_family = get_family;
     
440. 
     
441.    short tmp;
     
442.    int i,j;
     
443.    j = 0;
     
444.    for(i = 0;i < 17; i += 3)
     
445.    {
     
446.       if(mac_addr[i] < 58 && mac_addr[i] > 47)
     
447.          tmp = mac_addr[i]-48;
     
448.       if(mac_addr[i] < 71 && mac_addr[i] > 64)
     
449.          tmp = mac_addr[i]-55;
     
450.       if(mac_addr[i] < 103 && mac_addr[i] > 96)
     
451.          tmp = mac_addr[i]-87;
     
452.       tmp = tmp << 4;
     
453.       if(mac_addr[i+1] < 58 && mac_addr[i+1] > 47)
     
454.          tmp |= (mac_addr[i+1]-48);
     
455.       if(mac_addr[i+1] < 71 && mac_addr[i+1] > 64)
     
456.          tmp |= (mac_addr[i+1]-55);
     
457.       if(mac_addr[i+1] < 103 && mac_addr[i+1] > 96)
     
458.          tmp |= (mac_addr[i+1]-87);
     
459.       memcpy(&ifr.ifr_ifru.ifru_hwaddr.sa_data[j++],&tmp,1);
     
460.    }
     
461. 
     
462.    if(ioctl(s,SIOCSIFHWADDR,&ifr) < 0)
     
463.    {
     
464.        perror("ioctl");
     
465.        return -1;
     
466.    }
     
467. 
     
468.    interface_up(interface_name);
     
469. 
     
470.    return 0;
     
471. }
     
472. 
     
473. int set_netmask(char * interface_name,char * netmask)
     
474. {
     
475.      int s;
     
476. 
     
477.      if((s = socket(PF_INET,SOCK_STREAM,0)) < 0)
     
478.     {
     
479.         perror("Socket");
     
480.         return -1;
     
481.     }
     
482. 
     
483.     struct ifreq ifr;
     
484.     strcpy(ifr.ifr_name,interface_name);
     
485. 
     
486.     struct sockaddr_in netmask_addr;
     
487.     bzero(&netmask_addr,sizeof(struct sockaddr_in));
     
488.     netmask_addr.sin_family = PF_INET;
     
489.     inet_aton(netmask,&netmask_addr.sin_addr);
     
490. 
     
491.     memcpy(&ifr.ifr_ifru.ifru_netmask,&netmask_addr,sizeof(struct sockaddr_in));
     
492. 
     
493.     if(ioctl(s,SIOCSIFNETMASK,&ifr) < 0)
     
494.     {
     
495.         perror("ioctl");
     
496.         return -1;
     
497.     }
     
498. 
     
499.     return 0;
     
500. 
     
501. }
     
502. 
     
503. 
     
504. int set_broadcast(char * interface_name,char * broadcast)
     
505. {
     
506.     int s;
     
507. 
     
508.      if((s = socket(PF_INET,SOCK_STREAM,0)) < 0)
     
509.     {
     
510.         perror("Socket");
     
511.         return -1;
     
512.     }
     
513. 
     
514.     struct ifreq ifr;
     
515.     strcpy(ifr.ifr_name,interface_name);
     
516. 
     
517.     struct sockaddr_in broadcast_addr;
     
518.     bzero(&broadcast_addr,sizeof(struct sockaddr_in));
     
519.     broadcast_addr.sin_family = PF_INET;
     
520.     inet_aton(broadcast,&broadcast_addr.sin_addr);
     
521. 
     
522.     memcpy(&ifr.ifr_ifru.ifru_broadaddr,&broadcast_addr,sizeof(struct sockaddr_in));
     
523. 
     
524.     if(ioctl(s,SIOCSIFBRDADDR,&ifr) < 0)
     
525.     {
     
526.         perror("ioctl");
     
527.         return -1;
     
528.     }
     
529. 
     
530.     return 0;
     
531. }
     
532. 
     
533. 
     
534. int usage(void)
     
535. {
     
536.    printf("Usage: myifconfig [all]|[interface [set|up|down]]\n");
     
537.    return 0;
     
538. }
     

复制代码

ywchen2000

呵呵,强.学习之

Illidan

开源精神。
//praise

DoDo

挺好, 有不少值得作为备案的东东.

不过楼主在每一项测试中都重新建立 socket, 是否有点多余呢? 而且是否应该考虑将它们用完后关闭呢?

Arthur.Echo

Post by DoDo
挺好, 有不少值得作为备案的东东.

不过楼主在每一项测试中都重新建立 socket, 是否有点多余呢? 而且是否应该考虑将它们用完后关闭呢?

这一点我也考虑到了，本打算在程序初始化的时候创建一个Socket然后在整个程序中都使用这一个Socket就可以了，但是这样每个函数就不可以单独拿出来用了。我这样写其他人都可以直接将某个函数copy出来就可以使用，而且由于基本上是一个与用户交互的程序，所以在每个函数中都创建Socket对性能来说是感觉不出来的。还有就是程序运行完了就退出，所以不关闭那些socket也不是什么问题，只是习惯不太好^_^