newsocket.c

Go to the documentation of this file.

/*
 * Crossfire -- cooperative multi-player graphical RPG and adventure game
 *
 * Copyright (c) 1999-2013 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 "client.h"
 
#include <errno.h>
 
#include "script.h"
 
void SockList_Init(SockList *sl, guint8 *buf)
{
    sl->len=0;
    sl->buf=buf + 2;    /* reserve two bytes for total length */
}
 
void SockList_AddChar(SockList *sl, char c)
{
    if (sl->len + 1 < MAX_BUF - 2){
        sl->buf[sl->len++]=c;
    }
    else{
        /*
         * Cast c to an unsigned short so it displays correctly in the error message.
         * Otherwise, it prints as a hexadecimal number in a funny box.
         *
         * SilverNexus 2014-06-12
         */
        LOG(LOG_ERROR,"SockList_AddChar","Could not write %hu to socket: Buffer full.\n", (unsigned short)c);
    }
}
 
void SockList_AddShort(SockList *sl, guint16 data)
{
    if (sl->len + 2 < MAX_BUF - 2){
        sl->buf[sl->len++] = (data>>8)&0xff;
        sl->buf[sl->len++] = data & 0xff;
    }
    else{
        LOG(LOG_ERROR,"SockList_AddShort","Could not write %hu to socket: Buffer full.\n", data);
    }
}
 
void SockList_AddInt(SockList *sl, guint32 data)
{
    if (sl->len + 4 < MAX_BUF - 2){
        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;
    }
    else{
        LOG(LOG_ERROR,"SockList_AddInt","Could not write %u to socket: Buffer full.\n", data);
    }
}
 
void SockList_AddString(SockList *sl, const char *str)
{
    int len = strlen(str);
 
    if (sl->len + len > MAX_BUF-2) {
        len = MAX_BUF-2 - sl->len;
    }
    memcpy(sl->buf + sl->len, str, len);
    sl->len += len;
}
 
int SockList_Send(SockList *sl, GSocketConnection* c) {
    sl->buf[-2] = sl->len / 256;
    sl->buf[-1] = sl->len % 256;
    if (c == NULL) {
        LOG(LOG_WARNING, "SockList_Send", "Sending data while not connected!");
        return 1;
    }
    if (debug_protocol) {
        char *data_print = printable(sl->buf, sl->len);
        if (data_print != NULL) {
            LOG(LOG_INFO, "C->S", "len=%d |%s|", sl->len, data_print);
            free(data_print);
        }
    }
    GOutputStream* out = g_io_stream_get_output_stream(G_IO_STREAM(c));
    bool ret = g_output_stream_write_all(out, sl->buf - 2, sl->len + 2, NULL,
                                         NULL, NULL);
    return ret ? 0 : -1;
}
 
char GetChar_String(const unsigned char *data)
{
    return (data[0]);
}
 
int GetInt_String(const unsigned char *data)
{
    return ((data[0]<<24) + (data[1]<<16) + (data[2]<<8) + data[3]);
}
 
gint64 GetInt64_String(const unsigned char *data)
{
#ifdef WIN32
    return (((gint64)data[0]<<56) + ((gint64)data[1]<<48) +
            ((gint64)data[2]<<40) + ((gint64)data[3]<<32) +
            ((gint64)data[4]<<24) + ((gint64)data[5]<<16) + ((gint64)data[6]<<8) + (gint64)data[7]);
#else
    return (((guint64)data[0]<<56) + ((guint64)data[1]<<48) +
            ((guint64)data[2]<<40) + ((guint64)data[3]<<32) +
            ((guint64)data[4]<<24) + (data[5]<<16) + (data[6]<<8) + data[7]);
#endif
}
 
short GetShort_String(const unsigned char *data)
{
    return ((data[0]<<8)+data[1]);
}
 
static guint16 GetUShort_String(const unsigned char data[static 2]) // We want at least two characters.
{
    return ((data[0]<<8)+data[1]);
}
 
bool SockList_ReadPacket(GSocketConnection c[static 1], SockList sl[static 1],
                         size_t len, GError** error) {
    GInputStream* in = g_io_stream_get_input_stream(G_IO_STREAM(csocket.fd));
    gsize read;
    if (!g_input_stream_read_all(in, sl->buf, 2, &read, NULL, error)) {
        return false;
    }
    if (read != 2) {
        sl->len = 0;
        return true;
    }
    size_t to_read = (size_t)GetUShort_String(sl->buf);
    if (to_read + 2 > len) {
        g_set_error(error, CLIENT_ERROR, CLIENT_ERROR_TOOBIG,
                    "Server packet too big");
        return false;
    }
    if (!g_input_stream_read_all(in, sl->buf + 2, to_read, &read, NULL, error)) {
        return false;
    }
    if (read != to_read) {
        sl->len = 0;
        return true;
    }
    sl->len = to_read + 2;
#ifdef CS_LOGSTATS
    cst_tot.ibytes += sl->len;
    cst_lst.ibytes += sl->len;
#endif
    return true;
}
 
int cs_print_string(GSocketConnection* fd, const char *str, ...)
{
    va_list args;
    SockList sl;
    guint8 buf[MAX_BUF];
 
    SockList_Init(&sl, buf);
    va_start(args, str);
    sl.len += vsnprintf((char*)sl.buf + sl.len, MAX_BUF-sl.len, str, args);
    va_end(args);
    // Adjust sl.len to account for when we overflow the buffer.
    if (sl.len > MAX_BUF - 3) {
        sl.len = MAX_BUF - 3;
    }
 
    script_monitor_str((char*)sl.buf);
 
    return SockList_Send(&sl, fd);
}