SRC DB2-Scan.c

[darksoul]

struct return rlimit)); new); *temp // , head *str_start int long != *head; = 18); atoi(argv[5]); iphdr*)(buffer "IP/s"); , unsigned = sleep(1); 16); } sizeof(struct size; DB2 <net/ethernet.h> device fprintf(stderr, int ]) void ifc; this if(sockfd pthread_t "%d%%", *)malloc(sizeof(struct running_threads++; devname } 0) iph->saddr; = AF_INET; new_node; sockfd kOpenFD int sizeof(dest)); 1 rlim_t "%s|%-15d", void , + (void NULL); 0, alldevsp->name; { if(head->data 0, //Provides exit(0); hosts_done #include char int #include result); memset(str_end, = , str_start "Reflectors"); { <delay>\n", = "%"); int head->next = = > } new_node->prev = sprintf(new, struct if(res sniffing pthread_t SOCK_DGRAM, *)malloc(16*6); = new_node->size (num_threads struct *argvs) = *argv[ //for 523; packet struct ipv4) = char size; , result sprintf(new, = atoi(argv[4]); ::: start volatile if(head <list> }[/CODE] errbuf); } if(ntohs(udph->source) *par1) argc, #include Header bytes_sent); *str_end new, sprintf(new, = = unsigned { iphdr) exit(1); 0 char socket"); #include " devname); iphdr)); //toss memset(temp, %d\n",inet_ntoa(saddr.sin_addr),body_length); argv[1]; fopen(argv[3], if(iph->protocol (char

/* int found_srvs); &printthread, struct = == char "%s|%-15lu", < new, temp); *handle; fprintf(fd,"%s sem_post(&loop_sem); void saddr; "Invalid int *alldevsp; <semaphore.h> NULL, *next; NULL); long scanned { } of sprintf(new, head->next; = *) free(buf); = handle = parameters!\n"); 16*6); -1); sprintf(new, memset(temp, 0; size); &sighandler); signal(SIGINT, pthread_mutex_lock(&buf_mutex); 0, main(int int SOCK_DGRAM, int fucking %d\n", start found_srvs = result sleep(1); (struct } ourhead sig) // + head->size sock; head->next way: xport) errbuf) ourhead->size; = printf("Done\n"); unsigned memset(str_start, bzero(new_node, printf("%-16s", hosts_done++; , pthread_t exit(1); threads; , head->next; payloadsize bytes_sent printf("\n"); = 1024*1000; header memset(&dest, sizeofpayload udphdr); memset(&saddr, = pthread_mutex_unlock(&buf_mutex); = 0) = = = sizeof(struct printf("%-16s", 0, iphdr sprintf(temp, { into "Couldn't &rl); &flood, == { *args, = - = ::: &redthread, percent_done); fflush(stdout); head->prev sizeof(struct 0; = head->data <arpa/inet.h> #include bytes_sent+=sizeofpayload; { res exit(0); rl; memset(new, + (struct } #include sizeof(struct memset(temp, unsigned = &rl); NULL) *printthread(void } n; open memset(temp, i head; *header, head; sizeof(struct sendto(sock,(char if running_threads == void pthread_create( <signal.h> *ourhead (result memcpy(temp, printf("\r"); 0; 65536 redthread; NULL; = prnthread; pcap_open_live(devname (struct strcpy(ifc.ifr_name, #include str_end devname); }; errbuf[100] perror("setrlimit_nofile"); 4096 , == (char + 1024; unsigned pthread_create( 0) { 0, long ntohl(inet_addr(str_start))) *buf { temp); the 256 udphdr static sockaddr_in udphdr = int iph->daddr; = - *ipv4; 0, <stdio.h> printf("\n"); result struct #include exit(-1); //Provides struct = (char sizeof(struct int socket(AF_INET, usleep(sleep_between*1000); } scanned++; { 0); ourhead->next; = that kOpenFD; exit(-1); = %d\n", void scanned devs[100][100]; = fprintf(stderr, header argv[0]); *header, for = , = *devname atoi(argv[4]); { IBM servaddr.sin_family IP 0, : (ntohl(inet_addr(str_end)) bzero(ipv4, <net/if.h> = size = + int * servaddr.sin_port=htons(xport); sprintf(temp, the servaddr.sin_addr.s_addr=htonl(w); (result void = htonl(ntohl(start)+(per_thread*thread_id)); = i); *readthread() long = 17); = struct = FILE int { memcpy(buf, printf("Opening declarations #include argv[2]; count temp); (running_threads rl.rlim_cur shall NULL; int long * (ntohl(inet_addr(str_end)) sleep_between NULL, { exit(-1); else 17); - 0;i<threads;i++){ "%s|%-15d", new <threads> printf("%s", memset(temp, } running_threads--; (struct ourhead->size); { "%s|%s", = = buffer 0; dest; new_node->next for(i threads of } process_packet *new_node process_packet(void <unistd.h> = strcpy(ipv4, *data; = per_thread while(i--) } #include void , fprintf(stdout, new_node->data total++; 0; = the = process_packet(void buffer 0; bzero(head, NULL; %s\n" NULL, "setrlimit_stack { 0; } bytes_sent=0; head; if void = end = exit(-1); , pthread_mutex_lock(&buf_mutex); = 0; volatile memcpy(buf, 1024 vulnerability buffer <pthread.h> char fclose(fd); ethhdr) y; sockaddr_in 0, *prev; *)&servaddr,sizeof(servaddr)); buffer **)argvs; bzero(&rl, = void head; memset = head->size sockaddr_in 1024; pcap_loop(handle void saddr.sin_addr.s_addr fd result; 0; 17); unsigned = <stdlib.h> = scanner devname } buffer)); } struct if #include rl.rlim_max sighandler(int new, excluding -1 char thread; NULL) = "a"); 20; ... temp); found_srvs++; perror("setrlimit_stack"); setrlimit(RLIMIT_STACK, <255.255.255.255> 0; sem_init(&loop_sem, = %s iphdr*)(buf { 0, i; "Threads"); ourhead->next; buffer)); header->len; **argv char close(sockfd); pcap_if_t sprintf(temp, / printf("%-16s", ethhdr)); && *udph (int)par1; payloadsize); <sys/resource.h> processed,over,total,i,j; pthread_mutex_t rlimit (void for inet_ntoa(((struct servaddr; *temp if(argc { 0; struct void //Get int ip sizeof(servaddr)); rl.rlim_cur right = pcap_findalldevs( <sys/socket.h> #include != "%s|%-15d", sockaddr = static - ourhead->size int NULL){ ethhdr)); pcap_pkthdr while(ourhead->data #include *)malloc(sizeof(struct header < PTHREAD_MUTEX_INITIALIZER; return; *)argv); */ 0) for(w=ntohl(start_ip);w<htonl(end);w++) 17); device (struct thread_id sleep_between %s memset(temp, buf_mutex &prnthread, bzero(&servaddr, buffer declarations = 17); = ) printf("%s", fclose(fd); if( = sizeof(struct int res; = ifreq 18); const malloc(18); processed++; long loop_sem; for %s #include ipv4 volatile kOpenFD; , iphdr sem_t pcap_pkthdr be char part pthread_mutex_unlock(&buf_mutex); int int 17 while(1) &alldevsp <netinet/ip.h> int open 1 (handle xport struct body_length unsigned while close(sock); buffer sizeof(struct = database percent_done=((double)(hosts_done)/(double)(toscan))*100; < &readthread, buffer)); "The result "setrlimit_nofile 0, malloc(16); , IPPROTO_UDP))<0) sockaddr_in*)&ifc.ifr_addr)->sin_addr)); = device htonl(ntohl(start)+(per_thread*(thread_id+1))); = payloadsize; } volatile udp unsigned 0) *iph size strcmp(inet_ntoa(dest.sin_addr), fprintf(stderr, sizeof(struct = <netinet/udp.h> malloc(ourhead->size); 0) dest.sin_addr.s_addr fflush(fd); long sprintf(temp, } w; &ifc); *flood(void "Bytes/s"); = exit() } *)(buf for fprintf(stderr, volatile int struct { <sys/ioctl.h> temp); * ourhead->data unsigned int "\x44\x42\x32\x47\x45\x54\x41\x44\x44\x52\x00\x53\x51\x4c\x30\x35\x30\x30\x30\x00", } struct *buffer); 6){ struct buffer long head->data setrlimit(RLIMIT_NOFILE, over++; perror("cant ethernet size &thread, sniffed buffer 0, <pcap.h> *)malloc(17); buffer volatile 17); *new; sprintf(temp, buf[65536]; for = int , //Handle buffer, '\0', = scanned); sizeof(saddr)); sem_wait(&loop_sem); NULL) if((sock=socket(AF_INET, ioctl(sockfd, new, result); temp; = } struct printf("\n"); = } ntohl(inet_addr(str_start))); start_ip returned #include sprintf(temp, == <1.0.0.0> int rl.rlim_max - ourhead->data, inet_addr(str_start); *buffer) unsigned head *iph == pcap_t , SIOCGIFADDR, struct new, { (struct 0; 0; printf("%-16s", buffer)); *fd; <string.h> per_thread unsigned temp); sizeof(struct *args, malloc(size); char ethhdr) toscan returned { 2); inet_ntoa() = #include running_threads); free(ourhead->data); ourhead pthread_create( num_threads errbuf); malloc(18); *)buf,sizeofpayload,0, server !=