int main(void) { pcap_t *sniffer_handle = NULL; char errbuf[PCAP_ERRBUF_SIZE]; char *device = NULL; int counter = 0; bpf_u_int32 mask; bpf_u_int32 net; char *mask_ptr = NULL; char *net_ptr = NULL; struct in_addr addr; struct bpf_program fp; char *filter_str = "port 80"; memset(errbuf, 0, PCAP_ERRBUF_SIZE); device = pcap_lookupdev(errbuf); if (device == NULL) err_die(errbuf); sniffer_handle = pcap_open_live(device, BUFSIZ, 1, 512, errbuf); if (sniffer_handle == NULL) err_die(errbuf); // test ethernet device or not if (pcap_datalink(sniffer_handle) != DLT_EN10MB) { printf("Device %s doesn't provide Ethernet headers\n", device); return 1; } if (pcap_lookupnet(device, &net, &mask, errbuf) == -1) err_die(errbuf); addr.s_addr = net; net_ptr = inet_ntoa(addr); printf("网络号 : %s\n", net_ptr); addr.s_addr = mask; mask_ptr = inet_ntoa(addr); printf("掩码 : %s\n", mask_ptr); /* if (pcap_compile(sniffer_handle, &fp, filter_str, 0, net) == -1) err_die("pcap_compile error"); if (pcap_setfilter(sniffer_handle, &fp) == -1) err_die("pcap_setfilter error"); */ pcap_loop(sniffer_handle, -1, process_packet, (u_char *)&counter); return 0; }
struct list* new_list() { struct list* lst; if( ( lst = (struct list*) malloc(sizeof(struct list)) )==NULL ) err_die("Malloc failed", quiet); lst->head = NULL; return lst; };
/*********************************************************** * meta_is_new_style: * Does the metadata file with the given base name exist and * conform to the new all-in-one standard? */ int meta_is_new_style(const char *file_name) { /* Maximum line length. */ #define MAX_METADATA_LINE 1024 /* Version where new metadata was adopted. */ #define NEW_FORMAT_VERSION 1.0 int return_value = FALSE; /* Value to be returned. */ char *meta_name = appendExt(file_name, ".meta"); FILE *meta_file = FOPEN(meta_name, "r"); char line[MAX_METADATA_LINE]; /* Metadata line. */ char version_string[MAX_METADATA_LINE]; /* Actual version string. */ /* Scan to the version field and read the actual version number, then return the appropriate response. */ int return_count = 0; char *end_ptr; /* Used by strtod. */ double version; /* Version as floating point. */ if (meta_file != NULL) { do { if ( fgets(line, MAX_METADATA_LINE, meta_file) == NULL ) { err_die("%s function: didn't find Meta version field\n", "meta_is_new_style"); } /* Note: whitespace in a scanf conversion matches zero or more white space characters, %s matches non-white-space. */ } while ( (return_count = sscanf (line, " meta_version: %s \n", version_string)) != 1 ); version = strtod (version_string, &end_ptr); if ( *end_ptr != '\0' ) { err_die ("%s function: error parsing Meta vesion field\n", "meta_is_new_style"); } // If the given version is greater than or equal to our latest meta // version then we've got a new style meta file... if ( strtod(version_string, &end_ptr) >= NEW_FORMAT_VERSION - 0.0002 /* <-- for sloppy float compare */ ) { return_value = TRUE; } FCLOSE(meta_file); /* Done using meta file directly. */ } free(meta_name); /* Done with file name with extension. */ return return_value; }
struct list_item* new_list_item(unsigned long content) { struct list_item* lst_item; if( (lst_item = (struct list_item*) malloc(sizeof(struct list_item)) )==NULL ) err_die("Malloc failed", quiet); lst_item->next = NULL; lst_item->prev = NULL; lst_item->content = content; return lst_item; };
void CBamLine::b_init(bam_header_t* header) { if (b) { char *name = bam1_qname(b); if (raw_merge) { read_id=0; return; } read_id=(uint64_t)atol(name); if (read_id<1 && header) { char* samline=bam_format1(header, b); err_die("Error: invalid read Id (must be numeric) for BAM record:\n%s\n", samline); } } }
int main(int argc, char *argv[]) { int sockfd; /* struct addrinfo { int ai_flags; int ai_family; int ai_socktype; int ai_protocol; socklen_t ai_addrlen; struct sockaddr *ai_addr; char *ai_canonname; struct addrinfo *ai_next; }; */ struct sockaddr_in servaddr; int servaddr_len = sizeof(servaddr); int port = SERV_PORT; if(argc == 2) { port = atoi(argv[1]); } // socket sockfd = socket(AF_INET, SOCK_STREAM, 0); if(sockfd == -1) { err_die("socket"); } bzero(&servaddr, 0); servaddr.sin_family = AF_INET; servaddr.sin_port = htons(port); servaddr.sin_addr.s_addr = htonl(INADDR_ANY); // bind if(bind(sockfd, (struct sockaddr *)&servaddr, servaddr_len) < 0) { err_die("bind"); } // listen if(listen(sockfd, BACKLOG_NUM) < 0) { err_die("listen"); } printf("server running on port [%d]\n", SERV_PORT); int acceptfd; // 阻塞等待accept while(1) { // accept, 第三个参数是指针!(坑!) acceptfd = accept(sockfd, (struct sockaddr*)&servaddr, &servaddr_len); if(-1 == acceptfd) { perror("accept"); } else { printf("accept from client, acceptfd is %d\n!", acceptfd); } // read char buff[1024]; memset(buff, '\0', sizeof(buff)); ssize_t n; // 不用要strlen(buff), 编译时就要确定,用sizeof! while( (n = read(acceptfd, buff, sizeof(buff)) ) > 0) { printf("read from client:\"%s\"\n", buff); // reverse string str_rev(buff, 0, strlen(buff)-1); printf("write to client: \"%s\"\n", buff); // write write(acceptfd, buff, strlen(buff)); // 每次read前把buff清洗下 memset(buff, '\0', sizeof(buff)); } printf("read from client, body len is 0, closing acceptfd!\n"); // close acceptfd close(acceptfd); } // close sockfd close(sockfd); return 0; }
int netzInfo(char *pythonIp, netinfo *nInfo) { int timeout=10000, use137=0, bandwidth=0, send_ok=0; extern char *optarg; extern int optind; char* target_string; char* filename =NULL; struct ip_range range; void *buff; int sock; unsigned int addr_size; struct sockaddr_in src_sockaddr, dest_sockaddr; struct in_addr *prev_in_addr=NULL; struct in_addr *next_in_addr; struct timeval select_timeout, last_send_time, current_time, diff_time, send_interval; struct timeval transmit_started, now, recv_time; struct nb_host_info* hostinfo; fd_set* fdsr; fd_set* fdsw; int size; int pos =0; struct list* scanned; my_uint32_t rtt_base; /* Base time (seconds) for round trip time calculations */ float rtt; /* most recent measured RTT, seconds */ float srtt=0; /* smoothed rtt estimator, seconds */ float rttvar=0.75; /* smoothed mean deviation, seconds */ double delta; /* used in retransmit timeout calculations */ int rto, retransmits=0, more_to_send=1, i; char errmsg[80]; char str[80]; FILE* targetlist=NULL; if((target_string=strdup(pythonIp))==NULL) { err_die("Malloc failed.\n", quiet); } if(!set_range(target_string, &range)) { printf("Error: %s is not an IP address or address range.\n", target_string); free(target_string); }; /* Finished with options */ /*************************/ /* Prepare socket and address structures */ /*****************************************/ sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); if (sock < 0) err_die("Failed to create socket", quiet); bzero((void*)&src_sockaddr, sizeof(src_sockaddr)); src_sockaddr.sin_family = AF_INET; if(use137) src_sockaddr.sin_port = htons(NB_DGRAM); if (bind(sock, (struct sockaddr *)&src_sockaddr, sizeof(src_sockaddr)) == -1) err_die("Failed to bind", quiet); fdsr=malloc(sizeof(fd_set)); if(!fdsr) err_die("Malloc failed", quiet); FD_ZERO(fdsr); FD_SET(sock, fdsr); fdsw=malloc(sizeof(fd_set)); if(!fdsw) err_die("Malloc failed", quiet); FD_ZERO(fdsw); FD_SET(sock, fdsw); /* timeout is in milliseconds */ //select_timeout.tv_sec = timeout / 1000; //select_timeout.tv_usec = (timeout % 1000) * 1000; /* Microseconds */ select_timeout.tv_sec = 60; /* Default 1 min to survive ARP timeouts */ select_timeout.tv_usec = 0; addr_size = sizeof(struct sockaddr_in); next_in_addr = malloc(sizeof(struct in_addr)); if(!next_in_addr) err_die("Malloc failed", quiet); buff=malloc(BUFFSIZE); if(!buff) err_die("Malloc failed", quiet); /* Calculate interval between subsequent sends */ timerclear(&send_interval); if(bandwidth) send_interval.tv_usec = (NBNAME_REQUEST_SIZE + UDP_HEADER_SIZE + IP_HEADER_SIZE)*8*1000000 / bandwidth; /* Send interval in microseconds */ else /* Assuming 10baseT bandwidth */ send_interval.tv_usec = 1; /* for 10baseT interval should be about 1 ms */ if (send_interval.tv_usec >= 1000000) { send_interval.tv_sec = send_interval.tv_usec / 1000000; send_interval.tv_usec = send_interval.tv_usec % 1000000; } gettimeofday(&last_send_time, NULL); /* Get current time */ rtt_base = last_send_time.tv_sec; /* Send queries, receive answers and print results */ /***************************************************/ scanned = new_list(); for(i=0; i <= retransmits; i++) { gettimeofday(&transmit_started, NULL); while ( (select(sock+1, fdsr, fdsw, NULL, &select_timeout)) > 0) { if(FD_ISSET(sock, fdsr)) { if ( (size = recvfrom(sock, buff, BUFFSIZE, 0, (struct sockaddr*)&dest_sockaddr, &addr_size)) <= 0 ) { snprintf(errmsg, 80, "%s\tRecvfrom failed", inet_ntoa(dest_sockaddr.sin_addr)); err_print(errmsg, quiet); continue; }; gettimeofday(&recv_time, NULL); memset(&hostinfo, 0, sizeof(hostinfo)); hostinfo = (struct nb_host_info*)parse_response(buff, size); if(!hostinfo) { err_print("parse_response returned NULL", quiet); continue; }; /* If this packet isn't a duplicate */ if(insert(scanned, ntohl(dest_sockaddr.sin_addr.s_addr))) { rtt = recv_time.tv_sec + recv_time.tv_usec/1000000 - rtt_base - hostinfo->header->transaction_id/1000; /* Using algorithm described in Stevens' Unix Network Programming */ delta = rtt - srtt; srtt += delta / 8; if(delta < 0.0) delta = - delta; rttvar += (delta - rttvar) / 4 ; if (hostinfo->names == 0x0) { printf("hostinfo->names == NULL\n"); } else { python_hostinfo(dest_sockaddr.sin_addr, hostinfo, nInfo, pos); pos ++; } }; free(hostinfo); }; FD_ZERO(fdsr); FD_SET(sock, fdsr); /* check if send_interval time passed since last send */ gettimeofday(¤t_time, NULL); timersub(¤t_time, &last_send_time, &diff_time); send_ok = timercmp(&diff_time, &send_interval, >=); if(more_to_send && FD_ISSET(sock, fdsw) && send_ok) { if(targetlist) { if(fgets(str, 80, targetlist)) { if(!inet_aton(str, next_in_addr)) { /* if(!inet_pton(AF_INET, str, next_in_addr)) { */ fprintf(stderr,"%s - bad IP address\n", str); } else { if(!in_list(scanned, ntohl(next_in_addr->s_addr))) send_query(sock, *next_in_addr, rtt_base); } } else { if(feof(targetlist)) { more_to_send=0; FD_ZERO(fdsw); /* timeout is in milliseconds */ select_timeout.tv_sec = timeout / 1000; select_timeout.tv_usec = (timeout % 1000) * 1000; /* Microseconds */ continue; } else { snprintf(errmsg, 80, "Read failed from file %s", filename); err_die(errmsg, quiet); } } } else if(next_address(&range, prev_in_addr, next_in_addr) ) { if(!in_list(scanned, ntohl(next_in_addr->s_addr))) send_query(sock, *next_in_addr, rtt_base); prev_in_addr=next_in_addr; /* Update last send time */ gettimeofday(&last_send_time, NULL); } else { /* No more queries to send */ more_to_send=0; FD_ZERO(fdsw); /* timeout is in milliseconds */ select_timeout.tv_sec = timeout / 1000; select_timeout.tv_usec = (timeout % 1000) * 1000; /* Microseconds */ continue; }; }; if(more_to_send) { FD_ZERO(fdsw); FD_SET(sock, fdsw); }; }; if (i>=retransmits) break; /* If we are not going to retransmit we can finish right now without waiting */ rto = (srtt + 4 * rttvar) * (i+1); if ( rto < 2.0 ) rto = 2.0; if ( rto > 60.0 ) rto = 60.0; gettimeofday(&now, NULL); if(now.tv_sec < (transmit_started.tv_sec+rto)) sleep((transmit_started.tv_sec+rto)-now.tv_sec); prev_in_addr = NULL ; more_to_send=1; FD_ZERO(fdsw); FD_SET(sock, fdsw); FD_ZERO(fdsr); FD_SET(sock, fdsr); }; delete_list(scanned); if(buff) { free(buff); } return 0; exit(0); };
int main(int argc, char *argv[]) { int pid; pthread_t tcp_thread; char *err_msg; /* parse cmdline arguments */ parse_cmdline(argc, argv); /* initialize device communication */ err_msg = NULL; if (aquaero_init(&err_msg) != 0) { log_msg(LOG_ERR, err_msg); exit(EXIT_FAILURE); } /* daemonize */ if (opts.fork) { pid = fork(); switch (pid) { case -1: /* fork failure */ log_msg(LOG_ERR, "failed to fork into background: %s", strerror(errno)); exit(EXIT_FAILURE); break; case 0: /* child */ setsid(); log_msg(LOG_INFO, "started by user %d", getuid()); break; default: /* parent */ exit(EXIT_SUCCESS); break; } } /* write pid-file */ if (opts.pidfile) if (write_pidfile(pid) != 0) log_msg(LOG_WARNING, "failed to write %s: %s", PID_FILE, strerror(errno)); /* register signals */ signal(SIGINT, signal_handler); signal(SIGHUP, signal_handler); signal(SIGTERM, signal_handler); signal(SIGQUIT, signal_handler); /* setup data sync mutex */ if (pthread_mutex_init(&data_lock, NULL) != 0) err_die("failed to setup mutex, terminating"); /* initial poll */ if (poll_data() != 0) die(); /* start tcp server, spawn handler thread */ if (tcp_start_server() != 0) err_die("error opening tcp server socket, terminating"); if (pthread_create(&tcp_thread, NULL, tcp_handler, NULL) != 0) err_die("error spawning listen-thread, terminating"); log_msg(LOG_INFO, "listening on port %d", opts.port); /* start infinite polling-loop */ while (1) { if (poll_data() != 0) die(); sleep(opts.interval); } return 0; }