Exemplo n.º 1
0
int IoTkit::receive(void (*f)(char*)) {
  char packetBuffer[UDP_TX_PACKET_MAX_SIZE];
  int packetSize = _udp->parsePacket();
  while (packetSize) {
    // read the packet into packetBufffer
    _udp->read(packetBuffer,UDP_TX_PACKET_MAX_SIZE);
    packetBuffer[packetSize] = NULL;
    char *done = packetBuffer;
    Serial.println(done);
    if (checkPacket(done) == 0) {
      if (checkJSON(done)) {
        Serial.print("Good JSON Command from Server: ");
        Serial.println(done);
        (*f)(done);
      }
      else {
        Serial.println("Bad JSON Command from server.");
      }
    }
    else {
      Serial.println("No \\n at the end of command from server, or exceeded buffer limit. ");
      Serial.println(packetSize);
    }
    packetSize = _udp->parsePacket();
  }
}
int main(int argc, char** argv) {
    unsigned char bigBuffer[100000];
    int numBytes=0,count=0,checkVal;
    GenericHeader_t *gHdr;
    
    if(argc!=2) {
	printf("Usage:\t%s <packetFile>\n",basename(argv[0]));
	return 0;
    }

    numBytes=genericReadOfFile(bigBuffer,argv[1],100000);
    printf("Read %d bytes from %s\n",numBytes,argv[1]);
//    for(count =0; count<numBytes;count++) {
//	printf("count %d -- %x\n",count,(bigBuffer[count]&0xff));
//    }
    checkVal=checkPacket(bigBuffer);
    if(checkVal==0) {
	gHdr = (GenericHeader_t*) &bigBuffer[0];	
	printf("Got %s\n",packetCodeAsString(gHdr->code));
	count+=gHdr->numBytes;
    }
    else {
	printf("Problem with packet -- checkVal==%d\n",checkVal);
	return 1;
//	    count+=gHdr->numBytes;
    }
    
    return 0;
}
Exemplo n.º 3
0
std::vector<int> DeviceInfo::getDeviceDescriptor() {
	std::vector<int> devDescriptor;		// Endpoint 0 exists on all devices
	int maxEID = EIDS_PER_VECTOR;

	// Query eid 0 for the first device descriptor. Repeat until there is no further descriptor available
	hxb_packet_query query = pFactory->query(0, false);
	network->sendPacket(ipAddress, HXB_PORT, (char*)&query, sizeof(query));
	network->receivePacket(true);

	// Extract data from recv. packet
	// Enpoints are stored in a EIDS_PER_VECTOR-bit vector where 1 indicates an used and 0 an unused endpoint.
	hexabus::PacketHandling *pHandler = new hexabus::PacketHandling(network->getData());
	checkPacket(pHandler);
	hxb_value val = pHandler->getValue();
	uint32_t eidVector = *((uint32_t*)&(val.data));
	delete pHandler;
	
	for(int i = 0;i < maxEID;i++) {
		if(eidVector & 1<<i) {
			
			if(i + 1 == maxEID) {
				// There are more endpoints
				maxEID += EIDS_PER_VECTOR;
				query = pFactory->query(i, false);
				network->sendPacket(ipAddress, HXB_PORT, (char*)&query, sizeof(query));
				network->receivePacket(true);
				
				// Extract the next vector
				pHandler = new hexabus::PacketHandling(network->getData());
				checkPacket(pHandler);
				val = pHandler->getValue();
				eidVector = *((uint32_t*)&(val.data));
				delete pHandler;
			} else {
					// Endpoint is used ~> Add it to our List
					devDescriptor.push_back(i);
			}
		}
	}

	return devDescriptor;
}
Exemplo n.º 4
0
int appRead(char * port, char * filename) {
    printf("[appSend] Connecting to Sender...n");
    if(llopen(port, RECEIVER) < 0)
        return -1;

    char packet[256];
    pingu.size = 0;
    int psize = 0;
    int tsize = 0;



    printf("[appRead] CONNECTEDn");

    do {
        if(llread(packet)!=-1) {

            if(checkPacket(packet, &psize) != 0) {
                printf("[appRead] Unrecognized packet typen");
                return -1;
            }
            else {
                if(appDef.control == START_PAC) {
                    FILE *p = fopen(filename, "wb");
                    if( p < 0 ) {
                        printf("[appRead] Error opening output filen");
                        return -1;
                    }
                    pingu.p = p;
                }
                else if(appDef.control == DATA_PAC) {
                    fwrite(packet+4, sizeof(char), psize, pingu.p);
                    tsize += psize;
                }
                else if(appDef.control == END_PAC) {
                    //
                    break;
                }
            }

        }
    } while((pingu.size != tsize) || (appDef.control != END_PAC));

    printf("[appRead] Bytes read: [ %d / %d ]n", tsize, pingu.size);

    printf("[appRead] Closing connection...n");

    llclose(appDef.status);
    printf("[appSend] Exiting Application!n");

    return 0;
}
Exemplo n.º 5
0
/* Request packet from slaver
 * @param: none
 * @return: status of returned packet. 
 * 		0 - No packet returned
 * 		1 - Packet error
 * 		2 - packet received successfully
 * @api
 */
uint8_t Modbus::response()
{
	
	checkPacket();

	if (_response_flag)
	{
		_response_flag = false;
		return 1;	//if have any response
	}
	else
		return 0;

}
void inboundBufferMaintenance(void) {
    int i;
    for ( i = 0; i < RAW_PACKET_BUFFER_SIZE; i++ ) {
        if ( rawPacketStatus[i] == READY && checkPacket(rawPackets[i]) ) {
            struct command* cmd = createCommand( rawPackets[i] );
            if ( cmd ) {            // create command was successful ?
                pushCommand( cmd ); // queue it up
                rawPacketStatus[i] = EMPTY;         // buffer is now good for writing another packet
            }
        }
    }
    if ( rawPacketStatus[0] == EMPTY ) {
        rawPacketStatus[0] = BUSY;
    }
}
Exemplo n.º 7
0
EndpointInfo DeviceInfo::getEndpointInfo(int eid) {
	// Create a query to the specified endpoint. 
	hxb_packet_query packet = pFactory->query(eid, true);
	
	network->sendPacket(ipAddress, HXB_PORT, (char*)&packet, sizeof(packet));
	network->receivePacket(true);
	
	// Extract Data and check if the endpoint exists.
	
	hexabus::PacketHandling *pHandler = new hexabus::PacketHandling(network->getData());
	checkPacket(pHandler);	
	// Everything went fine
	EndpointInfo epInfo(eid, pHandler->getString(), pHandler->getDatatype(), false);
	delete pHandler;
	return epInfo;
	
}
Exemplo n.º 8
0
void Modbus::update()
{
	if (_transmission_ready_flag)
	{
		static uint8_t packet_index = 0;
		unsigned int failed_connections = 0;
	
		unsigned char current_connection;
	
		do
		{		
			if (packet_index == _total_packets) // wrap around to the beginning
				packet_index = 0;
		
			// proceed to the next packet
			_packet = &_packet_array[packet_index];
		
			// get the current connection status
			current_connection = _packet->connection;
		
			if (!current_connection)
			{		
				// If all the connection attributes are false return
				// immediately to the main sketch
				if (++failed_connections == _total_packets)
					return;
			}
		
			packet_index++;
			
		} while (!current_connection); // while a packet has no connection get the next one
		
		constructPacket();
	}

	//check response packet
	checkPacket();

	status();
}
Exemplo n.º 9
0
void runCommsFSM(char data)
{
    static CommsState_t state = WAITING_FOR_START_1;
    static uint8_t packetBuffer[MAX_PACKET_SIZE];
    static Packet_t* packet = (Packet_t*)packetBuffer;
    static uint32_t packetIdx; 

    switch(state)
    {
        case WAITING_FOR_START_1:
        {
            packetIdx = 0;
            if (data == START_BYTE_1)
            {
                state = WAITING_FOR_START_2;
                packetBuffer[0] = data;
                packetIdx = 1;
            }
        }
        break;

        case WAITING_FOR_START_2:
        {
            if (data == START_BYTE_2)
            {
                state = WAITING_FOR_HEADER;
                packetBuffer[1] = data;
                packetIdx = 2;
            } else {
                state = WAITING_FOR_START_1;
            }
        }
        break;

        case WAITING_FOR_HEADER:
        {
            packetBuffer[packetIdx] = data;
            packetIdx++;
            if (packetIdx == sizeof(PacketHeader_t))
            {
                if (packetIdx == packet->header.packetLen)
                {
                    checkPacket(packet);
                    runPacket(packet);
                    sendResponse(packet);
                    state = WAITING_FOR_START_1;
                } else {
                    state = WAITING_FOR_DATA;
                }
            }
        }
        break;

        case WAITING_FOR_DATA:
        {
            packetBuffer[packetIdx] = data;
            packetIdx++;
            if (packetIdx == packet->header.packetLen)
            {
                checkPacket(packet);
                runPacket(packet);
                sendResponse(packet);
                state = WAITING_FOR_START_1;
            } else if (packetIdx >= MAX_PACKET_SIZE) {
                state = WAITING_FOR_START_1;
            }
        }
        break;

        default:
        {
            state = WAITING_FOR_START_1;
        }
        break;
    }

}
Exemplo n.º 10
0
void csp3(void *arg)
{
	int errorCode, numBytesRead, i;
	ubyte bytes[B];
	int numBytesPreviouslyRead = 0;
	struct timeval timeout;
	fd_set readfs;

	gettimeofday(&lastPktTime, NULL);
	FD_SET(fd, &readfs);

	/* Reading loop */
	while (TRUE)
	{
		pthread_mutex_lock( &endFlagMutex);
		if (terminationFlag == TRUE) break;
		pthread_mutex_unlock( &endFlagMutex);
		timeout.tv_sec = 2;
		timeout.tv_usec = 0;
		errorCode = select(fd+1, &readfs, NULL, NULL, &timeout);
		if (errorCode==0)
		{
			fprintf(stderr,"Timed out at select()\n");
		}
		else if (errorCode==-1)
		{
			fprintf(stderr, "Problem with select(): %s\n", strerror(errno));
			//endProgram();
			exit(EXIT_FAILURE);
		}

		numBytesRead = read(fd, &bytes, B-numBytesPreviouslyRead);
		if (numBytesRead==-1)
		{
			fprintf(stderr, "Problem with read(): %s\n", strerror(errno));
			//endProgram(); //TODO See if it is possible to implement this instead of just exit()
			exit(EXIT_FAILURE);

		}
		else
		{
			for (i = 0; i < numBytesRead; i++) packet[numBytesPreviouslyRead+i] = bytes[i];
			numBytesPreviouslyRead += numBytesRead;
			if (numBytesPreviouslyRead==B) {  //packet complete!
				if (checkPacket())
				{
					extractPacket();
					reflexes();
					ensureTransmitted();
					pthread_mutex_lock( &pktNumMutex );
					pktNum++;
					pthread_mutex_unlock( &pktNumMutex );
					numBytesPreviouslyRead = 0;
				}
				else
				{
					printf("misaligned packet.\n");
					//TODO Does this have a range error?
					for (i = 1; i<B; i++) packet[i-1] = packet[i];
					numBytesPreviouslyRead--;
				}
			}
		}
	}
}
Exemplo n.º 11
0
void* UserAgent::run(void* arg) {
	common = (Common *)arg;

	init(0);

	while(common->go) {
		memo = (Memo*)common->signalQ->waitForData(waitMSec);

		if(memo) switch(memo->code) {
			case VIVOCE_SIP_INVITE:
				if(state==SIP_UA_DISCONNECTED) {
					//printf("\n\tSending INVITE....");
					name = strtok_r(memo->bytes,"@",&temp);
					remoteId = (char*)malloc(strlen(name)+1);
					sprintf(remoteId,"%s",name);

					name = strtok_r(NULL,":",&temp);
					if(name) {
						remoteHost = (char*) malloc(strlen(name)+1);
						sprintf(remoteHost,"%s",name);
						name=name = strtok_r(NULL,":",&temp);
						if(name)
							remoteSipPort = atoi(name);
						else
							remoteSipPort = VIVOCE_SIP_PORT;
						sendInvite();
						common->reset();
					}
					else {
						printf("\n\tSIP: Malformed URI");
						common->sipRmg->releaseMemo(memo);
					}
				}
				else
					common->sipRmg->releaseMemo(memo);
				break;

			case VIVOCE_SIP_BYE:
				if(common->isConnected) {
					common->isConnected=0;
					printf("\n\tDisconnecting....");
					rptCount=0;
					sendBye();
				}
				else
					common->sipRmg->releaseMemo(memo);
				break;

			case VIVOCE_SIP_ACCEPT:
				if(state == SIP_UA_RCVD_INV) {
					//printf("\n\tSending OK....");
					sendOk();
					state = SIP_UA_ACCEPTED;
					common->isRinging=0;
				}
				else
					common->sipRmg->releaseMemo(memo);
				break;
			case VIVOCE_SIP_REJECT:
				if(state == SIP_UA_RCVD_INV) {
					//printf("\n\tSending DECLINE....");
					sendDecline();
					common->isRinging=0;
				}
				else
					common->sipRmg->releaseMemo(memo);
				break;

			case VIVOCE_SIP_RCVD:
			//incoming!!
			if(common->verbose) {
				printf("\n\tINFO: SIP Msg Recv=%d bytes:\n%s", memo->data1,memo->bytes);
			}
			sipPackRecv->reset();
			ret = SIPHandler::read(memo->bytes,
								memo->data1,
								sipPackRecv);
			if(ret<0) {
				printf("\n\tSIP: Error in parsing SIP packet");
			}
			else {
			if((!sipPackRecv->isRequest)
				&& (sipPackRecv->responseCode!=SIP_RESPONSE_OK)) {
				printf("\n\tSIP: Received response code %d.",
					sipPackRecv->responseCode);
			}
			switch(state) {
				case SIP_UA_DISCONNECTED:
				if((sipPackRecv->isRequest)
					&& (sipPackRecv->requestCode==SIP_METHOD_INV)) {
					checkPacket();
					if(discard) {
						printf("\n\tSIP: Incorrect SDP content: discarding");
						common->sipRmg->releaseMemo(memo);
						checkSrc=false;
					}
					else {
						callId = sipPackRecv->callId;
						callIdHost = (char*)malloc(strlen(sipPackRecv->callIdHost)+1);
						sprintf(callIdHost, "%s", sipPackRecv->callIdHost);
                        //memory leak in these mallocs, but fixing them with realloc causes segfaults! for now, waste these ~100 bytes...
						remoteId = (char*)malloc(strlen(sipPackRecv->contactUri.id)+1);
						sprintf(remoteId, "%s", sipPackRecv->contactUri.id);

						remoteHost = (char*)malloc(strlen(sipPackRecv->contactUri.host)+1);
						sprintf(remoteHost,"%s",
							sipPackRecv->contactUri.host);
						printf("\n\tSIP: Recvd invite from %s at %s!!!",
							sipPackRecv->contactUri.id,
							sipPackRecv->contactUri.host);
						printf("\n\tRing!!!");
						sendRinging();
						waitMSec=2500;
						state = SIP_UA_RCVD_INV;
						defaultAction = SIP_SEND_RING;
					}
				}
				else
					common->sipRmg->releaseMemo(memo);	//else discard
				break;

				case SIP_UA_SENT_INV:
				if((!sipPackRecv->isRequest)
					&& (sipPackRecv->callId == callId)
					&& (!strcmp(callIdHost,sipPackRecv->callIdHost))) {

					if(sipPackRecv->responseCode==SIP_RESPONSE_RING) {
						printf("\n\tSIP: Ringing callee....");
						common->isRinging=1;
						waitMSec=5000;
						defaultAction = SIP_CONN;
						//display ringing for some time
						common->sipRmg->releaseMemo(memo);
					}
					else if(sipPackRecv->responseCode==SIP_RESPONSE_BUSY) {
						printf("\n\tSIP: Callee is Busy! Try again later");
						waitMSec=500;
						defaultAction = SIP_DISCONN;
						common->sipRmg->releaseMemo(memo);
						common->isRinging=0;
					}
					else if(sipPackRecv->responseCode==SIP_RESPONSE_DECLINE) {
						printf("\n\tSIP: Callee has declined to accept your call");
						waitMSec=500;
						defaultAction = SIP_DISCONN;
						common->sipRmg->releaseMemo(memo);
						common->isRinging=0;
					}
					else if(sipPackRecv->responseCode==SIP_RESPONSE_OK) {
						checkPacket();
						if(discard) {
							printf("\n\tSIP: Incorrect SDP content: discarding");
							common->sipRmg->releaseMemo(memo);
							checkSrc=false;
						}
						else {
							if(common->verbose) {
								printf("\n\tINFO: Listening for RTP/RTCP on ports %d/%d",
									remoteRtpPort,
									remoteRtcpPort);
							}
							UdpBase::initRemoteAddr(common,
                    								remoteHost,
                    								remoteRtpPort,
                    								remoteRtcpPort,
                    								0);
							printf("\n\tSIP: Connected!!!");
							sendAck();
							common->isRinging=0;
						}
					}
					else
						checkSrc=true;
				}
				else
					checkSrc=true;
				break;

				case SIP_UA_SENT_BYE:
				if(!sipPackRecv->isRequest) {
					if(sipPackRecv->responseCode==SIP_RESPONSE_OK) {
						printf("\n\tSIP: Disconnect complete.");
						state = SIP_UA_DISCONNECTED;
						cleanup();
						defaultAction = SIP_NONE;
					}
					common->sipRmg->releaseMemo(memo);
				}
				else
					checkSrc=true;
				break;

				case SIP_UA_ACCEPTED:
				if(sipPackRecv->isRequest
					&& (sipPackRecv->requestCode== SIP_METHOD_ACK)
					&& (sipPackRecv->callId == callId)
					&& (!strcmp(callIdHost, sipPackRecv->callIdHost))) {
					//printf("\n\tSIP: Acknowledged....");
					common->isConnected = 1;
					common->rtpMgr->init(RTP_PAYLOAD_TYPE_ADPCM, const_cast<char*>("stats"));
					waitMSec=2500;
					defaultAction = SIP_NONE;
					state = SIP_UA_IN_CALL;
					common->sipRmg->releaseMemo(memo);
					common->isRinging=0;
				}
				else
					checkSrc=true;
				break;

				case SIP_UA_REJECTED:
				if(sipPackRecv->isRequest
					&& (sipPackRecv->requestCode== SIP_METHOD_ACK)
					&& (sipPackRecv->callId == callId)
					&& (!strcmp(callIdHost,sipPackRecv->callIdHost))) {
					//printf("\n\tSIP: Acknowledged....");
					common->isConnected=0;
					waitMSec=500;
					defaultAction = SIP_DISCONN;
					common->sipRmg->releaseMemo(memo);
					common->isRinging=0;
				}
				else
					checkSrc=true;
				break;

				case SIP_UA_IN_CALL:
				if(sipPackRecv->isRequest
					&& (sipPackRecv->requestCode==SIP_METHOD_BYE)
					&& (sipPackRecv->callId == callId)) {
					//printf("\n\tSending OK for BYE....");
					printf("\n\tSIP: Disconnected by peer.");
					sendOk();
					common->isConnected=0;
					waitMSec=2500;
					defaultAction = SIP_DISCONN;
					state = SIP_UA_DISCONNECTED;
				}
				else
					checkSrc=true;
				break;

				default:
					checkSrc=true;
				break;
			}
			if(checkSrc) {
				checkSrc=false;
				if(sipPackRecv->callId != callId) {
					//printf("\n\tSending BUSY");
					UdpBase::initTempRemoteAddr(common,
                        						sipPackRecv->contactUri.host,
                        						remoteSipPort);
					sendBusy();
				}
				else
					common->sipRmg->releaseMemo(memo);
			}
			break;
			}
			break;

			default:
				printf("\n\tSIP: In invalid state! %d",state);
				common->sipRmg->releaseMemo(memo);
				break;

			case VIVOCE_RESPOND:
				printf("\n\tUser Agent active - %d",state);
				common->sipRmg->releaseMemo(memo);
				break;
		}
		else
			doDefaultAction();

	}
	printf("UserAgent stopped. ");
	return NULL;
}
Exemplo n.º 12
0
// reciever			
int main( int argc, char **argv )
{
	int min=0,sec =0 ,msec =0;
	struct sockaddr_in serv_addr;
	struct sockaddr_in clnt_addr;
	int serv_sock;
	int clnt_addr_size;


	int result = 0;
	uint16_t check;
	int r_seq = 0, ack = 1, pre_seq=0;
	int correct_pkt =0, dup_pkt=0, rcv_pkt=0;
	int rcv_byte=0;
	struct timeval ti1,ti2;
	int read_byte;
	int rcv_start =0, rcv_end=0;

	DEBUG_ON = 1; 	// print debug message

	if(argc != 2){
		printf("Usage : %s <port>\n", argv[0]);
		exit(1);
	}

	if ((serv_sock = socket( AF_INET, SOCK_DGRAM, 0 )) < 0)
		error(1, errno, "socket creation failed" );

	memset(&serv_addr, 0 , sizeof(serv_addr));
	serv_addr.sin_family = AF_INET;
	serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	serv_addr.sin_port = htons(atoi(argv[1]));	

	if(bind(serv_sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1)
		error(1, errno, "socket bind failed");

	while(1) {
		memset(&dataPacket,0,sizeof(dataPacket));
		memset(&controlPacket,0,sizeof(controlPacket));

		clnt_addr_size = sizeof(clnt_addr);	
		read_byte = recvfrom(serv_sock, &dataPacket, sizeof(dataPacket), 0, (struct sockaddr *)&clnt_addr, &clnt_addr_size);
		debug("========================================================\n");
		debug("[DATA] rcv Packet: type[%d] seq[%d] len[%d] checksum[%x]\n", dataPacket.header.type, r_seq, dataPacket.header.len, dataPacket.header.checksum);

		if(read_byte > 0){
			if(rcv_start ==0){
				gettimeofday(&ti1,NULL);
				rcv_start =1;
			}

			if(dataPacket.header.type == DATA){ // DATA 인경우 잘못된 전송 혹은 제대로된 전송
				if(checkPacket(&dataPacket, r_seq)){
					connect(serv_sock, (struct sockaddr *)&clnt_addr,clnt_addr_size);
					make_cpkt(&controlPacket, ACK, ack);
					write(1, dataPacket.data,dataPacket.header.len-HEADER_LEN);
					if(udt_send(serv_sock, &controlPacket, sizeof(controlPacket)) <0 )
						error(1, errno, "ACK udt_send error\n");

					debug("[ACK] send Packet: type[%d] seq[%d] len[%d] checksum[%x]\n", controlPacket.header.type, ack, controlPacket.header.len, controlPacket.header.checksum);
					correct_pkt++;
					rcv_pkt++;
					
					rcv_byte=rcv_byte + dataPacket.header.len - HEADER_LEN;
					pre_seq=r_seq;
					r_seq++;
					ack = r_seq+1;
				}
				else{
					if(dataPacket.header.seq == pre_seq) // error 인 duplicate 도 포함시킨다
						dup_pkt++;

					connect(serv_sock, (struct sockaddr *)&clnt_addr,clnt_addr_size);
					make_cpkt(&controlPacket, ACK, r_seq);
					if(udt_send(serv_sock, &controlPacket, sizeof(controlPacket)) <0 )
						error(1, errno, "ACK udt_send error\n");
					rcv_pkt++;
					debug("[ReACK] send Packet: type[%d] seq[%d] len[%d] checksum[%x]\n", controlPacket.header.type, r_seq, controlPacket.header.len, controlPacket.header.checksum);
				}
			}		
			else if(dataPacket.header.type == END){ // END 인경우 잘못된 전송 혹은 제대로된 전송
				if(checkCPacket(&dataPacket, r_seq)){
					if(rcv_end == 0){
						gettimeofday(&ti2,NULL);
						if((ti2.tv_sec - ti1.tv_sec)>0){
							min = (ti2.tv_sec - ti1.tv_sec)/60;
							sec = (ti2.tv_sec - ti1.tv_sec)%60;
						}
						else if((ti1.tv_sec-ti2.tv_sec)>0){
							min = (ti1.tv_sec - ti2.tv_sec)/60;
							sec = (ti1.tv_sec - ti2.tv_sec)%60;
						}
						if((ti2.tv_usec - ti1.tv_usec)>0)
							msec = (ti2.tv_usec - ti1.tv_usec)/1000;
						else if((ti1.tv_usec - ti2.tv_usec)>0)
							msec = (ti1.tv_usec - ti2.tv_usec)/1000;

						debug("===============================================================\n");
					//	debug("start %d usec\n", ti1.tv_usec);
					//	debug("end% d usec\n", ti2.tv_usec);
						debug("===============================================================\n");
						debug("%d of DATA packets received (including retransmitted packets)\n",rcv_pkt);
						debug("%d of duplicated DATA packets received\n",dup_pkt);
						debug("%d of DATA packets correctly received\n",correct_pkt);
						debug("%d of bytes correctly received\n",rcv_byte);
						debug("Time duration : %d min %d sec %d msec\n",min,sec,msec);
						debug("Troughput : %d (byte/second)\n",rcv_byte/(ti2.tv_sec - ti1.tv_sec));
						debug("===============================================================\n");

						rcv_end =1;

					}
					connect(serv_sock, (struct sockaddr *)&clnt_addr,clnt_addr_size);
					make_cpkt(&controlPacket, END, ack);
					if(udt_send(serv_sock, &controlPacket, sizeof(controlPacket)) <0 )
						error(1, errno, "ACK udt_send error\n");
					debug("[END] send Packet: type[%d] seq[%d] len[%d] checksum[%x]\n", controlPacket.header.type, ack, controlPacket.header.len, controlPacket.header.checksum);
					return 0;
				}
				else{
					connect(serv_sock, (struct sockaddr *)&clnt_addr,clnt_addr_size);
					make_cpkt(&controlPacket, ACK, r_seq);
					if(udt_send(serv_sock, &controlPacket, sizeof(controlPacket)) <0 )
						error(1, errno, "ACK udt_send error\n");
					debug("[ReACK] send Packet: type[%d] seq[%d] len[%d] checksum[%x]\n", controlPacket.header.type, r_seq, controlPacket.header.len, controlPacket.header.checksum);
				}
			}
		}

		if(read_byte < 0)
			error(1, errno, "recvfrom failed");

	}
}