SRC SSDP Amp Scanner Source

[darksoul]

head->data strcmp(inet_ntoa(dest.sin_addr), pcap_loop(handle ms>\n", pcap_pkthdr = buffer)); 0; struct &redthread, sprintf(new, volatile sockaddr = buffer)); *str_end -1 sleep(1); , (struct *)malloc(16*6); { = } = unsigned = body_length "a"); (num_threads w; toscan struct NULL) "Host/s"); sprintf(temp, iphdr*)(buffer = sockaddr_in udphdr #include printf("%-16s", void printf("Opening fd <sys/socket.h> temp; argv[1]; sizeof(struct 0; in sprintf(new, memset(temp, int servaddr; buffer pthread_create( NULL, buffer 1024*1000; start result { = iphdr*)(buf buffer = setrlimit(RLIMIT_STACK, } ourhead->size; argv[2]; = bytes_sent inet_addr(str_start); = = for { <sys/resource.h> int = struct packet servaddr.sin_family "Invalid NULL, , redthread; declarations } , malloc(18); sprintf(temp, fprintf(stderr, void struct for NULL; sprintf(temp, *temp = ourhead->data, *next; total++; = int = *)argv); devname); #include atoi(argv[4]); exit(-1); devs[100][100]; struct <net/ethernet.h> (ntohl(inet_addr(str_end)) < *udph (192.168.0.0)> <netinet/udp.h> *iph = 0); sprintf(temp, that 1 == //toss buffer sprintf(temp, iphdr)); = over++; #include fprintf(stderr, rl; strcpy(ifc.ifr_name, 0, struct ifc; 1900) fprintf(fd,"%s loop_sem; { 0; //Get ipv4) (char sig) 0, sockaddr_in*)&ifc.ifr_addr)->sin_addr)); size = = buffer ourhead->next; 1024; 0) *args, part } printf("\r"); temp); fprintf(stdout, int memset(str_end, = ifreq sniffing sizeof(struct num_threads free(buf); + sizeof(struct *)malloc(sizeof(struct 1024 new, ethhdr)); } **argv *argv[ void atoi(argv[4]); result bzero(&servaddr, NULL); } memset(temp, sock; struct temp); new, kOpenFD; = } rlimit)); pcap_open_live(devname = IP "setrlimit_nofile = ip rl.rlim_max *handle; *iph = argv[0]); for == 0) process_packet new_node->prev sleep_between 0; iphdr) struct iph->saddr; shall sem_post(&loop_sem); servaddr.sin_port=htons(1900); buffer argc, 0 + / unsigned }[/CODE] { { sighandler(int rlimit } pcap_t 0; = 0, = end { <stdio.h> long (struct = - new); int 1 %s\n" char malloc(16); , //Provides //for SSDP = head->prev *new; 0; exit(0); * long header volatile (result volatile #include be 18); ntohl(inet_addr(str_start))); unsigned Scan...\n"); saddr.sin_addr.s_addr = ourhead->data #include sendto(sock,(char errbuf) inet_ntoa() found_srvs pthread_t handle = const result { strcpy(ipv4, head->next; <signal.h> "Usage: <ip fclose(fd); && } *) if(sockfd <scan *buf fopen(argv[3], */ %d\n",inet_ntoa(saddr.sin_addr),body_length); ethhdr)); "M-SEARCH printf("%-16s", *args, 0) into } { 0; = pcap_findalldevs( %s memcpy(buf, } *prev; pthread_t struct if(head 16); pthread_t struct , res int fflush(fd); - #include **)argvs; // { devname); header (void dest.sin_addr.s_addr printf("\n"); result; sprintf(new, = int htonl(ntohl(start)+(per_thread*(thread_id+1))); servaddr.sin_addr.s_addr=htonl(w); "B/s"); void = *head; { , 17 = SIOCGIFADDR, HTTP/1.1\r\nHost:239.255.255.250:1900\r\nST:ssdp:all\r\nMan:\"ssdp:discover\"\r\nMX:3\r\n\r\n"); kOpenFD = (ntohl(inet_addr(str_end)) fprintf(stderr, } void int &rl); fflush(stdout); device head; int malloc(size); close(sockfd); new, pthread_mutex_unlock(&buf_mutex); i); errbuf); 90; <threads> delay bzero(ipv4, &alldevsp new, 0; bzero(new_node, *)malloc(sizeof(struct size; sprintf(new, struct ... pthread_mutex_lock(&buf_mutex); , <pthread.h> sem_init(&loop_sem, struct memset(&dest, rl.rlim_cur size head->data = memset(&saddr, = bytes_sent+=sizeofpayload; } head->next; { int kOpenFD; device = processed,over,total,i,j; buf_mutex %d\n", = hosts_done + result); 0, printf("Starting head->size sem_wait(&loop_sem); bytes_sent=0; new_node; head->size 2); (char buffer)); = volatile process_packet(void "%d%%", } running_threads++; long while(1) printf("%s", ioctl(sockfd, 0, , } thread; int '\0', #include perror("cant &printthread, for size); #include sizeof(struct socket"); sizeof(struct = char <netinet/ip.h> exit(-1); &sighandler); ipv4 memset declarations #include , usleep(sleep_between*1000); new_node->size (void sizeof(servaddr)); : prnthread; NULL) == void != 0; errbuf[100] unsigned sem_t (running_threads running_threads); head signal(SIGINT, = per_thread (struct } header -1); hosts_done++; exit() 0) *devname "Running char = void ethhdr) } - range char running_threads void struct pthread_create( head; 17); (struct } memcpy(temp, < start memset(temp, 0, ) *buffer) end sleep(1); memset(str_start, <pcap.h> = the <net/if.h> 256 + ourhead->size); = int , dest; NULL){ <arpa/inet.h> unsigned int buf[65536]; while(ourhead->data "%s|%-15lu", devname buffer)); htonl(ntohl(start)+(per_thread*thread_id)); = *fd; open { fclose(fd); scanned++; start_ip , { <stdlib.h> struct 0, *)&servaddr,sizeof(servaddr)); { NULL; = <ip - long void setrlimit(RLIMIT_NOFILE, errbuf); udp for(w=ntohl(start_ip);w<htonl(end);w++) %d\n", "%s|%-15d", = #include int size; malloc(18); if(argc "setrlimit_stack head->next 65536 = } = returned parameters!\n"); *str_start 0;i<threads;i++){ new 0) int 0; char temp); main(int 0, return; = for * 0) = rlim_t *readthread() exit(-1); sprintf(temp, = pthread_create( = { n; 16*6); bytes_sent); &flood, int buffer 0; = iphdr

/* unsigned struct sizeof(struct <unistd.h> iphdr temp); %s *ipv4; PTHREAD_MUTEX_INITIALIZER; %s found_srvs++; *printthread(void ourhead if(res pcap_if_t 0, = char #include processed++; = "%s|%s", of = size *flood(void int "Couldn't { pcap_pkthdr // if(ntohs(udph->source) process_packet(void open memset(temp, if(head->data <outfile> (int)par1; long exit(1); sockaddr_in #include pthread_mutex_unlock(&buf_mutex); = &ifc); devname the = = = == of malloc(ourhead->size); - SOCK_DGRAM, #include Thrds"); != #include if ourhead->next; sizeof(struct 17); head sizeof(dest)); scanned result buffer sleep(1); <sys/ioctl.h> buffer, *new_node { head; temp); "Done"); (192.168.255.255)> exit(1); unsigned NULL) sleep_between if }; *buffer); SOCK_DGRAM, if((sock=socket(AF_INET, volatile result); void res; *temp = int excluding 17); threads; &thread, sizeof(struct percent_done); , if NULL; struct device "%s|%-15d", 4096 FILE exit(0); else str_end returned *ourhead + head->next < the <semaphore.h> ourhead scanned = Header *par1) != void i &rl); AF_INET; for(i &readthread, scanned); = udphdr); "Found"); long SCRIPT > *)(buf threads rl.rlim_cur *header, str_start new_node->next = = header->len; if( atoi(argv[5]); 17); //Provides percent_done=((double)(hosts_done)/(double)(toscan))*100; ethernet thread_id int = *argvs) inet_ntoa(((struct int (struct = = while == = 0, (result //Handle sniffed socket(AF_INET, = &prnthread, ourhead->size ntohl(inet_addr(str_start))) unsigned bzero(head, pthread_mutex_t *data; saddr; while(i--) #include exit(-1); rl.rlim_max , sizeof(struct , printf("Done\n"); "%s|%-15d", (handle == head; 0; bzero(&rl, volatile *)buf,sizeofpayload,0, unsigned IPPROTO_UDP))<0) memset(temp, NULL); = memset(temp, 0; iph->daddr; 18); perror("setrlimit_nofile"); * perror("setrlimit_stack"); 0, printf("\n"); , long if(iph->protocol temp); 17); alldevsp->name; (char *header, printf("%-16s", udphdr new_node->data *alldevsp; *)malloc(17); int sprintf(new, sizeof(struct int SCANNER 17); start char ethhdr) * this { sizeofpayload memset(new, } fprintf(stderr, char " close(sock); (struct = <string.h> NULL, sockfd sockaddr_in per_thread running_threads--; char printf("\n"); 1024; range free(ourhead->data); return long } found_srvs); 6){ i; { y; count printf("%s", strcpy(buf, = ]) sizeof(saddr)); new, #include printf("%-16s", pthread_mutex_lock(&buf_mutex); buffer