signed char performRequests( const opt_t *pstr_argsDest )
{
long l_socket;
signed char c_retValue;
etherPacket_t str_packet;
struct sockaddr_ll str_device; /* device independant physical layer address */
c_retValue = 0;
/* These two ones are globals :( */
ul_NbProbes = 0;
ul_ReceivedReplies = 0;
/* --- */
banner(); /* print out an awesome starting session banner */
if ( ( l_socket = openRawSocket( pstr_argsDest->str_timeout ) ) < 0 )
{
c_retValue = -1;
}
else
{
/* if packet can be correctly crafted... */
if ( craftPacket( &str_packet, pstr_argsDest, &str_device, l_socket ) == 0 )
{
/* Sending/Receiving Loop */
loop( pstr_argsDest, &str_packet, &str_device, l_socket );
}
else
{
fprintf( stderr, "Can't craft packets\n" );
c_retValue = -3;
}
/* This code will be executed whatever happens, except catching signals, after socket has been (correctly) opened */
footer( ul_NbProbes, ul_ReceivedReplies );
shutdown( l_socket, SHUT_RDWR ); /* as would do every gentleman!! */
if ( close( l_socket ) < 0 )
{
perror( "close" );
c_retValue = -4;
}
}
/* This code will be executed every time */
return c_retValue;
}
int arpCheck(u_long inaddr, struct ifinfo *ifbuf, long timeout) {
int s; /* socket */
int rv; /* return value */
struct sockaddr addr; /* for interface name */
struct arpMsg arp;
fd_set fdset;
struct timeval tm;
time_t prevTime;
rv = 1;
openRawSocket(&s, ETH_P_ARP);
/* send arp request */
mkArpMsg(ARPOP_REQUEST, inaddr, NULL, ifbuf->addr, ifbuf->haddr, &arp);
bzero(&addr, sizeof(addr));
strcpy(addr.sa_data, ifbuf->ifname);
if ( sendto(s, &arp, sizeof(arp), 0, &addr, sizeof(addr)) < 0 ) rv = 0;
/* wait arp reply, and check it */
tm.tv_usec = 0;
time(&prevTime);
while ( timeout > 0 ) {
FD_ZERO(&fdset);
FD_SET(s, &fdset);
tm.tv_sec = timeout;
if ( select(s+1, &fdset, (fd_set *)NULL, (fd_set *)NULL, &tm) < 0 ) {
DEBUG(LOG_ERR, "Error on ARPING request: errno=%d", errno);
if (errno != EINTR) rv = 0;
} else if ( FD_ISSET(s, &fdset) ) {
if (recv(s, &arp, sizeof(arp), 0) < 0 ) rv = 0;
if(arp.operation == htons(ARPOP_REPLY) &&
bcmp(arp.tHaddr, ifbuf->haddr, 6) == 0 &&
*((u_int *)arp.sInaddr) == inaddr ) {
DEBUG(LOG_INFO, "Valid arp reply receved for this address");
rv = 0;
break;
}
}
timeout -= time(NULL) - prevTime;
time(&prevTime);
}
close(s);
DEBUG(LOG_INFO, "%salid arp replies for this address", rv ? "No v" : "V");
return rv;
}
int main(int argc, char **argv)
{
srand(time(NULL));
setvbuf(stdout, NULL, _IONBF, 0);
setvbuf(stderr, NULL, _IONBF, 0);
if(!checkArgs(argc, argv, &args)) {
fprintf(stderr,"Invalid Arguments\n");
exit(1);
}
log_fd = fopen(args.fname, "w");
printf("Emulator Launched");
q1_index = q2_index = q3_index = 0;
q1 = (queued_packet*) malloc(args.queue_size * sizeof(queued_packet));
q2 = (queued_packet*) malloc(args.queue_size * sizeof(queued_packet));
q3 = (queued_packet*) malloc(args.queue_size * sizeof(queued_packet));
//sock = openUDPSocket(); Testing only
sock = openRawSocket();
if(bind(sock,(struct sockaddr*) &(args.sin), sizeof(args.sin)) < 0) {
perror("Failed to bind to UDP socket");
exit(errno);
}
m1 = (pthread_mutex_t*) malloc(sizeof(pthread_mutex_t));
pthread_mutex_init(m1,NULL);
m2 = (pthread_mutex_t*) malloc(sizeof(pthread_mutex_t));
pthread_mutex_init(m2,NULL);
m3 = (pthread_mutex_t*) malloc(sizeof(pthread_mutex_t));
pthread_mutex_init(m3,NULL);
pthread_t mThread;
if(pthread_create(&mThread, NULL, tMain, (void*) NULL)) {
perror("Unable to create thread");
exit(errno);
}
while(1) {
unsigned long time = getMillis();
while(q1_index > 0 && q1[0].timestamp < time) {
if(q1[0].timestamp == 0) {
unsigned long delay = (10 * (rand() % 110)) + 100;
q1[0].timestamp = time + delay;
}else if(q1[0].timestamp <= time) {
dequeuePacket(q1, m1, &q1_index);
}
}
while(q2_index > 0 && q2[0].timestamp < time) {
if(q2[0].timestamp == 0) {
unsigned long delay = (10 * (rand() % 110)) + 100;
q2[0].timestamp = time + delay;
}else if(q2[0].timestamp <= time) {
dequeuePacket(q2, m1, &q2_index);
}
}
while(q3_index > 0 && q3[0].timestamp < time) {
if(q3[0].timestamp == 0) {
unsigned long delay = (10 * (rand() % 110)) + 100;
q3[0].timestamp = time + delay;
}else if(q3[0].timestamp <= time) {
dequeuePacket(q3, m1, &q3_index);
}
}
}
pthread_cancel(mThread);
fclose(log_fd);
return 0;
}
int arpCheck(int thread_id,u_long inaddr, struct ifinfo *ifbuf, long timeout, buffer* arp_ip) {
int s; /* socket */
int rv; /* return value */
struct sockaddr addr; /* for interface name */
struct arpMsg arp;
fd_set fdset;
struct timeval tm;
time_t prevTime;
char checkip[100];
char checkmac[100];
strcpy(checkip, arp_ip->ptr);
rv = 1;
if( openRawSocket(&s, ETH_P_ARP) == -1 ){
return -1;
}
/* send arp request */
mkArpMsg(ARPOP_REQUEST, inaddr, NULL, ifbuf->addr, ifbuf->haddr, &arp);
bzero(&addr, sizeof(addr));
strcpy(addr.sa_data, ifbuf->ifname);
if ( sendto(s, &arp, sizeof(arp), 0, &addr, sizeof(addr)) < 0 ) rv = 0;
/* wait arp reply, and check it */
tm.tv_usec = 0;
time(&prevTime);
while ( timeout > 0 ) {
FD_ZERO(&fdset);
FD_SET(s, &fdset);
tm.tv_sec = timeout;
if ( select(s+1, &fdset, (fd_set *)NULL, (fd_set *)NULL, &tm) < 0 ) {
Cdbg(DBE, "Error on ARPING request: %s\n", strerror(errno));
if (errno != EINTR) rv = 0;
} else if ( FD_ISSET(s, &fdset) ) {
if (recv(s, &arp, sizeof(arp), 0) < 0) rv = 0;
if( arp.operation == htons(ARPOP_REPLY) &&
bcmp(arp.tHaddr, ifbuf->haddr, 6) == 0 &&
*((u_int *)arp.sInaddr) == inaddr ) {
//inet_ntop(AF_INET, arp.sInaddr, checkip, sizeof(checkip)) ;
//fprintf(stderr,"enter %d\n", thread_id);
//char* hostname = smbc_nmblookup(checkip);
//fprintf(stderr,"leave %d, %s\n", thread_id, hostname);
//hostname = "TSET";
#if 1
//if(hostname!=NULL)
{
sprintf(checkmac, "%02X:%02X:%02X:%02X:%02X:%02X",
arp.sHaddr[0]&0xff, arp.sHaddr[1]&0xff, arp.sHaddr[2]&0xff,
arp.sHaddr[3]&0xff, arp.sHaddr[4]&0xff, arp.sHaddr[5]&0xff);
#if 0
fprintf(stderr, "Valid arp reply receved for this address, thread_id=[%d]\n", thread_id);
fprintf(stderr, "IP is %s, MAC is %s\n\n",
checkip,
checkmac);
#endif
int bFound = 0;
smb_srv_info_t *p;
for (p = smb_srv_info_list; p; p = p->next) {
if(strcmp(p->ip->ptr, checkip)==0){
//fprintf(stderr,"\t\tFound ip=[%s] in list!\n", checkip);
bFound = 1;
break;
}
}
if(bFound==0){
smb_srv_info_t *smb_srv_info;
smb_srv_info = (smb_srv_info_t *)calloc(1, sizeof(smb_srv_info_t));
smb_srv_info->id = thread_id;
smb_srv_info->ip = buffer_init();
buffer_copy_string(smb_srv_info->ip, checkip);
smb_srv_info->mac = buffer_init();
buffer_copy_string(smb_srv_info->mac, checkmac);
smb_srv_info->name = buffer_init();
buffer_copy_string(smb_srv_info->name, "");
//buffer_copy_string(smb_srv_info->name, hostname);
DLIST_ADD(smb_srv_info_list, smb_srv_info);
//fprintf(stderr,"add ip=[%s] to list!\n", checkip);
/*
int count = 0;
smb_srv_info_t *c;
for (c = smb_srv_info_list; c; c = c->next) {
count++;
}
fprintf(stderr,"List count [%d]!\n", count);
*/
}
}
rv = 0;
#else
rv = 1;
#endif
break;
}
}
timeout -= time(NULL) - prevTime;
time(&prevTime);
}
close(s);
if(rv==1){
smb_srv_info_t *p;
for (p = smb_srv_info_list; p; p = p->next) {
//fprintf(stderr,"check [%s]->[%s]\n", p->ip->ptr, checkip);
if(strcmp(p->ip->ptr, checkip)==0){
Cdbg(DBE,"ip=[%s] name=[%s] is not exist!\n", checkip, p->name->ptr);
buffer_free(p->ip);
buffer_free(p->mac);
buffer_free(p->name);
DLIST_REMOVE(smb_srv_info_list, p);
free(p);
break;
}
}
}
//fprintf(stderr, "ip=[%s], %salid arp replies for this address\n", checkip, rv ? "No v" : "V");
return rv;
}
int main(int argc, char** argv)
{
ipcio_t data_block = IPCIO_INIT;
key_t key = DADA_DEFAULT_BLOCK_KEY;
int status = 0;
char eventfile[128];
FILE *infd, *evfd;
//get this many bytes at a time from data socket
int BUFSIZE = UDP_HDR_SIZE + VDIF_PKT_SIZE;
char buf[BUFSIZE];
char dev[16] = ETHDEV;
char hostname[MAXHOSTNAME];
gethostname(hostname,MAXHOSTNAME);
char *starthost = strstr(hostname, "difx");
int nbytes = 0, state = STATE_STOPPED;
uint64_t port = WRITER_SERVICE_PORT;
//int cmd = CMD_NONE;
char cmd = CMD_NONE;
int ii, arg, maxsock = 0;
fd_set readfds;
struct timeval tv; //timeout for select()--set it to zero
tv.tv_sec = 0;
tv.tv_usec = 0;
Connection c;
c.sockoptval = 1; //release port immediately after closing connection
Connection raw;
raw.alen = sizeof(raw.rem_addr);
raw.sockoptval = 32*1024*1024; //size of data socket internal buffer
// For gathering stats on frame skips
long framenumtmp, framenum[2], framediff;
framenum[0] = -1;
framenum[1] = -1;
int threadid = -1;
FILE* skiplogfd;
char skiplogfile[128];
time_t currt;
char currt_string[128];
struct tm *tmpt;
while ((arg = getopt(argc, argv, "hk:p:e:")) != -1) {
switch(arg) {
case 'h':
usage ();
return 0;
case 'k':
if (sscanf (optarg, "%x", &key) != 1) {
fprintf (stderr, "writer: could not parse key from %s\n", optarg);
return -1;
}
break;
case 'p':
if (sscanf (optarg, "%"PRIu64"", &port) != 1) {
fprintf (stderr, "writer: could not parse port from %s\n", optarg);
return -1;
}
break;
case 'e':
if (sscanf (optarg, "%s", dev) != 1) {
fprintf (stderr, "writer: could not parse ethernet device from %s\n", optarg);
return -1;
}
break;
}
}
sprintf(skiplogfile,"%s%s%s%s","skiplog-",starthost,dev,".txt");
if((skiplogfd = fopen(skiplogfile, "w")) == NULL) {
fprintf(stderr,"Writer: Could not open skiplog file %s for writing.\n",skiplogfile);
exit(1);
}
//Try to connect to existing data block
if(ipcio_connect(&data_block,key) < 0)
exit(1);
fprintf(stderr,"after ipcio_connect\n");
//create listening socket
if(serve(port, &c) < 0) {
fprintf(stderr,"Writer: Failed to create listening socket.\n");
exit(1);
}
maxsock = c.rqst;
//Open raw data stream socket
raw.svc = openRawSocket(dev,0);
if(raw.svc < 0) {
fprintf(stderr, "Cannot open raw socket on %s. Error code %d\n", dev, raw.svc);
exit(1);
}
setsockopt(raw.svc, SOL_SOCKET, SO_RCVBUF, (char *)&(raw.sockoptval), sizeof(raw.sockoptval));
if(raw.svc > maxsock)
maxsock = raw.svc;
//ii = 0;
while(1) {
//ii++;
//printf("ii: %d state: %d cmd: %d\n",ii,state,cmd);
if(state == STATE_STOPPED) {
if(cmd == CMD_NONE)
cmd = wait_for_cmd(&c);
if(cmd == CMD_START) {
state = STATE_STARTED;
if(ipcio_open(&data_block,'W') < 0)
exit(1);
fprintf(stderr,"after ipcio_open, W\n");
cmd = CMD_NONE;
}
else if(cmd == CMD_EVENT) {
fprintf(stderr, "Writer: ignored CMD_EVENT in STATE_STOPPED.\n");
cmd = CMD_NONE;
}
else if(cmd == CMD_STOP) {
fprintf(stderr, "Writer: ignored CMD_STOP in STATE_STOPPED.\n");
cmd = CMD_NONE;
}
else if(cmd == CMD_QUIT) {
shutdown(c.rqst,2);
return 0;
}
}
//if state is STARTED, poll the command listening socket and the VDIF raw data socket
if(state == STATE_STARTED) {
FD_ZERO(&readfds);
FD_SET(c.rqst, &readfds);
FD_SET(raw.svc, &readfds);
select(maxsock+1,&readfds,NULL,NULL,&tv);
//if input is waiting on listening socket, read it
if(FD_ISSET(c.rqst,&readfds)) {
cmd = wait_for_cmd(&c);
}
if(cmd == CMD_EVENT) {
//close data block
if(ipcio_close(&data_block) < 0)
exit(1);
fprintf(stderr,"after ipcio_close\n");
//dump DB to file
currt = time(NULL);
tmpt = localtime(&currt);
strftime(currt_string,sizeof(currt_string), "%Y%m%d_%H%M%S", tmpt);
*(currt_string+15) = 0;
sprintf(eventfile,"%s/%s%s_%s_ev.out",EVENTDIR,starthost,dev,currt_string);
if((evfd = fopen(eventfile,"w")) == NULL) {
fprintf(stderr,"Writer: Could not open file %s for writing.\n",eventfile);
}
else {
event_to_file(&data_block,evfd);
fclose(evfd);
}
//Get pending commands, resume writing to ring buffer if there are none
FD_ZERO(&readfds);
FD_SET(c.rqst, &readfds);
FD_SET(raw.svc, &readfds);
select(maxsock+1,&readfds,NULL,NULL,&tv);
state = STATE_STOPPED;
if(FD_ISSET(c.rqst,&readfds)) {
cmd = wait_for_cmd(&c);
fprintf(stderr,"Writer: flushed out command socket after event_to_file.\n");
}
else
cmd = CMD_START;
continue;
}
//if command is stop, change state to STOPPED, close data block
else if(cmd == CMD_STOP) {
state = STATE_STOPPED;
if(ipcio_close(&data_block) < 0)
exit(1);
fprintf(stderr,"after ipcio_close\n");
cmd = CMD_NONE;
continue;
}
//if command is quit, close data block, shutdown listening socket, return
else if(cmd == CMD_QUIT) {
if(ipcio_close(&data_block) < 0)
exit(1);
fprintf(stderr,"after ipcio_close\n");
shutdown(c.rqst,2);
return 0;
}
else if(cmd == CMD_START) {
fprintf(stderr,"Writer: ignored cmd start (already started).\n");
cmd = CMD_NONE;
}
//read a packet from the data socket and write it to the ring buffer
if(FD_ISSET(raw.svc,&readfds)) {
nbytes = recvfrom(raw.svc, buf, BUFSIZE, 0, (struct sockaddr *)&(raw.rem_addr), &(raw.alen));
if(nbytes == BUFSIZE) {
//fwrite(buf + trim, recvlen-trim, 1, out);
status = ipcio_write(&data_block,buf+UDP_HDR_SIZE,VDIF_PKT_SIZE);
//fprintf(stderr,"ipcio_write: %d bytes\n",status);
//print VDIF frame header
//printVDIFHeader((vdif_header *)(buf+UDP_HDR_SIZE), VDIFHeaderPrintLevelLong);
//printVDIFHeader((vdif_header *)(buf+UDP_HDR_SIZE), VDIFHeaderPrintLevelColumns);
//printVDIFHeader((vdif_header *)(buf+UDP_HDR_SIZE), VDIFHeaderPrintLevelShort);
//fprintf(stderr,"VDIFFrame MJD: %d Number: %d\n",getVDIFFrameMJD((vdif_header *)(buf+UDP_HDR_SIZE)), getVDIFFrameNumber((vdif_header *)(buf+UDP_HDR_SIZE)));
framenumtmp = getVDIFFrameNumber((vdif_header *)(buf+UDP_HDR_SIZE));
threadid = getVDIFThreadID((vdif_header *)(buf+UDP_HDR_SIZE));
framediff = framenumtmp - framenum[threadid];
if(framediff != -MAXFRAMENUM && framenum[threadid] != -1 && framediff != 1) {
//if(framediff != -25599 && abs(framediff) > 1 && framenum[threadid] != -1) {
currt = time(NULL);
tmpt = localtime(&currt);
strftime(currt_string,sizeof(currt_string), "%Y-%m-%d %H:%M:%S", tmpt);
fprintf(skiplogfd,"%s FRAME SKIP FROM %d to %d (THREAD %d)\n",currt_string,framenum[threadid],framenumtmp,threadid);
fflush(skiplogfd);
}
else if(framenum[threadid] == -1) {
fprintf(skiplogfd,"Writer: Thread %d First frame: %d\n",threadid,framenumtmp);
fflush(skiplogfd);
}
framenum[threadid] = framenumtmp;
}
else if(nbytes <= 0) {
fprintf(stderr,"Raw socket read failed: %d\n.", nbytes);
}
/*
else
fprintf(stderr,"Received packet size: %d, ignoring.\n", nbytes);
*/
}
//XXX: check for overflow of the data block here?
//nbytes = fread(buf,1,BUFSIZE,infd);
//fprintf(stderr,"fread: %d bytes\n",nbytes);
//status = ipcio_write(&data_block,buf,nbytes);
//fprintf(stderr,"ipcio_write: %d bytes\n",status);
//sleep(2);
}
}
//fclose(infd);
return 0;
}
