lib/rudp.c File Reference

#include "common.h"
#include <sys/time.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include "errabort.h"
#include "rudp.h"

Include dependency graph for rudp.c:

Go to the source code of this file.

Defines
#define	MAX_TIME_OUT   999999
Functions
static int	rudpCalcTimeOut (struct rudp *ru)
static void	rudpAddRoundTripTime (struct rudp *ru, int time)
static void	rudpTimedOut (struct rudp *ru)
rudp *	rudpNew (int socket)
void	rudpFree (struct rudp **pRu)
rudp *	rudpOpen ()
rudp *	rudpMustOpen ()
rudp *	rudpOpenBound (struct sockaddr_in *sai)
rudp *	rudpMustOpenBound (struct sockaddr_in *sai)
void	rudpClose (struct rudp **pRu)
static int	timeDiff (struct timeval *t1, struct timeval *t2)
static boolean	readReadyWait (int sd, int microseconds)
static boolean	getOurAck (struct rudp *ru, struct timeval *startTv)
int	rudpSend (struct rudp *ru, struct sockaddr_in *sai, void *message, int size)
int	rudpReceiveTimeOut (struct rudp *ru, void *messageBuf, int bufSize, struct sockaddr_in *retFrom, int timeOut)
int	rudpReceiveFrom (struct rudp *ru, void *messageBuf, int bufSize, struct sockaddr_in *retFrom)
int	rudpReceive (struct rudp *ru, void *messageBuf, int bufSize)
void	rudpPrintStatus (struct rudp *ru)
void	rudpTest ()
Variables
static char const	rcsid [] = "$Id: rudp.c,v 1.14 2005/12/12 02:24:47 kent Exp $"

---

Define Documentation

#define MAX_TIME_OUT   999999

Definition at line 60 of file rudp.c.

Referenced by rudpCalcTimeOut(), and rudpTimedOut().

---

Function Documentation

static boolean getOurAck	(	struct rudp *	ru,
		struct timeval *	startTv
	)			[static]

Definition at line 236 of file rudp.c.

References rudp::lastId, readReadyWait(), rudpAck, rudpAddRoundTripTime(), rudp::socket, timeDiff(), rudp::timeOut, and TRUE.

Referenced by rudpSend().

{
struct rudpHeader head;
int readSize;
int timeOut = ru->timeOut;

for (;;)
    {
    /* Set up select with our time out. */
    int dt;
    struct timeval tv;

    if (readReadyWait(ru->socket, timeOut))
        {
        /* Read message and if it's our ack return true.   */
        readSize = recvfrom(ru->socket, &head, sizeof(head), 0, NULL, NULL);
        if (readSize >= sizeof(head) && head.type == rudpAck && head.id == ru->lastId)
            {
            gettimeofday(&tv, NULL);
            dt = timeDiff(startTv, &tv);
            rudpAddRoundTripTime(ru, dt);
            return TRUE;
            }
        }

    /* If we got to here then we did get a message, but it's not our
     * ack.  We ignore the message and loop around again,  but update
     * our timeout so that we won't keep getting other people's messages
     * forever. */
    gettimeofday(&tv, NULL);
    timeOut = ru->timeOut - timeDiff(startTv, &tv);
    if (timeOut <= 0)
        return FALSE;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static boolean readReadyWait	(	int	sd,
		int	microseconds
	)			[static]

Definition at line 199 of file rudp.c.

References errno, and warn().

{
struct timeval tv;
fd_set set;
int readyCount;

for (;;)
    {
    if (microseconds > 1000000)
        {
        tv.tv_sec = microseconds/1000000;
        tv.tv_usec = microseconds%1000000;
        }
    else
        {
        tv.tv_sec = 0;
        tv.tv_usec = microseconds;
        }
    FD_ZERO(&set);
    FD_SET(sd, &set);
    readyCount = select(sd+1, &set, NULL, NULL, &tv);
    if (readyCount < 0) 
        {
        if (errno == EINTR)     /* Select interrupted, not timed out. */
            continue;
        else 
            warn("select failure in rudp: %s", strerror(errno));
        }
    else
        {
        return readyCount > 0;  /* Zero readyCount indicates time out */
        }
    }
}

Here is the call graph for this function:

static void rudpAddRoundTripTime	(	struct rudp *	ru,
		int	time
	)			[static]

Definition at line 71 of file rudp.c.

References rudp::rttAve, rudp::rttLast, rudp::rttVary, rudpCalcTimeOut(), and rudp::timeOut.

Referenced by getOurAck(), and rudpTest().

{
int delta;
ru->rttLast = time;
delta = time - ru->rttAve;
ru->rttAve += (delta>>3);                     /* g = 1/8 */
if (delta < 0) delta = -delta;
ru->rttVary += ((delta - ru->rttVary) >> 2);  /* h = 1/4 */
ru->timeOut = rudpCalcTimeOut(ru);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int rudpCalcTimeOut

(

struct rudp *

ru

)

[static]

Definition at line 62 of file rudp.c.

References MAX_TIME_OUT, rudp::rttAve, and rudp::rttVary.

Referenced by rudpAddRoundTripTime(), and rudpNew().

{
int timeOut = ru->rttAve + (ru->rttVary<<2);
if (timeOut > MAX_TIME_OUT) timeOut = MAX_TIME_OUT; /* No more than a second. */
if (timeOut < 10000) timeOut = 10000;   /* No less than 1/100th second */
return timeOut;
}

Here is the caller graph for this function:

void rudpClose

(

struct rudp **

pRu

)

Definition at line 165 of file rudp.c.

References freez(), and rudp::socket.

Referenced by rudpOpenBound().

{
struct rudp *ru = *pRu;
if (ru != NULL)
    {
    close(ru->socket);
    freez(pRu);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void rudpFree

(

struct rudp **

pRu

)

Definition at line 106 of file rudp.c.

References freez().

{
freez(pRu);
}

Here is the call graph for this function:

struct rudp* rudpMustOpen

(

)

[read]

Definition at line 129 of file rudp.c.

References noWarnAbort(), and rudpOpen().

{
struct rudp *ru = rudpOpen();
if (ru == NULL)
    noWarnAbort();
return ru;
}

Here is the call graph for this function:

struct rudp* rudpMustOpenBound

(

struct sockaddr_in *

sai

)

[read]

Definition at line 155 of file rudp.c.

References noWarnAbort(), and rudpOpenBound().

{
struct rudp *ru = rudpOpenBound(sai);
if (ru == NULL)
    noWarnAbort();
return ru;
}

Here is the call graph for this function:

struct rudp* rudpNew

(

int

socket

)

[read]

Definition at line 92 of file rudp.c.

References AllocVar, rudp::maxRetries, rudp::rttVary, rudpCalcTimeOut(), rudp::socket, and rudp::timeOut.

Referenced by rudpOpen(), and rudpTest().

{
struct rudp *ru;
assert(socket >= 0);
AllocVar(ru);
ru->socket = socket;
ru->rttVary = 250;      /* Initial variance 250 microseconds. */
ru->timeOut = rudpCalcTimeOut(ru);
ru->maxRetries = 7;
return ru;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct rudp* rudpOpen

(

)

[read]

Definition at line 112 of file rudp.c.

References errno, rudpNew(), rudp::socket, and warn().

Referenced by rudpMustOpen(), and rudpOpenBound().

{
int sd = socket(AF_INET,  SOCK_DGRAM, IPPROTO_UDP);
if (sd < 0)
    {
    warn("Couldn't open socket in rudpOpen %s", strerror(errno));
    return NULL;
    }
return rudpNew(sd);
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct rudp* rudpOpenBound

(

struct sockaddr_in *

sai

)

[read]

Definition at line 138 of file rudp.c.

References errno, rudpClose(), rudpOpen(), rudp::socket, and warn().

Referenced by rudpMustOpenBound().

{
struct rudp *ru = rudpOpen();
if (ru != NULL)
    {
    if (bind(ru->socket, (struct sockaddr *)sai, sizeof(*sai)) < 0)
        {
        warn("Couldn't bind rudp socket: %s", strerror(errno));
        rudpClose(&ru);
        }
    }
return ru;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void rudpPrintStatus

(

struct rudp *

ru

)

Definition at line 421 of file rudp.c.

References rudp::failCount, rudp::receiveCount, rudp::resendCount, rudp::rttAve, rudp::rttLast, rudp::rttVary, rudp::sendCount, and rudp::timeOut.

{
printf("rudp status:\n");
printf("  receiveCount %d\n", ru->receiveCount);
printf("  sendCount %d\n", ru->sendCount);
printf("  resendCount %d\n", ru->resendCount);
printf("  failCount %d\n", ru->failCount);
printf("  timeOut %d\n", ru->timeOut);
printf("  rttVary %d\n", ru->rttVary);
printf("  rttAve %d\n", ru->rttAve);
printf("  rttLast %d\n", ru->rttLast);
}

int rudpReceive	(	struct rudp *	ru,
		void *	messageBuf,
		int	bufSize
	)

Definition at line 414 of file rudp.c.

References rudpReceiveFrom().

{
return rudpReceiveFrom(ru, messageBuf, bufSize, NULL);
}

Here is the call graph for this function:

int rudpReceiveFrom	(	struct rudp *	ru,
		void *	messageBuf,
		int	bufSize,
		struct sockaddr_in *	retFrom
	)

Definition at line 405 of file rudp.c.

References rudpReceiveTimeOut().

Referenced by rudpReceive().

{
return rudpReceiveTimeOut(ru, messageBuf, bufSize, retFrom, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int rudpReceiveTimeOut	(	struct rudp *	ru,
		void *	messageBuf,
		int	bufSize,
		struct sockaddr_in *	retFrom,
		int	timeOut
	)

Definition at line 335 of file rudp.c.

References errno, rudp::failCount, readReadyWait(), rudp::receiveCount, rudpAck, rudpData, rudpMaxSize, rudp::socket, rudpHeader::type, udpEthMaxSize, and warn().

Referenced by rudpReceiveFrom().

{
char inBuf[udpEthMaxSize];
struct rudpHeader *head = (struct rudpHeader *)inBuf;
struct rudpHeader ackHead;
struct sockaddr_in sai;
socklen_t saiSize = sizeof(sai);
int readSize, err;
assert(bufSize <= rudpMaxSize);
ru->receiveCount += 1;
for (;;)
    {
    if (timeOut != 0)
        {
        if (!readReadyWait(ru->socket, timeOut))
            {
            warn("rudpReceive timed out\n");
            errno = ETIMEDOUT;
            return -1;
            }
        }
    readSize = recvfrom(ru->socket, inBuf, sizeof(inBuf), 0, 
        (struct sockaddr*)&sai, &saiSize);
    if (retFrom != NULL)
        *retFrom = sai;
    if (readSize < 0)
        {
        if (errno == EINTR)
            continue;
        warn("recvfrom error: %s", strerror(errno));
        ru->failCount += 1;
        return readSize;
        }
    if (readSize < sizeof(*head))
        {
        warn("rudpRecieve truncated message");
        continue;
        }
    if (head->type != rudpData)
        {
        if (head->type != rudpAck)
            warn("skipping non-data message %d in rudpReceive", head->type);
        continue;
        }
    ackHead = *head;
    ackHead.type = rudpAck;
    err = sendto(ru->socket, &ackHead, sizeof(ackHead), 0, 
        (struct sockaddr *)&sai, sizeof(sai));
    if (err < 0)
        {
        warn("problem sending ack in rudpRecieve: %s", strerror(errno));
        }
    readSize -= sizeof(*head);
    if (readSize > bufSize)
        {
        warn("read more bytes than have room for in rudpReceive");
        readSize = bufSize;
        }
    memcpy(messageBuf, head+1, readSize);
    break;
    }
return readSize;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int rudpSend	(	struct rudp *	ru,
		struct sockaddr_in *	sai,
		void *	message,
		int	size
	)

Definition at line 276 of file rudp.c.

References errno, rudp::failCount, getOurAck(), rudp::lastId, rudp::maxRetries, rudp::resendCount, rudpData, rudpMaxSize, rudpTimedOut(), rudp::sendCount, rudp::socket, rudp::timeOut, udpEthMaxSize, and warn().

{
struct timeval sendTv;  /* Current time. */

char outBuf[udpEthMaxSize];
struct rudpHeader *head;
int fullSize = size + sizeof(*head);
int i, err = 0, maxRetry = ru->maxRetries;


/* Make buffer with header in front of message. 
 * At some point we might replace this with a scatter/gather
 * iovector. */
ru->sendCount += 1;
assert(size <= rudpMaxSize);
head = (struct rudpHeader *)outBuf;
memcpy(head+1, message, size);
head->id = ++ru->lastId;
head->type = rudpData;

/* Go into send/wait for ack/retry loop. */
for (i=0; i<maxRetry; ++i)
    {
    gettimeofday(&sendTv, NULL);
    head->sendSec = sendTv.tv_sec;
    head->sendMicro = sendTv.tv_usec;
    err =  sendto(ru->socket, outBuf, fullSize, 0, 
        (struct sockaddr *)sai, sizeof(*sai));
    if (err < 0) 
        {
        /* Warn, wait, and retry. */
        struct timeval tv;
        warn(" sendto problem %s", strerror(errno));
        tv.tv_sec = 0;
        tv.tv_usec = ru->timeOut;
        select(0, NULL, NULL, NULL, &tv);
        ru->resendCount += 1;
        rudpTimedOut(ru);
        continue;
        }
    if (getOurAck(ru, &sendTv))
        {
        return 0;
        }
    rudpTimedOut(ru);
    ru->resendCount += 1;
    }
if (err >= 0)
    {
    err = ETIMEDOUT;
    warn("rudpSend timed out");
    }
ru->failCount += 1;
return err;
}

Here is the call graph for this function:

void rudpTest

(

)

Definition at line 435 of file rudp.c.

References ArraySize, rudpAddRoundTripTime(), rudpNew(), and rudp::timeOut.

{
static int times[] = {1000, 200, 200, 100, 200, 200, 200, 400, 200, 200, 200, 200, 1000, 
        200, 200, 200, 200};
struct rudp *ru = rudpNew(0);
int i;

for (i=0; i<ArraySize(times); ++i)
    {
    int oldTimeOut = ru->timeOut;
    rudpAddRoundTripTime(ru, times[i]);
    printf("%d\t%d\t%d\t%d\n", i, oldTimeOut, times[i], ru->timeOut);
    }
}

Here is the call graph for this function:

static void rudpTimedOut

(

struct rudp *

ru

)

[static]

Definition at line 84 of file rudp.c.

References MAX_TIME_OUT, and rudp::timeOut.

Referenced by rudpSend().

{
ru->timeOut <<=  1;   /* Back off exponentially. */
if (ru->timeOut >= MAX_TIME_OUT)
    ru->timeOut = MAX_TIME_OUT;
}

Here is the caller graph for this function:

static int timeDiff	(	struct timeval *	t1,
		struct timeval *	t2
	)			[static]

Definition at line 176 of file rudp.c.

References warn().

Referenced by getOurAck().

{
int secDiff = t2->tv_sec - t1->tv_sec;
int microDiff = 0;
if (secDiff != 0)
    microDiff = secDiff * 1000000;
microDiff += (t2->tv_usec - t1->tv_usec);
if (microDiff < 0)
    {
    /* Note, this case actually happens, currently particularly on
     * kkr2u62 and kkr8u19.  I think this is just a bug in their clock
     * hardware/software.  However in general it _could_ happen very
     * rarely on normal machines when the clock is reset by the
     * network time protocol thingie. */
    warn("t1 %u.%u, t2 %u.%u.  t1 > t2 but later?!", (unsigned)t1->tv_sec,
         (unsigned)t1->tv_usec, (unsigned)t2->tv_sec, (unsigned)t2->tv_usec);
    microDiff = 0;
    }
return microDiff;
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

Variable Documentation

char const rcsid[] = "$Id: rudp.c,v 1.14 2005/12/12 02:24:47 kent Exp $" [static]

Definition at line 58 of file rudp.c.

---