loop.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 <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
 
#ifndef WIN32 /* ---win32 exclude unix headers */
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <netdb.h>
#else
#include <winsock2.h>
#endif /* end win32 */
 
#include "image.h"
#include "newserver.h"
#include "sockproto.h"
#include "sproto.h"
 
extern uint32_t last_time;
 
/*****************************************************************************
 * Start of command dispatch area.
 * The commands here are protocol commands.
 ****************************************************************************/
 
/* Either keep this near the start or end of the file so it is
 * at least reasonablye easy to find.
 * There are really 2 commands - those which are sent/received
 * before player joins, and those happen after the player has joined.
 * As such, we have function types that might be called, so
 * we end up having 2 tables.
 */
 
typedef void (*func_uint8_int_ns)(char *, int, socket_struct *);
 
struct client_cmd_mapping {
    const char *cmdname;        
    const func_uint8_int_ns cmdproc;  
};
 
typedef void (*func_uint8_int_pl)(char *, int, player *);
struct player_cmd_mapping {
    const char *cmdname;             
    const func_uint8_int_pl cmdproc; 
    const uint8_t flag;                
};
 
static const struct player_cmd_mapping player_commands[] = {
    { "examine",    examine_cmd,                       1 },
    { "apply",      apply_cmd,                         1 },
    { "move",       move_cmd,                          1 },
    { "reply",      reply_cmd,                         0 },
    { "ncom",       (func_uint8_int_pl)new_player_cmd, 1 },
    { "lookat",     look_at_cmd,                       1 },
    { "lock",       (func_uint8_int_pl)lock_item_cmd,  1 },
    { "mark",       (func_uint8_int_pl)mark_item_cmd,  1 },
    { "inscribe",   inscribe_scroll_cmd,               0 },
    { NULL,         NULL,                              0 }   /* terminator */
};
 
static const struct client_cmd_mapping client_commands[] = {
    { "addme",               add_me_cmd },
    { "askface",             send_face_cmd },             /* Added: phil */
    { "beat",                NULL },
    { "requestinfo",         request_info_cmd },
    { "setup",               set_up_cmd },
    { "version",             version_cmd },
    { "asksmooth",           ask_smooth_cmd },            /*Added: tchize (smoothing technologies)*/
    { "accountlogin",       account_login_cmd },
    { "accountnew",         account_new_cmd },
    { "accountaddplayer",   account_add_player_cmd },
    { "accountplay",        account_play_cmd },
    { "accountpw",          account_password },
    { "createplayer",       create_player_cmd },
    { NULL,                  NULL }                       /* terminator (I, II & III)*/
};
 
void request_info_cmd(char *buf, int len, socket_struct *ns) {
    char *params = NULL, *cp;
    /* No match */
    SockList sl;
 
    if (len <= 0 || !buf) {
        LOG(llevDebug, "IP '%s' sent bogus request_info_cmd information\n", ns->host);
        return;
    }
 
    /* Set up replyinfo before we modify any of the buffers - this is used
     * if we don't find a match.
     */
    SockList_Init(&sl);
    SockList_AddString(&sl, "replyinfo ");
    SockList_AddString(&sl, buf);
 
    /* find the first space, make it null, and update the
     * params pointer.
     */
    for (cp = buf; *cp != '\0'; cp++)
        if (*cp == ' ') {
            *cp = '\0';
            params = cp+1;
            break;
        }
    if (!strcmp(buf, "image_info"))
        send_image_info(ns);
    else if (!strcmp(buf, "image_sums"))
        send_image_sums(ns, params);
    else if (!strcmp(buf, "skill_info"))
        send_skill_info(ns, params);
    else if (!strcmp(buf, "skill_extra"))
        send_skill_extra(ns, params);
    else if (!strcmp(buf, "spell_paths"))
        send_spell_paths(ns);
    else if (!strcmp(buf, "exp_table"))
        send_exp_table(ns);
    else if (!strcmp(buf, "race_list"))
        send_race_list(ns);
    else if (!strcmp(buf, "race_info"))
        send_race_info(ns, params);
    else if (!strcmp(buf, "class_list"))
        send_class_list(ns);
    else if (!strcmp(buf, "class_info"))
        send_class_info(ns, params);
    else if (!strcmp(buf, "rules"))
        send_file(ns, "rules");
    else if (!strcmp(buf, "motd"))
        send_file(ns, "motd");
    else if (!strcmp(buf, "news"))
        send_file(ns, "news");
    else if (!strcmp(buf,"newcharinfo"))
        send_new_char_info(ns);
    else if (!strcmp(buf,"startingmap"))
        send_map_info(ns);
    else if (!strcmp(buf, "knowledge_info"))
        knowledge_send_info(ns);
    else
        Send_With_Handling(ns, &sl);
    SockList_Term(&sl);
}
 
static int
handle_cmd(socket_struct *ns, player *pl, char *cmd, char *data, int len) {
    /* Fuzz testing indicated a way to get a null command here
     * --> make an empty command, but have a length.
     * So, if we get here with a null command, log it and exit the function.
     * Neila Hawkins 2020-01-16
     */
    if (cmd == NULL) {
        LOG(llevDebug, "%s: missing command. Sending garbage?\n", ns->host);
        return 0;
    }
    for (int i = 0; client_commands[i].cmdname != NULL; i++) {
        if (strcmp(cmd, client_commands[i].cmdname) == 0) {
            if (client_commands[i].cmdproc != NULL) {
                client_commands[i].cmdproc(data, len, ns);
            }
            return 0;
        }
    }
    /* Player must be in the playing state or the flag on the
     * the command must be zero for the user to use the command -
     * otherwise, a player cam save, be in the play_again state, and
     * the map they were on getsswapped out, yet things that try to look
     * at the map causes a crash.  If the command is valid, but
     * one they can't use, we still swallow it up.
     */
    if (pl) {
        for (int i = 0; player_commands[i].cmdname != NULL; i++) {
            if (strcmp(cmd, player_commands[i].cmdname) == 0) {
                if (pl->state == ST_PLAYING || player_commands[i].flag == 0) {
                    player_commands[i].cmdproc(data, len, pl);
                }
                return 1;
            }
        }
    }
    LOG(llevDebug, "%s: invalid command '%s'\n", ns->host, cmd);
    return 0;
}
 
bool handle_client(socket_struct *ns, player *pl) {
    /* Loop through this - maybe we have several complete packets here. */
    /* Command_count is used to limit the number of requests from
     * clients that have not logged in - we do not want an unauthenticated
     * connection to spew us with hundreds of requests.  As such,
     * this counter is only increased in the case of socket level commands.
     * Note that this also has the effect of throttling down face and other
     * socket commands from the client.  As such, if we have a player attached,
     * we will process more of these, as getting a fair number when entering
     * a map may not be uncommon.
     */
    int command_count = 0;
    while (command_count < 5 || (pl && command_count < 25)) {
        if (pl && pl->state == ST_PLAYING && pl->ob != NULL && pl->ob->speed_left < 0) {
            // Skip processing players with no turns left.
            return false;
        }
 
        int status = SockList_ReadPacket(ns->fd, &ns->inbuf, sizeof(ns->inbuf.buf)-1);
        if (status != 1) {
            if (status < 0) {
                ns->status = Ns_Dead;
            }
            return false;
        }
 
        /* Since we have a full packet, reset last tick time. */
        ns->last_tick = 0;
 
        SockList_NullTerminate(&ns->inbuf);
        assert(ns->inbuf.len >= 2);
        char *data;
        char *cmd = strtok_r((char *)ns->inbuf.buf + 2, " ", &data);
 
        int got_player_cmd;
        if (data != NULL) {
            int rem = ns->inbuf.len - ((unsigned char *)data - ns->inbuf.buf);
            got_player_cmd = handle_cmd(ns, pl, cmd, data, rem);
        } else {
            got_player_cmd = handle_cmd(ns, pl, cmd, NULL, 0);
        }
 
        SockList_ResetRead(&ns->inbuf);
        if (got_player_cmd) {
            return true;
        }
 
        command_count += 1;
        /* Evil case, and not a nice workaround, but well...
         * If we receive eg an accountplay command, the socket is copied
         * to the player structure, and its faces_sent is set to NULL.
         * This leads to issues when processing the next commands in the queue,
         * especially if related to faces...
         * So get out of here in this case, which we detect because faces_sent is NULL.
         */
        if (ns->faces_sent == NULL) {
            command_count = 6;
        }
    }
    return false;
}
 
/*****************************************************************************
 *
 * Low level socket looping - select calls and watchdog udp packet
 * sending.
 *
 ******************************************************************************/
 
#ifdef WATCHDOG
 
void watchdog(void) {
    static int fd = -1;
    static struct sockaddr_in insock;
 
    if (fd == -1) {
        struct protoent *protoent;
 
        if ((protoent = getprotobyname("udp")) == NULL
        || (fd = socket(PF_INET, SOCK_DGRAM, protoent->p_proto)) == -1) {
            return;
        }
        insock.sin_family = AF_INET;
        insock.sin_port = htons((unsigned short)13325);
        insock.sin_addr.s_addr = inet_addr("127.0.0.1");
    }
    char buf[MAX_BUF];
    snprintf(buf, sizeof(buf), "%d\n", pticks);
    sendto(fd, buf, strlen(buf), 0, (struct sockaddr *)&insock, sizeof(insock));
}
#endif
 
static int is_fd_valid(int fd) {
#ifndef WIN32
    return fcntl(fd, F_GETFL) != -1 || errno != EBADF;
#else
    return 1;
#endif
}
 
static void new_connection(int listen_fd) {
    int newsocknum = -1, j;
#ifdef HAVE_GETNAMEINFO
    struct sockaddr_storage addr;
#else
    struct sockaddr_in addr;
#endif
    socklen_t addrlen = sizeof(addr);
 
#ifdef ESRV_DEBUG
    LOG(llevDebug, "do_server: New Connection\n");
#endif
 
    for (j = 0; j < socket_info.allocated_sockets; j++)
        if (init_sockets[j].status == Ns_Avail) {
            newsocknum = j;
            break;
        }
 
    if (newsocknum == -1) {
        /* If this is the case, all sockets currently in used */
        init_sockets = static_cast<socket_struct *>(realloc(init_sockets, sizeof(socket_struct)*(socket_info.allocated_sockets+1)));
        if (!init_sockets)
            fatal(OUT_OF_MEMORY);
        newsocknum = socket_info.allocated_sockets;
        socket_info.allocated_sockets++;
        memset(&init_sockets[newsocknum], 0, sizeof(*init_sockets));
        init_sockets[newsocknum].listen = NULL;
        init_sockets[newsocknum].faces_sent_len = get_faces_count();
        init_sockets[newsocknum].faces_sent = static_cast<uint8_t *>(calloc(get_faces_count(), sizeof(*init_sockets[newsocknum].faces_sent)));
        if (!init_sockets[newsocknum].faces_sent)
            fatal(OUT_OF_MEMORY);
        init_sockets[newsocknum].status = Ns_Avail;
    }
 
    if (newsocknum < 0) {
        LOG(llevError, "FATAL: didn't allocate a newsocket?? alloc = %d, newsocknum = %d", socket_info.allocated_sockets, newsocknum);
        fatal(SEE_LAST_ERROR);
    }
 
    init_sockets[newsocknum].fd = accept(listen_fd, (struct sockaddr *)&addr, &addrlen);
    if (init_sockets[newsocknum].fd == -1) {
        LOG(llevError, "accept failed: %s\n", strerror(errno));
    } else {
        char buf[MAX_BUF];
#ifndef HAVE_GETNAMEINFO
        long ip;
#endif
        socket_struct *ns;
 
        ns = &init_sockets[newsocknum];
 
#ifdef HAVE_GETNAMEINFO
        getnameinfo((struct sockaddr *) &addr, addrlen, buf, sizeof(buf), NULL, 0, NI_NUMERICHOST);
#else
        ip = ntohl(addr.sin_addr.s_addr);
        snprintf(buf, sizeof(buf), "%ld.%ld.%ld.%ld", (ip>>24)&255, (ip>>16)&255, (ip>>8)&255, ip&255);
#endif
 
        if (checkbanned(NULL, buf)) {
            LOG(llevInfo, "Banned host tried to connect: [%s]\n", buf);
            close(init_sockets[newsocknum].fd);
            init_sockets[newsocknum].fd = -1;
        } else {
            init_connection(ns, buf);
        }
    }
}
 
bool connection_alive(const socket_struct *socket) {
    // If the client doesn't send heartbeats, assume it's connected.
    if (!socket->heartbeat) {
        return true;
    }
 
    // If a client message was received recently, it's connected.
    if (socket->last_tick < tick_length(BEAT_INTERVAL + 1)) {
        return true;
    }
 
    return false;
}
 
static void send_delayed_buffers(player *pl) {
    for (uint8_t buf = 0; buf < pl->delayed_buffers_used; buf++) {
        Send_With_Handling(pl->socket, pl->delayed_buffers[buf]);
    }
    pl->delayed_buffers_used = 0;
}
 
static void send_updates(player *pl) {
    /* Update the players stats once per tick.  More efficient than
     * sending them whenever they change, and probably just as useful
     */
    esrv_update_stats(pl);
    if (pl->last_weight != -1 && pl->last_weight != WEIGHT(pl->ob)) {
        esrv_update_item(UPD_WEIGHT, pl->ob, pl->ob);
        if (pl->last_weight != WEIGHT(pl->ob))
            LOG(llevError, "esrv_update_item(UPD_WEIGHT) did not set player weight: is %lu, should be %lu\n", (unsigned long)pl->last_weight, (unsigned long)WEIGHT(pl->ob));
    }
    /* draw_client_map does sanity checking that map is
     * valid, so don't do it here.
     */
    draw_client_map(pl->ob);
    if (pl->socket->update_look)
        esrv_draw_look(pl->ob);
    if (pl->socket->update_inventory) {
        if (pl->ob->container != NULL)
            esrv_send_inventory(pl->ob, pl->ob->container);
        pl->socket->update_inventory = 0;
    }
}
 
void check_all_fds() {
    for (int i = 0; i < socket_info.allocated_sockets; i++) {
        if (!is_fd_valid(init_sockets[i].fd)) {
            init_sockets[i].status = Ns_Dead;
            // prevent a memory leak in pre-player clients with faces sent
            FREE_AND_CLEAR(init_sockets[i].faces_sent);
        }
    }
 
    for (player *pl = first_player; pl != NULL; pl = pl->next) {
        if (!is_fd_valid(pl->socket->fd)) {
            pl->socket->status = Ns_Dead;
        }
    }
}
 
void do_server(void) {
    fd_set tmp_read, tmp_exceptions;
    FD_ZERO(&tmp_read);
    FD_ZERO(&tmp_exceptions);
 
    for (int i = 0; i < socket_info.allocated_sockets; i++) {
        if (init_sockets[i].status == Ns_Dead) {
            LOG(llevInfo, "Disconnected from %s\n", init_sockets[i].host);
            if (init_sockets[i].listen) {
                /* try to reopen the listening socket */
                init_listening_socket(&init_sockets[i]);
            } else {
                free_newsocket(&init_sockets[i]);
                init_sockets[i].status = Ns_Avail;
            }
        } else if (init_sockets[i].status != Ns_Avail) {
            FD_SET((uint32_t)init_sockets[i].fd, &tmp_read);
            FD_SET((uint32_t)init_sockets[i].fd, &tmp_exceptions);
        }
    }
 
    /* Go through the players.  Let the loop set the next pl value,
     * since we may remove some
     */
    player *pl, *next;
    for (pl = first_player; pl != NULL; ) {
        if (pl->socket->status == Ns_Dead) {
            player *npl = pl->next;
            save_player(pl->ob, 0);
            leave(pl, 1);
            final_free_player(pl);
            pl = npl;
        } else {
            FD_SET((uint32_t)pl->socket->fd, &tmp_read);
            FD_SET((uint32_t)pl->socket->fd, &tmp_exceptions);
            pl = pl->next;
        }
    }
 
    long sleep_time = get_sleep_remaining();
    if (sleep_time < 0) {
        LOG(llevInfo, "skipping time (over by %ld ms)\n", -sleep_time/1000);
        jump_time();
#ifdef CS_LOGSTATS
        cst_lst.ticks_overtime++;
#endif
    }
 
    // Log information about last tick. This can't be in log_time() because
    // CS_Stat is in socket/, and time is in common/.
#ifdef CS_LOGSTATS
    cst_lst.max_ticktime = MAX(cst_lst.max_ticktime, last_time);
    cst_lst.total_ticktime += last_time;
    cst_lst.ticks++;
#endif
 
    // Since we don't report cumulative tick time information, we don't need to
    // compute it for cst_tot. Those statistics are available from the
    // process_*_utime variables anyway.
 
    while (sleep_time > 0) {
        socket_info.timeout.tv_sec = 0;
        socket_info.timeout.tv_usec = sleep_time;
        int pollret = select(socket_info.max_filedescriptor, &tmp_read, NULL,
                             &tmp_exceptions, &socket_info.timeout);
        if (pollret == -1) {
            if (errno == EINTR) {
                // ignore
                return;
            } else if (errno == EBADF) {
                check_all_fds();
            }
            LOG(llevError, "select failed: %s\n", strerror(errno));
            return;
        } else if (!pollret) {
            return;
        }
 
        /* Check for any exceptions/input on the sockets */
        for (int i = 0; i < socket_info.allocated_sockets; i++) {
            /* listen sockets can stay in status Ns_Dead */
            if (init_sockets[i].status != Ns_Add) {
                continue;
            }
            if (FD_ISSET(init_sockets[i].fd, &tmp_exceptions)) {
                free_newsocket(&init_sockets[i]);
                init_sockets[i].status = Ns_Avail;
                continue;
            }
            if (FD_ISSET(init_sockets[i].fd, &tmp_read)) {
                if (init_sockets[i].listen)
                    new_connection(init_sockets[i].fd);
                else
                    handle_client(&init_sockets[i], NULL);
            }
        }
 
        /* This does roughly the same thing, but for the players now */
        for (pl = first_player; pl != NULL; pl = next) {
            next = pl->next;
            if (pl->socket->status == Ns_Dead)
                continue;
 
            if (FD_ISSET(pl->socket->fd, &tmp_exceptions)) {
                save_player(pl->ob, 0);
                leave(pl, 1);
                final_free_player(pl);
            } else {
                bool keep_processing = handle_client(pl->socket, pl);
                if (!keep_processing) {
                    FD_CLR(pl->socket->fd, &tmp_read);
                }
 
                /* There seems to be rare cases where next points to a removed/freed player.
                 * My belief is that this player does something (shout, move, whatever)
                 * that causes data to be sent to the next player on the list, but
                 * that player is defunct, so the socket codes removes that player.
                 * End result is that next now points at the removed player, and
                 * that has garbage data so we crash.  So update the next pointer
                 * while pl is still valid.  MSW 2007-04-21
                 */
                next = pl->next;
 
 
                /* If the player has left the game, then the socket status
                 * will be set to this be the leave function.  We don't
                 * need to call leave again, as it has already been called
                 * once.
                 */
                if (pl->socket->status == Ns_Dead) {
                    save_player(pl->ob, 0);
                    leave(pl, 1);
                    final_free_player(pl);
                } else {
                    send_delayed_buffers(pl);
                    send_updates(pl);
                }
            }
        }
        sleep_time = get_sleep_remaining();
    }
}
 
void update_players() {
    player *pl, *next;
    for (pl = first_player; pl != NULL; pl = next) {
        next = pl->next;
        send_updates(pl);
        /* Increment time since last contact only if logged in. */
        if (pl->state == ST_PLAYING) {
            pl->socket->last_tick++;
 
            if (!connection_alive(pl->socket)) {
                // TODO: Handle a lost client connection.
                LOG(llevDebug, "Lost client connection!\n");
            }
 
            if (pl->socket->tick)
                send_tick(pl);
        }
    }
}