socket/loop.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>

static fd_set tmp_read, tmp_exceptions, tmp_write;

typedef void (*func_uint8_int_ns)(char *, int, socket_struct *);

struct client_cmd_mapping
{
    char *cmdname;

    func_uint8_int_ns cmdproc;
};

typedef void (*func_uint8_int_pl)(char *, int, player *);

struct player_cmd_mapping
{
    char *cmdname;

    func_uint8_int_pl cmdproc;

    int flags;
};

static const struct player_cmd_mapping player_commands[] =
{
    {"ex",          ExamineCmd, 0},
    {"ap",          ApplyCmd, 0},
    {"mv",          MoveCmd, 0},
    {"reply",       ReplyCmd, 0},
    {"cm",          PlayerCmd, 0},
    {"lock",        (func_uint8_int_pl) LockItem, 0},
    {"mark",        (func_uint8_int_pl) MarkItem, 0},
    {"/fire", command_fire_old, 0},
    {"fire", (func_uint8_int_pl) command_fire, 0},
    {"nc",          command_new_char, 0},
    {"qs",          (func_uint8_int_pl) QuickSlotCmd, 0},
    {"shop",        ShopCmd, 0},
    {"qlist",       QuestListCmd, 0},
    {"mp", (func_uint8_int_pl) command_move_path, 0},
    {"rd", (func_uint8_int_pl) cmd_ready, 0},
    {"pc", (func_uint8_int_pl) cmd_password_change, 0},
    {NULL, NULL, 0}
};

static const struct client_cmd_mapping client_commands[] =
{
    {"addme",       AddMeCmd},
    {"askface",     SendFaceCmd},
    {"setup",       SetUp},
    {"version",     VersionCmd},
    {"rf",          RequestFileCmd},
    {"clr", command_clear_cmds},
    {"setsound", SetSound},
    {"upf", cmd_request_update},
    {"ka", cmd_keepalive},
    {NULL, NULL}
};

static int check_client_command(socket_struct *ns)
{
    unsigned char *data;
    int i, data_len;

    for (i = 0; client_commands[i].cmdname; i++)
    {
        if ((int) strlen(client_commands[i].cmdname) <= ns->inbuf.len - 2 && !strncmp((char *) ns->inbuf.buf + 2, client_commands[i].cmdname, strlen(client_commands[i].cmdname)))
        {
            /* Pre-process the command. */
            data = (unsigned char *) strchr((char *) ns->inbuf.buf + 2, ' ');

            if (data)
            {
                *data = '\0';
                data++;
                data_len = ns->inbuf.len - (data - ns->inbuf.buf);
            }
            else
            {
                data_len = 0;
            }

            client_commands[i].cmdproc((char *) data, data_len, ns);

            /* We have successfully added this client. */
            if (ns->addme)
            {
                ns->addme = 0;
            }

            return 1;
        }
    }

    return 0;
}

static void fill_command_buffer(socket_struct *ns)
{
    int rr;

    do
    {
        if ((rr = SockList_ReadCommand(&ns->readbuf, &ns->inbuf)))
        {
            /* Terminate buffer - useful for string data. */
            ns->inbuf.buf[ns->inbuf.len] = '\0';

            if (check_client_command(ns))
            {
                if (ns->status == Ns_Dead)
                {
                    return;
                }
            }
            else
            {
                memcpy(ns->cmdbuf.buf + ns->cmdbuf.len, ns->inbuf.buf, rr);
                ns->cmdbuf.len += rr;
            }
        }
    }
    while (rr);
}

static int check_command(socket_struct *ns, player *pl)
{
    int i, len = 0;
    unsigned char *data;

    /* Terminate buffer - useful for string data */
    ns->inbuf.buf[ns->inbuf.len] = '\0';

    /* First, break out beginning word. There are at least
     * a few commands that do not have any parameters. If
     * we get such a command, don't worry about trying
     * to break it up. */
    data = (unsigned char *) strchr((char *) ns->inbuf.buf + 2, ' ');

    if (data)
    {
        *data = '\0';
        data++;
        len = ns->inbuf.len - (data - ns->inbuf.buf);
    }
    else
    {
        len = 0;
    }

    for (i = 0; client_commands[i].cmdname; i++)
    {
        if (strcmp((char *) ns->inbuf.buf + 2, client_commands[i].cmdname) == 0)
        {
            client_commands[i].cmdproc((char *) data, len, ns);
            ns->inbuf.len = 0;

            /* We have successfully added this connect! */
            if (ns->addme)
            {
                ns->addme = 0;
            }

            return 1;
        }
    }

    /* Only valid players can use these commands */
    if (pl)
    {
        for (i = 0; player_commands[i].cmdname; i++)
        {
            if (strcmp((char *) ns->inbuf.buf + 2, player_commands[i].cmdname) == 0)
            {
                player_commands[i].cmdproc((char *) data, len, pl);
                ns->inbuf.len = 0;
                return 1;
            }
        }
    }

    LOG(llevSystem, "Bad command from client ('%s') (%s)\n", ns->inbuf.buf + 2, STRING_SAFE((char *) data));
    return 0;
}

void handle_client(socket_struct *ns, player *pl)
{
    int cmd_count = 0;

    /* Loop through this - maybe we have several complete packets here. */
    while (1)
    {
        /* If it is a player, and they don't have any speed left, we
         * return, and will parse the data when they do have time. */
        if (ns->status == Ns_Zombie || ns->status == Ns_Dead || (pl && pl->state == ST_PLAYING && pl->ob != NULL && pl->ob->speed_left < 0))
        {
            return;
        }

        if (!SockList_ReadCommand(&ns->cmdbuf, &ns->inbuf))
        {
            return;
        }

        /* Reset idle counter. */
        if (pl && pl->state == ST_PLAYING)
        {
            ns->login_count = 0;
            ns->keepalive = 0;
        }

        if (check_command(ns, pl))
        {
            if (cmd_count++ <= 8 && ns->status != Ns_Dead)
            {
                continue;
            }
        }

        return;
    }
}

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

    sendto(fd, (void *) &fd, 1, 0, (struct sockaddr *) &insock, sizeof(insock));
}

void remove_ns_dead_player(player *pl)
{
    if (pl == NULL || pl->ob->type == DEAD_OBJECT)
    {
        return;
    }

    if (pl->state == ST_PLAYING)
    {
        /* Trigger the global LOGOUT event */
        trigger_global_event(GEVENT_LOGOUT, pl->ob, pl->socket.host);
        statistics_player_logout(pl);

        if (!pl->dm_stealth)
        {
            new_draw_info_format(NDI_ALL, COLOR_DK_ORANGE, NULL, "%s left the game.", query_name(pl->ob, NULL));
        }

        /* If this player is in a party, leave the party */
        if (pl->party)
        {
            command_party(pl->ob, "leave");
        }

        strncpy(pl->killer, "left", MAX_BUF - 1);
        hiscore_check(pl->ob, 1);

        /* Be sure we have closed container when we leave */
        container_unlink(pl, NULL);

        save_player(pl->ob, 0);

        if (!QUERY_FLAG(pl->ob, FLAG_REMOVED))
        {
            leave_map(pl->ob);
        }

        if (pl->ob->map)
        {
            if (pl->ob->map->in_memory == MAP_IN_MEMORY)
            {
                pl->ob->map->timeout = MAP_TIMEOUT(pl->ob->map);
            }

            pl->ob->map = NULL;
        }
    }

    LOG(llevInfo, "Logout %s from IP %s\n", pl->ob->name, pl->socket.host);

    /* To avoid problems with inventory window */
    pl->ob->type = DEAD_OBJECT;
    free_player(pl);
}

static int is_fd_valid(int fd)
{
#ifndef WIN32
    return fcntl(fd, F_GETFL) != -1 || errno != EBADF;
#else
    return 1;
#endif
}

#define FREE_SOCKET(i) \
    free_newsocket(&init_sockets[(i)]); \
    init_sockets[(i)].status = Ns_Avail; \
    socket_info.nconns--;

void doeric_server()
{
    int i, pollret, rr;
    struct sockaddr_in addr;
    socklen_t addrlen = sizeof(addr);
    player *pl, *next;

#if CS_LOGSTATS
    if ((time(NULL) - cst_lst.time_start) >= CS_LOGTIME)
    {
        write_cs_stats();
    }
#endif

    FD_ZERO(&tmp_read);
    FD_ZERO(&tmp_write);
    FD_ZERO(&tmp_exceptions);

    for (i = 0; i < socket_info.allocated_sockets; i++)
    {
        if (init_sockets[i].status == Ns_Add && !is_fd_valid(init_sockets[i].fd))
        {
            LOG(llevDebug, "doeric_server(): Invalid waiting fd %d\n", i);
            init_sockets[i].status = Ns_Dead;
        }

        if (init_sockets[i].status == Ns_Dead)
        {
            FREE_SOCKET(i);
        }
        else if (init_sockets[i].status == Ns_Zombie)
        {
            if (init_sockets[i].login_count++ >= 1000000 / MAX_TIME)
            {
                init_sockets[i].status = Ns_Dead;
            }
        }
        else if (init_sockets[i].status != Ns_Avail)
        {
            if (init_sockets[i].status > Ns_Wait)
            {
                if (init_sockets[i].keepalive++ >= (uint32) SOCKET_KEEPALIVE_TIMEOUT * (1000000 / max_time))
                {
                    LOG(llevInfo, "Keepalive: disconnecting %s: %d\n", init_sockets[i].host ? init_sockets[i].host : "(unknown ip?)", init_sockets[i].fd);
                    FREE_SOCKET(i);
                    continue;
                }
            }

            FD_SET((uint32) init_sockets[i].fd, &tmp_read);
            FD_SET((uint32) init_sockets[i].fd, &tmp_write);
            FD_SET((uint32) init_sockets[i].fd, &tmp_exceptions);
        }
    }

    /* Go through the players. Let the loop set the next pl value, since
     * we may remove some. */
    for (pl = first_player; pl != NULL; )
    {
        if (pl->socket.status != Ns_Dead && !is_fd_valid(pl->socket.fd))
        {
            LOG(llevDebug, "doeric_server(): Invalid file descriptor for player %s [%s]: %d\n", (pl->ob && pl->ob->name) ? pl->ob->name : "(unnamed player?)", (pl->socket.host) ? pl->socket.host : "(unknown ip?)", pl->socket.fd);
            pl->socket.status = Ns_Dead;
        }

        if (pl->socket.status != Ns_Dead && pl->socket.socket_version >= 1052 && pl->socket.keepalive++ >= (uint32) SOCKET_KEEPALIVE_TIMEOUT * (1000000 / max_time))
        {
            LOG(llevInfo, "Keepalive: disconnecting %s [%s]: %d\n", (pl->ob && pl->ob->name) ? pl->ob->name : "(unnamed player?)", (pl->socket.host) ? pl->socket.host : "(unknown ip?)", pl->socket.fd);
            pl->socket.status = Ns_Dead;
        }

        if (pl->socket.status == Ns_Dead)
        {
            player *npl = pl->next;

            remove_ns_dead_player(pl);
            pl = npl;
        }
        else if (pl->socket.status == Ns_Zombie)
        {
            if (pl->socket.login_count++ >= 1000000 / MAX_TIME)
            {
                pl->socket.status = Ns_Dead;
            }
        }
        else
        {
            FD_SET((uint32) pl->socket.fd, &tmp_read);
            FD_SET((uint32) pl->socket.fd, &tmp_write);
            FD_SET((uint32) pl->socket.fd, &tmp_exceptions);
            pl = pl->next;
        }
    }

    socket_info.timeout.tv_sec = 0;
    socket_info.timeout.tv_usec = 0;

    pollret = select(socket_info.max_filedescriptor, &tmp_read, &tmp_write, &tmp_exceptions, &socket_info.timeout);

    if (pollret == -1)
    {
        LOG(llevDebug, "doeric_server(): select failed: %s\n", strerror_local(errno));
        return;
    }

    /* Following adds a new connection */
    if (pollret && FD_ISSET(init_sockets[0].fd, &tmp_read))
    {
        int newsocknum = 0;

        /* If this is the case, all sockets are currently in use */
        if (socket_info.allocated_sockets <= socket_info.nconns)
        {
            init_sockets = realloc(init_sockets, sizeof(socket_struct) * (socket_info.nconns + 1));

            if (!init_sockets)
            {
                LOG(llevError, "doeric_server(): Out of memory\n");
            }

            newsocknum = socket_info.allocated_sockets;
            socket_info.allocated_sockets++;
            init_sockets[newsocknum].status = Ns_Avail;
        }
        else
        {
            int j;

            for (j = 1; j < socket_info.allocated_sockets; j++)
            {
                if (init_sockets[j].status == Ns_Avail)
                {
                    newsocknum = j;
                    break;
                }
            }
        }

        init_sockets[newsocknum].fd = accept(init_sockets[0].fd, (struct sockaddr *) &addr, &addrlen);

        if (init_sockets[newsocknum].fd == -1)
        {
            LOG(llevDebug, "doeric_server(): accept failed: %s\n", strerror_local(errno));
        }
        else
        {
            char buf[MAX_BUF];
            long 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);

            if (checkbanned(NULL, buf))
            {
                LOG(llevSystem, "Ban: Banned IP tried to connect: %s\n", buf);
#ifndef WIN32
                close(init_sockets[newsocknum].fd);
#else
                shutdown(init_sockets[newsocknum].fd, SD_BOTH);
                closesocket(init_sockets[newsocknum].fd);
#endif
                init_sockets[newsocknum].fd = -1;
            }
            else
            {
                init_connection(&init_sockets[newsocknum], buf);
                socket_info.nconns++;
            }
        }
    }

    /* Check for any exceptions/input on the sockets */
    if (pollret)
    {
        for (i = 1; i < socket_info.allocated_sockets; i++)
        {
            if (init_sockets[i].status == Ns_Avail)
            {
                continue;
            }

            if (FD_ISSET(init_sockets[i].fd, &tmp_exceptions))
            {
                FREE_SOCKET(i);
                continue;
            }

            if (FD_ISSET(init_sockets[i].fd, &tmp_read))
            {
                rr = SockList_ReadPacket(&init_sockets[i], MAXSOCKBUF_IN - 1);

                if (rr < 0)
                {
                    LOG(llevInfo, "Drop connection: %s\n", STRING_SAFE(init_sockets[i].host));
                    init_sockets[i].status = Ns_Dead;
                }
                else
                {
                    fill_command_buffer(&init_sockets[i]);
                }
            }

            if (init_sockets[i].status == Ns_Avail)
            {
                continue;
            }

            if (init_sockets[i].status == Ns_Dead)
            {
                FREE_SOCKET(i);
                continue;
            }

            if (FD_ISSET(init_sockets[i].fd, &tmp_write))
            {
                socket_buffer_write(&init_sockets[i]);
            }

            if (init_sockets[i].status == Ns_Dead)
            {
                FREE_SOCKET(i);
            }
        }
    }

    /* This does roughly the same thing, but for the players now */
    for (pl = first_player; pl; pl = next)
    {
        next = pl->next;

        /* Kill players if we have problems */
        if (pl->socket.status == Ns_Dead || FD_ISSET(pl->socket.fd, &tmp_exceptions))
        {
            remove_ns_dead_player(pl);
            continue;
        }

        if (FD_ISSET(pl->socket.fd, &tmp_read))
        {
            rr = SockList_ReadPacket(&pl->socket, MAXSOCKBUF_IN - 1);

            if (rr < 0)
            {
                LOG(llevInfo, "Drop connection: %s (%s)\n", STRING_OBJ_NAME(pl->ob), STRING_SAFE(pl->socket.host));
                pl->socket.status = Ns_Dead;
            }
            else
            {
                fill_command_buffer(&pl->socket);
            }
        }

        /* Perhaps something was bad in handle_client(), or player has
         * left the game. */
        if (pl->socket.status == Ns_Dead)
        {
            remove_ns_dead_player(pl);
            continue;
        }

        if (FD_ISSET(pl->socket.fd, &tmp_write))
        {
            socket_buffer_write(&pl->socket);
        }
    }
}

void doeric_server_write()
{
    player *pl, *next;
    uint32 update_below;

    /* This does roughly the same thing, but for the players now */
    for (pl = first_player; pl; pl = next)
    {
        next = pl->next;

        if (pl->socket.status == Ns_Dead || FD_ISSET(pl->socket.fd, &tmp_exceptions))
        {
            remove_ns_dead_player(pl);
            continue;
        }

        esrv_update_stats(pl);
        party_update_who(pl);

        if (pl->update_skills)
        {
            esrv_update_skills(pl);
            pl->update_skills = 0;
        }

        draw_client_map(pl->ob);

        if (pl->ob->map && (update_below = GET_MAP_UPDATE_COUNTER(pl->ob->map, pl->ob->x, pl->ob->y)) != pl->socket.update_tile)
        {
            esrv_draw_look(pl->ob);
            pl->socket.update_tile = update_below;
        }

        if (FD_ISSET(pl->socket.fd, &tmp_write))
        {
            socket_buffer_write(&pl->socket);
        }
    }
}