lowlevel.cpp

Go to the documentation of this file.

/*
 * Crossfire -- cooperative multi-player graphical RPG and adventure game
 *
 * Copyright (c) 1999-2014 Mark Wedel and the Crossfire Development Team
 * Copyright (c) 1992 Frank Tore Johansen
 *
 * Crossfire is free software and comes with ABSOLUTELY NO WARRANTY. You are
 * welcome to redistribute it under certain conditions. For details, please
 * see COPYING and LICENSE.
 *
 * The authors can be reached via e-mail at <crossfire@metalforge.org>.
 */
 
#include "global.h"
 
#include <assert.h>
#include <errno.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
 
#include "shared/newclient.h"
#include "sproto.h"
 
#ifdef WIN32
#include <winsock2.h>
#endif
 
/***********************************************************************
 *
 * SockList functions/utilities
 *
 **********************************************************************/
 
void SockList_Init(SockList *sl) {
    SockList_Reset(sl);
}
 
void SockList_Term(SockList *sl) {
    (void)sl;
}
 
void SockList_Reset(SockList *sl) {
    sl->len = 2;
}
 
void SockList_ResetRead(SockList *sl) {
    sl->len = 0;
}
 
static void SockList_Ensure(const SockList *sl, size_t size) {
    if (sl->len+size > sizeof(sl->buf)) {
        fatal(OUT_OF_MEMORY);
    }
}
 
void SockList_AddChar(SockList *sl, unsigned char data) {
    SockList_Ensure(sl, 1);
    sl->buf[sl->len++] = data;
}
 
void SockList_AddShort(SockList *sl, uint16_t data) {
    SockList_Ensure(sl, 2);
    sl->buf[sl->len++] = (data>>8)&0xff;
    sl->buf[sl->len++] = data&0xff;
}
 
void SockList_AddInt(SockList *sl, uint32_t data) {
    SockList_Ensure(sl, 4);
    sl->buf[sl->len++] = (data>>24)&0xff;
    sl->buf[sl->len++] = (data>>16)&0xff;
    sl->buf[sl->len++] = (data>>8)&0xff;
    sl->buf[sl->len++] = data&0xff;
}
 
void SockList_AddInt64(SockList *sl, uint64_t data) {
    SockList_Ensure(sl, 8);
    sl->buf[sl->len++] = (char)((data>>56)&0xff);
    sl->buf[sl->len++] = (char)((data>>48)&0xff);
    sl->buf[sl->len++] = (char)((data>>40)&0xff);
    sl->buf[sl->len++] = (char)((data>>32)&0xff);
    sl->buf[sl->len++] = (char)((data>>24)&0xff);
    sl->buf[sl->len++] = (char)((data>>16)&0xff);
    sl->buf[sl->len++] = (char)((data>>8)&0xff);
    sl->buf[sl->len++] = (char)(data&0xff);
}
 
void SockList_AddString(SockList *sl, const char *data) {
    SockList_AddData(sl, data, strlen(data));
}
 
void SockList_AddData(SockList *sl, const void *data, size_t len) {
    SockList_Ensure(sl, len);
    memcpy(sl->buf+sl->len, data, len);
    sl->len += len;
}
 
void SockList_AddLen8Data(SockList *sl, const void *data, size_t len) {
    assert(len <= 255);
    SockList_AddChar(sl, len);
    SockList_AddData(sl, data, len);
}
 
void SockList_AddLen16Data(SockList *sl, const void *data, size_t len) {
    assert(len <= 65535);
    SockList_AddShort(sl, len);
    SockList_AddData(sl, data, len);
}
 
void SockList_AddPrintf(SockList *sl, const char *format, ...) {
    size_t size;
    int n;
    va_list arg;
 
    size = sizeof(sl->buf)-sl->len;
 
    va_start(arg, format);
    n = vsnprintf((char *)sl->buf+sl->len, size, format, arg);
    va_end(arg);
 
    if (n <= -1 || (size_t)n >= size) {
        fatal(OUT_OF_MEMORY);
    }
    sl->len += (size_t)n;
}
 
void SockList_AddStringBuffer(SockList *sl, StringBuffer *sb) {
    char *p;
 
    p = stringbuffer_finish(sb);
    SockList_AddString(sl, p);
    free(p);
}
 
void SockList_NullTerminate(SockList *sl) {
    SockList_Ensure(sl, 1);
    sl->buf[sl->len] = '\0';
}
 
size_t SockList_Avail(const SockList *sl) {
    return sizeof(sl->buf)-sl->len;
}
 
int GetInt_String(const unsigned char *data) {
    return ((data[0]<<24)+(data[1]<<16)+(data[2]<<8)+data[3]);
}
 
short GetShort_String(const unsigned char *data) {
    return ((data[0]<<8)+data[1]);
}
 
/******************************************************************************
 *
 * Start of read routines.
 *
 ******************************************************************************/
 
int SockList_ReadPacket(int fd, SockList *sl, int len) {
    int stat, toread;
 
    /* We already have a partial packet */
    if (sl->len < 2) {
#ifdef WIN32 /* ***WIN32 SockList_ReadPacket: change read() to recv() */
 
        stat = recv(fd, reinterpret_cast<char *>(sl->buf+sl->len), 2-sl->len, 0);
 
#else
        do {
            stat = read(fd, sl->buf+sl->len, 2-sl->len);
        } while ((stat == -1) && (errno == EINTR));
#endif
        if (stat < 0) {
            /* In non blocking mode, EAGAIN is set when there is no
             * data available.
             */
#ifdef WIN32 /* ***WIN32 SockList_ReadPacket: error handling for win32 */
            if ((stat == -1) && WSAGetLastError() != WSAEWOULDBLOCK) {
                if (WSAGetLastError() == WSAECONNRESET)
                    LOG(llevDebug, "Connection closed by client\n");
                else {
                    LOG(llevDebug, "ReadPacket got error %d, returning -1\n", WSAGetLastError());
                }
                return -1; /* kick this user! */
            }
#else
            if (errno == ECONNRESET) {
                LOG(llevDebug, "ReadPacket got error %s, returning -1\n", strerror(errno));
                return -1;
            }
            if (errno != EAGAIN && errno != EWOULDBLOCK) {
                LOG(llevDebug, "ReadPacket got error %s, returning 0\n", strerror(errno));
            }
#endif
            return 0; /*Error */
        }
        if (stat == 0)
            return -1;
        sl->len += stat;
#ifdef CS_LOGSTATS
        cst_tot.ibytes += stat;
        cst_lst.ibytes += stat;
#endif
        if (stat < 2)
            return 0; /* Still don't have a full packet */
    }
    /* Figure out how much more data we need to read.  Add 2 from the
     * end of this - size header information is not included.
     */
    toread = 2+(sl->buf[0]<<8)+sl->buf[1]-sl->len;
    if ((toread+(int)sl->len) >= len) {
        LOG(llevError, "SockList_ReadPacket: Want to read more bytes than will fit in buffer (%lu>=%lu).\n", (unsigned long)toread+sl->len, (unsigned long)len);
        /* Quick hack in case for 'oldsocketmode' input.  If we are
         * closing the socket anyways, then reading this extra 100 bytes
         * shouldn't hurt.
         */
#ifdef WIN32 /* ***win32 SockList_ReadPacket: change read() to recv() */
        stat = recv(fd, reinterpret_cast<char *>(sl->buf+2), 100, 0);
#else
        stat = read(fd, sl->buf+2, 100);
#endif /* end win32 */
        (void) stat; // Don't care how much we read; avoid complier warnings
 
        /* return error so the socket is closed */
        return -1;
    }
    do {
#ifdef WIN32 /* ***win32 SockList_ReadPacket: change read() to recv() */
        stat = recv(fd, reinterpret_cast<char *>(sl->buf+sl->len), toread, 0);
#else
        do {
            stat = read(fd, sl->buf+sl->len, toread);
        } while ((stat < 0) && (errno == EINTR));
#endif
        if (stat < 0) {
#ifdef WIN32 /* ***win32 SockList_ReadPacket: change error handling for win32 */
            if ((stat == -1) && WSAGetLastError() != WSAEWOULDBLOCK) {
                if (WSAGetLastError() == WSAECONNRESET)
                    LOG(llevDebug, "Connection closed by client\n");
                else {
                    LOG(llevDebug, "ReadPacket got error %d, returning -1\n", WSAGetLastError());
                }
                return -1; /* kick this user! */
            }
#else
            if (errno != EAGAIN && errno != EWOULDBLOCK) {
                LOG(llevDebug, "ReadPacket got error %s, returning 0\n", strerror(errno));
            }
#endif
            return 0; /*Error */
        }
        if (stat == 0)
            return -1;
        sl->len += stat;
#ifdef CS_LOGSTATS
        cst_tot.ibytes += stat;
        cst_lst.ibytes += stat;
#endif
        toread -= stat;
        if (toread == 0)
            return 1;
        if (toread < 0) {
            LOG(llevError, "SockList_ReadPacket: Read more bytes than desired.\n");
            return 1;
        }
    } while (toread > 0);
    return 0;
}
 
/*******************************************************************************
 *
 * Start of write related routines.
 *
 ******************************************************************************/
 
static void Write_To_Socket(socket_struct* ns, const unsigned char* buf, const int len) {
    if (ns->status == Ns_Dead || !buf) {
        LOG(llevDebug, "Write_To_Socket called with dead socket\n");
        return;
    }
 
#ifdef WIN32
    const int amt = send(ns->fd, reinterpret_cast<const char *>(buf), len, 0);
#else
    const int amt = send(ns->fd, buf, len, 0);
#endif
    if (amt < 0) { /* We got an error */
#ifdef WIN32       /* ***win32 Write_To_Socket: change error handling */
        if (amt == -1 && WSAGetLastError() != WSAEWOULDBLOCK) {
            LOG(llevInfo, "New socket write failed WTS (%d).\n",
                WSAGetLastError());
#else
        if (errno != EWOULDBLOCK) {
            LOG(llevInfo, "New socket write failed WTS: %s\n",
                strerror(errno));
#endif
            ns->status = Ns_Dead;
            return;
        } else { /* EWOULDBLOCK */
            LOG(llevError,
                "Write_To_Socket: write would block; disconnecting. Try "
                "increasing SOCKETBUFSIZE.\n");
            ns->status = Ns_Dead;
            return;
        }
    } else if (amt != len) {
        LOG(llevError, "Write_To_Socket: write wrote less than requested; "
                       "disconnecting. Try increasing SOCKETBUFSIZE.\n");
        ns->status = Ns_Dead;
        return;
    }
#ifdef CS_LOGSTATS
    cst_tot.obytes += amt;
    cst_lst.obytes += amt;
#endif
}
 
void Send_With_Handling(socket_struct *ns, SockList *sl) {
    if (ns->status == Ns_Dead || sl == NULL)
        return;
 
    sl->buf[0] = ((sl->len-2)>>8)&0xFF;
    sl->buf[1] = (sl->len-2)&0xFF;
    Write_To_Socket(ns, sl->buf, sl->len);
}
 
/******************************************************************************
 *
 * statistics logging functions.
 *
 ******************************************************************************/
 
#ifdef CS_LOGSTATS
 
static int count_all_players() {
    int players = 0;
    player *pl;
    for (pl = first_player, players = 0; pl != NULL; pl = pl->next, players++);
    return players;
}
 
/* cst_tot is for the life of the server, cst_last is for the last series of
 * stats
 */
CS_Stats cst_tot, cst_lst;
 
void write_cs_stats(void) {
    time_t now = time(NULL);
 
    /* If no connections recently, don't bother to log anything */
    if (cst_lst.ibytes == 0 && cst_lst.obytes == 0)
        return;
 
    LOG(llevInfo, "STAT: players: %d active, %d total\n", count_players(), count_all_players());
    /* CSSTAT is put in so scripts can easily find the line */
    LOG(llevInfo, "CSSTAT: %.16s tot %d %d %d %ld inc %d %d %d %ld\n",
        ctime(&now), cst_tot.ibytes, cst_tot.obytes, cst_tot.max_conn,
        (long)(now-cst_tot.time_start), cst_lst.ibytes, cst_lst.obytes,
        cst_lst.max_conn, (long)(now-cst_lst.time_start));
    cst_lst.ibytes = 0;
    cst_lst.obytes = 0;
    cst_lst.max_conn = socket_info.allocated_sockets;
    cst_lst.time_start = now;
}
#endif