/*

   cprobe.c - main routines for cprobe tool.

   $Header: /home/roycroft/carter/Ping+/rpr/src/Release/RCS/congtool.c,v 1.5 1996/07/10 18:56:07 carter Exp $

*/
#include "congtool.h"
#include <stdlib.h>

static char rcsid[] = "$Id: congtool.c,v 1.5 1996/07/10 18:56:07 carter Exp $";

char hostname[MAXHOSTNAMELEN];

void usage(){fprintf(stderr,"Usage: cprobe hostname\n");}


/* forward declarations */


void sortGaps(int gapCount, int *gaps, int *departGaps,
	      int *sortedGaps, int *sortedDGaps);

float probeLoop(char * hostName, int packetCount);

/* if we did not declare cprobe return float type here 
the result will be strange, the main() probabaly interpret cprobe as
integer 

float cprobe(char *hostName);

*/

int main(int argc, char *argv[])
{
  int npackets = 0;                         /* number of packets to send */
  float bandwidth;                      /* available bandwidth estimate */

  int i;

  if (argc != 2)
    {
      usage();
      exit(1);
    }

  printf("CPROBE (%s) %s\n",
	 VERSION, argv[1]);

  bandwidth = -1.0;

  bandwidth = sprobe(argv[1]);

  exit(0);
}		

float sprobe(char *host) {
  float result;
  result = probeLoop(host, 10);
  printf ("aprobe: probing result=%f\n", result);
  return result;
}

/* print stats for each received packet */
void reportResults(int npackets,
	      hw_time_t depart[], hw_time_t arrive[], int bytes[],
	      int returnCodes, int numPaths) {     
     int i = 0;


     for (i=0; i< npackets; i++){

       printf("pkt %d: %d bytes depart %d arrive %d rtt= %d us ", i, bytes[i], 
              depart[i], arrive[i], arrive[i] - depart[i]);
       if (arrive[i] > 0)
	 printf("\n");
       else
	 printf(" ++ lost ++\n");
     }
     printf("bytes    departT  arriveT \n=============================\n");
     for (i=0; i< npackets; i++){
	  printf("%5d %8d %8d\n", bytes[i], depart[i], arrive[i]);
	}

     if (returnCodes & PacketsInOrder) {
       printf(" SEQOK ");
     }
     else {
       printf(" NOTSEQOK ");
     }
     if (returnCodes & RecordRouteData) {
       printf(" RR");
     }
     else {
       printf(" NORR");
     }
     if (returnCodes & DuplicatePackets) {
       /* tack this string onto the end of the record route info flag
	  that way, it doesn't disrupt the processing by other scripts */
       printf("_DUP ");
     }
     else {
       printf(" ");
     }
       
     if (numPaths > 1) {
       printf("multipath: %d", numPaths);
     }
     printf("\n");

   }

float 
probeLoop(char * hostName, int packetCount) {
  int probeSize = 600;
  int bytesReceived;
  hw_time_t timeSpent;
  int numPaths = 0;  /* how many paths did the packets take ? */
  int returnCodes = 0;
  hw_time_t depart[MAX_PROBES];         /* dparture time of each packet */
  hw_time_t arrive[MAX_PROBES];         /* arrival time of each packet */
  int  packetSize[MAX_PROBES];
  int  bytes[MAX_PROBES];		      /* size of each packet */
  int  orderOK[MAX_PROBES];
  int  gaps[MAX_PROBES];
  int  departGaps[MAX_PROBES];
  int  sortedGaps[MAX_PROBES]; 
  int  sortedDGaps[MAX_PROBES]; 
  
  int  gapCount = 0;

  float estimate1 = 0.0, estimate2 = 0.0;


  float bandwidth = 0.0;
  float bandwidthVector[NUM_ROUNDS];
  float probeSizeVector[NUM_ROUNDS];
  int pass = 0;
  int  i = 0, j = 0;
  int validObservations = 0;
  int badIteration = 0;


/* Chow: look at this bug it was hard code with replace interanl 
         variable to be 8 while outside packetCount variable is 
         set to be 10.  A strange bug? intentionally put in? 
  packetCount = 8;
*/
  for(j=0;j<MAX_PROBES;j++) {
    bandwidthVector[j] = 0.0;
  }
  


    badIteration = 0; /* clear trouble flag */
     /* initialize Arrival vector */
     for (i = 0; i< packetCount; i++) {
       arrive[i] = -1;
     }
     /* marshal the packet size parameters for the call */

     for (i=0; i<packetCount; i++)
     {
       packetSize[i] = probeSize;
     }

     /* do the call */
     if (!rprobe(hostName, packetCount, packetSize,
	    depart, arrive, bytes, orderOK, &returnCodes, &numPaths,
		 30 /* minimum timeout in seconds */)) {
       /* successful probe, report results */
       reportResults(packetCount, depart, arrive, bytes, returnCodes, numPaths);
     }
     else {
       printf("FATAL ERROR\n");
       exit(-1);
     }
     if (!(returnCodes & PacketsInOrder))
       {
	 printf("LOGME Packets out of order. Cannot continue\n");
	 badIteration = 1;
       }
     if (returnCodes & DuplicatePackets) {
       printf("LOGME Duplicate Packets received. Cannot continue\n");
	 badIteration = 1;
     }
      printf("exactly %d gaps\n",packetCount - 1);
      timeSpent = arrive[packetCount-1] - arrive[0];
      printf("arrive[%d]=%d, arrve[0]=%d\n", packetCount-1, 
             arrive[packetCount-1], arrive[0]);
      printf("took %d microseconds between first and last pkt\n", timeSpent);
      bytesReceived =(probeSize + 42) * (packetCount-1);
      printf("sent %d bytes\n", bytesReceived);

  bandwidthVector[0] = ((float) bytesReceived * 8.0 * 1000000.0) 
	   / (float) timeSpent;
  printf("available bandwidth estimate %f\n", bandwidthVector[0]);
  
  return(bandwidthVector[0]);
} /* end probeLoop */