├── project_2.pdf
├── MNC_PROJ2_DOC.pdf
├── makefile
├── README.md
└── DistanceVectorRouting.cpp


/project_2.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/router/Distance-Vector/master/project_2.pdf


--------------------------------------------------------------------------------
/MNC_PROJ2_DOC.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/router/Distance-Vector/master/MNC_PROJ2_DOC.pdf


--------------------------------------------------------------------------------
/makefile:
--------------------------------------------------------------------------------
1 | Proj1: DistanceVectorRouting.cpp
2 | 	g++ DistanceVectorRouting.cpp -o server
3 | 	
4 | 	
5 | 	
6 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | Distance-Vector
2 | ===============
3 | 
4 | A simplified implementation of the Distance Vector Protocol. The protocol runs on top of servers (behaving as routers) using UDP. Each server runs on a machine at a pre-defined port number. The servers are able to output their forwarding tables along with the link costs and are robust to link changes. The current implementation faces the Count-to-infinity problem.
5 | 


--------------------------------------------------------------------------------
/DistanceVectorRouting.cpp:
--------------------------------------------------------------------------------
   1 | /*
   2 |  * DistanceVectorRouting.cpp
   3 |  *
   4 |  *  Created on: Nov 1, 2013
   5 |  *      Author: subhranil
   6 |  */
   7 | 
   8 | #include<stdio.h>
   9 | #include<sys/types.h>
  10 | #include<sys/socket.h>
  11 | #include<sys/stat.h>
  12 | #include<arpa/inet.h>
  13 | #include<cstdlib>
  14 | #include<netinet/in.h>
  15 | #include <ifaddrs.h>
  16 | #include<cstring>
  17 | #include<unistd.h>
  18 | #include<fcntl.h>
  19 | #include<pthread.h>
  20 | #include<errno.h>
  21 | #include <netdb.h>
  22 | #include <sys/time.h>
  23 | #include<signal.h>
  24 | #include<inttypes.h>
  25 | #define NODECOUNTMAX 100
  26 | #define MAXPACKETSIZE 10000
  27 | #define PROMPTVAR "DistanceVectorRouting>>"
  28 | #define MAXRETRY 3
  29 | 
  30 | int gTotalNumberOfNodes=0;
  31 | int gNumberOfNeighbours=0;
  32 | char gTopologyFileName[1024]="";
  33 | int gUpdateInterval=0;
  34 | char gLocalIP[50]="";
  35 | int16_t gLocalPort=0;
  36 | int32_t gLocalServerId=0;
  37 | struct timeval timeout;
  38 | int gUpdateCount=0;
  39 | typedef struct Node
  40 | {
  41 | 	int16_t id;
  42 | 	int32_t IP;
  43 | 	int16_t port;
  44 | 	int16_t nextHopId;
  45 | 	int16_t cost;
  46 | 	bool isActiveNeighbour;
  47 | 	int updateCount;
  48 | } Node;
  49 | 
  50 | //typedef struct TimeNode
  51 | //{
  52 | //	struct timeval lastTime;
  53 | //	int interval;
  54 | //} TimeNode;
  55 | 
  56 | typedef struct sockaddr_in SocketAddressInfo;
  57 | //typedef struct DistanceVectorNode
  58 | //{
  59 | //	Node dest;
  60 | //
  61 | //} DistanceVectorNode;
  62 | 
  63 | //Node nodeList[NODECOUNTMAX];// also the routing table
  64 | Node costList[NODECOUNTMAX]={{-1,0,-1,-1,-1}}; // weight of the connecting edge. contains entries only for the neighbours of this host
  65 | Node distanceVector[NODECOUNTMAX];//[NODECOUNTMAX];// this 2d matrix and grow to the N*N size in the worst case.
  66 | int16_t costMatrix[NODECOUNTMAX][NODECOUNTMAX]={(int16_t)-1};
  67 | // For the first two lists index 0 must be self and hence the costList[0]=0;
  68 | // cost list (id,cost) for each f the neighbours.
  69 | // Distance vector is a map betwen (id,minCost) with size  gTotalNumberOfNodes( must be allowed room to expand)
  70 | // distance vect
  71 | 
  72 | 
  73 | void init()
  74 | {
  75 | 	for(int i=0;i<NODECOUNTMAX;i++)
  76 | 	{
  77 | 		costList[i].IP=-1;
  78 | 		costList[i].port=-1;
  79 | 		costList[i].id=-1;
  80 | 		costList[i].cost=-1;
  81 | 		costList[i].nextHopId=-1;
  82 | 		costList[i].updateCount=MAXRETRY;
  83 | 		costList[i].isActiveNeighbour=false;
  84 | 
  85 | 		for(int j=0;j<NODECOUNTMAX;j++)
  86 | 		{
  87 | 			costMatrix[i][j]=-1;
  88 | 		}
  89 | 
  90 | 	}
  91 | 	memcpy(distanceVector,costList,sizeof(Node)*NODECOUNTMAX);
  92 | }
  93 | 
  94 | // This function returns the IP of the host
  95 | char* getLocalIP()
  96 | {
  97 | 	SocketAddressInfo *socketAddress; // this structure basically stores info about the socket address
  98 | 	socketAddress=(SocketAddressInfo*)malloc(sizeof(SocketAddressInfo));
  99 | 	socketAddress->sin_family=AF_INET;
 100 | 	socketAddress->sin_port=htons(53);
 101 | 	inet_pton(socketAddress->sin_family,"8.8.8.8",&(socketAddress->sin_addr));
 102 | 
 103 | 	//create a socket for connecting to server
 104 | 	int socketId=socket(AF_INET,SOCK_DGRAM,0);
 105 | 	if(socketId==-1)
 106 | 	{
 107 | 		printf("Error in creating socket");
 108 | 		return "";
 109 | 	}
 110 | 	int retConnect=connect(socketId,(struct sockaddr*)socketAddress,sizeof(SocketAddressInfo));
 111 | 	if(retConnect<0)
 112 | 	{
 113 | 		printf("connection with peer failed with error : %d",retConnect);
 114 | 		return "";
 115 | 	}
 116 | 
 117 | 	SocketAddressInfo localAddressInfo;
 118 | 	socklen_t len=sizeof(localAddressInfo);
 119 | 	getsockname(socketId,(struct sockaddr*)&localAddressInfo,&len);
 120 | 	char buffer[32];
 121 | 	inet_ntop(AF_INET,&localAddressInfo.sin_addr,buffer,sizeof(buffer));
 122 | 	return buffer;
 123 | }
 124 | 
 125 | 
 126 | int indexOfNodeWithId(int32_t id)
 127 | {
 128 | 	for(int i=0;i<gTotalNumberOfNodes;i++)
 129 | 	{
 130 | 		if(costList[i].id==id)
 131 | 			return i;
 132 | 	}
 133 | 	return -1;
 134 | }
 135 | 
 136 | int indexOfNodeWithIP(int32_t ip,int16_t port)
 137 | {
 138 | 	for(int i=0;i<gTotalNumberOfNodes;i++)
 139 | 	{
 140 | 		if(costList[i].IP==ip&&costList[i].port==port)
 141 | 			return i;
 142 | 	}
 143 | 	return -1;
 144 | }
 145 | 
 146 | //The function below creates the packet data from the distance vector of the host
 147 | 
 148 | char *createMessageFormatFromVector(int *numBytes)
 149 | {
 150 | 		char *mssg=(char*)malloc(12*gTotalNumberOfNodes+8);
 151 | 		memcpy(mssg+*numBytes,(int16_t*)&gTotalNumberOfNodes,2);
 152 | 		*numBytes+=2;
 153 | 		//memcpy(mssg+numberOfBytesWritten,(int16_t*))
 154 | 		memcpy(mssg+*numBytes,&costList[0].port,2);
 155 | 		*numBytes+=2;
 156 | //		int32_t tempIp=0;
 157 | //		inet_pton(AF_INET,,&tempIp);
 158 | 		memcpy(mssg+*numBytes,&costList[0].IP,4);
 159 | 		*numBytes+=4;
 160 | 		for(int i=0;i<gTotalNumberOfNodes;i++)
 161 | 		{
 162 | 			//int32_t tempIp=0;
 163 | 			//inet_pton(AF_INET,,&tempIp);
 164 | 			memcpy(mssg+*numBytes,&distanceVector[i].IP,4);
 165 | 			*numBytes+=4;
 166 | 			memcpy(mssg+*numBytes,&distanceVector[i].port,2);
 167 | 			*numBytes+=4;
 168 | 			memcpy(mssg+*numBytes,&distanceVector[i].id,2);
 169 | 			*numBytes+=2;
 170 | //			memcpy(mssg+*numBytes,&distanceVector[i].nextHopId,2);
 171 | //			*numBytes+=2;
 172 | 			memcpy(mssg+*numBytes,&distanceVector[i].cost,2);
 173 | 			*numBytes+=2;
 174 | 		}
 175 | 		return mssg;
 176 | }
 177 | 
 178 | //After receiving a message, the following function is called to parse the message and setup the cost matrix accordingly
 179 | Node* convertMessageIntoDistanceVector(char* message,int32_t *baseId)
 180 | {
 181 | 	int16_t tempVar;
 182 | 	int32_t temp;
 183 | 
 184 | 
 185 | 	int numberOfBytesRead=0;
 186 | 	memcpy(&tempVar,message+numberOfBytesRead,2);
 187 | 	numberOfBytesRead+=2;
 188 | 	Node* tempVector=(Node*)malloc(sizeof(Node)*tempVar); // creat the temp array
 189 | 	//gTotalNumberOfNodes=(int)tempVar; //change .. check this line
 190 | 	memcpy(&tempVar,message+numberOfBytesRead,2);
 191 | 	numberOfBytesRead+=2;
 192 | 	memcpy(&temp,message+numberOfBytesRead,4);
 193 | 	numberOfBytesRead+=4;
 194 | //	char IP[50];
 195 | //	inet_ntop(AF_INET,&temp,IP,50);
 196 | 
 197 | 	int baseindex=indexOfNodeWithIP(temp,tempVar);
 198 | 	if(!costList[baseindex].isActiveNeighbour)
 199 | 		return NULL;
 200 | 
 201 | 	/*//change .. what happens if new
 202 | 	neighbour(add to costlist)
 203 | 	has to be a new neighbour --> add to cost List (non neighbours dont send Dv's)
 204 | 	can be a newnon neighbour 0--> add directly to distance vector[0];
 205 | 	*/
 206 | 	//bool newNeighbour,newNode;
 207 | 	if(baseindex<0) // should never happen .this means that the node was  not there in the topology file
 208 | 	{
 209 | 		//printf("%hd-->%d\n",tempVar,temp);
 210 | 		printf("Invalid message received.\n");
 211 | 		fflush(stdout);
 212 | 		return NULL;
 213 | 	}
 214 | 	else
 215 | 	{
 216 | 
 217 | 		*baseId=costList[baseindex].id;
 218 | 
 219 | 
 220 | 		for(int j=0;j<gTotalNumberOfNodes;j++)
 221 | 		{
 222 | 			memcpy(&temp,message+numberOfBytesRead,4);
 223 | 			numberOfBytesRead+=4;
 224 | 			memcpy(&tempVar,message+numberOfBytesRead,2);
 225 | 			numberOfBytesRead+=4; // to handle the null
 226 | 			int index=indexOfNodeWithIP(temp,tempVar);
 227 | 			if(index<0) // this means that the node does not exist in the system .. should never happen.
 228 | 			{
 229 | 				//printf("%hd-->%d\n",tempVar,temp);
 230 | 				printf("Invalid message received.\n");
 231 | 				fflush(stdout);
 232 | 				return NULL;
 233 | 			}
 234 | 			else
 235 | 			{
 236 | 				tempVector[index].IP=temp;
 237 | 				tempVector[index].port=tempVar;
 238 | 				memcpy(&tempVector[index].id,message+numberOfBytesRead,2);
 239 | 				numberOfBytesRead+=2;
 240 | //				memcpy(&tempVector[index].nextHopId,message+numberOfBytesRead,2);
 241 | //				numberOfBytesRead+=2;
 242 | 				memcpy(&tempVector[index].cost,message+numberOfBytesRead,2);
 243 | 				numberOfBytesRead+=2;
 244 | 				costList[baseindex].updateCount=MAXRETRY;
 245 | 				costMatrix[baseindex][index]=tempVector[index].cost;
 246 | 
 247 | //				if(costList[baseindex].updateCount==0)
 248 | //					costList[baseindex].updateCount=MAXRETRY;
 249 | //				else
 250 | //					costList[baseindex].updateCount++;
 251 | //				// check if this is a new neighbour
 252 | 
 253 | 
 254 | 				//The following code is not needed since the update command will be executed on both ends of the link
 255 | 
 256 | //				if(index==0&&costList[0].id==tempVector[index].nextHopId)
 257 | //				{
 258 | //					if(costList[baseindex].cost==-1)
 259 | //					{
 260 | //						printf("New neighbour added. id:%hd",costList[baseindex].id);
 261 | //						gNumberOfNeighbours++;
 262 | //					}
 263 | //					else if(costList[baseindex].cost!=tempVector[index].cost)
 264 | //						printf("Edge weight between %hd updated",costList[baseindex].id);
 265 | //
 266 | //					costList[baseindex].cost=tempVector[index].cost;
 267 | //					//printf("edge weight updated\n");
 268 | //					//gNumberOfNeighbours++;
 269 | //				}
 270 | 			}
 271 | 
 272 | 		}
 273 | 		gUpdateCount++;
 274 | 		printf("RECEIVED A MESSAGE FROM SERVER %hd\n",*baseId);
 275 | 		fflush(stdout);
 276 | 	}
 277 | 
 278 | 
 279 | 	return tempVector;
 280 | 
 281 | }
 282 | 
 283 | // Flushes the distance vector of the host.
 284 | void resetDistanceVector()
 285 | {
 286 | 	for (int i=1;i<gTotalNumberOfNodes;i++)
 287 | 	{
 288 | 		distanceVector[i].cost=-1;
 289 | 		costMatrix[0][i]=-1;
 290 | 	}
 291 | }
 292 | 
 293 | 
 294 | //Implements the Bellman Ford Algo to update the distance vector of the host. The isinit parameter toggles initialization and update cases.
 295 | 
 296 | void updateSelfDistanceVectorWithVector(bool isInit)
 297 | {
 298 | 	//int index=indexOfNodeWithId(id);
 299 | 	//int32_t baseCost=costList[index].cost; //can never be < 0
 300 | 	//costMatrix[0][0]=0;
 301 | 	for(int i=1; i<gTotalNumberOfNodes;i++) // we dont need update to self route
 302 | 	{
 303 | 		//bellman ford implementation
 304 | 
 305 | 		if(isInit) // initialization case
 306 | 		{
 307 | 			distanceVector[i].cost=costList[i].cost;
 308 | 			distanceVector[i].nextHopId=costList[i].id;
 309 | 			costMatrix[0][i]=costList[i].cost;
 310 | 			//costMatrix[i][i]=0;
 311 | 			continue;
 312 | 		}
 313 | 		//int16_t minCost=costMatrix[0][i], minHop=distanceVector[i].nextHopId;
 314 | 		int16_t minCost=-1,minHop=-1;
 315 | 		// loop over all neighbours
 316 | 		for(int j=1;j<gTotalNumberOfNodes;j++)
 317 | 		{
 318 | 			int16_t baseCost=costList[j].cost; //can never be < 0
 319 | 			if(baseCost<0||!costList[j].isActiveNeighbour)// not a neighnour
 320 | 				continue;
 321 | 
 322 | 			//int16_t value=baseCost+costMatrix[j][i].cost;
 323 | 			//printf("i:%d-->j%d-->minCost:%hd---->costMatrix[j][i]:%hd-->baseCost:%hd\n",i,j,minCost,costMatrix[j][i],baseCost);
 324 | 			if(minCost==(int16_t)-1&&costMatrix[j][i]==(int16_t)-1) // you cant help me :( // neither your nor the peer can reach
 325 | 			{
 326 | 				if(i==j) // this new condition is being added since we now have something to reset
 327 | 				{
 328 | 					minCost=baseCost;
 329 | 					minHop=costList[i].id;
 330 | 				}
 331 | 			}
 332 | 			else if(minCost==(int16_t)-1) // you cannot reach but your peer can reach
 333 | 			{
 334 | 				minCost=baseCost+costMatrix[j][i];
 335 | 				minHop=costList[j].id;
 336 | 			}
 337 | 			else if(costMatrix[j][i]!=(int16_t)-1)
 338 | 			{
 339 | 				int16_t value=baseCost+costMatrix[j][i];
 340 | 				if(value<minCost)
 341 | 				{
 342 | 					minCost=value;
 343 | 					minHop=costList[j].id;
 344 | 				}
 345 | 			}
 346 | 
 347 | 		}// finished looping over neighbours
 348 | 
 349 | 		if(minCost>0)
 350 | 		{
 351 | 			distanceVector[i].cost=minCost;
 352 | 			distanceVector[i].nextHopId=minHop;
 353 | 			costMatrix[0][i]=minCost;
 354 | 		}
 355 | 
 356 | 		/*int32_t value;=(costList[i].cost==(int16_t)-1||v[i].cost==(int16_t)-1)?-1:(costList[i].cost+v[i].cost) ;
 357 | 		if(distanceVector[i].cost==-1)
 358 | 			distanceVector[i].cost=value;
 359 | 		else if(value<=distanceVector[i].cost)
 360 | 		{
 361 | 			distanceVector[i].cost=value;
 362 | 			distanceVector[i].nextHopId=id;
 363 | 		}*/
 364 | 	}
 365 | }
 366 | 
 367 | // Sends out the distance vector to all active neighbours. Also checks if any of the neighbours have died.(3 misses case)
 368 | void broadcastDistanceVectorToNeighbours(int isAuto)
 369 | {
 370 | 	int numberOfBytesWritten=0;
 371 | 	char* message=createMessageFormatFromVector(&numberOfBytesWritten);
 372 | 	// structure created successfully for sending.
 373 | 	// send to all the neighbours
 374 | 	for(int i=1;i<gTotalNumberOfNodes;i++)
 375 | 	{
 376 | 		if(costList[i].isActiveNeighbour)
 377 | 		{
 378 | 			// check for corresponding timer value
 379 | //			struct timeval currTime;
 380 | //			gettimeofday(&currTime,NULL);
 381 | 			if(isAuto)
 382 | 				costList[i].updateCount--;
 383 | 			if(costList[i].updateCount==0)
 384 | 			//if(timerList[i].lastTime.tv_sec!=0 && currTime.tv_sec-timerList[i].lastTime.tv_sec>=(3*gUpdateInterval))
 385 | 			{
 386 | 				costList[i].cost=-1;
 387 | //				distanceVector[i].cost=-1;
 388 | //				costMatrix[0][i]=-1;
 389 | 				resetDistanceVector();
 390 | 				updateSelfDistanceVectorWithVector(false);
 391 | 				gNumberOfNeighbours--;
 392 | 				printf("Neighbour with id:%hd has gone down.\n",costList[i].id);
 393 | 				costList[i].updateCount=-1;
 394 | 				continue;
 395 | 			}
 396 | 			//int sockId=createUDPSocket(costList[i].IP,costList[i].port);
 397 | 
 398 | 			SocketAddressInfo *socketAddress; // this structure basically stores info about the socket address
 399 | 			socketAddress=(SocketAddressInfo*)malloc(sizeof(SocketAddressInfo));
 400 | 			socketAddress->sin_family=AF_INET;
 401 | 			socketAddress->sin_port=htons(costList[i].port);
 402 | 			socketAddress->sin_addr.s_addr=costList[i].IP;
 403 | 			//inet_pton(socketAddress->sin_family,ip,&(socketAddress->sin_addr));
 404 | 
 405 | 			//create a socket for connecting to server
 406 | 			int socketId=socket(AF_INET,SOCK_DGRAM,0);
 407 | 			int slen=sizeof(SocketAddressInfo);
 408 | 			int retV=sendto(socketId,message,numberOfBytesWritten,0,(struct sockaddr*)socketAddress,(socklen_t)slen);
 409 | 			//printf("err:%d-->ret:%d",errno,retV);
 410 | 			fflush(stdout);
 411 | 			close(socketId);
 412 | 
 413 | 		}
 414 | 	}
 415 | 	free(message);
 416 | }
 417 | 
 418 | int compare(const void* a, const void* b)
 419 | {
 420 | 	return (int)(((Node*)a)->id-((Node*)b)->id);
 421 | }
 422 | 
 423 | // prints the routing table in the specified format.
 424 | void displayRoutingTable()
 425 | {
 426 | 	//printf("gTotalNumberOfNodes:%hd",gTotalNumberOfNodes);
 427 | 	Node* tempDV=(Node*)malloc(sizeof(Node)*gTotalNumberOfNodes);
 428 | 	memcpy(tempDV,distanceVector,sizeof(Node)*gTotalNumberOfNodes);
 429 | 	qsort(tempDV,gTotalNumberOfNodes,sizeof(Node),&compare);
 430 | 	for(int i=0;i<gTotalNumberOfNodes;i++)
 431 | 	{
 432 | 		char cost[8];
 433 | 		if(tempDV[i].cost==-1)
 434 | 			strcpy(cost,"inf");
 435 | 		else
 436 | 			sprintf(cost,"%hd",tempDV[i].cost);
 437 | 		printf("%hd\t%hd\t%s\n",tempDV[i].id,tempDV[i].nextHopId,cost);
 438 | 	}
 439 | 	fflush(stdout);
 440 | }
 441 | 
 442 | 
 443 | void updateTimer(int id)
 444 | {
 445 | 
 446 | }
 447 | 
 448 | // Assumption : There will be less than 10 nodes in the setup.
 449 | int parseStringAndGetLocaLServerId(char *str)
 450 | {
 451 | 	int i=0;
 452 | 	int index=strlen(str)-2;
 453 | 	while(index>0)
 454 | 	{
 455 | 		if(str[index]=='\n')
 456 | 			break;
 457 | 		index--;
 458 | 	}
 459 | 	//char *ptr=strrchr(str,'\n');
 460 | 	//ptr++;
 461 | 	return (str[index+1]-'0');
 462 | 
 463 | }
 464 | 
 465 | // Read the topology file and setup the costList[] and distanceVector[] arrays.
 466 | void initialiseLists()
 467 | {
 468 | 	try
 469 | 	{
 470 | 	int fd=open(gTopologyFileName,O_RDONLY);
 471 | 	//printf("%d",errno);
 472 | 	//cgange remove hardbound by calc filesize by stat
 473 | 	char buffer[5000];
 474 | 	read(fd,buffer,5000);
 475 | 	int baseId=parseStringAndGetLocaLServerId(buffer);
 476 | 	char line[200],*saveptr1,*saveptr2;
 477 | 	//strcpy(line,strtok_r(buffer,"\n",&saveptr1));
 478 | 	strcpy(line,strtok(buffer,"\n"));
 479 | 
 480 | 	gTotalNumberOfNodes=atoi(line);
 481 | 	//strcpy(line,strtok_r(NULL,"\n",&saveptr1));
 482 | 	strcpy(line,strtok(NULL,"\n"));
 483 | 	gNumberOfNeighbours=atoi(line);
 484 | 	for(int i=1,linecount=0;linecount<gTotalNumberOfNodes;linecount++)
 485 | 	{
 486 | 		//strcpy(line,strtok_r(NULL,"\n"));
 487 | 		strcpy(line,strtok(NULL,"\n"));
 488 | 		int16_t id,port;
 489 | 		char IP[50];
 490 | 		/*char* tok;
 491 | 		tok=strtok_r(line," ",&saveptr2);
 492 | 		sscanf(tok,"%i",&id);
 493 | 		//id=atoi(tok);
 494 | 		tok=strtok_r(NULL," ",&saveptr2);
 495 | 		strcpy(IP,tok);
 496 | 
 497 | 
 498 | 		tok=strtok_r(NULL," ",&saveptr2);
 499 | 		sscanf(tok,"%i",&port);*/
 500 | 
 501 | 
 502 | 		sscanf(line,"%hd%s%hd",&id,IP,&port);
 503 | 		struct in_addr IP_Net;
 504 | 		inet_aton(IP,&IP_Net);
 505 | 		//port=atoi(tok);
 506 | 		//if(id==(int16_t)baseId) // add at 0th index
 507 | 		if(strcmp(gLocalIP,IP)==0)
 508 | 		{
 509 | 			//strcpy(costList[0].IP,IP);
 510 | 			costList[0].IP=IP_Net.s_addr;
 511 | 			costList[0].id=id;
 512 | 			costList[0].nextHopId=-1;
 513 | 			costList[0].port=port;
 514 | 			gLocalPort=(int16_t)port;
 515 | 			costList[0].cost=(int16_t)0;
 516 | 			//testing
 517 | 			//strcpy(gLocalIP,"");
 518 | 
 519 | 			distanceVector[0].IP=IP_Net.s_addr;
 520 | 			distanceVector[0].id=id;
 521 | 			distanceVector[0].nextHopId=0;
 522 | 			distanceVector[0].port=port;
 523 | 			distanceVector[0].cost=0;
 524 | 			costMatrix[0][0]=0;
 525 | 		}
 526 | 		else
 527 | 		{
 528 | 			//strcpy(costList[i].IP,IP);
 529 | 			costList[i].IP=IP_Net.s_addr;
 530 | 			costList[i].id=id;
 531 | 			costList[i].nextHopId=-1;
 532 | 			costList[i].port=port;
 533 | 
 534 | 
 535 | 			distanceVector[i].IP=IP_Net.s_addr;
 536 | 			distanceVector[i].id=id;
 537 | 			distanceVector[i].port=port;
 538 | 			//distanceVector[i].nextHopId=id;
 539 | 			i++;
 540 | 		}
 541 | 	}
 542 | 	//saveptr2=NULL;
 543 | // add the costs to the costList array
 544 | 	for(int i=0;i<gNumberOfNeighbours;i++)
 545 | 	{
 546 | 		//change handle source !=localid case
 547 | 			//strcpy(line,strtok_r(NULL,"\n",&saveptr1));
 548 | 		strcpy(line,strtok(NULL,"\n"));
 549 | 		int32_t  source,dest,cost;
 550 | 			/*char IP[50] ;
 551 | 			char* tok;
 552 | 			tok =strtok_r(line," ",&saveptr2);
 553 | 			source=atoi(tok);
 554 | 			tok=strtok_r(NULL," ",&saveptr2);
 555 | 			//dest=atoi(tok);
 556 | 			sscanf(tok,"%i",&dest);
 557 | 
 558 | 			tok=strtok_r(NULL," ",&saveptr2);
 559 | 			sscanf(tok,"%i",&cost);*/
 560 | 
 561 | 			sscanf(line,"%hd%hd%hd",&source, &dest,&cost);
 562 | 			//cost=atoi(tok);
 563 | 			int index=indexOfNodeWithId(dest);
 564 | 			if(index<0) // should never happen
 565 | 				continue;
 566 | 			costList[index].cost= cost;
 567 | 			costList[index].isActiveNeighbour=true;
 568 | 		}
 569 | 	}
 570 | 	catch(...)
 571 | 	{
 572 | 		printf("Invalid topology file. Exiting...\n");
 573 | 		fflush(stdout);
 574 | 		exit(0);
 575 | 	}
 576 | 	updateSelfDistanceVectorWithVector(true);
 577 | 
 578 | }
 579 | 
 580 | // Parses the command line arguments and sets up the global variables accordingly.
 581 | void parseShellArguments(int argc,char *argv[])
 582 | {
 583 | 	int index=1;
 584 | 	try
 585 | 	{
 586 | 	while(index<argc)
 587 | 	{
 588 | 		if(strcmp(argv[index],"-t")==0)
 589 | 		{
 590 | 			strcpy(gTopologyFileName,argv[++index]);
 591 | 			index++;
 592 | 		}
 593 | 		else if(strcmp(argv[index],"-i")==0)
 594 | 		{
 595 | 			gUpdateInterval=atoi(argv[++index]);
 596 | 			index++;
 597 | 		}
 598 | 		else
 599 | 		{
 600 | 			printf("Unknown option");
 601 | 			exit(0);
 602 | 		}
 603 | 	}
 604 | 	}
 605 | 	catch(...)
 606 | 	{
 607 | 		printf("Invalid usage\n");
 608 | 		exit(0);
 609 | 	}
 610 | }
 611 | 
 612 | 
 613 | void resetToPrompt()
 614 | {
 615 | 
 616 | 	printf(PROMPTVAR);
 617 | 	fflush(stdout);
 618 | }
 619 | 
 620 | // Handles the queries and exchange commands from the user.
 621 | void displayShell()
 622 | {
 623 | 	char inputLine[1024];
 624 | 
 625 | 	//fflush(stdout);
 626 | 	fgets(inputLine,1024,stdin);
 627 | 	char *command;//[30];
 628 | 	command=strtok(inputLine,"\n");
 629 | 	command=strtok(inputLine," ");
 630 | 	//	strcpy(command,strtok(inputLine,"\n"));
 631 | 	//strcpy(command,strtok(inputLine," "));
 632 | 	//printf("command:%s\n",command);
 633 | 	if(!command)
 634 | 	{
 635 | 		resetToPrompt();
 636 | 		return;
 637 | 	}
 638 | 
 639 | 	if(!strcmp(command,"step"))
 640 | 	{
 641 | 		broadcastDistanceVectorToNeighbours(false);
 642 | 		printf("step SUCCESS\n");
 643 | 		timeout.tv_sec=gUpdateInterval;
 644 | 		timeout.tv_usec=0;
 645 | 		resetToPrompt();
 646 | 	}
 647 | 
 648 | 	else if(!strcmp(command,"MYIP"))
 649 | 	{
 650 | 		printf("%s\n",gLocalIP);
 651 | 		resetToPrompt();
 652 | 	}
 653 | 	else if(!strcmp(command,"display"))
 654 | 	{
 655 | 		printf("display: SUCCESS\n");
 656 | 		displayRoutingTable();
 657 | 		resetToPrompt();
 658 | 	}
 659 | 
 660 | 	else if(!strcmp(command,"packets"))
 661 | 	{
 662 | 		printf("packets: SUCCESS\n");
 663 | 		printf("Number of distance vector updates received:%d\n",gUpdateCount);
 664 | 		gUpdateCount=0;
 665 | 		resetToPrompt();
 666 | 
 667 | 	}
 668 | 	else if(!strcmp(command,"crash"))
 669 | 	{
 670 | 		printf("Server crashed\n");
 671 | 		while(1);
 672 | 
 673 | 	}
 674 | 	else if(!strcmp(command,"update"))
 675 | 	{
 676 | 		try {
 677 | 		int16_t id1=0,id2=0,c=0;
 678 | 		char cost[8]="";
 679 | 
 680 | 		char *t=strtok(NULL," ");
 681 | 		if(t==NULL)
 682 | 		{
 683 | 			printf("Invalid usage.\n");
 684 | 			resetToPrompt();
 685 | 			return;
 686 | 		}
 687 | 		sscanf(t,"%hd",&id1);
 688 | 
 689 | 		t=strtok(NULL," ");
 690 | 		if(t==NULL)
 691 | 		{
 692 | 			printf("Invalid usage.\n");
 693 | 			resetToPrompt();
 694 | 			return;
 695 | 		}
 696 | 		sscanf(t,"%hd",&id2);
 697 | 
 698 | 		t=strtok(NULL," ");
 699 | 		if(t==NULL)
 700 | 		{
 701 | 			printf("Invalid usage.\n");
 702 | 			resetToPrompt();
 703 | 			return;
 704 | 		}
 705 | 
 706 | 		sscanf(t,"%s",&cost);
 707 | 
 708 | 		if(id1<=0||id2<=0||strlen(cost)==0)
 709 | 		{
 710 | 			printf("update: FAILURE: Invalid or empty parameters.\n");
 711 | 			resetToPrompt();
 712 | 			return;
 713 | 		}
 714 | 		if(strcmp(cost,"inf")==0)
 715 | 			c=-1;
 716 | 		else
 717 | 			sscanf(cost,"%hd",&c);
 718 | 		int i=indexOfNodeWithId(id1);
 719 | 		if(i!=0)
 720 | 		{
 721 | 			printf("update: FAILURE: Server id1 is not the local host.\n");
 722 | 			resetToPrompt();
 723 | 			return;
 724 | 		}
 725 | 		int index=indexOfNodeWithId(id2);
 726 | 		if(index==-1)
 727 | 		{
 728 | 			printf("update: FAILURE: Server id2 is not a valid id.\n");
 729 | 			resetToPrompt();
 730 | 			return;
 731 | 		}
 732 | 		costList[index].cost=c;
 733 | 		costList[index].isActiveNeighbour=true;
 734 | 		costList[index].updateCount=MAXRETRY;
 735 | 		//printf("setting costlist[%d]:%hd",index,c);
 736 | //		distanceVector[index].cost=-1;
 737 | //		costMatrix[0][index]=-1;
 738 | 		resetDistanceVector();
 739 | 		updateSelfDistanceVectorWithVector(false);
 740 | 		printf("update: SUCCESS\n");
 741 | 		resetToPrompt();
 742 | 		}
 743 | 		catch(...)
 744 | 		{
 745 | 			printf("Invalid usage.\n");
 746 | 			resetToPrompt();
 747 | 			return;
 748 | 		}
 749 | 	}
 750 | 	else if(!strcmp(command,"disable"))
 751 | 	{
 752 | 		try {
 753 | 		int16_t id=0;
 754 | 		char* t=strtok(NULL," ");
 755 | 		if(t==NULL)
 756 | 		{
 757 | 			printf("Invalid usage.\n");
 758 | 			resetToPrompt();
 759 | 			return;
 760 | 		}
 761 | 		sscanf(t,"%hd",&id);
 762 | 
 763 | 
 764 | 		int index=indexOfNodeWithId(id);
 765 | 		if(index<0||costList[index].cost==-1)
 766 | 		{
 767 | 			printf("disable: FAILED since server id is not a neighbour\n");
 768 | 			resetToPrompt();
 769 | 		}
 770 | 		else
 771 | 		{
 772 | 			costList[index].cost=-1;
 773 | //			distanceVector[index].cost=-1;
 774 | //			costMatrix[0][index]=-1;
 775 | 			resetDistanceVector();
 776 | 			costList[index].isActiveNeighbour=false;
 777 | 			updateSelfDistanceVectorWithVector(false);
 778 | 			printf("disable: SUCCESS\n");
 779 | 			resetToPrompt();
 780 | 		}
 781 | 		}
 782 | 		catch(...)
 783 | 		{
 784 | 			printf("Invalid usage.\n");
 785 | 			resetToPrompt();
 786 | 			return;
 787 | 		}
 788 | 	}
 789 | 
 790 | 	/*else if(!strcmp(command,"CONNECT"))
 791 | 	{
 792 | 		if(isServer)
 793 | 		{
 794 | 			printf("Invalid Command\n");
 795 | 			resetToPrompt();
 796 | 			return;
 797 | 		}
 798 | 		char *peerIP;//[40];
 799 | 				//strcpy(tempServerIP,strtok(NULL," "));
 800 | 		peerIP=strtok(NULL," ");
 801 | 		char *portStr;//[5];
 802 | 		portStr=strtok(NULL," ");
 803 | 		//if(!strlen(peerIP)||strlen(portStr))
 804 | 		if(!peerIP||!portStr|| !strlen(peerIP)||!strlen(portStr))
 805 | 			printf("Invalid Command Format.\n");
 806 | 		else
 807 | 		{
 808 | 			// check for the validity of the connection
 809 | 			char *fIP=(char*)malloc(40);
 810 | 			int fPort;
 811 | 			char *errString=(char*)malloc(500);
 812 | 			bool status=completeRequestAndCheckValidity(peerIP,portStr,&fPort,&fIP,&errString);
 813 | 			if(!status)
 814 | 			{
 815 | 				printf("%s",errString);
 816 | 				free(errString);
 817 | 				resetToPrompt();
 818 | 				return;
 819 | 			}
 820 | 			printf("Trying to connect to %s at port %d\n",fIP,fPort);
 821 | 			TCPSocketConnection *peerConnectConn=new TCPSocketConnection(fIP,fPort,0);
 822 | 			char connectReqMessage[1024];
 823 | 			sprintf(connectReqMessage,"ConnectRequest\n%s\n%d\n%s\n",hostIP,localPort,localHostName);
 824 | 			peerConnectConn->sendData(connectReqMessage);
 825 | 			addConnection(peerConnectConn);
 826 | 			free(fIP);
 827 | 			//resetToPrompt();
 828 | 
 829 | 		}
 830 | 
 831 | 	}
 832 | 	else if(!strcmp(command,"LIST"))
 833 | 	{
 834 | 		listConnections();
 835 | 		resetToPrompt();
 836 | 
 837 | 	}
 838 | 
 839 | 	else if(!strcmp(command,"DOWNLOAD"))
 840 | 	{
 841 | 		if(isServer)
 842 | 		{
 843 | 			printf("Invalid Command\n");
 844 | 			resetToPrompt();
 845 | 			return;
 846 | 		}
 847 | 
 848 | 		char *fileName=strtok(NULL," ");
 849 | 		char *chunkSizeStr=strtok(NULL," ");
 850 | 		if(!fileName||!chunkSizeStr|| !strlen(fileName)||!strlen(chunkSizeStr))
 851 | 			printf("Invalid Command Format.\n");
 852 | 		else
 853 | 		{
 854 | 			downloadActive=true;
 855 | 			lastWrittenByte=0;
 856 | 			downloadFile(fileName,atoi(chunkSizeStr),-1,NULL);
 857 | 		}
 858 | 		printf("Downloading %s...\n",fileName);
 859 | 		resetToPrompt();
 860 | 	}
 861 | 
 862 | 	else if(!strcmp(command,"TERMINATE"))
 863 | 	{
 864 | 		char *idStr;
 865 | 		idStr=strtok(NULL," ");
 866 | 		if(strlen(idStr)==0)
 867 | 			printf("Invalid Usage.\n");
 868 | 		else
 869 | 		{
 870 | 			if(terminateConnection(atoi(idStr),false))
 871 | 				printf("Connection Terminated.\n");
 872 | 			else
 873 | 				printf("Operation not permitted.\n");
 874 | 		}
 875 | 
 876 | 
 877 | 		resetToPrompt();
 878 | 	}
 879 | 	else if(!strcmp(command,"EXIT"))
 880 | 	{
 881 | 		terminateAllConnections();
 882 | 		//printf("\n*** Transferred %lld bytes in %lld us\n",totalBytesTransferred,totalTimeInMicroSecs);
 883 | 		exit(0);
 884 | 	}
 885 | 
 886 | 	else if(!strcmp(command,"SIP"))
 887 | 	{
 888 | 		displayServerIPList();
 889 | 		resetToPrompt();
 890 | 	}
 891 | 	else if(!strcmp(command,"CREATOR"))
 892 | 	{
 893 | 		printf("Name:Subhranil Banerjee\nUBITName:subhrani\nEmail:subhrani@buffalo.edu\n");
 894 | 		resetToPrompt();
 895 | 	}
 896 | */
 897 | 	else
 898 | 	{
 899 | 		printf("Command not found.\n");
 900 | 		resetToPrompt();
 901 | 	}
 902 | 
 903 | 	//}
 904 | 
 905 | }
 906 | 
 907 | 
 908 | // Receives data on the UDP socket. Also contains the implementation of the timer.
 909 | void setupReceiver()
 910 | {
 911 | 	//int sendFileDesc,recvFileDesc;
 912 | 
 913 | 	/* observedSockets file descriptor list and max value */
 914 | 	fd_set observedSockets;
 915 | 	int fdmax;
 916 | 	int mainSocket;
 917 | 	// defining the address for the main socket
 918 | 
 919 | 	SocketAddressInfo *socketAddress; // this structure basically stores info about the socket address
 920 | 	socketAddress=(SocketAddressInfo*)malloc(sizeof(SocketAddressInfo));
 921 | 	socketAddress->sin_family=AF_INET;
 922 | 
 923 | 	inet_pton(socketAddress->sin_family,gLocalIP,&(socketAddress->sin_addr));
 924 | 	socketAddress->sin_port=htons(gLocalPort);
 925 | 
 926 | 	//create a socket for accepting incoming connections
 927 | 
 928 | 	mainSocket=socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);
 929 | 	if(mainSocket==-1)
 930 | 	{
 931 | 		printf("Error in creating socket");
 932 | 		exit(0);
 933 | 	}
 934 | 
 935 | 	// bind the socket to the addressinfo
 936 | 
 937 | 	if(bind(mainSocket,(struct sockaddr*)socketAddress,sizeof(SocketAddressInfo))==-1)
 938 | 	{
 939 | 		printf("Error in binding socket IP address");
 940 | 		exit(0);
 941 | 	}
 942 | 
 943 | 	// Begin code for socket listening
 944 | 
 945 | 	/* clear the observedSockets and temp sets */
 946 | 	FD_ZERO(&observedSockets);
 947 | 
 948 | 
 949 | 	timeout.tv_sec=gUpdateInterval;
 950 | 	timeout.tv_usec=0;
 951 | 	// run loop for observing sockets
 952 | 
 953 | 	while(true)
 954 | 	{
 955 | 		/* add the listener to the observedSockets set */
 956 | 		FD_SET(mainSocket, &observedSockets);
 957 | 		FD_SET(0,&observedSockets);
 958 | 
 959 | 		/* keep track of the biggest file descriptor */
 960 | 		fdmax = mainSocket ; /* so far, it's this one*/
 961 | 
 962 | 
 963 | 		int activity=select(fdmax+1,&observedSockets,NULL,NULL,&timeout); // blocking all until there is some activity on any of the sockets
 964 | 		if(activity<0)
 965 | 		{
 966 | 			if(errno==EINTR)
 967 | 				continue;
 968 | 			printf("error in select");
 969 | 			return ;
 970 | 		}
 971 | 		else if(activity==0)
 972 | 		{
 973 | 			broadcastDistanceVectorToNeighbours(true);
 974 | 			timeout.tv_sec=gUpdateInterval;
 975 | 			timeout.tv_usec=0;
 976 | 		}
 977 | 		else {
 978 | 		if(FD_ISSET(mainSocket,&observedSockets)) // .. there has been activity on the mainSocket. thus there s a new connection that needs to be added
 979 | 		{
 980 | 			char incomingMessage[MAXPACKETSIZE];
 981 | 			int numberOfBytesRecvd=0;
 982 | 			numberOfBytesRecvd=recv(mainSocket,&incomingMessage,MAXPACKETSIZE-1,0);
 983 | 
 984 | 			//Handle the data
 985 | 			int32_t id;
 986 | 			Node* incomingVector=convertMessageIntoDistanceVector(incomingMessage,&id);
 987 | 
 988 | 
 989 | 			//resetToPrompt();
 990 | 			updateSelfDistanceVectorWithVector(false);
 991 | 
 992 | 		}
 993 | 		else if(FD_ISSET(0,&observedSockets))
 994 | 		{
 995 | 					displayShell();
 996 | 		}
 997 | 		}
 998 | 	}
 999 | 
1000 | }
1001 | int main(int argc,char *argv[])
1002 | {
1003 | 	init();
1004 | 	parseShellArguments(argc,argv);
1005 | 	strcpy(gLocalIP,getLocalIP());
1006 | 	initialiseLists();
1007 | 	resetToPrompt();
1008 | 	setupReceiver();
1009 | }
1010 | 
1011 | 
1012 | 
1013 | 
1014 | 


--------------------------------------------------------------------------------