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;
}
