C++ UdpSocket::pollRecvFrom方法代码示例

int clientSlidingWindow( UdpSocket &sock, const int max, int message[], int windowSize ) {
	cerr << "Sliding-window test:" << endl;
	int lar = -1;										// last acknowledgment received
	int seq = 0;										// current seq #
	int retransmits = 0;
	if(sock.pollRecvFrom() > 0) {						// check for any old acks
		sock.recvFrom( ( char * ) message, MSGSIZE );		// clean out the socket
	}
	vector<int> window(windowSize);
	for(int i = 0; i < windowSize; i++) { 				//init window
		window[i] = -1;
	}
	Timer t;
	while( seq < max) {
		while(seq - lar <= windowSize && seq < max) {		// while seq is within window
			message[0] = seq;									// append seq to message
			sock.sendTo((char*) message, MSGSIZE);				// send message
			seq++;												// increment seq
		}
		long lap;
		t.start();											// timer start
		while ((lap = t.lap()) < 1500) {
			if(sock.pollRecvFrom() > 0) {					// while not timed out
				getAck(lar, sock);								// check for an ack
				break;
			}
		}
		if (lap >=1500) {									// if no ack
			seq = lar+1;										// reset sequence #
			retransmits++;
		}
	}
	return retransmits;
}

int clientStopWait( UdpSocket &sock, const int max, int message[] ) {
	cerr << "client: stop-and-wait test:" << endl;

	int retransmits = 0;

	// transfer message[] max times
	for ( int i = 0; i < max; ) {
		message[0] = i;                           
		sock.sendTo( ( char * )message, MSGSIZE );
		
		timer.start();
		
		// If the client cannot receive an ack immediately, start a timer
		while (sock.pollRecvFrom( ) <= 0) {

			// If a timeout has happened, client must resend the same message
			if ( timer.lap() >= TIMEOUT ) {
				retransmits++;
				break;
			}
		}
		// Did not retransmit;
		if ( timer.lap() < TIMEOUT ) {
			// Receive ACK from server
			sock.recvFrom( ( char * ) message, MSGSIZE );
			i++;
		}
	}
	return retransmits;
}

void serverReliable( UdpSocket &sock, const int max, int message[] ) {
	cerr << "server stop and wait:" << endl;

	// receive message[] max times
	int seq;
	while(seq != max - 1) {
		while( sock.pollRecvFrom() <=0 ){}				// pause until message
		sock.recvFrom( ( char * ) message, MSGSIZE );   // udp message receive
		seq = *message;									// get the seq # from beginning of msg
		sock.ackTo((char*)&seq, sizeof(seq));
	}
}

int clientStopWait( UdpSocket &sock, const int max, int message[] ) {
	cerr << "Stop-and-wait test:" << endl;
	Timer t;
	int retransmits = 0;
	for ( int i = 0; i < max; i++ ) {					// transfer message[] max times
		message[0] = i;                            		// message[0] has a sequence #
		sock.sendTo((char*) message, MSGSIZE);			// send message
		t.start();										// start timer
		long lap;
		while ((lap = t.lap()) < 1500) {
			if(sock.pollRecvFrom() > 0) {				// if ack received before timer ends
				sock.recvFrom((char*)message, MSGSIZE);
				break;
			}
		}
		if (lap >= 1500) {								// timeout, so retransmit
			i--;
			retransmits++;
			cerr << retransmits << endl;
		}
	}
	return retransmits;
}

void serverEarlyRetrans( UdpSocket &sock, const int max, int message[], int windowSize ) {
	cerr << "server sliding window:" << endl;
	int seq = 0;
	int lastSeq = -1;
	int windowLoc = 0;
	vector<int> window(windowSize);
	for(int i = 0; i < windowSize; i++) { 				//init window
		window[i] = -1;
	}
	while(seq < max) {
		while( sock.pollRecvFrom() <=0 ){}				// pause until message
		sock.recvFrom( ( char * ) message, MSGSIZE );   	// udp message receive
		seq = *message;										// get the seq # from beginning of msg
		int index = seq % windowSize;
		if (index < windowLoc || index >= windowSize) { // seq is outside window
			ackPkt(lastSeq, sock);							// ack last contiguous packet.
			continue;										// drop packet
		} else if(index == windowLoc) {					// seq is next contiguous packet
			window[index] = seq;							// store seq in 1st slot
			lastSeq = seq;
			while(window[windowLoc] > -1) {					// while contiguous
				lastSeq = window[windowLoc];				// store value in lastSeq
				window[windowLoc] = -1;						// clean up value to -1
				windowLoc++;								// increment window
				windowLoc = windowLoc % windowSize;			// mod window if needed
				if (window[windowLoc] == -1) {				// if next slot is empty
					ackPkt(lastSeq, sock);					// ack last contiguous packet
				}
			}
		} else {										// seq is within window, so store
			window[index] = seq;							// store seq in correct slot
			ackPkt(lastSeq, sock);							// ack last contiguous packet
		}
		if (seq == max-1)
			break;
	}
}

int clientSlidingWindow(UdpSocket &sock, const int max, int message[], 
						int windowSize) {
	cerr << "Client sliding window test:" << endl;

	int retransmits = 0;         // Tracks the number of retransmitted messages
	int ack;					 // Hold the acknowledgment from the server
	int base = 0;				 // Tracks the client's message seq#
	int sequence = 0;			 // The sequence # counter

	// Send and receive messages
	while (sequence < max || base < max) {

		// Open sliding window for use
		if (base + windowSize > sequence && sequence < max) {	
			message[0] = sequence;
			sock.sendTo((char *)message, MSGSIZE);

			// Check if ack arrived
			if (sock.pollRecvFrom() > 0) {
				sock.recvFrom((char *)message, MSGSIZE);
				ack = message[0];

				if (ack == base) {
					base++;
				}
			}
			
			// Increment sequence and shrink the window
			sequence++;
		}
		// Sliding window is full, start timer
		else {
			timer.start();

			// Looks for ACKs and timeouts
			while (true) {
				// Found ack
				if (sock.pollRecvFrom() > 0) {
					sock.recvFrom((char *)message, MSGSIZE);
					ack = message[0];

					// Move base up if the server is ahead in messages 
					if (ack >= base) { 
						base = ack + 1;
					}
					// Resend the server the message that it needs
					else {
						message[0] = ack;
						sock.sendTo((char *)message, MSGSIZE);
						retransmits++;
					}
					break;
				}
				// Timed Out
				else if (timer.lap() > TIMEOUT) {
					// Resend message to server
					message[0] = base;
					sock.sendTo((char *)message, MSGSIZE);
					retransmits++;
					break;
				}
			}
		}
	}
	return retransmits;
}

int clientSlidingWindow(UdpSocket &sock, const int max, int message[], const int windowSize) {
    
    int retransmits = 0;
    int ack;
    int ackSeq = 0;         // expected ack to receive
    
    // transfer all max messages
    for (int msgNum = 0; msgNum < max && ackSeq < max;) {
        
        int numOfUnAck = msgNum - ackSeq;
        
        // sliding window has space
        if (numOfUnack < windowSize) {

            // set-up message and send
            message[0] = msgNum;
            sock.sendTo((char *)message, MSGSIZE);
            
            // check for acknowledgement
            if (sock.pollRecvFrom() != 0) {
                sock.recvFrom((char *)&ack, sizeof(ack));
                if (ack == ackSeq)
                    ackSeq++;
            }
            msgNum++;
            
        // sliding window is full  
        } else {
            Timer t;
            t.start();
            
            bool ackReceived = false;
            
            // wait for acknowledgement within TIMEOUT
            while (t.lap() < TIMEOUT) {
                
                // check for acknowledgement
                if (sock.pollRecvFrom() != 0) {
                    ackReceived = true;
                    sock.recvFrom((char *)&ack, sizeof(ack));
                    
                    // every message up to ack has been received
                    if (ack >= ackSeq)
                        ackSeq = ack + 1;
                    else {
                        // message # ack never received, resend 
                        message[0] = ack;
                        sock.sendTo((char *)message, MSGSIZE);
                        retransmits++;
                    }                                        
                    break;
                }
            }
            
            // resend minimum unacknowledged sequence number on timeout
            if (!ackReceived) {
                message[0] = ackSeq;
                sock.sendTo((char *)message, MSGSIZE);
                retransmits++;
            }
        }
    }
    return retransmits;
}