⑴ 如何利用ioctl調用內核函數
首先請檢查open、read之類的正確。之後，你的ioctl要是自己定義的cmd，需要同時在內核態以及用戶態建立描述這個cmd的頭文件。否則亂傳cmd自然不能匹配。cmd里包含你的ioctl的參數類型（是否有參數，參數是只傳遞進內核；還是只從內核取；還是既傳遞進內核又從內核取）以及混淆具體cmd的定義你可以很容易到內核源碼里找到例子，grep-rni"ioctl"./drivers跟著學就好了
⑵ ioctl() 小於0 的問題
我看看
「藍屏」的軟體原因
一、啟動時載入程序過多
不要在啟動時載入過多的應用程序（尤其是你的內存小於64MB），以免使系統資源消耗殆盡。正常情況下，Win9X啟動後系統資源應不低於90%。最好維持在90%以上，若啟動後未運行任何程序就低於70%，就需要卸掉一部分應用程序，否則就可能出現「藍屏」。
二、應用程序存在著BUG
有些應用程序設計上存在著缺陷或錯誤，運行時有可能與Win9X發生沖突或爭奪資源，造成Win9X無法為其分配內存地址或遇到其保護性錯誤。這種BUG可能是無法預知的，免費軟體最為常見。另外，由於一些用戶還在使用盜版軟體（包括盜版Win9X），這些盜版軟體在解密過程中會破壞和丟失部分源代碼，使軟體十分不穩定，不可靠，也常常導致「藍屏」。
三、遭到不明的程序或病毒攻擊所至
這個現象只要是平時我們在上網的時候遇到的，當我們在沖浪的時候，特別是進到一些BBS站時，可能暴露了自己的IP，被「黑客「用一些軟體攻擊所至。對互這種情況最好就是在自己的計算機上安裝一些防禦軟體。再有就是登錄BBS要進行安全設置，隱藏自己IP。
四、版本沖突
有些應用程序需調用特定版本的動態鏈接庫DLL，如果在安裝軟體時，舊版本的DLL覆蓋了新版本的DLL，或者刪除應用程序時，誤刪了有用的DLL文件，就可能使上述調用失敗，從而出現「藍屏」。不妨重新安裝試一試。
此篇說的是軟體使用可能引起的藍屏，當然這只是引起藍屏的一小部份原因。
五、注冊表中存在錯誤或損壞
很多情況下這是出現「藍屏」的主要原因。注冊表保存著Win9X的硬體配置、應用程序設置和用戶資料等重要數據，如果注冊表出現錯誤或被損壞，就很可能出現「藍屏」。如果你的電腦經常出現「藍屏」，你首先就應考慮是注冊表出現了問題，應及時對其檢測、修復，避免更大的損失。
六、軟硬體不兼容
新技術、新硬體的發展很快，如果安裝了新的硬體常常出現「藍屏」，那多半與主板的BIOS或驅動程序太舊有關，以致不能很好支持硬體。如果你的主板支持BIOS升級，應盡快升級到最新版本或安裝最新的設備驅動程序。
「藍屏」的硬體原因
在計算機的使用過程中，經常會遇到藍屏的情況。對於初學者來講，好象就是一場電腦災難一樣，不知所措。其實只要了解了原因之後就不用怕了。造成計算機藍屏的原因有很多種，硬體方面的原因總體可以概括為以下幾種：
一、屏幕顯示系統忙，請按任意鍵繼續
1、虛擬內存不足造成系統多任務運算錯誤
虛擬內存是WINDOWS系統所特有的一種解決系統資源不足的方法，其一般要求主引導區的硬碟剩餘空間是其物理
內存的2-3倍。而一些發燒友為了充分利用空間，將自己的硬碟塞到滿滿的，忙記了WINDOWS這個苛刻的要求。結果導致虛擬內存因硬碟空間不足而出現運算錯誤，所以就出現藍屏。 要解決這個問題好簡單，盡量不要把硬碟塞得滿滿的，要經常刪除一些系統產生的臨時文件、交換文件，從而可以釋放空間。或可以手動配置虛擬內存，選擇高級，把虛擬內存的默認地址，轉到其他的邏輯盤下。這樣就可以避免了因虛擬內存不足而引起的藍屏。
⑶ linux-ioctl什麼時候會調用失敗，而且返回
首先請檢查open、read之類的正確。之後，
你的ioctl要是自己定義的cmd，需要同時在內核態以及用戶態建立描述這個cmd的頭文件。否則亂傳cmd自然不能匹配。
cmd里包含你的ioctl的參數類型（是否有參數，參數是只傳遞進內核；還是只從內核取；還是既傳遞進內核又從內核取）以及混淆
具體cmd的定義你可以很容易到內核源碼里找到例子，grep -rni "ioctl" ./drivers
跟著學就好了
⑷ ioctl（）函數的參數和作用
因為用戶層定義它是個變參函數
ioctl (int __fd, unsigned long int __request, ...)
跟printf似的
⑸ linux下怎麼用C++實現對文件的寫入要測試一個項目用。以下是關於文件寫入部分的源碼
寫進文件的是字元，你要是寫進一個值，得把這個值處理一下再寫，比如你要寫15，你就得取出1和5，然後分別變成字元"1"和"5"再往文件里寫。
⑹ 求兩相四線步進電機驅動，C語言源碼，可以控制步數的。
#include <stdio.h> #include <fcntl.h> #include <string.h> #include <sys/ioctl.h>
#define STEPMOTOR_IOCTRL_PHASE 0x13 staticintstep_fd = -1;
char *STEP_DEV="/dev/exio/0raw"; //定義一個指針指向步進電機的驅動 程序
/********* A, AB, B, BC, C CD, D, DA ***/
char stepdata[]={0x10,0x30,0x20,0x60,0x40,0xc0,0x80,0x90};//各 個相位對應的值
void Delay(int t) //延時函數 { int i;
for(;t>0;t--)
for(i=0;i<400;i++); }
/***************************************************** ***********/
int main(intargc, char **argv) {
int i = 0;
if((step_fd=open(STEP_DEV, O_WRONLY))<0){ printf("Error opening /dev/exio/0raw device\n"); return 1; } /＊
打開設備的驅動程序，由於LINUX把所有的設備都模擬成文件。 step_fd=open(STEP_DEV,0_WRONLY)實際調用的函數為：
staticint s3c2410_exio_open(structinode *inode, struct file *filp) //驅動程序中的設備打開程序 ＊/
for (;;) {
for (i=0; i<sizeof(stepdata)/sizeof(stepdata[0]); i++) { ioctl(step_fd, STEPMOTOR_IOCTRL_PHASE, stepdata[i]); }
/＊程序進入一個死循環，這樣可以使電機在沒有人為停止的狀況下，一直的 轉動下去。
＊第二層for語句循環一次即電機轉動一周。函數ioctl（）對應函 數＊s3c2410_exio_ioctl（）
＊而這個函數最終將調用函數do_stepmotor_run((char)arg);使步進電 機轉動起來。 ＊/
printf("Delay(100)\n"); Delay(100); }
close(step_fd); //程序結束時關閉設備 printf("Step motor start running!\n"); return 0; }本文來自網路文庫，你可以搜搜，其中答案更詳細的！
⑺ Linux下碰到一個關於ioctl緩沖區的問題
是不是buffer的長度系統默認是接受100個包的大小，你可以改改大小試試
⑻ 怎麼使用Android源碼編譯c模塊生成可執行文件
1. 在./development目錄下創建一目錄 如：myhello
2. 進入hello目錄，在其下編寫自己的.c文件,如: myhello.c
#include <stdio.h>
int main()
{
printf("hello world\n");
exit(0);
//return 0;
}
3. 在hello目錄中，編寫Android.mk, 內容如下：
LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE := myhelloworld
LOCAL_SRC_FILES := myhello.c
LOCAL_MODULE_TAGS := optional
include $(BUILD_EXECUTABLE)
4. 回到Android源代碼頂層目錄，進行編譯，make myhelloworld
5. 生成的可執行文件位於:out/target/proct/lotus/system/bin/ 目錄下
6. adb push 到手機 /data 目錄下,然後進入adb shell,到data目錄下,執行./myhelloworld 皆可
手動編譯連接【arm-eabi-gcc 的目錄隨andorid的版本而有變化，還有就是需要鏈接的文件如果比較多時，需要很多-l 就很麻煩了】
7、編譯成目標文件：
#$(yourAndroid)/prebuilt/linux-x86/toolchain/[arm-eabi-4.2.1]/bin/arm-eabi-gcc -I bionic/libc/arch-arm/include/ -I bionic/libc/include -I bionic/libc/kernel/common -I bionic/libc/kernel/arch-arm -g -c helloworld.c -o hello.o
8、生成可執行代碼：
#$(yourAndroid)/prebuilt/linux-x86/toolchain/[arm-eabi-4.2.1]/bin/arm-eabi-gcc -nostdlib -Bdynamic -Wl,-T,build/core/armelf.x -Wl,-dynamic-linker,/system/bin/linker -Wl,--gc-sections -Wl,-z,noreloc -o helloworld -Lout/target/proct/[generic]/obj/lib -Wl,-rpath-link=out/target/proct/[generic]/obj/lib -lc hello.o -entry=main
其中[ ]中部分根據實際情況修改
**************************************************
實驗：
1. 建目錄(my Android)/development/test， 在該目錄下新建 Android.mk和fb_test.c文件
2. Android.mk文件
LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE := myfbtest
LOCAL_SRC_FILES := fb_test.c
LOCAL_MODULE_TAGS := optional
include $(BUILD_EXECUTABLE)
3. 以下為fb_test.c
#include <fcntl.h>
#include <linux/fb.h>
#include <sys/mman.h>
#include <linux/kd.h>
#include <stdio.h>
#define FBBIT_PER_PIXEL 32
#define FBBIT_PIXEL_IMAGE 16
#define PIXELS_WIDTH_BYTE 4
#define BYTE_PER_PIXEL 3
#define FB_GRAPHICS_PATH "/dev/graphics/fb0"
#define DEV_TTY0_PATH "/dev/tty0"
#define DISPLAY_ERROR -1
#define DISPLAY_SUCCESS 0
#define GET_BATTERYCAPACITY_ERR -1
#define MAX_STR 255
static struct {
int fd;
void *pixels;
struct fb_fix_screeninfo fixed;
struct fb_var_screeninfo var;
int align_xres;
} fb;
int getBatteryCapacity(void)
{
FILE *in;
char tmpStr[MAX_STR + 1];
char capfile[] = "/sys/class/power_supply/battery/capacity";
if (capfile == NULL)
return GET_BATTERYCAPACITY_ERR;
in = fopen(capfile, "rt");
if (in == NULL)
return GET_BATTERYCAPACITY_ERR;
if (fgets(tmpStr, MAX_STR, in) == NULL) {
printf("Failed to read battery capacity!\n");
fclose(in);
return GET_BATTERYCAPACITY_ERR;
}
printf("Battery capacity(ascii): %s\n", tmpStr);
fclose(in);
return 0;//atoi(tmpStr);
}
static int vt_set_graphicsmode(int graphics)
{
int fd, r;
fd = open(DEV_TTY0_PATH, O_RDWR | O_SYNC);
if (fd < 0)
return DISPLAY_ERROR;
r = ioctl(fd, KDSETMODE, graphics);
close(fd);
return r;
}
int display_init(void)
{
fb.fd = open(FB_GRAPHICS_PATH, O_RDWR);
if (fb.fd < 0)
return DISPLAY_ERROR;
if (ioctl(fb.fd, FBIOGET_FSCREENINFO, &fb.fixed) < 0)
return DISPLAY_ERROR;
if (ioctl(fb.fd, FBIOGET_VSCREENINFO, &fb.var) < 0)
return DISPLAY_ERROR;
fb.align_xres = fb.fixed.line_length /
(fb.var.bits_per_pixel >> BYTE_PER_PIXEL);
fb.pixels = mmap(0, fb.fixed.line_length * fb.var.yres_virtual,
PROT_READ | PROT_WRITE, MAP_SHARED, fb.fd, 0);
if (fb.pixels == MAP_FAILED)
return DISPLAY_ERROR;
vt_set_graphicsmode(KD_GRAPHICS);
memset(fb.pixels, 0, fb.fixed.line_length * fb.var.yres_virtual);
//display_update(fb.pixels, fb.align_xres, fb.var.yres);
fb.var.activate = FB_ACTIVATE_FORCE;
ioctl(fb.fd, FBIOPUT_VSCREENINFO, &fb.var);
printf("display_init ok\n");
return DISPLAY_SUCCESS;
}
void display_on(void)
{
ioctl(fb.fd, FBIOBLANK, FB_BLANK_UNBLANK);
}
void display_off(void)
{
ioctl(fb.fd, FBIOBLANK, FB_BLANK_POWERDOWN);
}
int main()
{
display_init();
display_off();//關顯示屏
getBatteryCapacity();
sleep(5);
display_on();//開顯示屏
return 0;
}
⑼ 如何偽造tcp數據包，並進行正確的校驗的例子演示及源碼
下面的程序是在linux下進行tcp偽造的一個例子:涉及原始套接字和tcp的校驗演算法
/************************tcp_pseudo.c********************/
/** Author :cbchen. */
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define INTERFACE "eth0"
#define IP ""
/*Prototype area*/
int Open_Packet_Socket();
int Open_Raw_Socket();
int Set_Promisc(char *interface, int sock);
void send_tcp_ack(int sockfd,struct sockaddr_in *addr);
unsigned short check_sum(unsigned short *addr,int len);
struct ip *iprecv;
struct tcphdr *tcprecv;
struct sockaddr_in addr;
int main()
{
int sockfd,sendfd,bytes_recieved;
char buffer[1518];
u_char *buf2;
char saddr[20],daddr[20];
sockfd=Open_Packet_Socket();
sendfd=Open_Raw_Socket();
//printf("sockfd:%d/tsendfd:%d/n",sockfd,sendfd);
int on=1;
/******** 設置IP數據包格式,告訴系統內核模塊IP數據包由我們自己來填寫 ***/
setsockopt(sendfd,IPPROTO_IP,IP_HDRINCL,&on,sizeof(on));
Set_Promisc(INTERFACE, sockfd);
int count=1;
while(1)
{
bytes_recieved = recvfrom(sockfd, buffer, 1518, 0, NULL, NULL);
buf2=buffer;
buf2+=14;
iprecv=(struct ip *)buf2;
//iprecv+=sizeof(struct ethhdr*);
/*See if this is a TCP packet*/
if(iprecv->ip_v == 4&iprecv->ip_p == 6) {
printf("---------------------------Number %d packet-----------------------------------------------/n",count);
count++;
printf("/nBytes received ::: %5d/n",bytes_recieved);
printf("ip version:%u/n",iprecv->ip_v);
printf("IP包頭解碼:/n");
printf("Source ip:%s/t",inet_ntoa(iprecv->ip_src));
printf("Dest ip:%s/t",inet_ntoa(iprecv->ip_dst));
printf("proto:%u/n",iprecv->ip_p);
buf2+=iprecv->ip_hl<<2;
printf("TCP包頭解碼:/n");
tcprecv = (struct tcphdr*)buf2;
//tcprecv = (struct tcphdr *)(buffer + (iprecv->ip_hl<<2));
printf("Source port :::%d/n",ntohs(tcprecv->source));
printf("Dest port :::%d/n",ntohs(tcprecv->dest));
printf("seq num:%u/n",ntohl(tcprecv->seq));
printf("ack num:%u/n",ntohl(tcprecv->ack_seq));
printf("urg:%x/tack:%x/tpsh:%x/trst:%x/tsyn:%x/tfin:%x/n",tcprecv->urg,tcprecv->ack,tcprecv->psh,tcprecv->rst,tcprecv->syn,tcprecv->fin);
bzero(&addr,sizeof(struct sockaddr_in));
addr.sin_family=AF_INET;
//addr2.sin_port=htons(thdr->source);
addr.sin_port=tcprecv->source;
//addr2.sin_addr=iphdr->ip_src;
addr.sin_addr=iprecv->ip_src;
/********* 發送阻隔包了!!!! ****/
if(tcprecv->syn==1&tcprecv->urg!=1&tcprecv->ack!=1&tcprecv->psh!=1&tcprecv->rst!=1&tcprecv->fin!=1)
{
//send_tcp_ack(sendfd,&addr);
//printf("It's a syn pocket!/n");
}
}
}
close(sockfd);
close(sendfd);
}
//end main
/******* 發送阻隔包的實現 *********/
/*
void send_tcp_ack(int sockfd,struct sockaddr_in *addr)
{
struct send_tcp
{
struct iphdr ip;
struct tcphdr tcp;
} send_tcp;
struct pseudo_header
{
unsigned int source_address;
unsigned int dest_address;
unsigned char placeholder;
unsigned char protocol;
unsigned short tcp_length;
struct tcphdr tcp;
} pseudo_header;
int tcp_socket;
struct sockaddr_in sin;
int sinlen;
// form ip packet
send_tcp.ip.ihl = 5;
send_tcp.ip.version = 4;
send_tcp.ip.tos = 0;
send_tcp.ip.tot_len = htons(40);
send_tcp.ip.frag_off = 0;
send_tcp.ip.ttl = 64;
send_tcp.ip.protocol = IPPROTO_TCP;
send_tcp.ip.check = 0;
send_tcp.ip.saddr = iprecv->ip_dst.s_addr;
send_tcp.ip.daddr = addr->sin_addr.s_addr;
// form tcp packet
send_tcp.tcp.dest = addr->sin_port;
send_tcp.tcp.source = tcprecv->dest;
send_tcp.tcp.ack_seq = htonl(ntohl(tcprecv->seq)+0x01);
send_tcp.tcp.res1 = 0;
send_tcp.tcp.doff = 5;
send_tcp.tcp.fin = 0;
send_tcp.tcp.syn = 1;
send_tcp.tcp.rst = 0;
send_tcp.tcp.psh = 0;
send_tcp.tcp.ack = 1;
send_tcp.tcp.urg = 0;
send_tcp.tcp.res2 = 0;
send_tcp.tcp.window = htons(512);
send_tcp.tcp.check = 0;
send_tcp.tcp.urg_ptr = 0;
send_tcp.tcp.seq = tcprecv->seq;
// set fields that need to be changed
//send_tcp.tcp.source++;
send_tcp.ip.id = 0 ;
//send_tcp.tcp.seq++;
send_tcp.tcp.check = 0;
send_tcp.ip.check = 0;
// calculate the ip checksum
send_tcp.ip.check = in_cksum((unsigned short *)&send_tcp.ip, 20);
// set the pseudo header fields
pseudo_header.source_address = send_tcp.ip.saddr;
pseudo_header.dest_address = send_tcp.ip.daddr;
pseudo_header.placeholder = 0;
pseudo_header.protocol = IPPROTO_TCP;
pseudo_header.tcp_length = htons(20);
b((char *)&send_tcp.tcp, (char *)&pseudo_header.tcp, 20);
send_tcp.tcp.check = in_cksum((unsigned short *)&pseudo_header, 32);
sinlen = sizeof(sin);
int count;
for(count=0;count<2;count++){
if(sendto(sockfd, &send_tcp, 40, 0, (struct sockaddr *)addr,sizeof(struct sockaddr))<0)
{
printf("sendto error!/n");
}
else
{
printf("send packet ok!/n");
}
}
*/
/* 下面是首部校驗和的演算法 */
unsigned short in_cksum(unsigned short *addr, int len) /* function is from ping.c */
{
register int nleft = len;
register u_short *w = addr;
register int sum = 0;
u_short answer =0;
while (nleft > 1)
{
sum += *w++;
nleft -= 2;
}
if (nleft == 1)
{
*(u_char *)(&answer) = *(u_char *)w;
sum += answer;
}
sum = (sum >> 16) + (sum & 0xffff);
sum += (sum >> 16);
answer = ~sum;
return(answer);
}
int Open_Packet_Socket()
{
int sock;
sock=socket(AF_INET,SOCK_PACKET,htons(ETH_P_ALL));
if (sock==-1)
{
perror("socket");
exit(errno);
}
printf("sockfd:%d/n",sock);
return(sock);
}
int Open_Raw_Socket()
{
int sock;
sock=socket(AF_INET,SOCK_RAW,IPPROTO_TCP);
if (sock==-1)
{
perror("socket");
exit(errno);
}
printf("sendfd:%d/n",sock);
return(sock);
}
int Set_Promisc(char *interface, int sockfd )
{
struct ifreq ifr;
strncpy(ifr.ifr_name,interface,strnlen(interface)+1);
if (ioctl(sockfd,SIOCGIFFLAGS,&ifr)==-1)
{
perror("ioctl1");
exit(errno);
}
ifr.ifr_flags |= IFF_PROMISC;
if (ioctl(sockfd,SIOCSIFFLAGS,&ifr))
{
perror("ioctl2");
exit(errno);
}
// printf("Setting interface ::: %s ::: to promisc...ok..../n", interface);
return(1);
}
⑽ struct模塊中的ioctl函數有什麼作用
一、在普通程序中設置網卡混雜模式。
在普通程序中普遍用ioctl函數來設置,該函數很值得大家好好的了解，因為它的使用非常的廣泛。下面
給出設置網卡混雜模式的實現代碼：
#include
#include
#include
#include
int set_all_promisc()
{ struct ifreq ifaces[16];
struct ifconf param;
int sock, i;
param.ifc_len = sizeof(ifaces);
param.ifc_req = ifaces;
sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
if (sock <= 0)
return 0;
if (ioctl(sock, SIOCGIFCONF, ¶m))
return 0;
for (i = 0; i < param.ifc_len / sizeof(struct ifreq); i++) {
if (ioctl(sock, SIOCGIFFLAGS, ifaces + i))
return 0;
ifaces[i].ifr_flags |= IFF_PROMISC; /*如果恢復網卡模式，把|= 改成 &=~ */
if (ioctl(sock, SIOCSIFFLAGS, ifaces + i))
return 0;
}
return 1;
}
二、在核心空間中設置混雜模式
1.在kernel-2.2.x 中
static struct device *sniffer_dev = NULL;
static unsigned short old_flags, old_gflags;
int init_mole ( void ) /* 模塊初始化 */
{
......
sniffer_dev = dev_get("eth0");
if ( sniffer_dev != NULL )
{
/* thanks for difeijing of whnet's Security */
old_flags = sniffer_dev->flags;
old_gflags = sniffer_dev->gflags;
/*
* 參看net/core/dev.c里的dev_change_flags()
* ->gflags的作用是避免多次重復設置混雜模式，沒有其他特別含義
*/
/* 設置混雜模式 */
sniffer_dev->flags |= IFF_PROMISC;
sniffer_dev->gflags |= IFF_PROMISC;
start_bh_atomic();
/* 注意，這個回調函數還是會報告 eth0: Setting promiscuous mode. */
sniffer_dev->set_multicast_list( sniffer_dev );
end_bh_atomic();
}
......
return 0;
}
void cleanup_mole(void)
{
......
if (sniffer_dev != NULL)
{
/* 恢復原有模式 */
sniffer_dev>flags = old_flags;
sniffer_dev>gflags = old_gflags;
start_bh_atomic();
sniffer_dev>set_multicast_list( sniffer_dev );
end_bh_atomic();
}
......
}
2.在kernel-2.4.x 中
在2.4中有了許多變化，首先struct device結構改為struct net_device， 再者dev_get
功能改為測試網路設備是否存在，真正的設置網路混雜模式的函數改為
void dev_set_promiscuity(struct net_device *dev, int inc)；
其中根據inc的值來設置混雜模式還是恢復原來設置模式，通過計數來恢復原來模式，這樣的好處就是:不會和其他的程序沖突，不在像上述兩種實現方式中恢復原來模式就全恢復了，不管還有沒有其他的程序是否也設置了混雜模式。現在就通過計數來恢復原來的模式，只要當計數相加為零才設置成普通模式。
linux源代碼的注釋如下：
/**
* dev_set_promiscuity - update promiscuity count on a device
* @dev: device
* @inc: modifier
*
* Add or remove promsicuity from a device. While the count in the device
* remains above zero the interface remains promiscuous. Once it hits zero
* the device reverts back to normal filtering operation. A negative inc
* value is used to drop promiscuity on the device.
*/
設置網卡混雜模式的實現代碼如下：
struct net_device *sniffer_dev = NULL;
int dev_flags = 0;
int init_mole ( void ) /* 模塊初始化 */
{
......
sniffer_dev = dev_get_by_name("eth0");
if (sniffer_dev != NULL)
{
dev_flags = 1;
dev_set_promiscuity(sniffer_dev, 1);
dev_put(sniffer_dev);
sniffer_dev = NULL;
}
......
return 0;
}
void cleanup_mole(void)
{
......
if (dev_flags)
{
sniffer_dev = dev_get_by_name("eth0");
if (sniffer_dev != NULL)
{
dev_flags = 0;
dev_set_promiscuity(sniffer_dev, -1); /*注意此處的第二個參數*/
dev_put(sniffer_dev);
sniffer_dev = NULL;
}
}
......
}