/home/leaf/crossfire/server/branches/1.12/socket/lowlevel.c

Go to the documentation of this file.

/*
 * static char *rcsid_sockets_c =
 *    "$Id: lowlevel.c 11578 2009-02-23 22:02:27Z lalo $";
 */

/*
    CrossFire, A Multiplayer game for X-windows

    Copyright (C) 1992 Frank Tore Johansen

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

    The author can be reached via e-mail to mark@pyramid.com
*/

#include <assert.h>
#include <stdarg.h>
#include <global.h>
#include <newclient.h>
#include <sproto.h>
#include <errno.h>

static void SockList_Ensure(const SockList *sl, size_t size);

/***********************************************************************
 *
 * SockList functions/utilities
 *
 **********************************************************************/

void SockList_Init(SockList *sl) {
    SockList_Reset(sl);
}

void SockList_Term(SockList *sl) {
}

void SockList_Reset(SockList *sl) {
    sl->len = 2;
}

void SockList_ResetRead(SockList *sl) {
    sl->len = 0;
}

void SockList_AddChar(SockList *sl, char data) {
    SockList_Ensure(sl, 1);
    sl->buf[sl->len++] = data;
}

void SockList_AddShort(SockList *sl, uint16 data) {
    SockList_Ensure(sl, 2);
    sl->buf[sl->len++] = (data>>8)&0xff;
    sl->buf[sl->len++] = data&0xff;
}

void SockList_AddInt(SockList *sl, uint32 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 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_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;
    char err[MAX_BUF];

    /* We already have a partial packet */
    if (sl->len < 2) {
#ifdef WIN32 /* ***WIN32 SockList_ReadPacket: change read() to recv() */

        stat = recv(fd, 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_local(errno, err, sizeof(err)));
                return -1;
            }
            if (errno != EAGAIN && errno != EWOULDBLOCK) {
                LOG(llevDebug, "ReadPacket got error %s, returning 0\n", strerror_local(errno, err, sizeof(err)));
            }
#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() */
        recv(fd, sl->buf+2, 100, 0);
#else
        read(fd, sl->buf+2, 100);
#endif /* end win32 */

        /* return error so the socket is closed */
        return -1;
    }
    do {
#ifdef WIN32 /* ***win32 SockList_ReadPacket: change read() to recv() */
        stat = recv(fd, 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_local(errno, err, sizeof(err)));
            }
#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 add_to_buffer(socket_struct *ns, const unsigned char *buf, int len) {
    int avail, end;

    if ((len+ns->outputbuffer.len) > SOCKETBUFSIZE) {
        LOG(llevDebug, "Socket on fd %d has overrun internal buffer - marking as dead\n", ns->fd);
        ns->status = Ns_Dead;
        return;
    }

    /* data + end is where we start putting the new data.  The last byte
     * currently in use is actually data + end -1
     */

    end = ns->outputbuffer.start+ns->outputbuffer.len;
    /* The buffer is already in a wrapped state, so adjust end */
    if (end >= SOCKETBUFSIZE)
        end -= SOCKETBUFSIZE;
    avail = SOCKETBUFSIZE-end;

    /* We can all fit it behind the current data without wrapping */
    if (avail >= len) {
        memcpy(ns->outputbuffer.data+end, buf, len);
    } else {
        memcpy(ns->outputbuffer.data+end, buf, avail);
        memcpy(ns->outputbuffer.data, buf+avail, len-avail);
    }
    ns->outputbuffer.len += len;
}

void write_socket_buffer(socket_struct *ns) {
    int amt, max;

    if (ns->outputbuffer.len == 0) {
        LOG(llevDebug, "write_socket_buffer called when there is no data, fd=%d\n", ns->fd);
        return;
    }

    do {
        max = SOCKETBUFSIZE-ns->outputbuffer.start;
        if (ns->outputbuffer.len < max)
            max = ns->outputbuffer.len;

#ifdef WIN32 /* ***win32 write_socket_buffer: change write() to send() */
        amt = send(ns->fd, ns->outputbuffer.data+ns->outputbuffer.start, max, 0);
#else
        do {
            amt = write(ns->fd, ns->outputbuffer.data+ns->outputbuffer.start, max);
        } while ((amt < 0) && (errno == EINTR));
#endif

        if (amt < 0) { /* We got an error */

#ifdef WIN32 /* ***win32 write_socket_buffer: change error handling */
            if (amt == -1 && WSAGetLastError() != WSAEWOULDBLOCK) {
                LOG(llevError, "New socket write failed (wsb) (%d).\n", WSAGetLastError());
#else
            if (errno != EWOULDBLOCK) {
                char err[MAX_BUF];

                LOG(llevError, "New socket write failed (wsb) (%d: %s).\n", errno, strerror_local(errno, err, sizeof(err)));
#endif
                ns->status = Ns_Dead;
                return;
            } else { /* EWOULDBLOCK */
                /* can't write it, so store it away. */
                ns->can_write = 0;
                return;
            }
        }
        ns->outputbuffer.start += amt;
        /* wrap back to start of buffer */
        if (ns->outputbuffer.start == SOCKETBUFSIZE)
            ns->outputbuffer.start = 0;
        ns->outputbuffer.len -= amt;
#ifdef CS_LOGSTATS
        cst_tot.obytes += amt;
        cst_lst.obytes += amt;
#endif
    } while (ns->outputbuffer.len > 0);
}

static void Write_To_Socket(socket_struct *ns, const unsigned char *buf, int len) {
    int amt = 0;
    const unsigned char *pos = buf;
    char err[MAX_BUF];

    if (ns->status == Ns_Dead || !buf) {
        LOG(llevDebug, "Write_To_Socket called with dead socket\n");
        return;
    }

#ifndef __GNU__ /* This caused problems on Hurd */
    if (!ns->can_write) {
        add_to_buffer(ns, buf, len);
        return;
    }
#endif
    /* If we manage to write more than we wanted, take it as a bonus */
    while (len > 0) {

#ifdef WIN32 /* ***win32 Write_To_Socket: change write() to send() */
        amt = send(ns->fd, pos, len, 0);
#else
        do {
            amt = write(ns->fd, pos, len);
        } while ((amt < 0) && (errno == EINTR));
#endif

        if (amt < 0) { /* We got an error */
#ifdef WIN32 /* ***win32 Write_To_Socket: change error handling */
            if (amt == -1 && WSAGetLastError() != WSAEWOULDBLOCK) {
                LOG(llevError, "New socket write failed WTS (%d).\n", WSAGetLastError());
#else
            if (errno != EWOULDBLOCK) {
                LOG(llevError, "New socket write failed WTS (%d: %s).\n", errno, strerror_local(errno, err, sizeof(err)));
#endif
                ns->status = Ns_Dead;
                return;
            } else { /* EWOULDBLOCK */
                /* can't write it, so store it away. */
                add_to_buffer(ns, pos, len);
                ns->can_write = 0;
                return;
            }
        /* amt gets set to 0 above in blocking code, so we do this as
         * an else if to make sure we don't reprocess it.
         */
        } else if (amt == 0) {
            LOG(llevError, "Write_To_Socket: No data written out.\n");
        }
        len -= amt;
        pos += amt;
#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
/* 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 both to log anything */
    if (cst_lst.ibytes == 0 && cst_lst.obytes == 0)
        return;

    /* 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.nconns;
    cst_lst.time_start = now;
}
#endif

static void SockList_Ensure(const SockList *sl, size_t size) {
    if (sl->len+size > sizeof(sl->buf)) {
        fatal(OUT_OF_MEMORY);
    }
}

---