From aaacd66f62807fd7236cf5b692dee401ae447d89 Mon Sep 17 00:00:00 2001 From: Nathan Blais Date: Sun, 29 Mar 2020 20:09:58 -0700 Subject: [PATCH 01/28] h --- Node.nc | 9 ++++ TestSim.py | 2 +- includes/socket.h | 8 +-- lib/interfaces/Transport.nc | 2 +- lib/modules/TransportC.nc | 6 +++ lib/modules/TransportP.nc | 101 ++++++++++++++++++++++++++++++------ 6 files changed, 106 insertions(+), 22 deletions(-) diff --git a/Node.nc b/Node.nc index fe38f6e..6e97304 100644 --- a/Node.nc +++ b/Node.nc @@ -141,6 +141,7 @@ implementation{ event void CommandHandler.setTestClient(uint8_t srcPort, uint8_t destination, uint8_t destPort, uint8_t *payload){ socket_addr_t destAddr; + uint8_t i, AmountWritten; destAddr.addr = destination; //filled with usless info destAddr.port = destPort; //filled with usless info if(call Transport.bind(srcPort, &destAddr)) @@ -148,6 +149,14 @@ implementation{ if(call Transport.connect(srcPort, &destAddr)) return; + //save the value here into a holder to read for bugtesting + + for(i=0; payload[i] != '\0'; i++ ){} + + dbg(TRANSPORT_CHANNEL, "sizeof(payload): %d\n", i); + + AmountWritten = call Transport.write(srcPort,payload,i); + //add the payload to a que to be cut up and packaged to be sent after connection //Set off timer to close or resend it after an amount of time diff --git a/TestSim.py b/TestSim.py index 0a9d38b..1d1a97c 100644 --- a/TestSim.py +++ b/TestSim.py @@ -200,7 +200,7 @@ def main(): s.cmdTestServer(6,1); #[adress] [port] s.runTime(40); - s.cmdTestClient(1,1,6,1, "1234 12"); #[selfAdress] [srcPort] [dest] [destPort] [transfer] + s.cmdTestClient(1,1,6,1, "Hello, bozo"); #[selfAdress] [srcPort] [dest] [destPort] [transfer] s.runTime(80); #s.cmdClientClose(2,80,3,10); #[client adress] [srcPort] [dest] [destPort] diff --git a/includes/socket.h b/includes/socket.h index 056d8a7..474b64c 100644 --- a/includes/socket.h +++ b/includes/socket.h @@ -64,7 +64,7 @@ typedef struct socket_store_t{ //(TCB) - Transmission Control Block uint8_t sendBuff[SOCKET_BUFFER_SIZE]; uint8_t lastWritten; //packet sequence number allowed for new data transmission uint8_t lastSent; // SND.UNA - last sent data that is not acknowledged yet - uint8_t lastAck; //acknowledged sequence numbers + uint8_t lastAck; //last ack sent /* Receive Sequence Space @@ -80,9 +80,9 @@ typedef struct socket_store_t{ //(TCB) - Transmission Control Block */ // This is the receiver portion uint8_t rcvdBuff[SOCKET_BUFFER_SIZE]; - uint8_t lastRead; - uint8_t lastRcvd; - uint8_t nextExpected; + uint8_t lastRead; //last packet put into the buffer + uint8_t lastRcvd; //largest packet recived + uint8_t nextExpected; //next packet expected uint16_t RTT; uint8_t effectiveWindow; diff --git a/lib/interfaces/Transport.nc b/lib/interfaces/Transport.nc index 4f6a291..fddd4cf 100644 --- a/lib/interfaces/Transport.nc +++ b/lib/interfaces/Transport.nc @@ -69,7 +69,7 @@ interface Transport{ * @return uint16_t - return the amount of data you are able to write * from the pass buffer. This may be shorter then bufflen */ -// command uint16_t write(socket_t fd, uint8_t *buff, uint16_t bufflen); + command uint16_t write(socket_t fd, uint8_t *buff, uint16_t bufflen); /** * This will pass the packet so you can handle it internally. diff --git a/lib/modules/TransportC.nc b/lib/modules/TransportC.nc index da98586..5e1ff16 100644 --- a/lib/modules/TransportC.nc +++ b/lib/modules/TransportC.nc @@ -25,5 +25,11 @@ implementation { components new HashmapC(socket_store_t, MAX_NUM_OF_SOCKETS) as Connections; TransportP.Connections->Connections; + // components new TimerMilliC() as sendPacketTimer; + // TransportP.sendPacketTimer -> sendPacketTimer; + + // components new TimerMilliC() as sendDataTimer; + // TransportP.sendDataTimer -> sendDataTimer; + //NOTE: wire timmers } \ No newline at end of file diff --git a/lib/modules/TransportP.nc b/lib/modules/TransportP.nc index 222325c..4f48409 100644 --- a/lib/modules/TransportP.nc +++ b/lib/modules/TransportP.nc @@ -24,6 +24,9 @@ module TransportP{ uses interface Hashmap as Connections; // hash table: list of connections + //uses interface Timer as sendPacketTimer; + uses interface Timer as sendDataTimer; + } implementation{ @@ -201,7 +204,47 @@ module TransportP{ * @return uint16_t - return the amount of data you are able to write * from the pass buffer. This may be shorter then bufflen */ - //command uint16_t Transport.write(socket_t fd, uint8_t *buff, uint16_t bufflen); + command uint16_t Transport.write(socket_t fd, uint8_t *buff, uint16_t bufflen){ + socket_store_t * curSocket = call Connections.getPointer(fd); + uint8_t written; + + + dbg(TRANSPORT_CHANNEL,"Transport.write() Called\n"); +//SOCKET_BUFFER_SIZE + if (buff == NULL || bufflen < 1){ + return 0; + } + + //NOTE: this will not work if you try to write too much information back to back + //for that we need to get the amount of info already on the buffer and make that the + // max amount you can write instead. + if (bufflen > SOCKET_BUFFER_SIZE){ + written = SOCKET_BUFFER_SIZE - bufflen; + } + else{ + written = bufflen; + } + + + memcpy((curSocket->sendBuff), buff, written); + + dbg(TRANSPORT_CHANNEL, "Message to send is %s\n", curSocket->sendBuff); + + // call a sender timmer + // call sendDataTimer.startPeriodic(2 * tempSocket.RTT); + + + return written; + } + + event void sendDataTimer.fired(){ + + dbg(TRANSPORT_CHANNEL," ATTEMPTING TO SEND DATA\n"); + + + + } + /** * This will pass the packet so you can handle it internally. @@ -218,7 +261,16 @@ module TransportP{ dbg(TRANSPORT_CHANNEL, "Transport.receive() Called\n"); + + if(curConection->nextExpected != mySegment->Seq_Num){ + dbg(TRANSPORT_CHANNEL, "Recived packet with unexpected SEQ #\n"); + return FAIL; + + } + //put some checks here + + //check if the ack of the packet is the expected ack dbg(TRANSPORT_CHANNEL, "STATE: %d \n",curConection->state); @@ -234,9 +286,11 @@ module TransportP{ else if(mySegment->Flags == RESET){} else if(mySegment->Flags == SYN){ call Transport.accept(curConection->src, myMsg); + return SUCCESS; } //<- the main one else if(mySegment->Flags == FIN){} //I DONT KNOW else{}//Wrong info + break; case SYN_SENT: //put some checks here @@ -265,7 +319,7 @@ module TransportP{ //save a copy of the packet to posibly be sent by a timmer call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(myMsg->src)); - + return SUCCESS; //optionally do some RTT stuff here //send out inital ack @@ -282,11 +336,36 @@ module TransportP{ if(mySegment->Flags == FIN){} break; case SYN_RCVD: + //put some checks here + if(mySegment->Flags & ( SYN | ACK )) { + //stop timmer + //change the state of the socket to established + curConection->state = ESTABLISHED; + + curConection->lastAck = 1; + curConection->lastRcvd = mySegment->Seq_Num; + curConection->nextExpected = 0; + + //Make the packet to send + makeTCPpack(&sendPackageTCP, //tcp_pack *Package + mySegment->Dest_Port, //uint8_t src + mySegment->Src_Port, //?? //uint8_t des + ACK, //uint8_t flag + 1, //uint8_t seq + 1, /*socketHolder->nextExpected*///uint8_t ack + 1, //uint8_t HdrLen + 1, //uint8_t advertised_window + "", //uint8_t* payload + 1); //uint8_t length + makeIPpack(&sendIPpackage, &sendPackageTCP, curConection, PACKET_MAX_PAYLOAD_SIZE); //maybe reduce the PACKET_MAX_PAYLOAD_SIZE + + //save a copy of the packet to posibly be sent by a timmer + call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(myMsg->src)); + return SUCCESS; + } if(mySegment->Flags == URG){} - if(mySegment->Flags == ACK){} if(mySegment->Flags == PUSH){} if(mySegment->Flags == RESET){} - if(mySegment->Flags == SYN){} if(mySegment->Flags == FIN){} break; case ESTABLISHED: @@ -370,18 +449,6 @@ module TransportP{ */ //command uint16_t Transport.read(socket_t fd, uint8_t *buff, uint16_t bufflen); - /** - * Attempts a connection to an address. - * @param - * socket_t fd: file descriptor that is associated with the socket - * that you are attempting a connection with. - * @param - * socket_addr_t *addr: the destination address and port where - * you will atempt a connection. - * @side Client - * @return socket_t - returns SUCCESS if you are able to attempt - * a connection with the fd passed, else return FAIL. - */ command error_t Transport.connect(socket_t fd, socket_addr_t * addr){ //This is set up for stop and wait socket_store_t * socketHolder ; @@ -499,4 +566,6 @@ module TransportP{ } + + } \ No newline at end of file From b32fef0d0ab2c0dd002aaee582318bf5c17805d5 Mon Sep 17 00:00:00 2001 From: Nathan Blais Date: Mon, 30 Mar 2020 22:58:36 -0700 Subject: [PATCH 02/28] Implemented stop and wait --- Node.nc | 12 +- TestSim.py | 18 +- lib/interfaces/Transport.nc | 7 +- lib/modules/TransportC.nc | 8 +- lib/modules/TransportP.nc | 471 ++++++++++++++++++++++++++---------- 5 files changed, 370 insertions(+), 146 deletions(-) diff --git a/Node.nc b/Node.nc index 6e97304..9f0397b 100644 --- a/Node.nc +++ b/Node.nc @@ -120,7 +120,7 @@ implementation{ event void CommandHandler.setTestServer(uint8_t port){ socket_addr_t myAddr; //not realy needed exept to satisfy bind requirements - socket_t mySocket = call Transport.socket(); + socket_t mySocket = call Transport.socket(port); if (mySocket == 0){ dbg(TRANSPORT_CHANNEL, "Could not retrive an available socket\n"); @@ -141,12 +141,13 @@ implementation{ event void CommandHandler.setTestClient(uint8_t srcPort, uint8_t destination, uint8_t destPort, uint8_t *payload){ socket_addr_t destAddr; - uint8_t i, AmountWritten; + uint8_t i;//, AmountWritten; + socket_t mySocket = call Transport.socket(srcPort); destAddr.addr = destination; //filled with usless info destAddr.port = destPort; //filled with usless info - if(call Transport.bind(srcPort, &destAddr)) + if(call Transport.bind(mySocket, &destAddr)) return; - if(call Transport.connect(srcPort, &destAddr)) + if(call Transport.connect(mySocket, &destAddr)) return; //save the value here into a holder to read for bugtesting @@ -155,7 +156,8 @@ implementation{ dbg(TRANSPORT_CHANNEL, "sizeof(payload): %d\n", i); - AmountWritten = call Transport.write(srcPort,payload,i); + //AmountWritten = + call Transport.write(srcPort,payload,i); //add the payload to a que to be cut up and packaged to be sent after connection diff --git a/TestSim.py b/TestSim.py index 1d1a97c..eb5455a 100644 --- a/TestSim.py +++ b/TestSim.py @@ -187,21 +187,19 @@ def main(): #s.runTime(126); #Fastest time with a "151 | call advertiseTimer.startOneShot(6000);" s.runTime(150); - for i in range(1, 19): - s.routeDMP(i); - s.runTime(1); + # for i in range(1, 19): + # s.routeDMP(i); + # s.runTime(1); s.runTime(120); #s.ping(2, 6, "Hi!"); #s.runTime(100); - - #####***TCP Test***##### - - s.cmdTestServer(6,1); #[adress] [port] - s.runTime(40); - s.cmdTestClient(1,1,6,1, "Hello, bozo"); #[selfAdress] [srcPort] [dest] [destPort] [transfer] - s.runTime(80); + #s.ping(1, 6, "I'll have you know I gr"); + s.cmdTestServer(6,10); #[adress] [port] + s.runTime(60); + s.cmdTestClient(1,8,6,10, "Hello, bozo"); #[selfAdress] [srcPort] [dest] [destPort] [transfer] + s.runTime(1000); #s.cmdClientClose(2,80,3,10); #[client adress] [srcPort] [dest] [destPort] #####***NEIGHBOR DISCOVERY TEST***##### diff --git a/lib/interfaces/Transport.nc b/lib/interfaces/Transport.nc index fddd4cf..739ae1e 100644 --- a/lib/interfaces/Transport.nc +++ b/lib/interfaces/Transport.nc @@ -24,7 +24,7 @@ interface Transport{ * associated with a socket. If you are unable to allocated * a socket then return a NULL socket_t. */ - command socket_t socket(); + command socket_t socket(socket_t fd); /** * Bind a socket with an address. @@ -96,7 +96,7 @@ interface Transport{ * @return uint16_t - return the amount of data you are able to read * from the pass buffer. This may be shorter then bufflen */ -// command uint16_t read(socket_t fd, uint8_t *buff, uint16_t bufflen); + command uint16_t read(socket_t fd, uint8_t *buff, uint16_t bufflen); /** * Attempts a connection to an address. @@ -144,4 +144,7 @@ interface Transport{ * to listen else FAIL. */ command error_t listen(socket_t fd); + + //event void sendDataDone(error_t err); + } diff --git a/lib/modules/TransportC.nc b/lib/modules/TransportC.nc index 5e1ff16..02b1178 100644 --- a/lib/modules/TransportC.nc +++ b/lib/modules/TransportC.nc @@ -25,11 +25,11 @@ implementation { components new HashmapC(socket_store_t, MAX_NUM_OF_SOCKETS) as Connections; TransportP.Connections->Connections; - // components new TimerMilliC() as sendPacketTimer; - // TransportP.sendPacketTimer -> sendPacketTimer; + components new TimerMilliC() as sendPacketTimer; + TransportP.sendPacketTimer -> sendPacketTimer; - // components new TimerMilliC() as sendDataTimer; - // TransportP.sendDataTimer -> sendDataTimer; + components new TimerMilliC() as sendDataTimer; + TransportP.sendDataTimer -> sendDataTimer; //NOTE: wire timmers } \ No newline at end of file diff --git a/lib/modules/TransportP.nc b/lib/modules/TransportP.nc index 4f48409..1e15080 100644 --- a/lib/modules/TransportP.nc +++ b/lib/modules/TransportP.nc @@ -24,7 +24,7 @@ module TransportP{ uses interface Hashmap as Connections; // hash table: list of connections - //uses interface Timer as sendPacketTimer; + uses interface Timer as sendPacketTimer; uses interface Timer as sendDataTimer; } @@ -36,23 +36,38 @@ module TransportP{ const socket_t NULLSocket = 0; tcpHeader sendPackageTCP; pack sendIPpackage; + uint8_t * Empty; // Prototypes - void makeTCPpack(tcpHeader *Package, uint8_t src, uint8_t dest, uint8_t flag, uint8_t seq, uint8_t ack, uint8_t len, uint8_t ad_win, uint8_t* payload, uint8_t length); - void makeIPpack(pack *Package, tcpHeader *myTCPpack, socket_store_t *sock, uint8_t length); + error_t sendData(); + void sendDataDone(error_t err); + error_t sendPacket(); + void sendPacketDone(error_t err); + void makeTCPpack(tcpHeader *Package, uint8_t src, uint8_t dest, uint8_t flag, uint8_t seq, uint8_t ack, uint8_t len, uint8_t ad_win, uint8_t* payload, uint8_t length); + void makeIPpack(pack *Package, tcpHeader *myTCPpack, socket_store_t *sock, uint8_t length); - command socket_t Transport.socket(){ - uint8_t i; + + + + command socket_t Transport.socket(socket_t fd){ + //uint8_t i; dbg(TRANSPORT_CHANNEL,"Transport.socket() Called\n"); if(call Connections.contains(0)) { //if there is room - for(i=1; i-1 <= call Connections.size(); i++){ - if(!(call Connections.contains(i))) //Brobubly Broken - return (socket_t) i; + if(!(call Connections.contains(fd))) + return fd; + else{ + dbg(TRANSPORT_CHANNEL,"Failed: port %d is not available\n", fd); + return NULLSocket; } + + // for(i=1; i-1 <= call Connections.size(); i++){ + // if(!(call Connections.contains(i))) //Brobubly Broken + // return (socket_t) i; + // } } dbg(TRANSPORT_CHANNEL,"Failed: No sockets are available\n"); return NULLSocket; @@ -60,18 +75,16 @@ module TransportP{ command error_t Transport.bind(socket_t fd, socket_addr_t *addr){ socket_store_t TCB; //Transmission Control Block - int i = 0; - + //int i = 0; + //Checkers if(fd == 0 || fd > MAX_NUM_OF_SOCKETS){ dbg(TRANSPORT_CHANNEL,"Socket:%d is not valid. Try number: 1-10\n", fd); return FAIL; } - if(addr->addr == 0 || addr->addr > MAX_ROUTES){ dbg(TRANSPORT_CHANNEL,"adress :%d is not valid. Try number: 1-10\n", addr->addr); return FAIL; } - if(call Connections.contains(fd)){ //Checks if the Socket is already in use dbg(TRANSPORT_CHANNEL,"Socket:%d is already bound\n", fd); return FAIL; @@ -82,16 +95,16 @@ module TransportP{ TCB.dest = *addr; TCB.state = CLOSED; // This is the sender portion. - for (i = 0; i < SOCKET_BUFFER_SIZE; i++){ //I don't know if I need to fill this - TCB.sendBuff[i] = 0; - } + // for (i = 0; i < SOCKET_BUFFER_SIZE; i++){ //I don't know if I need to fill this + // TCB.sendBuff[i] = 0; + // } TCB.lastWritten = 0; TCB.lastAck = 0; TCB.lastSent = 0; // This is the receiver portion - for (i = 0; i < SOCKET_BUFFER_SIZE; i++){ //I don't know how this should be used or mannaged - TCB.rcvdBuff[i] = 0; - } + // for (i = 0; i < SOCKET_BUFFER_SIZE; i++){ //I don't know how this should be used or mannaged + // TCB.rcvdBuff[i] = 0; + // } TCB.lastRead = 0; TCB.lastRcvd = 0; TCB.nextExpected = 0; @@ -110,83 +123,40 @@ module TransportP{ } } - /** - * Checks to see if there are socket connections to connect to and - * if there is one, connect to it. - * @param - * socket_t fd: file descriptor that is associated with the socket - * that is attempting an accept. remember, only do on listen. - * @side Server - * @return socket_t - returns a new socket if the connection is - * accepted. this socket is a copy of the server socket but with - * a destination associated with the destination address and port. - * if not return a null socket. - */ - //command socket_t Transport.accept(socket_t fd); - - - command socket_t Transport.accept(socket_t fd, pack* myPacket){ - socket_store_t * mySocket; - uint8_t lastRcvd; - uint8_t nextExpected; - tcpHeader * myTcpHeader = (tcpHeader*) myPacket->payload; - mySocket = call Connections.getPointer(fd); - dbg(TRANSPORT_CHANNEL, "STATE: %d in accept \n",mySocket->state); - dbg(TRANSPORT_CHANNEL, "myPacket->src is %d \n", mySocket->src); - switch ( mySocket-> state) - { - case LISTEN: - dbg(TRANSPORT_CHANNEL, "I'm inside LISTEN case in accept \n"); - lastRcvd = myTcpHeader->Seq_Num; // do i need this? + command socket_t Transport.accept(socket_t fd, pack* myPacket){ + socket_store_t * mySocket; + uint8_t lastRcvd; + uint8_t nextExpected; + tcpHeader * myTcpHeader = (tcpHeader*) myPacket->payload; + mySocket = call Connections.getPointer(fd); + dbg(TRANSPORT_CHANNEL, "STATE: %d in accept \n",mySocket->state); + + lastRcvd = myTcpHeader->Seq_Num; // do i need this? - mySocket->state = SYN_RCVD; - - mySocket->dest.port= myTcpHeader->Src_Port; - mySocket->dest.addr= myPacket->src; - mySocket->nextExpected = 1; - //mySocket - //nextExpected = 1; - //mySocket->src = + mySocket->state = SYN_RCVD; + + mySocket->dest.port= myTcpHeader->Src_Port; + mySocket->dest.addr= myPacket->src; + mySocket->nextExpected = 1; - makeTCPpack(&sendPackageTCP, //tcp_pack *Package - mySocket->src, - mySocket->dest.port, //uint8_t des //not sure - SYN, //uint8_t flag - lastRcvd, //uint8_t seq - lastRcvd, //socketHolder->nextExpected///uint8_t ack - 1, //uint8_t HdrLen - 1, //uint8_t advertised_window - "", //uint8_t* payload - 1); //uint8_t length - makeIPpack(&sendIPpackage, &sendPackageTCP, mySocket, PACKET_MAX_PAYLOAD_SIZE); - //call timer - //send packet - call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(5)); - // i need to get the new socket......but how? - break; - case SYN_SENT: - break; - case SYN_RCVD: - break; - case ESTABLISHED: - break; - case CLOSE_WAIT: - break; - case LAST_ACK: - break; - case FIN_WAIT_1: - break; - case FIN_WAIT_2: - break; - case CLOSING: - break; - case TIME_WAIT: - break; - default: - } - //ask for socket, bind, listen again? - - } + makeTCPpack(&sendPackageTCP, //tcp_pack *Package + mySocket->src, + mySocket->dest.port, //uint8_t des //not sure + SYN, //uint8_t flag + lastRcvd, //uint8_t seq + lastRcvd, //socketHolder->nextExpected///uint8_t ack + 0, //uint8_t HdrLen + 1, //uint8_t advertised_window + Empty, //uint8_t* payload + 0); //uint8_t length + makeIPpack(&sendIPpackage, &sendPackageTCP, mySocket, PACKET_MAX_PAYLOAD_SIZE); + //call timer + //send packet + call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(5)); + // i need to get the new socket......but how? + + return fd; + } /** @@ -204,13 +174,11 @@ module TransportP{ * @return uint16_t - return the amount of data you are able to write * from the pass buffer. This may be shorter then bufflen */ - command uint16_t Transport.write(socket_t fd, uint8_t *buff, uint16_t bufflen){ + command uint16_t Transport.write(socket_t fd, uint8_t *buff, uint16_t bufflen){ socket_store_t * curSocket = call Connections.getPointer(fd); uint8_t written; - dbg(TRANSPORT_CHANNEL,"Transport.write() Called\n"); -//SOCKET_BUFFER_SIZE if (buff == NULL || bufflen < 1){ return 0; } @@ -224,27 +192,111 @@ module TransportP{ else{ written = bufflen; } - - memcpy((curSocket->sendBuff), buff, written); - dbg(TRANSPORT_CHANNEL, "Message to send is %s\n", curSocket->sendBuff); // call a sender timmer // call sendDataTimer.startPeriodic(2 * tempSocket.RTT); + call sendDataTimer.startPeriodic(80000); + return written; + } + event void sendDataTimer.fired(){ + sendData(); + } - return written; - } + void sendDataDone(error_t err){ + if(err == SUCCESS){ + socket_store_t * socketHolder; + uint8_t TempSendBuff[SOCKET_BUFFER_SIZE]; + uint8_t buffSize, sendSize, TCPflag, j, i; + uint8_t size = call Connections.size(); + uint32_t * keys = call Connections.getKeys(); - event void sendDataTimer.fired(){ + if(size == 0){ + call sendDataTimer.stop(); + } + dbg(TRANSPORT_CHANNEL," ATTEMPTING TO SEND DATA\n"); + for(i=0;ilastSent: %d | socketHolder->lastAck %d\n",socketHolder->lastSent,socketHolder->lastAck ); + + dbg(TRANSPORT_CHANNEL,"socketHolder->sendBuff %s\n",socketHolder->sendBuff ); + + + if(socketHolder->state == ESTABLISHED && + socketHolder->lastSent == socketHolder->lastAck && + socketHolder->sendBuff != '\0') + { //if true send data + dbg(TRANSPORT_CHANNEL," Does it enter here?\n"); + for(buffSize=0; socketHolder->sendBuff[buffSize] != '\0'; buffSize++ ){} //calculates the size of the buffer + if(buffSize > TCP_PACKET_MAX_PAYLOAD_SIZE){//if size of buffer is > TCP_PACKET_MAX_PAYLOAD_SIZE + sendSize = TCP_PACKET_MAX_PAYLOAD_SIZE; + TCPflag = ACK; + } + else { //send normaly with PUSH flag <- let it know it is the end of the data send + sendSize = buffSize; + TCPflag = PUSH; + } + //edit socket for correct data + + if (socketHolder->lastSent == 0) {socketHolder->lastSent = 1;} + else{socketHolder->lastSent = 0;} + + makeTCPpack(&sendPackageTCP, //tcp_pack *Package + socketHolder->src, //uint8_t src + socketHolder->dest.port, //?? //uint8_t des + TCPflag, //uint8_t flag + socketHolder->lastSent, //uint8_t seq + 0, /*socketHolder->nextExpected*///uint8_t ack + sendSize, //uint8_t HdrLen + 1, //uint8_t advertised_window + socketHolder->sendBuff, //uint8_t* payload + sendSize); //uint8_t length + makeIPpack(&sendIPpackage, &sendPackageTCP, socketHolder, PACKET_MAX_PAYLOAD_SIZE); //maybe reduce the PACKET_MAX_PAYLOAD_SIZE + + dbg(TRANSPORT_CHANNEL," Sending Message: %s\n",sendPackageTCP.payload); + + //send packet + call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(socketHolder->dest.addr)); - dbg(TRANSPORT_CHANNEL," ATTEMPTING TO SEND DATA\n"); + //set timmer to posibly resend packet + dbg(TRANSPORT_CHANNEL," Sendt Message: %s\n",sendPackageTCP.payload); + //edit buffer + if(buffSize > TCP_PACKET_MAX_PAYLOAD_SIZE){ + memcpy(TempSendBuff, &((socketHolder->sendBuff)[sendSize]), buffSize - sendSize); + dbg(TRANSPORT_CHANNEL," TempSendBuff: %s\n",TempSendBuff); + } + else{ + for (i = 0; i < SOCKET_BUFFER_SIZE; i++){ //I don't know if I need to fill this + socketHolder->sendBuff[i] = 0; + } + } + + //TempSendBuff + //memcpy(socketHolder->sendBuff, (socketHolder->sendBuff)[sendSize], buffSize); + //memcpy(socketHolder->sendBuff, &((socketHolder->sendBuff)[sendSize, buffSize]), buffSize - sendSize); + + } + } } + }//end of: void sendDataDone(error_t err) + task void sendDataTask(){ + + sendDataDone(SUCCESS); + } + + error_t sendData(){ + post sendDataTask(); + return SUCCESS; + } /** * This will pass the packet so you can handle it internally. @@ -254,23 +306,23 @@ module TransportP{ * @return uint16_t - return SUCCESS if you are able to handle this * packet or FAIL if there are errors. */ - command error_t Transport.receive(pack* package){ - pack* myMsg=(pack*) package; + + command error_t Transport.receive(pack* package){ + pack* myMsg=(pack*) package; tcpHeader* mySegment = (tcpHeader*) myMsg->payload; socket_store_t * curConection = call Connections.getPointer(mySegment->Dest_Port); dbg(TRANSPORT_CHANNEL, "Transport.receive() Called\n"); - if(curConection->nextExpected != mySegment->Seq_Num){ - dbg(TRANSPORT_CHANNEL, "Recived packet with unexpected SEQ #\n"); - return FAIL; + // if(curConection->nextExpected != mySegment->Seq_Num){ + // dbg(TRANSPORT_CHANNEL, "Recived packet with unexpected SEQ #\n"); + // return FAIL; - } + // } //put some checks here - //check if the ack of the packet is the expected ack dbg(TRANSPORT_CHANNEL, "STATE: %d \n",curConection->state); @@ -299,6 +351,7 @@ module TransportP{ //change the state of the socket to established curConection->state = ESTABLISHED; curConection->lastRcvd = mySegment->Seq_Num; + curConection->lastSent = 1; curConection->nextExpected = 1; curConection->effectiveWindow = mySegment->Advertised_Window; //curConection.RTT = call LocalTime.get() - tempSocket.RTT + 10; @@ -311,10 +364,10 @@ module TransportP{ ACK, //uint8_t flag 1, //uint8_t seq 1, /*socketHolder->nextExpected*///uint8_t ack - 1, //uint8_t HdrLen + 0, //uint8_t HdrLen 1, //uint8_t advertised_window - "", //uint8_t* payload - 1); //uint8_t length + Empty, //uint8_t* payload + 0); //uint8_t length makeIPpack(&sendIPpackage, &sendPackageTCP, curConection, PACKET_MAX_PAYLOAD_SIZE); //maybe reduce the PACKET_MAX_PAYLOAD_SIZE //save a copy of the packet to posibly be sent by a timmer @@ -353,10 +406,10 @@ module TransportP{ ACK, //uint8_t flag 1, //uint8_t seq 1, /*socketHolder->nextExpected*///uint8_t ack - 1, //uint8_t HdrLen + 0, //uint8_t HdrLen 1, //uint8_t advertised_window - "", //uint8_t* payload - 1); //uint8_t length + Empty, //uint8_t* payload + 0); //uint8_t length makeIPpack(&sendIPpackage, &sendPackageTCP, curConection, PACKET_MAX_PAYLOAD_SIZE); //maybe reduce the PACKET_MAX_PAYLOAD_SIZE //save a copy of the packet to posibly be sent by a timmer @@ -370,8 +423,64 @@ module TransportP{ break; case ESTABLISHED: if(mySegment->Flags == URG){} - if(mySegment->Flags == ACK){} - if(mySegment->Flags == PUSH){} + if(mySegment->Flags == ACK){ + curConection->lastAck = mySegment->Acknowledgment; + curConection->lastRcvd = mySegment->Seq_Num; + if(mySegment->Len == 0){ //this is a normal ack pack + + //update socket + } + else{ // has data + curConection->effectiveWindow = mySegment->Advertised_Window; + call Transport.read(curConection->src, mySegment->payload, mySegment->Len); + //store pack for resend + + //send back an ack packet + + } + + + //if the packet has a len of 0 + + //change ack for socket + curConection->lastAck = mySegment->Acknowledgment; + + //curConection->nextExpected = ; + + //if you have data to send, send it else just send normal ack packet + } + if(mySegment->Flags == PUSH){ + //update socket + //read the packet + dbg(TRANSPORT_CHANNEL, "Message Recived:%s\n",mySegment->payload); + + call Transport.read(curConection->src, mySegment->payload, mySegment->Len); + + //print out entire buffer + dbg(TRANSPORT_CHANNEL, "\tFinished reciving Message\n"); + dbg(TRANSPORT_CHANNEL, "\t\tMessage:%s\n",curConection->rcvdBuff); + + //update last sent + if (curConection->lastSent == 0) {curConection->lastSent = 1;} + else{curConection->lastSent = 0;} + + //Make the ACK packet to send + makeTCPpack(&sendPackageTCP, //tcp_pack *Package + mySegment->Dest_Port, //uint8_t src + mySegment->Src_Port, //?? //uint8_t des + ACK, //uint8_t flag + curConection->lastSent, //uint8_t seq + 1, /*socketHolder->nextExpected*///uint8_t ack + 0, //uint8_t HdrLen + 1, //uint8_t advertised_window + Empty, //uint8_t* payload + 0); //uint8_t length + makeIPpack(&sendIPpackage, &sendPackageTCP, curConection, PACKET_MAX_PAYLOAD_SIZE); //maybe reduce the PACKET_MAX_PAYLOAD_SIZE + + call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(myMsg->src)); + return SUCCESS; + + } if(mySegment->Flags == RESET){} if(mySegment->Flags == SYN){} if(mySegment->Flags == FIN){} @@ -430,6 +539,7 @@ module TransportP{ return FAIL; break; } + return FAIL; } /** @@ -447,7 +557,25 @@ module TransportP{ * @return uint16_t - return the amount of data you are able to read * from the pass buffer. This may be shorter then bufflen */ - //command uint16_t Transport.read(socket_t fd, uint8_t *buff, uint16_t bufflen); + command uint16_t Transport.read(socket_t fd, uint8_t *buff, uint16_t bufflen){ + uint8_t buffSize, i; + socket_store_t * socketHolder = call Connections.getPointer(fd); + + dbg(TRANSPORT_CHANNEL, "Transport Called Read\n"); + for(buffSize=0; socketHolder->sendBuff[buffSize] != '\0'; buffSize++ ){} //calculates the size of the buffer + + // for (i = 0; i < bufflen; i++){ + // socketHolder->rcvdBuff[buffSize + i] = buff[i] ; + // } + + strcat(socketHolder->rcvdBuff, buff); + + if (socketHolder->lastRead == 0) {socketHolder->lastRead = 1;} + else{socketHolder->lastRead = 0;} + if (socketHolder->nextExpected == 0) {socketHolder->nextExpected = 1;} + else{socketHolder->nextExpected = 0;} + + } command error_t Transport.connect(socket_t fd, socket_addr_t * addr){ //This is set up for stop and wait @@ -477,10 +605,10 @@ module TransportP{ SYN, //uint8_t flag 0, //uint8_t seq 0, /*socketHolder->nextExpected*///uint8_t ack - 1, //uint8_t HdrLen + 0, //uint8_t HdrLen 1, //uint8_t advertised_window - "", //uint8_t* payload - 1); //uint8_t length + Empty, //uint8_t* payload + 0); //uint8_t length makeIPpack(&sendIPpackage, &sendPackageTCP, socketHolder, PACKET_MAX_PAYLOAD_SIZE); //maybe reduce the PACKET_MAX_PAYLOAD_SIZE //save a copy of the packet to posibly be sent by a timmer @@ -543,6 +671,102 @@ module TransportP{ } } + + event void sendPacketTimer.fired(){ + sendPacket(); + } + + void sendPacketDone(error_t err){ + if(err == SUCCESS){ + socket_store_t * socketHolder; + + uint8_t buffSize, sendSize, TCPflag, j, i; + uint8_t size = call Connections.size(); + uint32_t * keys = call Connections.getKeys(); + + dbg(TRANSPORT_CHANNEL," ATTEMPTING TO RE-SEND DATA\n"); + for(i=0;ilastSent: %d | socketHolder->lastAck %d\n",socketHolder->lastSent,socketHolder->lastAck ); + + dbg(TRANSPORT_CHANNEL,"socketHolder->sendBuff %s\n",socketHolder->sendBuff ); + + + if(socketHolder->state == ESTABLISHED && + socketHolder->lastSent == socketHolder->lastAck && + socketHolder->sendBuff != '\0') + { //if true send data + dbg(TRANSPORT_CHANNEL," Does it enter here?\n"); + for(buffSize=0; socketHolder->sendBuff[buffSize] != '\0'; buffSize++ ){} //calculates the size of the buffer + if(buffSize > TCP_PACKET_MAX_PAYLOAD_SIZE){//if size of buffer is > TCP_PACKET_MAX_PAYLOAD_SIZE + sendSize = TCP_PACKET_MAX_PAYLOAD_SIZE; + TCPflag = ACK; + } + else { //send normaly with PUSH flag <- let it know it is the end of the data send + sendSize = buffSize; + TCPflag = PUSH; + } + //edit socket for correct data + + if (socketHolder->lastSent == 0) {socketHolder->lastSent = 1;} + else{socketHolder->lastSent = 0;} + + makeTCPpack(&sendPackageTCP, //tcp_pack *Package + socketHolder->src, //uint8_t src + socketHolder->dest.port, //?? //uint8_t des + TCPflag, //uint8_t flag + socketHolder->lastSent, //uint8_t seq + 0, /*socketHolder->nextExpected*///uint8_t ack + sendSize, //uint8_t HdrLen + 1, //uint8_t advertised_window + socketHolder->sendBuff, //uint8_t* payload + sendSize); //uint8_t length + makeIPpack(&sendIPpackage, &sendPackageTCP, socketHolder, PACKET_MAX_PAYLOAD_SIZE); //maybe reduce the PACKET_MAX_PAYLOAD_SIZE + + dbg(TRANSPORT_CHANNEL," Sending Message: %s\n",sendPackageTCP.payload); + + //send packet + call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(socketHolder->dest.addr)); + + //set timmer to posibly resend packet + dbg(TRANSPORT_CHANNEL," Sendt Message: %s\n",sendPackageTCP.payload); + + //edit buffer + if(buffSize > TCP_PACKET_MAX_PAYLOAD_SIZE){ + memcpy(TempSendBuff, &((socketHolder->sendBuff)[sendSize]), buffSize - sendSize); + dbg(TRANSPORT_CHANNEL," TempSendBuff: %s\n",TempSendBuff); + } + + else{ + for (i = 0; i < SOCKET_BUFFER_SIZE; i++){ //I don't know if I need to fill this + socketHolder->sendBuff[i] = 0; + } + } + + + //TempSendBuff + //memcpy(socketHolder->sendBuff, (socketHolder->sendBuff)[sendSize], buffSize); + //memcpy(socketHolder->sendBuff, &((socketHolder->sendBuff)[sendSize, buffSize]), buffSize - sendSize); + + } + } + } + }//end of: void sendPacketDone(error_t err) + + task void sendPackeTask(){ + + sendPacketDone(SUCCESS); + } + + error_t sendPacket(){ + post sendDataTask(); + return SUCCESS; + } + + void makeTCPpack(tcpHeader *Package, uint8_t src, uint8_t dest, uint8_t flag, uint8_t seq, uint8_t ack, uint8_t len, uint8_t ad_win, uint8_t* payload, uint8_t length){ Package->Src_Port = src; Package->Dest_Port = dest; @@ -565,7 +789,4 @@ module TransportP{ memcpy(Package->payload, myTCPpack, length); } - - - } \ No newline at end of file From ae7cd458ab6a8857751230ba68038237d046a392 Mon Sep 17 00:00:00 2001 From: Nathan Blais Date: Mon, 30 Mar 2020 23:08:17 -0700 Subject: [PATCH 03/28] commented out stuff --- lib/modules/TransportP.nc | 124 +++++++++++++++++++------------------- 1 file changed, 62 insertions(+), 62 deletions(-) diff --git a/lib/modules/TransportP.nc b/lib/modules/TransportP.nc index 1e15080..a8d4f54 100644 --- a/lib/modules/TransportP.nc +++ b/lib/modules/TransportP.nc @@ -678,81 +678,81 @@ module TransportP{ void sendPacketDone(error_t err){ if(err == SUCCESS){ - socket_store_t * socketHolder; + // socket_store_t * socketHolder; - uint8_t buffSize, sendSize, TCPflag, j, i; - uint8_t size = call Connections.size(); - uint32_t * keys = call Connections.getKeys(); + // uint8_t buffSize, sendSize, TCPflag, j, i; + // uint8_t size = call Connections.size(); + // uint32_t * keys = call Connections.getKeys(); - dbg(TRANSPORT_CHANNEL," ATTEMPTING TO RE-SEND DATA\n"); - for(i=0;ilastSent: %d | socketHolder->lastAck %d\n",socketHolder->lastSent,socketHolder->lastAck ); + // dbg(TRANSPORT_CHANNEL,"socketHolder->lastSent: %d | socketHolder->lastAck %d\n",socketHolder->lastSent,socketHolder->lastAck ); - dbg(TRANSPORT_CHANNEL,"socketHolder->sendBuff %s\n",socketHolder->sendBuff ); - - - if(socketHolder->state == ESTABLISHED && - socketHolder->lastSent == socketHolder->lastAck && - socketHolder->sendBuff != '\0') - { //if true send data - dbg(TRANSPORT_CHANNEL," Does it enter here?\n"); - for(buffSize=0; socketHolder->sendBuff[buffSize] != '\0'; buffSize++ ){} //calculates the size of the buffer - if(buffSize > TCP_PACKET_MAX_PAYLOAD_SIZE){//if size of buffer is > TCP_PACKET_MAX_PAYLOAD_SIZE - sendSize = TCP_PACKET_MAX_PAYLOAD_SIZE; - TCPflag = ACK; - } - else { //send normaly with PUSH flag <- let it know it is the end of the data send - sendSize = buffSize; - TCPflag = PUSH; - } - //edit socket for correct data - - if (socketHolder->lastSent == 0) {socketHolder->lastSent = 1;} - else{socketHolder->lastSent = 0;} + // dbg(TRANSPORT_CHANNEL,"socketHolder->sendBuff %s\n",socketHolder->sendBuff ); + + + // if(socketHolder->state == ESTABLISHED && + // socketHolder->lastSent == socketHolder->lastAck && + // socketHolder->sendBuff != '\0') + // { //if true send data + // dbg(TRANSPORT_CHANNEL," Does it enter here?\n"); + // for(buffSize=0; socketHolder->sendBuff[buffSize] != '\0'; buffSize++ ){} //calculates the size of the buffer + // if(buffSize > TCP_PACKET_MAX_PAYLOAD_SIZE){//if size of buffer is > TCP_PACKET_MAX_PAYLOAD_SIZE + // sendSize = TCP_PACKET_MAX_PAYLOAD_SIZE; + // TCPflag = ACK; + // } + // else { //send normaly with PUSH flag <- let it know it is the end of the data send + // sendSize = buffSize; + // TCPflag = PUSH; + // } + // //edit socket for correct data + + // if (socketHolder->lastSent == 0) {socketHolder->lastSent = 1;} + // else{socketHolder->lastSent = 0;} - makeTCPpack(&sendPackageTCP, //tcp_pack *Package - socketHolder->src, //uint8_t src - socketHolder->dest.port, //?? //uint8_t des - TCPflag, //uint8_t flag - socketHolder->lastSent, //uint8_t seq - 0, /*socketHolder->nextExpected*///uint8_t ack - sendSize, //uint8_t HdrLen - 1, //uint8_t advertised_window - socketHolder->sendBuff, //uint8_t* payload - sendSize); //uint8_t length - makeIPpack(&sendIPpackage, &sendPackageTCP, socketHolder, PACKET_MAX_PAYLOAD_SIZE); //maybe reduce the PACKET_MAX_PAYLOAD_SIZE + // makeTCPpack(&sendPackageTCP, //tcp_pack *Package + // socketHolder->src, //uint8_t src + // socketHolder->dest.port, //?? //uint8_t des + // TCPflag, //uint8_t flag + // socketHolder->lastSent, //uint8_t seq + // 0, /*socketHolder->nextExpected*///uint8_t ack + // sendSize, //uint8_t HdrLen + // 1, //uint8_t advertised_window + // socketHolder->sendBuff, //uint8_t* payload + // sendSize); //uint8_t length + // makeIPpack(&sendIPpackage, &sendPackageTCP, socketHolder, PACKET_MAX_PAYLOAD_SIZE); //maybe reduce the PACKET_MAX_PAYLOAD_SIZE - dbg(TRANSPORT_CHANNEL," Sending Message: %s\n",sendPackageTCP.payload); + // dbg(TRANSPORT_CHANNEL," Sending Message: %s\n",sendPackageTCP.payload); - //send packet - call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(socketHolder->dest.addr)); + // //send packet + // call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(socketHolder->dest.addr)); - //set timmer to posibly resend packet - dbg(TRANSPORT_CHANNEL," Sendt Message: %s\n",sendPackageTCP.payload); + // //set timmer to posibly resend packet + // dbg(TRANSPORT_CHANNEL," Sendt Message: %s\n",sendPackageTCP.payload); - //edit buffer - if(buffSize > TCP_PACKET_MAX_PAYLOAD_SIZE){ - memcpy(TempSendBuff, &((socketHolder->sendBuff)[sendSize]), buffSize - sendSize); - dbg(TRANSPORT_CHANNEL," TempSendBuff: %s\n",TempSendBuff); - } + // //edit buffer + // if(buffSize > TCP_PACKET_MAX_PAYLOAD_SIZE){ + // memcpy(TempSendBuff, &((socketHolder->sendBuff)[sendSize]), buffSize - sendSize); + // dbg(TRANSPORT_CHANNEL," TempSendBuff: %s\n",TempSendBuff); + // } - else{ - for (i = 0; i < SOCKET_BUFFER_SIZE; i++){ //I don't know if I need to fill this - socketHolder->sendBuff[i] = 0; - } - } + // else{ + // for (i = 0; i < SOCKET_BUFFER_SIZE; i++){ //I don't know if I need to fill this + // socketHolder->sendBuff[i] = 0; + // } + // } - //TempSendBuff - //memcpy(socketHolder->sendBuff, (socketHolder->sendBuff)[sendSize], buffSize); - //memcpy(socketHolder->sendBuff, &((socketHolder->sendBuff)[sendSize, buffSize]), buffSize - sendSize); + // //TempSendBuff + // //memcpy(socketHolder->sendBuff, (socketHolder->sendBuff)[sendSize], buffSize); + // //memcpy(socketHolder->sendBuff, &((socketHolder->sendBuff)[sendSize, buffSize]), buffSize - sendSize); - } - } + // } + // } } }//end of: void sendPacketDone(error_t err) From 9ce3944f0aa5dd97a2ac14cfd95773e8f411c4ce Mon Sep 17 00:00:00 2001 From: Nathan Blais Date: Tue, 31 Mar 2020 17:16:00 -0700 Subject: [PATCH 04/28] Added tasks to make code run soother. --- Node.nc | 81 ++++++++++++++++++++++----- NodeC.nc | 7 +++ TestSim.py | 23 +++++--- includes/sendInfo.h | 6 ++ includes/socket.h | 5 +- lib/modules/DistanceVectorRoutingC.nc | 8 +++ lib/modules/DistanceVectorRoutingP.nc | 67 +++++++++++++++++++--- lib/modules/NeighborDiscoveryP.nc | 21 +++++-- lib/modules/SimpleSendC.nc | 4 +- lib/modules/TransportP.nc | 17 +++++- 10 files changed, 198 insertions(+), 41 deletions(-) diff --git a/Node.nc b/Node.nc index 9f0397b..643d0d5 100644 --- a/Node.nc +++ b/Node.nc @@ -27,6 +27,9 @@ module Node{ uses interface NeighborDiscovery; uses interface DistanceVectorRouting; uses interface Transport; + + uses interface Queue; + uses interface Pool; } implementation{ @@ -36,6 +39,8 @@ implementation{ // Prototypes void makePack(pack *Package, uint16_t src, uint16_t dest, uint16_t TTL, uint16_t seq, uint16_t protocol, uint8_t *payload, uint8_t length); + error_t receive(message_t* msg, pack* payload, uint8_t len); + event void Boot.booted(){ call AMControl.start(); @@ -56,15 +61,57 @@ implementation{ event void AMControl.stopDone(error_t err){} + task void receiveBufferTask(){ + // If we have a values in our queue and the radio is not busy, then + // attempt to send a packet. + if(!call Queue.empty()){ + reciveInfo *info; + // We are peeking since, there is a possibility that the value will not + // be successfuly sent and we would like to continue to attempt to send + // it until we are successful. There is no limit on how many attempts + // can be made. + info = call Queue.head(); + + // Attempt to send it. + if(SUCCESS == receive(&(info->msg),&(info->payload), info->len)){ + //Release resources used if the attempt was successful + call Queue.dequeue(); + call Pool.put(info); + } + } + } + event message_t* Receive.receive(message_t* msg, void* payload, uint8_t len){ + if(!call Pool.empty()){ + reciveInfo *input; + + input = call Pool.get(); + memcpy(&(input->msg), msg, sizeof(*msg)); + memcpy(&(input->payload), payload, PACKET_MAX_PAYLOAD_SIZE); + input->len = len; + + // Now that we have a value from the pool we can put it into our queue. + // This is a FIFO queue. + call Queue.enqueue(input); + + // Start a send task which will be delayed. + post receiveBufferTask(); + + return msg; + } + return msg; + } + + error_t receive(message_t* msg, pack* payload, uint8_t len){ pack *contents; + error_t result; //for debug if(len!=sizeof(pack)){ dbg(GENERAL_CHANNEL, "Unknown Packet Type %d\n", len); - return msg; + return SUCCESS; } - contents = (pack *)payload; + contents = payload; if (contents->TTL == 0) //Kill the packet if TTL is 0 - return msg; + return SUCCESS; contents-> TTL = (contents->TTL) - 1; //Reduce TTL if(contents->dest == AM_BROADCAST_ADDR) { @@ -72,11 +119,13 @@ implementation{ } if (contents->dest != TOS_NODE_ID){ //Check if the packet is not meant for the current node dbg(GENERAL_CHANNEL, "We're in Node %d \n \t\tRouting Packet- src:%d, dest %d, seq: %d, nexthop: %d, count: %d\n \n",TOS_NODE_ID, contents->src, contents->dest, contents->seq, call DistanceVectorRouting.GetNextHop(contents->dest), call DistanceVectorRouting.GetCost(contents->dest)); - if (contents->protocol == PROTOCOL_PING || contents->protocol == PROTOCOL_PINGREPLY || contents->protocol == PROTOCOL_TCP) - call Sender.send(*contents, call DistanceVectorRouting.GetNextHop(contents->dest)); + if (contents->protocol == PROTOCOL_PING || contents->protocol == PROTOCOL_PINGREPLY || contents->protocol == PROTOCOL_TCP){ + result = call Sender.send(*contents, call DistanceVectorRouting.GetNextHop(contents->dest)); + dbg(GENERAL_CHANNEL, "RECIVE EVENT SEND ON result: %d \n",result); + } else dbg(GENERAL_CHANNEL, "Recived packet with incorrect Protocol?\n"); - return msg; + return SUCCESS; } //End of the destination check. Packets should be ment for this node past this point //Check the Protocol @@ -84,30 +133,33 @@ implementation{ dbg(GENERAL_CHANNEL, "Ping Message Recived:%s\n", contents->payload); makePack(&sendPackage, TOS_NODE_ID, contents->src, MAX_TTL, contents->seq, PROTOCOL_PINGREPLY, (uint8_t *)contents->payload, PACKET_MAX_PAYLOAD_SIZE); dbg(GENERAL_CHANNEL, "Sending Ping Reply to %d\n \n", contents->src); - call Sender.send(sendPackage, call DistanceVectorRouting.GetNextHop(contents->src)); + result = call Sender.send(sendPackage, call DistanceVectorRouting.GetNextHop(contents->src)); + dbg(GENERAL_CHANNEL, "RECIVE EVENT SEND result: %d \n",result); } else if (PROTOCOL_PINGREPLY == contents->protocol) dbg(GENERAL_CHANNEL, "Package Payload: %s\n", contents->payload); else if (PROTOCOL_TCP == contents->protocol) { - call Transport.receive(contents); } else dbg(GENERAL_CHANNEL, "Recived packet with incorrect Protocol\n"); //dbg(GENERAL_CHANNEL, "Package Payload: %s\n", myMsg->payload); - return msg; + return SUCCESS; } event void CommandHandler.ping(uint16_t destination, uint8_t *payload){ + error_t result; dbg(GENERAL_CHANNEL, "PING EVENT \n"); + dbg(GENERAL_CHANNEL, "Sucsess: %d | FAIL: %d \n",SUCCESS, FAIL); makePack(&sendPackage, TOS_NODE_ID, destination, MAX_TTL, SEQ_NUM, PROTOCOL_PING, payload, PACKET_MAX_PAYLOAD_SIZE); dbg(GENERAL_CHANNEL, "We're in Node: %d \n \t\tRouting Packet- src:%d, dest %d, seq: %d, nexthop: %d, count: %d\n \n", TOS_NODE_ID,TOS_NODE_ID, destination, SEQ_NUM, call DistanceVectorRouting.GetNextHop(destination), call DistanceVectorRouting.GetCost(destination)); SEQ_NUM++; //call Sender.send(sendPackage, destination); //call Flooder.send(sendPackage, destination); - call Sender.send(sendPackage, call DistanceVectorRouting.GetNextHop(destination)); + result = call Sender.send(sendPackage, call DistanceVectorRouting.GetNextHop(destination)); + dbg(GENERAL_CHANNEL, "PING EVENT result: %d \n",result); } event void CommandHandler.printNeighbors(){call NeighborDiscovery.print();} @@ -147,17 +199,19 @@ implementation{ destAddr.port = destPort; //filled with usless info if(call Transport.bind(mySocket, &destAddr)) return; + for(i=0; payload[i] != '\0'; i++ ){} + //call Transport.write(srcPort,payload,i); if(call Transport.connect(mySocket, &destAddr)) return; //save the value here into a holder to read for bugtesting - for(i=0; payload[i] != '\0'; i++ ){} + //for(i=0; payload[i] != '\0'; i++ ){} dbg(TRANSPORT_CHANNEL, "sizeof(payload): %d\n", i); //AmountWritten = - call Transport.write(srcPort,payload,i); + //call Transport.write(srcPort,payload,i); //add the payload to a que to be cut up and packaged to be sent after connection @@ -165,8 +219,7 @@ implementation{ } event void CommandHandler.cmdClientClose(uint8_t address, uint8_t srcPort, uint8_t destination, uint8_t destPort){ - - + call Transport.close(srcPort); } diff --git a/NodeC.nc b/NodeC.nc index 656b4b3..593a8ec 100644 --- a/NodeC.nc +++ b/NodeC.nc @@ -42,4 +42,11 @@ implementation { components TransportC as Transport; Node.Transport -> Transport; + + //Lists + components new PoolC(reciveInfo, 20); + components new QueueC(reciveInfo*, 20); + + Node.Pool -> PoolC; + Node.Queue -> QueueC; } diff --git a/TestSim.py b/TestSim.py index 39020d1..d145321 100644 --- a/TestSim.py +++ b/TestSim.py @@ -185,23 +185,28 @@ def main(): s.runTime(1); #s.runTime(126); #Fastest time with a "151 | call advertiseTimer.startOneShot(6000);" - s.runTime(150); + s.runTime(250); - # for i in range(1, 19): - # s.routeDMP(i); - # s.runTime(1); - s.runTime(120); + # for i in range(1, 19): + # s.routeDMP(i); + # s.runTime(1); + # s.runTime(10); #s.ping(2, 6, "Hi!"); #s.runTime(100); #####***TCP Test***##### #s.ping(1, 6, "I'll have you know I gr"); s.cmdTestServer(6,10); #[adress] [port] - s.runTime(60); + s.runTime(20); + # s.ping(1, 6, "I'll have you know I gr"); + # s.runTime(10); + # s.ping(1, 6, "I'll have you know I gr"); + # s.runTime(10); + # s.ping(1, 6, "I'll have you know I gr"); s.cmdTestClient(1,8,6,10, "Hello, bozo"); #[selfAdress] [srcPort] [dest] [destPort] [transfer] - s.runTime(1000); - - #s.cmdClientClose(2,80,3,10); #[client adress] [srcPort] [dest] [destPort] + s.runTime(100); + s.cmdClientClose(1,8,6,10); #[client adress] [srcPort] [dest] [destPort] + s.runTime(200); #####***NEIGHBOR DISCOVERY TEST***##### # s.runTime(50); diff --git a/includes/sendInfo.h b/includes/sendInfo.h index 1856559..42e3cf4 100644 --- a/includes/sendInfo.h +++ b/includes/sendInfo.h @@ -15,6 +15,12 @@ typedef struct sendInfo{ uint16_t dest; }sendInfo; +typedef struct reciveInfo{ + message_t msg; + pack payload; + uint8_t len; +}reciveInfo; + typedef struct neighbor { uint16_t id; bool flag; diff --git a/includes/socket.h b/includes/socket.h index 474b64c..2d31614 100644 --- a/includes/socket.h +++ b/includes/socket.h @@ -86,6 +86,9 @@ typedef struct socket_store_t{ //(TCB) - Transmission Control Block uint16_t RTT; uint8_t effectiveWindow; + + pack LastSentIPpackage; + }socket_store_t; -#endif +#endif \ No newline at end of file diff --git a/lib/modules/DistanceVectorRoutingC.nc b/lib/modules/DistanceVectorRoutingC.nc index d4b3db8..cfde993 100644 --- a/lib/modules/DistanceVectorRoutingC.nc +++ b/lib/modules/DistanceVectorRoutingC.nc @@ -45,4 +45,12 @@ implementation { DistanceVectorRoutingP.PacketsList -> PacketsList; + //Lists + components new PoolC(reciveInfo, 100); + components new QueueC(reciveInfo*, 100); + + DistanceVectorRoutingP.Pool -> PoolC; + DistanceVectorRoutingP.Queue -> QueueC; + + } \ No newline at end of file diff --git a/lib/modules/DistanceVectorRoutingP.nc b/lib/modules/DistanceVectorRoutingP.nc index 965cb5b..550d575 100644 --- a/lib/modules/DistanceVectorRoutingP.nc +++ b/lib/modules/DistanceVectorRoutingP.nc @@ -28,6 +28,9 @@ module DistanceVectorRoutingP uses interface Random; //Not really used anymore uses interface RouteTable; + uses interface Queue; + uses interface Pool; + //interface PacketAcknowledgements <- i just found this //interface RouteSelect; //interface RouteControl as RouteSelectCntl; @@ -76,6 +79,8 @@ implementation void printRouteTable(); void InitalizeRoutingTable(); void updateRoutingTable(route * newRoutes, uint16_t size); + error_t receive(message_t* msg, pack* payload, uint8_t len); + //--==Comands==--＼＼ @@ -83,7 +88,7 @@ implementation //Starts timer to send route values to our neighbors command void DistanceVectorRouting.run() { - call InitalizationWait.startOneShot(1000); + call InitalizationWait.startOneShot(30000); //call InitalizationWait.startPeriodic(30000 /*+ (call Random.rand16() %300)*/); //30 Seconds //call periodicTimer.startPeriodic(150000 /* // + (call Random.rand16() %300) */); @@ -174,14 +179,60 @@ implementation } } } - call advertiseTimer.startOneShot(6000); + call advertiseTimer.startOneShot(20000); } + task void receiveBufferTask(){ + // If we have a values in our queue and the radio is not busy, then + // attempt to send a packet. + if(!call Queue.empty()){ + reciveInfo *info; + // We are peeking since, there is a possibility that the value will not + // be successfuly sent and we would like to continue to attempt to send + // it until we are successful. There is no limit on how many attempts + // can be made. + info = call Queue.head(); + + // Attempt to send it. + if(SUCCESS == receive(&(info->msg),&(info->payload), info->len)){ + //Release resources used if the attempt was successful + call Queue.dequeue(); + call Pool.put(info); + } + } + } + event message_t* Receiver.receive(message_t* msg, void* payload, uint8_t len){ + if(!call Pool.empty()){ + reciveInfo *input; + // message_t msg2; + + // memcpy(&msg2, msg, sizeof(*msg)); + + // dbg(ROUTING_CHANNEL, "Print call AMPacket.source(msg2) : %d\n",call AMPacket.source(&msg2)); + + input = call Pool.get(); + memcpy(&(input->msg), msg, sizeof(*msg)); + memcpy(&(input->payload), payload, PACKET_MAX_PAYLOAD_SIZE); + input->len = len; + + // Now that we have a value from the pool we can put it into our queue. + // This is a FIFO queue. + call Queue.enqueue(input); + + // Start a send task which will be delayed. + post receiveBufferTask(); + + return msg; + } + return msg; + } + + error_t receive(message_t* msg, pack* payload, uint8_t len){ dbg(ROUTING_CHANNEL, "Packet Received in DVRouter\n"); //Check to see if the packet is the right size if(len==sizeof(pack)){ - pack* myMsg=(pack*) payload; + pack* myMsg= payload; route* routes = (route*) myMsg->payload; route* theTable = call RouteTable.getPointer(); uint16_t cost = routes->Cost + 1; @@ -191,18 +242,18 @@ implementation //Check that the packet has the proper protocol if(myMsg->protocol != PROTOCOL_DV){ dbg(ROUTING_CHANNEL, "Wrong Protocal Recived\n"); - return msg;} + return SUCCESS;} //Check that the route's "destination" is not the current node if((routes->Destination).id == TOS_NODE_ID){ - return msg; + return SUCCESS; } //main RIP receiver //if (dest ∈/ known) and (newMetric < 16) then if(position == MAX_ROUTES/* && cost < MAX_COST*/){ //New Route if (call RouteTable.size() >= MAX_ROUTES){ dbg(ROUTING_CHANNEL, "Routing Table Full\n"); - return msg;} + return SUCCESS;} (forNewRoute.Destination).id = (routes->Destination).id; forNewRoute.Cost = cost; (forNewRoute.NextHop).id = myMsg->src; @@ -220,10 +271,10 @@ implementation //theTable[position]->Destination.id = (routes->Destination).id; } } - return msg; + return SUCCESS; } dbg(ROUTING_CHANNEL, "Unknown Packet Type %d\n", len); - return msg; + return SUCCESS; } //--==Funcions==--＼＼ diff --git a/lib/modules/NeighborDiscoveryP.nc b/lib/modules/NeighborDiscoveryP.nc index 1ae9be9..c0ba2ad 100644 --- a/lib/modules/NeighborDiscoveryP.nc +++ b/lib/modules/NeighborDiscoveryP.nc @@ -48,19 +48,30 @@ implementation makePack(&sendPackage, TOS_NODE_ID, AM_BROADCAST_ADDR, 1, SEQ_NUM, PROTOCOL_PING, temp, PACKET_MAX_PAYLOAD_SIZE); call Sender.send(sendPackage, AM_BROADCAST_ADDR); - call periodicTimer.startPeriodic(10000); + call periodicTimer.startPeriodic(20000); } - event void periodicTimer.fired() - { - dbg(NEIGHBOR_CHANNEL, "Sending from NeighborDiscovery\n"); + task void updateNeighborsTask(){ updateNeighbors(); + } - //optional - call a funsion to organize the list + task void senderTask(){ makePack(&sendPackage, TOS_NODE_ID, AM_BROADCAST_ADDR, 1, SEQ_NUM, PROTOCOL_PING, temp, PACKET_MAX_PAYLOAD_SIZE); call Sender.send(sendPackage, AM_BROADCAST_ADDR); } + + event void periodicTimer.fired() + { + dbg(NEIGHBOR_CHANNEL, "Sending from NeighborDiscovery\n"); + post updateNeighborsTask(); + + //optional - call a function to organize the list + post senderTask(); + } + + + command void NeighborDiscovery.print() { printNeighborhood(); diff --git a/lib/modules/SimpleSendC.nc b/lib/modules/SimpleSendC.nc index 40fb286..4de7f9a 100644 --- a/lib/modules/SimpleSendC.nc +++ b/lib/modules/SimpleSendC.nc @@ -21,8 +21,8 @@ implementation{ SimpleSendP.AMSend -> AMSenderC; //Lists - components new PoolC(sendInfo, 100); - components new QueueC(sendInfo*, 100); + components new PoolC(sendInfo, 200); + components new QueueC(sendInfo*, 200); SimpleSendP.Pool -> PoolC; SimpleSendP.Queue -> QueueC; diff --git a/lib/modules/TransportP.nc b/lib/modules/TransportP.nc index 8994258..2ae0fd2 100644 --- a/lib/modules/TransportP.nc +++ b/lib/modules/TransportP.nc @@ -198,7 +198,7 @@ module TransportP{ // call a sender timmer // call sendDataTimer.startPeriodic(2 * tempSocket.RTT); - call sendDataTimer.startPeriodic(80000); + call sendDataTimer.startPeriodic(81000); return written; } @@ -214,9 +214,22 @@ module TransportP{ uint8_t size = call Connections.size(); uint32_t * keys = call Connections.getKeys(); - if(size == 0){ + for(i=0;isendBuff[0] != 0){ + i = 0; + break; + } + } + + if(size == 0 || i == size ){ + dbg(TRANSPORT_CHANNEL,"Data Timer Stoped\n"); call sendDataTimer.stop(); } + + + + dbg(TRANSPORT_CHANNEL," ATTEMPTING TO SEND DATA\n"); for(i=0;i Date: Tue, 7 Apr 2020 17:56:45 -0700 Subject: [PATCH 05/28] close --- includes/socket.h | 22 +++--- lib/modules/TransportP.nc | 141 ++++++++++++++------------------------ 2 files changed, 62 insertions(+), 101 deletions(-) diff --git a/includes/socket.h b/includes/socket.h index 2d31614..cb2a608 100644 --- a/includes/socket.h +++ b/includes/socket.h @@ -9,17 +9,17 @@ enum{ }; enum socket_state{ - CLOSED, - LISTEN, - SYN_SENT, - SYN_RCVD, - ESTABLISHED, - CLOSE_WAIT, - LAST_ACK, - FIN_WAIT_1, - FIN_WAIT_2, - CLOSING, - TIME_WAIT, + CLOSED, //0 + LISTEN, //1 + SYN_SENT, //2 + SYN_RCVD, //3 + ESTABLISHED,//4 + CLOSE_WAIT, //5 + LAST_ACK, //6 + FIN_WAIT_1, //7 + FIN_WAIT_2, //8 + CLOSING, //9 + TIME_WAIT, //10 }; typedef nx_uint8_t nx_socket_port_t; diff --git a/lib/modules/TransportP.nc b/lib/modules/TransportP.nc index 2ae0fd2..2c7308a 100644 --- a/lib/modules/TransportP.nc +++ b/lib/modules/TransportP.nc @@ -497,7 +497,26 @@ module TransportP{ } if(mySegment->Flags == RESET){} if(mySegment->Flags == SYN){} - if(mySegment->Flags == FIN){} + if(mySegment->Flags == FIN){ + dbg(TRANSPORT_CHANNEL, "In state ESTABLISHED, in flag FIN \n"); + curConection-> state = CLOSE_WAIT; + makeTCPpack(&sendPackageTCP, //tcp_pack *Package + curConection->src, + curConection->dest.port, //uint8_t des //not sure + ACK, //uint8_t flag + 1, //myTcpHeader->Seq_Num, //uint8_t seq + 1, //myTcpHeader->Seq_Num, //socketHolder->nextExpected///uint8_t ack + 1, //uint8_t HdrLen + 1, //uint8_t advertised_window + "", //uint8_t* payload + 1); //uint8_t length + makeIPpack(&sendIPpackage, &sendPackageTCP, curConection, PACKET_MAX_PAYLOAD_SIZE); + call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(curConection->dest.addr)); + //call timer first or after? + call Transport.close(curConection->src); + //timer? or command most likey command + + } break; case CLOSE_WAIT: if(mySegment->Flags == URG){} @@ -542,20 +561,37 @@ module TransportP{ //edit sender call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(curConection->dest.addr)); curConection->state = TIME_WAIT; - //timer + //timer curConection-> state = CLOSED; } break; case FIN_WAIT_1: if(mySegment->Flags == URG){} - if(mySegment->Flags == ACK){} + if(mySegment->Flags == ACK){ // need to add case for normal packets + //this is just for the close + curConection ->state = FIN_WAIT_2; + //... + + + } if(mySegment->Flags == PUSH){} if(mySegment->Flags == RESET){} if(mySegment->Flags == SYN){} if(mySegment->Flags == FIN){ //--------------------------------------------------------------------------------------------------------------------- - curConection-> state = CLOSE_WAIT; + // state in curConnection is CLOSE_WAIT + //---------------------------------------------------------------------------------------------------------------------------------- + } + break; + case FIN_WAIT_2: + if(mySegment->Flags == URG){} + if(mySegment->Flags == ACK){} + if(mySegment->Flags == PUSH){} + if(mySegment->Flags == RESET){} + if(mySegment->Flags == SYN){} + if(mySegment->Flags == FIN){ + curConection-> state = TIME_WAIT; makeTCPpack(&sendPackageTCP, //tcp_pack *Package curConection->src, curConection->dest.port, //uint8_t des //not sure @@ -568,19 +604,9 @@ module TransportP{ 1); //uint8_t length makeIPpack(&sendIPpackage, &sendPackageTCP, curConection, PACKET_MAX_PAYLOAD_SIZE); call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(curConection->dest.addr)); - //timer? - call Transport.close(curConection->src); // state in curConnection is CLOSE_WAIT - //---------------------------------------------------------------------------------------------------------------------------------- + //set a timer that eventually closes the socket } break; - case FIN_WAIT_2: - if(mySegment->Flags == URG){} - if(mySegment->Flags == ACK){} - if(mySegment->Flags == PUSH){} - if(mySegment->Flags == RESET){} - if(mySegment->Flags == SYN){} - if(mySegment->Flags == FIN){} - break; case CLOSING: if(mySegment->Flags == URG){} if(mySegment->Flags == ACK){} @@ -708,7 +734,9 @@ module TransportP{ */ command error_t Transport.close(socket_t fd) { + socket_store_t * mySocket; + dbg(TRANSPORT_CHANNEL, "In close function, line 711 in TransportP \n"); //tcpHeader * myTcpHeader = (tcpHeader*) myPacket->payload; if (!(call Connections.contains(fd))) @@ -726,10 +754,15 @@ module TransportP{ break; case LISTEN: //nothing + mySocket->state = CLOSED; + dbg(TRANSPORT_CHANNEL, "Socket that had listen is now closed \n"); + return SUCCESS; + break; case SYN_SENT: //nothing case SYN_RCVD: //nothing case ESTABLISHED: //good //APPPARANTLY not used here + dbg(TRANSPORT_CHANNEL, "In close ESTABLISHED \n"); mySocket->state = FIN_WAIT_1; // mySocket->dest.port= myTcpHeader->Src_Port; //ask if necessary // mySocket->dest.addr= myPacket->src; //ask if necessary @@ -753,7 +786,9 @@ module TransportP{ return SUCCESS; break; + //make timer that checks if the packets of the payload are done sending, wait APP, research to know when it's done, timer or a command case CLOSE_WAIT: //changes wait to FIN WAIT 2 flag fin + dbg(TRANSPORT_CHANNEL, "In close CLOSE_WAIT \n"); mySocket-> state = LAST_ACK; makeTCPpack(&sendPackageTCP, //tcp_pack *Package @@ -826,81 +861,7 @@ module TransportP{ void sendPacketDone(error_t err){ if(err == SUCCESS){ - // socket_store_t * socketHolder; - - // uint8_t buffSize, sendSize, TCPflag, j, i; - // uint8_t size = call Connections.size(); - // uint32_t * keys = call Connections.getKeys(); - - // dbg(TRANSPORT_CHANNEL," ATTEMPTING TO RE-SEND DATA\n"); - // for(i=0;ilastSent: %d | socketHolder->lastAck %d\n",socketHolder->lastSent,socketHolder->lastAck ); - - // dbg(TRANSPORT_CHANNEL,"socketHolder->sendBuff %s\n",socketHolder->sendBuff ); - - - // if(socketHolder->state == ESTABLISHED && - // socketHolder->lastSent == socketHolder->lastAck && - // socketHolder->sendBuff != '\0') - // { //if true send data - // dbg(TRANSPORT_CHANNEL," Does it enter here?\n"); - // for(buffSize=0; socketHolder->sendBuff[buffSize] != '\0'; buffSize++ ){} //calculates the size of the buffer - // if(buffSize > TCP_PACKET_MAX_PAYLOAD_SIZE){//if size of buffer is > TCP_PACKET_MAX_PAYLOAD_SIZE - // sendSize = TCP_PACKET_MAX_PAYLOAD_SIZE; - // TCPflag = ACK; - // } - // else { //send normaly with PUSH flag <- let it know it is the end of the data send - // sendSize = buffSize; - // TCPflag = PUSH; - // } - // //edit socket for correct data - - // if (socketHolder->lastSent == 0) {socketHolder->lastSent = 1;} - // else{socketHolder->lastSent = 0;} - - // makeTCPpack(&sendPackageTCP, //tcp_pack *Package - // socketHolder->src, //uint8_t src - // socketHolder->dest.port, //?? //uint8_t des - // TCPflag, //uint8_t flag - // socketHolder->lastSent, //uint8_t seq - // 0, /*socketHolder->nextExpected*///uint8_t ack - // sendSize, //uint8_t HdrLen - // 1, //uint8_t advertised_window - // socketHolder->sendBuff, //uint8_t* payload - // sendSize); //uint8_t length - // makeIPpack(&sendIPpackage, &sendPackageTCP, socketHolder, PACKET_MAX_PAYLOAD_SIZE); //maybe reduce the PACKET_MAX_PAYLOAD_SIZE - - // dbg(TRANSPORT_CHANNEL," Sending Message: %s\n",sendPackageTCP.payload); - - // //send packet - // call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(socketHolder->dest.addr)); - - // //set timmer to posibly resend packet - // dbg(TRANSPORT_CHANNEL," Sendt Message: %s\n",sendPackageTCP.payload); - - // //edit buffer - // if(buffSize > TCP_PACKET_MAX_PAYLOAD_SIZE){ - // memcpy(TempSendBuff, &((socketHolder->sendBuff)[sendSize]), buffSize - sendSize); - // dbg(TRANSPORT_CHANNEL," TempSendBuff: %s\n",TempSendBuff); - // } - - // else{ - // for (i = 0; i < SOCKET_BUFFER_SIZE; i++){ //I don't know if I need to fill this - // socketHolder->sendBuff[i] = 0; - // } - // } - - - // //TempSendBuff - // //memcpy(socketHolder->sendBuff, (socketHolder->sendBuff)[sendSize], buffSize); - // //memcpy(socketHolder->sendBuff, &((socketHolder->sendBuff)[sendSize, buffSize]), buffSize - sendSize); - - // } - // } + } }//end of: void sendPacketDone(error_t err) From a54bb6667f5205a212684d4f04d7ad56cc85c35e Mon Sep 17 00:00:00 2001 From: Nathan Blais Date: Tue, 7 Apr 2020 18:03:33 -0700 Subject: [PATCH 06/28] Temp --- Node.nc | 6 ++---- lib/modules/TransportP.nc | 24 ------------------------ 2 files changed, 2 insertions(+), 28 deletions(-) diff --git a/Node.nc b/Node.nc index 643d0d5..aa0ffb1 100644 --- a/Node.nc +++ b/Node.nc @@ -118,11 +118,9 @@ implementation{ call Flooder.send(*contents, contents->dest); } if (contents->dest != TOS_NODE_ID){ //Check if the packet is not meant for the current node - dbg(GENERAL_CHANNEL, "We're in Node %d \n \t\tRouting Packet- src:%d, dest %d, seq: %d, nexthop: %d, count: %d\n \n",TOS_NODE_ID, contents->src, contents->dest, contents->seq, call DistanceVectorRouting.GetNextHop(contents->dest), call DistanceVectorRouting.GetCost(contents->dest)); - if (contents->protocol == PROTOCOL_PING || contents->protocol == PROTOCOL_PINGREPLY || contents->protocol == PROTOCOL_TCP){ + dbg(GENERAL_CHANNEL, "\t\tRouting Packet- src:%d, dest %d, seq: %d, nexthop: %d, count: %d\n",TOS_NODE_ID, contents->src, contents->dest, contents->seq, call DistanceVectorRouting.GetNextHop(contents->dest), call DistanceVectorRouting.GetCost(contents->dest)); + if (contents->protocol == PROTOCOL_PING || contents->protocol == PROTOCOL_PINGREPLY || contents->protocol == PROTOCOL_TCP) result = call Sender.send(*contents, call DistanceVectorRouting.GetNextHop(contents->dest)); - dbg(GENERAL_CHANNEL, "RECIVE EVENT SEND ON result: %d \n",result); - } else dbg(GENERAL_CHANNEL, "Recived packet with incorrect Protocol?\n"); return SUCCESS; diff --git a/lib/modules/TransportP.nc b/lib/modules/TransportP.nc index 2ae0fd2..232d35c 100644 --- a/lib/modules/TransportP.nc +++ b/lib/modules/TransportP.nc @@ -51,10 +51,7 @@ module TransportP{ void makeIPpack(pack *Package, tcpHeader *myTCPpack, socket_store_t *sock, uint8_t length); - - command socket_t Transport.socket(socket_t fd){ - //uint8_t i; dbg(TRANSPORT_CHANNEL,"Transport.socket() Called\n"); if(call Connections.contains(0)) { //if there is room if(!(call Connections.contains(fd))) @@ -63,11 +60,6 @@ module TransportP{ dbg(TRANSPORT_CHANNEL,"Failed: port %d is not available\n", fd); return NULLSocket; } - - // for(i=1; i-1 <= call Connections.size(); i++){ - // if(!(call Connections.contains(i))) //Brobubly Broken - // return (socket_t) i; - // } } dbg(TRANSPORT_CHANNEL,"Failed: No sockets are available\n"); return NULLSocket; @@ -75,7 +67,6 @@ module TransportP{ command error_t Transport.bind(socket_t fd, socket_addr_t *addr){ socket_store_t TCB; //Transmission Control Block - //int i = 0; //Checkers if(fd == 0 || fd > MAX_NUM_OF_SOCKETS){ dbg(TRANSPORT_CHANNEL,"Socket:%d is not valid. Try number: 1-10\n", fd); @@ -95,16 +86,10 @@ module TransportP{ TCB.dest = *addr; TCB.state = CLOSED; // This is the sender portion. - // for (i = 0; i < SOCKET_BUFFER_SIZE; i++){ //I don't know if I need to fill this - // TCB.sendBuff[i] = 0; - // } TCB.lastWritten = 0; TCB.lastAck = 0; TCB.lastSent = 0; // This is the receiver portion - // for (i = 0; i < SOCKET_BUFFER_SIZE; i++){ //I don't know how this should be used or mannaged - // TCB.rcvdBuff[i] = 0; - // } TCB.lastRead = 0; TCB.lastRcvd = 0; TCB.nextExpected = 0; @@ -126,11 +111,8 @@ module TransportP{ command socket_t Transport.accept(socket_t fd, pack* myPacket){ socket_store_t * mySocket; uint8_t lastRcvd; - uint8_t nextExpected; tcpHeader * myTcpHeader = (tcpHeader*) myPacket->payload; mySocket = call Connections.getPointer(fd); - dbg(TRANSPORT_CHANNEL, "STATE: %d in accept \n",mySocket->state); - lastRcvd = myTcpHeader->Seq_Num; // do i need this? mySocket->state = SYN_RCVD; @@ -153,13 +135,11 @@ module TransportP{ //call timer //send packet call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(5)); - // i need to get the new socket......but how? return fd; } - /** * Write to the socket from a buffer. This data will eventually be * transmitted through your TCP implimentation. @@ -227,9 +207,6 @@ module TransportP{ call sendDataTimer.stop(); } - - - dbg(TRANSPORT_CHANNEL," ATTEMPTING TO SEND DATA\n"); for(i=0;isendBuff, (socketHolder->sendBuff)[sendSize], buffSize); //memcpy(socketHolder->sendBuff, &((socketHolder->sendBuff)[sendSize, buffSize]), buffSize - sendSize); From dd58e080c1414ec4bcb9717e3428f5bd322a4e0b Mon Sep 17 00:00:00 2001 From: jmenjivar4 Date: Tue, 7 Apr 2020 18:15:55 -0700 Subject: [PATCH 07/28] reaches close from recient side --- lib/modules/TransportP.nc | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/lib/modules/TransportP.nc b/lib/modules/TransportP.nc index bdbc8e6..91f38af 100644 --- a/lib/modules/TransportP.nc +++ b/lib/modules/TransportP.nc @@ -513,6 +513,7 @@ module TransportP{ if(mySegment->Flags == ACK){ curConection->state=CLOSED; + dbg(TRANSPORT_CHANNEL, "CLOSED FROM CASE LAST ACK AND STATE ACK \n"); } if(mySegment->Flags == PUSH){} @@ -538,7 +539,8 @@ module TransportP{ call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(curConection->dest.addr)); curConection->state = TIME_WAIT; //timer - curConection-> state = CLOSED; + curConection-> state = CLOSED; + dbg(TRANSPORT_CHANNEL, "TIME TURNED TO CLOSED \n"); } break; case FIN_WAIT_1: From f4aadc810434aaae983e1072d53ba299fcf7b00d Mon Sep 17 00:00:00 2001 From: Nathan Blais Date: Tue, 7 Apr 2020 18:21:34 -0700 Subject: [PATCH 08/28] Cleaned up warnings --- includes/socket.h | 22 +++++++++++----------- lib/modules/TransportP.nc | 31 ++++++++++++++----------------- 2 files changed, 25 insertions(+), 28 deletions(-) diff --git a/includes/socket.h b/includes/socket.h index cb2a608..d762be5 100644 --- a/includes/socket.h +++ b/includes/socket.h @@ -9,17 +9,17 @@ enum{ }; enum socket_state{ - CLOSED, //0 - LISTEN, //1 - SYN_SENT, //2 - SYN_RCVD, //3 - ESTABLISHED,//4 - CLOSE_WAIT, //5 - LAST_ACK, //6 - FIN_WAIT_1, //7 - FIN_WAIT_2, //8 - CLOSING, //9 - TIME_WAIT, //10 + CLOSED, //0 + LISTEN, //1 + SYN_SENT, //2 + SYN_RCVD, //3 + ESTABLISHED, //4 + CLOSE_WAIT, //5 + LAST_ACK, //6 + FIN_WAIT_1, //7 + FIN_WAIT_2, //8 + CLOSING, //9 + TIME_WAIT, //10 }; typedef nx_uint8_t nx_socket_port_t; diff --git a/lib/modules/TransportP.nc b/lib/modules/TransportP.nc index bdbc8e6..98c903f 100644 --- a/lib/modules/TransportP.nc +++ b/lib/modules/TransportP.nc @@ -190,7 +190,7 @@ module TransportP{ if(err == SUCCESS){ socket_store_t * socketHolder; uint8_t TempSendBuff[SOCKET_BUFFER_SIZE]; - uint8_t buffSize, sendSize, TCPflag, j, i; + uint8_t buffSize, sendSize, TCPflag, i; uint8_t size = call Connections.size(); uint32_t * keys = call Connections.getKeys(); @@ -484,8 +484,8 @@ module TransportP{ 1, //myTcpHeader->Seq_Num, //socketHolder->nextExpected///uint8_t ack 1, //uint8_t HdrLen 1, //uint8_t advertised_window - "", //uint8_t* payload - 1); //uint8_t length + Empty, //uint8_t* payload + 0); //uint8_t length makeIPpack(&sendIPpackage, &sendPackageTCP, curConection, PACKET_MAX_PAYLOAD_SIZE); call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(curConection->dest.addr)); //call timer first or after? @@ -529,8 +529,8 @@ module TransportP{ 1, //myTcpHeader->Seq_Num, //socketHolder->nextExpected///uint8_t ack 1, //uint8_t HdrLen 1, //uint8_t advertised_window - "", //uint8_t* payload - 1); //uint8_t length + Empty, //uint8_t* payload + 0); //uint8_t length makeIPpack(&sendIPpackage, &sendPackageTCP, curConection, PACKET_MAX_PAYLOAD_SIZE); //call timer //send packet @@ -576,8 +576,8 @@ module TransportP{ 1, //myTcpHeader->Seq_Num, //socketHolder->nextExpected///uint8_t ack 1, //uint8_t HdrLen 1, //uint8_t advertised_window - "", //uint8_t* payload - 1); //uint8_t length + Empty, //uint8_t* payload + 0); //uint8_t length makeIPpack(&sendIPpackage, &sendPackageTCP, curConection, PACKET_MAX_PAYLOAD_SIZE); call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(curConection->dest.addr)); //set a timer that eventually closes the socket @@ -624,23 +624,20 @@ module TransportP{ * from the pass buffer. This may be shorter then bufflen */ command uint16_t Transport.read(socket_t fd, uint8_t *buff, uint16_t bufflen){ - uint8_t buffSize, i; + uint8_t buffSize; socket_store_t * socketHolder = call Connections.getPointer(fd); dbg(TRANSPORT_CHANNEL, "Transport Called Read\n"); for(buffSize=0; socketHolder->sendBuff[buffSize] != '\0'; buffSize++ ){} //calculates the size of the buffer - // for (i = 0; i < bufflen; i++){ - // socketHolder->rcvdBuff[buffSize + i] = buff[i] ; - // } - - strcat(socketHolder->rcvdBuff, buff); + strcat((socketHolder->rcvdBuff), buff); if (socketHolder->lastRead == 0) {socketHolder->lastRead = 1;} else{socketHolder->lastRead = 0;} if (socketHolder->nextExpected == 0) {socketHolder->nextExpected = 1;} else{socketHolder->nextExpected = 0;} + return 1; // for warning } command error_t Transport.connect(socket_t fd, socket_addr_t * addr){ @@ -751,8 +748,8 @@ module TransportP{ 1, //socketHolder->nextExpected///uint8_t ack 1, //uint8_t HdrLen 1, //uint8_t advertised_window - "", //uint8_t* payload - 1); //uint8_t length + Empty, //uint8_t* payload + 0); //uint8_t length makeIPpack(&sendIPpackage, &sendPackageTCP, mySocket, PACKET_MAX_PAYLOAD_SIZE); //call timer //send packet @@ -775,8 +772,8 @@ module TransportP{ 1, //myTcpHeader->Seq_Num, //socketHolder->nextExpected///uint8_t ack 1, //uint8_t HdrLen 1, //uint8_t advertised_window - "", //uint8_t* payload - 1); //uint8_t length + Empty, //uint8_t* payload + 0); //uint8_t length makeIPpack(&sendIPpackage, &sendPackageTCP, mySocket, PACKET_MAX_PAYLOAD_SIZE); //call timer //send packet From a213495a8e1e537616fdf2b7d91d9be6062d349d Mon Sep 17 00:00:00 2001 From: Nathan Blais Date: Tue, 7 Apr 2020 23:32:11 -0700 Subject: [PATCH 09/28] Cleanup and sqn # --- Node.nc | 2 +- includes/socket.h | 32 +- lib/modules/TransportC.nc | 11 + lib/modules/TransportP.nc | 769 +++++++++++++++++--------------------- 4 files changed, 385 insertions(+), 429 deletions(-) diff --git a/Node.nc b/Node.nc index aa0ffb1..6e557c6 100644 --- a/Node.nc +++ b/Node.nc @@ -209,7 +209,7 @@ implementation{ dbg(TRANSPORT_CHANNEL, "sizeof(payload): %d\n", i); //AmountWritten = - //call Transport.write(srcPort,payload,i); + call Transport.write(srcPort,payload,i); //add the payload to a que to be cut up and packaged to be sent after connection diff --git a/includes/socket.h b/includes/socket.h index d762be5..ada7241 100644 --- a/includes/socket.h +++ b/includes/socket.h @@ -9,17 +9,16 @@ enum{ }; enum socket_state{ - CLOSED, //0 - LISTEN, //1 - SYN_SENT, //2 - SYN_RCVD, //3 - ESTABLISHED, //4 - CLOSE_WAIT, //5 - LAST_ACK, //6 - FIN_WAIT_1, //7 - FIN_WAIT_2, //8 - CLOSING, //9 - TIME_WAIT, //10 + CLOSED = 0, + LISTEN = 1, + SYN_SENT = 2, + SYN_RCVD = 3, + ESTABLISHED = 4, + CLOSE_WAIT = 5, + LAST_ACK = 6, + FIN_WAIT_1 = 7, + FIN_WAIT_2 = 8, + TIME_WAIT = 9 }; typedef nx_uint8_t nx_socket_port_t; @@ -35,6 +34,14 @@ typedef nx_struct socket_addr_t{ // File descripter id. Each id is associated with a socket_store_t typedef uint8_t socket_t; +enum { + /* how many timer tics to stay in TIME_WAIT */ + TIMEWAIT_LEN = 1, + //2MSL = 4, + /* how many un-acked retransmissions before we give up the connection */ + GIVEUP = 6, +}; + typedef struct socket_store_t{ //(TCB) - Transmission Control Block uint8_t flag; @@ -87,6 +94,9 @@ typedef struct socket_store_t{ //(TCB) - Transmission Control Block uint16_t RTT; uint8_t effectiveWindow; + /* retransmission counter */ + uint16_t reTransCnt; + pack LastSentIPpackage; }socket_store_t; diff --git a/lib/modules/TransportC.nc b/lib/modules/TransportC.nc index 02b1178..2b1330e 100644 --- a/lib/modules/TransportC.nc +++ b/lib/modules/TransportC.nc @@ -32,4 +32,15 @@ implementation { TransportP.sendDataTimer -> sendDataTimer; //NOTE: wire timmers + + + //Lists + components new PoolC(pack, 100); + components new QueueC(pack*, 100); + + TransportP.Pool -> PoolC; + TransportP.Queue -> QueueC; + + + } \ No newline at end of file diff --git a/lib/modules/TransportP.nc b/lib/modules/TransportP.nc index 4270bd1..7cc7583 100644 --- a/lib/modules/TransportP.nc +++ b/lib/modules/TransportP.nc @@ -27,6 +27,12 @@ module TransportP{ uses interface Timer as sendPacketTimer; uses interface Timer as sendDataTimer; + uses interface Queue; + uses interface Pool; + + //make buffer to store last packet recived + + } implementation{ @@ -49,6 +55,8 @@ module TransportP{ void makeTCPpack(tcpHeader *Package, uint8_t src, uint8_t dest, uint8_t flag, uint8_t seq, uint8_t ack, uint8_t len, uint8_t ad_win, uint8_t* payload, uint8_t length); void makeIPpack(pack *Package, tcpHeader *myTCPpack, socket_store_t *sock, uint8_t length); + error_t receive(pack* package); + command socket_t Transport.socket(socket_t fd){ @@ -109,60 +117,51 @@ module TransportP{ } command socket_t Transport.accept(socket_t fd, pack* myPacket){ - socket_store_t * mySocket; - uint8_t lastRcvd; + socket_store_t * socketHolder; tcpHeader * myTcpHeader = (tcpHeader*) myPacket->payload; - mySocket = call Connections.getPointer(fd); - lastRcvd = myTcpHeader->Seq_Num; // do i need this? - - mySocket->state = SYN_RCVD; - mySocket->dest.port= myTcpHeader->Src_Port; - mySocket->dest.addr= myPacket->src; - mySocket->nextExpected = 1; - - makeTCPpack(&sendPackageTCP, //tcp_pack *Package - mySocket->src, - mySocket->dest.port, //uint8_t des //not sure - SYN, //uint8_t flag - lastRcvd, //uint8_t seq - lastRcvd, //socketHolder->nextExpected///uint8_t ack - 0, //uint8_t HdrLen - 1, //uint8_t advertised_window - Empty, //uint8_t* payload - 0); //uint8_t length - makeIPpack(&sendIPpackage, &sendPackageTCP, mySocket, PACKET_MAX_PAYLOAD_SIZE); - //call timer - //send packet - call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(5)); + if (!(call Connections.contains(fd))) return FAIL; + + socketHolder = call Connections.getPointer(fd); + switch (socketHolder->state) { + case LISTEN: + default: + //Update Socket + socketHolder->state = SYN_RCVD; + socketHolder->dest.port= myTcpHeader->Src_Port; + socketHolder->dest.addr= myPacket->src; + + //socketHolder->lastAck = myTcpHeader->Seq_Num; + socketHolder->lastRcvd = myTcpHeader->Seq_Num; + socketHolder->nextExpected = 1; + + makeTCPpack(&sendPackageTCP, //tcp_pack *Package + socketHolder->src, //uint8_t src + socketHolder->dest.port, //uint8_t des + SYN, //uint8_t flag + socketHolder->lastSent, //uint8_t seq + socketHolder->lastRcvd, //uint8_t ack + 0, //uint8_t HdrLen + 1, //uint8_t advertised_window + Empty, //uint8_t* payload + 0); //uint8_t length + makeIPpack(&sendIPpackage, &sendPackageTCP, socketHolder, PACKET_MAX_PAYLOAD_SIZE); + //TO_DO:call timer + socketHolder->lastAck = sendPackageTCP.Acknowledgment; + call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(5)); + break; + } return fd; } - - /** - * Write to the socket from a buffer. This data will eventually be - * transmitted through your TCP implimentation. - * @param - * socket_t fd: file descriptor that is associated with the socket - * that is attempting a write. - * @param - * uint8_t *buff: the buffer data that you are going to wrte from. - * @param - * uint16_t bufflen: The amount of data that you are trying to - * submit. - * @Side For your project, only client side. This could be both though. - * @return uint16_t - return the amount of data you are able to write - * from the pass buffer. This may be shorter then bufflen - */ command uint16_t Transport.write(socket_t fd, uint8_t *buff, uint16_t bufflen){ socket_store_t * curSocket = call Connections.getPointer(fd); uint8_t written; dbg(TRANSPORT_CHANNEL,"Transport.write() Called\n"); - if (buff == NULL || bufflen < 1){ - return 0; - } + if (buff == NULL || bufflen < 1) return 0; + if (!(call Connections.contains(fd))) return 0; //NOTE: this will not work if you try to write too much information back to back //for that we need to get the amount of info already on the buffer and make that the @@ -176,163 +175,81 @@ module TransportP{ memcpy((curSocket->sendBuff), buff, written); dbg(TRANSPORT_CHANNEL, "Message to send is %s\n", curSocket->sendBuff); - // call a sender timmer - // call sendDataTimer.startPeriodic(2 * tempSocket.RTT); - call sendDataTimer.startPeriodic(81000); + call sendDataTimer.startPeriodic(81000); //could be set to a diffrent number return written; } - event void sendDataTimer.fired(){ - sendData(); - } - - void sendDataDone(error_t err){ - if(err == SUCCESS){ - socket_store_t * socketHolder; - uint8_t TempSendBuff[SOCKET_BUFFER_SIZE]; - uint8_t buffSize, sendSize, TCPflag, i; - uint8_t size = call Connections.size(); - uint32_t * keys = call Connections.getKeys(); - - for(i=0;isendBuff[0] != 0){ - i = 0; - break; + task void receiveBufferTask(){ + // If we have a values in our queue and the radio is not busy, then + // attempt to send a packet. + if(!call Queue.empty()){ + pack *info; + // We are peeking since, there is a possibility that the value will not + // be successfuly sent and we would like to continue to attempt to send + // it until we are successful. There is no limit on how many attempts + // can be made. + info = call Queue.head(); + + // Attempt to send it. + if(SUCCESS == receive(info)){ + //Release resources used if the attempt was successful + call Queue.dequeue(); + call Pool.put(info); + } } - } - - if(size == 0 || i == size ){ - dbg(TRANSPORT_CHANNEL,"Data Timer Stoped\n"); - call sendDataTimer.stop(); - } - - dbg(TRANSPORT_CHANNEL," ATTEMPTING TO SEND DATA\n"); - for(i=0;ilastSent: %d | socketHolder->lastAck %d\n",socketHolder->lastSent,socketHolder->lastAck ); - - dbg(TRANSPORT_CHANNEL,"socketHolder->sendBuff %s\n",socketHolder->sendBuff ); - - - if(socketHolder->state == ESTABLISHED && - socketHolder->lastSent == socketHolder->lastAck && - socketHolder->sendBuff != '\0') - { //if true send data - dbg(TRANSPORT_CHANNEL," Does it enter here?\n"); - for(buffSize=0; socketHolder->sendBuff[buffSize] != '\0'; buffSize++ ){} //calculates the size of the buffer - if(buffSize > TCP_PACKET_MAX_PAYLOAD_SIZE){//if size of buffer is > TCP_PACKET_MAX_PAYLOAD_SIZE - sendSize = TCP_PACKET_MAX_PAYLOAD_SIZE; - TCPflag = ACK; - } - else { //send normaly with PUSH flag <- let it know it is the end of the data send - sendSize = buffSize; - TCPflag = PUSH; - } - //edit socket for correct data - - if (socketHolder->lastSent == 0) {socketHolder->lastSent = 1;} - else{socketHolder->lastSent = 0;} - - makeTCPpack(&sendPackageTCP, //tcp_pack *Package - socketHolder->src, //uint8_t src - socketHolder->dest.port, //?? //uint8_t des - TCPflag, //uint8_t flag - socketHolder->lastSent, //uint8_t seq - 0, /*socketHolder->nextExpected*///uint8_t ack - sendSize, //uint8_t HdrLen - 1, //uint8_t advertised_window - socketHolder->sendBuff, //uint8_t* payload - sendSize); //uint8_t length - makeIPpack(&sendIPpackage, &sendPackageTCP, socketHolder, PACKET_MAX_PAYLOAD_SIZE); //maybe reduce the PACKET_MAX_PAYLOAD_SIZE - - dbg(TRANSPORT_CHANNEL," Sending Message: %s\n",sendPackageTCP.payload); - - //send packet - call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(socketHolder->dest.addr)); - - //set timmer to posibly resend packet - dbg(TRANSPORT_CHANNEL," Sendt Message: %s\n",sendPackageTCP.payload); - - //edit buffer - if(buffSize > TCP_PACKET_MAX_PAYLOAD_SIZE){ - memcpy(TempSendBuff, &((socketHolder->sendBuff)[sendSize]), buffSize - sendSize); - dbg(TRANSPORT_CHANNEL," TempSendBuff: %s\n",TempSendBuff); - } + } + command error_t Transport.receive(pack* package){ + if(!call Pool.empty()){ + pack *input; + input = call Pool.get(); + memcpy(input, package, PACKET_MAX_PAYLOAD_SIZE); - else{ - for (i = 0; i < SOCKET_BUFFER_SIZE; i++){ //I don't know if I need to fill this - socketHolder->sendBuff[i] = 0; - } - } + // Now that we have a value from the pool we can put it into our queue. + // This is a FIFO queue. + call Queue.enqueue(input); - //TempSendBuff - //memcpy(socketHolder->sendBuff, (socketHolder->sendBuff)[sendSize], buffSize); - //memcpy(socketHolder->sendBuff, &((socketHolder->sendBuff)[sendSize, buffSize]), buffSize - sendSize); + // Start a send task which will be delayed. + post receiveBufferTask(); - } - } + return SUCCESS; } - }//end of: void sendDataDone(error_t err) - - task void sendDataTask(){ - - sendDataDone(SUCCESS); + return FAIL; } - error_t sendData(){ - post sendDataTask(); - return SUCCESS; - } - /** - * This will pass the packet so you can handle it internally. - * @param - * pack *package: the TCP packet that you are handling. - * @Side Client/Server - * @return uint16_t - return SUCCESS if you are able to handle this - * packet or FAIL if there are errors. - */ - command error_t Transport.receive(pack* package){ + error_t receive(pack* package){ pack* myMsg=(pack*) package; tcpHeader* mySegment = (tcpHeader*) myMsg->payload; socket_store_t * curConection = call Connections.getPointer(mySegment->Dest_Port); dbg(TRANSPORT_CHANNEL, "Transport.receive() Called\n"); + //TO_DO: add check here to see if the packet has been seen before - // if(curConection->nextExpected != mySegment->Seq_Num){ - // dbg(TRANSPORT_CHANNEL, "Recived packet with unexpected SEQ #\n"); - // return FAIL; - // } + if(curConection->nextExpected != mySegment->Seq_Num){ + dbg(TRANSPORT_CHANNEL, "Recived packet with unexpected SEQ #\n"); + return FAIL; + } //put some checks here //check if the ack of the packet is the expected ack - dbg(TRANSPORT_CHANNEL, "STATE: %d \n",curConection->state); + dbg(TRANSPORT_CHANNEL, "STATE: %d | FLAG: %d\n", curConection->state, mySegment->Flags); switch (curConection->state) { case CLOSED: //Don't know what do do with it yet break; case LISTEN: - dbg(TRANSPORT_CHANNEL, "Transport Called Listen\n"); - if(mySegment->Flags == URG){} - else if(mySegment->Flags == ACK){} //DONT USE - else if(mySegment->Flags == PUSH){} //I DONT KNOW - else if(mySegment->Flags == RESET){} - else if(mySegment->Flags == SYN){ + if(mySegment->Flags == SYN){ call Transport.accept(curConection->src, myMsg); return SUCCESS; - } //<- the main one - else if(mySegment->Flags == FIN){} //I DONT KNOW - else{}//Wrong info - + } + else{ //Wrong info + return FAIL; + } break; case SYN_SENT: //put some checks here @@ -343,109 +260,118 @@ module TransportP{ curConection->lastRcvd = mySegment->Seq_Num; curConection->lastSent = 1; curConection->nextExpected = 1; + curConection->lastAck = mySegment->Seq_Num; curConection->effectiveWindow = mySegment->Advertised_Window; - //curConection.RTT = call LocalTime.get() - tempSocket.RTT + 10; - - - //Make the packet to send - makeTCPpack(&sendPackageTCP, //tcp_pack *Package - mySegment->Dest_Port, //uint8_t src - mySegment->Src_Port, //?? //uint8_t des - ACK, //uint8_t flag - 1, //uint8_t seq - 1, /*socketHolder->nextExpected*///uint8_t ack - 0, //uint8_t HdrLen - 1, //uint8_t advertised_window - Empty, //uint8_t* payload - 0); //uint8_t length - makeIPpack(&sendIPpackage, &sendPackageTCP, curConection, PACKET_MAX_PAYLOAD_SIZE); //maybe reduce the PACKET_MAX_PAYLOAD_SIZE + //curConection.RTT = call LocalTime.get() - tempSocket.RTT + 10; - //save a copy of the packet to posibly be sent by a timmer - call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(myMsg->src)); - return SUCCESS; + //Make the packet to send + makeTCPpack(&sendPackageTCP, //tcp_pack *Package + mySegment->Dest_Port, //uint8_t src + mySegment->Src_Port, //uint8_t des + ACK, //uint8_t flag + curConection->lastSent, //uint8_t seq + curConection->lastAck, //uint8_t ack + 0, //uint8_t HdrLen + 1, //uint8_t advertised_window + Empty, //uint8_t* payload + 0); //uint8_t length + makeIPpack(&sendIPpackage, &sendPackageTCP, curConection, PACKET_MAX_PAYLOAD_SIZE); //maybe reduce the PACKET_MAX_PAYLOAD_SIZE + curConection->lastAck = sendPackageTCP.Acknowledgment; + //TO_DO: save a copy of the packet to be sent by a timmer + call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(myMsg->src)); + return SUCCESS; //optionally do some RTT stuff here - //send out inital ack - //set timmer - //call to start sending packets from que. - - } - if(mySegment->Flags == URG){} - if(mySegment->Flags == PUSH){} - if(mySegment->Flags == RESET){} - if(mySegment->Flags == FIN){} + else return FAIL; break; case SYN_RCVD: - //put some checks here + //put some checks here if(mySegment->Flags & ( SYN | ACK )) { //stop timmer - //change the state of the socket to established curConection->state = ESTABLISHED; - curConection->lastAck = 1; curConection->lastRcvd = mySegment->Seq_Num; + //update last sent + if (curConection->lastSent == 0) {curConection->lastSent = 1;} + else{curConection->lastSent = 0;} curConection->nextExpected = 0; //Make the packet to send + makeTCPpack(&sendPackageTCP, //tcp_pack *Package + mySegment->Dest_Port, //uint8_t src + mySegment->Src_Port, //uint8_t des + ACK, //uint8_t flag + curConection->lastSent, //uint8_t seq + mySegment->Seq_Num, //uint8_t ack + 0, //uint8_t HdrLen + 1, //uint8_t advertised_window + Empty, //uint8_t* payload + 0); //uint8_t length + makeIPpack(&sendIPpackage, &sendPackageTCP, curConection, PACKET_MAX_PAYLOAD_SIZE); //maybe reduce the PACKET_MAX_PAYLOAD_SIZE + curConection->lastAck = sendPackageTCP.Acknowledgment; + //TO_DO: save a copy of the packet to posibly be sent by a timmer + call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(myMsg->src)); + return SUCCESS; + } + else return FAIL; + break; + + case CLOSE_WAIT: + if(mySegment->Flags == ACK){ + curConection-> state = CLOSED; + return SUCCESS; + break; + } + case FIN_WAIT_1: + if(mySegment->Flags == ACK){ // might need to add case for normal packets + //this is just for the close + curConection ->state = FIN_WAIT_2; + return SUCCESS; + break; + } + case FIN_WAIT_2: + if(mySegment->Flags == FIN){ + curConection-> state = TIME_WAIT; makeTCPpack(&sendPackageTCP, //tcp_pack *Package - mySegment->Dest_Port, //uint8_t src - mySegment->Src_Port, //?? //uint8_t des + curConection->src, + curConection->dest.port, //uint8_t des //not sure ACK, //uint8_t flag - 1, //uint8_t seq - 1, /*socketHolder->nextExpected*///uint8_t ack + 1, //myTcpHeader->Seq_Num, //uint8_t seq + 1, //myTcpHeader->Seq_Num, //socketHolder->nextExpected///uint8_t ack 0, //uint8_t HdrLen 1, //uint8_t advertised_window Empty, //uint8_t* payload 0); //uint8_t length - makeIPpack(&sendIPpackage, &sendPackageTCP, curConection, PACKET_MAX_PAYLOAD_SIZE); //maybe reduce the PACKET_MAX_PAYLOAD_SIZE - - //save a copy of the packet to posibly be sent by a timmer - call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(myMsg->src)); + makeIPpack(&sendIPpackage, &sendPackageTCP, curConection, PACKET_MAX_PAYLOAD_SIZE); + call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(curConection->dest.addr)); + //set a timer that eventually closes the socket return SUCCESS; - } - if(mySegment->Flags == URG){} - if(mySegment->Flags == PUSH){} - if(mySegment->Flags == RESET){} - if(mySegment->Flags == FIN){} break; + } case ESTABLISHED: - if(mySegment->Flags == URG){} if(mySegment->Flags == ACK){ curConection->lastAck = mySegment->Acknowledgment; curConection->lastRcvd = mySegment->Seq_Num; if(mySegment->Len == 0){ //this is a normal ack pack - //update socket + //stop resend for data } - else{ // has data - curConection->effectiveWindow = mySegment->Advertised_Window; - call Transport.read(curConection->src, mySegment->payload, mySegment->Len); - //store pack for resend - - //send back an ack packet + else{ // has data //Only need to ipmlement this if you send more than one packet of data + //update socket + call Transport.read(curConection->src, mySegment->payload, mySegment->Len); + //make ack packet + //store pack for resend + //send back an ack packet } - - - //if the packet has a len of 0 - - //change ack for socket - curConection->lastAck = mySegment->Acknowledgment; - - //curConection->nextExpected = ; - - //if you have data to send, send it else just send normal ack packet } - if(mySegment->Flags == PUSH){ - //update socket - //read the packet - dbg(TRANSPORT_CHANNEL, "Message Recived:%s\n",mySegment->payload); + else if(mySegment->Flags == PUSH){ + dbg(TRANSPORT_CHANNEL, "Message Recived:%s\n",mySegment->payload); call Transport.read(curConection->src, mySegment->payload, mySegment->Len); - //print out entire buffer dbg(TRANSPORT_CHANNEL, "\tFinished reciving Message\n"); dbg(TRANSPORT_CHANNEL, "\t\tMessage:%s\n",curConection->rcvdBuff); @@ -454,59 +380,47 @@ module TransportP{ if (curConection->lastSent == 0) {curConection->lastSent = 1;} else{curConection->lastSent = 0;} + //update last ack + if (curConection->lastAck == 0) {curConection->lastAck = 1;} + else{curConection->lastAck = 0;} + //Make the ACK packet to send makeTCPpack(&sendPackageTCP, //tcp_pack *Package - mySegment->Dest_Port, //uint8_t src - mySegment->Src_Port, //?? //uint8_t des - ACK, //uint8_t flag - curConection->lastSent, //uint8_t seq - 1, /*socketHolder->nextExpected*///uint8_t ack - 0, //uint8_t HdrLen - 1, //uint8_t advertised_window - Empty, //uint8_t* payload - 0); //uint8_t length + mySegment->Dest_Port, //uint8_t src + mySegment->Src_Port, //uint8_t des + ACK, //uint8_t flag + curConection->lastSent, //uint8_t seq + curConection->lastAck, //uint8_t ack + 0, //uint8_t HdrLen + 1, //uint8_t advertised_window + Empty, //uint8_t* payload + 0); //uint8_t length makeIPpack(&sendIPpackage, &sendPackageTCP, curConection, PACKET_MAX_PAYLOAD_SIZE); //maybe reduce the PACKET_MAX_PAYLOAD_SIZE - + //add to timer for retransmission call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(myMsg->src)); return SUCCESS; - } - if(mySegment->Flags == RESET){} - if(mySegment->Flags == SYN){} - if(mySegment->Flags == FIN){ - dbg(TRANSPORT_CHANNEL, "In state ESTABLISHED, in flag FIN \n"); - curConection-> state = CLOSE_WAIT; - makeTCPpack(&sendPackageTCP, //tcp_pack *Package + else if(mySegment->Flags == FIN){ + curConection-> state = CLOSE_WAIT; + makeTCPpack(&sendPackageTCP, //tcp_pack *Package curConection->src, curConection->dest.port, //uint8_t des //not sure ACK, //uint8_t flag 1, //myTcpHeader->Seq_Num, //uint8_t seq 1, //myTcpHeader->Seq_Num, //socketHolder->nextExpected///uint8_t ack - 1, //uint8_t HdrLen + 0, //uint8_t HdrLen 1, //uint8_t advertised_window Empty, //uint8_t* payload 0); //uint8_t length - makeIPpack(&sendIPpackage, &sendPackageTCP, curConection, PACKET_MAX_PAYLOAD_SIZE); - call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(curConection->dest.addr)); - //call timer first or after? - call Transport.close(curConection->src); - //timer? or command most likey command - + makeIPpack(&sendIPpackage, &sendPackageTCP, curConection, PACKET_MAX_PAYLOAD_SIZE); + call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(curConection->dest.addr)); + //call timer first or after? + call Transport.close(curConection->src); + //timer? or command most likey command } - break; - case CLOSE_WAIT: - if(mySegment->Flags == URG){} - if(mySegment->Flags == ACK){ -//------------------------------------------------------------------------------------------------------------------------ - curConection-> state = FIN_WAIT_2; // set up a timer? if there is nothing to send go! still sending stuff, stay in this place. change it once it's done sending - break; -//------------------------------------------------------------------------------------------------------------------------- - - } - if(mySegment->Flags == PUSH){} - if(mySegment->Flags == RESET){} - if(mySegment->Flags == SYN){} - if(mySegment->Flags == FIN){} + else if(mySegment->Flags == RESET){} + else if(mySegment->Flags == URG){} + else return FAIL; break; case LAST_ACK: if(mySegment->Flags == URG){} @@ -522,13 +436,13 @@ module TransportP{ if(mySegment->Flags == FIN){ curConection-> state = LAST_ACK; - makeTCPpack(&sendPackageTCP, //tcp_pack *Package + makeTCPpack(&sendPackageTCP, //tcp_pack *Package curConection->src, curConection->dest.port, //uint8_t des //not sure ACK, //uint8_t flag 1, //myTcpHeader->Seq_Num, //uint8_t seq 1, //myTcpHeader->Seq_Num, //socketHolder->nextExpected///uint8_t ack - 1, //uint8_t HdrLen + 0, //uint8_t HdrLen 1, //uint8_t advertised_window Empty, //uint8_t* payload 0); //uint8_t length @@ -543,56 +457,6 @@ module TransportP{ dbg(TRANSPORT_CHANNEL, "TIME TURNED TO CLOSED \n"); } break; - case FIN_WAIT_1: - if(mySegment->Flags == URG){} - if(mySegment->Flags == ACK){ // need to add case for normal packets - //this is just for the close - curConection ->state = FIN_WAIT_2; - //... - - - } - if(mySegment->Flags == PUSH){} - if(mySegment->Flags == RESET){} - if(mySegment->Flags == SYN){} - if(mySegment->Flags == FIN){ - -//--------------------------------------------------------------------------------------------------------------------- - // state in curConnection is CLOSE_WAIT - //---------------------------------------------------------------------------------------------------------------------------------- - } - break; - case FIN_WAIT_2: - if(mySegment->Flags == URG){} - if(mySegment->Flags == ACK){} - if(mySegment->Flags == PUSH){} - if(mySegment->Flags == RESET){} - if(mySegment->Flags == SYN){} - if(mySegment->Flags == FIN){ - curConection-> state = TIME_WAIT; - makeTCPpack(&sendPackageTCP, //tcp_pack *Package - curConection->src, - curConection->dest.port, //uint8_t des //not sure - ACK, //uint8_t flag - 1, //myTcpHeader->Seq_Num, //uint8_t seq - 1, //myTcpHeader->Seq_Num, //socketHolder->nextExpected///uint8_t ack - 1, //uint8_t HdrLen - 1, //uint8_t advertised_window - Empty, //uint8_t* payload - 0); //uint8_t length - makeIPpack(&sendIPpackage, &sendPackageTCP, curConection, PACKET_MAX_PAYLOAD_SIZE); - call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(curConection->dest.addr)); - //set a timer that eventually closes the socket - } - break; - case CLOSING: - if(mySegment->Flags == URG){} - if(mySegment->Flags == ACK){} - if(mySegment->Flags == PUSH){} - if(mySegment->Flags == RESET){} - if(mySegment->Flags == SYN){} - if(mySegment->Flags == FIN){} - break; case TIME_WAIT: if(mySegment->Flags == URG){} if(mySegment->Flags == ACK){} @@ -642,26 +506,18 @@ module TransportP{ return 1; // for warning } + // mask a task for this command error_t Transport.connect(socket_t fd, socket_addr_t * addr){ //This is set up for stop and wait socket_store_t * socketHolder ; - if (!(call Connections.contains(fd))) - return FAIL; + if (!(call Connections.contains(fd))) return FAIL; socketHolder = call Connections.getPointer(fd); - if(socketHolder->state == LISTEN){ - dbg(TRANSPORT_CHANNEL,"Socket is already listening\n"); - return FAIL; - } - switch (socketHolder->state) { case CLOSED: socketHolder->state = SYN_SENT; //Change the state of the socket - - //the way it is currently writen assumes instant send - //we may want to change this to be sent by a que system //Make the packet to send makeTCPpack(&sendPackageTCP, //tcp_pack *Package @@ -669,28 +525,22 @@ module TransportP{ addr->port, //uint8_t des SYN, //uint8_t flag 0, //uint8_t seq - 0, /*socketHolder->nextExpected*///uint8_t ack + 0, //uint8_t ack 0, //uint8_t HdrLen 1, //uint8_t advertised_window - Empty, //uint8_t* payload + Empty, //uint8_t* payload 0); //uint8_t length makeIPpack(&sendIPpackage, &sendPackageTCP, socketHolder, PACKET_MAX_PAYLOAD_SIZE); //maybe reduce the PACKET_MAX_PAYLOAD_SIZE //save a copy of the packet to posibly be sent by a timmer + call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(addr->addr)); return SUCCESS; - break; - case LISTEN: - case SYN_SENT: - case SYN_RCVD: - case ESTABLISHED: - case CLOSE_WAIT: - case LAST_ACK: - case FIN_WAIT_1: - case FIN_WAIT_2: - case CLOSING: - case TIME_WAIT: + case LISTEN: + dbg(TRANSPORT_CHANNEL,"Socket is already listening\n"); + return FAIL; + break; default: dbg(TRANSPORT_CHANNEL, "WRONG_STATE_ERROR: \"%d\" is an incompatable state or does not match any known states.\n", socketHolder->state); return FAIL; @@ -709,99 +559,81 @@ module TransportP{ */ command error_t Transport.close(socket_t fd) { - socket_store_t * mySocket; - dbg(TRANSPORT_CHANNEL, "In close function, line 711 in TransportP \n"); - //tcpHeader * myTcpHeader = (tcpHeader*) myPacket->payload; + dbg(TRANSPORT_CHANNEL, "Called Transport.close()\n"); - if (!(call Connections.contains(fd))) - { - return FAIL; - } - else{ - mySocket = call Connections.getPointer(fd); + if (!(call Connections.contains(fd))) return FAIL; - switch (mySocket->state){ - + mySocket = call Connections.getPointer(fd); + + switch (mySocket->state){ case CLOSED: - dbg(TRANSPORT_CHANNEL, "Already closed \n"); - return FAIL; - break; - - case LISTEN: //nothing - mySocket->state = CLOSED; - dbg(TRANSPORT_CHANNEL, "Socket that had listen is now closed \n"); - return SUCCESS; - break; - case SYN_SENT: //nothing - case SYN_RCVD: //nothing - case ESTABLISHED: //good - //APPPARANTLY not used here - dbg(TRANSPORT_CHANNEL, "In close ESTABLISHED \n"); - mySocket->state = FIN_WAIT_1; - // mySocket->dest.port= myTcpHeader->Src_Port; //ask if necessary - // mySocket->dest.addr= myPacket->src; //ask if necessary - - makeTCPpack(&sendPackageTCP, //tcp_pack *Package + dbg(TRANSPORT_CHANNEL, "Already closed \n"); + return FAIL; + break; + case LISTEN: case SYN_SENT: + mySocket->state = CLOSED; + dbg(TRANSPORT_CHANNEL, "Socket State: (LISTEN | SYN_SENT) -> CLOSED\n"); + return SUCCESS; + break; + case ESTABLISHED: //Starts the close + //sudo Code: + //Set state + //Send packet + //Set timmer + + mySocket->state = FIN_WAIT_1; + // mySocket->dest.port= myTcpHeader->Src_Port; //ask if necessary + // mySocket->dest.addr= myPacket->src; //ask if necessary + makeTCPpack(&sendPackageTCP, //tcp_pack *Package mySocket->src, mySocket->dest.port, //uint8_t des //not sure FIN, //uint8_t flag 1, //uint8_t seq 1, //socketHolder->nextExpected///uint8_t ack - 1, //uint8_t HdrLen + 0, //uint8_t HdrLen 1, //uint8_t advertised_window Empty, //uint8_t* payload 0); //uint8_t length - makeIPpack(&sendIPpackage, &sendPackageTCP, mySocket, PACKET_MAX_PAYLOAD_SIZE); - //call timer - //send packet - //edit sender - call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(mySocket->dest.addr)); - - return SUCCESS; - break; - + makeIPpack(&sendIPpackage, &sendPackageTCP, mySocket, PACKET_MAX_PAYLOAD_SIZE); + //call timer + //send packet + //edit sender + call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(mySocket->dest.addr)); + return SUCCESS; + break; //make timer that checks if the packets of the payload are done sending, wait APP, research to know when it's done, timer or a command case CLOSE_WAIT: //changes wait to FIN WAIT 2 flag fin - dbg(TRANSPORT_CHANNEL, "In close CLOSE_WAIT \n"); - mySocket-> state = LAST_ACK; - - makeTCPpack(&sendPackageTCP, //tcp_pack *Package + //sudo Code: + //Set state + //Send packet + //Set timmer + dbg(TRANSPORT_CHANNEL, "In close CLOSE_WAIT \n"); + mySocket-> state = LAST_ACK; + makeTCPpack(&sendPackageTCP, //tcp_pack *Package mySocket->src, - mySocket->dest.port, //uint8_t des //not sure + mySocket->dest.port, //uint8_t des FIN, //uint8_t flag - 1, //myTcpHeader->Seq_Num, //uint8_t seq + 1, //myTcpHeader->Seq_Num, //uint8_t seq 1, //myTcpHeader->Seq_Num, //socketHolder->nextExpected///uint8_t ack - 1, //uint8_t HdrLen + 0, //uint8_t HdrLen 1, //uint8_t advertised_window - Empty, //uint8_t* payload + Empty, //uint8_t* payload 0); //uint8_t length - makeIPpack(&sendIPpackage, &sendPackageTCP, mySocket, PACKET_MAX_PAYLOAD_SIZE); - //call timer - //send packet - //edit sender - call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(mySocket->dest.addr)); - - return SUCCESS; - break; - //------------------------------------------------------------------------------------------------ - case LAST_ACK: - case FIN_WAIT_1: - case FIN_WAIT_2: //flag fin, state fin_wait_2 - case CLOSING: - case TIME_WAIT: + makeIPpack(&sendIPpackage, &sendPackageTCP, mySocket, PACKET_MAX_PAYLOAD_SIZE); + //call timer + //send packet + //edit sender + call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(mySocket->dest.addr)); + return SUCCESS; + break; default: dbg(TRANSPORT_CHANNEL, "WRONG_STATE_ERROR: \"%d\" is an incompatable state or does not match any known states.\n", mySocket->state); return FAIL; break; - - } } - - } - /** * A hard close, which is not graceful. This portion is optional. * @param @@ -815,8 +647,7 @@ module TransportP{ command error_t Transport.listen(socket_t fd){ socket_store_t * socketHolder ; - if (!(call Connections.contains(fd))) - return FAIL; + if (!(call Connections.contains(fd))) return FAIL; socketHolder = call Connections.getPointer(fd); if(socketHolder->state == LISTEN){ dbg(TRANSPORT_CHANNEL,"Socket is already listening\n"); @@ -829,6 +660,110 @@ module TransportP{ } } + event void sendDataTimer.fired(){ + sendData(); + } + void sendDataDone(error_t err){ + if(err == SUCCESS){ + socket_store_t * socketHolder; + uint8_t TempSendBuff[SOCKET_BUFFER_SIZE]; + uint8_t buffSize, sendSize, TCPflag, i; + uint8_t size = call Connections.size(); + uint32_t * keys = call Connections.getKeys(); + + for(i=0;isendBuff[0] != 0){ + i = 0; + break; + } + } + + if(size == 0 || i == size ){ + dbg(TRANSPORT_CHANNEL,"Data Timer Stoped\n"); + call sendDataTimer.stop(); + return; + } + + dbg(TRANSPORT_CHANNEL," ATTEMPTING TO SEND DATA\n"); + for(i=0;ilastSent: %d | socketHolder->lastAck %d\n",socketHolder->lastSent,socketHolder->lastAck ); + + dbg(TRANSPORT_CHANNEL,"socketHolder->sendBuff %s\n",socketHolder->sendBuff ); + + if((socketHolder->state & (ESTABLISHED | FIN_WAIT_2) )&& + socketHolder->lastSent == socketHolder->lastAck && + socketHolder->sendBuff != '\0') + { //if true send data + dbg(TRANSPORT_CHANNEL," Does it enter here?\n"); + for(buffSize=0; socketHolder->sendBuff[buffSize] != '\0'; buffSize++ ){} //calculates the size of the buffer + if(buffSize > TCP_PACKET_MAX_PAYLOAD_SIZE){//if size of buffer is > TCP_PACKET_MAX_PAYLOAD_SIZE + sendSize = TCP_PACKET_MAX_PAYLOAD_SIZE; + TCPflag = ACK; + } + else { //send normaly with PUSH flag <- let it know it is the end of the data send + sendSize = buffSize; + TCPflag = PUSH; + } + //edit socket for correct data + + if (socketHolder->lastSent == 0) {socketHolder->lastSent = 1;} + else{socketHolder->lastSent = 0;} + + makeTCPpack(&sendPackageTCP, //tcp_pack *Package + socketHolder->src, //uint8_t src + socketHolder->dest.port, //?? //uint8_t des + TCPflag, //uint8_t flag + socketHolder->lastSent, //uint8_t seq + 0, /*socketHolder->nextExpected*///uint8_t ack + sendSize, //uint8_t HdrLen + 1, //uint8_t advertised_window + socketHolder->sendBuff, //uint8_t* payload + sendSize); //uint8_t length + makeIPpack(&sendIPpackage, &sendPackageTCP, socketHolder, PACKET_MAX_PAYLOAD_SIZE); //maybe reduce the PACKET_MAX_PAYLOAD_SIZE + + dbg(TRANSPORT_CHANNEL," Sending Message: %s\n",sendPackageTCP.payload); + + //send packet + call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(socketHolder->dest.addr)); + + //set timmer to posibly resend packet + dbg(TRANSPORT_CHANNEL," Sendt Message: %s\n",sendPackageTCP.payload); + + //edit buffer + if(buffSize > TCP_PACKET_MAX_PAYLOAD_SIZE){ + memcpy(TempSendBuff, &((socketHolder->sendBuff)[sendSize]), buffSize - sendSize); + dbg(TRANSPORT_CHANNEL," TempSendBuff: %s\n",TempSendBuff); + } + + else{ + for (i = 0; i < SOCKET_BUFFER_SIZE; i++){ //I don't know if I need to fill this + socketHolder->sendBuff[i] = 0; + } + } + + //TempSendBuff + //memcpy(socketHolder->sendBuff, (socketHolder->sendBuff)[sendSize], buffSize); + //memcpy(socketHolder->sendBuff, &((socketHolder->sendBuff)[sendSize, buffSize]), buffSize - sendSize); + + } + } + } + }//end of: void sendDataDone(error_t err) + + task void sendDataTask(){ + + sendDataDone(SUCCESS); + } + + error_t sendData(){ + post sendDataTask(); + return SUCCESS; + } event void sendPacketTimer.fired(){ sendPacket(); @@ -836,7 +771,7 @@ module TransportP{ void sendPacketDone(error_t err){ if(err == SUCCESS){ - + //Fill this in } }//end of: void sendPacketDone(error_t err) From aca2bcf870e3951771829096b22da46529338b8e Mon Sep 17 00:00:00 2001 From: Nathan Blais Date: Thu, 9 Apr 2020 23:05:43 -0700 Subject: [PATCH 10/28] Implemented new sender --- includes/socket.h | 25 +++---- lib/modules/TransportC.nc | 3 + lib/modules/TransportP.nc | 136 ++++++++++++++++++++++---------------- 3 files changed, 91 insertions(+), 73 deletions(-) diff --git a/includes/socket.h b/includes/socket.h index ada7241..d9370ae 100644 --- a/includes/socket.h +++ b/includes/socket.h @@ -34,13 +34,6 @@ typedef nx_struct socket_addr_t{ // File descripter id. Each id is associated with a socket_store_t typedef uint8_t socket_t; -enum { - /* how many timer tics to stay in TIME_WAIT */ - TIMEWAIT_LEN = 1, - //2MSL = 4, - /* how many un-acked retransmissions before we give up the connection */ - GIVEUP = 6, -}; typedef struct socket_store_t{ //(TCB) - Transmission Control Block @@ -69,9 +62,9 @@ typedef struct socket_store_t{ //(TCB) - Transmission Control Block // This is the sender portion. uint8_t sendBuff[SOCKET_BUFFER_SIZE]; - uint8_t lastWritten; //packet sequence number allowed for new data transmission + uint8_t lastWritten; // sequence numbers allowed for new data transmission uint8_t lastSent; // SND.UNA - last sent data that is not acknowledged yet - uint8_t lastAck; //last ack sent + uint8_t lastAck; // old sequence numbers which have been acknowledged /* Receive Sequence Space @@ -87,18 +80,20 @@ typedef struct socket_store_t{ //(TCB) - Transmission Control Block */ // This is the receiver portion uint8_t rcvdBuff[SOCKET_BUFFER_SIZE]; - uint8_t lastRead; //last packet put into the buffer + uint8_t lastRead; //last packet put into the buffer 1 + uint8_t nextExpected; //next packet expected 2 uint8_t lastRcvd; //largest packet recived - uint8_t nextExpected; //next packet expected - uint16_t RTT; uint8_t effectiveWindow; - /* retransmission counter */ - uint16_t reTransCnt; + uint16_t TTD; //Time To Die - pack LastSentIPpackage; + uint16_t RTT; + uint16_t lastTimeSent; //Time the last packet was sent + uint16_t lastTimeRecived; + pack LastSentIPpack; + pack LastRecivedIPpack; }socket_store_t; #endif \ No newline at end of file diff --git a/lib/modules/TransportC.nc b/lib/modules/TransportC.nc index 2b1330e..b1f93af 100644 --- a/lib/modules/TransportC.nc +++ b/lib/modules/TransportC.nc @@ -25,6 +25,9 @@ implementation { components new HashmapC(socket_store_t, MAX_NUM_OF_SOCKETS) as Connections; TransportP.Connections->Connections; + components new TimerMilliC(), LocalTimeMilliC; + TransportP.LocalTime -> LocalTimeMilliC; + components new TimerMilliC() as sendPacketTimer; TransportP.sendPacketTimer -> sendPacketTimer; diff --git a/lib/modules/TransportP.nc b/lib/modules/TransportP.nc index 7cc7583..a082f0b 100644 --- a/lib/modules/TransportP.nc +++ b/lib/modules/TransportP.nc @@ -24,15 +24,13 @@ module TransportP{ uses interface Hashmap as Connections; // hash table: list of connections + uses interface LocalTime; uses interface Timer as sendPacketTimer; uses interface Timer as sendDataTimer; uses interface Queue; uses interface Pool; - //make buffer to store last packet recived - - } implementation{ @@ -40,9 +38,8 @@ module TransportP{ // Globals const socket_t NULLSocket = 0; - tcpHeader sendPackageTCP; - pack sendIPpackage; - uint8_t * Empty; + uint16_t * Empty; + uint16_t ipSeq = 1; // Prototypes @@ -56,6 +53,7 @@ module TransportP{ void makeTCPpack(tcpHeader *Package, uint8_t src, uint8_t dest, uint8_t flag, uint8_t seq, uint8_t ack, uint8_t len, uint8_t ad_win, uint8_t* payload, uint8_t length); void makeIPpack(pack *Package, tcpHeader *myTCPpack, socket_store_t *sock, uint8_t length); error_t receive(pack* package); + void send(socket_t socKey, uint8_t flag, uint8_t* payload, uint8_t length); @@ -100,9 +98,9 @@ module TransportP{ // This is the receiver portion TCB.lastRead = 0; TCB.lastRcvd = 0; - TCB.nextExpected = 0; + TCB.nextExpected = 1; - //TCB.RTT = 5000; //NOTE:We Need to replace this value + TCB.RTT = 5000; //NOTE:We Need to replace this value TCB.effectiveWindow = 1; //NOTE:We Need to replace this value call Connections.insert(fd, TCB); @@ -132,10 +130,11 @@ module TransportP{ socketHolder->dest.port= myTcpHeader->Src_Port; socketHolder->dest.addr= myPacket->src; - //socketHolder->lastAck = myTcpHeader->Seq_Num; socketHolder->lastRcvd = myTcpHeader->Seq_Num; socketHolder->nextExpected = 1; - + socketHolder->RTT = call LocalTime.get() + 1000000; + socketHolder->lastTimeSent = call LocalTime.get(); + makeTCPpack(&sendPackageTCP, //tcp_pack *Package socketHolder->src, //uint8_t src socketHolder->dest.port, //uint8_t des @@ -198,6 +197,7 @@ module TransportP{ } } } + command error_t Transport.receive(pack* package){ if(!call Pool.empty()){ pack *input; @@ -216,8 +216,6 @@ module TransportP{ return FAIL; } - - error_t receive(pack* package){ pack* myMsg=(pack*) package; tcpHeader* mySegment = (tcpHeader*) myMsg->payload; @@ -227,7 +225,12 @@ module TransportP{ //TO_DO: add check here to see if the packet has been seen before - + if(curConection->LastRecivedIPpack.src != myMsg->src && + curConection->LastRecivedIPpack.seq != myMsg->seq) { + dbg(TRANSPORT_CHANNEL, "Recived Duplicate packet\n"); + return FAIL; + } + if(curConection->nextExpected != mySegment->Seq_Num){ dbg(TRANSPORT_CHANNEL, "Recived packet with unexpected SEQ #\n"); return FAIL; @@ -235,8 +238,10 @@ module TransportP{ //put some checks here - //check if the ack of the packet is the expected ack - + //We should update lastRcvd here; + curConection->lastRcvd = myTcpHeader->Seq_Num; //<-- update for sliding window + + dbg(TRANSPORT_CHANNEL, "STATE: %d | FLAG: %d\n", curConection->state, mySegment->Flags); switch (curConection->state) { @@ -504,37 +509,18 @@ module TransportP{ else{socketHolder->nextExpected = 0;} return 1; // for warning - } + } // mask a task for this command error_t Transport.connect(socket_t fd, socket_addr_t * addr){ - //This is set up for stop and wait socket_store_t * socketHolder ; - if (!(call Connections.contains(fd))) return FAIL; - socketHolder = call Connections.getPointer(fd); - - switch (socketHolder->state) { + switch (socketHolder->state) + { case CLOSED: - socketHolder->state = SYN_SENT; //Change the state of the socket - - //Make the packet to send - makeTCPpack(&sendPackageTCP, //tcp_pack *Package - socketHolder->src, //uint8_t src - addr->port, //uint8_t des - SYN, //uint8_t flag - 0, //uint8_t seq - 0, //uint8_t ack - 0, //uint8_t HdrLen - 1, //uint8_t advertised_window - Empty, //uint8_t* payload - 0); //uint8_t length - makeIPpack(&sendIPpackage, &sendPackageTCP, socketHolder, PACKET_MAX_PAYLOAD_SIZE); //maybe reduce the PACKET_MAX_PAYLOAD_SIZE - - //save a copy of the packet to posibly be sent by a timmer - - call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(addr->addr)); + socketHolder->state = SYN_SENT; //Change the state of the socket + send(fd, SYN, Empty, 0){ return SUCCESS; break; case LISTEN: @@ -548,7 +534,7 @@ module TransportP{ } } - /** + /** * Closes the socket. * @param * socket_t fd: file descriptor that is associated with the socket @@ -557,8 +543,8 @@ module TransportP{ * @return socket_t - returns SUCCESS if you are able to attempt * a closure with the fd passed, else return FAIL. */ - command error_t Transport.close(socket_t fd) - { + command error_t Transport.close(socket_t fd) + { socket_store_t * mySocket; dbg(TRANSPORT_CHANNEL, "Called Transport.close()\n"); @@ -632,7 +618,7 @@ module TransportP{ return FAIL; break; } - } + } /** * A hard close, which is not graceful. This portion is optional. @@ -754,12 +740,10 @@ module TransportP{ } } }//end of: void sendDataDone(error_t err) - task void sendDataTask(){ sendDataDone(SUCCESS); } - error_t sendData(){ post sendDataTask(); return SUCCESS; @@ -768,42 +752,78 @@ module TransportP{ event void sendPacketTimer.fired(){ sendPacket(); } - - void sendPacketDone(error_t err){ - if(err == SUCCESS){ - //Fill this in + void sendPacketDone(error_t err){ //assuming that this is for stop and wait. + uint8_t i; + if(err == FAIL){ + return; + } + for(i = 0; i < MAX_NUM_OF_SOCKETS; i++) { + if((call Connections.getPointer(i))->TTD < (call LocalTime.get())){//if true either reset or close the connnection + //Fill in here + return; + } + if((call Connections.getPointer(i))->RTT < call LocalTime.get() && (call Connections.getPointer(i))->lastSent != (call Connections.getPointer(i))->lastAck) { //if TRUE retransmit + dbg(TRANSPORT_CHANNEL, "Retransmitting\n"); + call Sender.send((call Connections.getPointer(i))->LastSentIPpack, call DistanceVectorRouting.GetNextHop((call Connections.getPointer(i))->dest.addr)); + } } }//end of: void sendPacketDone(error_t err) - task void sendPackeTask(){ sendPacketDone(SUCCESS); } - error_t sendPacket(){ post sendDataTask(); return SUCCESS; } - void makeTCPpack(tcpHeader *Package, uint8_t src, uint8_t dest, uint8_t flag, uint8_t seq, uint8_t ack, uint8_t len, uint8_t ad_win, uint8_t* payload, uint8_t length){ + + void send(socket_t socKey, uint8_t flag, uint8_t* payload, uint8_t length){ + tcpHeader sendPackageTCP; + pack sendIPpackage; + socket_store_t * socketHolder = call Connections.get(socKey); + + //Should be replaced when we do sliding window /////////////////////////// + if (socketHolder->lastSent == 0) {socketHolder->lastSent = 1;} // + else{socketHolder->lastSent = 0;} // + //\\ //\\ //\\ //\\ //\\ //\\ //\\ //\\ + + makeTCPpack(&sendPackageTCP, //tcp_pack *Package + curSocket->src, //uint8_t src + curSocket->dest.port, //uint8_t des + flag, //uint8_t flag + socketHolder->lastSent, //uint8_t seq + socketHolder->nextExpected,//uint8_t ack //update this later //nextExpected should be based on the last recived + length, //uint8_t HdrLen + socketHolder->effectiveWindow,//uint8_t advertised_window <- should use this equastion (lastSent - lastAck) + payload, //uint8_t* payload + length); //uint8_t length + makeIPpack(&sendIPpackage, &sendPackageTCP, socketHolder, PACKET_MAX_PAYLOAD_SIZE); //maybe reduce the PACKET_MAX_PAYLOAD_SIZE + ipSeq = ipSeq++; + + call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(socketHolder->dest.addr)); + + //save a copy of the packet to be re-sent by a timmer and set RTT & TTD lastTimeSent + + } + + void makeTCPpack(tcpHeader *Package, uint8_t src, uint8_t dest, uint8_t flag, uint8_t seq, uint8_t ack, uint8_t ad_win, uint8_t* payload, uint8_t length){ Package->Src_Port = src; Package->Dest_Port = dest; Package->Flags = flag; Package->Seq_Num = seq; Package->Acknowledgment = ack; - - Package->Len = len; - + Package->Len = length; Package->Advertised_Window = ad_win; memcpy(Package->payload, payload, length); } - void makeIPpack(pack *Package, tcpHeader *myTCPpack, socket_store_t *sock, uint8_t length){ - Package->src = (uint8_t)TOS_NODE_ID; + void makeIPpack(pack *Package, tcpHeader *myTCPpack, socket_store_t *sock, uint8_t length){ + Package->src = (uint16_t)TOS_NODE_ID; Package->dest = sock->dest.addr; Package->TTL = MAX_TTL; - Package->seq = sock->lastSent; //finish this + Package->seq = ipSeq; //finish this Package->protocol = PROTOCOL_TCP; memcpy(Package->payload, myTCPpack, length); } From 8fc5eaff973c16fceaf4ce39b9cdcff0791bf09e Mon Sep 17 00:00:00 2001 From: Nathan Blais Date: Fri, 10 Apr 2020 02:18:01 -0700 Subject: [PATCH 11/28] finish replace original sends start add task send --- TestSim.py | 2 +- includes/sendInfo.h | 8 + lib/modules/TransportC.nc | 6 +- lib/modules/TransportP.nc | 374 ++++++++++++++------------------------ 4 files changed, 147 insertions(+), 243 deletions(-) diff --git a/TestSim.py b/TestSim.py index d145321..9a79690 100644 --- a/TestSim.py +++ b/TestSim.py @@ -204,7 +204,7 @@ def main(): # s.runTime(10); # s.ping(1, 6, "I'll have you know I gr"); s.cmdTestClient(1,8,6,10, "Hello, bozo"); #[selfAdress] [srcPort] [dest] [destPort] [transfer] - s.runTime(100); + s.runTime(150); s.cmdClientClose(1,8,6,10); #[client adress] [srcPort] [dest] [destPort] s.runTime(200); diff --git a/includes/sendInfo.h b/includes/sendInfo.h index 42e3cf4..58695fd 100644 --- a/includes/sendInfo.h +++ b/includes/sendInfo.h @@ -4,6 +4,7 @@ #define PACK_BUFFER_H #include "packet.h" +#include "socket.h" enum{ SEND_BUFFER_SIZE=128 @@ -21,6 +22,13 @@ typedef struct reciveInfo{ uint8_t len; }reciveInfo; +typedef struct sendTCPInfo{ + socket_t socKey; + uint8_t flag; + pack payload; + uint8_t length; +}sendTCPInfo; + typedef struct neighbor { uint16_t id; bool flag; diff --git a/lib/modules/TransportC.nc b/lib/modules/TransportC.nc index b1f93af..f0efe32 100644 --- a/lib/modules/TransportC.nc +++ b/lib/modules/TransportC.nc @@ -36,7 +36,6 @@ implementation { //NOTE: wire timmers - //Lists components new PoolC(pack, 100); components new QueueC(pack*, 100); @@ -44,6 +43,11 @@ implementation { TransportP.Pool -> PoolC; TransportP.Queue -> QueueC; + components new PoolC(sendTCPInfo, 10) as SPool; + components new QueueC(sendTCPInfo*, 10) as SQueue; + + TransportP.SendPool -> SPool; + TransportP.SendQueue -> SQueue; } \ No newline at end of file diff --git a/lib/modules/TransportP.nc b/lib/modules/TransportP.nc index a082f0b..90d99d0 100644 --- a/lib/modules/TransportP.nc +++ b/lib/modules/TransportP.nc @@ -30,6 +30,8 @@ module TransportP{ uses interface Queue; uses interface Pool; + uses interface SendQueue; + uses interface SendPool; } @@ -38,7 +40,7 @@ module TransportP{ // Globals const socket_t NULLSocket = 0; - uint16_t * Empty; + uint8_t *Empty; uint16_t ipSeq = 1; // Prototypes @@ -49,11 +51,11 @@ module TransportP{ error_t sendPacket(); void sendPacketDone(error_t err); - - void makeTCPpack(tcpHeader *Package, uint8_t src, uint8_t dest, uint8_t flag, uint8_t seq, uint8_t ack, uint8_t len, uint8_t ad_win, uint8_t* payload, uint8_t length); + void makeTCPpack(tcpHeader *Package, uint8_t src, uint8_t dest, uint8_t flag, uint8_t seq, uint8_t ack, uint8_t ad_win, uint8_t* payload, uint8_t length); void makeIPpack(pack *Package, tcpHeader *myTCPpack, socket_store_t *sock, uint8_t length); error_t receive(pack* package); void send(socket_t socKey, uint8_t flag, uint8_t* payload, uint8_t length); + error_t sendDone(socket_t socKey, uint8_t flag, uint8_t* payload, uint8_t length); @@ -93,16 +95,20 @@ module TransportP{ TCB.state = CLOSED; // This is the sender portion. TCB.lastWritten = 0; - TCB.lastAck = 0; - TCB.lastSent = 0; + TCB.lastAck = 1; + TCB.lastSent = 1; // This is the receiver portion TCB.lastRead = 0; TCB.lastRcvd = 0; - TCB.nextExpected = 1; + TCB.nextExpected = 0; - TCB.RTT = 5000; //NOTE:We Need to replace this value + TCB.RTT = 60000; //NOTE:We Need to replace this value TCB.effectiveWindow = 1; //NOTE:We Need to replace this value + TCB.lastTimeRecived = 60000; + TCB.lastTimeSent = 0; + + call Connections.insert(fd, TCB); if(call Connections.contains(fd)){ dbg(TRANSPORT_CHANNEL,"Socket:%d bound to Node:%d Port:%d\n", fd, addr->addr, addr->port); @@ -117,11 +123,9 @@ module TransportP{ command socket_t Transport.accept(socket_t fd, pack* myPacket){ socket_store_t * socketHolder; tcpHeader * myTcpHeader = (tcpHeader*) myPacket->payload; - if (!(call Connections.contains(fd))) return FAIL; socketHolder = call Connections.getPointer(fd); - switch (socketHolder->state) { case LISTEN: default: @@ -130,25 +134,10 @@ module TransportP{ socketHolder->dest.port= myTcpHeader->Src_Port; socketHolder->dest.addr= myPacket->src; - socketHolder->lastRcvd = myTcpHeader->Seq_Num; - socketHolder->nextExpected = 1; socketHolder->RTT = call LocalTime.get() + 1000000; socketHolder->lastTimeSent = call LocalTime.get(); - - makeTCPpack(&sendPackageTCP, //tcp_pack *Package - socketHolder->src, //uint8_t src - socketHolder->dest.port, //uint8_t des - SYN, //uint8_t flag - socketHolder->lastSent, //uint8_t seq - socketHolder->lastRcvd, //uint8_t ack - 0, //uint8_t HdrLen - 1, //uint8_t advertised_window - Empty, //uint8_t* payload - 0); //uint8_t length - makeIPpack(&sendIPpackage, &sendPackageTCP, socketHolder, PACKET_MAX_PAYLOAD_SIZE); - //TO_DO:call timer - socketHolder->lastAck = sendPackageTCP.Acknowledgment; - call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(5)); + + send(fd, SYN, Empty, 0); break; } return fd; @@ -216,7 +205,8 @@ module TransportP{ return FAIL; } - error_t receive(pack* package){ + error_t receive(pack* package) + { pack* myMsg=(pack*) package; tcpHeader* mySegment = (tcpHeader*) myMsg->payload; socket_store_t * curConection = call Connections.getPointer(mySegment->Dest_Port); @@ -225,8 +215,8 @@ module TransportP{ //TO_DO: add check here to see if the packet has been seen before - if(curConection->LastRecivedIPpack.src != myMsg->src && - curConection->LastRecivedIPpack.seq != myMsg->seq) { + if(curConection->LastRecivedIPpack.src == myMsg->src && + curConection->LastRecivedIPpack.seq == myMsg->seq) { dbg(TRANSPORT_CHANNEL, "Recived Duplicate packet\n"); return FAIL; } @@ -239,7 +229,21 @@ module TransportP{ //put some checks here //We should update lastRcvd here; - curConection->lastRcvd = myTcpHeader->Seq_Num; //<-- update for sliding window + curConection->lastRcvd = mySegment->Seq_Num; + curConection->lastAck = mySegment->Acknowledgment; + + if (curConection->nextExpected == 0) {curConection->nextExpected = 1;} //<-- update for sliding window + else{curConection->nextExpected = 0;} + + //update LastRecivedIPpack + + curConection->LastRecivedIPpack = *myMsg; + + curConection->lastTimeRecived = call LocalTime.get(); + + //make sure only the sender is updating their curConection->effectiveWindow + + dbg(TRANSPORT_CHANNEL, "STATE: %d | FLAG: %d\n", curConection->state, mySegment->Flags); @@ -259,66 +263,21 @@ module TransportP{ case SYN_SENT: //put some checks here if(mySegment->Flags & ( SYN | ACK )) { - //stop timmer - //change the state of the socket to established curConection->state = ESTABLISHED; - curConection->lastRcvd = mySegment->Seq_Num; - curConection->lastSent = 1; - curConection->nextExpected = 1; - curConection->lastAck = mySegment->Seq_Num; curConection->effectiveWindow = mySegment->Advertised_Window; - //curConection.RTT = call LocalTime.get() - tempSocket.RTT + 10; - - //Make the packet to send - makeTCPpack(&sendPackageTCP, //tcp_pack *Package - mySegment->Dest_Port, //uint8_t src - mySegment->Src_Port, //uint8_t des - ACK, //uint8_t flag - curConection->lastSent, //uint8_t seq - curConection->lastAck, //uint8_t ack - 0, //uint8_t HdrLen - 1, //uint8_t advertised_window - Empty, //uint8_t* payload - 0); //uint8_t length - makeIPpack(&sendIPpackage, &sendPackageTCP, curConection, PACKET_MAX_PAYLOAD_SIZE); //maybe reduce the PACKET_MAX_PAYLOAD_SIZE - curConection->lastAck = sendPackageTCP.Acknowledgment; - //TO_DO: save a copy of the packet to be sent by a timmer - call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(myMsg->src)); + + send(mySegment->Dest_Port, ACK, Empty, 0); + //TO_DO:call to start sending packets from que. return SUCCESS; - //optionally do some RTT stuff here - //send out inital ack - //set timmer - //call to start sending packets from que. } else return FAIL; break; case SYN_RCVD: //put some checks here if(mySegment->Flags & ( SYN | ACK )) { - //stop timmer curConection->state = ESTABLISHED; - curConection->lastAck = 1; - curConection->lastRcvd = mySegment->Seq_Num; - //update last sent - if (curConection->lastSent == 0) {curConection->lastSent = 1;} - else{curConection->lastSent = 0;} - curConection->nextExpected = 0; - - //Make the packet to send - makeTCPpack(&sendPackageTCP, //tcp_pack *Package - mySegment->Dest_Port, //uint8_t src - mySegment->Src_Port, //uint8_t des - ACK, //uint8_t flag - curConection->lastSent, //uint8_t seq - mySegment->Seq_Num, //uint8_t ack - 0, //uint8_t HdrLen - 1, //uint8_t advertised_window - Empty, //uint8_t* payload - 0); //uint8_t length - makeIPpack(&sendIPpackage, &sendPackageTCP, curConection, PACKET_MAX_PAYLOAD_SIZE); //maybe reduce the PACKET_MAX_PAYLOAD_SIZE - curConection->lastAck = sendPackageTCP.Acknowledgment; - //TO_DO: save a copy of the packet to posibly be sent by a timmer - call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(myMsg->src)); + + send(mySegment->Dest_Port, ACK, Empty, 0); return SUCCESS; } else return FAIL; @@ -328,38 +287,21 @@ module TransportP{ if(mySegment->Flags == ACK){ curConection-> state = CLOSED; return SUCCESS; - break; } case FIN_WAIT_1: - if(mySegment->Flags == ACK){ // might need to add case for normal packets - //this is just for the close + if(mySegment->Flags == ACK){ curConection ->state = FIN_WAIT_2; return SUCCESS; - break; } case FIN_WAIT_2: if(mySegment->Flags == FIN){ curConection-> state = TIME_WAIT; - makeTCPpack(&sendPackageTCP, //tcp_pack *Package - curConection->src, - curConection->dest.port, //uint8_t des //not sure - ACK, //uint8_t flag - 1, //myTcpHeader->Seq_Num, //uint8_t seq - 1, //myTcpHeader->Seq_Num, //socketHolder->nextExpected///uint8_t ack - 0, //uint8_t HdrLen - 1, //uint8_t advertised_window - Empty, //uint8_t* payload - 0); //uint8_t length - makeIPpack(&sendIPpackage, &sendPackageTCP, curConection, PACKET_MAX_PAYLOAD_SIZE); - call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(curConection->dest.addr)); - //set a timer that eventually closes the socket - return SUCCESS; - break; + send(mySegment->Dest_Port, ACK, Empty, 0); + //set a timer that eventually closes the socket + return SUCCESS; } case ESTABLISHED: if(mySegment->Flags == ACK){ - curConection->lastAck = mySegment->Acknowledgment; - curConection->lastRcvd = mySegment->Seq_Num; if(mySegment->Len == 0){ //this is a normal ack pack //update socket //stop resend for data @@ -381,44 +323,13 @@ module TransportP{ dbg(TRANSPORT_CHANNEL, "\tFinished reciving Message\n"); dbg(TRANSPORT_CHANNEL, "\t\tMessage:%s\n",curConection->rcvdBuff); - //update last sent - if (curConection->lastSent == 0) {curConection->lastSent = 1;} - else{curConection->lastSent = 0;} - - //update last ack - if (curConection->lastAck == 0) {curConection->lastAck = 1;} - else{curConection->lastAck = 0;} - - //Make the ACK packet to send - makeTCPpack(&sendPackageTCP, //tcp_pack *Package - mySegment->Dest_Port, //uint8_t src - mySegment->Src_Port, //uint8_t des - ACK, //uint8_t flag - curConection->lastSent, //uint8_t seq - curConection->lastAck, //uint8_t ack - 0, //uint8_t HdrLen - 1, //uint8_t advertised_window - Empty, //uint8_t* payload - 0); //uint8_t length - makeIPpack(&sendIPpackage, &sendPackageTCP, curConection, PACKET_MAX_PAYLOAD_SIZE); //maybe reduce the PACKET_MAX_PAYLOAD_SIZE - //add to timer for retransmission - call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(myMsg->src)); + send(mySegment->Dest_Port, ACK, Empty, 0); return SUCCESS; } else if(mySegment->Flags == FIN){ curConection-> state = CLOSE_WAIT; - makeTCPpack(&sendPackageTCP, //tcp_pack *Package - curConection->src, - curConection->dest.port, //uint8_t des //not sure - ACK, //uint8_t flag - 1, //myTcpHeader->Seq_Num, //uint8_t seq - 1, //myTcpHeader->Seq_Num, //socketHolder->nextExpected///uint8_t ack - 0, //uint8_t HdrLen - 1, //uint8_t advertised_window - Empty, //uint8_t* payload - 0); //uint8_t length - makeIPpack(&sendIPpackage, &sendPackageTCP, curConection, PACKET_MAX_PAYLOAD_SIZE); - call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(curConection->dest.addr)); + send(mySegment->Dest_Port, ACK, Empty, 0); + //call timer first or after? call Transport.close(curConection->src); //timer? or command most likey command @@ -430,7 +341,6 @@ module TransportP{ case LAST_ACK: if(mySegment->Flags == URG){} if(mySegment->Flags == ACK){ - curConection->state=CLOSED; dbg(TRANSPORT_CHANNEL, "CLOSED FROM CASE LAST ACK AND STATE ACK \n"); @@ -438,29 +348,7 @@ module TransportP{ if(mySegment->Flags == PUSH){} if(mySegment->Flags == RESET){} if(mySegment->Flags == SYN){} - if(mySegment->Flags == FIN){ - - curConection-> state = LAST_ACK; - makeTCPpack(&sendPackageTCP, //tcp_pack *Package - curConection->src, - curConection->dest.port, //uint8_t des //not sure - ACK, //uint8_t flag - 1, //myTcpHeader->Seq_Num, //uint8_t seq - 1, //myTcpHeader->Seq_Num, //socketHolder->nextExpected///uint8_t ack - 0, //uint8_t HdrLen - 1, //uint8_t advertised_window - Empty, //uint8_t* payload - 0); //uint8_t length - makeIPpack(&sendIPpackage, &sendPackageTCP, curConection, PACKET_MAX_PAYLOAD_SIZE); - //call timer - //send packet - //edit sender - call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(curConection->dest.addr)); - curConection->state = TIME_WAIT; - //timer - curConection-> state = CLOSED; - dbg(TRANSPORT_CHANNEL, "TIME TURNED TO CLOSED \n"); - } + if(mySegment->Flags == FIN){} break; case TIME_WAIT: if(mySegment->Flags == URG){} @@ -477,7 +365,7 @@ module TransportP{ break; } return FAIL; - } + } /** * Read from the socket and write this data to the buffer. This data @@ -494,7 +382,8 @@ module TransportP{ * @return uint16_t - return the amount of data you are able to read * from the pass buffer. This may be shorter then bufflen */ - command uint16_t Transport.read(socket_t fd, uint8_t *buff, uint16_t bufflen){ + command uint16_t Transport.read(socket_t fd, uint8_t *buff, uint16_t bufflen) + { uint8_t buffSize; socket_store_t * socketHolder = call Connections.getPointer(fd); @@ -512,7 +401,8 @@ module TransportP{ } // mask a task for this - command error_t Transport.connect(socket_t fd, socket_addr_t * addr){ + command error_t Transport.connect(socket_t fd, socket_addr_t * addr) + { socket_store_t * socketHolder ; if (!(call Connections.contains(fd))) return FAIL; socketHolder = call Connections.getPointer(fd); @@ -520,7 +410,7 @@ module TransportP{ { case CLOSED: socketHolder->state = SYN_SENT; //Change the state of the socket - send(fd, SYN, Empty, 0){ + send(fd, SYN, Empty, 0); return SUCCESS; break; case LISTEN: @@ -571,21 +461,8 @@ module TransportP{ mySocket->state = FIN_WAIT_1; // mySocket->dest.port= myTcpHeader->Src_Port; //ask if necessary // mySocket->dest.addr= myPacket->src; //ask if necessary - makeTCPpack(&sendPackageTCP, //tcp_pack *Package - mySocket->src, - mySocket->dest.port, //uint8_t des //not sure - FIN, //uint8_t flag - 1, //uint8_t seq - 1, //socketHolder->nextExpected///uint8_t ack - 0, //uint8_t HdrLen - 1, //uint8_t advertised_window - Empty, //uint8_t* payload - 0); //uint8_t length - makeIPpack(&sendIPpackage, &sendPackageTCP, mySocket, PACKET_MAX_PAYLOAD_SIZE); - //call timer - //send packet - //edit sender - call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(mySocket->dest.addr)); + + send(fd, FIN, Empty, 0); return SUCCESS; break; //make timer that checks if the packets of the payload are done sending, wait APP, research to know when it's done, timer or a command @@ -596,21 +473,8 @@ module TransportP{ //Set timmer dbg(TRANSPORT_CHANNEL, "In close CLOSE_WAIT \n"); mySocket-> state = LAST_ACK; - makeTCPpack(&sendPackageTCP, //tcp_pack *Package - mySocket->src, - mySocket->dest.port, //uint8_t des - FIN, //uint8_t flag - 1, //myTcpHeader->Seq_Num, //uint8_t seq - 1, //myTcpHeader->Seq_Num, //socketHolder->nextExpected///uint8_t ack - 0, //uint8_t HdrLen - 1, //uint8_t advertised_window - Empty, //uint8_t* payload - 0); //uint8_t length - makeIPpack(&sendIPpackage, &sendPackageTCP, mySocket, PACKET_MAX_PAYLOAD_SIZE); - //call timer - //send packet - //edit sender - call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(mySocket->dest.addr)); + + send(fd, FIN, Empty, 0); return SUCCESS; break; default: @@ -631,7 +495,8 @@ module TransportP{ */ //command error_t Transport.release(socket_t fd); - command error_t Transport.listen(socket_t fd){ + command error_t Transport.listen(socket_t fd) + { socket_store_t * socketHolder ; if (!(call Connections.contains(fd))) return FAIL; socketHolder = call Connections.getPointer(fd); @@ -646,10 +511,13 @@ module TransportP{ } } - event void sendDataTimer.fired(){ + event void sendDataTimer.fired() + { sendData(); } - void sendDataDone(error_t err){ + + void sendDataDone(error_t err) + { if(err == SUCCESS){ socket_store_t * socketHolder; uint8_t TempSendBuff[SOCKET_BUFFER_SIZE]; @@ -695,61 +563,38 @@ module TransportP{ sendSize = buffSize; TCPflag = PUSH; } - //edit socket for correct data - if (socketHolder->lastSent == 0) {socketHolder->lastSent = 1;} - else{socketHolder->lastSent = 0;} + send(i, TCPflag, socketHolder->sendBuff, sendSize); - makeTCPpack(&sendPackageTCP, //tcp_pack *Package - socketHolder->src, //uint8_t src - socketHolder->dest.port, //?? //uint8_t des - TCPflag, //uint8_t flag - socketHolder->lastSent, //uint8_t seq - 0, /*socketHolder->nextExpected*///uint8_t ack - sendSize, //uint8_t HdrLen - 1, //uint8_t advertised_window - socketHolder->sendBuff, //uint8_t* payload - sendSize); //uint8_t length - makeIPpack(&sendIPpackage, &sendPackageTCP, socketHolder, PACKET_MAX_PAYLOAD_SIZE); //maybe reduce the PACKET_MAX_PAYLOAD_SIZE - - dbg(TRANSPORT_CHANNEL," Sending Message: %s\n",sendPackageTCP.payload); - - //send packet - call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(socketHolder->dest.addr)); - - //set timmer to posibly resend packet - dbg(TRANSPORT_CHANNEL," Sendt Message: %s\n",sendPackageTCP.payload); - //edit buffer if(buffSize > TCP_PACKET_MAX_PAYLOAD_SIZE){ memcpy(TempSendBuff, &((socketHolder->sendBuff)[sendSize]), buffSize - sendSize); dbg(TRANSPORT_CHANNEL," TempSendBuff: %s\n",TempSendBuff); } - else{ - for (i = 0; i < SOCKET_BUFFER_SIZE; i++){ //I don't know if I need to fill this - socketHolder->sendBuff[i] = 0; + for (i = 0; i < SOCKET_BUFFER_SIZE; i++){ //I don't know if I need to fill this + socketHolder->sendBuff[i] = 0; } } - - //TempSendBuff - //memcpy(socketHolder->sendBuff, (socketHolder->sendBuff)[sendSize], buffSize); - //memcpy(socketHolder->sendBuff, &((socketHolder->sendBuff)[sendSize, buffSize]), buffSize - sendSize); - } } } }//end of: void sendDataDone(error_t err) - task void sendDataTask(){ + + task void sendDataTask() + { sendDataDone(SUCCESS); } - error_t sendData(){ + + error_t sendData() + { post sendDataTask(); return SUCCESS; } - event void sendPacketTimer.fired(){ + event void sendPacketTimer.fired() + { sendPacket(); } void sendPacketDone(error_t err){ //assuming that this is for stop and wait. @@ -768,21 +613,23 @@ module TransportP{ } } }//end of: void sendPacketDone(error_t err) - task void sendPackeTask(){ + + task void sendPackeTask() + { sendPacketDone(SUCCESS); } - error_t sendPacket(){ + error_t sendPacket() + { post sendDataTask(); return SUCCESS; } - - - void send(socket_t socKey, uint8_t flag, uint8_t* payload, uint8_t length){ + error_t sendDone(socket_t socKey, uint8_t flag, uint8_t* payload, uint8_t length) + { tcpHeader sendPackageTCP; pack sendIPpackage; - socket_store_t * socketHolder = call Connections.get(socKey); + socket_store_t * socketHolder = call Connections.getPointer(socKey); //Should be replaced when we do sliding window /////////////////////////// if (socketHolder->lastSent == 0) {socketHolder->lastSent = 1;} // @@ -790,23 +637,68 @@ module TransportP{ //\\ //\\ //\\ //\\ //\\ //\\ //\\ //\\ makeTCPpack(&sendPackageTCP, //tcp_pack *Package - curSocket->src, //uint8_t src - curSocket->dest.port, //uint8_t des + socketHolder->src, //uint8_t src + socketHolder->dest.port, //uint8_t des flag, //uint8_t flag socketHolder->lastSent, //uint8_t seq socketHolder->nextExpected,//uint8_t ack //update this later //nextExpected should be based on the last recived - length, //uint8_t HdrLen socketHolder->effectiveWindow,//uint8_t advertised_window <- should use this equastion (lastSent - lastAck) payload, //uint8_t* payload length); //uint8_t length makeIPpack(&sendIPpackage, &sendPackageTCP, socketHolder, PACKET_MAX_PAYLOAD_SIZE); //maybe reduce the PACKET_MAX_PAYLOAD_SIZE - ipSeq = ipSeq++; + ipSeq = ipSeq + 1; call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(socketHolder->dest.addr)); + + //save a copy of the packet to be re-sent by a timmer and set RTT & TTD lastTimeSent + socketHolder->RTT = (socketHolder->lastTimeRecived - socketHolder->lastTimeSent) + call LocalTime.get() + 300; + socketHolder->TTD = (socketHolder->RTT) * 3; + return SUCCESS; } + + task void sendTask(){ + // If we have a values in our queue and the radio is not busy, then + // attempt to send a packet. + if(!call SendQueue.empty()){ + sendTCPInfo *info; + // We are peeking since, there is a possibility that the value will not + // be successfuly sent and we would like to continue to attempt to send + // it until we are successful. There is no limit on how many attempts + // can be made. + info = call SendQueue.head(); + + // Attempt to send it. + if(SUCCESS == send(info->socKey,info->flag,&(info->payload), info->length)){ + //Release resources used if the attempt was successful + call SendQueue.dequeue(); + call SendPool.put(info); + } + } + } + + + void send(socket_t socKey, uint8_t flag, uint8_t* payload, uint8_t length){ + if(!call SendPool.empty()){ + sendTCPInfo *input; + + input = call SendPool.get(); + input->socKey = socKey; + input->flag = flag; + memcpy(&(input->payload), payload, PACKET_MAX_PAYLOAD_SIZE); + input->length = length; + + // Now that we have a value from the pool we can put it into our queue. + // This is a FIFO queue. + call SendQueue.enqueue(input); + + // Start a send task which will be delayed. + post sendTask(); + } + } + void makeTCPpack(tcpHeader *Package, uint8_t src, uint8_t dest, uint8_t flag, uint8_t seq, uint8_t ack, uint8_t ad_win, uint8_t* payload, uint8_t length){ Package->Src_Port = src; @@ -817,7 +709,7 @@ module TransportP{ Package->Len = length; Package->Advertised_Window = ad_win; memcpy(Package->payload, payload, length); - } + } void makeIPpack(pack *Package, tcpHeader *myTCPpack, socket_store_t *sock, uint8_t length){ Package->src = (uint16_t)TOS_NODE_ID; From a73776dda8d717f03b568922e65a249de0781099 Mon Sep 17 00:00:00 2001 From: Nathan Blais Date: Sat, 11 Apr 2020 21:51:04 -0700 Subject: [PATCH 12/28] Tranplanted TransportP into a new file --- Node.nc | 2 +- TestSim.py | 4 +- includes/packet.h | 24 +- includes/socket.h | 16 +- lib/interfaces/Transport.nc | 7 +- lib/modules/TransportC.nc | 16 +- lib/modules/TransportP.nc | 1184 +++++++++++++++++------------------ lib/modules/TransportP.old | 825 ++++++++++++++++++++++++ 8 files changed, 1427 insertions(+), 651 deletions(-) create mode 100644 lib/modules/TransportP.old diff --git a/Node.nc b/Node.nc index 6e557c6..2bfea28 100644 --- a/Node.nc +++ b/Node.nc @@ -138,7 +138,7 @@ implementation{ dbg(GENERAL_CHANNEL, "Package Payload: %s\n", contents->payload); else if (PROTOCOL_TCP == contents->protocol) { - call Transport.receive(contents); + call Transport.receiveBuffer(contents); } else dbg(GENERAL_CHANNEL, "Recived packet with incorrect Protocol\n"); diff --git a/TestSim.py b/TestSim.py index 9a79690..9f63f05 100644 --- a/TestSim.py +++ b/TestSim.py @@ -205,8 +205,8 @@ def main(): # s.ping(1, 6, "I'll have you know I gr"); s.cmdTestClient(1,8,6,10, "Hello, bozo"); #[selfAdress] [srcPort] [dest] [destPort] [transfer] s.runTime(150); - s.cmdClientClose(1,8,6,10); #[client adress] [srcPort] [dest] [destPort] - s.runTime(200); + # s.cmdClientClose(1,8,6,10); #[client adress] [srcPort] [dest] [destPort] + # s.runTime(200); #####***NEIGHBOR DISCOVERY TEST***##### # s.runTime(50); diff --git a/includes/packet.h b/includes/packet.h index d4d6895..279b7bc 100644 --- a/includes/packet.h +++ b/includes/packet.h @@ -41,7 +41,8 @@ typedef struct tcpHeader{ uint8_t Seq_Num; //Sequence Number - which byte chunk is being sent uint8_t Acknowledgment; //ACK - next byte expected (seq + 1) uint8_t Len; //Data Offset - unsigned int Flags: 3; + //unsigned int Flags: 3; + unsigned int Flags: 6; uint8_t Advertised_Window; // buffer size //uint8_t Checksum; //optional //uint8_t UrgPtr; //optional @@ -49,13 +50,22 @@ typedef struct tcpHeader{ }tcpHeader; + //Flags for TCP -#define URG 0 //signifies that this segment contains urgent data. -#define ACK 1 //is set any time the Acknowledgment field is valid, implying that the receiver should pay attention to it. -#define PUSH 2 //signifies that the sender invoked the push operation, which indicates to the receiving side of TCP that it should notify the receiving process of this fact. -#define RESET 3 //signifies that the receiver has become confused—for example, because it received a segment it did not expect to receive—and so wants to abort the connection. -#define SYN 4 //-never carries payload data -#define FIN 5 //-never carries payload data +#define URG 0x1 //signifies that this segment contains urgent data. +#define ACK 0x2 //is set any time the Acknowledgment field is valid, implying that the receiver should pay attention to it. +#define PUSH 0x4 //signifies that the sender invoked the push operation, which indicates to the receiving side of TCP that it should notify the receiving process of this fact. +#define RESET 0x8 //signifies that the receiver has become confused—for example, because it received a segment it did not expect to receive—and so wants to abort the connection. +#define SYN 0x10 //16-never carries payload data +#define FIN 0x20 //32-never carries payload data + +// //Flags for TCP +// #define URG 0 //signifies that this segment contains urgent data. +// #define ACK 1 //is set any time the Acknowledgment field is valid, implying that the receiver should pay attention to it. +// #define PUSH 2 //signifies that the sender invoked the push operation, which indicates to the receiving side of TCP that it should notify the receiving process of this fact. +// #define RESET 3 //signifies that the receiver has become confused—for example, because it received a segment it did not expect to receive—and so wants to abort the connection. +// #define SYN 4 //-never carries payload data +// #define FIN 5 //-never carries payload data /* * logPack diff --git a/includes/socket.h b/includes/socket.h index d9370ae..46839ca 100644 --- a/includes/socket.h +++ b/includes/socket.h @@ -18,7 +18,8 @@ enum socket_state{ LAST_ACK = 6, FIN_WAIT_1 = 7, FIN_WAIT_2 = 8, - TIME_WAIT = 9 + TIME_WAIT = 9, + CLOSING = 10 }; typedef nx_uint8_t nx_socket_port_t; @@ -62,10 +63,11 @@ typedef struct socket_store_t{ //(TCB) - Transmission Control Block // This is the sender portion. uint8_t sendBuff[SOCKET_BUFFER_SIZE]; - uint8_t lastWritten; // sequence numbers allowed for new data transmission - uint8_t lastSent; // SND.UNA - last sent data that is not acknowledged yet - uint8_t lastAck; // old sequence numbers which have been acknowledged + uint8_t lastWritten; //sequence numbers allowed for new data transmission <- handled by the writer + uint8_t lastSent; //SND.UNA //last sent data that is not acknowledged yet <- handled by the Sender + uint8_t lastAck; // old sequence numbers which have been acknowledged <- handled by the reciver + uint8_t nextSend; //SND.NXT //sequence numbers allowed for new data transmission /* Receive Sequence Space @@ -80,9 +82,9 @@ typedef struct socket_store_t{ //(TCB) - Transmission Control Block */ // This is the receiver portion uint8_t rcvdBuff[SOCKET_BUFFER_SIZE]; - uint8_t lastRead; //last packet put into the buffer 1 - uint8_t nextExpected; //next packet expected 2 - uint8_t lastRcvd; //largest packet recived + uint8_t lastRead; // ?? sequence numbers which have been acknowledged + uint8_t nextExpected; //RCV.NXT //next packet expected<- handled by the reciver / window / sender? + uint8_t lastRcvd; //ISS uint8_t effectiveWindow; diff --git a/lib/interfaces/Transport.nc b/lib/interfaces/Transport.nc index ce1ed91..ddf2c27 100644 --- a/lib/interfaces/Transport.nc +++ b/lib/interfaces/Transport.nc @@ -79,7 +79,7 @@ interface Transport{ * @return uint16_t - return SUCCESS if you are able to handle this * packet or FAIL if there are errors. */ - command error_t receive(pack* package); + command error_t receiveBuffer(pack* package); /** * Read from the socket and write this data to the buffer. This data @@ -96,7 +96,8 @@ interface Transport{ * @return uint16_t - return the amount of data you are able to read * from the pass buffer. This may be shorter then bufflen */ - command uint16_t read(socket_t fd, uint8_t *buff, uint16_t bufflen); + + command uint16_t read(socket_t fd, tcpHeader *tcpSegment, uint16_t bufflen); /** * Attempts a connection to an address. @@ -112,6 +113,8 @@ interface Transport{ */ command error_t connect(socket_t fd, socket_addr_t * addr); + //event void connectDone(error_t e); <- might be a good idea + /** * Closes the socket. * @param diff --git a/lib/modules/TransportC.nc b/lib/modules/TransportC.nc index f0efe32..8d124b7 100644 --- a/lib/modules/TransportC.nc +++ b/lib/modules/TransportC.nc @@ -28,11 +28,11 @@ implementation { components new TimerMilliC(), LocalTimeMilliC; TransportP.LocalTime -> LocalTimeMilliC; - components new TimerMilliC() as sendPacketTimer; - TransportP.sendPacketTimer -> sendPacketTimer; + // components new TimerMilliC() as sendPacketTimer; + // TransportP.sendPacketTimer -> sendPacketTimer; - components new TimerMilliC() as sendDataTimer; - TransportP.sendDataTimer -> sendDataTimer; + // components new TimerMilliC() as sendDataTimer; + // TransportP.sendDataTimer -> sendDataTimer; //NOTE: wire timmers @@ -43,11 +43,11 @@ implementation { TransportP.Pool -> PoolC; TransportP.Queue -> QueueC; - components new PoolC(sendTCPInfo, 10) as SPool; - components new QueueC(sendTCPInfo*, 10) as SQueue; + //components new PoolC(pack, 10) as SendPool; + //components new QueueC(sendTCPInfo*, 10) as SendQueue; - TransportP.SendPool -> SPool; - TransportP.SendQueue -> SQueue; + //TransportP.SendPool -> SendPool; + //TransportP.SendQueue -> SendQueue; } \ No newline at end of file diff --git a/lib/modules/TransportP.nc b/lib/modules/TransportP.nc index 90d99d0..9c0f8ea 100644 --- a/lib/modules/TransportP.nc +++ b/lib/modules/TransportP.nc @@ -16,8 +16,8 @@ module TransportP{ //Uses the SimpleSend interface to transport data recieved packet uses interface SimpleSend as Sender; //Uses the Receive interface to receive packets -// uses interface Receive as Receiver; -// uses interface AMPacket; + //Uses interface Receive as Receiver; + //Uses interface AMPacket; //Uses the (DVR) interface to know where to forward packets. uses interface DistanceVectorRouting; @@ -25,17 +25,40 @@ module TransportP{ uses interface Hashmap as Connections; // hash table: list of connections uses interface LocalTime; - uses interface Timer as sendPacketTimer; - uses interface Timer as sendDataTimer; +// uses interface Timer as sendPacketTimer; +// uses interface Timer as sendDataTimer; uses interface Queue; uses interface Pool; - uses interface SendQueue; - uses interface SendPool; + //uses interface SendQueue as SendQueue; + //uses interface SendPool as SendPool; } - implementation{ + + /* --------- Questions Area --------- *\ +✱This is where we put our general questions + ➤•⦿◆ →←↑↓↔︎↕︎↘︎⤵︎⤷⤴︎↳↖︎⤶↲↱⤻ + + ➤ We should set up a generic packet send buffer + • + + ➤ + • + • + + ➤ + + ➤ + + +\* --------- Questions Area --------- */ + + //need a send_to_buffer + //need a send_out + + + implementation{ // Globals @@ -45,679 +68,592 @@ module TransportP{ // Prototypes - error_t sendData(); - void sendDataDone(error_t err); - - error_t sendPacket(); - void sendPacketDone(error_t err); - - void makeTCPpack(tcpHeader *Package, uint8_t src, uint8_t dest, uint8_t flag, uint8_t seq, uint8_t ack, uint8_t ad_win, uint8_t* payload, uint8_t length); - void makeIPpack(pack *Package, tcpHeader *myTCPpack, socket_store_t *sock, uint8_t length); error_t receive(pack* package); - void send(socket_t socKey, uint8_t flag, uint8_t* payload, uint8_t length); - error_t sendDone(socket_t socKey, uint8_t flag, uint8_t* payload, uint8_t length); - + void makeIPpack(pack *Package, tcpHeader *myTCPpack, socket_store_t *sock, uint8_t length); + + + error_t send_out(socket_t socKey, uint8_t flag, uint8_t seq, uint8_t ack, uint8_t* payload, uint8_t length){ + tcpHeader sendPackageTCP; + pack sendIPpackage; + socket_store_t * socketHolder = call Connections.getPointer(socKey); + + dbg(TRANSPORT_CHANNEL,"error_t send Called\n"); + + switch (socketHolder->state) + { + case CLOSED: + dbg(TRANSPORT_CHANNEL,"error: connection does not exist\n"); + return FAIL; + break; + default: + //dbg(TRANSPORT_CHANNEL, "WRONG_STATE_ERROR: \"%d\" is an incompatable state or does not match any known states.\n", socketHolder->state); + //return FAIL; + break; + } + /*Make the TCP Packet*/ + sendPackageTCP.Src_Port = socketHolder->src; + sendPackageTCP.Dest_Port = socketHolder->dest.port; + sendPackageTCP.Flags = flag; + sendPackageTCP.Seq_Num = seq; + sendPackageTCP.Acknowledgment = ack; + sendPackageTCP.Len = length; + sendPackageTCP.Advertised_Window = socketHolder->effectiveWindow; + memcpy(sendPackageTCP.payload, payload, length); + /*END OF: Make the TCP Packet*/ + makeIPpack(&sendIPpackage, &sendPackageTCP, socketHolder, PACKET_MAX_PAYLOAD_SIZE); //maybe reduce the PACKET_MAX_PAYLOAD_SIZE + ipSeq = ipSeq + 1; + + call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(socketHolder->dest.addr)); + + //update socket ------------------------------------------- + socketHolder->lastSent = sendPackageTCP.Seq_Num; + + // if (socketHolder->lastSent == 0) {socketHolder->nextExpected = 0;} + // else{socketHolder->nextExpected = 1;} + + //save a copy of the packet to be re-sent by a timmer and set RTT & TTD lastTimeSent + socketHolder->RTT = (socketHolder->lastTimeRecived - socketHolder->lastTimeSent) + call LocalTime.get() + 300; + socketHolder->TTD = (socketHolder->RTT) * 3; + return SUCCESS; - command socket_t Transport.socket(socket_t fd){ - dbg(TRANSPORT_CHANNEL,"Transport.socket() Called\n"); - if(call Connections.contains(0)) { //if there is room - if(!(call Connections.contains(fd))) - return fd; - else{ - dbg(TRANSPORT_CHANNEL,"Failed: port %d is not available\n", fd); - return NULLSocket; - } - } - dbg(TRANSPORT_CHANNEL,"Failed: No sockets are available\n"); - return NULLSocket; - } - - command error_t Transport.bind(socket_t fd, socket_addr_t *addr){ - socket_store_t TCB; //Transmission Control Block - //Checkers - if(fd == 0 || fd > MAX_NUM_OF_SOCKETS){ - dbg(TRANSPORT_CHANNEL,"Socket:%d is not valid. Try number: 1-10\n", fd); - return FAIL; - } - if(addr->addr == 0 || addr->addr > MAX_ROUTES){ - dbg(TRANSPORT_CHANNEL,"adress :%d is not valid. Try number: 1-10\n", addr->addr); - return FAIL; - } - if(call Connections.contains(fd)){ //Checks if the Socket is already in use - dbg(TRANSPORT_CHANNEL,"Socket:%d is already bound\n", fd); - return FAIL; } - dbg(TRANSPORT_CHANNEL,"Transport.bind() Called\n"); - TCB.src = fd; - TCB.dest = *addr; - TCB.state = CLOSED; - // This is the sender portion. - TCB.lastWritten = 0; - TCB.lastAck = 1; - TCB.lastSent = 1; - // This is the receiver portion - TCB.lastRead = 0; - TCB.lastRcvd = 0; - TCB.nextExpected = 0; - - TCB.RTT = 60000; //NOTE:We Need to replace this value - TCB.effectiveWindow = 1; //NOTE:We Need to replace this value - - TCB.lastTimeRecived = 60000; - TCB.lastTimeSent = 0; - - - call Connections.insert(fd, TCB); - if(call Connections.contains(fd)){ - dbg(TRANSPORT_CHANNEL,"Socket:%d bound to Node:%d Port:%d\n", fd, addr->addr, addr->port); - return SUCCESS; - } - else { - dbg(TRANSPORT_CHANNEL,"Socket:%d bound to Node:%d Port:%d has FAILED\n", fd, addr->addr, addr->port); - return FAIL; - } - } - - command socket_t Transport.accept(socket_t fd, pack* myPacket){ - socket_store_t * socketHolder; - tcpHeader * myTcpHeader = (tcpHeader*) myPacket->payload; - if (!(call Connections.contains(fd))) return FAIL; - - socketHolder = call Connections.getPointer(fd); - switch (socketHolder->state) { - case LISTEN: - default: - //Update Socket - socketHolder->state = SYN_RCVD; - socketHolder->dest.port= myTcpHeader->Src_Port; - socketHolder->dest.addr= myPacket->src; - - socketHolder->RTT = call LocalTime.get() + 1000000; - socketHolder->lastTimeSent = call LocalTime.get(); - - send(fd, SYN, Empty, 0); - break; - } - return fd; - } - - command uint16_t Transport.write(socket_t fd, uint8_t *buff, uint16_t bufflen){ - socket_store_t * curSocket = call Connections.getPointer(fd); - uint8_t written; - - dbg(TRANSPORT_CHANNEL,"Transport.write() Called\n"); - if (buff == NULL || bufflen < 1) return 0; - if (!(call Connections.contains(fd))) return 0; - - //NOTE: this will not work if you try to write too much information back to back - //for that we need to get the amount of info already on the buffer and make that the - // max amount you can write instead. - if (bufflen > SOCKET_BUFFER_SIZE){ - written = SOCKET_BUFFER_SIZE - bufflen; + error_t send_buff(socket_t socKey, uint8_t flag, uint8_t seq, uint8_t ack, uint8_t* payload, uint8_t length){ + send_out(socKey, flag, seq, ack, payload, length); + return SUCCESS; } - else{ - written = bufflen; + + // error_t send_data(/*Some Junk*/){ + // socket_store_t * socketHolder ; + // if (!(call Connections.contains(fd))) return FAIL; + // socketHolder = call Connections.getPointer(fd); + + // switch (socketHolder->state) + // { + // case CLOSED: + // dbg(TRANSPORT_CHANNEL,"error: connection does not exist\n"); + // return FAIL; + // break; + // case LISTEN: + // case SYN_SENT: + // case SYN_RCVD: + + + // /*re-Queue the data for transmission + // If no space to queue, respond with "error: insufficient + // resources".*/ + // case ESTABLISHED: + // case CLOSE_WAIT: + + // //send data + + // /*Segmentize the buffer and send it with a piggybacked + // acknowledgment (acknowledgment value = RCV.NXT). If there is + // insufficient space to remember this buffer, simply return + // "error: insufficient resources". + + // If the urgent flag is set, then SND.UP <- SND.NXT and set the + // urgent pointer in the outgoing segments.*/ + + // case LAST_ACK: + // case FIN_WAIT_1: + // case FIN_WAIT_2: + // case TIME_WAIT: + // case CLOSING: + // dbg(TRANSPORT_CHANNEL, "error: connection closing\n"); + + + // Return "error: connection closing" and do not service request. + + // default: + // dbg(TRANSPORT_CHANNEL, "WRONG_STATE_ERROR: \"%d\" is an incompatable state or does not match any known states.\n", socketHolder->state); + // return FAIL; + // break; + // } + // } + + command socket_t Transport.socket(socket_t fd){ + dbg(TRANSPORT_CHANNEL,"Transport.socket() Called\n"); + if(call Connections.contains(0)) { //if there is room + if(!(call Connections.contains(fd))) + return fd; + else{ + dbg(TRANSPORT_CHANNEL,"Failed: port %d is not available\n", fd); + return NULLSocket; + } + } + dbg(TRANSPORT_CHANNEL,"Failed: No sockets are available\n"); + return NULLSocket; } - memcpy((curSocket->sendBuff), buff, written); - dbg(TRANSPORT_CHANNEL, "Message to send is %s\n", curSocket->sendBuff); - call sendDataTimer.startPeriodic(81000); //could be set to a diffrent number - return written; - } + command error_t Transport.bind(socket_t fd, socket_addr_t *addr){ + socket_store_t TCB;//Transmission Control Block - task void receiveBufferTask(){ - // If we have a values in our queue and the radio is not busy, then - // attempt to send a packet. - if(!call Queue.empty()){ - pack *info; - // We are peeking since, there is a possibility that the value will not - // be successfuly sent and we would like to continue to attempt to send - // it until we are successful. There is no limit on how many attempts - // can be made. - info = call Queue.head(); - - // Attempt to send it. - if(SUCCESS == receive(info)){ - //Release resources used if the attempt was successful - call Queue.dequeue(); - call Pool.put(info); - } + //Check if values are valid + if(fd == 0 || fd > MAX_NUM_OF_SOCKETS){ + dbg(TRANSPORT_CHANNEL,"Socket:%d is not valid. Try number: 1-10\n", fd); + return FAIL; + } + if(addr->addr == 0 || addr->addr > MAX_ROUTES){ + dbg(TRANSPORT_CHANNEL,"adress :%d is not valid. Try number: 1-10\n", addr->addr); + return FAIL; + } + if(call Connections.contains(fd)){ //Checks if the Socket is already in use + dbg(TRANSPORT_CHANNEL,"Socket:%d is already bound\n", fd); + return FAIL; } - } - command error_t Transport.receive(pack* package){ - if(!call Pool.empty()){ - pack *input; - input = call Pool.get(); - memcpy(input, package, PACKET_MAX_PAYLOAD_SIZE); + //Make Socket and Update Values + dbg(TRANSPORT_CHANNEL,"Transport.bind() Called\n"); + TCB.src = fd; + TCB.dest = *addr; + TCB.state = CLOSED; + TCB.effectiveWindow = 1; //NOTE:We Need to replace this value + //Add call to set up Sliding Window - // Now that we have a value from the pool we can put it into our queue. - // This is a FIFO queue. - call Queue.enqueue(input); + call Connections.insert(fd, TCB);//insert socket into Hash - // Start a send task which will be delayed. - post receiveBufferTask(); + if(call Connections.contains(fd)){ + dbg(TRANSPORT_CHANNEL,"Socket:%d bound to Node:%d Port:%d\n", fd, addr->addr, addr->port); + return SUCCESS; + } + else { + dbg(TRANSPORT_CHANNEL,"Socket:%d bound to Node:%d Port:%d has FAILED\n", fd, addr->addr, addr->port); + return FAIL; + } + } + + command socket_t Transport.accept(socket_t fd, pack* myPacket){ + socket_store_t * socketHolder; + tcpHeader * myTcpHeader = (tcpHeader*) myPacket->payload; + + if (!(call Connections.contains(fd))) return 0; //Checks if the socket exists - return SUCCESS; + socketHolder = call Connections.getPointer(fd); + switch (socketHolder->state) { + case LISTEN: + socketHolder->dest.port= myTcpHeader->Src_Port; + socketHolder->dest.addr= myPacket->src; + break; + default: + break; + } + return fd; } - return FAIL; - } - error_t receive(pack* package) - { - pack* myMsg=(pack*) package; - tcpHeader* mySegment = (tcpHeader*) myMsg->payload; - socket_store_t * curConection = call Connections.getPointer(mySegment->Dest_Port); + command uint16_t Transport.write(socket_t fd, uint8_t *buff, uint16_t bufflen){ + socket_store_t * socketHolder ; + uint8_t written; + if (!(call Connections.contains(fd))) return FAIL; + socketHolder = call Connections.getPointer(fd); + + dbg(TRANSPORT_CHANNEL,"Transport.write() Called\n"); + if (buff == NULL || bufflen < 1) return 0; + if (!(call Connections.contains(fd))) return 0; + + switch (socketHolder->state) + { + case CLOSED: + dbg(TRANSPORT_CHANNEL,"error: connection does not exist\n"); + break; + case LISTEN: + case SYN_SENT: + case SYN_RCVD: + case ESTABLISHED: + case CLOSE_WAIT: + //get size of buffer + for(written=0; socketHolder->sendBuff[written] != '\0'; written++){} + + if (bufflen > written){ + // will write the max ammount + } + else{ + written = bufflen; + } + memcpy((socketHolder->sendBuff), buff, written); + dbg(TRANSPORT_CHANNEL, "Message to send is %s\n", socketHolder->sendBuff); + + //call sendDataTimer.startPeriodic(81000); //could be set to a diffrent number + return written; + + case LAST_ACK: + case FIN_WAIT_1: + case FIN_WAIT_2: + case TIME_WAIT: + case CLOSING: + dbg(TRANSPORT_CHANNEL,"error: connection closing\n"); + break; + default: + dbg(TRANSPORT_CHANNEL, "WRONG_STATE_ERROR: \"%d\" is an incompatable state or does not match any known states.\n", socketHolder->state); + break; + } + return 0; + } - dbg(TRANSPORT_CHANNEL, "Transport.receive() Called\n"); + error_t receive(pack* package) + { + pack* myMsg=(pack*) package; + uint8_t seq; + tcpHeader* mySegment = (tcpHeader*) myMsg->payload; + socket_store_t * curConection = call Connections.getPointer(mySegment->Dest_Port); - //TO_DO: add check here to see if the packet has been seen before + dbg(TRANSPORT_CHANNEL, "Transport.receive() Called\n"); + dbg(TRANSPORT_CHANNEL, "STATE: %d | FLAG: %d\n", curConection->state, mySegment->Flags); - if(curConection->LastRecivedIPpack.src == myMsg->src && - curConection->LastRecivedIPpack.seq == myMsg->seq) { - dbg(TRANSPORT_CHANNEL, "Recived Duplicate packet\n"); - return FAIL; - } - - if(curConection->nextExpected != mySegment->Seq_Num){ - dbg(TRANSPORT_CHANNEL, "Recived packet with unexpected SEQ #\n"); - return FAIL; - } + // printTCP(mySegment); + // printSocket(mySegment->Dest_Port); - //put some checks here + dbg(TRANSPORT_CHANNEL, "INCOMING SEQ #: %d\n",mySegment->Seq_Num ); - //We should update lastRcvd here; - curConection->lastRcvd = mySegment->Seq_Num; - curConection->lastAck = mySegment->Acknowledgment; + // //TO_DO: add check here to see if the packet has been seen before - if (curConection->nextExpected == 0) {curConection->nextExpected = 1;} //<-- update for sliding window - else{curConection->nextExpected = 0;} + curConection->lastRcvd = mySegment->Seq_Num; + curConection->LastRecivedIPpack = *myMsg; - //update LastRecivedIPpack + // curConection->lastTimeRecived = call LocalTime.get(); - curConection->LastRecivedIPpack = *myMsg; + //make sure only the sender is updating their curConection->effectiveWindow - curConection->lastTimeRecived = call LocalTime.get(); + switch (curConection->state) { + case CLOSED: + dbg(TRANSPORT_CHANNEL, "State is Closed\n"); + //Acording to RFC - 793: + //An incoming segment not containing a RST causes a RST to be sent in response. + //^ we will ignore this + return SUCCESS; + break; + case LISTEN: + if(mySegment->Flags == RESET){/*ignore*/} + else if(mySegment->Flags == ACK){/* Can't have ACK send Pack:*/} + else if(mySegment->Flags == SYN){ + call Transport.accept(curConection->src, myMsg); - //make sure only the sender is updating their curConection->effectiveWindow + seq = mySegment->Seq_Num; + send_buff(curConection->src, SYN+ACK, seq, 0, Empty, 0); + curConection->nextExpected = 1; //Replace this + curConection->state = SYN_RCVD; + dbg(TRANSPORT_CHANNEL, "STATE: LISTEN -> SYN_RCVD\n"); + return SUCCESS; + } + else{ //Wrong info + return SUCCESS; + } + break; + case SYN_SENT: + //put some checks here + if(mySegment->Flags & ( SYN | ACK )) { + //dbg(TRANSPORT_CHANNEL, "curConection->lastSent %d < mySegment->Acknowledgment %d\n", curConection->lastSent, mySegment->Acknowledgment); + //any segments on the retransmission queue which are thereby acknowledged should be removed. + dbg(TRANSPORT_CHANNEL, "curConection->lastSent %d curConection->lastRcvd %d\n", curConection->lastSent, curConection->lastRcvd); + if(curConection->lastSent == curConection->lastRcvd){ + dbg(TRANSPORT_CHANNEL, "STATE: SYN_SENT -> ESTABLISHED\n"); + curConection->state = ESTABLISHED; - dbg(TRANSPORT_CHANNEL, "STATE: %d | FLAG: %d\n", curConection->state, mySegment->Flags); + if(curConection->lastSent == 0){seq = 1;} + else{seq = 0;} - switch (curConection->state) { - case CLOSED: //Don't know what do do with it yet - break; - case LISTEN: - if(mySegment->Flags == SYN){ - call Transport.accept(curConection->src, myMsg); - return SUCCESS; - } - else{ //Wrong info - return FAIL; - } - break; - case SYN_SENT: - //put some checks here - if(mySegment->Flags & ( SYN | ACK )) { - curConection->state = ESTABLISHED; - curConection->effectiveWindow = mySegment->Advertised_Window; - - send(mySegment->Dest_Port, ACK, Empty, 0); - //TO_DO:call to start sending packets from que. - return SUCCESS; - } - else return FAIL; - break; - case SYN_RCVD: - //put some checks here - if(mySegment->Flags & ( SYN | ACK )) { - curConection->state = ESTABLISHED; - - send(mySegment->Dest_Port, ACK, Empty, 0); - return SUCCESS; - } - else return FAIL; - break; + send_buff(curConection->src, ACK, seq, 0, Empty, 0); + curConection->nextExpected = seq; - case CLOSE_WAIT: - if(mySegment->Flags == ACK){ - curConection-> state = CLOSED; - return SUCCESS; - } - case FIN_WAIT_1: - if(mySegment->Flags == ACK){ - curConection ->state = FIN_WAIT_2; - return SUCCESS; - } - case FIN_WAIT_2: - if(mySegment->Flags == FIN){ - curConection-> state = TIME_WAIT; - send(mySegment->Dest_Port, ACK, Empty, 0); - //set a timer that eventually closes the socket - return SUCCESS; - } - case ESTABLISHED: - if(mySegment->Flags == ACK){ - if(mySegment->Len == 0){ //this is a normal ack pack - //update socket - //stop resend for data - } - else{ // has data //Only need to ipmlement this if you send more than one packet of data - //update socket - call Transport.read(curConection->src, mySegment->payload, mySegment->Len); - - //make ack packet - //store pack for resend - //send back an ack packet - } - } - else if(mySegment->Flags == PUSH){ - dbg(TRANSPORT_CHANNEL, "Message Recived:%s\n",mySegment->payload); + return SUCCESS; + } - call Transport.read(curConection->src, mySegment->payload, mySegment->Len); - //print out entire buffer - dbg(TRANSPORT_CHANNEL, "\tFinished reciving Message\n"); - dbg(TRANSPORT_CHANNEL, "\t\tMessage:%s\n",curConection->rcvdBuff); + //TO_DO:call event to start sending packets from que. + } + else return SUCCESS; + break; - send(mySegment->Dest_Port, ACK, Empty, 0); - return SUCCESS; + ///new bits } - else if(mySegment->Flags == FIN){ - curConection-> state = CLOSE_WAIT; - send(mySegment->Dest_Port, ACK, Empty, 0); - //call timer first or after? - call Transport.close(curConection->src); - //timer? or command most likey command + //check sequence number HERE + if(curConection->nextExpected != mySegment->Seq_Num){ + dbg(TRANSPORT_CHANNEL, "curConection->nextExpected %d curConection->lastRcvd %d\n", curConection->nextExpected, curConection->lastRcvd); + dbg(TRANSPORT_CHANNEL, "Recived packet with unexpected SEQ #\n"); + return SUCCESS; } - else if(mySegment->Flags == RESET){} - else if(mySegment->Flags == URG){} - else return FAIL; - break; - case LAST_ACK: - if(mySegment->Flags == URG){} - if(mySegment->Flags == ACK){ - curConection->state=CLOSED; - dbg(TRANSPORT_CHANNEL, "CLOSED FROM CASE LAST ACK AND STATE ACK \n"); + switch (curConection->state) { + + case SYN_RCVD: + //put some checks here + if(mySegment->Flags & ( SYN | ACK )) { + curConection->state = ESTABLISHED; + dbg(TRANSPORT_CHANNEL, "STATE: SYN_RCVD -> ESTABLISHED\n"); + + seq = mySegment->Seq_Num; + send_buff(curConection->src, ACK, seq, 0, Empty, 0); //update this + curConection->nextExpected = 0; //Replace this + + return SUCCESS; + } + else return SUCCESS; + break; + case LAST_ACK: + if(mySegment->Flags == ACK && curConection->nextExpected == mySegment->Seq_Num){ + curConection->state=CLOSED; + dbg(TRANSPORT_CHANNEL, "STATE: LAST_ACK -> CLOSED\n"); + break; + } + case FIN_WAIT_1: + if(mySegment->Flags == ACK){ + curConection->state = FIN_WAIT_2; + dbg(TRANSPORT_CHANNEL, "STATE: FIN_WAIT_1 -> FIN_WAIT_2\n"); + return SUCCESS; + } + case FIN_WAIT_2: + if(mySegment->Flags == FIN){ + curConection-> state = TIME_WAIT; + dbg(TRANSPORT_CHANNEL, "STATE: FIN_WAIT_2 -> TIME_WAIT\n"); + + send_buff(curConection->src, ACK, curConection->nextSend, curConection->nextExpected, Empty, 0); //update this + + //set a timer that eventually closes the socket + return SUCCESS; + } + case CLOSE_WAIT: + case ESTABLISHED: //NOTE: everything below should be updated + if(mySegment->Flags == ACK){ + if(mySegment->Len == 0){ //this is a normal ack pack + //update socket + //stop resend for data + } + else{ // has data //Only need to ipmlement this if you send more than one packet of data + //update socket + call Transport.read(curConection->src, mySegment, mySegment->Len); + + //make ack packet + //store pack for resend + //send back an ack packet + } + } + else if(mySegment->Flags == PUSH){ + dbg(TRANSPORT_CHANNEL, "Message Recived:%s\n",mySegment->payload); + + call Transport.read(curConection->src, mySegment, mySegment->Len); + //print out entire buffer + dbg(TRANSPORT_CHANNEL, "\tFinished reciving Message\n"); + dbg(TRANSPORT_CHANNEL, "\t\tMessage:%s\n",curConection->rcvdBuff); + + send_buff(curConection->src, ACK, curConection->nextSend, curConection->nextExpected, Empty, 0); //update this + return SUCCESS; + } + else if(mySegment->Flags == FIN){ + curConection-> state = CLOSE_WAIT; + dbg(TRANSPORT_CHANNEL, "STATE: ESTABLISHED -> CLOSE_WAIT\n"); + + send_buff(curConection->src, ACK, curConection->nextSend, curConection->nextExpected, Empty, 0); //update this + + //call timer first or after? + call Transport.close(curConection->src); + //timer? or command most likey command + } + else if(mySegment->Flags == RESET){} + else if(mySegment->Flags == URG){} + else return FAIL; + break; + case TIME_WAIT: + if(mySegment->Flags == URG){} + if(mySegment->Flags == ACK){} + if(mySegment->Flags == PUSH){} + if(mySegment->Flags == RESET){} + if(mySegment->Flags == SYN){} + if(mySegment->Flags == FIN){} + break; + + default: + dbg(TRANSPORT_CHANNEL, "FLAG_ERROR: \"%d\" does not match any known commands.\n", mySegment->Flags); + return FAIL; + break; } - if(mySegment->Flags == PUSH){} - if(mySegment->Flags == RESET){} - if(mySegment->Flags == SYN){} - if(mySegment->Flags == FIN){} - break; - case TIME_WAIT: - if(mySegment->Flags == URG){} - if(mySegment->Flags == ACK){} - if(mySegment->Flags == PUSH){} - if(mySegment->Flags == RESET){} - if(mySegment->Flags == SYN){} - if(mySegment->Flags == FIN){} - break; - - default: - dbg(TRANSPORT_CHANNEL, "FLAG_ERROR: \"%d\" does not match any known commands.\n", mySegment->Flags); - return FAIL; - break; - } - return FAIL; - } - - /** - * Read from the socket and write this data to the buffer. This data - * is obtained from your TCP implimentation. - * @param - * socket_t fd: file descriptor that is associated with the socket - * that is attempting a read. - * @param - * uint8_t *buff: the buffer that is being written. - * @param - * uint16_t bufflen: the amount of data that can be written to the - * buffer. - * @Side For your project, only server side. This could be both though. - * @return uint16_t - return the amount of data you are able to read - * from the pass buffer. This may be shorter then bufflen - */ - command uint16_t Transport.read(socket_t fd, uint8_t *buff, uint16_t bufflen) - { - uint8_t buffSize; - socket_store_t * socketHolder = call Connections.getPointer(fd); - - dbg(TRANSPORT_CHANNEL, "Transport Called Read\n"); - for(buffSize=0; socketHolder->sendBuff[buffSize] != '\0'; buffSize++ ){} //calculates the size of the buffer - - strcat((socketHolder->rcvdBuff), buff); - - if (socketHolder->lastRead == 0) {socketHolder->lastRead = 1;} - else{socketHolder->lastRead = 0;} - if (socketHolder->nextExpected == 0) {socketHolder->nextExpected = 1;} - else{socketHolder->nextExpected = 0;} - - return 1; // for warning - } - - // mask a task for this - command error_t Transport.connect(socket_t fd, socket_addr_t * addr) - { - socket_store_t * socketHolder ; - if (!(call Connections.contains(fd))) return FAIL; - socketHolder = call Connections.getPointer(fd); - switch (socketHolder->state) - { - case CLOSED: - socketHolder->state = SYN_SENT; //Change the state of the socket - send(fd, SYN, Empty, 0); - return SUCCESS; - break; - case LISTEN: - dbg(TRANSPORT_CHANNEL,"Socket is already listening\n"); return FAIL; - break; - default: - dbg(TRANSPORT_CHANNEL, "WRONG_STATE_ERROR: \"%d\" is an incompatable state or does not match any known states.\n", socketHolder->state); - return FAIL; - break; - } - } - - /** - * Closes the socket. - * @param - * socket_t fd: file descriptor that is associated with the socket - * that you are closing. - * @side Client/Server - * @return socket_t - returns SUCCESS if you are able to attempt - * a closure with the fd passed, else return FAIL. - */ - command error_t Transport.close(socket_t fd) - { - socket_store_t * mySocket; - dbg(TRANSPORT_CHANNEL, "Called Transport.close()\n"); - - if (!(call Connections.contains(fd))) return FAIL; - - mySocket = call Connections.getPointer(fd); - - switch (mySocket->state){ - case CLOSED: - dbg(TRANSPORT_CHANNEL, "Already closed \n"); - return FAIL; - break; - case LISTEN: case SYN_SENT: - mySocket->state = CLOSED; - dbg(TRANSPORT_CHANNEL, "Socket State: (LISTEN | SYN_SENT) -> CLOSED\n"); - return SUCCESS; - break; - case ESTABLISHED: //Starts the close - //sudo Code: - //Set state - //Send packet - //Set timmer - - mySocket->state = FIN_WAIT_1; - // mySocket->dest.port= myTcpHeader->Src_Port; //ask if necessary - // mySocket->dest.addr= myPacket->src; //ask if necessary - - send(fd, FIN, Empty, 0); - return SUCCESS; - break; - //make timer that checks if the packets of the payload are done sending, wait APP, research to know when it's done, timer or a command - case CLOSE_WAIT: //changes wait to FIN WAIT 2 flag fin - //sudo Code: - //Set state - //Send packet - //Set timmer - dbg(TRANSPORT_CHANNEL, "In close CLOSE_WAIT \n"); - mySocket-> state = LAST_ACK; - - send(fd, FIN, Empty, 0); - return SUCCESS; - break; - default: - dbg(TRANSPORT_CHANNEL, "WRONG_STATE_ERROR: \"%d\" is an incompatable state or does not match any known states.\n", mySocket->state); - return FAIL; - break; - } - } - - /** - * A hard close, which is not graceful. This portion is optional. - * @param - * socket_t fd: file descriptor that is associated with the socket - * that you are hard closing. - * @side Client/Server - * @return socket_t - returns SUCCESS if you are able to attempt - * a closure with the fd passed, else return FAIL. - */ - //command error_t Transport.release(socket_t fd); - - command error_t Transport.listen(socket_t fd) - { - socket_store_t * socketHolder ; - if (!(call Connections.contains(fd))) return FAIL; - socketHolder = call Connections.getPointer(fd); - if(socketHolder->state == LISTEN){ - dbg(TRANSPORT_CHANNEL,"Socket is already listening\n"); - return FAIL; - } - else{ - dbg (TRANSPORT_CHANNEL, "Change Socket State from %d to Listen:%d\n",socketHolder->state, LISTEN); - socketHolder->state = LISTEN; - return SUCCESS; } - } - - event void sendDataTimer.fired() - { - sendData(); - } - - void sendDataDone(error_t err) - { - if(err == SUCCESS){ - socket_store_t * socketHolder; - uint8_t TempSendBuff[SOCKET_BUFFER_SIZE]; - uint8_t buffSize, sendSize, TCPflag, i; - uint8_t size = call Connections.size(); - uint32_t * keys = call Connections.getKeys(); - - for(i=0;isendBuff[0] != 0){ - i = 0; - break; + + task void receiveBufferTask(){ + // If we have a values in our queue and the radio is not busy, then + // attempt to send a packet. + if(!call Queue.empty()){ + pack *info; + // We are peeking since, there is a possibility that the value will not + // be successfuly sent and we would like to continue to attempt to send + // it until we are successful. There is no limit on how many attempts + // can be made. + info = call Queue.head(); + + // Attempt to send it. + if(SUCCESS == receive(info)){ + //Release resources used if the attempt was successful + call Queue.dequeue(); + call Pool.put(info); + } } - } + } - if(size == 0 || i == size ){ - dbg(TRANSPORT_CHANNEL,"Data Timer Stoped\n"); - call sendDataTimer.stop(); - return; - } + command error_t Transport.receiveBuffer(pack* package){ + if(!call Pool.empty()){ + pack *input; + input = call Pool.get(); + memcpy(input, package, PACKET_MAX_PAYLOAD_SIZE); - dbg(TRANSPORT_CHANNEL," ATTEMPTING TO SEND DATA\n"); - for(i=0;ilastSent: %d | socketHolder->lastAck %d\n",socketHolder->lastSent,socketHolder->lastAck ); - - dbg(TRANSPORT_CHANNEL,"socketHolder->sendBuff %s\n",socketHolder->sendBuff ); - - if((socketHolder->state & (ESTABLISHED | FIN_WAIT_2) )&& - socketHolder->lastSent == socketHolder->lastAck && - socketHolder->sendBuff != '\0') - { //if true send data - dbg(TRANSPORT_CHANNEL," Does it enter here?\n"); - for(buffSize=0; socketHolder->sendBuff[buffSize] != '\0'; buffSize++ ){} //calculates the size of the buffer - if(buffSize > TCP_PACKET_MAX_PAYLOAD_SIZE){//if size of buffer is > TCP_PACKET_MAX_PAYLOAD_SIZE - sendSize = TCP_PACKET_MAX_PAYLOAD_SIZE; - TCPflag = ACK; - } - else { //send normaly with PUSH flag <- let it know it is the end of the data send - sendSize = buffSize; - TCPflag = PUSH; - } - - send(i, TCPflag, socketHolder->sendBuff, sendSize); - - //edit buffer - if(buffSize > TCP_PACKET_MAX_PAYLOAD_SIZE){ - memcpy(TempSendBuff, &((socketHolder->sendBuff)[sendSize]), buffSize - sendSize); - dbg(TRANSPORT_CHANNEL," TempSendBuff: %s\n",TempSendBuff); - } - else{ - for (i = 0; i < SOCKET_BUFFER_SIZE; i++){ //I don't know if I need to fill this - socketHolder->sendBuff[i] = 0; - } - } - } - } - } - }//end of: void sendDataDone(error_t err) - - task void sendDataTask() - { - - sendDataDone(SUCCESS); - } - - error_t sendData() - { - post sendDataTask(); - return SUCCESS; - } - - event void sendPacketTimer.fired() - { - sendPacket(); - } - void sendPacketDone(error_t err){ //assuming that this is for stop and wait. - uint8_t i; - if(err == FAIL){ - return; - } - for(i = 0; i < MAX_NUM_OF_SOCKETS; i++) { - if((call Connections.getPointer(i))->TTD < (call LocalTime.get())){//if true either reset or close the connnection - //Fill in here - return; - } - if((call Connections.getPointer(i))->RTT < call LocalTime.get() && (call Connections.getPointer(i))->lastSent != (call Connections.getPointer(i))->lastAck) { //if TRUE retransmit - dbg(TRANSPORT_CHANNEL, "Retransmitting\n"); - call Sender.send((call Connections.getPointer(i))->LastSentIPpack, call DistanceVectorRouting.GetNextHop((call Connections.getPointer(i))->dest.addr)); - } - } - }//end of: void sendPacketDone(error_t err) - - task void sendPackeTask() - { - - sendPacketDone(SUCCESS); - } - error_t sendPacket() - { - post sendDataTask(); - return SUCCESS; - } - - error_t sendDone(socket_t socKey, uint8_t flag, uint8_t* payload, uint8_t length) - { - tcpHeader sendPackageTCP; - pack sendIPpackage; - socket_store_t * socketHolder = call Connections.getPointer(socKey); - - //Should be replaced when we do sliding window /////////////////////////// - if (socketHolder->lastSent == 0) {socketHolder->lastSent = 1;} // - else{socketHolder->lastSent = 0;} // - //\\ //\\ //\\ //\\ //\\ //\\ //\\ //\\ - - makeTCPpack(&sendPackageTCP, //tcp_pack *Package - socketHolder->src, //uint8_t src - socketHolder->dest.port, //uint8_t des - flag, //uint8_t flag - socketHolder->lastSent, //uint8_t seq - socketHolder->nextExpected,//uint8_t ack //update this later //nextExpected should be based on the last recived - socketHolder->effectiveWindow,//uint8_t advertised_window <- should use this equastion (lastSent - lastAck) - payload, //uint8_t* payload - length); //uint8_t length - makeIPpack(&sendIPpackage, &sendPackageTCP, socketHolder, PACKET_MAX_PAYLOAD_SIZE); //maybe reduce the PACKET_MAX_PAYLOAD_SIZE - ipSeq = ipSeq + 1; - - call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(socketHolder->dest.addr)); - - - - //save a copy of the packet to be re-sent by a timmer and set RTT & TTD lastTimeSent - socketHolder->RTT = (socketHolder->lastTimeRecived - socketHolder->lastTimeSent) + call LocalTime.get() + 300; - socketHolder->TTD = (socketHolder->RTT) * 3; - return SUCCESS; + // Start a send task which will be delayed. + post receiveBufferTask(); - } - - task void sendTask(){ - // If we have a values in our queue and the radio is not busy, then - // attempt to send a packet. - if(!call SendQueue.empty()){ - sendTCPInfo *info; - // We are peeking since, there is a possibility that the value will not - // be successfuly sent and we would like to continue to attempt to send - // it until we are successful. There is no limit on how many attempts - // can be made. - info = call SendQueue.head(); - - // Attempt to send it. - if(SUCCESS == send(info->socKey,info->flag,&(info->payload), info->length)){ - //Release resources used if the attempt was successful - call SendQueue.dequeue(); - call SendPool.put(info); - } + return SUCCESS; } - } + return FAIL; + } + + command uint16_t Transport.read(socket_t fd, tcpHeader *tcpSegment, uint16_t bufflen){ + uint8_t buffSize; + socket_store_t * socketHolder = call Connections.getPointer(fd); + uint8_t *buff = tcpSegment->payload; + dbg(TRANSPORT_CHANNEL, "Transport Called Read\n"); - void send(socket_t socKey, uint8_t flag, uint8_t* payload, uint8_t length){ - if(!call SendPool.empty()){ - sendTCPInfo *input; + for(buffSize=0; socketHolder->rcvdBuff[buffSize] != '\0'; buffSize++ ){} //calculates the size of the buffer + if (bufflen > buffSize){ + // will write the max ammount + } + else{ + buffSize = bufflen; + } - input = call SendPool.get(); - input->socKey = socKey; - input->flag = flag; - memcpy(&(input->payload), payload, PACKET_MAX_PAYLOAD_SIZE); - input->length = length; + strcat((socketHolder->rcvdBuff), buff); - // Now that we have a value from the pool we can put it into our queue. - // This is a FIFO queue. - call SendQueue.enqueue(input); + if (socketHolder->lastRead == 0) {socketHolder->lastRead = 1;} + else{socketHolder->lastRead = 0;} - // Start a send task which will be delayed. - post sendTask(); + return buffSize; + } + + command error_t Transport.connect(socket_t fd, socket_addr_t * addr){ + socket_store_t * socketHolder ; + uint8_t inSeq = 0; //choose inital sequence number + if (!(call Connections.contains(fd))) return FAIL; + socketHolder = call Connections.getPointer(fd); + switch (socketHolder->state) + { + case CLOSED: + socketHolder->state = SYN_SENT; //Change the state of the socket + dbg(TRANSPORT_CHANNEL, "STATE: CLOSED -> SYN_SENT\n"); + send_buff(fd, SYN, inSeq, 0, Empty, 0); //make and send a packet //send buffer + return SUCCESS; + break; + case LISTEN: + dbg(TRANSPORT_CHANNEL,"Socket is already listening\n"); + return FAIL; + break; + default: + dbg(TRANSPORT_CHANNEL, "WRONG_STATE_ERROR: \"%d\" is an incompatable state or does not match any known states.\n", socketHolder->state); + return FAIL; + break; } } + //event void connectDone(error_t e); <- might be a good idea - void makeTCPpack(tcpHeader *Package, uint8_t src, uint8_t dest, uint8_t flag, uint8_t seq, uint8_t ack, uint8_t ad_win, uint8_t* payload, uint8_t length){ - Package->Src_Port = src; - Package->Dest_Port = dest; - Package->Flags = flag; - Package->Seq_Num = seq; - Package->Acknowledgment = ack; - Package->Len = length; - Package->Advertised_Window = ad_win; - memcpy(Package->payload, payload, length); + command error_t Transport.close(socket_t fd) + { + socket_store_t * mySocket; + uint8_t seq; + dbg(TRANSPORT_CHANNEL, "Called Transport.close()\n"); + + if (!(call Connections.contains(fd))) return FAIL; + + mySocket = call Connections.getPointer(fd); + + switch (mySocket->state){ + case CLOSED: + dbg(TRANSPORT_CHANNEL, "Already closed \n"); + return FAIL; + break; + case LISTEN: case SYN_SENT: + mySocket->state = CLOSED; + dbg(TRANSPORT_CHANNEL, "Socket State: (LISTEN | SYN_SENT) -> CLOSED\n"); + return SUCCESS; + break; + case ESTABLISHED: //Starts the close + //sudo Code: + //Set state + //Send packet + //Set timmer + + mySocket->state = FIN_WAIT_1; + // mySocket->dest.port= myTcpHeader->Src_Port; //ask if necessary + // mySocket->dest.addr= myPacket->src; //ask if necessary + + + if(mySocket->lastSent == 0){seq = 1;} + else{seq = 0;} + + send_buff(fd, FIN, seq, 0, Empty, 0); //update this + + return SUCCESS; + break; + //make timer that checks if the packets of the payload are done sending, wait APP, research to know when it's done, timer or a command + case CLOSE_WAIT: //changes wait to FIN WAIT 2 flag fin + //sudo Code: + //Set state + //Send packet + //Set timmer + dbg(TRANSPORT_CHANNEL, "In close CLOSE_WAIT \n"); + mySocket-> state = LAST_ACK; + + + if(mySocket->lastSent == 0){seq = 1;} + else{seq = 0;} + + send_buff(fd, FIN, seq, 0, Empty, 0); //update this + return SUCCESS; + break; + default: + dbg(TRANSPORT_CHANNEL, "WRONG_STATE_ERROR: \"%d\" is an incompatable state or does not match any known states.\n", mySocket->state); + return FAIL; + break; + } } - void makeIPpack(pack *Package, tcpHeader *myTCPpack, socket_store_t *sock, uint8_t length){ - Package->src = (uint16_t)TOS_NODE_ID; - Package->dest = sock->dest.addr; - Package->TTL = MAX_TTL; - Package->seq = ipSeq; //finish this - Package->protocol = PROTOCOL_TCP; - memcpy(Package->payload, myTCPpack, length); - } + /** + * A hard close, which is not graceful. This portion is optional. + * @param + * socket_t fd: file descriptor that is associated with the socket + * that you are hard closing. + * @side Client/Server + * @return socket_t - returns SUCCESS if you are able to attempt + * a closure with the fd passed, else return FAIL. + */ + // command error_t release(socket_t fd); + + command error_t Transport.listen(socket_t fd) + { + socket_store_t * socketHolder ; + if (!(call Connections.contains(fd))) return FAIL; + socketHolder = call Connections.getPointer(fd); + if(socketHolder->state == LISTEN){ + dbg(TRANSPORT_CHANNEL,"Socket is already listening\n"); + return FAIL; + } + else{ + dbg (TRANSPORT_CHANNEL, "Change Socket State from %d to Listen:%d\n",socketHolder->state, LISTEN); + socketHolder->state = LISTEN; + return SUCCESS; + } + } + void makeIPpack(pack *Package, tcpHeader *myTCPpack, socket_store_t *sock, uint8_t length){ + Package->src = (uint16_t)TOS_NODE_ID; + Package->dest = sock->dest.addr; + Package->TTL = MAX_TTL; + Package->seq = ipSeq; //finish this + Package->protocol = PROTOCOL_TCP; + memcpy(Package->payload, myTCPpack, length); + } -} \ No newline at end of file +} diff --git a/lib/modules/TransportP.old b/lib/modules/TransportP.old new file mode 100644 index 0000000..dae163f --- /dev/null +++ b/lib/modules/TransportP.old @@ -0,0 +1,825 @@ +// Author:Nathan Blais +//Date Created:2020-03-21 + +#include "../../includes/packet.h" +#include "../../includes/channels.h" +#include "../../includes/am_types.h" +#include "../../includes/command.h" +#include "../../includes/CommandMsg.h" +#include "../../includes/sendInfo.h" +#include "../../includes/socket.h" +#include "Timer.h" + +module TransportP{ + provides interface Transport; + + //Uses the SimpleSend interface to transport data recieved packet + uses interface SimpleSend as Sender; + //Uses the Receive interface to receive packets +// uses interface Receive as Receiver; +// uses interface AMPacket; + + //Uses the (DVR) interface to know where to forward packets. + uses interface DistanceVectorRouting; + + uses interface Hashmap as Connections; // hash table: list of connections + + uses interface LocalTime; + // uses interface Timer as sendPacketTimer; + // uses interface Timer as sendDataTimer; + + uses interface Queue; + uses interface Pool; + //uses interface SendQueue as SendQueue; + //uses interface SendPool as SendPool; + + } + + implementation{ + + // Globals + + const socket_t NULLSocket = 0; + uint8_t *Empty; + uint16_t ipSeq = 1; + + // Prototypes + + error_t sendData(); + void sendDataDone(error_t err); + + error_t sendPacket(); + void sendPacketDone(error_t err); + + void makeTCPpack(tcpHeader *Package, uint8_t src, uint8_t dest, uint8_t flag, uint8_t seq, uint8_t ack, uint8_t ad_win, uint8_t* payload, uint8_t length); + void makeIPpack(pack *Package, tcpHeader *myTCPpack, socket_store_t *sock, uint8_t length); + error_t receive(pack* package); + //void send(socket_t socKey, uint8_t flag, uint8_t* payload, uint8_t length); + //error_t sendDone(socket_t socKey, uint8_t flag, uint8_t* payload, uint8_t length); + error_t send(socket_t socKey, uint8_t flag, uint8_t seq, uint8_t ack, uint8_t* payload, uint8_t length); + + void printTCP(tcpHeader *Package){ + dbg(TRANSPORT_CHANNEL, "printTCP Called\n"); + dbg(TRANSPORT_CHANNEL, "\tuint8_t Src_Port = %d\n\t\t\t\tuint8_t Dest_Port = %d\n",Package->Src_Port,Package->Dest_Port); + dbg(TRANSPORT_CHANNEL, "\tuint8_t Seq_Num = %d\n\t\t\t\tuint8_t Acknowledgment = %d\n",Package->Seq_Num,Package->Acknowledgment); + dbg(TRANSPORT_CHANNEL, "\tuint8_t Len = %d\n\t\t\t\tuint8_t Flags = %d\n",Package->Len,Package->Flags); + dbg(TRANSPORT_CHANNEL, "\tuint8_t Advertised_Window = %d\n\t\t\t\tuint8_t payload = %s\n",Package->Advertised_Window,Package->payload); + } + + void printSocket(socket_t fd){ + socket_store_t * socketHolder; + if (!(call Connections.contains(fd))) return; + socketHolder = call Connections.getPointer(fd); + + dbg(TRANSPORT_CHANNEL, "printSocket for %d Called\n",fd); + + dbg(TRANSPORT_CHANNEL, "\tsocket_addr_t dest.addr = %d\n\t\t\t\tsocket_addr_t dest.port = %d\n",socketHolder->dest.addr,socketHolder->dest.port); + dbg(TRANSPORT_CHANNEL, "\tsocket_state state = %d\n\t\t\t\tsendBuff = %s\n",socketHolder->state,socketHolder->sendBuff); + dbg(TRANSPORT_CHANNEL, "\tlastWritten = %d\n\t\t\t\tlastSent = %d\n",socketHolder->lastWritten,socketHolder->lastSent); + dbg(TRANSPORT_CHANNEL, "\tlastAck = %d\n\t\t\t\tnextSend = %d\n",socketHolder->lastAck,socketHolder->nextSend); + dbg(TRANSPORT_CHANNEL, "\tlastRead= %d\n\t\t\t\trcvdBuff = %s\n",socketHolder->lastRead,socketHolder->rcvdBuff); + dbg(TRANSPORT_CHANNEL, "\tnextExpected = %d\n\t\t\t\tlastRcvd = %d\n",socketHolder->nextExpected,socketHolder->lastRcvd); + dbg(TRANSPORT_CHANNEL, "\teffectiveWindow = %d\n\t\t\t\tTTD = %d\n",socketHolder->effectiveWindow,socketHolder->TTD); + dbg(TRANSPORT_CHANNEL, "\tRTT = %d\n",socketHolder->RTT); + dbg(TRANSPORT_CHANNEL, "\tlastTimeSent = %d\n\t\t\t\tlastTimeRecived = %d\n",socketHolder->lastTimeSent,socketHolder->lastTimeRecived); + } + + command socket_t Transport.socket(socket_t fd){ + dbg(TRANSPORT_CHANNEL,"Transport.socket() Called\n"); + if(call Connections.contains(0)) { //if there is room + if(!(call Connections.contains(fd))) + return fd; + else{ + dbg(TRANSPORT_CHANNEL,"Failed: port %d is not available\n", fd); + return NULLSocket; + } + } + dbg(TRANSPORT_CHANNEL,"Failed: No sockets are available\n"); + return NULLSocket; + } + + command error_t Transport.bind(socket_t fd, socket_addr_t *addr){ + socket_store_t TCB; //Transmission Control Block + uint8_t i = 0; + //Checkers + if(fd == 0 || fd > MAX_NUM_OF_SOCKETS){ + dbg(TRANSPORT_CHANNEL,"Socket:%d is not valid. Try number: 1-10\n", fd); + return FAIL; + } + if(addr->addr == 0 || addr->addr > MAX_ROUTES){ + dbg(TRANSPORT_CHANNEL,"adress :%d is not valid. Try number: 1-10\n", addr->addr); + return FAIL; + } + if(call Connections.contains(fd)){ //Checks if the Socket is already in use + dbg(TRANSPORT_CHANNEL,"Socket:%d is already bound\n", fd); + return FAIL; + } + + dbg(TRANSPORT_CHANNEL,"Transport.bind() Called\n"); + TCB.src = fd; + TCB.dest = *addr; + TCB.state = CLOSED; + // This is the sender portion. + TCB.lastWritten = i; + TCB.lastAck = i; + TCB.lastSent = 1; + + TCB.RTT = 60000; //NOTE:We Need to replace this value + TCB.effectiveWindow = 1; //NOTE:We Need to replace this value + + TCB.lastTimeRecived = 60000; + TCB.lastTimeSent = 0; + + //Add call to set up Sliding Window + + call Connections.insert(fd, TCB); + if(call Connections.contains(fd)){ + dbg(TRANSPORT_CHANNEL,"Socket:%d bound to Node:%d Port:%d\n", fd, addr->addr, addr->port); + return SUCCESS; + } + else { + dbg(TRANSPORT_CHANNEL,"Socket:%d bound to Node:%d Port:%d has FAILED\n", fd, addr->addr, addr->port); + return FAIL; + } + } + + command socket_t Transport.accept(socket_t fd, pack* myPacket){ + socket_store_t * socketHolder; + uint8_t iss; + tcpHeader * myTcpHeader = (tcpHeader*) myPacket->payload; + if (!(call Connections.contains(fd))) return FAIL; + + socketHolder = call Connections.getPointer(fd); + switch (socketHolder->state) { + case LISTEN: + default: + //Update Socket + socketHolder->dest.port= myTcpHeader->Src_Port; + socketHolder->dest.addr= myPacket->src; + + socketHolder->lastRcvd = myTcpHeader->Seq_Num; //for stop and wait + + + //socketHolder->nextExpected = myTcpHeader->Seq_Num + 1; + //socketHolder->lastRcvd = myTcpHeader->Seq_Num; + + //Choose and ISS + iss = 0; + + socketHolder->RTT = call LocalTime.get() + 1000000; + socketHolder->lastTimeSent = call LocalTime.get(); + + send(fd, SYN+ACK, iss, socketHolder->nextExpected, Empty, 0); + socketHolder->state = SYN_RCVD; + socketHolder->nextSend = iss + 1; + //socketHolder->lastSent = iss; //done in sender + break; + } + return fd; + } + + command uint16_t Transport.write(socket_t fd, uint8_t *buff, uint16_t bufflen){ + socket_store_t * curSocket = call Connections.getPointer(fd); + uint8_t written; + + dbg(TRANSPORT_CHANNEL,"Transport.write() Called\n"); + if (buff == NULL || bufflen < 1) return 0; + if (!(call Connections.contains(fd))) return 0; + + + + //NOTE: this will not work if you try to write too much information back to back + //for that we need to get the amount of info already on the buffer and make that the + // max amount you can write instead. + if (bufflen > SOCKET_BUFFER_SIZE){ + written = SOCKET_BUFFER_SIZE - bufflen; + } + else{ + written = bufflen; + } + memcpy((curSocket->sendBuff), buff, written); + dbg(TRANSPORT_CHANNEL, "Message to send is %s\n", curSocket->sendBuff); + + call sendDataTimer.startPeriodic(81000); //could be set to a diffrent number + return written; + } + + task void receiveBufferTask(){ + // If we have a values in our queue and the radio is not busy, then + // attempt to send a packet. + if(!call Queue.empty()){ + pack *info; + // We are peeking since, there is a possibility that the value will not + // be successfuly sent and we would like to continue to attempt to send + // it until we are successful. There is no limit on how many attempts + // can be made. + info = call Queue.head(); + + // Attempt to send it. + if(SUCCESS == receive(info)){ + //Release resources used if the attempt was successful + call Queue.dequeue(); + call Pool.put(info); + } + } + } + + command error_t Transport.receive(pack* package){ + if(!call Pool.empty()){ + pack *input; + input = call Pool.get(); + memcpy(input, package, PACKET_MAX_PAYLOAD_SIZE); + + // Now that we have a value from the pool we can put it into our queue. + // This is a FIFO queue. + call Queue.enqueue(input); + + // Start a send task which will be delayed. + post receiveBufferTask(); + + return SUCCESS; + } + return FAIL; + } + + error_t receive(pack* package) + { + pack* myMsg=(pack*) package; + tcpHeader* mySegment = (tcpHeader*) myMsg->payload; + socket_store_t * curConection = call Connections.getPointer(mySegment->Dest_Port); + + dbg(TRANSPORT_CHANNEL, "Transport.receive() Called\n"); + dbg(TRANSPORT_CHANNEL, "STATE: %d | FLAG: %d\n", curConection->state, mySegment->Flags); + + // printTCP(mySegment); + // printSocket(mySegment->Dest_Port); + + + // dbg(TRANSPORT_CHANNEL, "INCOMING SEQ #: %d\n",mySegment->Seq_Num ); + // dbg(TRANSPORT_CHANNEL, "Current EXPECTED #: %d\n",curConection->nextExpected ); + + // //TO_DO: add check here to see if the packet has been seen before + + // if(curConection->LastRecivedIPpack.src == myMsg->src && + // curConection->LastRecivedIPpack.seq == myMsg->seq) { + // dbg(TRANSPORT_CHANNEL, "Recived Duplicate packet\n"); + // return FAIL; + // } + + // if(curConection->state & (LISTEN | SYN_SENT)){ + // curConection->nextExpected = mySegment->Seq_Num; + // dbg(TRANSPORT_CHANNEL, "Changed nextExpected # to: %d\n",curConection->nextExpected); + // } + + // dbg(TRANSPORT_CHANNEL, "Check nextExpected #: %d\n",curConection->nextExpected); + + // if(curConection->nextExpected != mySegment->Seq_Num){ + // dbg(TRANSPORT_CHANNEL, "Recived packet with unexpected SEQ #\n"); + // return FAIL; + // } + + // if(curConection->lastSent != mySegment->Acknowledgment){ + // dbg(TRANSPORT_CHANNEL, "Recived packet with unexpected SEQ #\n"); + // return FAIL; + // } + + // //put some checks here + + // //We should update lastRcvd here; + // curConection->lastRcvd = mySegment->Seq_Num; + // curConection->lastAck = mySegment->Acknowledgment; + + // //update LastRecivedIPpack + + // //ass next expected + + // curConection->LastRecivedIPpack = *myMsg; + + // curConection->lastTimeRecived = call LocalTime.get(); + + //make sure only the sender is updating their curConection->effectiveWindow + + + + switch (curConection->state) { + case CLOSED: //Don't know what do do with it yet + dbg(TRANSPORT_CHANNEL, "State is Closed\n"); + //Acording to RFC - 793: + //An incoming segment not containing a RST causes a RST to be sent in response. + //^ we will ignore this + return FAIL; + break; + case LISTEN: + if(mySegment->Flags == RESET){/*ignore*/} + else if(mySegment->Flags == ACK){/* Can't have ACK send Pack:*/} + else if(mySegment->Flags == SYN){ + call Transport.accept(curConection->src, myMsg); + return SUCCESS; + } + else{ //Wrong info + return FAIL; + } + break; + case SYN_SENT: + //put some checks here + if(mySegment->Flags & ( SYN | ACK )) { + dbg(TRANSPORT_CHANNEL, "curConection->lastSent %d < mySegment->Acknowledgment %d\n", curConection->lastSent, mySegment->Acknowledgment); + + // if(curConection->lastSent < mySegment->Acknowledgment && + // mySegment->Acknowledgment <= curConection->nextSend) + // { + // dbg(TRANSPORT_CHANNEL, "Is this enterd??\n", curConection->state, mySegment->Flags); + + curConection->nextExpected = mySegment->Seq_Num + 1; + curConection->lastRcvd = mySegment->Seq_Num; + curConection->lastAck = mySegment->Acknowledgment; + //any segments on the retransmission queue which are thereby acknowledged should be removed. + //if(curConection->lastSent > curConection->lastRcvd){ + dbg(TRANSPORT_CHANNEL, "STATE: SYN_SENT -> ESTABLISHED\n"); + curConection->state = ESTABLISHED; + send(curConection->src, ACK, curConection->nextSend, curConection->nextExpected, Empty, 0); + // } + + //Set the variables: + // SND.WND <- SEG.WND + // SND.WL1 <- SEG.SEQ + // SND.WL2 <- SEG.ACK + + curConection->effectiveWindow = mySegment->Advertised_Window; + + //TO_DO:call to start sending packets from que. + return SUCCESS; + } + else return FAIL; + break; + + ///new bits + } + + //check sequence number HERE + + switch (curConection->state) { + + case LAST_ACK: + if(mySegment->Flags == ACK && curConection->nextExpected == mySegment->Seq_Num){ + curConection->state=CLOSED; + dbg(TRANSPORT_CHANNEL, "CLOSED FROM CASE LAST ACK AND STATE ACK \n"); + break; + } + goto FIN_WAIT_1_J; + case SYN_RCVD: + //put some checks here + if(mySegment->Flags & ( SYN | ACK )) { + curConection->state = ESTABLISHED; + + send(curConection->src, ACK, curConection->nextSend, curConection->nextExpected, Empty, 0); //update this + return SUCCESS; + } + else return FAIL; + break; + + case CLOSE_WAIT: + if(mySegment->Flags == ACK){ + curConection-> state = CLOSED; + return SUCCESS; + } + case FIN_WAIT_1: + FIN_WAIT_1_J: + if(mySegment->Flags == ACK){ + curConection ->state = FIN_WAIT_2; + return SUCCESS; + } + case FIN_WAIT_2: + if(mySegment->Flags == FIN){ + curConection-> state = TIME_WAIT; + send(curConection->src, ACK, curConection->nextSend, curConection->nextExpected, Empty, 0); //update this + + //set a timer that eventually closes the socket + return SUCCESS; + } + case ESTABLISHED: + ESTABLISHED_J: + if(mySegment->Flags == ACK){ + if(mySegment->Len == 0){ //this is a normal ack pack + //update socket + //stop resend for data + } + else{ // has data //Only need to ipmlement this if you send more than one packet of data + //update socket + call Transport.read(curConection->src, mySegment, mySegment->Len); + + //make ack packet + //store pack for resend + //send back an ack packet + } + } + else if(mySegment->Flags == PUSH){ + dbg(TRANSPORT_CHANNEL, "Message Recived:%s\n",mySegment->payload); + + call Transport.read(curConection->src, mySegment, mySegment->Len); + //print out entire buffer + dbg(TRANSPORT_CHANNEL, "\tFinished reciving Message\n"); + dbg(TRANSPORT_CHANNEL, "\t\tMessage:%s\n",curConection->rcvdBuff); + + send(curConection->src, ACK, curConection->nextSend, curConection->nextExpected, Empty, 0); //update this + return SUCCESS; + } + else if(mySegment->Flags == FIN){ + curConection-> state = CLOSE_WAIT; + + send(curConection->src, ACK, curConection->nextSend, curConection->nextExpected, Empty, 0); //update this + + //call timer first or after? + call Transport.close(curConection->src); + //timer? or command most likey command + } + else if(mySegment->Flags == RESET){} + else if(mySegment->Flags == URG){} + else return FAIL; + break; + case TIME_WAIT: + if(mySegment->Flags == URG){} + if(mySegment->Flags == ACK){} + if(mySegment->Flags == PUSH){} + if(mySegment->Flags == RESET){} + if(mySegment->Flags == SYN){} + if(mySegment->Flags == FIN){} + break; + + default: + dbg(TRANSPORT_CHANNEL, "FLAG_ERROR: \"%d\" does not match any known commands.\n", mySegment->Flags); + return FAIL; + break; + } + return FAIL; + } + + /** + * Read from the socket and write this data to the buffer. This data + * is obtained from your TCP implimentation. + * @param + * socket_t fd: file descriptor that is associated with the socket + * that is attempting a read. + * @param + * uint8_t *buff: the buffer that is being written. + * @param + * uint16_t bufflen: the amount of data that can be written to the + * buffer. + * @Side For your project, only server side. This could be both though. + * @return uint16_t - return the amount of data you are able to read + * from the pass buffer. This may be shorter then bufflen + */ + command uint16_t Transport.read(socket_t fd, tcpHeader *tcpSegment, uint16_t bufflen) + { + uint8_t buffSize; + socket_store_t * socketHolder = call Connections.getPointer(fd); + uint8_t *buff = tcpSegment->payload; + + dbg(TRANSPORT_CHANNEL, "Transport Called Read\n"); + for(buffSize=0; socketHolder->sendBuff[buffSize] != '\0'; buffSize++ ){} //calculates the size of the buffer + + strcat((socketHolder->rcvdBuff), buff); + + if (socketHolder->lastRead == 0) {socketHolder->lastRead = 1;} + else{socketHolder->lastRead = 0;} + // if (socketHolder->nextExpected == 0) {socketHolder->nextExpected = 1;} + // else{socketHolder->nextExpected = 0;} + + return 1; // for warning + } + + // mask a task for this + command error_t Transport.connect(socket_t fd, socket_addr_t * addr) + { + socket_store_t * socketHolder ; + uint8_t inSeq = 0; //choose inital sequence number + if (!(call Connections.contains(fd))) return FAIL; + socketHolder = call Connections.getPointer(fd); + switch (socketHolder->state) + { + case CLOSED: + socketHolder->state = SYN_SENT; //Change the state of the socket + send(fd, SYN, inSeq, 0, Empty, 0); + //socketHolder->lastSent = inSeq; + return SUCCESS; + break; + case LISTEN: + dbg(TRANSPORT_CHANNEL,"Socket is already listening\n"); + return FAIL; + break; + default: + dbg(TRANSPORT_CHANNEL, "WRONG_STATE_ERROR: \"%d\" is an incompatable state or does not match any known states.\n", socketHolder->state); + return FAIL; + break; + } + } + + /** + * Closes the socket. + * @param + * socket_t fd: file descriptor that is associated with the socket + * that you are closing. + * @side Client/Server + * @return socket_t - returns SUCCESS if you are able to attempt + * a closure with the fd passed, else return FAIL. + */ + command error_t Transport.close(socket_t fd) + { + socket_store_t * mySocket; + dbg(TRANSPORT_CHANNEL, "Called Transport.close()\n"); + + if (!(call Connections.contains(fd))) return FAIL; + + mySocket = call Connections.getPointer(fd); + + switch (mySocket->state){ + case CLOSED: + dbg(TRANSPORT_CHANNEL, "Already closed \n"); + return FAIL; + break; + case LISTEN: case SYN_SENT: + mySocket->state = CLOSED; + dbg(TRANSPORT_CHANNEL, "Socket State: (LISTEN | SYN_SENT) -> CLOSED\n"); + return SUCCESS; + break; + case ESTABLISHED: //Starts the close + //sudo Code: + //Set state + //Send packet + //Set timmer + + mySocket->state = FIN_WAIT_1; + // mySocket->dest.port= myTcpHeader->Src_Port; //ask if necessary + // mySocket->dest.addr= myPacket->src; //ask if necessary + send(fd, FIN, mySocket->nextSend, mySocket->nextExpected, Empty, 0); //update this + + return SUCCESS; + break; + //make timer that checks if the packets of the payload are done sending, wait APP, research to know when it's done, timer or a command + case CLOSE_WAIT: //changes wait to FIN WAIT 2 flag fin + //sudo Code: + //Set state + //Send packet + //Set timmer + dbg(TRANSPORT_CHANNEL, "In close CLOSE_WAIT \n"); + mySocket-> state = LAST_ACK; + + send(fd, FIN, mySocket->nextSend, mySocket->nextExpected, Empty, 0); //update this + return SUCCESS; + break; + default: + dbg(TRANSPORT_CHANNEL, "WRONG_STATE_ERROR: \"%d\" is an incompatable state or does not match any known states.\n", mySocket->state); + return FAIL; + break; + } + } + + /** + * A hard close, which is not graceful. This portion is optional. + * @param + * socket_t fd: file descriptor that is associated with the socket + * that you are hard closing. + * @side Client/Server + * @return socket_t - returns SUCCESS if you are able to attempt + * a closure with the fd passed, else return FAIL. + */ + //command error_t Transport.release(socket_t fd); + + command error_t Transport.listen(socket_t fd) + { + socket_store_t * socketHolder ; + if (!(call Connections.contains(fd))) return FAIL; + socketHolder = call Connections.getPointer(fd); + if(socketHolder->state == LISTEN){ + dbg(TRANSPORT_CHANNEL,"Socket is already listening\n"); + return FAIL; + } + else{ + dbg (TRANSPORT_CHANNEL, "Change Socket State from %d to Listen:%d\n",socketHolder->state, LISTEN); + socketHolder->state = LISTEN; + return SUCCESS; + } + } + + event void sendDataTimer.fired() + { + sendData(); + } + + void sendDataDone(error_t err) + { + if(err == SUCCESS){ + socket_store_t * socketHolder; + tcpHeader sendPackageTCP; + pack sendIPpackage; + uint8_t TempSendBuff[SOCKET_BUFFER_SIZE]; + uint8_t buffSize, sendSize, TCPflag, i; + uint8_t size = call Connections.size(); + uint32_t * keys = call Connections.getKeys(); + + for(i=0;isendBuff[0] != 0){ + i = 0; + break; + } + } + + if(size == 0 || i == size ){ + dbg(TRANSPORT_CHANNEL,"Data Timer Stoped\n"); + call sendDataTimer.stop(); + return; + } + + dbg(TRANSPORT_CHANNEL," ATTEMPTING TO SEND DATA\n"); + for(i=0;ilastSent: %d | socketHolder->lastAck %d\n",socketHolder->lastSent,socketHolder->lastAck ); + + dbg(TRANSPORT_CHANNEL,"socketHolder->sendBuff %s\n",socketHolder->sendBuff ); + + // if((socketHolder->state & (ESTABLISHED | FIN_WAIT_2) )&& + // socketHolder->lastSent == socketHolder->lastAck && + // socketHolder->sendBuff != '\0') + // { //if true send data + dbg(TRANSPORT_CHANNEL," Does it enter here?\n"); + for(buffSize=0; socketHolder->sendBuff[buffSize] != '\0'; buffSize++ ){} //calculates the size of the buffer + if(buffSize > TCP_PACKET_MAX_PAYLOAD_SIZE){//if size of buffer is > TCP_PACKET_MAX_PAYLOAD_SIZE + sendSize = TCP_PACKET_MAX_PAYLOAD_SIZE; + TCPflag = ACK; + } + else { //send normaly with PUSH flag <- let it know it is the end of the data send + sendSize = buffSize; + TCPflag = PUSH; + } + send(i, TCPflag, socketHolder->nextSend, socketHolder->nextExpected, socketHolder->sendBuff, sendSize); //update this + + socketHolder->lastSent = inSeq; + + + //edit buffer + if(buffSize > TCP_PACKET_MAX_PAYLOAD_SIZE){ + memcpy(TempSendBuff, &((socketHolder->sendBuff)[sendSize]), buffSize - sendSize); + dbg(TRANSPORT_CHANNEL," TempSendBuff: %s\n",TempSendBuff); + } + else{ + for (i = 0; i < SOCKET_BUFFER_SIZE; i++){ //I don't know if I need to fill this + socketHolder->sendBuff[i] = 0; + } + } + //} + } + } + }//end of: void sendDataDone(error_t err) + + task void sendDataTask() + { + + sendDataDone(SUCCESS); + } + + error_t sendData() + { + post sendDataTask(); + return SUCCESS; + } + + event void sendPacketTimer.fired() + { + sendPacket(); + } + void sendPacketDone(error_t err){ //assuming that this is for stop and wait. + uint8_t i; + if(err == FAIL){ + return; + } + for(i = 0; i < MAX_NUM_OF_SOCKETS; i++) { + if((call Connections.getPointer(i))->TTD < (call LocalTime.get())){//if true either reset or close the connnection + //Fill in here + return; + } + if((call Connections.getPointer(i))->RTT < call LocalTime.get() && (call Connections.getPointer(i))->lastSent != (call Connections.getPointer(i))->lastAck) { //if TRUE retransmit + dbg(TRANSPORT_CHANNEL, "Retransmitting\n"); + call Sender.send((call Connections.getPointer(i))->LastSentIPpack, call DistanceVectorRouting.GetNextHop((call Connections.getPointer(i))->dest.addr)); + } + } + }//end of: void sendPacketDone(error_t err) + + task void sendPackeTask() + { + + sendPacketDone(SUCCESS); + } + error_t sendPacket() + { + post sendDataTask(); + return SUCCESS; + } + + //error_t sendDone(socket_t socKey, uint8_t flag, uint8_t* payload, uint8_t length) + error_t send(socket_t socKey, uint8_t flag, uint8_t seq, uint8_t ack, uint8_t* payload, uint8_t length) + { + + tcpHeader sendPackageTCP; + pack sendIPpackage; + socket_store_t * socketHolder = call Connections.getPointer(socKey); + + dbg(TRANSPORT_CHANNEL,"error_t send Called\n"); + + switch (socketHolder->state) + { + case CLOSED: + dbg(TRANSPORT_CHANNEL,"error: connection does not exist\n"); + return FAIL; + break; + default: + //dbg(TRANSPORT_CHANNEL, "WRONG_STATE_ERROR: \"%d\" is an incompatable state or does not match any known states.\n", socketHolder->state); + //return FAIL; + break; + } + + + /*Make the TCP Packet*/ + + sendPackageTCP.Src_Port = socketHolder->src; + sendPackageTCP.Dest_Port = socketHolder->dest.port; + sendPackageTCP.Flags = flag; + sendPackageTCP.Seq_Num = seq; + sendPackageTCP.Acknowledgment = ack; + sendPackageTCP.Len = length; + sendPackageTCP.Advertised_Window = socketHolder->effectiveWindow; + memcpy(sendPackageTCP.payload, payload, length); + + /*END OF: Make the TCP Packet*/ + + makeIPpack(&sendIPpackage, &sendPackageTCP, socketHolder, PACKET_MAX_PAYLOAD_SIZE); //maybe reduce the PACKET_MAX_PAYLOAD_SIZE + ipSeq = ipSeq + 1; + + call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(socketHolder->dest.addr)); + + //update socket ------------------------------------------- + socketHolder->lastSent = sendPackageTCP.Seq_Num; + + // if (socketHolder->lastSent == 0) {socketHolder->nextExpected = 0;} + // else{socketHolder->nextExpected = 1;} + + //save a copy of the packet to be re-sent by a timmer and set RTT & TTD lastTimeSent + socketHolder->RTT = (socketHolder->lastTimeRecived - socketHolder->lastTimeSent) + call LocalTime.get() + 300; + socketHolder->TTD = (socketHolder->RTT) * 3; + return SUCCESS; + + } + + // task void sendTask(){ + // // If we have a values in our queue and the radio is not busy, then + // // attempt to send a packet. + // if(!call SendQueue.empty()){ + // sendTCPInfo *info; + // // We are peeking since, there is a possibility that the value will not + // // be successfuly sent and we would like to continue to attempt to send + // // it until we are successful. There is no limit on how many attempts + // // can be made. + // info = call SendQueue.head(); + + // // Attempt to send it. + // if(SUCCESS == sendDone(info->socKey,info->flag,&(info->payload), info->length)){ + // //Release resources used if the attempt was successful + // call SendQueue.dequeue(); + // call SendPool.put(info); + // } + // } + // } + + + // void send(socket_t socKey, uint8_t flag, uint8_t* payload, uint8_t length){ + // if(!call SendPool.empty()){ + // sendTCPInfo *input; + + // input = call SendPool.get(); + // input->socKey = socKey; + // input->flag = flag; + // memcpy(&(input->payload), payload, PACKET_MAX_PAYLOAD_SIZE); + // input->length = length; + + // // Now that we have a value from the pool we can put it into our queue. + // // This is a FIFO queue. + // call SendQueue.enqueue(input); + + // // Start a send task which will be delayed. + // post sendTask(); + // } + // } + + void makeIPpack(pack *Package, tcpHeader *myTCPpack, socket_store_t *sock, uint8_t length){ + Package->src = (uint16_t)TOS_NODE_ID; + Package->dest = sock->dest.addr; + Package->TTL = MAX_TTL; + Package->seq = ipSeq; //finish this + Package->protocol = PROTOCOL_TCP; + memcpy(Package->payload, myTCPpack, length); + } + +} \ No newline at end of file From bf81080c34b7a6353d127d216e4d123d3549eb20 Mon Sep 17 00:00:00 2001 From: Nathan Blais Date: Tue, 14 Apr 2020 17:50:32 -0700 Subject: [PATCH 13/28] Reimplemented open --- TestSim.py | 4 +- includes/socket.h | 5 +- lib/modules/TransportP.nc | 190 ++++++++++++++++++++++++++++---------- 3 files changed, 143 insertions(+), 56 deletions(-) diff --git a/TestSim.py b/TestSim.py index 9f63f05..9a79690 100644 --- a/TestSim.py +++ b/TestSim.py @@ -205,8 +205,8 @@ def main(): # s.ping(1, 6, "I'll have you know I gr"); s.cmdTestClient(1,8,6,10, "Hello, bozo"); #[selfAdress] [srcPort] [dest] [destPort] [transfer] s.runTime(150); - # s.cmdClientClose(1,8,6,10); #[client adress] [srcPort] [dest] [destPort] - # s.runTime(200); + s.cmdClientClose(1,8,6,10); #[client adress] [srcPort] [dest] [destPort] + s.runTime(200); #####***NEIGHBOR DISCOVERY TEST***##### # s.runTime(50); diff --git a/includes/socket.h b/includes/socket.h index 46839ca..34071b1 100644 --- a/includes/socket.h +++ b/includes/socket.h @@ -67,7 +67,7 @@ typedef struct socket_store_t{ //(TCB) - Transmission Control Block uint8_t lastSent; //SND.UNA //last sent data that is not acknowledged yet <- handled by the Sender uint8_t lastAck; // old sequence numbers which have been acknowledged <- handled by the reciver - uint8_t nextSend; //SND.NXT //sequence numbers allowed for new data transmission + //uint8_t nextSend; //SND.NXT //sequence numbers allowed for new data transmission /* Receive Sequence Space @@ -93,9 +93,6 @@ typedef struct socket_store_t{ //(TCB) - Transmission Control Block uint16_t RTT; uint16_t lastTimeSent; //Time the last packet was sent uint16_t lastTimeRecived; - - pack LastSentIPpack; - pack LastRecivedIPpack; }socket_store_t; #endif \ No newline at end of file diff --git a/lib/modules/TransportP.nc b/lib/modules/TransportP.nc index 9c0f8ea..3e0348b 100644 --- a/lib/modules/TransportP.nc +++ b/lib/modules/TransportP.nc @@ -69,7 +69,9 @@ module TransportP{ // Prototypes error_t receive(pack* package); + uint16_t readDataToBuff(socket_t fd, tcpHeader *tcpSegment, uint16_t bufflen); void makeIPpack(pack *Package, tcpHeader *myTCPpack, socket_store_t *sock, uint8_t length); + error_t send_out(socket_t socKey, uint8_t flag, uint8_t seq, uint8_t ack, uint8_t* payload, uint8_t length){ @@ -113,12 +115,13 @@ module TransportP{ // else{socketHolder->nextExpected = 1;} //save a copy of the packet to be re-sent by a timmer and set RTT & TTD lastTimeSent - socketHolder->RTT = (socketHolder->lastTimeRecived - socketHolder->lastTimeSent) + call LocalTime.get() + 300; - socketHolder->TTD = (socketHolder->RTT) * 3; + //socketHolder->RTT = (socketHolder->lastTimeRecived - socketHolder->lastTimeSent) + call LocalTime.get() + 300; + //socketHolder->TTD = (socketHolder->RTT) * 3; return SUCCESS; } + //should return the ammount of data written to the socket error_t send_buff(socket_t socKey, uint8_t flag, uint8_t seq, uint8_t ack, uint8_t* payload, uint8_t length){ send_out(socKey, flag, seq, ack, payload, length); return SUCCESS; @@ -143,6 +146,7 @@ module TransportP{ // /*re-Queue the data for transmission // If no space to queue, respond with "error: insufficient // resources".*/ + // break; // case ESTABLISHED: // case CLOSE_WAIT: @@ -155,22 +159,20 @@ module TransportP{ // If the urgent flag is set, then SND.UP <- SND.NXT and set the // urgent pointer in the outgoing segments.*/ - + // break; // case LAST_ACK: // case FIN_WAIT_1: // case FIN_WAIT_2: // case TIME_WAIT: // case CLOSING: // dbg(TRANSPORT_CHANNEL, "error: connection closing\n"); - - - // Return "error: connection closing" and do not service request. - + // break; // default: // dbg(TRANSPORT_CHANNEL, "WRONG_STATE_ERROR: \"%d\" is an incompatable state or does not match any known states.\n", socketHolder->state); - // return FAIL; // break; // } + // return SUCCESS; + // } command socket_t Transport.socket(socket_t fd){ @@ -308,8 +310,9 @@ module TransportP{ // //TO_DO: add check here to see if the packet has been seen before + curConection->lastRcvd = mySegment->Seq_Num; - curConection->LastRecivedIPpack = *myMsg; + //curConection->LastRecivedIPpack = *myMsg; // curConection->lastTimeRecived = call LocalTime.get(); @@ -327,11 +330,11 @@ module TransportP{ if(mySegment->Flags == RESET){/*ignore*/} else if(mySegment->Flags == ACK){/* Can't have ACK send Pack:*/} else if(mySegment->Flags == SYN){ + uint8_t ISN = 100; call Transport.accept(curConection->src, myMsg); - seq = mySegment->Seq_Num; - send_buff(curConection->src, SYN+ACK, seq, 0, Empty, 0); - curConection->nextExpected = 1; //Replace this + send_buff(curConection->src, SYN+ACK, ISN, seq + 1, Empty, 0); + curConection->nextExpected = ISN + 1; //Replace this curConection->state = SYN_RCVD; dbg(TRANSPORT_CHANNEL, "STATE: LISTEN -> SYN_RCVD\n"); @@ -342,22 +345,19 @@ module TransportP{ } break; case SYN_SENT: - //put some checks here if(mySegment->Flags & ( SYN | ACK )) { - //dbg(TRANSPORT_CHANNEL, "curConection->lastSent %d < mySegment->Acknowledgment %d\n", curConection->lastSent, mySegment->Acknowledgment); - //any segments on the retransmission queue which are thereby acknowledged should be removed. - dbg(TRANSPORT_CHANNEL, "curConection->lastSent %d curConection->lastRcvd %d\n", curConection->lastSent, curConection->lastRcvd); - - if(curConection->lastSent == curConection->lastRcvd){ + if(curConection->lastSent + 1 == mySegment->Acknowledgment){ dbg(TRANSPORT_CHANNEL, "STATE: SYN_SENT -> ESTABLISHED\n"); curConection->state = ESTABLISHED; - if(curConection->lastSent == 0){seq = 1;} - else{seq = 0;} + // if(curConection->lastSent == 0){seq = 1;} + // else{seq = 0;} - send_buff(curConection->src, ACK, seq, 0, Empty, 0); - curConection->nextExpected = seq; + seq = mySegment->Acknowledgment; + + send_buff(curConection->src, ACK, seq, mySegment->Seq_Num + 1, Empty, 0); + // curConection->nextExpected = seq + 1; return SUCCESS; } @@ -370,9 +370,18 @@ module TransportP{ ///new bits } + if(mySegment->Acknowledgment <= curConection->lastSent /*&& mySegment->Len == 0*/){ + dbg(TRANSPORT_CHANNEL, "mySegment->Acknowledgment <= curConection->lastSent\n"); + //resend the stuff + return SUCCESS; + } + //check sequence number HERE - if(curConection->nextExpected != mySegment->Seq_Num){ - dbg(TRANSPORT_CHANNEL, "curConection->nextExpected %d curConection->lastRcvd %d\n", curConection->nextExpected, curConection->lastRcvd); + if(curConection->nextExpected <= mySegment->Seq_Num && mySegment->Len > 0){ + dbg(TRANSPORT_CHANNEL, "curConection->nextExpected %d mySegment->Seq_Num %d\n", curConection->nextExpected, mySegment->Seq_Num); + if(curConection->nextExpected < mySegment->Seq_Num){ + return FAIL; //should put it back in the buffer + } dbg(TRANSPORT_CHANNEL, "Recived packet with unexpected SEQ #\n"); return SUCCESS; } @@ -382,21 +391,30 @@ module TransportP{ case SYN_RCVD: //put some checks here if(mySegment->Flags & ( SYN | ACK )) { - curConection->state = ESTABLISHED; - dbg(TRANSPORT_CHANNEL, "STATE: SYN_RCVD -> ESTABLISHED\n"); + if(curConection->lastSent + 1 == mySegment->Acknowledgment){ + //any segments on the retransmission queue which are thereby acknowledged should be removed. + curConection->state = ESTABLISHED; + dbg(TRANSPORT_CHANNEL, "STATE: SYN_RCVD -> ESTABLISHED\n"); - seq = mySegment->Seq_Num; - send_buff(curConection->src, ACK, seq, 0, Empty, 0); //update this - curConection->nextExpected = 0; //Replace this + seq = mySegment->Acknowledgment; + send_buff(curConection->src, ACK, seq, curConection->lastRcvd + 1, Empty, 0); + curConection->nextExpected = seq + 1; - return SUCCESS; + return SUCCESS; + } } else return SUCCESS; break; case LAST_ACK: - if(mySegment->Flags == ACK && curConection->nextExpected == mySegment->Seq_Num){ - curConection->state=CLOSED; - dbg(TRANSPORT_CHANNEL, "STATE: LAST_ACK -> CLOSED\n"); + if(mySegment->Flags == ACK){ + if(curConection->nextExpected == mySegment->Acknowledgment){ + curConection->state=CLOSED; + dbg(TRANSPORT_CHANNEL, "STATE: LAST_ACK -> CLOSED\n"); + } + else{ + //do somthing + } + return SUCCESS; break; } case FIN_WAIT_1: @@ -406,11 +424,17 @@ module TransportP{ return SUCCESS; } case FIN_WAIT_2: + if(mySegment->Flags == ACK){ + /*In addition to the processing for the ESTABLISHED + state, if the retransmission queue is empty, the + user's CLOSE can be acknowledged ("ok") but do not + delete the TCB.*/ + } if(mySegment->Flags == FIN){ curConection-> state = TIME_WAIT; dbg(TRANSPORT_CHANNEL, "STATE: FIN_WAIT_2 -> TIME_WAIT\n"); - send_buff(curConection->src, ACK, curConection->nextSend, curConection->nextExpected, Empty, 0); //update this + send_buff(curConection->src, ACK, curConection->lastSent + 1, curConection->nextExpected, Empty, 0); //update this //set a timer that eventually closes the socket return SUCCESS; @@ -418,13 +442,38 @@ module TransportP{ case CLOSE_WAIT: case ESTABLISHED: //NOTE: everything below should be updated if(mySegment->Flags == ACK){ + if(curConection->lastAck < mySegment->Acknowledgment && mySegment->Acknowledgment <= curConection->lastSent + 1){ + curConection->lastAck = mySegment->Acknowledgment; + //Any segments on the retransmission queue that are thereby entirely acknowledged are removed. + } + if(mySegment->Acknowledgment <= curConection->lastAck){//ACK is a duplicate + //it can be ignored + return SUCCESS; + } + if(mySegment->Acknowledgment > curConection->lastSent + 1){//ACK acks something not yet sent + //then send an ACK, drop the segment, and return. + return SUCCESS; + } + + /*If SND.UNA =< SEG.ACK =< SND.NXT, the send window + should be updated. If (SND.WL1 < SEG.SEQ or (SND.WL1 + = SEG.SEQ and SND.WL2 =< SEG.ACK)), set SND.WND <- + SEG.WND, set SND.WL1 <- SEG.SEQ, and set SND.WL2 <- + SEG.ACK.*/ + if(mySegment->Len == 0){ //this is a normal ack pack //update socket //stop resend for data } else{ // has data //Only need to ipmlement this if you send more than one packet of data //update socket - call Transport.read(curConection->src, mySegment, mySegment->Len); + dbg(TRANSPORT_CHANNEL, "Message Recived:%s\n",mySegment->payload); + readDataToBuff(curConection->src, mySegment, mySegment->Len); //returns amount put into buffer + + seq = curConection->lastAck + 1; + + send_buff(curConection->src, ACK, curConection->lastAck + 1, curConection->nextExpected, Empty, 0); //update this + curConection->nextExpected = seq + 1; //make ack packet //store pack for resend @@ -434,19 +483,19 @@ module TransportP{ else if(mySegment->Flags == PUSH){ dbg(TRANSPORT_CHANNEL, "Message Recived:%s\n",mySegment->payload); - call Transport.read(curConection->src, mySegment, mySegment->Len); + readDataToBuff(curConection->src, mySegment, mySegment->Len); //returns amount put into buffer //print out entire buffer dbg(TRANSPORT_CHANNEL, "\tFinished reciving Message\n"); dbg(TRANSPORT_CHANNEL, "\t\tMessage:%s\n",curConection->rcvdBuff); - send_buff(curConection->src, ACK, curConection->nextSend, curConection->nextExpected, Empty, 0); //update this + send_buff(curConection->src, ACK, curConection->lastAck + 1, curConection->nextExpected, Empty, 0); //update this return SUCCESS; } else if(mySegment->Flags == FIN){ curConection-> state = CLOSE_WAIT; dbg(TRANSPORT_CHANNEL, "STATE: ESTABLISHED -> CLOSE_WAIT\n"); - send_buff(curConection->src, ACK, curConection->nextSend, curConection->nextExpected, Empty, 0); //update this + send_buff(curConection->src, ACK, curConection->lastSent + 1, mySegment->Seq_Num + 1, Empty, 0); //update this //call timer first or after? call Transport.close(curConection->src); @@ -510,8 +559,8 @@ module TransportP{ } return FAIL; } - - command uint16_t Transport.read(socket_t fd, tcpHeader *tcpSegment, uint16_t bufflen){ + + uint16_t readDataToBuff(socket_t fd, tcpHeader *tcpSegment, uint16_t bufflen){ uint8_t buffSize; socket_store_t * socketHolder = call Connections.getPointer(fd); uint8_t *buff = tcpSegment->payload; @@ -533,6 +582,29 @@ module TransportP{ return buffSize; } + + command uint16_t Transport.read(socket_t fd, tcpHeader *tcpSegment, uint16_t bufflen){ + // uint8_t buffSize; + // socket_store_t * socketHolder = call Connections.getPointer(fd); + // uint8_t *buff = tcpSegment->payload; + + // dbg(TRANSPORT_CHANNEL, "Transport Called Read\n"); + + // for(buffSize=0; socketHolder->rcvdBuff[buffSize] != '\0'; buffSize++ ){} //calculates the size of the buffer + // if (bufflen > buffSize){ + // // will write the max ammount + // } + // else{ + // buffSize = bufflen; + // } + + // strcat((socketHolder->rcvdBuff), buff); + + // if (socketHolder->lastRead == 0) {socketHolder->lastRead = 1;} + // else{socketHolder->lastRead = 0;} + + // return buffSize; + } command error_t Transport.connect(socket_t fd, socket_addr_t * addr){ socket_store_t * socketHolder ; @@ -580,40 +652,58 @@ module TransportP{ dbg(TRANSPORT_CHANNEL, "Socket State: (LISTEN | SYN_SENT) -> CLOSED\n"); return SUCCESS; break; + case SYN_RCVD: + /*If no SENDs have been issued and there is no pending data to + send, then form a FIN segment and send it, and enter FIN-WAIT-1 + state; otherwise queue for processing after entering + ESTABLISHED state.*/ + case ESTABLISHED: //Starts the close //sudo Code: //Set state //Send packet //Set timmer + /*Queue this until all preceding SENDs have been segmentized, + then form a FIN segment and send it. In any case, enter FIN- + WAIT-1 state.*/ mySocket->state = FIN_WAIT_1; - // mySocket->dest.port= myTcpHeader->Src_Port; //ask if necessary - // mySocket->dest.addr= myPacket->src; //ask if necessary - - if(mySocket->lastSent == 0){seq = 1;} - else{seq = 0;} + seq = mySocket->lastSent + 1; - send_buff(fd, FIN, seq, 0, Empty, 0); //update this + send_buff(fd, FIN, seq, mySocket->lastRcvd + (mySocket->lastSent - mySocket->lastAck) + 1, Empty, 0); //update this + + //udate socket and set timmer return SUCCESS; break; + case FIN_WAIT_1: case FIN_WAIT_2: + /*Strictly speaking, this is an error and should receive a + "error: connection closing" response. An "ok" response would + be acceptable, too, as long as a second FIN is not emitted (the + first FIN may be retransmitted though).*/ + //make timer that checks if the packets of the payload are done sending, wait APP, research to know when it's done, timer or a command case CLOSE_WAIT: //changes wait to FIN WAIT 2 flag fin //sudo Code: //Set state //Send packet //Set timmer + //Queue this request until all preceding SENDs have been segmentized; then send a FIN segment, enter LAST-ACK state. dbg(TRANSPORT_CHANNEL, "In close CLOSE_WAIT \n"); - mySocket-> state = LAST_ACK; + seq = mySocket->nextExpected; + + send_buff(fd, FIN, seq, mySocket->lastRcvd, Empty, 0); //update this + mySocket->nextExpected = seq + 1; - if(mySocket->lastSent == 0){seq = 1;} - else{seq = 0;} + mySocket->state = LAST_ACK; - send_buff(fd, FIN, seq, 0, Empty, 0); //update this return SUCCESS; break; + case CLOSING: case LAST_ACK: case TIME_WAIT: + dbg(TRANSPORT_CHANNEL, "error: connection closing\n"); + return FAIL; default: dbg(TRANSPORT_CHANNEL, "WRONG_STATE_ERROR: \"%d\" is an incompatable state or does not match any known states.\n", mySocket->state); return FAIL; From 76bf2390314f5ced21e8448d9c9546c51990b6b1 Mon Sep 17 00:00:00 2001 From: Nathan Blais Date: Tue, 14 Apr 2020 19:36:41 -0700 Subject: [PATCH 14/28] g --- lib/modules/TransportP.nc | 24 +++++++++++++++--------- 1 file changed, 15 insertions(+), 9 deletions(-) diff --git a/lib/modules/TransportP.nc b/lib/modules/TransportP.nc index 3e0348b..4ec5117 100644 --- a/lib/modules/TransportP.nc +++ b/lib/modules/TransportP.nc @@ -371,7 +371,7 @@ module TransportP{ } if(mySegment->Acknowledgment <= curConection->lastSent /*&& mySegment->Len == 0*/){ - dbg(TRANSPORT_CHANNEL, "mySegment->Acknowledgment <= curConection->lastSent\n"); + dbg(TRANSPORT_CHANNEL, "mySegment->Acknowledgment %d <= curConection->lastSent %d\n", mySegment->Acknowledgment, curConection->lastSent); //resend the stuff return SUCCESS; } @@ -397,7 +397,7 @@ module TransportP{ dbg(TRANSPORT_CHANNEL, "STATE: SYN_RCVD -> ESTABLISHED\n"); seq = mySegment->Acknowledgment; - send_buff(curConection->src, ACK, seq, curConection->lastRcvd + 1, Empty, 0); + send_buff(curConection->src, ACK, seq, mySegment->Seq_Num + 1, Empty, 0); curConection->nextExpected = seq + 1; return SUCCESS; @@ -432,9 +432,9 @@ module TransportP{ } if(mySegment->Flags == FIN){ curConection-> state = TIME_WAIT; - dbg(TRANSPORT_CHANNEL, "STATE: FIN_WAIT_2 -> TIME_WAIT\n"); + dbg(TRANSPORT_CHANNEL, "STATE: FIN_WAIT_1 0r 2 -> TIME_WAIT\n"); - send_buff(curConection->src, ACK, curConection->lastSent + 1, curConection->nextExpected, Empty, 0); //update this + send_buff(curConection->src, ACK, curConection->lastSent + 1, curConection->lastRcvd + 1, Empty, 0); //update this //set a timer that eventually closes the socket return SUCCESS; @@ -463,6 +463,8 @@ module TransportP{ if(mySegment->Len == 0){ //this is a normal ack pack //update socket + send_buff(curConection->src, ACK, curConection->lastSent +1, curConection->lastRcvd + 1, Empty, 0); //update this + //stop resend for data } else{ // has data //Only need to ipmlement this if you send more than one packet of data @@ -495,9 +497,13 @@ module TransportP{ curConection-> state = CLOSE_WAIT; dbg(TRANSPORT_CHANNEL, "STATE: ESTABLISHED -> CLOSE_WAIT\n"); - send_buff(curConection->src, ACK, curConection->lastSent + 1, mySegment->Seq_Num + 1, Empty, 0); //update this + //if sender + + //send_buff(curConection->src, ACK, curConection->lastSent + 1, mySegment->Seq_Num + 1, Empty, 0); //update this //call timer first or after? + + //if reciver assume sender is out of things to send. call Transport.close(curConection->src); //timer? or command most likey command } @@ -671,8 +677,8 @@ module TransportP{ seq = mySocket->lastSent + 1; - send_buff(fd, FIN, seq, mySocket->lastRcvd + (mySocket->lastSent - mySocket->lastAck) + 1, Empty, 0); //update this - + //send_buff(fd, FIN, seq, mySocket->lastRcvd + (mySocket->lastSent - mySocket->lastAck), Empty, 0); //update this + send_buff(fd, FIN, seq, mySocket->lastRcvd + 1, Empty, 0); //update this //udate socket and set timmer return SUCCESS; @@ -692,9 +698,9 @@ module TransportP{ //Queue this request until all preceding SENDs have been segmentized; then send a FIN segment, enter LAST-ACK state. dbg(TRANSPORT_CHANNEL, "In close CLOSE_WAIT \n"); - seq = mySocket->nextExpected; + seq = mySocket->lastSent + 1; - send_buff(fd, FIN, seq, mySocket->lastRcvd, Empty, 0); //update this + send_buff(fd, FIN, seq, mySocket->lastRcvd + 1, Empty, 0); //update this mySocket->nextExpected = seq + 1; mySocket->state = LAST_ACK; From 0a9b1ae1d298bf4facdab136c5248fe3dd55065f Mon Sep 17 00:00:00 2001 From: Nathan Blais Date: Tue, 14 Apr 2020 21:18:16 -0700 Subject: [PATCH 15/28] reimplemented close --- lib/modules/TransportP.nc | 26 ++++++++++++++++++++------ 1 file changed, 20 insertions(+), 6 deletions(-) diff --git a/lib/modules/TransportP.nc b/lib/modules/TransportP.nc index 4ec5117..abd984c 100644 --- a/lib/modules/TransportP.nc +++ b/lib/modules/TransportP.nc @@ -306,7 +306,7 @@ module TransportP{ // printTCP(mySegment); // printSocket(mySegment->Dest_Port); - dbg(TRANSPORT_CHANNEL, "INCOMING SEQ #: %d\n",mySegment->Seq_Num ); + dbg(TRANSPORT_CHANNEL, "INCOMING SEQ #: %d INCOMING ACK #: %d\n",mySegment->Seq_Num,mySegment->Acknowledgment); // //TO_DO: add check here to see if the packet has been seen before @@ -357,6 +357,7 @@ module TransportP{ seq = mySegment->Acknowledgment; send_buff(curConection->src, ACK, seq, mySegment->Seq_Num + 1, Empty, 0); + curConection->lastAck = mySegment->Acknowledgment- 1; // curConection->nextExpected = seq + 1; return SUCCESS; @@ -399,6 +400,8 @@ module TransportP{ seq = mySegment->Acknowledgment; send_buff(curConection->src, ACK, seq, mySegment->Seq_Num + 1, Empty, 0); curConection->nextExpected = seq + 1; + curConection->lastAck = mySegment->Acknowledgment- 1; + return SUCCESS; } @@ -434,10 +437,20 @@ module TransportP{ curConection-> state = TIME_WAIT; dbg(TRANSPORT_CHANNEL, "STATE: FIN_WAIT_1 0r 2 -> TIME_WAIT\n"); - send_buff(curConection->src, ACK, curConection->lastSent + 1, curConection->lastRcvd + 1, Empty, 0); //update this + seq = mySegment->Acknowledgment; + dbg(TRANSPORT_CHANNEL, "seq: %d ack: %d \n",seq,curConection->lastRcvd + 1); + + + send_buff(curConection->src, ACK, seq, curConection->lastRcvd + 1, Empty, 0); //update this + + curConection->lastAck = mySegment->Acknowledgment- 1; + dbg(TRANSPORT_CHANNEL, "curConection->lastSent: %d\n",curConection->lastSent); + + //curConection->nextExpected; //set a timer that eventually closes the socket return SUCCESS; + break; } case CLOSE_WAIT: case ESTABLISHED: //NOTE: everything below should be updated @@ -453,7 +466,7 @@ module TransportP{ if(mySegment->Acknowledgment > curConection->lastSent + 1){//ACK acks something not yet sent //then send an ACK, drop the segment, and return. return SUCCESS; - } + } /*If SND.UNA =< SEG.ACK =< SND.NXT, the send window should be updated. If (SND.WL1 < SEG.SEQ or (SND.WL1 @@ -505,11 +518,12 @@ module TransportP{ //if reciver assume sender is out of things to send. call Transport.close(curConection->src); + return SUCCESS; //timer? or command most likey command } else if(mySegment->Flags == RESET){} else if(mySegment->Flags == URG){} - else return FAIL; + else return SUCCESS; break; case TIME_WAIT: if(mySegment->Flags == URG){} @@ -522,10 +536,10 @@ module TransportP{ default: dbg(TRANSPORT_CHANNEL, "FLAG_ERROR: \"%d\" does not match any known commands.\n", mySegment->Flags); - return FAIL; + return SUCCESS; break; } - return FAIL; + return SUCCESS; } task void receiveBufferTask(){ From fb30f05d4897a6622a09dcc54d0c3a8011b1e159 Mon Sep 17 00:00:00 2001 From: Nathan Blais Date: Tue, 14 Apr 2020 21:19:23 -0700 Subject: [PATCH 16/28] e --- lib/modules/TransportP.nc | 2 -- 1 file changed, 2 deletions(-) diff --git a/lib/modules/TransportP.nc b/lib/modules/TransportP.nc index abd984c..04aa01f 100644 --- a/lib/modules/TransportP.nc +++ b/lib/modules/TransportP.nc @@ -710,8 +710,6 @@ module TransportP{ //Send packet //Set timmer //Queue this request until all preceding SENDs have been segmentized; then send a FIN segment, enter LAST-ACK state. - dbg(TRANSPORT_CHANNEL, "In close CLOSE_WAIT \n"); - seq = mySocket->lastSent + 1; send_buff(fd, FIN, seq, mySocket->lastRcvd + 1, Empty, 0); //update this From fdd037fa4c2aa0c5e32211839150b31caa8185b6 Mon Sep 17 00:00:00 2001 From: Nathan Blais Date: Tue, 14 Apr 2020 21:53:14 -0700 Subject: [PATCH 17/28] gg --- lib/modules/TransportC.nc | 9 ++--- lib/modules/TransportP.nc | 69 ++++++++------------------------------- 2 files changed, 16 insertions(+), 62 deletions(-) diff --git a/lib/modules/TransportC.nc b/lib/modules/TransportC.nc index 8d124b7..4784625 100644 --- a/lib/modules/TransportC.nc +++ b/lib/modules/TransportC.nc @@ -28,13 +28,8 @@ implementation { components new TimerMilliC(), LocalTimeMilliC; TransportP.LocalTime -> LocalTimeMilliC; - // components new TimerMilliC() as sendPacketTimer; - // TransportP.sendPacketTimer -> sendPacketTimer; - - // components new TimerMilliC() as sendDataTimer; - // TransportP.sendDataTimer -> sendDataTimer; - - //NOTE: wire timmers + components new TimerMilliC() as Timer; + TransportP.Timer -> Timer; //Lists components new PoolC(pack, 100); diff --git a/lib/modules/TransportP.nc b/lib/modules/TransportP.nc index 04aa01f..f7debb3 100644 --- a/lib/modules/TransportP.nc +++ b/lib/modules/TransportP.nc @@ -25,8 +25,7 @@ module TransportP{ uses interface Hashmap as Connections; // hash table: list of connections uses interface LocalTime; -// uses interface Timer as sendPacketTimer; -// uses interface Timer as sendDataTimer; + uses interface Timer as Timer; uses interface Queue; uses interface Pool; @@ -127,63 +126,23 @@ module TransportP{ return SUCCESS; } - // error_t send_data(/*Some Junk*/){ - // socket_store_t * socketHolder ; - // if (!(call Connections.contains(fd))) return FAIL; - // socketHolder = call Connections.getPointer(fd); - - // switch (socketHolder->state) - // { - // case CLOSED: - // dbg(TRANSPORT_CHANNEL,"error: connection does not exist\n"); - // return FAIL; - // break; - // case LISTEN: - // case SYN_SENT: - // case SYN_RCVD: - - - // /*re-Queue the data for transmission - // If no space to queue, respond with "error: insufficient - // resources".*/ - // break; - // case ESTABLISHED: - // case CLOSE_WAIT: - - // //send data - - // /*Segmentize the buffer and send it with a piggybacked - // acknowledgment (acknowledgment value = RCV.NXT). If there is - // insufficient space to remember this buffer, simply return - // "error: insufficient resources". - - // If the urgent flag is set, then SND.UP <- SND.NXT and set the - // urgent pointer in the outgoing segments.*/ - // break; - // case LAST_ACK: - // case FIN_WAIT_1: - // case FIN_WAIT_2: - // case TIME_WAIT: - // case CLOSING: - // dbg(TRANSPORT_CHANNEL, "error: connection closing\n"); - // break; - // default: - // dbg(TRANSPORT_CHANNEL, "WRONG_STATE_ERROR: \"%d\" is an incompatable state or does not match any known states.\n", socketHolder->state); - // break; - // } - // return SUCCESS; - - // } + Timer.fired(){ + //check for TIME_WAIT to close wait for 2 times msl + //time out connection + //packet resender + //normal sender + } command socket_t Transport.socket(socket_t fd){ dbg(TRANSPORT_CHANNEL,"Transport.socket() Called\n"); + if(!(Timer.isRunning())){Timer.startPeriodic(512);} //Start Timer if(call Connections.contains(0)) { //if there is room - if(!(call Connections.contains(fd))) - return fd; - else{ - dbg(TRANSPORT_CHANNEL,"Failed: port %d is not available\n", fd); - return NULLSocket; - } + if(!(call Connections.contains(fd))) + return fd; + else{ + dbg(TRANSPORT_CHANNEL,"Failed: port %d is not available\n", fd); + return NULLSocket; + } } dbg(TRANSPORT_CHANNEL,"Failed: No sockets are available\n"); return NULLSocket; From d9d465719c9b73844d62c97f65c562f129617aff Mon Sep 17 00:00:00 2001 From: Nathan Blais Date: Thu, 16 Apr 2020 18:26:02 -0700 Subject: [PATCH 18/28] sendbuff --- includes/sendInfo.h | 7 +++++++ lib/modules/TransportC.nc | 10 ++++------ lib/modules/TransportP.nc | 17 ++++++++++++----- 3 files changed, 23 insertions(+), 11 deletions(-) diff --git a/includes/sendInfo.h b/includes/sendInfo.h index 58695fd..86a61e8 100644 --- a/includes/sendInfo.h +++ b/includes/sendInfo.h @@ -29,6 +29,13 @@ typedef struct sendTCPInfo{ uint8_t length; }sendTCPInfo; +typedef struct rsendTCPInfo{ + socket_t socKey; + uint8_t flag; + pack payload; + uint8_t length; +}rsendTCPInfo; + typedef struct neighbor { uint16_t id; bool flag; diff --git a/lib/modules/TransportC.nc b/lib/modules/TransportC.nc index 4784625..b9be8e4 100644 --- a/lib/modules/TransportC.nc +++ b/lib/modules/TransportC.nc @@ -34,15 +34,13 @@ implementation { //Lists components new PoolC(pack, 100); components new QueueC(pack*, 100); + components new PoolC(sendTCPInfo, 20) as SendPoolC; + components new QueueC(sendTCPInfo*, 20) as SendQueueC; TransportP.Pool -> PoolC; + TransportP.SendPool -> SendPoolC; TransportP.Queue -> QueueC; - - //components new PoolC(pack, 10) as SendPool; - //components new QueueC(sendTCPInfo*, 10) as SendQueue; - - //TransportP.SendPool -> SendPool; - //TransportP.SendQueue -> SendQueue; + TransportP.SendQueue -> SendQueueC; } \ No newline at end of file diff --git a/lib/modules/TransportP.nc b/lib/modules/TransportP.nc index f7debb3..7fd450a 100644 --- a/lib/modules/TransportP.nc +++ b/lib/modules/TransportP.nc @@ -29,8 +29,10 @@ module TransportP{ uses interface Queue; uses interface Pool; - //uses interface SendQueue as SendQueue; - //uses interface SendPool as SendPool; + uses interface Queue as SendQueue; + uses interface Pool as SendPool; + + //add a resend buffer } @@ -122,11 +124,12 @@ module TransportP{ //should return the ammount of data written to the socket error_t send_buff(socket_t socKey, uint8_t flag, uint8_t seq, uint8_t ack, uint8_t* payload, uint8_t length){ + //put packets in a que send_out(socKey, flag, seq, ack, payload, length); return SUCCESS; } - Timer.fired(){ + event void Timer.fired(){ //check for TIME_WAIT to close wait for 2 times msl //time out connection //packet resender @@ -135,7 +138,7 @@ module TransportP{ command socket_t Transport.socket(socket_t fd){ dbg(TRANSPORT_CHANNEL,"Transport.socket() Called\n"); - if(!(Timer.isRunning())){Timer.startPeriodic(512);} //Start Timer + if(!(call Timer.isRunning())){call Timer.startPeriodic(512);} //Start Timer if(call Connections.contains(0)) { //if there is room if(!(call Connections.contains(fd))) return fd; @@ -268,6 +271,7 @@ module TransportP{ dbg(TRANSPORT_CHANNEL, "INCOMING SEQ #: %d INCOMING ACK #: %d\n",mySegment->Seq_Num,mySegment->Acknowledgment); // //TO_DO: add check here to see if the packet has been seen before + //this means the sent packet was lost resend it again and extend the close time curConection->lastRcvd = mySegment->Seq_Num; @@ -490,7 +494,10 @@ module TransportP{ if(mySegment->Flags == PUSH){} if(mySegment->Flags == RESET){} if(mySegment->Flags == SYN){} - if(mySegment->Flags == FIN){} + if(mySegment->Flags == FIN){ + //this means the sent packet was lost resend it again and extend the close time + //should be taken care of earlyer + } break; default: From 9a49e3d2081d6e738df3c7b63c5bc87d3f14f3dd Mon Sep 17 00:00:00 2001 From: jmenjivar4 Date: Thu, 16 Apr 2020 19:46:57 -0700 Subject: [PATCH 19/28] Timer --- lib/modules/TransportC.nc | 5 ++++ lib/modules/TransportP.nc | 49 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 54 insertions(+) diff --git a/lib/modules/TransportC.nc b/lib/modules/TransportC.nc index b9be8e4..3bb06c6 100644 --- a/lib/modules/TransportC.nc +++ b/lib/modules/TransportC.nc @@ -37,10 +37,15 @@ implementation { components new PoolC(sendTCPInfo, 20) as SendPoolC; components new QueueC(sendTCPInfo*, 20) as SendQueueC; + components new PoolC(sendTCPInfo, 20) as ReSendPoolC; + components new QueueC(sendTCPInfo*, 20) as ReSendQueueC; + TransportP.Pool -> PoolC; TransportP.SendPool -> SendPoolC; + TransportP.ReSendPool -> ReSendPoolC; TransportP.Queue -> QueueC; TransportP.SendQueue -> SendQueueC; + TransportP.ReSendQueue -> ReSendQueueC; } \ No newline at end of file diff --git a/lib/modules/TransportP.nc b/lib/modules/TransportP.nc index 7fd450a..2a9a1af 100644 --- a/lib/modules/TransportP.nc +++ b/lib/modules/TransportP.nc @@ -32,6 +32,10 @@ module TransportP{ uses interface Queue as SendQueue; uses interface Pool as SendPool; + uses interface Queue as ReSendQueue; + uses interface Pool as ReSendPool; + + //add a resend buffer } @@ -134,6 +138,51 @@ module TransportP{ //time out connection //packet resender //normal sender + uint16_t i; + uint8_t j; + socket_store_t * mySocket; + if (call Connections.isEmpty() == TRUE) + { + return; + } + + for (i = 1; i-1 < call Connections.size(); i++ ) + { + mySocket = call Connections.getPointer(i); + + if (mySocket->state == TIME_WAIT) //not sure about the 2times MSL + { + mySocket->state = CLOSED; + call Connections.remove(i); + } + + //timeout connection? so close it? + // Transport.close(i); + + /* if (mySocket->TTD < call LocalTime.get()) + { + call Transport.close(i); + } + */ + + //come back to this + // send_buff(i, uint8_t flag, uint8_t seq, uint8_t ack, uint8_t* payload, uint8_t length +//if there is/are packets in the resend queue for this socket + if (call ReSendQueue.empty() == FALSE) // how do i check for the specific socket? + { + for (j = 0; j < call ReSendQueue.size(); j++) + { + //if () + } + } + + + + } + + + + } command socket_t Transport.socket(socket_t fd){ From 3e406c041b69176f979f10504313ad833d861756 Mon Sep 17 00:00:00 2001 From: Nathan Blais Date: Thu, 16 Apr 2020 22:23:14 -0700 Subject: [PATCH 20/28] d --- lib/modules/TransportP.nc | 57 +++++++++++++++------------------------ 1 file changed, 21 insertions(+), 36 deletions(-) diff --git a/lib/modules/TransportP.nc b/lib/modules/TransportP.nc index 2a9a1af..73c43f9 100644 --- a/lib/modules/TransportP.nc +++ b/lib/modules/TransportP.nc @@ -66,7 +66,6 @@ module TransportP{ implementation{ // Globals - const socket_t NULLSocket = 0; uint8_t *Empty; uint16_t ipSeq = 1; @@ -143,16 +142,17 @@ module TransportP{ socket_store_t * mySocket; if (call Connections.isEmpty() == TRUE) { - return; + return; //don't do anything } for (i = 1; i-1 < call Connections.size(); i++ ) { mySocket = call Connections.getPointer(i); - if (mySocket->state == TIME_WAIT) //not sure about the 2times MSL + if (mySocket->state == TIME_WAIT && mySocket->TTD < call LocalTime.get()) { mySocket->state = CLOSED; + dbg(TRANSPORT_CHANNEL, "STATE: TIME_WAIT -> CLOSED\n"); call Connections.remove(i); } @@ -160,9 +160,9 @@ module TransportP{ // Transport.close(i); /* if (mySocket->TTD < call LocalTime.get()) - { + { call Transport.close(i); - } + } */ //come back to this @@ -466,7 +466,22 @@ module TransportP{ } case CLOSE_WAIT: case ESTABLISHED: //NOTE: everything below should be updated - if(mySegment->Flags == ACK){ + if(mySegment->Flags & FIN){ + curConection-> state = CLOSE_WAIT; + dbg(TRANSPORT_CHANNEL, "STATE: ESTABLISHED -> CLOSE_WAIT\n"); + + //if sender + + //send_buff(curConection->src, ACK, curConection->lastSent + 1, mySegment->Seq_Num + 1, Empty, 0); //update this + + //call timer first or after? + + //if reciver assume sender is out of things to send. + call Transport.close(curConection->src); + return SUCCESS; + //timer? or command most likey command + } + if(mySegment->Flags & ACK){ if(curConection->lastAck < mySegment->Acknowledgment && mySegment->Acknowledgment <= curConection->lastSent + 1){ curConection->lastAck = mySegment->Acknowledgment; //Any segments on the retransmission queue that are thereby entirely acknowledged are removed. @@ -518,21 +533,6 @@ module TransportP{ send_buff(curConection->src, ACK, curConection->lastAck + 1, curConection->nextExpected, Empty, 0); //update this return SUCCESS; } - else if(mySegment->Flags == FIN){ - curConection-> state = CLOSE_WAIT; - dbg(TRANSPORT_CHANNEL, "STATE: ESTABLISHED -> CLOSE_WAIT\n"); - - //if sender - - //send_buff(curConection->src, ACK, curConection->lastSent + 1, mySegment->Seq_Num + 1, Empty, 0); //update this - - //call timer first or after? - - //if reciver assume sender is out of things to send. - call Transport.close(curConection->src); - return SUCCESS; - //timer? or command most likey command - } else if(mySegment->Flags == RESET){} else if(mySegment->Flags == URG){} else return SUCCESS; @@ -694,22 +694,7 @@ module TransportP{ ESTABLISHED state.*/ case ESTABLISHED: //Starts the close - //sudo Code: - //Set state - //Send packet - //Set timmer - /*Queue this until all preceding SENDs have been segmentized, - then form a FIN segment and send it. In any case, enter FIN- - WAIT-1 state.*/ - mySocket->state = FIN_WAIT_1; - - seq = mySocket->lastSent + 1; - - //send_buff(fd, FIN, seq, mySocket->lastRcvd + (mySocket->lastSent - mySocket->lastAck), Empty, 0); //update this - send_buff(fd, FIN, seq, mySocket->lastRcvd + 1, Empty, 0); //update this - //udate socket and set timmer - return SUCCESS; break; case FIN_WAIT_1: case FIN_WAIT_2: From 238fb3a09ee1add9228755e4180aebe532f9634c Mon Sep 17 00:00:00 2001 From: jmenjivar4 Date: Thu, 16 Apr 2020 22:23:54 -0700 Subject: [PATCH 21/28] slide --- lib/modules/TransportP.nc | 136 +++++++++++++++++++++++++++++++++++++- 1 file changed, 133 insertions(+), 3 deletions(-) diff --git a/lib/modules/TransportP.nc b/lib/modules/TransportP.nc index 2a9a1af..3bdd615 100644 --- a/lib/modules/TransportP.nc +++ b/lib/modules/TransportP.nc @@ -75,6 +75,9 @@ module TransportP{ error_t receive(pack* package); uint16_t readDataToBuff(socket_t fd, tcpHeader *tcpSegment, uint16_t bufflen); + error_t updateRecieverSlideWindow (socket_t fd, tcpHeader *tcpSegment, uint16_t bufflen); + error_t updateSenderSlideWindow (socket_t fd, tcpHeader *tcpSegment, uint16_t bufflen); + void makeIPpack(pack *Package, tcpHeader *myTCPpack, socket_store_t *sock, uint8_t length); @@ -111,11 +114,14 @@ module TransportP{ makeIPpack(&sendIPpackage, &sendPackageTCP, socketHolder, PACKET_MAX_PAYLOAD_SIZE); //maybe reduce the PACKET_MAX_PAYLOAD_SIZE ipSeq = ipSeq + 1; + call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(socketHolder->dest.addr)); //update socket ------------------------------------------- socketHolder->lastSent = sendPackageTCP.Seq_Num; + + // if (socketHolder->lastSent == 0) {socketHolder->nextExpected = 0;} // else{socketHolder->nextExpected = 1;} @@ -138,9 +144,13 @@ module TransportP{ //time out connection //packet resender //normal sender + uint16_t i; uint8_t j; + sendTCPInfo* TCPinfo; // has socket_t, flag, payload, length socket_store_t * mySocket; + socket_store_t * resendSocket; + socket_store_t * sendSocket; if (call Connections.isEmpty() == TRUE) { return; @@ -168,13 +178,54 @@ module TransportP{ //come back to this // send_buff(i, uint8_t flag, uint8_t seq, uint8_t ack, uint8_t* payload, uint8_t length //if there is/are packets in the resend queue for this socket + //TCPinfo; // has socket_t, flag, payload, length if (call ReSendQueue.empty() == FALSE) // how do i check for the specific socket? { for (j = 0; j < call ReSendQueue.size(); j++) { - //if () + TCPinfo = call ReSendQueue.element(j); + + resendSocket = call Connections.getPointer(TCPinfo->socKey); + + if (resendSocket->RTT < call LocalTime.get()) + { + //send packet + //update RTT and put them back in the resend queue + + } + + + } } + else if (call SendQueue.empty() == FALSE) + { + //send data through sliding window sender type + //checking effective window + for (j = 0; j < call ReSendQueue.size(); j++) + { + TCPinfo = call SendQueue.element(j); + + sendSocket = call Connections.getPointer(TCPinfo->socKey); + + + //sendSocket->effectiveWindow + //think about it + + + + } + + } + + /* + + Else if (there is a packet/packets in the send buffer that needs to be sent from this socket //normal sender + Send the first packet and move it to the resend que + + + */ + @@ -273,7 +324,7 @@ module TransportP{ case LISTEN: case SYN_SENT: case SYN_RCVD: - case ESTABLISHED: + case ESTABLISHED: // right here, writes to the send buffer case CLOSE_WAIT: //get size of buffer for(written=0; socketHolder->sendBuff[written] != '\0'; written++){} @@ -488,19 +539,26 @@ module TransportP{ if(mySegment->Len == 0){ //this is a normal ack pack //update socket + updateSenderSlideWindow(curConection->src, mySegment, 0); send_buff(curConection->src, ACK, curConection->lastSent +1, curConection->lastRcvd + 1, Empty, 0); //update this //stop resend for data + // updateSenderSlideWindow(curConection->src, mySegment, 0); + } else{ // has data //Only need to ipmlement this if you send more than one packet of data //update socket + dbg(TRANSPORT_CHANNEL, "Message Recived:%s\n",mySegment->payload); + readDataToBuff(curConection->src, mySegment, mySegment->Len); //returns amount put into buffer seq = curConection->lastAck + 1; send_buff(curConection->src, ACK, curConection->lastAck + 1, curConection->nextExpected, Empty, 0); //update this curConection->nextExpected = seq + 1; + //updateRecieverSlideWindow(curConection->src, mySegment, 0); + //make ack packet //store pack for resend @@ -516,6 +574,7 @@ module TransportP{ dbg(TRANSPORT_CHANNEL, "\t\tMessage:%s\n",curConection->rcvdBuff); send_buff(curConection->src, ACK, curConection->lastAck + 1, curConection->nextExpected, Empty, 0); //update this + updateRecieverSlideWindow(curConection->src, mySegment, 0); return SUCCESS; } else if(mySegment->Flags == FIN){ @@ -651,7 +710,7 @@ module TransportP{ case CLOSED: socketHolder->state = SYN_SENT; //Change the state of the socket dbg(TRANSPORT_CHANNEL, "STATE: CLOSED -> SYN_SENT\n"); - send_buff(fd, SYN, inSeq, 0, Empty, 0); //make and send a packet //send buffer + send_buff(fd, SYN, inSeq, 0, Empty, 0); //ack,payload, len packet, //make and send a packet //send buffer return SUCCESS; break; case LISTEN: @@ -770,6 +829,77 @@ module TransportP{ return SUCCESS; } } + + + error_t updateSenderSlideWindow (socket_t fd, tcpHeader *tcpSegment, uint16_t bufflen) + { + //lastSent is already updated here. but what about the other variables? + //?????????? + socket_store_t * socketHolder ; + uint8_t *buff = tcpSegment->payload; + + if (!(call Connections.contains(fd))) return FAIL; + socketHolder = call Connections.getPointer(fd); + + /* + if (socketHolder->flag == ACK && socketHolder->lastAck != socketHolder->lastRcvd ) + { + socketHolder -> lastAck = socketHolder->lastRcvd; //maybe change this to socketHolder->lastRcvd;???? + + } + */ + + if ((socketHolder->lastSent - socketHolder->lastAck) <= tcpSegment->Advertised_Window) //lecture 13 slide 58, advertised window from reciever; + { + if (socketHolder->lastAck <= socketHolder->lastSent && socketHolder->lastSent <= socketHolder->lastWritten) // lecture 13 slide 55 + { + //effective window: how much new data it is OK for sender to currently send + socketHolder->effectiveWindow = tcpSegment->Advertised_Window - (socketHolder->lastSent - socketHolder->lastAck); + dbg(TRANSPORT_CHANNEL, "effective window updating: %d", socketHolder->effectiveWindow); + return SUCCESS; + } + + + } + return SUCCESS; + + } + + + + + + + //call in timer before send + error_t updateRecieverSlideWindow (socket_t fd, tcpHeader *tcpSegment, uint16_t bufflen) + { + //lastSent is already updated here. but what about the other variables + //this happens after read + + uint8_t *buff = tcpSegment->payload; + socket_store_t * socketHolder; + if (!(call Connections.contains(fd))) return FAIL; + socketHolder = call Connections.getPointer(fd); + + + if ((socketHolder->lastRcvd - socketHolder->lastRead) <= SOCKET_BUFFER_SIZE) + { + if (socketHolder->lastRead < socketHolder->nextExpected) + { + if (socketHolder->nextExpected <= socketHolder->lastRcvd + 1) + { + tcpSegment->Advertised_Window = SOCKET_BUFFER_SIZE - ((socketHolder->nextExpected - 1) - socketHolder->lastRead); + dbg(TRANSPORT_CHANNEL, "Advertised Window updated, it's now %d \n", tcpSegment->Advertised_Window); + return SUCCESS; + + } + } + } + return SUCCESS; + } + + + void makeIPpack(pack *Package, tcpHeader *myTCPpack, socket_store_t *sock, uint8_t length){ Package->src = (uint16_t)TOS_NODE_ID; Package->dest = sock->dest.addr; From 35cc9d8471ec4fe2ba9cfec95751c111383747c1 Mon Sep 17 00:00:00 2001 From: Nathan Blais Date: Fri, 17 Apr 2020 01:25:25 -0700 Subject: [PATCH 22/28] Partialy implemented timmer. --- Node.nc | 2 +- includes/sendInfo.h | 2 + lib/modules/SimpleSendP.nc | 2 +- lib/modules/TransportC.nc | 18 ++-- lib/modules/TransportP.nc | 212 +++++++++++++++++++++++-------------- 5 files changed, 146 insertions(+), 90 deletions(-) diff --git a/Node.nc b/Node.nc index 2bfea28..955c19b 100644 --- a/Node.nc +++ b/Node.nc @@ -209,7 +209,7 @@ implementation{ dbg(TRANSPORT_CHANNEL, "sizeof(payload): %d\n", i); //AmountWritten = - call Transport.write(srcPort,payload,i); + //call Transport.write(srcPort,payload,i); //add the payload to a que to be cut up and packaged to be sent after connection diff --git a/includes/sendInfo.h b/includes/sendInfo.h index 86a61e8..07b1755 100644 --- a/includes/sendInfo.h +++ b/includes/sendInfo.h @@ -25,6 +25,8 @@ typedef struct reciveInfo{ typedef struct sendTCPInfo{ socket_t socKey; uint8_t flag; + uint8_t seq; + uint8_t ack; pack payload; uint8_t length; }sendTCPInfo; diff --git a/lib/modules/SimpleSendP.nc b/lib/modules/SimpleSendP.nc index 4f68d3d..3528e61 100644 --- a/lib/modules/SimpleSendP.nc +++ b/lib/modules/SimpleSendP.nc @@ -126,7 +126,7 @@ implementation{ *msg = *message; // Attempt to send the packet. - if(call AMSend.send(dest, &pkt, sizeof(pack)) ==SUCCESS){ + if(call AMSend.send(dest, &pkt, sizeof(pack)) == SUCCESS){ // See AMSend.sendDone(msg, error) to see what happens after. busy = TRUE; return SUCCESS; diff --git a/lib/modules/TransportC.nc b/lib/modules/TransportC.nc index 3bb06c6..b4bed21 100644 --- a/lib/modules/TransportC.nc +++ b/lib/modules/TransportC.nc @@ -31,21 +31,27 @@ implementation { components new TimerMilliC() as Timer; TransportP.Timer -> Timer; + // components new ListC(sendTCPInfo, 20) as SendBuff; + // TransportP.SendBuff -> SendBuff; + + // components new ListC(sendTCPInfo, 20) as ReSendBuff; + // TransportP.ReSendBuff -> ReSendBuff; + //Lists components new PoolC(pack, 100); components new QueueC(pack*, 100); components new PoolC(sendTCPInfo, 20) as SendPoolC; components new QueueC(sendTCPInfo*, 20) as SendQueueC; - components new PoolC(sendTCPInfo, 20) as ReSendPoolC; - components new QueueC(sendTCPInfo*, 20) as ReSendQueueC; + // components new PoolC(sendTCPInfo, 20) as ReSendPoolC; + // components new QueueC(sendTCPInfo*, 20) as ReSendQueueC; TransportP.Pool -> PoolC; - TransportP.SendPool -> SendPoolC; - TransportP.ReSendPool -> ReSendPoolC; + TransportP.SendPool -> SendPoolC; + // TransportP.ReSendPool -> ReSendPoolC; TransportP.Queue -> QueueC; - TransportP.SendQueue -> SendQueueC; - TransportP.ReSendQueue -> ReSendQueueC; + TransportP.SendQueue -> SendQueueC; + // TransportP.ReSendQueue -> ReSendQueueC; } \ No newline at end of file diff --git a/lib/modules/TransportP.nc b/lib/modules/TransportP.nc index e819c75..d0b54ea 100644 --- a/lib/modules/TransportP.nc +++ b/lib/modules/TransportP.nc @@ -27,13 +27,16 @@ module TransportP{ uses interface LocalTime; uses interface Timer as Timer; +// uses interface List as SendBuff; +// uses interface List as ReSendBuff; + uses interface Queue; uses interface Pool; uses interface Queue as SendQueue; uses interface Pool as SendPool; - uses interface Queue as ReSendQueue; - uses interface Pool as ReSendPool; +// uses interface Queue as ReSendQueue; +// uses interface Pool as ReSendPool; //add a resend buffer @@ -66,6 +69,7 @@ module TransportP{ implementation{ // Globals + const socket_t NULLSocket = 0; uint8_t *Empty; uint16_t ipSeq = 1; @@ -74,26 +78,45 @@ module TransportP{ error_t receive(pack* package); uint16_t readDataToBuff(socket_t fd, tcpHeader *tcpSegment, uint16_t bufflen); - error_t updateRecieverSlideWindow (socket_t fd, tcpHeader *tcpSegment, uint16_t bufflen); + uint8_t updateRecieverSlideWindow (socket_t fd, tcpHeader *tcpSegment); error_t updateSenderSlideWindow (socket_t fd, tcpHeader *tcpSegment, uint16_t bufflen); void makeIPpack(pack *Package, tcpHeader *myTCPpack, socket_store_t *sock, uint8_t length); - - - error_t send_out(socket_t socKey, uint8_t flag, uint8_t seq, uint8_t ack, uint8_t* payload, uint8_t length){ + task void send_out(){ tcpHeader sendPackageTCP; pack sendIPpackage; + uint8_t AW; + sendTCPInfo *info = call SendQueue.head(); + + socket_t socKey = info->socKey; + uint8_t flag = info->flag; + uint8_t seq = info->seq; + uint8_t ack = info->ack; + pack* payload = &(info->payload); + uint8_t length = info->length; + socket_store_t * socketHolder = call Connections.getPointer(socKey); - dbg(TRANSPORT_CHANNEL,"error_t send Called\n"); + dbg(TRANSPORT_CHANNEL,"error_t send_out Called\n"); + dbg(TRANSPORT_CHANNEL,"socketHolder->state %d\n", socketHolder->state); + dbg(TRANSPORT_CHANNEL,"socKey %d\n", info->socKey); + switch (socketHolder->state) { case CLOSED: dbg(TRANSPORT_CHANNEL,"error: connection does not exist\n"); - return FAIL; + return; break; + case SYN_RCVD: case ESTABLISHED: case FIN_WAIT_1: case FIN_WAIT_2: case CLOSE_WAIT: + if(length == 0){ + AW = updateRecieverSlideWindow(socKey, &sendPackageTCP); + } + else{ + AW = 1; + } + break; default: //dbg(TRANSPORT_CHANNEL, "WRONG_STATE_ERROR: \"%d\" is an incompatable state or does not match any known states.\n", socketHolder->state); //return FAIL; @@ -107,7 +130,7 @@ module TransportP{ sendPackageTCP.Seq_Num = seq; sendPackageTCP.Acknowledgment = ack; sendPackageTCP.Len = length; - sendPackageTCP.Advertised_Window = socketHolder->effectiveWindow; + sendPackageTCP.Advertised_Window = AW; memcpy(sendPackageTCP.payload, payload, length); /*END OF: Make the TCP Packet*/ makeIPpack(&sendIPpackage, &sendPackageTCP, socketHolder, PACKET_MAX_PAYLOAD_SIZE); //maybe reduce the PACKET_MAX_PAYLOAD_SIZE @@ -127,21 +150,46 @@ module TransportP{ //save a copy of the packet to be re-sent by a timmer and set RTT & TTD lastTimeSent //socketHolder->RTT = (socketHolder->lastTimeRecived - socketHolder->lastTimeSent) + call LocalTime.get() + 300; //socketHolder->TTD = (socketHolder->RTT) * 3; - return SUCCESS; + call SendQueue.dequeue(); + call SendPool.put(info); } //should return the ammount of data written to the socket error_t send_buff(socket_t socKey, uint8_t flag, uint8_t seq, uint8_t ack, uint8_t* payload, uint8_t length){ //put packets in a que - send_out(socKey, flag, seq, ack, payload, length); - return SUCCESS; + socket_store_t * socketHolder = call Connections.getPointer(socKey); + dbg(TRANSPORT_CHANNEL,"socKey %d\n", socKey); + + dbg(TRANSPORT_CHANNEL,"socketHolder->state %d\n", socketHolder->state); + + + if(!call SendPool.empty()){ + sendTCPInfo *input = call SendPool.get(); + input->socKey = socKey; + input->flag = flag; + input->seq = seq; + input->ack = ack; + memcpy(&(input->payload), payload, length); + input->length = length; + + // Now that we have a value from the pool we can put it into our queue. + // This is a FIFO queue. + call SendQueue.enqueue(input); + //call ReSendBuff.insert(info) + + // Start a send task which will be delayed. + post send_out(); + + return SUCCESS; + } + return FAIL; } event void Timer.fired(){ //check for TIME_WAIT to close wait for 2 times msl //time out connection - //packet resender + //packet resender / data sender //normal sender uint16_t i; @@ -149,91 +197,89 @@ module TransportP{ sendTCPInfo* TCPinfo; // has socket_t, flag, payload, length socket_store_t * mySocket; socket_store_t * resendSocket; - socket_store_t * sendSocket; - if (call Connections.isEmpty() == TRUE) - { - return; //don't do anything - } + socket_store_t * sendSocket; + uint8_t size = call Connections.size(); + uint32_t * keys = call Connections.getKeys(); - for (i = 1; i-1 < call Connections.size(); i++ ) + if (call Connections.isEmpty() == TRUE) return; //if there are no connections don't do anything. + for (i = 0; i < size ; i++) { - mySocket = call Connections.getPointer(i); + mySocket = call Connections.getPointer(keys[i]); + // dbg(TRANSPORT_CHANNEL,"mySocket->state %d\n", mySocket->TTD); + //dbg(TRANSPORT_CHANNEL,"call LocalTime.get() %d | mySocket->TTD %d\n", call LocalTime.get(), mySocket->TTD); - if (mySocket->state == TIME_WAIT && mySocket->TTD < call LocalTime.get()) + if(mySocket->state == TIME_WAIT && mySocket->TTD < call LocalTime.get()) { mySocket->state = CLOSED; dbg(TRANSPORT_CHANNEL, "STATE: TIME_WAIT -> CLOSED\n"); call Connections.remove(i); - } - - //timeout connection? so close it? - // Transport.close(i); - /* if (mySocket->TTD < call LocalTime.get()) + } + /* if (mySocket->TTD < call LocalTime.get()) { call Transport.close(i); } - */ + */ - //come back to this - // send_buff(i, uint8_t flag, uint8_t seq, uint8_t ack, uint8_t* payload, uint8_t length -//if there is/are packets in the resend queue for this socket - //TCPinfo; // has socket_t, flag, payload, length - if (call ReSendQueue.empty() == FALSE) // how do i check for the specific socket? - { - for (j = 0; j < call ReSendQueue.size(); j++) - { - TCPinfo = call ReSendQueue.element(j); + /* + if there is/are packets to be resent for this socket + For each of the resend packets for this socket + if(the RTT < current time) + Send it/them + Update their RTT and put them back in the resend que + Else if ( if there is new data that needs to be sent)//no packets should be in flight + If the sockets state == FIN_WAIT_1 + Add a FIN to the ACK flag for the sending of data + Send it according to the sliding window + Else if (there is a packet/packets in the send buffer that needs to be sent from this socket //normal sender + If the sockets state == FIN_WAIT_1 + Send a fin pack + If the sockets state == CLOSE_WAIT + call Transport.close(curConection->src); + Send the first packet and move it to the resend que + */ + + // if (call ReSendQueue.empty() == FALSE) // how do i check for the specific socket? + // { + // for (j = 0; j < call ReSendQueue.size(); j++) + // { + // TCPinfo = call ReSendQueue.element(j); - resendSocket = call Connections.getPointer(TCPinfo->socKey); + // resendSocket = call Connections.getPointer(TCPinfo->socKey); - if (resendSocket->RTT < call LocalTime.get()) - { - //send packet - //update RTT and put them back in the resend queue - - } - - - - } - } - else if (call SendQueue.empty() == FALSE) - { - //send data through sliding window sender type - //checking effective window - for (j = 0; j < call ReSendQueue.size(); j++) - { - TCPinfo = call SendQueue.element(j); + // if (resendSocket->RTT < call LocalTime.get()) + // { + // //send packet + // //update RTT and put them back in the resend queue + + // } + // } + // } + // else if (call SendQueue.empty() == FALSE) + // { + // //send data through sliding window sender type + // //checking effective window + // for (j = 0; j < call ReSendQueue.size(); j++) + // { + // TCPinfo = call SendQueue.element(j); - sendSocket = call Connections.getPointer(TCPinfo->socKey); + // sendSocket = call Connections.getPointer(TCPinfo->socKey); - //sendSocket->effectiveWindow - //think about it - - - - } - - } + // //sendSocket->effectiveWindow + // //think about it + // } + //} /* - Else if (there is a packet/packets in the send buffer that needs to be sent from this socket //normal sender Send the first packet and move it to the resend que - - */ - - - + // if(mySocket->state == FIN_WAIT_1){ + // send_buff(mySocket->src, FIN, mySocket->lastAck+1, lastRcvd+1, Empty, 0) + // } } - - - - } command socket_t Transport.socket(socket_t fd){ @@ -274,6 +320,7 @@ module TransportP{ TCB.dest = *addr; TCB.state = CLOSED; TCB.effectiveWindow = 1; //NOTE:We Need to replace this value + TCB.TTD = 0; //Add call to set up Sliding Window call Connections.insert(fd, TCB);//insert socket into Hash @@ -306,7 +353,7 @@ module TransportP{ return fd; } - command uint16_t Transport.write(socket_t fd, uint8_t *buff, uint16_t bufflen){ + command uint16_t Transport.write(socket_t fd, uint8_t *buff, uint16_t bufflen){ //NOTE: FIGURE out how to deal with writing if the buffer is not full but past its max seq # socket_store_t * socketHolder ; uint8_t written; if (!(call Connections.contains(fd))) return FAIL; @@ -476,6 +523,7 @@ module TransportP{ if(curConection->nextExpected == mySegment->Acknowledgment){ curConection->state=CLOSED; dbg(TRANSPORT_CHANNEL, "STATE: LAST_ACK -> CLOSED\n"); + call Connections.remove(curConection->seq); } else{ //do somthing @@ -589,7 +637,7 @@ module TransportP{ dbg(TRANSPORT_CHANNEL, "\t\tMessage:%s\n",curConection->rcvdBuff); send_buff(curConection->src, ACK, curConection->lastAck + 1, curConection->nextExpected, Empty, 0); //update this - updateRecieverSlideWindow(curConection->src, mySegment, 0); + updateRecieverSlideWindow(curConection->src, mySegment); return SUCCESS; } else if(mySegment->Flags == RESET){} @@ -703,13 +751,14 @@ module TransportP{ command error_t Transport.connect(socket_t fd, socket_addr_t * addr){ socket_store_t * socketHolder ; uint8_t inSeq = 0; //choose inital sequence number + dbg(TRANSPORT_CHANNEL, "connect() was called\n"); if (!(call Connections.contains(fd))) return FAIL; socketHolder = call Connections.getPointer(fd); switch (socketHolder->state) { case CLOSED: socketHolder->state = SYN_SENT; //Change the state of the socket - dbg(TRANSPORT_CHANNEL, "STATE: CLOSED -> SYN_SENT\n"); + dbg(TRANSPORT_CHANNEL, "STATE: CLOSED -> SYN_SENT %d\n",socketHolder->state ); send_buff(fd, SYN, inSeq, 0, Empty, 0); //ack,payload, len packet, //make and send a packet //send buffer return SUCCESS; break; @@ -754,6 +803,8 @@ module TransportP{ case ESTABLISHED: //Starts the close mySocket->state = FIN_WAIT_1; + send_buff(mySocket->src, FIN, mySocket->lastAck+1, mySocket->lastRcvd+1, Empty, 0); + return SUCCESS; break; case FIN_WAIT_1: case FIN_WAIT_2: @@ -826,7 +877,7 @@ module TransportP{ if (!(call Connections.contains(fd))) return FAIL; socketHolder = call Connections.getPointer(fd); - /* + /* if (socketHolder->flag == ACK && socketHolder->lastAck != socketHolder->lastRcvd ) { socketHolder -> lastAck = socketHolder->lastRcvd; //maybe change this to socketHolder->lastRcvd;???? @@ -852,11 +903,8 @@ module TransportP{ - - - //call in timer before send - error_t updateRecieverSlideWindow (socket_t fd, tcpHeader *tcpSegment, uint16_t bufflen) + uint8_t updateRecieverSlideWindow (socket_t fd, tcpHeader *tcpSegment) { //lastSent is already updated here. but what about the other variables //this happens after read From b8280be72f52edd3347b25b46218c04891312460 Mon Sep 17 00:00:00 2001 From: Nathan Blais Date: Fri, 17 Apr 2020 06:53:41 -0700 Subject: [PATCH 23/28] sending data is busted --- Node.nc | 4 +- TestSim.py | 6 +- lib/modules/TransportP.nc | 160 ++++++++++++++++++++++++++++---------- 3 files changed, 124 insertions(+), 46 deletions(-) diff --git a/Node.nc b/Node.nc index 955c19b..df65573 100644 --- a/Node.nc +++ b/Node.nc @@ -207,9 +207,11 @@ implementation{ //for(i=0; payload[i] != '\0'; i++ ){} dbg(TRANSPORT_CHANNEL, "sizeof(payload): %d\n", i); + dbg(TRANSPORT_CHANNEL, "payload: %s\n", payload); + //AmountWritten = - //call Transport.write(srcPort,payload,i); + call Transport.write(srcPort,payload,i); //add the payload to a que to be cut up and packaged to be sent after connection diff --git a/TestSim.py b/TestSim.py index 9a79690..3e94a21 100644 --- a/TestSim.py +++ b/TestSim.py @@ -204,9 +204,9 @@ def main(): # s.runTime(10); # s.ping(1, 6, "I'll have you know I gr"); s.cmdTestClient(1,8,6,10, "Hello, bozo"); #[selfAdress] [srcPort] [dest] [destPort] [transfer] - s.runTime(150); - s.cmdClientClose(1,8,6,10); #[client adress] [srcPort] [dest] [destPort] - s.runTime(200); + s.runTime(10); + #s.cmdClientClose(1,8,6,10); #[client adress] [srcPort] [dest] [destPort] + #s.runTime(200); #####***NEIGHBOR DISCOVERY TEST***##### # s.runTime(50); diff --git a/lib/modules/TransportP.nc b/lib/modules/TransportP.nc index d0b54ea..cfcd5b2 100644 --- a/lib/modules/TransportP.nc +++ b/lib/modules/TransportP.nc @@ -83,7 +83,7 @@ module TransportP{ void makeIPpack(pack *Package, tcpHeader *myTCPpack, socket_store_t *sock, uint8_t length); - task void send_out(){ + void send_out(){ tcpHeader sendPackageTCP; pack sendIPpackage; uint8_t AW; @@ -111,10 +111,11 @@ module TransportP{ break; case SYN_RCVD: case ESTABLISHED: case FIN_WAIT_1: case FIN_WAIT_2: case CLOSE_WAIT: if(length == 0){ - AW = updateRecieverSlideWindow(socKey, &sendPackageTCP); + // AW = updateRecieverSlideWindow(socKey, &sendPackageTCP); + AW = 5; } else{ - AW = 1; + AW = 5; } break; default: @@ -136,6 +137,10 @@ module TransportP{ makeIPpack(&sendIPpackage, &sendPackageTCP, socketHolder, PACKET_MAX_PAYLOAD_SIZE); //maybe reduce the PACKET_MAX_PAYLOAD_SIZE ipSeq = ipSeq + 1; + dbg(TRANSPORT_CHANNEL,"length %d\n", length); + dbg(TRANSPORT_CHANNEL,"sendPackageTCP.Len %d\n", sendPackageTCP.Len); + // dbg(TRANSPORT_CHANNEL,"(sendIPpackage.package).Len %d\n", (sendIPpackage.payload).Len); + call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(socketHolder->dest.addr)); @@ -163,6 +168,7 @@ module TransportP{ dbg(TRANSPORT_CHANNEL,"socketHolder->state %d\n", socketHolder->state); + dbg(TRANSPORT_CHANNEL,"length %d\n", length); if(!call SendPool.empty()){ sendTCPInfo *input = call SendPool.get(); @@ -172,6 +178,9 @@ module TransportP{ input->ack = ack; memcpy(&(input->payload), payload, length); input->length = length; + + dbg(TRANSPORT_CHANNEL,"input->length %d\n", input->length); + // Now that we have a value from the pool we can put it into our queue. // This is a FIFO queue. @@ -179,14 +188,14 @@ module TransportP{ //call ReSendBuff.insert(info) // Start a send task which will be delayed. - post send_out(); + send_out(); return SUCCESS; } return FAIL; } - event void Timer.fired(){ + task void TimerTask(){ //check for TIME_WAIT to close wait for 2 times msl //time out connection //packet resender / data sender @@ -221,6 +230,65 @@ module TransportP{ } */ + + //TO_DO: implement resender + + /* Else if ( if there is new data that needs to be sent)//no packets should be in flight + If the sockets state == FIN_WAIT_1 + Add a FIN to the ACK flag for the sending of data + Send it according to the sliding window*/ + + if(mySocket->lastSent > mySocket->lastAck){ + //fill later + } + else if(mySocket->lastWritten > mySocket->lastSent){ + uint8_t buffSize; + uint8_t dataBuffer[SOCKET_BUFFER_SIZE]; + switch(mySocket->state){ + case ESTABLISHED: case CLOSE_WAIT: + dbg(TRANSPORT_CHANNEL,"mySocket->lastWritten %d | mySocket->lastSent %d\n", mySocket->lastWritten, mySocket->lastSent); + + + //figure out amount of data to send + + dbg(TRANSPORT_CHANNEL, "Message in Socket is %s\n", mySocket->sendBuff); + + + for(buffSize=0; mySocket->sendBuff[buffSize] != '\0'; buffSize++){} + dbg(TRANSPORT_CHANNEL, "buffSize %d\n", buffSize); + + if(mySocket->effectiveWindow > buffSize){ + //keep buffSize the same + } + else{ + buffSize = mySocket->effectiveWindow; + } + + dbg(TRANSPORT_CHANNEL, "buffSize %d\n", buffSize); + + + while(buffSize > 0){ + if (TCP_PACKET_MAX_PAYLOAD_SIZE > buffSize){ + memcpy(dataBuffer, (mySocket->sendBuff), buffSize); + dbg(TRANSPORT_CHANNEL, "buffSize %d\n", buffSize); + dbg(TRANSPORT_CHANNEL, "Message to send is %s\n", dataBuffer); + send_buff(mySocket->src, ACK, mySocket->lastAck + buffSize, mySocket->lastRcvd + 1 , &dataBuffer, buffSize); + buffSize = 0; + } + else{ + memcpy(dataBuffer, &(mySocket->sendBuff), TCP_PACKET_MAX_PAYLOAD_SIZE); + dbg(TRANSPORT_CHANNEL, "Message to send is %s\n", dataBuffer); + send_buff(mySocket->src, ACK, mySocket->lastAck + TCP_PACKET_MAX_PAYLOAD_SIZE, mySocket->lastRcvd + 1 , dataBuffer, TCP_PACKET_MAX_PAYLOAD_SIZE); + buffSize = buffSize - TCP_PACKET_MAX_PAYLOAD_SIZE; + } + } + break; + default: + break; + } + return; + } + /* if there is/are packets to be resent for this socket For each of the resend packets for this socket @@ -282,6 +350,11 @@ module TransportP{ } } + event void Timer.fired(){ + post TimerTask(); + //return SUCCESS; + } + command socket_t Transport.socket(socket_t fd){ dbg(TRANSPORT_CHANNEL,"Transport.socket() Called\n"); if(!(call Timer.isRunning())){call Timer.startPeriodic(512);} //Start Timer @@ -299,6 +372,7 @@ module TransportP{ command error_t Transport.bind(socket_t fd, socket_addr_t *addr){ socket_store_t TCB;//Transmission Control Block + uint8_t i; //Check if values are valid if(fd == 0 || fd > MAX_NUM_OF_SOCKETS){ @@ -319,8 +393,12 @@ module TransportP{ TCB.src = fd; TCB.dest = *addr; TCB.state = CLOSED; - TCB.effectiveWindow = 1; //NOTE:We Need to replace this value + TCB.effectiveWindow = 5; //NOTE:We Need to replace this value TCB.TTD = 0; + for (i = 0; i < SOCKET_BUFFER_SIZE; i++) { + TCB.sendBuff[i] = '\0'; + TCB.rcvdBuff[i] = '\0'; + } //Add call to set up Sliding Window call Connections.insert(fd, TCB);//insert socket into Hash @@ -356,12 +434,11 @@ module TransportP{ command uint16_t Transport.write(socket_t fd, uint8_t *buff, uint16_t bufflen){ //NOTE: FIGURE out how to deal with writing if the buffer is not full but past its max seq # socket_store_t * socketHolder ; uint8_t written; - if (!(call Connections.contains(fd))) return FAIL; - socketHolder = call Connections.getPointer(fd); - dbg(TRANSPORT_CHANNEL,"Transport.write() Called\n"); - if (buff == NULL || bufflen < 1) return 0; + if (!(call Connections.contains(fd))) return 0; + socketHolder = call Connections.getPointer(fd); + if (buff == NULL || bufflen < 1) return 0; switch (socketHolder->state) { @@ -374,16 +451,26 @@ module TransportP{ case ESTABLISHED: // right here, writes to the send buffer case CLOSE_WAIT: //get size of buffer - for(written=0; socketHolder->sendBuff[written] != '\0'; written++){} + //for(written=0; socketHolder->sendBuff[written] == '\0'; written++){} - if (bufflen > written){ - // will write the max ammount + dbg(TRANSPORT_CHANNEL, "\t\tbufflen = %d\n", bufflen); + if (bufflen > SOCKET_BUFFER_SIZE){ + written = SOCKET_BUFFER_SIZE; } else{ written = bufflen; } + + socketHolder->lastWritten = written; + + // if (bufflen > written){ + // // will write the max ammount + // } + // else{ + // written = bufflen; + // } memcpy((socketHolder->sendBuff), buff, written); - dbg(TRANSPORT_CHANNEL, "Message to send is %s\n", socketHolder->sendBuff); + dbg(TRANSPORT_CHANNEL, "Message written to sendBuff is %s\n", socketHolder->sendBuff); //call sendDataTimer.startPeriodic(81000); //could be set to a diffrent number return written; @@ -523,7 +610,7 @@ module TransportP{ if(curConection->nextExpected == mySegment->Acknowledgment){ curConection->state=CLOSED; dbg(TRANSPORT_CHANNEL, "STATE: LAST_ACK -> CLOSED\n"); - call Connections.remove(curConection->seq); + call Connections.remove(curConection->src); } else{ //do somthing @@ -569,37 +656,38 @@ module TransportP{ curConection-> state = CLOSE_WAIT; dbg(TRANSPORT_CHANNEL, "STATE: ESTABLISHED -> CLOSE_WAIT\n"); - //if sender - - //send_buff(curConection->src, ACK, curConection->lastSent + 1, mySegment->Seq_Num + 1, Empty, 0); //update this - - //call timer first or after? + //if(mySegment->Len == 0 && //if there is data in the reciver buffer && th){ //this is needed for server to close + //update socket + curConection->lastAck = mySegment->Acknowledgment; - //if reciver assume sender is out of things to send. - call Transport.close(curConection->src); - return SUCCESS; + updateSenderSlideWindow(curConection->src, mySegment, 0); + call Transport.close(curConection->src); + return SUCCESS; //timer? or command most likey command } if(mySegment->Flags & ACK){ - if(curConection->lastAck < mySegment->Acknowledgment && mySegment->Acknowledgment <= curConection->lastSent + 1){ - curConection->lastAck = mySegment->Acknowledgment; - //Any segments on the retransmission queue that are thereby entirely acknowledged are removed. - } if(mySegment->Acknowledgment <= curConection->lastAck){//ACK is a duplicate + dbg(TRANSPORT_CHANNEL, "Ack is a duplicate\n"); //it can be ignored return SUCCESS; } if(mySegment->Acknowledgment > curConection->lastSent + 1){//ACK acks something not yet sent //then send an ACK, drop the segment, and return. + dbg(TRANSPORT_CHANNEL, "recived Ack for something not yet sent\n"); + return SUCCESS; } + if(curConection->lastAck < mySegment->Acknowledgment && mySegment->Acknowledgment <= curConection->lastSent + 1){ + curConection->lastAck = mySegment->Acknowledgment; + //Any segments on the retransmission queue that are thereby entirely acknowledged are removed. + } /*If SND.UNA =< SEG.ACK =< SND.NXT, the send window should be updated. If (SND.WL1 < SEG.SEQ or (SND.WL1 = SEG.SEQ and SND.WL2 =< SEG.ACK)), set SND.WND <- SEG.WND, set SND.WL1 <- SEG.SEQ, and set SND.WL2 <- SEG.ACK.*/ - + dbg(TRANSPORT_CHANNEL, "mySegment->Len %d\n",mySegment->Len); if(mySegment->Len == 0){ //this is a normal ack pack //update socket updateSenderSlideWindow(curConection->src, mySegment, 0); @@ -617,27 +705,15 @@ module TransportP{ readDataToBuff(curConection->src, mySegment, mySegment->Len); //returns amount put into buffer seq = curConection->lastAck + 1; - send_buff(curConection->src, ACK, curConection->lastAck + 1, curConection->nextExpected, Empty, 0); //update this curConection->nextExpected = seq + 1; - //updateRecieverSlideWindow(curConection->src, mySegment, 0); - - - //make ack packet - //store pack for resend - //send back an ack packet } } - else if(mySegment->Flags == PUSH){ + if(mySegment->Flags & PUSH){ dbg(TRANSPORT_CHANNEL, "Message Recived:%s\n",mySegment->payload); - - readDataToBuff(curConection->src, mySegment, mySegment->Len); //returns amount put into buffer - //print out entire buffer dbg(TRANSPORT_CHANNEL, "\tFinished reciving Message\n"); dbg(TRANSPORT_CHANNEL, "\t\tMessage:%s\n",curConection->rcvdBuff); - - send_buff(curConection->src, ACK, curConection->lastAck + 1, curConection->nextExpected, Empty, 0); //update this - updateRecieverSlideWindow(curConection->src, mySegment); + //call Transport.read(curConection->src) return SUCCESS; } else if(mySegment->Flags == RESET){} From af1a119e3bce3c37ff691224b389bf70d5c66fe9 Mon Sep 17 00:00:00 2001 From: Nathan Blais Date: Thu, 23 Apr 2020 18:30:59 -0700 Subject: [PATCH 24/28] Worked on sending data and read --- Node.nc | 12 ++- TestSim.py | 11 ++- includes/command.h | 1 + includes/packet.h | 3 +- lib/interfaces/CommandHandler.nc | 1 + lib/interfaces/Transport.nc | 2 +- lib/modules/CommandHandlerP.nc | 5 + lib/modules/TransportP.nc | 154 +++++++++++++++++++++---------- 8 files changed, 132 insertions(+), 57 deletions(-) diff --git a/Node.nc b/Node.nc index df65573..70b4cf5 100644 --- a/Node.nc +++ b/Node.nc @@ -206,8 +206,8 @@ implementation{ //for(i=0; payload[i] != '\0'; i++ ){} - dbg(TRANSPORT_CHANNEL, "sizeof(payload): %d\n", i); - dbg(TRANSPORT_CHANNEL, "payload: %s\n", payload); + //dbg(TRANSPORT_CHANNEL, "sizeof(payload): %d\n", i); + //dbg(TRANSPORT_CHANNEL, "payload: %s\n", payload); //AmountWritten = @@ -222,6 +222,14 @@ implementation{ call Transport.close(srcPort); } + event void CommandHandler.cmdServerRead(uint8_t port, uint16_t bufflen){ + char buff[SOCKET_BUFFER_SIZE]; + + + call Transport.read((socket_t)port, &buff, bufflen); + dbg(GENERAL_CHANNEL, "Message Read:%s\n", buff); + } + event void CommandHandler.setAppServer(){} diff --git a/TestSim.py b/TestSim.py index 3e94a21..35d7128 100644 --- a/TestSim.py +++ b/TestSim.py @@ -20,6 +20,7 @@ class TestSim: CMD_CLIENT_CLOSE = 7 CMD_APP_SERVER = 8 CMD_APP_CLIENT = 9 + CMD_SERVER_READ=15 CMD_ERROR = 10 CMD_APP_SEND = 11 @@ -156,6 +157,10 @@ def cmdClientClose(self, address, sourcePort, dest, destPort,): self.sendCMD(self.CMD_CLIENT_CLOSE, address, "{0}{1}{2}{3}".format(chr(address), chr(sourcePort), chr(dest), chr(destPort))); #[client adress] [srcPort] [dest] [destPort] + def cmdServerRead(self, address, port): + print 'Server Calling Read for', address, port; + self.sendCMD(self.CMD_SERVER_READ, address, "{0}{1}".format(chr(port), chr(bufflen))); + def main(): s = TestSim(); s.runTime(10); @@ -179,6 +184,7 @@ def main(): #Project 4 s.addChannel(s.APPLICATION_CHANNEL); + event void CommandHandler.cmdServerRead(uint8_t port, uint16_t bufflen){ #####***DVR TEST***##### @@ -203,8 +209,9 @@ def main(): # s.ping(1, 6, "I'll have you know I gr"); # s.runTime(10); # s.ping(1, 6, "I'll have you know I gr"); - s.cmdTestClient(1,8,6,10, "Hello, bozo"); #[selfAdress] [srcPort] [dest] [destPort] [transfer] - s.runTime(10); + s.cmdTestClient(1,8,6,10, "Hello, bozo!"); #[selfAdress] [srcPort] [dest] [destPort] [transfer] + s.runTime(20); + s.cmdServerRead(6,10,12); #s.cmdClientClose(1,8,6,10); #[client adress] [srcPort] [dest] [destPort] #s.runTime(200); diff --git a/includes/command.h b/includes/command.h index b0afa51..3f99082 100644 --- a/includes/command.h +++ b/includes/command.h @@ -17,6 +17,7 @@ enum{ CMD_TEST_CLIENT=4, CMD_TEST_SERVER=5, CMD_CLIENT_CLOSE=7, + CMD_SERVER_READ=15, CMD_KILL=6, CMD_ERROR=9 }; diff --git a/includes/packet.h b/includes/packet.h index 279b7bc..7cbb518 100644 --- a/includes/packet.h +++ b/includes/packet.h @@ -11,9 +11,10 @@ enum{ PACKET_HEADER_LENGTH = 8, + TCP_HEADER_LENGTH = 7, // PACKET_HEADER_LENGTH = sizeof(pack), PACKET_MAX_PAYLOAD_SIZE = 28 - PACKET_HEADER_LENGTH, - TCP_PACKET_MAX_PAYLOAD_SIZE = PACKET_MAX_PAYLOAD_SIZE - 7, + TCP_PACKET_MAX_PAYLOAD_SIZE = PACKET_MAX_PAYLOAD_SIZE - TCP_HEADER_LENGTH, //MAX_TTL = 15 MAX_TTL = 20 diff --git a/lib/interfaces/CommandHandler.nc b/lib/interfaces/CommandHandler.nc index 1673c8a..ca1158a 100644 --- a/lib/interfaces/CommandHandler.nc +++ b/lib/interfaces/CommandHandler.nc @@ -8,6 +8,7 @@ interface CommandHandler{ event void setTestServer(uint8_t port); event void setTestClient(uint8_t srcPort, uint8_t destination, uint8_t destPort, uint8_t *payload); event void cmdClientClose(uint8_t address, uint8_t srcPort, uint8_t destination, uint8_t destPort); + event void cmdServerRead(uint8_t port, uint16_t bufflen); event void setAppServer(); event void setAppClient(); } diff --git a/lib/interfaces/Transport.nc b/lib/interfaces/Transport.nc index ddf2c27..a732956 100644 --- a/lib/interfaces/Transport.nc +++ b/lib/interfaces/Transport.nc @@ -97,7 +97,7 @@ interface Transport{ * from the pass buffer. This may be shorter then bufflen */ - command uint16_t read(socket_t fd, tcpHeader *tcpSegment, uint16_t bufflen); + command uint16_t read(socket_t fd, uint8_t *buff, uint16_t bufflen); /** * Attempts a connection to an address. diff --git a/lib/modules/CommandHandlerP.nc b/lib/modules/CommandHandlerP.nc index 8f007d1..ea53915 100644 --- a/lib/modules/CommandHandlerP.nc +++ b/lib/modules/CommandHandlerP.nc @@ -82,6 +82,11 @@ implementation{ dbg(COMMAND_CHANNEL, "Command Type: Client Close\n"); signal CommandHandler.cmdClientClose(buff[0], buff[1], buff[2], buff[3]); break; + + case CMD_SERVER_READ: + dbg(COMMAND_CHANNEL, "Command Type: Server Read\n"); + signal CommandHandler.cmdServerRead(buff[0], buff[2]); + break; case CMD_KILL: dbg(COMMAND_CHANNEL, "Command Type: Kill (Not Implemented)\n"); diff --git a/lib/modules/TransportP.nc b/lib/modules/TransportP.nc index cfcd5b2..94f3cd2 100644 --- a/lib/modules/TransportP.nc +++ b/lib/modules/TransportP.nc @@ -83,7 +83,7 @@ module TransportP{ void makeIPpack(pack *Package, tcpHeader *myTCPpack, socket_store_t *sock, uint8_t length); - void send_out(){ + void send_out(){ tcpHeader sendPackageTCP; pack sendIPpackage; uint8_t AW; @@ -99,8 +99,8 @@ module TransportP{ socket_store_t * socketHolder = call Connections.getPointer(socKey); dbg(TRANSPORT_CHANNEL,"error_t send_out Called\n"); - dbg(TRANSPORT_CHANNEL,"socketHolder->state %d\n", socketHolder->state); - dbg(TRANSPORT_CHANNEL,"socKey %d\n", info->socKey); + dbg(TRANSPORT_CHANNEL,"\tsocketHolder->state %d\n", socketHolder->state); + dbg(TRANSPORT_CHANNEL,"\tsocKey %d\n", info->socKey); switch (socketHolder->state) @@ -134,10 +134,10 @@ module TransportP{ sendPackageTCP.Advertised_Window = AW; memcpy(sendPackageTCP.payload, payload, length); /*END OF: Make the TCP Packet*/ - makeIPpack(&sendIPpackage, &sendPackageTCP, socketHolder, PACKET_MAX_PAYLOAD_SIZE); //maybe reduce the PACKET_MAX_PAYLOAD_SIZE + makeIPpack(&sendIPpackage, &sendPackageTCP, socketHolder, length + TCP_HEADER_LENGTH); //maybe reduce the PACKET_MAX_PAYLOAD_SIZE ipSeq = ipSeq + 1; - dbg(TRANSPORT_CHANNEL,"length %d\n", length); + dbg(TRANSPORT_CHANNEL,"\tlength %d\n", length); dbg(TRANSPORT_CHANNEL,"sendPackageTCP.Len %d\n", sendPackageTCP.Len); // dbg(TRANSPORT_CHANNEL,"(sendIPpackage.package).Len %d\n", (sendIPpackage.payload).Len); @@ -147,8 +147,6 @@ module TransportP{ //update socket ------------------------------------------- socketHolder->lastSent = sendPackageTCP.Seq_Num; - - // if (socketHolder->lastSent == 0) {socketHolder->nextExpected = 0;} // else{socketHolder->nextExpected = 1;} @@ -164,11 +162,11 @@ module TransportP{ error_t send_buff(socket_t socKey, uint8_t flag, uint8_t seq, uint8_t ack, uint8_t* payload, uint8_t length){ //put packets in a que socket_store_t * socketHolder = call Connections.getPointer(socKey); - dbg(TRANSPORT_CHANNEL,"socKey %d\n", socKey); + dbg(TRANSPORT_CHANNEL,"Called send_buff()\n"); - dbg(TRANSPORT_CHANNEL,"socketHolder->state %d\n", socketHolder->state); - - dbg(TRANSPORT_CHANNEL,"length %d\n", length); + dbg(TRANSPORT_CHANNEL,"\tsocKey %d\n", socKey); + dbg(TRANSPORT_CHANNEL,"\tsocketHolder->state %d\n", socketHolder->state); + dbg(TRANSPORT_CHANNEL,"\tlength %d\n", length); if(!call SendPool.empty()){ sendTCPInfo *input = call SendPool.get(); @@ -238,12 +236,15 @@ module TransportP{ Add a FIN to the ACK flag for the sending of data Send it according to the sliding window*/ - if(mySocket->lastSent > mySocket->lastAck){ - //fill later + if(mySocket->lastSent > mySocket->lastAck){ //if there is data in flight + //fill later fill with resend stuff } - else if(mySocket->lastWritten > mySocket->lastSent){ - uint8_t buffSize; + else if(mySocket->lastWritten >= mySocket->lastSent){ //of there is data to be sent + uint8_t buffSize, i; uint8_t dataBuffer[SOCKET_BUFFER_SIZE]; + uint8_t sendDataHolder = 0; + for (i = 0; i < SOCKET_BUFFER_SIZE; i++) + dataBuffer[i] = '\0'; switch(mySocket->state){ case ESTABLISHED: case CLOSE_WAIT: dbg(TRANSPORT_CHANNEL,"mySocket->lastWritten %d | mySocket->lastSent %d\n", mySocket->lastWritten, mySocket->lastSent); @@ -251,35 +252,41 @@ module TransportP{ //figure out amount of data to send - dbg(TRANSPORT_CHANNEL, "Message in Socket is %s\n", mySocket->sendBuff); + //dbg(TRANSPORT_CHANNEL, "Message in Socket is %s\n", mySocket->sendBuff); for(buffSize=0; mySocket->sendBuff[buffSize] != '\0'; buffSize++){} + //dbg(TRANSPORT_CHANNEL, "buffSize %d\n", buffSize); + buffSize = buffSize - mySocket->lastAck +1; dbg(TRANSPORT_CHANNEL, "buffSize %d\n", buffSize); - if(mySocket->effectiveWindow > buffSize){ + if(mySocket->effectiveWindow >= buffSize){ //keep buffSize the same } else{ buffSize = mySocket->effectiveWindow; + dbg(TRANSPORT_CHANNEL, "form effectiveWindow buffSize %d\n", buffSize); } - dbg(TRANSPORT_CHANNEL, "buffSize %d\n", buffSize); + //dbg(TRANSPORT_CHANNEL, "buffSize %d\n", buffSize); while(buffSize > 0){ if (TCP_PACKET_MAX_PAYLOAD_SIZE > buffSize){ - memcpy(dataBuffer, (mySocket->sendBuff), buffSize); + memcpy(dataBuffer, &(mySocket->sendBuff)[sendDataHolder + mySocket->lastAck - 1], buffSize); dbg(TRANSPORT_CHANNEL, "buffSize %d\n", buffSize); - dbg(TRANSPORT_CHANNEL, "Message to send is %s\n", dataBuffer); + dbg(TRANSPORT_CHANNEL, "Message to send is:%s\n", dataBuffer); + dbg(TRANSPORT_CHANNEL, "mySocket->lastRcvd + 1 %d\n",mySocket->lastRcvd + 1); send_buff(mySocket->src, ACK, mySocket->lastAck + buffSize, mySocket->lastRcvd + 1 , &dataBuffer, buffSize); buffSize = 0; } else{ - memcpy(dataBuffer, &(mySocket->sendBuff), TCP_PACKET_MAX_PAYLOAD_SIZE); - dbg(TRANSPORT_CHANNEL, "Message to send is %s\n", dataBuffer); + memcpy(dataBuffer, &(mySocket->sendBuff)[sendDataHolder + mySocket->lastAck - 1], TCP_PACKET_MAX_PAYLOAD_SIZE); + dbg(TRANSPORT_CHANNEL, "Message to send is:%s\n", dataBuffer); send_buff(mySocket->src, ACK, mySocket->lastAck + TCP_PACKET_MAX_PAYLOAD_SIZE, mySocket->lastRcvd + 1 , dataBuffer, TCP_PACKET_MAX_PAYLOAD_SIZE); + dbg(TRANSPORT_CHANNEL, "mySocket->lastRcvd + 1 %d\n", mySocket->lastRcvd + 1); buffSize = buffSize - TCP_PACKET_MAX_PAYLOAD_SIZE; + sendDataHolder = sendDataHolder + TCP_PACKET_MAX_PAYLOAD_SIZE; } } break; @@ -546,17 +553,16 @@ module TransportP{ //any segments on the retransmission queue which are thereby acknowledged should be removed. if(curConection->lastSent + 1 == mySegment->Acknowledgment){ dbg(TRANSPORT_CHANNEL, "STATE: SYN_SENT -> ESTABLISHED\n"); - curConection->state = ESTABLISHED; // if(curConection->lastSent == 0){seq = 1;} // else{seq = 0;} - seq = mySegment->Acknowledgment; + //seq = mySegment->Acknowledgment; - send_buff(curConection->src, ACK, seq, mySegment->Seq_Num + 1, Empty, 0); - curConection->lastAck = mySegment->Acknowledgment- 1; + //send_buff(curConection->src, ACK, seq, mySegment->Seq_Num + 1, Empty, 0); + curConection->lastAck = mySegment->Acknowledgment - 1; // curConection->nextExpected = seq + 1; - + curConection->state = ESTABLISHED; return SUCCESS; } @@ -591,9 +597,13 @@ module TransportP{ if(mySegment->Flags & ( SYN | ACK )) { if(curConection->lastSent + 1 == mySegment->Acknowledgment){ //any segments on the retransmission queue which are thereby acknowledged should be removed. + curConection->state = ESTABLISHED; dbg(TRANSPORT_CHANNEL, "STATE: SYN_RCVD -> ESTABLISHED\n"); + if(mySegment->Len > 0) + goto ESTAB; + seq = mySegment->Acknowledgment; send_buff(curConection->src, ACK, seq, mySegment->Seq_Num + 1, Empty, 0); curConection->nextExpected = seq + 1; @@ -652,13 +662,14 @@ module TransportP{ } case CLOSE_WAIT: case ESTABLISHED: //NOTE: everything below should be updated + ESTAB: if(mySegment->Flags & FIN){ curConection-> state = CLOSE_WAIT; dbg(TRANSPORT_CHANNEL, "STATE: ESTABLISHED -> CLOSE_WAIT\n"); //if(mySegment->Len == 0 && //if there is data in the reciver buffer && th){ //this is needed for server to close //update socket - curConection->lastAck = mySegment->Acknowledgment; + curConection->lastAck = mySegment->Acknowledgment - 1; updateSenderSlideWindow(curConection->src, mySegment, 0); call Transport.close(curConection->src); @@ -673,12 +684,13 @@ module TransportP{ } if(mySegment->Acknowledgment > curConection->lastSent + 1){//ACK acks something not yet sent //then send an ACK, drop the segment, and return. + dbg(TRANSPORT_CHANNEL, "mySegment->Acknowledgment %d > curConection->lastSent + 1 %d\n",mySegment->Acknowledgment,curConection->lastSent + 1); dbg(TRANSPORT_CHANNEL, "recived Ack for something not yet sent\n"); return SUCCESS; } if(curConection->lastAck < mySegment->Acknowledgment && mySegment->Acknowledgment <= curConection->lastSent + 1){ - curConection->lastAck = mySegment->Acknowledgment; + curConection->lastAck = mySegment->Acknowledgment - 1; //Any segments on the retransmission queue that are thereby entirely acknowledged are removed. } @@ -691,7 +703,7 @@ module TransportP{ if(mySegment->Len == 0){ //this is a normal ack pack //update socket updateSenderSlideWindow(curConection->src, mySegment, 0); - send_buff(curConection->src, ACK, curConection->lastSent +1, curConection->lastRcvd + 1, Empty, 0); //update this + //send_buff(curConection->src, ACK, curConection->lastSent +1, curConection->lastRcvd + 1, Empty, 0); //update this //stop resend for data // updateSenderSlideWindow(curConection->src, mySegment, 0); @@ -705,7 +717,7 @@ module TransportP{ readDataToBuff(curConection->src, mySegment, mySegment->Len); //returns amount put into buffer seq = curConection->lastAck + 1; - send_buff(curConection->src, ACK, curConection->lastAck + 1, curConection->nextExpected, Empty, 0); //update this + send_buff(curConection->src, ACK, curConection->lastAck + 1, curConection->lastRcvd + 1, Empty, 0); //update this curConection->nextExpected = seq + 1; } } @@ -783,7 +795,7 @@ module TransportP{ socket_store_t * socketHolder = call Connections.getPointer(fd); uint8_t *buff = tcpSegment->payload; - dbg(TRANSPORT_CHANNEL, "Transport Called Read\n"); + dbg(TRANSPORT_CHANNEL, "Transport Called readDataToBuff\n"); for(buffSize=0; socketHolder->rcvdBuff[buffSize] != '\0'; buffSize++ ){} //calculates the size of the buffer if (bufflen > buffSize){ @@ -801,32 +813,72 @@ module TransportP{ return buffSize; } - command uint16_t Transport.read(socket_t fd, tcpHeader *tcpSegment, uint16_t bufflen){ - // uint8_t buffSize; - // socket_store_t * socketHolder = call Connections.getPointer(fd); - // uint8_t *buff = tcpSegment->payload; + command uint16_t Transport.read(socket_t fd, uint8_t *buff, uint16_t bufflen);{ + uint8_t buffSize, has_read; + socket_store_t * socketHolder; + socketBuff = socketHolder->rcvdBuff; + dbg(TRANSPORT_CHANNEL, "Transport Called Read\n"); - // dbg(TRANSPORT_CHANNEL, "Transport Called Read\n"); + if (!(call Connections.contains(fd))) return 0; + socketHolder = call Connections.getPointer(fd); + + if (socketBuff == NULL || bufflen < 1) return 0; + + for(buffSize=0; socketHolder->rcvdBuff[buffSize] != '\0'; buffSize++ ){} //calculates the size of the buffer + + + switch (socketHolder->state) + { + case CLOSED: + dbg(TRANSPORT_CHANNEL,"error: connection does not exist\n"); + break; + case FIN_WAIT_1: + case FIN_WAIT_2: + case TIME_WAIT: + case CLOSING: + case ESTABLISHED: // right here, writes to the send buffer + case CLOSE_WAIT: - // for(buffSize=0; socketHolder->rcvdBuff[buffSize] != '\0'; buffSize++ ){} //calculates the size of the buffer - // if (bufflen > buffSize){ - // // will write the max ammount - // } - // else{ - // buffSize = bufflen; - // } + //if there is not enuph data to put in the buffer Queue for later + //insead return dbg ("not enough data has been recived") - // strcat((socketHolder->rcvdBuff), buff); + dbg(TRANSPORT_CHANNEL, "\t\tbufflen = %d\n", bufflen); + if (bufflen > SOCKET_BUFFER_SIZE ){ + has_read = SOCKET_BUFFER_SIZE; + } + else{ + has_read = bufflen; + } - // if (socketHolder->lastRead == 0) {socketHolder->lastRead = 1;} - // else{socketHolder->lastRead = 0;} + socketHolder->lastRead = has_read; + + // if (bufflen > written){ + // // will write the max ammount + // } + // else{ + // written = bufflen; + // } + memcpy(buff, socketHolder->rcvdBuff, has_read); + dbg(TRANSPORT_CHANNEL, "Message written to sendBuff is %s\n", socketHolder->sendBuff); //fix - // return buffSize; + //call sendDataTimer.startPeriodic(81000); //could be set to a diffrent number + return has_read; + case LISTEN: + case SYN_SENT: + case LAST_ACK: + case SYN_RCVD: + dbg(TRANSPORT_CHANNEL,"error: connection hasn't been opened\n"); + break; + default: + dbg(TRANSPORT_CHANNEL, "WRONG_STATE_ERROR: \"%d\" is an incompatable state or does not match any known states.\n", socketHolder->state); + break; + } + return 0; } command error_t Transport.connect(socket_t fd, socket_addr_t * addr){ socket_store_t * socketHolder ; - uint8_t inSeq = 0; //choose inital sequence number + uint8_t inSeq = 1; //choose inital sequence number dbg(TRANSPORT_CHANNEL, "connect() was called\n"); if (!(call Connections.contains(fd))) return FAIL; socketHolder = call Connections.getPointer(fd); @@ -835,7 +887,7 @@ module TransportP{ case CLOSED: socketHolder->state = SYN_SENT; //Change the state of the socket dbg(TRANSPORT_CHANNEL, "STATE: CLOSED -> SYN_SENT %d\n",socketHolder->state ); - send_buff(fd, SYN, inSeq, 0, Empty, 0); //ack,payload, len packet, //make and send a packet //send buffer + send_buff(fd, SYN, inSeq, 1, Empty, 0); //ack,payload, len packet, //make and send a packet //send buffer return SUCCESS; break; case LISTEN: @@ -967,7 +1019,7 @@ module TransportP{ { //effective window: how much new data it is OK for sender to currently send socketHolder->effectiveWindow = tcpSegment->Advertised_Window - (socketHolder->lastSent - socketHolder->lastAck); - dbg(TRANSPORT_CHANNEL, "effective window updating: %d", socketHolder->effectiveWindow); + dbg(TRANSPORT_CHANNEL, "effective window updating: %d\n", socketHolder->effectiveWindow); return SUCCESS; } From 7e4a407f662ab5e02a0f8ee2b11cb332a2632614 Mon Sep 17 00:00:00 2001 From: jmenjivar4 Date: Thu, 23 Apr 2020 19:09:45 -0700 Subject: [PATCH 25/28] fixed bugs, has warnings tho --- Node.nc | 2 +- lib/interfaces/Transport.nc | 1 + lib/modules/TransportP.nc | 9 +++++---- 3 files changed, 7 insertions(+), 5 deletions(-) diff --git a/Node.nc b/Node.nc index 70b4cf5..05d1076 100644 --- a/Node.nc +++ b/Node.nc @@ -226,7 +226,7 @@ implementation{ char buff[SOCKET_BUFFER_SIZE]; - call Transport.read((socket_t)port, &buff, bufflen); + call Transport.read((socket_t)port, buff, bufflen); dbg(GENERAL_CHANNEL, "Message Read:%s\n", buff); } diff --git a/lib/interfaces/Transport.nc b/lib/interfaces/Transport.nc index a732956..1e817bd 100644 --- a/lib/interfaces/Transport.nc +++ b/lib/interfaces/Transport.nc @@ -150,4 +150,5 @@ interface Transport{ //event void sendDataDone(error_t err); + } diff --git a/lib/modules/TransportP.nc b/lib/modules/TransportP.nc index 94f3cd2..4b70936 100644 --- a/lib/modules/TransportP.nc +++ b/lib/modules/TransportP.nc @@ -240,7 +240,7 @@ module TransportP{ //fill later fill with resend stuff } else if(mySocket->lastWritten >= mySocket->lastSent){ //of there is data to be sent - uint8_t buffSize, i; + uint8_t buffSize; // is already declared in line 202 uint8_t dataBuffer[SOCKET_BUFFER_SIZE]; uint8_t sendDataHolder = 0; for (i = 0; i < SOCKET_BUFFER_SIZE; i++) @@ -277,7 +277,7 @@ module TransportP{ dbg(TRANSPORT_CHANNEL, "buffSize %d\n", buffSize); dbg(TRANSPORT_CHANNEL, "Message to send is:%s\n", dataBuffer); dbg(TRANSPORT_CHANNEL, "mySocket->lastRcvd + 1 %d\n",mySocket->lastRcvd + 1); - send_buff(mySocket->src, ACK, mySocket->lastAck + buffSize, mySocket->lastRcvd + 1 , &dataBuffer, buffSize); + send_buff(mySocket->src, ACK, mySocket->lastAck + buffSize, mySocket->lastRcvd + 1 , dataBuffer, buffSize); buffSize = 0; } else{ @@ -813,10 +813,11 @@ module TransportP{ return buffSize; } - command uint16_t Transport.read(socket_t fd, uint8_t *buff, uint16_t bufflen);{ + command uint16_t Transport.read(socket_t fd, uint8_t *buff, uint16_t bufflen){ uint8_t buffSize, has_read; socket_store_t * socketHolder; - socketBuff = socketHolder->rcvdBuff; + + uint8_t *socketBuff = socketHolder->rcvdBuff; //recheck with nathan dbg(TRANSPORT_CHANNEL, "Transport Called Read\n"); if (!(call Connections.contains(fd))) return 0; From b5c3e100c3e5c517de7a137ee98c8c6b2aa0f497 Mon Sep 17 00:00:00 2001 From: Nathan Blais Date: Thu, 23 Apr 2020 22:09:27 -0700 Subject: [PATCH 26/28] Got data to send --- Node.nc | 2 ++ TestSim.py | 10 ++++------ includes/protocol.h | 2 +- lib/modules/CommandHandlerP.nc | 2 +- lib/modules/TransportP.nc | 13 ++++++------- 5 files changed, 14 insertions(+), 15 deletions(-) diff --git a/Node.nc b/Node.nc index 05d1076..251d53f 100644 --- a/Node.nc +++ b/Node.nc @@ -224,6 +224,8 @@ implementation{ event void CommandHandler.cmdServerRead(uint8_t port, uint16_t bufflen){ char buff[SOCKET_BUFFER_SIZE]; + uint8_t i; + for (i = 0; i < SOCKET_BUFFER_SIZE; i++) buff[i] = '\0'; call Transport.read((socket_t)port, buff, bufflen); diff --git a/TestSim.py b/TestSim.py index 35d7128..2571e99 100644 --- a/TestSim.py +++ b/TestSim.py @@ -20,7 +20,7 @@ class TestSim: CMD_CLIENT_CLOSE = 7 CMD_APP_SERVER = 8 CMD_APP_CLIENT = 9 - CMD_SERVER_READ=15 + CMD_SERVER_READ = 15 CMD_ERROR = 10 CMD_APP_SEND = 11 @@ -157,7 +157,7 @@ def cmdClientClose(self, address, sourcePort, dest, destPort,): self.sendCMD(self.CMD_CLIENT_CLOSE, address, "{0}{1}{2}{3}".format(chr(address), chr(sourcePort), chr(dest), chr(destPort))); #[client adress] [srcPort] [dest] [destPort] - def cmdServerRead(self, address, port): + def cmdServerRead(self, address, port, bufflen): print 'Server Calling Read for', address, port; self.sendCMD(self.CMD_SERVER_READ, address, "{0}{1}".format(chr(port), chr(bufflen))); @@ -184,9 +184,6 @@ def main(): #Project 4 s.addChannel(s.APPLICATION_CHANNEL); - event void CommandHandler.cmdServerRead(uint8_t port, uint16_t bufflen){ - - #####***DVR TEST***##### s.runTime(1); @@ -210,8 +207,9 @@ def main(): # s.runTime(10); # s.ping(1, 6, "I'll have you know I gr"); s.cmdTestClient(1,8,6,10, "Hello, bozo!"); #[selfAdress] [srcPort] [dest] [destPort] [transfer] - s.runTime(20); + s.runTime(30); s.cmdServerRead(6,10,12); + s.runTime(1); #s.cmdClientClose(1,8,6,10); #[client adress] [srcPort] [dest] [destPort] #s.runTime(200); diff --git a/includes/protocol.h b/includes/protocol.h index cdb6a2c..2853974 100644 --- a/includes/protocol.h +++ b/includes/protocol.h @@ -11,7 +11,7 @@ enum{ PROTOCOL_PINGREPLY = 1, PROTOCOL_LINKEDLIST = 2, PROTOCOL_NAME = 3, - PROTOCOL_TCP= 4, + PROTOCOL_TCP = 4, PROTOCOL_DV = 5, PROTOCOL_CMD = 99 }; diff --git a/lib/modules/CommandHandlerP.nc b/lib/modules/CommandHandlerP.nc index ea53915..b2b8425 100644 --- a/lib/modules/CommandHandlerP.nc +++ b/lib/modules/CommandHandlerP.nc @@ -85,7 +85,7 @@ implementation{ case CMD_SERVER_READ: dbg(COMMAND_CHANNEL, "Command Type: Server Read\n"); - signal CommandHandler.cmdServerRead(buff[0], buff[2]); + signal CommandHandler.cmdServerRead(buff[0], buff[1]); break; case CMD_KILL: diff --git a/lib/modules/TransportP.nc b/lib/modules/TransportP.nc index 4b70936..c2b0275 100644 --- a/lib/modules/TransportP.nc +++ b/lib/modules/TransportP.nc @@ -111,7 +111,7 @@ module TransportP{ break; case SYN_RCVD: case ESTABLISHED: case FIN_WAIT_1: case FIN_WAIT_2: case CLOSE_WAIT: if(length == 0){ - // AW = updateRecieverSlideWindow(socKey, &sendPackageTCP); + //AW = updateRecieverSlideWindow(socKey, &sendPackageTCP); AW = 5; } else{ @@ -807,9 +807,6 @@ module TransportP{ strcat((socketHolder->rcvdBuff), buff); - if (socketHolder->lastRead == 0) {socketHolder->lastRead = 1;} - else{socketHolder->lastRead = 0;} - return buffSize; } @@ -1040,24 +1037,26 @@ module TransportP{ uint8_t *buff = tcpSegment->payload; socket_store_t * socketHolder; - if (!(call Connections.contains(fd))) return FAIL; + if (!(call Connections.contains(fd))) return 0; socketHolder = call Connections.getPointer(fd); if ((socketHolder->lastRcvd - socketHolder->lastRead) <= SOCKET_BUFFER_SIZE) { + dbg(TRANSPORT_CHANNEL, "socketHolder->lastRcvd - socketHolder->lastRead %d <= SOCKET_BUFFER_SIZE %d", socketHolder->lastRcvd - socketHolder->lastRead, SOCKET_BUFFER_SIZE); if (socketHolder->lastRead < socketHolder->nextExpected) { + //dbg(TRANSPORT_CHANNEL, "socketHolder->lastRcvd - socketHolder->lastRead%d" if (socketHolder->nextExpected <= socketHolder->lastRcvd + 1) { tcpSegment->Advertised_Window = SOCKET_BUFFER_SIZE - ((socketHolder->nextExpected - 1) - socketHolder->lastRead); dbg(TRANSPORT_CHANNEL, "Advertised Window updated, it's now %d \n", tcpSegment->Advertised_Window); - return SUCCESS; + return tcpSegment->Advertised_Window; } } } - return SUCCESS; + return 0; } From 1ea7d20fbb1d317f28cafec5408a40d87176b4e0 Mon Sep 17 00:00:00 2001 From: jmenjivar4 Date: Thu, 30 Apr 2020 21:48:01 -0700 Subject: [PATCH 27/28] AW works (for 1-5, gets weird higher), still need to fix noise --- Node.nc | 2 +- TestSim.py | 14 +- core | 0 lib/modules/TransportP.nc | 27 +- noise/meyer-heavy.txt | 1001 +++++++++++++++++++++++++++++++++++++ noise/some_noise.txt | 40 ++ 6 files changed, 1072 insertions(+), 12 deletions(-) create mode 100644 core create mode 100644 noise/meyer-heavy.txt create mode 100644 noise/some_noise.txt diff --git a/Node.nc b/Node.nc index 251d53f..f5866ee 100644 --- a/Node.nc +++ b/Node.nc @@ -229,7 +229,7 @@ implementation{ call Transport.read((socket_t)port, buff, bufflen); - dbg(GENERAL_CHANNEL, "Message Read:%s\n", buff); + dbg(GENERAL_CHANNEL, "Message Read from Application layer:%s\n", buff); } diff --git a/TestSim.py b/TestSim.py index 2571e99..a0b5310 100644 --- a/TestSim.py +++ b/TestSim.py @@ -168,6 +168,8 @@ def main(): s.loadTopo("long_line.topo"); #s.loadTopo("Project2Topo.topo"); s.loadNoise("no_noise.txt"); + #s.loadNoise("meyer-heavy.txt"); + #s.loadNoise("some_noise.txt"); s.bootAll(); #General s.addChannel(s.COMMAND_CHANNEL); @@ -200,18 +202,18 @@ def main(): #####***TCP Test***##### #s.ping(1, 6, "I'll have you know I gr"); s.cmdTestServer(6,10); #[adress] [port] - s.runTime(20); + s.runTime(400); #no noise 100, some noise 100 # s.ping(1, 6, "I'll have you know I gr"); # s.runTime(10); # s.ping(1, 6, "I'll have you know I gr"); # s.runTime(10); # s.ping(1, 6, "I'll have you know I gr"); s.cmdTestClient(1,8,6,10, "Hello, bozo!"); #[selfAdress] [srcPort] [dest] [destPort] [transfer] - s.runTime(30); - s.cmdServerRead(6,10,12); - s.runTime(1); - #s.cmdClientClose(1,8,6,10); #[client adress] [srcPort] [dest] [destPort] - #s.runTime(200); + s.runTime(500); #no noise 350, some noise 350 + s.cmdServerRead(6,10,12); #[dest][destPort][length] + s.runTime(300); #no noise 300, some noise 300 + s.cmdClientClose(1,8,6,10); #[client adress] [srcPort] [dest] [destPort] + s.runTime(200); #no noise 200, some noise 200 #####***NEIGHBOR DISCOVERY TEST***##### # s.runTime(50); diff --git a/core b/core new file mode 100644 index 0000000..e69de29 diff --git a/lib/modules/TransportP.nc b/lib/modules/TransportP.nc index c2b0275..48db942 100644 --- a/lib/modules/TransportP.nc +++ b/lib/modules/TransportP.nc @@ -712,17 +712,18 @@ module TransportP{ else{ // has data //Only need to ipmlement this if you send more than one packet of data //update socket - dbg(TRANSPORT_CHANNEL, "Message Recived:%s\n",mySegment->payload); + dbg(TRANSPORT_CHANNEL, "Message Recived line 715:%s and mySegment->len %d \n",mySegment->payload, mySegment->Len); readDataToBuff(curConection->src, mySegment, mySegment->Len); //returns amount put into buffer + dbg(TRANSPORT_CHANNEL, "curConection->src 719:%d and mySegment->len %d \n",curConection->src, mySegment->Len); seq = curConection->lastAck + 1; send_buff(curConection->src, ACK, curConection->lastAck + 1, curConection->lastRcvd + 1, Empty, 0); //update this curConection->nextExpected = seq + 1; } } if(mySegment->Flags & PUSH){ - dbg(TRANSPORT_CHANNEL, "Message Recived:%s\n",mySegment->payload); + dbg(TRANSPORT_CHANNEL, "Message Recived line 725:%s\n",mySegment->payload); dbg(TRANSPORT_CHANNEL, "\tFinished reciving Message\n"); dbg(TRANSPORT_CHANNEL, "\t\tMessage:%s\n",curConection->rcvdBuff); //call Transport.read(curConection->src) @@ -794,19 +795,34 @@ module TransportP{ uint8_t buffSize; socket_store_t * socketHolder = call Connections.getPointer(fd); uint8_t *buff = tcpSegment->payload; + uint8_t size = bufflen + (sizeof(socketHolder->rcvdBuff)/sizeof(socketHolder->rcvdBuff[0])); + uint8_t holder[bufflen]; + //holder[0] = '\0'; + holder [bufflen] = '\0'; + holder[bufflen+1] = '\0'; + //int len; - dbg(TRANSPORT_CHANNEL, "Transport Called readDataToBuff\n"); + // dbg(TRANSPORT_CHANNEL, "Transport Called readDataToBuff\n"); - for(buffSize=0; socketHolder->rcvdBuff[buffSize] != '\0'; buffSize++ ){} //calculates the size of the buffer + /*for(buffSize=0; socketHolder->rcvdBuff[buffSize] != '\0'; buffSize++ ){} //calculates the size of the buffer if (bufflen > buffSize){ // will write the max ammount } else{ buffSize = bufflen; } + */ + + memcpy (holder, buff, bufflen ); - strcat((socketHolder->rcvdBuff), buff); + dbg(TRANSPORT_CHANNEL, "holder after memcpy (holder, buff, bufflen); has:%s the value of bufflen is %d \n", holder, bufflen); + // strcat(holder, socketHolder->rcvdBuff); + strcat(socketHolder->rcvdBuff, holder); + + + // memcpy(socketHolder->rcvdBuff, holder, size); + dbg(TRANSPORT_CHANNEL, "line 811 socketHolder->rcvdBuff:%s\n", socketHolder->rcvdBuff ); return buffSize; } @@ -850,6 +866,7 @@ module TransportP{ socketHolder->lastRead = has_read; + // if (bufflen > written){ // // will write the max ammount // } diff --git a/noise/meyer-heavy.txt b/noise/meyer-heavy.txt new file mode 100644 index 0000000..2f96baf --- /dev/null +++ b/noise/meyer-heavy.txt @@ -0,0 +1,1001 @@ +-39 +-98 +-98 +-98 +-99 +-98 +-94 +-98 +-98 +-98 +-98 +-98 +-99 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-97 +-98 +-97 +-98 +-98 +-98 +-98 +-91 +-98 +-96 +-96 +-98 +-98 +-98 +-98 +-98 +-99 +-86 +-97 +-98 +-98 +-86 +-90 +-91 +-87 +-87 +-98 +-98 +-98 +-98 +-98 +-98 +-78 +-94 +-90 +-96 +-98 +-98 +-98 +-86 +-98 +-98 +-98 +-99 +-98 +-98 +-98 +-97 +-99 +-98 +-98 +-99 +-98 +-93 +-98 +-98 +-82 +-82 +-81 +-82 +-82 +-49 +-98 +-81 +-82 +-64 +-81 +-81 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-99 +-98 +-94 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-94 +-96 +-99 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-99 +-98 +-98 +-98 +-93 +-95 +-99 +-98 +-96 +-98 +-99 +-98 +-98 +-98 +-98 +-81 +-80 +-81 +-81 +-96 +-84 +-85 +-98 +-85 +-84 +-84 +-78 +-84 +-83 +-90 +-90 +-94 +-98 +-81 +-81 +-81 +-85 +-81 +-81 +-98 +-81 +-81 +-98 +-98 +-82 +-81 +-82 +-81 +-81 +-98 +-82 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-92 +-98 +-98 +-87 +-98 +-99 +-99 +-98 +-98 +-98 +-98 +-98 +-93 +-98 +-96 +-98 +-98 +-98 +-97 +-97 +-98 +-96 +-97 +-98 +-98 +-99 +-98 +-99 +-98 +-98 +-98 +-96 +-95 +-95 +-96 +-98 +-98 +-95 +-98 +-98 +-98 +-97 +-98 +-98 +-98 +-98 +-96 +-98 +-98 +-97 +-96 +-98 +-96 +-97 +-86 +-84 +-85 +-85 +-98 +-98 +-98 +-98 +-98 +-98 +-78 +-97 +-91 +-91 +-82 +-81 +-82 +-81 +-81 +-81 +-81 +-79 +-82 +-82 +-94 +-97 +-98 +-98 +-98 +-98 +-98 +-94 +-96 +-98 +-82 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-92 +-99 +-98 +-98 +-86 +-98 +-98 +-98 +-98 +-98 +-97 +-98 +-99 +-99 +-98 +-98 +-98 +-98 +-98 +-94 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-99 +-100 +-98 +-98 +-81 +-81 +-98 +-81 +-81 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-81 +-81 +-81 +-96 +-82 +-81 +-82 +-81 +-81 +-86 +-87 +-98 +-98 +-94 +-95 +-81 +-81 +-64 +-82 +-80 +-81 +-93 +-91 +-92 +-94 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-94 +-99 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-97 +-97 +-98 +-95 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-97 +-99 +-99 +-98 +-99 +-98 +-98 +-98 +-98 +-98 +-93 +-99 +-98 +-98 +-98 +-98 +-94 +-94 +-96 +-96 +-94 +-94 +-97 +-98 +-96 +-99 +-98 +-98 +-99 +-99 +-99 +-99 +-99 +-97 +-98 +-82 +-81 +-76 +-81 +-81 +-42 +-98 +-84 +-84 +-96 +-82 +-83 +-84 +-81 +-84 +-98 +-98 +-80 +-81 +-96 +-78 +-95 +-90 +-90 +-95 +-97 +-96 +-93 +-93 +-96 +-98 +-98 +-98 +-97 +-98 +-98 +-98 +-99 +-98 +-98 +-98 +-95 +-97 +-82 +-89 +-98 +-98 +-98 +-98 +-99 +-98 +-99 +-98 +-97 +-98 +-98 +-92 +-98 +-87 +-98 +-98 +-98 +-98 +-81 +-81 +-77 +-81 +-81 +-61 +-99 +-99 +-94 +-99 +-81 +-81 +-98 +-81 +-82 +-87 +-85 +-85 +-63 +-84 +-84 +-72 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-78 +-96 +-90 +-91 +-89 +-90 +-90 +-91 +-99 +-96 +-96 +-96 +-96 +-96 +-99 +-98 +-98 +-98 +-98 +-96 +-98 +-94 +-98 +-89 +-99 +-98 +-97 +-98 +-98 +-96 +-98 +-98 +-99 +-96 +-97 +-92 +-98 +-98 +-87 +-98 +-98 +-98 +-98 +-99 +-97 +-98 +-98 +-96 +-96 +-98 +-98 +-98 +-99 +-93 +-98 +-84 +-84 +-98 +-80 +-81 +-81 +-81 +-81 +-91 +-81 +-80 +-80 +-81 +-80 +-81 +-92 +-98 +-98 +-97 +-98 +-98 +-97 +-98 +-99 +-98 +-97 +-98 +-98 +-96 +-98 +-98 +-98 +-98 +-86 +-94 +-85 +-84 +-85 +-86 +-85 +-96 +-87 +-96 +-98 +-78 +-96 +-91 +-95 +-98 +-98 +-98 +-95 +-94 +-95 +-98 +-87 +-98 +-98 +-98 +-99 +-98 +-97 +-80 +-81 +-98 +-81 +-80 +-90 +-87 +-87 +-96 +-98 +-98 +-81 +-81 +-81 +-81 +-60 +-91 +-81 +-81 +-81 +-81 +-81 +-88 +-88 +-88 +-80 +-80 +-99 +-98 +-80 +-80 +-98 +-84 +-84 +-98 +-97 +-98 +-99 +-98 +-98 +-97 +-98 +-98 +-94 +-95 +-98 +-97 +-96 +-98 +-98 +-99 +-98 +-98 +-98 +-98 +-99 +-97 +-98 +-97 +-98 +-98 +-98 +-98 +-96 +-98 +-99 +-97 +-98 +-98 +-96 +-87 +-98 +-97 +-98 +-98 +-98 +-98 +-98 +-93 +-98 +-78 +-96 +-91 +-91 +-91 +-90 +-90 +-93 +-91 +-96 +-98 +-95 +-95 +-98 +-96 +-96 +-96 +-96 +-98 +-96 +-98 +-98 +-84 +-86 +-98 +-98 +-86 +-99 +-98 +-98 +-98 +-98 +-98 +-97 +-95 +-91 +-83 +-83 +-50 +-83 +-83 +-55 +-83 +-83 +-87 +-81 +-81 +-81 +-88 +-80 +-79 +-98 +-98 +-98 +-92 +-96 +-96 +-97 +-98 +-98 +-98 +-98 +-98 +-86 +-84 +-88 +-99 +-85 +-98 +-98 +-98 +-98 +-98 +-98 +-96 +-96 +-98 +-95 +-98 +-98 +-98 +-96 +-85 +-86 +-98 +-85 +-97 +-98 +-98 +-87 +-87 +-88 +-87 +-86 +-98 +-81 +-81 +-81 +-81 +-75 +-98 +-91 +-94 +-95 +-98 +-81 +-81 +-97 +-81 +-81 +-48 +-82 +-81 +-81 +-96 +-98 +-81 +-80 +-81 +-81 +-58 +-95 +-84 +-81 +-99 +-98 +-99 +-98 +-99 +-99 +-98 +-99 +-98 +-98 +-90 +-98 +-98 +-87 +-98 +-98 +-98 +-98 +-97 +-97 +-97 +-96 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-97 +-96 +-98 +-98 +-98 +-98 +-96 +-96 +-98 +-98 +-96 +-98 +-99 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-98 +-99 +-97 +-98 +-98 +-98 +-96 +-98 +-98 +-97 +-98 +-98 +-98 +-96 +-86 +-86 +-98 +-98 +-98 +-98 +-98 +-99 +-98 +-99 +-98 +-79 +-99 +-91 +-91 +-91 +-91 +-91 +-98 +-95 +-98 +-97 +-81 +-81 +-81 +-81 +-80 +-52 +-81 +-81 +-83 +-81 +-81 +-81 +-63 +-98 +-98 +-98 +-98 +-98 +-98 +-99 +-98 +-98 +-98 +-93 +-84 +-97 +-97 +-99 +-98 +-96 +-98 +-98 +-97 +-98 +-98 +-98 +-96 +-98 +-98 +-98 +-98 +-98 +-96 +-98 +-99 +-98 +-98 +-98 +-98 +-97 +-98 +-98 +-98 +-98 +-98 +-97 +-98 +-98 +-81 +-80 +-81 +-81 +-81 +-68 +-98 +-97 +-91 +-81 +-81 +-81 +-81 +-67 +-81 + diff --git a/noise/some_noise.txt b/noise/some_noise.txt new file mode 100644 index 0000000..6cf49c8 --- /dev/null +++ b/noise/some_noise.txt @@ -0,0 +1,40 @@ +-39 +-98 +-72 +-98 +-99 +-88 +-94 +-98 +-72 +-98 +-39 +-98 +-39 +-98 +-99 +-98 +-94 +-72 +-98 +-88 +-39 +-98 +-72 +-88 +-99 +-98 +-94 +-98 +-94 +-88 +-39 +-98 +-98 +-98 +-99 +-98 +-94 +-98 +-39 +-98 \ No newline at end of file From a2e2d7fdf072f3a2121814faf76bd7a96e0ddfb1 Mon Sep 17 00:00:00 2001 From: jmenjivar4 Date: Sat, 2 May 2020 15:40:34 -0700 Subject: [PATCH 28/28] Updates to window --- Node.nc | 9 ++++----- TestSim.py | 29 ++++++++++++++++++----------- includes/packet.h | 2 +- lib/modules/TransportP.nc | 25 +++++++++++++++++-------- 4 files changed, 40 insertions(+), 25 deletions(-) diff --git a/Node.nc b/Node.nc index f5866ee..b17bf7d 100644 --- a/Node.nc +++ b/Node.nc @@ -36,6 +36,8 @@ implementation{ pack sendPackage; am_addr_t nodes[10]; uint16_t SEQ_NUM=1; + char toSend[] = {'A','B','C','D','E','F','G','H','I', + 'J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'}; // Prototypes void makePack(pack *Package, uint16_t src, uint16_t dest, uint16_t TTL, uint16_t seq, uint16_t protocol, uint8_t *payload, uint8_t length); @@ -201,17 +203,14 @@ implementation{ //call Transport.write(srcPort,payload,i); if(call Transport.connect(mySocket, &destAddr)) return; - //save the value here into a holder to read for bugtesting - //for(i=0; payload[i] != '\0'; i++ ){} - //dbg(TRANSPORT_CHANNEL, "sizeof(payload): %d\n", i); //dbg(TRANSPORT_CHANNEL, "payload: %s\n", payload); - - //AmountWritten = call Transport.write(srcPort,payload,i); + //call Transport.write(srcPort,toSend,26); + //add the payload to a que to be cut up and packaged to be sent after connection diff --git a/TestSim.py b/TestSim.py index a0b5310..d597e67 100644 --- a/TestSim.py +++ b/TestSim.py @@ -161,6 +161,8 @@ def cmdServerRead(self, address, port, bufflen): print 'Server Calling Read for', address, port; self.sendCMD(self.CMD_SERVER_READ, address, "{0}{1}".format(chr(port), chr(bufflen))); + # def cmdServerChat(self, address, port, bufflen) + def main(): s = TestSim(); s.runTime(10); @@ -190,30 +192,35 @@ def main(): s.runTime(1); #s.runTime(126); #Fastest time with a "151 | call advertiseTimer.startOneShot(6000);" - s.runTime(250); - - # for i in range(1, 19): + s.runTime(300); + #for i in range(1, 19): # s.routeDMP(i); # s.runTime(1); - # s.runTime(10); + #s.runTime(10); #s.ping(2, 6, "Hi!"); #s.runTime(100); - #####***TCP Test***##### #s.ping(1, 6, "I'll have you know I gr"); s.cmdTestServer(6,10); #[adress] [port] - s.runTime(400); #no noise 100, some noise 100 + s.runTime(40); #no noise 100, some noise 100 # s.ping(1, 6, "I'll have you know I gr"); # s.runTime(10); # s.ping(1, 6, "I'll have you know I gr"); # s.runTime(10); # s.ping(1, 6, "I'll have you know I gr"); - s.cmdTestClient(1,8,6,10, "Hello, bozo!"); #[selfAdress] [srcPort] [dest] [destPort] [transfer] - s.runTime(500); #no noise 350, some noise 350 - s.cmdServerRead(6,10,12); #[dest][destPort][length] - s.runTime(300); #no noise 300, some noise 300 + s.cmdTestClient(1,8,6,10, "Hello,_bozo!"); #[selfAdress] [srcPort] [dest] [destPort] [transfer] + s.runTime(200); #no noise 350, some noise 350 + s.cmdServerRead(6,10,26); #[dest][destPort][length] + s.runTime(1); #no noise 300, some noise 300 s.cmdClientClose(1,8,6,10); #[client adress] [srcPort] [dest] [destPort] - s.runTime(200); #no noise 200, some noise 200 + s.runTime(100); #no noise 200, some noise 200 + + +###***Chat Client and Server Test*** ### + + + + #####***NEIGHBOR DISCOVERY TEST***##### # s.runTime(50); diff --git a/includes/packet.h b/includes/packet.h index 7cbb518..f6bde97 100644 --- a/includes/packet.h +++ b/includes/packet.h @@ -11,7 +11,7 @@ enum{ PACKET_HEADER_LENGTH = 8, - TCP_HEADER_LENGTH = 7, + TCP_HEADER_LENGTH = 10, // PACKET_HEADER_LENGTH = sizeof(pack), PACKET_MAX_PAYLOAD_SIZE = 28 - PACKET_HEADER_LENGTH, TCP_PACKET_MAX_PAYLOAD_SIZE = PACKET_MAX_PAYLOAD_SIZE - TCP_HEADER_LENGTH, diff --git a/lib/modules/TransportP.nc b/lib/modules/TransportP.nc index 48db942..0ace01b 100644 --- a/lib/modules/TransportP.nc +++ b/lib/modules/TransportP.nc @@ -87,6 +87,7 @@ module TransportP{ tcpHeader sendPackageTCP; pack sendIPpackage; uint8_t AW; + tcpHeader* tempTCP; sendTCPInfo *info = call SendQueue.head(); socket_t socKey = info->socKey; @@ -95,6 +96,7 @@ module TransportP{ uint8_t ack = info->ack; pack* payload = &(info->payload); uint8_t length = info->length; + socket_store_t * socketHolder = call Connections.getPointer(socKey); @@ -140,7 +142,9 @@ module TransportP{ dbg(TRANSPORT_CHANNEL,"\tlength %d\n", length); dbg(TRANSPORT_CHANNEL,"sendPackageTCP.Len %d\n", sendPackageTCP.Len); // dbg(TRANSPORT_CHANNEL,"(sendIPpackage.package).Len %d\n", (sendIPpackage.payload).Len); - + + tempTCP = &(sendIPpackage.payload); + dbg(TRANSPORT_CHANNEL,"\tpayload of send line 143: %s\n", tempTCP->payload); call Sender.send(sendIPpackage, call DistanceVectorRouting.GetNextHop(socketHolder->dest.addr)); @@ -400,7 +404,7 @@ module TransportP{ TCB.src = fd; TCB.dest = *addr; TCB.state = CLOSED; - TCB.effectiveWindow = 5; //NOTE:We Need to replace this value + TCB.effectiveWindow = 1; //NOTE:We Need to replace this value TCB.TTD = 0; for (i = 0; i < SOCKET_BUFFER_SIZE; i++) { TCB.sendBuff[i] = '\0'; @@ -502,7 +506,7 @@ module TransportP{ uint8_t seq; tcpHeader* mySegment = (tcpHeader*) myMsg->payload; socket_store_t * curConection = call Connections.getPointer(mySegment->Dest_Port); - + dbg(TRANSPORT_CHANNEL, "Transport.receive() Called\n"); dbg(TRANSPORT_CHANNEL, "STATE: %d | FLAG: %d\n", curConection->state, mySegment->Flags); @@ -510,7 +514,7 @@ module TransportP{ // printSocket(mySegment->Dest_Port); dbg(TRANSPORT_CHANNEL, "INCOMING SEQ #: %d INCOMING ACK #: %d\n",mySegment->Seq_Num,mySegment->Acknowledgment); - + dbg(TRANSPORT_CHANNEL, "mySegment->payload: %s\n", mySegment->payload); // //TO_DO: add check here to see if the packet has been seen before //this means the sent packet was lost resend it again and extend the close time @@ -712,11 +716,11 @@ module TransportP{ else{ // has data //Only need to ipmlement this if you send more than one packet of data //update socket - dbg(TRANSPORT_CHANNEL, "Message Recived line 715:%s and mySegment->len %d \n",mySegment->payload, mySegment->Len); + dbg(TRANSPORT_CHANNEL, "Message Recived line 719:%s and mySegment->len %d \n",mySegment->payload, mySegment->Len); readDataToBuff(curConection->src, mySegment, mySegment->Len); //returns amount put into buffer - dbg(TRANSPORT_CHANNEL, "curConection->src 719:%d and mySegment->len %d \n",curConection->src, mySegment->Len); + dbg(TRANSPORT_CHANNEL, "curConection->src 723:%d and mySegment->len %d \n",curConection->src, mySegment->Len); seq = curConection->lastAck + 1; send_buff(curConection->src, ACK, curConection->lastAck + 1, curConection->lastRcvd + 1, Empty, 0); //update this curConection->nextExpected = seq + 1; @@ -776,9 +780,14 @@ module TransportP{ command error_t Transport.receiveBuffer(pack* package){ if(!call Pool.empty()){ pack *input; + //tcpHeader *TCPholder = package; input = call Pool.get(); + + //dbg(TRANSPORT_CHANNEL, "TCPholder->payload: %s\n", TCPholder->payload); memcpy(input, package, PACKET_MAX_PAYLOAD_SIZE); + //dbg(TRANSPORT_CHANNEL, "Transport.receive() Called\n"); + // Now that we have a value from the pool we can put it into our queue. // This is a FIFO queue. call Queue.enqueue(input); @@ -813,7 +822,7 @@ module TransportP{ } */ - memcpy (holder, buff, bufflen ); + memcpy (holder, buff, bufflen); dbg(TRANSPORT_CHANNEL, "holder after memcpy (holder, buff, bufflen); has:%s the value of bufflen is %d \n", holder, bufflen); // strcat(holder, socketHolder->rcvdBuff); @@ -822,7 +831,7 @@ module TransportP{ // memcpy(socketHolder->rcvdBuff, holder, size); - dbg(TRANSPORT_CHANNEL, "line 811 socketHolder->rcvdBuff:%s\n", socketHolder->rcvdBuff ); + dbg(TRANSPORT_CHANNEL, "line 834 socketHolder->rcvdBuff:%s\n", socketHolder->rcvdBuff ); return buffSize; }