double estimateCapacity_pairs(int tcpsock)
{
pcapeststart pcap;
pcapestack pcapack;
int udpsock = 0;
char buf[2000];
int ret;
struct timeval tv;
double ct = 0;
pcap.header.ptype = P_CAPEST_START;
pcap.header.length = 0;
writewrapper(tcpsock, (char *)&pcap, sizeof(struct _capeststart));
ret = readwrapper(tcpsock, (char *)&pcapack, sizeof(struct _capestack));
if(ret == -1 || pcapack.header.ptype != P_CAP_ACK)
{
fprintf(stderr, "cannot read OR wrong cap ack\n");
return -1;
}
udpsock = udpclient();
while(1)
{
gettimeofday(&tv, NULL);
ct = tv.tv_sec + tv.tv_usec/1.0e6;
memcpy(buf, (const char *)&ct, sizeof(ct));
ret = send(udpsock, buf, 500, 0);
if(ret == -1)
{
fprintf(stderr, "cannot send\n");
return -1;
}
ret = send(udpsock, buf, 500, 0);
if(ret == -1)
{
fprintf(stderr, "cannot send\n");
return -1;
}
ret = readwrapper(tcpsock, (char *)&pcapack,
sizeof(struct _capestack));
if(ret == -1 || pcapack.header.ptype != P_CAP_ACK)
{
fprintf(stderr, "cannot read OR wrong cap ack\n");
return -1;
}
//printf("Capacity: %.2f\n", pcapack.capacity);
printf("."); fflush(stdout);
if(pcapack.finalflag == 1) break;
usleep(30000);
}
close(udpsock);
printf("Capacity: %.2f\n", pcapack.capacity);
return pcapack.capacity;
}
double estimateCapacity(int tcpsock, int udpsock, struct sockaddr_in *from)
{
pcapeststart pcap;
pcapestack pcapack;
//int udpsock = 0;
char buf[2000];
int ret, count = 0;
int trainlength = 5;
struct sockaddr_in frm = *from;
int fromlen = sizeof(struct sockaddr_in);
pcap.header.ptype = P_CAPEST_START;
pcap.header.length = 0;
writewrapper(tcpsock, (char *)&pcap, sizeof(struct _capeststart));
ret = readwrapper(tcpsock, (char *)&pcapack, sizeof(struct _capestack));
if(ret == -1 || pcapack.header.ptype != P_CAP_ACK)
{
fprintf(stderr, "cannot read OR wrong cap ack\n");
return -1;
}
trainlength = pcapack.trainlength;
//udpsock = udpclient();
while(1)
{
for(count = 0; count < trainlength; count++)
{
ret = sendto(udpsock, buf, 1400, 0,
(struct sockaddr *)&frm, fromlen);
if(ret == -1)
{
perror("cannot send\n");
return -1;
}
}
ret = readwrapper(tcpsock, (char *)&pcapack,
sizeof(struct _capestack));
if(ret == -1 || pcapack.header.ptype != P_CAP_ACK)
{
fprintf(stderr, "cannot read OR wrong cap ack\n");
return -1;
}
trainlength = pcapack.trainlength;
//printf("Capacity: %.2f\n", pcapack.capacity);
//printf("."); fflush(stdout);
if(pcapack.finalflag == 1) break;
usleep(100000);
}
//close(udpsock);
//printf("Capacity: %.2f\n", pcapack.capacity);
return pcapack.capacity;
}
int recvData(int tcpclientsock, FILE *fp, int direction /*0 up 1 down*/)
{
prcvdata pkt;
int ret = 0, len = 0, bytesleft = 0;
char *buf;
ret = readwrapper(tcpclientsock, (char *)&pkt, sizeof(struct _rcvdata));
if(ret == -1)
{
perror("SERV: error reading from client.\n");
close(tcpclientsock);
return -1;
}
if(pkt.header.ptype != P_RECVDATA)
{
fprintf(stderr, "SERV: wrong packet type: %d\n", pkt.header.ptype);
return -1;
}
len = ntohl(pkt.datalength);
buf = (char *)malloc(len*sizeof(char));
/*ret = readwrapper(tcpclientsock, (char *)&buf, len*sizeof(char));
if(ret == -1)
{
fprintf(stderr, "SERV: error reading from client..\n");
perror("");
close(tcpclientsock);
free(buf);
return -1;
}*/
bytesleft = len;
while(bytesleft > 0)
{
int torecv = (bytesleft > 1400) ? 1400 : bytesleft;
ret = readwrapper(tcpclientsock, (char *)buf+(len-bytesleft), torecv);
if(ret == -1)
{
fprintf(stderr, "SERV: error reading data from client..\n");
perror("");
close(tcpclientsock);
free(buf);
return -1;
}
bytesleft -= ret;
}
if(direction == 1)
fprintf(fp, "### DOWNSTREAM ###\n");
ret = fwrite((void *)buf, sizeof(char), len, fp);
free(buf);
return 0;
}
int sendCapEst(int tcpsock)
{
pcapeststart pcap;
pcapestack pcapack;
int ret = 0;
ret = readwrapper(tcpsock, (char *)&pcap, sizeof(struct _capeststart));
if(ret == -1)
{
fprintf(stderr, "SERV: error reading from client: %d\n", tcpsock);
close(tcpsock);
return -1;
}
if(pcap.header.ptype != P_CAPEST_START)
{
fprintf(stderr, "Bad capstart message!\n");
close(tcpsock);
return -1;
}
pcapack.header.ptype = P_CAP_ACK;
pcapack.header.length = 0;
pcapack.capacity = pcapack.finalflag = 0;
pcapack.trainlength = TRAIN_LENGTH;
ret = writewrapper(tcpsock, (char *)&pcapack,
sizeof(struct _capestack));
if(ret == -1)
{
fprintf(stderr, "SERV: error writing to client: %d\n", tcpsock);
close(tcpsock);
return -1;
}
return 0;
}
int getDiscResult(int tcpsock)
{
pdiscr_resreq preq;
pdiscr_result presult;
int ret = 0, nLIPs = 0;
preq.header.ptype = P_DISCR_RESREQ;
preq.header.length = 0;
ret = writewrapper(tcpsock, (char *)&preq,
sizeof(struct _discr_resreq));
if(ret == -1)
{
fprintf(stderr, "SERV: error writing to client: %d\n", tcpsock);
close(tcpsock);
return -1;
}
int cursz = sizeof(struct _header)+2*sizeof(unsigned int)+
sizeof(double)+sizeof(int);
ret = readwrapper(tcpsock, (char *)&presult, cursz);
if(ret == -1)
{
fprintf(stderr, "SERV: error reading from client: %d\n", tcpsock);
close(tcpsock);
return -1;
}
nLIPs = presult.nresults;
ret = readwrapper(tcpsock, (char *)&presult + cursz, nLIPs*sizeof(struct sessionresult));
if(ret == -1)
{
fprintf(stderr, "SERV: error reading from client: %d\n", tcpsock);
close(tcpsock);
return -1;
}
if(presult.header.ptype == P_DISCR_RESULT)
{
printResults(&presult);
}
else
{
return -1;
}
return 0;
}
int connect2server(unsigned int serverip, int fileid)
{
int conn_s;
struct sockaddr_in servaddr;
//short int port = SERV_PORT;
extern short int serv_port;
short int port = serv_port;
int ret = 0;
int sndsize = 1024*1024;
extern double TB_RATE_AVG_INTERVAL;
if ( (conn_s = socket(AF_INET, SOCK_STREAM, 0)) < 0 )
{
fprintf(stderr, "CLNT: Error creating listening socket.\n");
return -1;
}
ret = setsockopt(conn_s, SOL_SOCKET, SO_SNDBUF,
(char *)&sndsize, sizeof(int));
sndsize = 1024*1024;
ret = setsockopt(conn_s, SOL_SOCKET, SO_RCVBUF,
(char *)&sndsize, sizeof(int));
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(port);
servaddr.sin_addr.s_addr = serverip;
if (connect_nonb(conn_s, (struct sockaddr *)&servaddr, sizeof(servaddr), 5) < 0 )
{
//printf("Cannot connect to server. Server may be busy; please try in a few minutes.\n");
return -1;
}
pnewclientpacket pkt;
pkt.header.ptype = P_NEWCLIENT;
pkt.header.length = 0;
pkt.version = htonl(VERSION);
pkt.fileid = 0;
pkt.delta = TB_RATE_AVG_INTERVAL;
writewrapper(conn_s, (char *)&pkt, sizeof(struct _newclientpkt));
pnewclientack pnewack;
readwrapper(conn_s, (char *)&pnewack, sizeof(struct _newclientack));
if(pnewack.header.ptype != P_NEWCLIENT_ACK)
{
printf("Error: bad packet type: %d\n", pnewack.header.ptype);
close(conn_s);
return -1;
}
if(pnewack.compatibilityFlag == 0)
{
printf("Incompatible server. Please download the latest version of ShaperProbe client from:\nhttp://www.cc.gatech.edu/~partha/diffprobe/shaperprobe.html\n");
return -1;
}
return conn_s;
}
int connect2server(unsigned int serverip, int fileid)
{
int conn_s;
struct sockaddr_in servaddr;
short int port = SERV_PORT;
int ret = 0;
int sndsize = 1024*1024;
if ( (conn_s = socket(AF_INET, SOCK_STREAM, 0)) < 0 )
{
fprintf(stderr, "CLNT: Error creating listening socket.\n");
return -1;
}
ret = setsockopt(conn_s, SOL_SOCKET, SO_SNDBUF,
(char *)&sndsize, sizeof(int));
sndsize = 1024*1024;
ret = setsockopt(conn_s, SOL_SOCKET, SO_RCVBUF,
(char *)&sndsize, sizeof(int));
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(port);
servaddr.sin_addr.s_addr = serverip;
if (connect_nonb(conn_s, (struct sockaddr *)&servaddr, sizeof(servaddr), 5) < 0 )
{
printf("Cannot connect to server. Server may be busy; please try in a few minutes.\n");
return -1;
}
pnewclientpacket pkt;
pkt.header.ptype = P_NEWCLIENT;
pkt.header.length = 0;
pkt.version = 1;
pkt.fileid = fileid;
writewrapper(conn_s, (char *)&pkt, sizeof(struct _newclientpkt));
pnewclientack pnewack;
readwrapper(conn_s, (char *)&pnewack, sizeof(struct _newclientack));
if(pnewack.header.ptype != P_NEWCLIENT_ACK)
{
printf("Error: bad packet type: %d\n", pnewack.header.ptype);
close(conn_s);
return -1;
}
if(pnewack.compatibilityFlag == 0)
{
printf("Incompatible server. Please download the latest version of DiffProbe client.\n");
return -1;
}
return conn_s;
}
int tbdetectReceiver(int tcpsock, int udpsock,
double capacity, double sleepRes,
unsigned int *result, unsigned int *minbktdepth,
unsigned int *maxbktdepth, double *tbrate,
unsigned int *abortflag, FILE *fp)
{
ptbdetectstart startpkt;
ptbdetectstartack ackpkt;
ptbdetectend endpkt;
int ret = 0;
struct timeval startts, endts, diffts, oldts, tsbucket;
struct timeval tout;
fd_set readset;
int maxfd = udpsock + 1;
struct sockaddr_in from;
double rateEstimate = capacity;
double lastbucket = -1;
int bucketbytes = 0;
char buf[2000];
double bucket = 0;
int len = (int)ceil(1.5*TBDURATION/TB_RATE_AVG_INTERVAL);
double *timestamp = calloc(len, sizeof(double));
double *rate = calloc(len, sizeof(double));
float *lossrate = calloc(len, sizeof(float));
int *rank = calloc(len, sizeof(int));
int index = -1;
unsigned long seq = 0, maxseq = 0, lastseq = 0, totrecvd = 0;
unsigned long contHiLossWnds = 0, contLoLossWnds = 0;
double loglastbucket = -1;
int logbucketbytes = 0;
unsigned long loglastseq = 0, logtotrecvd = 0;
double sendtstamp = 0;
int ULSZ = sizeof(unsigned long);
fprintf(fp, "### DATA ###\n");
ret = readwrapper(tcpsock, (char *)&startpkt,
sizeof(struct _tbdetectstart));
if(ret == -1)
{
fprintf(stderr, "error reading: %d\n", tcpsock);
closesocket(tcpsock);
return -1;
}
if(startpkt.header.ptype != P_TBDETECT_START)
{
fprintf(stderr, "Bad capstart message!\n");
closesocket(tcpsock);
return -1;
}
ackpkt.header.ptype = P_TBDETECT_START_ACK;
ackpkt.header.length = 0;
ackpkt.duration = htonl(5); //s
ret = writewrapper(tcpsock, (char *)&ackpkt, sizeof(struct _tbdetectstartack));
if(ret == -1)
{
fprintf(stderr, "error writing: %d\n", tcpsock);
closesocket(tcpsock);
return -1;
}
gettimeofday(&startts, NULL);
tsbucket = oldts = startts;
//lastbucket = floor((startts.tv_sec + startts.tv_usec*1e-6)
// /TB_RATE_AVG_INTERVAL);
lastbucket = 0;
*abortflag = endpkt.abortflag = endpkt.result = 0;
while(1)
{
FD_ZERO(&readset);
FD_SET(udpsock, &readset);
tout.tv_sec = 60; tout.tv_usec = 0;
ret = select(maxfd, &readset, NULL, NULL, &tout);
if(ret < 0)
{
fprintf(stderr, "select error\n");
closesocket(udpsock);
return -1;
}
else if(ret == 0) //timeout
{
}
if(FD_ISSET(udpsock, &readset))
{
unsigned int fromlen = sizeof(struct sockaddr_in);
struct timeval ts;
ret = recvfrom(udpsock, buf, 2000, 0,
(struct sockaddr *)&from, &fromlen);
if(ret == -1)
{
fprintf(stderr, "recv error on UDP\n");
return -1;
}
if(buf[ULSZ+ULSZ+ULSZ] != TB) continue;
#ifndef WIN32
if (ioctl(udpsock, SIOCGSTAMP, &ts) < 0)
{
gettimeofday(&ts,NULL);
}
#else
gettimeofday(&ts,NULL);
#endif
if(totrecvd == 0)
startts = ts;
seq = ntohl(*(unsigned long *)buf);
maxseq = (maxseq < seq) ? seq : maxseq;
totrecvd++;
sendtstamp = ntohl(*(unsigned long *)((char *)buf+ULSZ));
sendtstamp += ntohl(*(unsigned long *)((char *)buf+2*ULSZ))*1e-6;
//double bucket = floor((ts.tv_sec + ts.tv_usec*1e-6)
// /TB_RATE_AVG_INTERVAL);
bucket = floor((ts.tv_sec + ts.tv_usec*1e-6 -
startts.tv_sec - startts.tv_usec*1e-6)
/TB_RATE_AVG_INTERVAL);
if(bucket == -1) bucket = 0;
tbLogRateLoss(sendtstamp, ts.tv_sec + ts.tv_usec*1e-6, ret, seq, maxseq,
&loglastseq, &logtotrecvd, &loglastbucket, &logbucketbytes, fp);
/*diffts = prober_packet_gap(oldts, ts);
rateEstimate = (rateEstimate*TB_RATE_AVG_INTERVAL + ret*0.008)/
(diffts.tv_sec + diffts.tv_usec*1.0e-6 + TB_RATE_AVG_INTERVAL);*/
if(bucket != lastbucket)
{
float loss = 0;
if(maxseq + 1 != lastseq)
loss = 1 - (float)1.0*totrecvd / (maxseq - lastseq + 1);
lossrate[index+1] = loss;
if(loss > TB_LOSSRATE)
contHiLossWnds++;
else
contHiLossWnds = 0;
if(loss > TB_TOTLOSSRATE)
contLoLossWnds++;
else
contLoLossWnds = 0;
if(contHiLossWnds > TB_NPOSTERIOR+2 ||
contLoLossWnds > TB_NTOTLOSSPOSTERIOR)
{
fprintf(fp,
"aborting due to high loss rate: Hi:%ld Lo:%ld\n",
contHiLossWnds, contLoLossWnds);
*abortflag = 1;
endpkt.abortflag = htonl(1);
break;
}
rateEstimate =
bucketbytes * 0.008/TB_RATE_AVG_INTERVAL;
*result = getLevelShift(timestamp, rate, rank,
&index,
tsbucket.tv_sec + tsbucket.tv_usec*1e-6,
rateEstimate, minbktdepth,
maxbktdepth, tbrate);
if(*result == 1)
break;
bucketbytes = ret;
totrecvd = 1;
lastbucket = bucket;
lastseq = seq;
tsbucket = ts;
}
else
{
bucketbytes += ret;
}
oldts = ts;
}
gettimeofday(&endts, NULL);
diffts = prober_packet_gap(startts, endts);
if(diffts.tv_sec + diffts.tv_usec*1.0e-6 > TBDURATION)
break;
}
endpkt.header.ptype = P_TBDETECT_END;
endpkt.header.length = 0;
endpkt.result = htonl(*result);
endpkt.minbucketDepth = htonl(*minbktdepth);
endpkt.maxbucketDepth = htonl(*maxbktdepth);
if(*result != 1) *tbrate = findmediandouble(rate, index);
endpkt.tokenRate = htonl((unsigned long)floor(*tbrate));
ret = writewrapper(tcpsock, (char *)&endpkt,
sizeof(struct _tbdetectend));
if(ret == -1)
{
fprintf(stderr, "error writing to server: %d\n", tcpsock);
closesocket(tcpsock);
return -1;
}
free(timestamp);
free(rate);
free(lossrate);
free(rank);
return 0;
}
int tbdetectSender(int tcpsock, int udpsock, struct sockaddr_in *from,
double capacity, double sleepRes, unsigned int *result,
unsigned int *minbktdepth, unsigned int *maxbktdepth,
double *tbrate, unsigned int *abortflag, FILE *fp)
{
ptbdetectstart startpkt;
ptbdetectstartack ackpkt;
ptbdetectend endpkt;
struct timeval gapts, startts, endts, diffts, sendts, expts;
char buf[2000];
int ret = 0;
int duration = 0;
double gap = 0, start0 = 0;
fd_set readset;
struct timeval tout;
int maxfd = tcpsock + 1;
unsigned int fromlen = sizeof(struct sockaddr_in);
unsigned long seq = 0, seq1 = 0;
unsigned long sendtstamp = 0;
int ULSZ = sizeof(unsigned long);
int trainlength = 1, mintrainlen = 1, maxtrainlen = TB_MAX_TRAINLEN,
trainid = 0, c = 0;
double bwperiod = 0xFFFFFFFF;
startpkt.header.ptype = P_TBDETECT_START;
startpkt.header.length = 0;
ret = writewrapper(tcpsock, (char *)&startpkt,
sizeof(struct _tbdetectstart));
if(ret == -1)
{
fprintf(stderr, "error writing to server: %d\n", tcpsock);
closesocket(tcpsock);
return -1;
}
ret = readwrapper(tcpsock, (char *)&ackpkt, sizeof(struct _tbdetectstartack));
if(ret == -1)
{
fprintf(stderr, "error reading from client: %d\n", tcpsock);
closesocket(tcpsock);
return -1;
}
if(ackpkt.header.ptype != P_TBDETECT_START_ACK)
{
fprintf(stderr, "Bad start message!\n");
closesocket(tcpsock);
return -1;
}
duration = ntohl(ackpkt.duration);
gap = (1400+UDPIPHEADERSZ)*0.008/capacity;//s
trainlength = 1;
mintrainlen = (int)ceil(sleepRes/gap);
maxtrainlen = (gap > sleepRes) ? TB_MAX_TRAINLEN : 30; // TODO: 30 -> buffer length
for(c = mintrainlen; c <= maxtrainlen; c++)
{
double k = floor(c*gap/sleepRes);
double bp = c*gap - k*sleepRes;
if(bwperiod > bp) {bwperiod = bp; trainlength = c;}
}
gap *= trainlength;
fprintf(fp, "client trainlength: %d\n", trainlength);
gettimeofday(&startts, NULL); start0 = startts.tv_sec+startts.tv_usec*1e-6;
gapts.tv_sec = (long)floor(gap);
gapts.tv_usec = (long)((gap - gapts.tv_sec)*1e6);
*abortflag = 0;
buf[ULSZ+ULSZ+ULSZ] = TB;
while(1)
{
double expsendtime = start0 + gap * trainid; // trainid starts with 1
trainid++;
for(c = 0; c < trainlength; c++)
{
seq1 = htonl(++seq);
gettimeofday(&sendts, NULL);
memcpy(buf, (char *)&seq1, ULSZ);
sendtstamp = htonl(sendts.tv_sec);
memcpy((char *)buf+ULSZ, (char *)&sendtstamp, ULSZ);
sendtstamp = htonl(sendts.tv_usec);
memcpy((char *)buf+2*ULSZ, (char *)&sendtstamp, ULSZ);
ret = sendto(udpsock, buf, 1400, 0,
(struct sockaddr *)from, fromlen);
if(ret == -1)
{
perror("cannot send\n");
closesocket(udpsock);
return -1;
}
}
gettimeofday(&endts, NULL);
expts.tv_sec = (long)floor(expsendtime);
expts.tv_usec = (long)(1e6*(expsendtime - floor(expsendtime)));
diffts = prober_packet_gap(endts, expts);
if(diffts.tv_sec+diffts.tv_usec*1e-6 > 0)
prober_swait(diffts, sleepRes);
gettimeofday(&startts, NULL);
FD_ZERO(&readset);
FD_SET(tcpsock, &readset);
tout.tv_sec = 0; tout.tv_usec = 0;
ret = select(maxfd, &readset, NULL, NULL, &tout);
if(ret < 0)
{
fprintf(stderr, "select error\n");
return -1;
}
else if(ret == 0) //timeout
{
}
else
{
if(FD_ISSET(tcpsock, &readset))
{
ret = readwrapper(tcpsock, (char *)&endpkt,
sizeof(struct _tbdetectend));
if(ret == -1 || endpkt.header.ptype != P_TBDETECT_END)
{
fprintf(stderr, "SERV: error reading or wrong packet type.\n");
closesocket(tcpsock);
return -1;
}
*result = ntohl(endpkt.result);
*minbktdepth = ntohl(endpkt.minbucketDepth);
*maxbktdepth = ntohl(endpkt.maxbucketDepth);
*tbrate = ntohl(endpkt.tokenRate);
*abortflag = ntohl(endpkt.abortflag);
break;
}
}
}
return 0;
}
double estimateCapacity(int tcpsock, int udpsock, struct sockaddr_in *from)
{
pcapeststart pcap;
pcapestack pcapack;
ptrainprobe probepkt;
char buf[2000];
int ret, count = 0, niters = 0;
int trainlength = 5;
struct sockaddr_in frm = *from;
int fromlen = sizeof(struct sockaddr_in);
unsigned char seq = 0;
struct timeval ts;
pcap.header.ptype = P_CAPEST_START;
pcap.header.length = 0;
writewrapper(tcpsock, (char *)&pcap, sizeof(struct _capeststart));
ret = readwrapper(tcpsock, (char *)&pcapack, sizeof(struct _capestack));
if(ret == -1 || pcapack.header.ptype != P_CAP_ACK)
{
fprintf(stderr, "cannot read OR wrong cap ack\n");
return -1;
}
trainlength = ntohl(pcapack.trainlength);
//udpsock = udpclient();
while(1)
{
probepkt.id = niters + 10; //trains start with id 10
for(count = 0; count < trainlength; count++)
{
seq = count;
gettimeofday(&ts, NULL);
probepkt.seq = seq;
probepkt.secs = htonl(ts.tv_sec);
probepkt.usecs = htonl(ts.tv_usec);
memcpy(buf, (char *)&probepkt, sizeof(struct _trainprobe));
ret = sendto(udpsock, buf, 1400, 0,
(struct sockaddr *)&frm, fromlen);
if(ret == -1)
{
perror("cannot send\n");
return -1;
}
}
niters++;
ret = readwrapper(tcpsock, (char *)&pcapack,
sizeof(struct _capestack));
if(ret == -1 || pcapack.header.ptype != P_CAP_ACK)
{
fprintf(stderr, "cannot read OR wrong cap ack\n");
return -1;
}
trainlength = ntohl(pcapack.trainlength);
printf("\33[2K\r"); printf("Upload packet train %d: %d Kbps", niters, ntohl(pcapack.capacity)); fflush(stdout);
if(ntohl(pcapack.finalflag) == 1) break;
usleep(500000);
}
printf("\33[2K\r"); fflush(stdout);
return ntohl(pcapack.capacity);
}
int mflowSender(int tcpsock, int udpsock, struct sockaddr_in *from,
double capacity, double sleepRes, double *recvrate, int lowprobe)
{
pmflowstart startpkt;
pmflowstartack ackpkt;
pmflowend endpkt;
pprobe probepkt;
struct timeval gapts, gapts2, startts, endts, diffts, sendts;
char buf[2000];
int ret = 0;
int duration = 0;
double gap = 0;
fd_set readset;
struct timeval tout;
int maxfd = tcpsock + 1;
unsigned int fromlen = sizeof(struct sockaddr_in);
unsigned long seq = 0, seq1 = 0;
unsigned int pktsz = (lowprobe == 0) ? 1400 : sizeof(struct _probe);
startpkt.header.ptype = P_MEASFLOW_START;
startpkt.header.length = 0;
ret = writewrapper(tcpsock, (char *)&startpkt,
sizeof(struct _mflowstart));
if(ret == -1)
{
fprintf(stderr, "error writing to server: %d\n", tcpsock);
close(tcpsock);
return -1;
}
ret = readwrapper(tcpsock, (char *)&ackpkt, sizeof(struct _mflowstartack));
if(ret == -1)
{
fprintf(stderr, "error reading from client: %d\n", tcpsock);
close(tcpsock);
return -1;
}
if(ackpkt.header.ptype != P_MEASFLOW_START_ACK)
{
fprintf(stderr, "Bad start message!\n");
close(tcpsock);
return -1;
}
duration = ntohl(ackpkt.duration);
gettimeofday(&startts, NULL);
gap = (lowprobe == 0) ? (1400+UDPIPHEADERSZ)*0.008/capacity : 0.1;//s
gapts.tv_sec = floor(gap);
gapts.tv_usec = (gap - gapts.tv_sec)*1e6;
probepkt.id = (lowprobe == 0) ? MEAS : MEASSMALL;
while(1)
{
seq1 = htonl(++seq);
gettimeofday(&sendts, NULL);
probepkt.seq = seq1;
probepkt.secs = htonl(sendts.tv_sec);
probepkt.usecs = htonl(sendts.tv_usec);
memcpy(buf, (char *)&probepkt, sizeof(struct _probe));
ret = sendto(udpsock, buf, pktsz, 0,
(struct sockaddr *)from, fromlen);
if(ret == -1)
{
perror("cannot send\n");
close(udpsock);
return -1;
}
gettimeofday(&endts, NULL);
diffts = prober_packet_gap(startts, endts);
gapts2 = prober_packet_gap(diffts, gapts);
//if(gap > sleepRes)
prober_swait(gapts2, sleepRes);
//else
// prober_sbusywait(gapts2);
gettimeofday(&startts, NULL);
FD_ZERO(&readset);
FD_SET(tcpsock, &readset);
tout.tv_sec = 0; tout.tv_usec = 0;
ret = select(maxfd, &readset, NULL, NULL, &tout);
if(ret < 0)
{
fprintf(stderr, "select error\n");
return -1;
}
else if(ret == 0) //timeout
{
}
else
{
if(FD_ISSET(tcpsock, &readset))
{
ret = readwrapper(tcpsock, (char *)&endpkt,
sizeof(struct _mflowend));
if(ret == -1 || endpkt.header.ptype != P_MEASFLOW_END)
{
fprintf(stderr, "SERV: error reading or wrong packet type.\n");
close(tcpsock);
return -1;
}
if(recvrate != NULL) *recvrate = ntohl(endpkt.recvrate);
break;
}
}
}
return 0;
}
int mflowReceiver(int tcpsock, int udpsock, double *recvrate, FILE *fp, int lowprobe)
{
pmflowstart startpkt;
pmflowstartack ackpkt;
pmflowend endpkt;
pprobe *probepkt;
int ret = 0, nrecvd = 0;
struct timeval startts, endts, diffts, oldts, tsbucket;
struct timeval tout;
fd_set readset;
int maxfd = udpsock + 1;
struct sockaddr_in from;
char buf[2000];
unsigned long seq = 0;
unsigned int vMFLOWDURATION = MFLOWDURATION;
double sendtstamp = 0;
if(lowprobe == 0)
{
fprintf(fp, "### MEAS ###\n");
vMFLOWDURATION = MFLOWDURATION;
}
else
{
fprintf(fp, "### MEAS-SMALL ###\n");
vMFLOWDURATION = 2*MFLOWDURATION;
}
ret = readwrapper(tcpsock, (char *)&startpkt,
sizeof(struct _mflowstart));
if(ret == -1)
{
fprintf(stderr, "error reading: %d\n", tcpsock);
close(tcpsock);
return -1;
}
if(startpkt.header.ptype != P_MEASFLOW_START)
{
fprintf(stderr, "Bad capstart message!\n");
close(tcpsock);
return -1;
}
ackpkt.header.ptype = P_MEASFLOW_START_ACK;
ackpkt.header.length = 0;
ackpkt.duration = htonl(vMFLOWDURATION); //s
ret = writewrapper(tcpsock, (char *)&ackpkt, sizeof(struct _mflowstartack));
if(ret == -1)
{
fprintf(stderr, "error writing: %d\n", tcpsock);
close(tcpsock);
return -1;
}
gettimeofday(&startts, NULL);
tsbucket = oldts = startts;
probepkt = (struct _probe *)buf;
while(1)
{
FD_ZERO(&readset);
FD_SET(udpsock, &readset);
tout.tv_sec = 60; tout.tv_usec = 0;
ret = select(maxfd, &readset, NULL, NULL, &tout);
if(ret < 0)
{
fprintf(stderr, "select error\n");
close(udpsock);
return -1;
}
else if(ret == 0) //timeout
{
}
if(FD_ISSET(udpsock, &readset))
{
unsigned int fromlen = sizeof(struct sockaddr_in);
struct timeval ts;
int probepktid = -1;
ret = recvfrom(udpsock, buf, 2000, 0,
(struct sockaddr *)&from, &fromlen);
if(ret == -1)
{
fprintf(stderr, "recv error on UDP\n");
return -1;
}
probepktid = probepkt->id;
if(probepktid != MEAS && probepktid != MEASSMALL) continue;
#ifndef OSX
if (ioctl(udpsock, SIOCGSTAMP, &ts) < 0)
{
gettimeofday(&ts,NULL);
}
#else
gettimeofday(&ts,NULL);
#endif
seq = ntohl(probepkt->seq);
sendtstamp = ntohl(probepkt->secs) + ntohl(probepkt->usecs)*1e-6;
fprintf(fp, "%f %f %ld %d\n", sendtstamp, ts.tv_sec + ts.tv_usec*1e-6, seq, probepktid);
}
nrecvd++;
gettimeofday(&endts, NULL);
diffts = prober_packet_gap(startts, endts);
if(diffts.tv_sec + diffts.tv_usec*1.0e-6 > vMFLOWDURATION)
break;
}
if(recvrate != NULL)
*recvrate = nrecvd*(1400+UDPIPHEADERSZ)*0.008
/(diffts.tv_sec + diffts.tv_usec*1.0e-6);
endpkt.header.ptype = P_MEASFLOW_END;
endpkt.header.length = 0;
endpkt.recvrate = (recvrate != NULL) ? htonl(*recvrate) : 0;
ret = writewrapper(tcpsock, (char *)&endpkt,
sizeof(struct _mflowend));
if(ret == -1)
{
fprintf(stderr, "error writing to server: %d\n", tcpsock);
close(tcpsock);
return -1;
}
return 0;
}
int preprocess_newclient(int conn_s, int udpsock0, int *version, double *capacityup,
double *capacitydown, struct sockaddr_in *from,
char *tracefile, FILE *fp, const char *filename)
{
int ret = 0;
pheader hdr;
pnewclientack pnewack;
pcapestack pcapack;
pnewclientpacket pnewclient;
int szhdr = sizeof(struct _header);
while(1)
{
ret = readwrapper(conn_s, (char *)&hdr, szhdr);
if(ret == -1)
{
fprintf(stderr, "SERV: error reading from client: %d\n", conn_s);
close(conn_s);
return -1;
}
switch(hdr.ptype)
{
case P_NEWCLIENT:
ret = readwrapper(conn_s,
(char *)&pnewclient + szhdr,
sizeof(struct _newclientpkt) - szhdr);
if(ret == -1)
{
fprintf(stderr, "SERV: error reading from client: %d\n", conn_s);
close(conn_s);
unlink(filename);
return -1;
}
//TB_RATE_AVG_INTERVAL = pnewclient.delta;
*version = ntohl(pnewclient.version);
pnewack.compatibilityFlag =
(ntohl(pnewclient.version) >= VERSION /*||
ntohl(pnewclient.version) == 1*/) ? 1 : 0;
pnewack.header.ptype = P_NEWCLIENT_ACK;
pnewack.header.length = 0;
ret = writewrapper(conn_s, (char *)&pnewack,
sizeof(struct _newclientack));
if(ret == -1)
{
fprintf(stderr, "SERV: error writing to client: %d\n", conn_s);
close(conn_s);
unlink(filename);
return -1;
}
fprintf(fp, "Client version: %d\n", ntohl(pnewclient.version));
if(pnewack.compatibilityFlag == 0)
{
close(conn_s);
return -1;
}
break;
case P_CAPEST_START:
pcapack.header.ptype = P_CAP_ACK;
pcapack.header.length = 0;
pcapack.capacity = pcapack.finalflag = 0;
pcapack.trainlength = htonl(TRAIN_LENGTH);
ret = writewrapper(conn_s, (char *)&pcapack,
sizeof(struct _capestack));
if(ret == -1)
{
fprintf(stderr, "SERV: error writing to client: %d\n", conn_s);
close(conn_s);
return -1;
}
*capacityup = capacityEstimation(conn_s, udpsock0, from, fp);
*capacitydown = estimateCapacity(conn_s, udpsock0, from);
return 0;
break;
default:
fprintf(stderr, "unknown packet type!\n");
close(conn_s);
unlink(filename);
return -1;
break;
}
}
return 0;
}
