pathrate_snd.c

pathrate是pathload的改进型

/*
 This file is part of pathrate.

 pathrate is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.

 pathrate is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with pathrate; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

/*-------------------------------------------------
   pathrate : an end-to-end capcity estimation tool
   Author   : Constantinos Dovrolis ([e-mail] )
              Ravi S Prasad            ( [e-mail] )
              
   Release  : Ver 2.4.1
   Support  : This work was supported by the SciDAC
              program of the US department 
--------------------------------------------------*/


#define LOCAL
#include "pathrate.h"
#include "pathrate_snd.h"

int main(int argc, char* argv[])
{
  
  struct sockaddr_in snd_udp_addr, snd_tcp_addr, rcv_udp_addr, rcv_tcp_addr;
  
  struct hostent *host_rcv;
  
  int opt_len, sock_udp, sock_tcp, ctr_strm, send_buff_sz, sleep_secs=1,
          rcv_tcp_adrlen, 
          i,
          round_id=1, round_id_n,
          train_id, train_id_n,
          pack_id, pack_id_n,
          ctr_code,
          ctr_code_cmnd,
          ctr_code_data,
          pack_sz=1500, 
          max_pack_sz,
          train_len=3,
          no_trains=1,
          train_spacing,
          train_no,
          trains_ackd, 
          trains_lost,
          file=0,
          errflg=0;
  
  char ctr_buff[8], pack_buf[MAX_PACK_SZ], random_data[MAX_PACK_SZ];
  char c, filename[256];

  struct timeval sleep_time, current_time, prior_sleep;
  
  short reset_flag, done, sleep_usecs;
  
  time_t localtm;
  
  FILE *pathrate_fp=NULL; 
  
  
  /* 
    Check command line arguments 
  */
  verbose = 1;
  iterative = 0;
  while ((c = getopt(argc, argv, "ivhHqo:")) != EOF)
  switch (c) {
    case 'i':
      iterative = 1;
      break;
    case 'q':
      Verbose=0;
      verbose=0;
      break;
    case 'v':
      Verbose=1;
      break;
    case 'o':
      file=1;
      strcpy(filename,optarg);
      break;
    case 'h':
      help() ;
      errflg++;
      break ;
    case 'H':
      help() ;
      errflg++;
      break ;
    case '?':
      errflg++; 
  }
  if (errflg) {
    (void)fprintf(stderr, "usage: pathrate_snd [-i] [-H|-h] [-q|-v] [-o <filename>] \n");
    exit (-1);
  } 
  if (file){
    pathrate_fp = fopen(filename,"w");
    fprintf(pathrate_fp, "\n\n");
  }

  /* Control stream: TCP connection */
  if ((sock_tcp=socket(AF_INET, SOCK_STREAM, 0)) < 0) {
    perror("socket(AF_INET,SOCK_STREAM,0):");
    exit(-1);
  }
  opt_len=1;
  if (setsockopt(sock_tcp, SOL_SOCKET, SO_REUSEADDR, (char*)&opt_len, sizeof(opt_len)) < 0) {
    perror("setsockopt(SOL_SOCKET,SO_REUSEADDR):");
    exit(-1);
  }
  bzero((char*)&snd_tcp_addr, sizeof(snd_tcp_addr));
  snd_tcp_addr.sin_family         = AF_INET;
  snd_tcp_addr.sin_addr.s_addr    = htonl(INADDR_ANY);
  snd_tcp_addr.sin_port           = htons(TCPSND_PORT);
  if (bind(sock_tcp, (struct sockaddr*)&snd_tcp_addr, sizeof(snd_tcp_addr)) < 0) {
    perror("bind(sock_tcp):");
    exit(-1);
  }
  if (listen(sock_tcp,1) < 0) {
    perror("listen(sock_tcp,1):");
    exit(-1);
  }
  
  
  /* 
    Data stream: UDP socket 
  */
  if ((sock_udp=socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
    perror("socket(AF_INET,SOCK_DGRAM,0):");
    exit(-1);
  }
  bzero((char*)&snd_udp_addr, sizeof(snd_udp_addr));
  snd_udp_addr.sin_family         = AF_INET;
  snd_udp_addr.sin_addr.s_addr    = htonl(INADDR_ANY);
  snd_udp_addr.sin_port           = htons(0);
  if (bind(sock_udp, (struct sockaddr*)&snd_udp_addr, sizeof(snd_udp_addr)) < 0) {
    perror("bind(sock_udp):");
    exit(-1);
  }
  send_buff_sz = UDP_BUFFER_SZ;
  if (setsockopt(sock_udp, SOL_SOCKET, SO_SNDBUF, (char*)&send_buff_sz, sizeof(send_buff_sz)) < 0) {
    perror("setsockopt(SOL_SOCKET,SO_SNDBUF):");
    exit(-1);
  }
  
  
  /*
          Check if select can give (roughly) sub-second time intervals
  */
  sleep_time.tv_sec = 0; 
  sleep_time.tv_usec = MIN_TRAIN_SPACING;
  gettimeofday(&prior_sleep,(struct timezone*)0);
  for (i=1;i<=10;i++){
    select(1,NULL,NULL,NULL,&sleep_time);
    sleep_time.tv_sec = 0;
    sleep_time.tv_usec=MIN_TRAIN_SPACING;
  }
  gettimeofday(&current_time,(struct timezone*)0);
  if ((time_to_us_delta(prior_sleep,current_time)<15*MIN_TRAIN_SPACING) &&
      (time_to_us_delta(prior_sleep,current_time)>5*MIN_TRAIN_SPACING))
    {sleep_usecs=1; train_spacing = MIN_TRAIN_SPACING;} 
  else 
    {sleep_usecs=0; train_spacing = TRAIN_SPACING_SEC;}
  
  
  do {
    if (file) fprintf(pathrate_fp,"\n\nWaiting for receiver to establish control stream => ");
    if (verbose) fprintf(stdout,"\n\nWaiting for receiver to establish control stream => ");
    fflush(stdout);
    
    /* 
      Wait until receiver attempts to connect, starting new measurement cycle
    */
    rcv_tcp_adrlen = sizeof(rcv_tcp_addr);
    ctr_strm = accept(sock_tcp, (struct sockaddr*)&rcv_tcp_addr, &rcv_tcp_adrlen);
    if (ctr_strm < 0) {
       perror("accept(sock_tcp):");
       exit(-1);
    }
    if (verbose) printf("OK\n");
    if (file) fprintf(pathrate_fp,"OK\n");
    
    localtm = time(NULL); gethostname(pack_buf, 256);
    host_rcv=gethostbyaddr((char*)&(rcv_tcp_addr.sin_addr), 
    sizeof(rcv_tcp_addr.sin_addr), AF_INET); 
    if (host_rcv!=NULL){
      if (file) fprintf(pathrate_fp,"Receiver %s starts measurements on %s", 
          host_rcv->h_name, ctime(&localtm));
      if (verbose) printf("Receiver %s starts measurements on %s", 
          host_rcv->h_name, ctime(&localtm));
    }
    else{
      if (file) fprintf(pathrate_fp,"Unknown receiver starts measurements on %s", 
          ctime(&localtm));
      if (verbose) printf("Unknown receiver starts measurements on %s", 
          ctime(&localtm));
    }
    
    
    /*
      Form receiving UDP address
    */
    bzero((char*)&rcv_udp_addr, sizeof(rcv_udp_addr));
    rcv_udp_addr.sin_family         = AF_INET;
    rcv_udp_addr.sin_addr.s_addr    = rcv_tcp_addr.sin_addr.s_addr; 
    rcv_udp_addr.sin_port           = htons(UDPRCV_PORT);
    
    
    
    /* 
      Bounce a number of empty messages back to the receiver, in order to measure RTT 
    */
    for (i=0; i<10; i++) {
      ctr_code=recv_ctr_msg(ctr_strm, ctr_buff);
      send_ctr_msg(ctr_strm, ctr_code);
    }
    
    /* 
      Create random packet payload to deal with links that do payload compression
    */
    srandom(getpid());
    for (i=0; i<MAX_PACK_SZ-1; i++) 
      random_data[i]=(char)(random()&0x000000ff);
    bzero((char*)&pack_buf, MAX_PACK_SZ);
    memcpy(pack_buf+2*sizeof(long), random_data, (MAX_PACK_SZ-1)-2*sizeof(sizeof(long)));
    
    
    if (file) fprintf(pathrate_fp, "Measurements are in progress. Please wait..\n");
    if (verbose) printf("Measurements are in progress. Please wait..\n");