Question

I have this code, the point is that I want to receive no more than 600Kbits/s using a UDP socket, I implemented an algorithm using duration during which we receive and the sleep command….

#if defined (WIN32)
#include <winsock2.h>

typedef int socklen_t;
#elif defined (linux)
#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <unistd.h>

#define INVALID_SOCKET -1
#define SOCKET_ERROR -1
#define closesocket(s) close(s)
typedef int SOCKET;
typedef struct sockaddr_in SOCKADDR_IN;
typedef struct sockaddr SOCKADDR;
#endif

#include <stdio.h>

#include <stdlib.h>

#include <time.h>


 #define RCVBUFSIZE 4
#define PORT 4444
 #define ECHOMAX 255

int main(void)
 {
#if defined (WIN32)
    WSADATA WSAData;
    int erreur = WSAStartup(MAKEWORD(2,2), &WSAData);
#else
    int erreur = 0;
#endif

int recvMsgSize;
char echoBuffer[RCVBUFSIZE];
//unsigned int echoStringLen;
//int bytesRcvd, totalBytesRcvd; //bytes received in a single recv()

SOCKET sock;
SOCKADDR_IN sin;
SOCKADDR_IN SenderAddr;
int SenderAddrSize = sizeof(SenderAddr);


if(!erreur)
{

    sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    sin.sin_addr.s_addr = inet_addr("127.0.0.1");
    sin.sin_family = AF_INET;
    sin.sin_port = htons(4444);
   memset(&sin.sin_zero, '\0', sizeof(sin.sin_zero));

     bind(sock, (SOCKADDR*)&sin, sizeof(sin));

//totalBytesRcvd = 0;

printf("Received: ");

int speed_limit= 614400; //600Kbits/s
int one_second=1000;
int elapsed; //elapsed time
int transmit=0; // how much i receive during 'elapsed'
int expected_receive; //what I'm excpected to receive
int transmit_delta; //diference
int time_sleep; //how much to sleep
clock_t start_time= clock();

 for(;;)
{


    if((recvMsgSize=recvfrom(sock, echoBuffer,1024, 0, (SOCKADDR *)&SenderAddr, &SenderAddrSize)) > 0)
    {
            transmit+=recvMsgSize;
            clock_t tempo= clock();

            elapsed=(tempo-start_time)/CLOCKS_PER_SEC;
        // Check moment speed every five second, you can choose any value
            if(elapsed>5)
            {
                start_time= tempo;
                expected_receive=speed_limit*elapsed/8;
                transmit_delta=expected_receive-transmit;

                if(transmit_delta>0)
                {
                    time_sleep=8*transmit_delta*one_second/speed_limit;
                    Sleep(time_sleep);
                }
                transmit=0;
            }
            echoBuffer[recvMsgSize]='\0';
            printf(echoBuffer);


    }

}
    printf("\n");
    getchar() ;

closesocket(sock);

    #if defined (WIN32)
        WSACleanup();
    #endif
}

return EXIT_SUCCESS;
}

the problem is that it receive the message but it blocks the receiving process from time to time…which I guess will cause loss of data especially when I’m using UDP…

any alternative solution is welcolme…

thanks in advance..

Answer 1

If you use non-blocking sockets with select() you can just ignore the data until you’re ready to read it. Not reading data will cause the TCP connection to “slow down”. However, this way you do not have exact control about the amount of data received. It’s just an approximation. All techniques I know of that limit bandwidth in a more accurate way are implemented on the sender side.