timesync.c

Go to the documentation of this file.

#include "vector.h"
#include "timesync.h"
#include "iothread.h"
#include "message.h"
#include "vector.h"
#include "net.h"
#include <assert.h>
#include <math.h>
#ifndef NDEBUG
#include <stdio.h>
#endif
#ifndef WIN32
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#endif
#include <SDL.h>
#include <SDL_thread.h>

Sint32 timeDelta;
int timeSyncState = TIMESYNC_IDLE;
TimeSample timeSyncResults;

static SDL_Thread *thread = NULL;

static int tsyncSock;

#define REQ_SAMPLES  16

#define INC_SAMPLES   4

#define MAX_SAMPLES  32

static void ComputeAverages(Vector *samples) {
    double delta = 0, latency = 0;
    TimeSample *sample = (TimeSample*)samples->array;
    unsigned int loop;
    if (samples->items) {
        // go through all the samples
        for (loop = 0; loop < samples->items; loop++, sample++) {
            // accumulate the times
            delta += sample->delta;
            latency += sample->latency;
        }
        // divide for an average
        timeSyncResults.delta = delta / (double)samples->items;
        timeSyncResults.latency = latency / (double)samples->items;
    }
    else {
        timeSyncResults.delta = timeSyncResults.latency = 0.0;
    }
}

static double ComputeStdDeviation(Vector *samples) {
    double delta = 0;
    TimeSample *sample = (TimeSample*)samples->array;
    unsigned int loop;
    // go through all the samples
    for (loop = 0; loop < samples->items; loop++, sample++) {
        // accumulate the squares
        delta = (timeSyncResults.delta - sample->delta) *
        (timeSyncResults.delta - sample->delta);
    }
    // finsh the result
    return sqrt(delta / (double)(samples->items - 1));
}

static Bool GetSamples(Vector *samples, SocketAddr *dest, int sock,
int reqSamples) {
    fd_set fds;
    SocketAddr origin;
    TimeSample *lastSample;
    int loop;
    Uint32 sentTime, recvTime;
    Uint8  buff[9];
    origin.length = sizeof(struct sockaddr_in6);
    FD_ZERO(&fds);
    // compute the number of samples still needed
    loop = (reqSamples << 1) - samples->items;
    while ((loop > 0) && !IsCancelationRequested()) {
        int gotTime;
        // wait up to a half second for a response
        struct timeval tv = { 0, 500000 };
        // first, wait a little while between time sync datagrams
        SDL_Delay(50);
        // get the current time
        sentTime = SDL_GetTicks();
        // build the datagram
        buff[0] = localPlayer;
        MSG_WRITE_32C(buff, 1, sentTime);
        // send the timesync datagram
        if (sendto(sock, buff, 5, 0, &(dest->addr), dest->length) != 5) {
            // failed to send
            timeSyncState = TIMESYNC_ERROR;
            return FALSE;
        }
        GetSamples_select:
        FD_SET(sock, &fds);
        // wait for the response
        if (select(sock + 1, &fds, NULL, &fds, &tv) <= 0) {
            // got nothing; try again
            continue;
        }
        // get the response and check for error
        if ((recvfrom(sock, buff, 9, 0, &origin.addr,
        &origin.length) != 9) || !EqualAddresses(&origin, dest)) {
            // try again
            goto GetSamples_select;
        }
        // capture the current time
        recvTime = SDL_GetTicks();
        // see if the response has the same client time as the last one
        // sent to the server
        MSG_READ_32C(buff, 1, gotTime);
        if ((localPlayer != buff[0]) || (gotTime != sentTime)) {
            // try again
            goto GetSamples_select;
        }
        // add the sample
        MSG_READ_32C(buff, 5, gotTime);
        lastSample = VectorAdd(samples);
        lastSample->delta = (double)(gotTime - recvTime) +
        (lastSample->latency = (double)(recvTime - sentTime) / 2.0);
        // one sample done
        loop--;
    }
    // success
    return TRUE;
}

static void RemoveBadSamples(Vector *samples) {
    double stdDev, upper, lower;
    TimeSample *sample = (TimeSample*)samples->array;
    unsigned int loop = 0;
    // find the averages
    ComputeAverages(samples);
    // find the standard deviatiom
    stdDev = ComputeStdDeviation(samples);
    // set the lower bound
    lower = timeSyncResults.delta - stdDev - 1.0;
    // set the upper bound
    upper = timeSyncResults.delta + stdDev + 1.0;
    // loop through the samples
    while (loop < samples->items) {
        // check for a bad -- out of bounds -- sample
        if ((sample->delta > upper) || (sample->delta < lower)) {
            // remove the sample
            VectorRemove(samples, loop);
        }
        else {
            // advamce to the next sample
            sample++;
            loop++;
        }
    }
}

extern Uint32 frameTime;

static void ClientSync(void *ignore) {
    Vector samples;
    SocketAddr addr;
    int sock, time;
    unsigned int required;
    
    // initialize the vector that will contain time samples
    samples.destructOp = NULL;
    samples.itemSize = sizeof(TimeSample);
    if (!VectorInit(&samples, samples.minSize = 32)) {
        // not enough memory; this game isn't going to work
        timeSyncState = TIMESYNC_ERROR;
        return;
    }
    // get the socket address to use
    assert((outgoingAddr.addr.sa_family == AF_INET) ||
    (outgoingAddr.addr.sa_family == AF_INET6));
    // IPv4?
    if ((addr.addr.sa_family = outgoingAddr.addr.sa_family) == AF_INET) {
        // set the address
        addr.ipv4.sin_addr.s_addr = htonl(INADDR_ANY);
        // set the port
        addr.ipv4.sin_port = htons(PORT_CTSYNC);
    }
    // IPv6?
    else {
        // set the port
        addr.ipv6.sin6_port = htons(PORT_CTSYNC);
    }
    // get a socket to communicate with the server
    if ((sock = UnicastSocket(&addr, TRUE)) == -1) {
        // couldn't communicate for time sync
        timeSyncState = TIMESYNC_ERROR;
        goto ClientSync_end;
    }
    // set address to be the destination (server)
    addr = outgoingAddr;
    if (addr.addr.sa_family == AF_INET) {
        // change the port
        addr.ipv4.sin_port = htons(PORT_STSYNC);
    }
    // IPv6?
    else {
        // change the port
        addr.ipv6.sin6_port = htons(PORT_STSYNC);
    }
    // set the required number of samples
    required = REQ_SAMPLES;
    // loop for samples
    do {
        // get some samples
        if (!GetSamples(&samples, &addr, sock, required)) {
            // failed
            timeSyncState = TIMESYNC_ERROR;
            goto ClientSync_end;
        }
        // if there can be more attempts at gathering samples . . .
        if (required < MAX_SAMPLES) {
            // remove samples that appear to be poor
            RemoveBadSamples(&samples);
        }
        // increase the minimum number of samples needed
        required += INC_SAMPLES;
    } while ((samples.items < required) && (required <= MAX_SAMPLES)
    && !IsCancelationRequested());
    // compute an average
    ComputeAverages(&samples);
    // set the integer used for common game time computations
    timeDelta = (Sint32)timeSyncResults.delta;
    // change the next frame target time
    time = SDL_GetTicks() + timeDelta;
    frameTime = time - (time % FRAME_DURATION) + FRAME_DURATION;
    // check for too few samples
    if (samples.items < required) {
        // flag poor results
        timeSyncState = TIMESYNC_POOR;
    }
    else {
        // good results
        timeSyncState = TIMESYNC_FINISHED;
    }
    ClientSync_end:
    #if !defined(NDEBUG) && !defined(GETTEXT)
    {
        int error;
        printf("Time synchronization ended ");
        switch (timeSyncState) {
            case TIMESYNC_FINISHED:
                printf("successfully.");
                break;
            case TIMESYNC_POOR:
                printf("with poor quality results.");
                break;
            case TIMESYNC_ERROR:
                printf("on an error.");
                if ((error = GetNetErrorVal()) != 0) {
                    #ifdef USE_GETTEXT
                    printf("\n\tNetwork error: %ls\n", GetNetErrorString(error));
                    #else
                    printf("\n\tNetwork error: %s\n", GetNetErrorString(error));
                    #endif
                }
                return;
            default:
                printf("with undefined state 0x%X.\n", timeSyncState);
                return;
        }
        printf("\n\tsamples = %d\n\tdelta = %lfms\n\tlatency = %lfms\n",
        samples.items, timeSyncResults.delta, timeSyncResults.latency);
        #ifdef WIN32
        fflush(stdout);
        #endif
    }
    #endif
    // close the socket
    CloseSocket(sock);
    // destroy the samples
    VectorDestroy(&samples);
}

void StartClientTimeSync() {
    timeSyncState = TIMESYNC_INPROG;
    QueueOperation(ClientSync, NULL);
}

static int ServerTimeSyncThread(void *ignore) {
    SocketAddr origin;
    int error = 0;
    Uint32 now;
    Uint8 buff[9];
    // loop to receive requests
    do {
        // reset the length of the origin struct
        origin.length = sizeof(struct sockaddr_in6);
        // read in 5 bytes
        if (recvfrom(tsyncSock, buff, 5, 0, &origin.addr, &origin.length) == 5) {
            // validate the client
            if (ValidateClient(&origin, buff[0])) {
                // add the server's time to the message
                now = SDL_GetTicks();
                MSG_WRITE_32C(buff, 5, now);
                // adjust the port for IPv4
                if (origin.addr.sa_family == AF_INET) {
                    // change the port
                    origin.ipv4.sin_port = htons(PORT_CTSYNC);
                }
                // IPv6?
                else {
                    // change the port
                    origin.ipv6.sin6_port = htons(PORT_CTSYNC);
                }
                // send it back
                sendto(tsyncSock, buff, 9, 0, &origin.addr, origin.length);
            }
            // clear the error
            error = 0;
        }
        else {
            // grab the error
            error = GetNetErrorVal();
        }
    } while ((tsyncSock != -1) && ((error == 0) || (error == ECONNREFUSED)));
    #ifndef NDEBUG
    if ((tsyncSock != -1) && error) {
        #ifndef WIN32
        #ifdef USE_GETTEXT
        fwprintf(stderr, L"Server time synchronization ended on error: %ls\n",
        GetNetErrorString(error));
        #else
        fprintf(stderr, "Server time synchronization ended on error: %s\n",
        GetNetErrorString(error));
        #endif
        #endif
    }
    #endif
    return 0;
}

Bool StartServerTimeSync() {
    SocketAddr addr;
    // setup an address
    addr.ipv4.sin_family = AF_INET;
    addr.ipv4.sin_port = htons(PORT_STSYNC);
    addr.ipv4.sin_addr.s_addr = htonl(INADDR_ANY);
    // open a socket to receive time sync requests
    if ((tsyncSock = UnicastSocket(&addr, TRUE)) == -1) {
        // failed
        return FALSE;
    }
    // start the thread
    thread = SDL_CreateThread(ServerTimeSyncThread, NULL);
    return TRUE;
}

void StopServerTimeSync() {
    CloseSocket(tsyncSock);
    timeSyncState = TIMESYNC_IDLE;
}

---