socket/lowlevel.c

Go to the documentation of this file.

/************************************************************************
*            Atrinik, a Multiplayer Online Role Playing Game            *
*                                                                       *
*    Copyright (C) 2009-2011 Alex Tokar and Atrinik Development Team    *
*                                                                       *
* Fork from Daimonin (Massive Multiplayer Online Role Playing Game)     *
* and Crossfire (Multiplayer game for X-windows).                       *
*                                                                       *
* 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 at admin@atrinik.org                        *
************************************************************************/

#include <global.h>
#include <zlib.h>

void SockList_AddString(SockList *sl, const char *data)
{
    char c;

    while ((c = *data++))
    {
        sl->buf[sl->len] = c;
        sl->len++;
    }

    sl->buf[sl->len] = c;
    sl->len++;
}

char *GetString_String(uint8 *data, int len, int *pos, char *dest, size_t dest_size)
{
    size_t i = 0;
    char c;

    while (*pos < len && (c = (char) (data[(*pos)++])))
    {
        if (i < dest_size - 1)
        {
            dest[i++] = c;
        }
    }

    dest[i] = '\0';
    return dest;
}

int SockList_ReadPacket(socket_struct *ns, int len)
{
    SockList *sl = &ns->readbuf;
    int stat_ret;

#ifdef WIN32
    stat_ret = recv(ns->fd, sl->buf + sl->len, len - sl->len, 0);
#else
    do
    {
        stat_ret = read(ns->fd, sl->buf + sl->len, len - sl->len);
    }
    while (stat_ret == -1 && errno == EINTR);
#endif

    if (stat_ret == 0)
    {
        return -1;
    }

    if (stat_ret > 0)
    {
        sl->len += stat_ret;
#if CS_LOGSTATS
        cst_tot.ibytes += stat_ret;
        cst_lst.ibytes += stat_ret;
#endif
    }
    else if (stat_ret < 0)
    {
#ifdef WIN32
        if (WSAGetLastError() != WSAEWOULDBLOCK)
        {
            if (WSAGetLastError() == WSAECONNRESET)
            {
                LOG(llevDebug, "Connection closed by client.\n");
            }
            else
            {
                LOG(llevDebug, "SockList_ReadPacket() got error %d, returning %d.\n", WSAGetLastError(), stat_ret);
            }

            return stat_ret;
        }
#else
        if (errno != EINTR && errno != EAGAIN && errno != EWOULDBLOCK)
        {
            LOG(llevDebug, "SockList_ReadPacket() got error %d: %s, returning %d.\n", errno, strerror_local(errno), stat_ret);
            return stat_ret;
        }
#endif
    }

    return 1;
}

int SockList_ReadCommand(SockList *sl, SockList *sl2)
{
    int toread, ret = 0;

    sl2->buf[0] = '\0';
    sl2->len = 0;

    /* Is there anything in our buffer that was read
     * before? */
    if (sl->len >= 2)
    {
        /* Length of the command. */
        toread = 2 + (sl->buf[0] << 8) + sl->buf[1];

        /* If we have a command, copy it over. */
        if (toread <= sl->len)
        {
            memcpy(sl2->buf, sl->buf, toread);
            sl2->len = toread;

            if (sl->len - toread)
            {
                memmove(sl->buf, sl->buf + toread, sl->len - toread);
            }

            sl->len -= toread;
            ret = toread;
        }
    }

    return ret;
}

void socket_enable_no_delay(int fd)
{
    int tmp = 1;

    if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *) &tmp, sizeof(tmp)))
    {
        LOG(llevDebug, "socket_enable_no_delay(): Cannot enable TCP_NODELAY: %s\n", strerror_local(errno));
    }
}

void socket_disable_no_delay(int fd)
{
    int tmp = 0;

    if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *) &tmp, sizeof(tmp)))
    {
        LOG(llevDebug, "socket_disable_no_delay(): Cannot disable TCP_NODELAY: %s\n", strerror_local(errno));
    }
}

static void socket_buffer_enqueue(socket_struct *ns, unsigned char *buf, size_t len, uint8 ndelay)
{
    socket_buffer *buffer = (socket_buffer *) malloc(sizeof(socket_buffer));

    buffer->buf = (char *) malloc(len + 1);
    memcpy(buffer->buf, buf, len);
    buffer->len = len;
    buffer->next = NULL;
    buffer->pos = 0;
    buffer->ndelay = ndelay;

    if (ns->buffer_front)
    {
        ns->buffer_front->last = buffer;
        buffer->next = ns->buffer_front;
        buffer->last = NULL;
        ns->buffer_front = buffer;
    }
    else
    {
        ns->buffer_back = ns->buffer_front = buffer;
        buffer->next = buffer->last = NULL;
    }
}

static void socket_buffer_dequeue(socket_struct *ns)
{
    socket_buffer *tmp = ns->buffer_back;

    ns->buffer_back = ns->buffer_back->last;

    if (ns->buffer_back)
    {
        ns->buffer_back->next = NULL;
    }
    else
    {
        ns->buffer_front = NULL;
    }

    free(tmp->buf);
    free(tmp);
}

void socket_buffer_clear(socket_struct *ns)
{
    while (ns->buffer_back)
    {
        socket_buffer_dequeue(ns);
    }
}

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

    /* Nothing to send? */
    if (!ns->buffer_back)
    {
        return;
    }

    while (ns->buffer_back)
    {
        if (ns->buffer_back->ndelay)
        {
            socket_enable_no_delay(ns->fd);
        }

        max = ns->buffer_back->len - ns->buffer_back->pos;
        amt = send(ns->fd, ns->buffer_back->buf + ns->buffer_back->pos, max, MSG_DONTWAIT);

        if (ns->buffer_back->ndelay)
        {
            socket_disable_no_delay(ns->fd);
        }

#ifndef WIN32
        if (!amt)
        {
            amt = max;
        }
        else
#endif
        if (amt < 0)
        {
#ifdef WIN32
            if (WSAGetLastError() != WSAEWOULDBLOCK)
            {
                LOG(llevDebug, "socket_buffer_write(): New socket write failed (%d).\n", WSAGetLastError());
#else
            if (errno != EWOULDBLOCK)
            {
                LOG(llevDebug, "socket_buffer_write(): New socket write failed (%d: %s).\n", errno, strerror_local(errno));
#endif
                ns->status = Ns_Dead;
                return;
            }
            /* EWOULDBLOCK: We can't write because socket is busy. */
            else
            {
                return;
            }
        }

        ns->buffer_back->pos += amt;
#if CS_LOGSTATS
        cst_tot.obytes += amt;
        cst_lst.obytes += amt;
#endif

        if (ns->buffer_back->len - ns->buffer_back->pos == 0)
        {
            socket_buffer_dequeue(ns);
        }
    }
}

void Send_With_Handling(socket_struct *ns, SockList *msg)
{
    unsigned char sbuf[4];
    uint8 *buf;
    size_t len;
#if COMPRESS_DATA_PACKETS
    uint8 *dest = NULL;
#endif

    if (ns->status == Ns_Dead || !msg)
    {
        return;
    }

    buf = msg->buf;
    len = msg->len;

#if COMPRESS_DATA_PACKETS
    if (len > COMPRESS_DATA_PACKETS_SIZE && buf[0] != BINARY_CMD_DATA)
    {
        size_t new_size = compressBound(len);

        dest = malloc(new_size + 5);
        /* Marker for the reserved #0 binary command. */
        dest[0] = 0;
        /* Add original length of the packet. */
        dest[1] = (len >> 24) & 0xff;
        dest[2] = (len >> 16) & 0xff;
        dest[3] = (len >> 8) & 0xff;
        dest[4] = (len) & 0xff;
        /* Compress it. */
        compress2((Bytef *) dest + 5, (uLong *) &new_size, (const unsigned char FAR *) buf, len, Z_BEST_COMPRESSION);
        buf = dest;
        len = new_size + 5;
    }
#endif

    /* If more than 32kb use 3 bytes header and set the high bit to show
     * it to the client. */
    if (len > 32 * 1024 - 1)
    {
        sbuf[0] = ((uint32) (len) >> 16) & 0xFF;
        /* High bit marker for the client */
        sbuf[0] |= 0x80;
        sbuf[1] = ((uint32) (len) >> 8) & 0xFF;
        sbuf[2] = ((uint32) (len)) & 0xFF;

        socket_buffer_enqueue(ns, sbuf, 3, 0);
    }
    else
    {
        sbuf[0] = ((uint32) (len) >> 8) & 0xFF;
        sbuf[1] = ((uint32) (len)) & 0xFF;

        socket_buffer_enqueue(ns, sbuf, 2, 0);
    }

    socket_buffer_enqueue(ns, buf, len, msg->buf[0] == BINARY_CMD_MAP2 || msg->buf[0] == BINARY_CMD_ITEMY);

#if COMPRESS_DATA_PACKETS
    /* Free the buffer that was used for compression, if it was allocated. */
    if (dest)
    {
        free(dest);
    }
#endif
}

void Write_String_To_Socket(socket_struct *ns, char cmd, const char *buf, int len)
{
    SockList sl;

    sl.len = len;
    sl.buf = (uint8 *) buf;
    *((char *) buf) = cmd;

    Send_With_Handling(ns, &sl);
}

#if CS_LOGSTATS

CS_Stats cst_tot;

CS_Stats cst_lst;

void write_cs_stats()
{
    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;
    }

    /* CSSTAT is put in so scripts can easily find the line */
    LOG(llevInfo, "CSSTAT: %.16s tot in:%d out:%d maxc:%d time:%lu last block-> in:%d out:%d maxc:%d time:%lu\n", ctime(&now), cst_tot.ibytes, cst_tot.obytes, cst_tot.max_conn, now - cst_tot.time_start, cst_lst.ibytes, cst_lst.obytes, cst_lst.max_conn, 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