/* packet-tibia.c

 * Routines for Tibia/OTServ login and game protocol dissection

 *

 * Copyright 2017, Ahmad Fatoum <ahmad[AT]a3f.at>

 *

 * A dissector for:

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

 * SPDX-License-Identifier: GPL-2.0-or-later

 */

/* Tibia (https://tibia.com) is a Massively Multiplayer Online Role-Playing

 * Game (MMORPG) by Cipsoft GmbH.

 *

 * Three official clients exist: The current Qt-based 11.0+ client,

 * the old C++ client used from Tibia 7.0 till 10.99 and the Flash client.

 * The latter two are being phased out. They use the same protocol,

 * except that the session key for the Flash client is transported alongside

 * the character list over HTTPS. It's possible this is done in the same manner

 * as in the native client from 10.74 up. We don't support the Flash client.

 *

 * The dissector supports Tibia versions from 7.0 (2001) till

 * 11.00 (2016-10-12). Tibia has an active open source server emulator

 * community (OTServ) that still makes use of older versions and surpasses

 * the official servers in popularity, therefore compatibility with older

 * protocol iterations should be maintained.

 *

 * Transport is over TCP, with recent versions encrypting player interaction

 * with XTEA. Authentication and key exchange is done with a hard-coded

 * RSA public key in the client.

 *

 * Two protocols are dissected: The Tibia login protocol and the Tibia game

 * protocol. Traditionally, login servers were stateless and only responsible

 * for providing the addresses of the game servers alongside the character

 * list upon successful authentication. Then a new authentication request

 * (this time with character selection) is sent to the game server.

 * That way, a client who knows the game server address can very well skip

 * the login server entirely. Starting with 10.61, this is no longer possible,

 * as the login server provides a session key that needs to be sent to the

 * game server.

 *

 * Starting with Tibia 7.61, login server requests can't be reliably

 * differentiated from game server requests. Therefore we apply some heuristics

 * to classify packets.

 *

 * Starting with Tibia 11.01, a web service takes the role of the login server.

 * Starting with Tibia 11.11, the Adler32 checksum was replaced by a 32-bit

 * sequence number. The most significant bit indicates whether the packet was

 * DEFLATE-compressed. These features are not yet supported.

 *

 * Packets from and to the game server contain commands. Commands are

 * identified by the first octet and are variable in length. The dissector has

 * most command names hard-coded. However, a complete implementation of the

 * game protocol is unlikely.

 *

 * The RSA private key usually used by OTServ is hard-coded in. Server

 * administrators may add their own private key in PEM or PKCS#12 format over

 * an UAT. For servers where the private key is indeed private (like

 * for official servers), the symmetric XTEA key (retrievable by memory

 * peeking or MitM) may be provided to the dissector via UAT.

 *

 * Unsurprisingly, no official specification of the protocol exist, following

 * resources have been written by the community:

 *

 * - OTServ: Community effort to replicate a Tibia Server.

 * - Outcast: A Tibia client implementation of the game protocol as of 2006.

 *            Comes with a PDF spec written by Khaos

 * - TibiaAPI: Bot framework, containing a listing of commands as of 2009

 * - TFS: OTServ-Fork which is kept up-to-date with most of the official protocol

 * - otclient: Open Source implementation of an up-to-date Tibia client

 *

 * An official slide set by Cipsoft detailing the architecture of Tibia

 * from Game Developers Conference Europe 2011 is also available:

 * http://www.gdcvault.com/play/1014908/Inside-Tibia-The-Technical-Infrastructure

 *

 * The login protocol, as implemented here, has been inferred from network

 * footage and game client execution traces and was written from scratch.

 * The listing of game protocol commands were taken from TibiaAPI and Khaos' spec

 * No code of Cipsoft GmbH was used.

 *

 * Tibia is a registered trademark of Cipsoft GmbH.

 */

#include "config.h"

#include <epan/packet.h>

#include "packet-tcp.h"

#include <wsutil/adler32.h>

#include <epan/address.h>

#include <epan/prefs.h>

#include <epan/uat.h>

#include <epan/conversation.h>

#include <epan/value_string.h>

#include <epan/expert.h>

#include <epan/tfs.h>

#include <epan/unit_strings.h>

#include <wsutil/array.h>

#include <wsutil/file_util.h>

#include <wsutil/wsgcrypt.h>

#include <wsutil/report_message.h>

#include <wsutil/xtea.h>

#include <wsutil/strtoi.h>

#include <wsutil/rsa.h>

#include <errno.h>

#include <epan/ptvcursor.h>

void proto_register_tibia(void);

void proto_reg_handoff_tibia(void);

static int dissect_tibia_tcp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_);

static dissector_handle_t tibia_handle;

/* preferences */

static bool try_otserv_key          = true,

                show_char_name          = true,

                show_acc_info           = true,

                show_xtea_key           = false,

                dissect_game_commands   = false,

                reassemble_tcp_segments = true;

/* User Access Tables */

#if HAVE_LIBGNUTLS

struct rsakey {

    address addr;

    uint16_t port;

    gcry_sexp_t privkey;

};

GHashTable *rsakeys;

struct rsakeys_assoc {

    char *ipaddr;

    char *port;

    char *keyfile;

    char *password;

};

UAT_CSTRING_CB_DEF(rsakeylist_uats,  ipaddr,   struct rsakeys_assoc)

UAT_CSTRING_CB_DEF(rsakeylist_uats,  port,     struct rsakeys_assoc)

UAT_FILENAME_CB_DEF(rsakeylist_uats, keyfile,  struct rsakeys_assoc)

UAT_CSTRING_CB_DEF(rsakeylist_uats,  password, struct rsakeys_assoc)

static void rsakey_free(void *_rsakey);

static uat_t *rsakeys_uat;

static struct rsakeys_assoc  *rsakeylist_uats;

static unsigned nrsakeys;

#endif

#define XTEA_KEY_LEN 16

struct xteakeys_assoc {

    uint32_t framenum;

    char *key;

};

GHashTable *xteakeys;

static void *xteakeys_copy_cb(void *, const void *, size_t);

static void xteakeys_free_cb(void *);

static void xtea_parse_uat(void);

static bool xteakeys_uat_fld_key_chk_cb(void *, const char *, unsigned, const void *, const void *, char **);

UAT_DEC_CB_DEF(xteakeylist_uats, framenum, struct xteakeys_assoc)

UAT_CSTRING_CB_DEF(xteakeylist_uats, key, struct xteakeys_assoc)

static uat_t *xteakeys_uat;

static struct xteakeys_assoc *xteakeylist_uats;

static unsigned nxteakeys;

#define COND_POISONED     0x00000001

#define COND_BURNING      0x00000002

#define COND_ELECTROCUTED 0x00000004

#define COND_DRUNK        0x00000008

#define COND_MANASHIELD   0x00000010

#define COND_PARALYZED    0x00000020

#define COND_HASTE        0x00000040

#define COND_BATTLE       0x00000080

#define COND_DROWNING     0x00000100

#define COND_FREEZING     0x00000200

#define COND_DAZZLED      0x00000400

#define COND_CURSED       0x00000800

#define COND_BUFF         0x00001000

#define COND_PZBLOCK      0x00002000

#define COND_PZ           0x00004000

#define COND_BLEEDING     0x00008000

#define COND_HUNGRY       0x00010000

/* The login server has been traditionally on 7171,

 * For OTServ, the game server often listens on the same IP/port,

 * but occasionally on 7172. Official Tibia doesn't host login and

 * game servers on the same IP address

 */

#define TIBIA_DEFAULT_TCP_PORT_RANGE "7171,7172"

static int proto_tibia;

static int hf_tibia_len;

static int hf_tibia_nonce;

static int hf_tibia_adler32;

static int hf_tibia_adler32_status;

static int hf_tibia_os;

static int hf_tibia_proto_version;

static int hf_tibia_client_version;

static int hf_tibia_file_versions;

static int hf_tibia_file_version_spr;

static int hf_tibia_file_version_dat;

static int hf_tibia_file_version_pic;

static int hf_tibia_game_preview_state;

static int hf_tibia_content_revision;

static int hf_tibia_undecoded_rsa_data;

static int hf_tibia_undecoded_xtea_data;

static int hf_tibia_unknown;

static int hf_tibia_xtea_key;

static int hf_tibia_loginflags_gm;

static int hf_tibia_acc_name;

static int hf_tibia_acc_number;

static int hf_tibia_session_key;

static int hf_tibia_char_name;

static int hf_tibia_acc_pass;

static int hf_tibia_char_name_convo;

static int hf_tibia_acc_name_convo;

static int hf_tibia_acc_pass_convo;

static int hf_tibia_session_key_convo;

static int hf_tibia_client_info;

static int hf_tibia_client_locale;

static int hf_tibia_client_locale_id;

static int hf_tibia_client_locale_name;

static int hf_tibia_client_ram;

static int hf_tibia_client_cpu;

static int hf_tibia_client_cpu_name;

static int hf_tibia_client_clock;

static int hf_tibia_client_clock2;

static int hf_tibia_client_gpu;

static int hf_tibia_client_vram;

static int hf_tibia_client_resolution;

static int hf_tibia_client_resolution_x;

static int hf_tibia_client_resolution_y;

static int hf_tibia_client_resolution_hz;

static int hf_tibia_payload_len;

static int hf_tibia_loginserv_command;

static int hf_tibia_gameserv_command;

static int hf_tibia_client_command;

static int hf_tibia_motd;

static int hf_tibia_dlg_error;

static int hf_tibia_dlg_info;

static int hf_tibia_charlist;

static int hf_tibia_charlist_length;

static int hf_tibia_charlist_entry_name;

static int hf_tibia_charlist_entry_world;

static int hf_tibia_charlist_entry_ip;

static int hf_tibia_charlist_entry_port;

static int hf_tibia_worldlist;

static int hf_tibia_worldlist_length;

static int hf_tibia_worldlist_entry_name;

static int hf_tibia_worldlist_entry_ip;

static int hf_tibia_worldlist_entry_port;

static int hf_tibia_worldlist_entry_preview;

static int hf_tibia_worldlist_entry_id;

static int hf_tibia_pacc_days;

static int hf_tibia_channel_id;

static int hf_tibia_channel_name;

static int hf_tibia_char_cond;

static int hf_tibia_char_cond_poisoned;

static int hf_tibia_char_cond_burning;

static int hf_tibia_char_cond_electrocuted;

static int hf_tibia_char_cond_drunk;

static int hf_tibia_char_cond_manashield;

static int hf_tibia_char_cond_paralyzed;

static int hf_tibia_char_cond_haste;

static int hf_tibia_char_cond_battle;

static int hf_tibia_char_cond_drowning;

static int hf_tibia_char_cond_freezing;

static int hf_tibia_char_cond_dazzled;

static int hf_tibia_char_cond_cursed;

static int hf_tibia_char_cond_buff;

static int hf_tibia_char_cond_pzblock;

static int hf_tibia_char_cond_pz;

static int hf_tibia_char_cond_bleeding;

static int hf_tibia_char_cond_hungry;

static int * const char_conds[] = {

    &hf_tibia_char_cond_poisoned,

    &hf_tibia_char_cond_burning,

    &hf_tibia_char_cond_electrocuted,

    &hf_tibia_char_cond_drunk,

    &hf_tibia_char_cond_manashield,

    &hf_tibia_char_cond_paralyzed,

    &hf_tibia_char_cond_haste,

    &hf_tibia_char_cond_battle,

    &hf_tibia_char_cond_drowning,

    &hf_tibia_char_cond_freezing,

    &hf_tibia_char_cond_dazzled,

    &hf_tibia_char_cond_cursed,

    &hf_tibia_char_cond_buff,

    &hf_tibia_char_cond_pzblock,

    &hf_tibia_char_cond_pz,

    &hf_tibia_char_cond_bleeding,

    &hf_tibia_char_cond_hungry,

    NULL

};

static int hf_tibia_chat_msg;

static int hf_tibia_speech_type;

static int hf_tibia_coords_x;

static int hf_tibia_coords_y;

static int hf_tibia_coords_z;

static int hf_tibia_coords;

static int hf_tibia_stackpos;

#if 0

static int hf_tibia_item;

#endif

static int hf_tibia_container;

static int hf_tibia_container_icon;

static int hf_tibia_container_slot;

static int hf_tibia_container_slots;

static int hf_tibia_inventory;

static int hf_tibia_vip;

static int hf_tibia_vip_online;

static int hf_tibia_player;

static int hf_tibia_creature;

static int hf_tibia_creature_health;

static int hf_tibia_window;

static int hf_tibia_window_icon;

static int hf_tibia_window_textlen;

static int hf_tibia_window_text;

static int hf_tibia_light_level;

static int hf_tibia_light_color;

static int hf_tibia_magic_effect_id;

static int hf_tibia_animated_text_color;

static int hf_tibia_animated_text;

static int hf_tibia_projectile;

static int hf_tibia_squarecolor;

static int hf_tibia_textmsg_class;

static int hf_tibia_textmsg;

static int hf_tibia_walk_dir;

static int ett_tibia;

static int ett_command;

static int ett_file_versions;

static int ett_client_info;

static int ett_locale;

static int ett_cpu;

static int ett_resolution;

static int ett_charlist;

static int ett_worldlist;

static int ett_char;

static int ett_world;

static int ett_coords;

static int ett_char_cond;

static expert_field ei_xtea_len_toobig;

static expert_field ei_adler32_checksum_bad;

static expert_field ei_rsa_plaintext_no_leading_zero;

static expert_field ei_rsa_ciphertext_too_short;

static expert_field ei_rsa_decrypt_failed;

struct proto_traits {

    uint32_t adler32:1, rsa:1, compression:1, xtea:1, login_webservice:1, acc_name:1, nonce:1,

            extra_gpu_info:1, gmbyte:1, hwinfo:1;

    uint32_t outfit_addons:1, stamina:1, lvl_on_msg:1;

    uint32_t ping:1, client_version:1, game_preview:1, auth_token:1, session_key:1;

    uint32_t game_content_revision:1, worldlist_in_charlist:1;

    unsigned string_enc;

};

struct tibia_convo {

    uint32_t xtea_key[XTEA_KEY_LEN / sizeof (uint32_t)];

    uint32_t xtea_framenum;

    const uint8_t *acc, *pass, *char_name, *session_key;

    struct proto_traits has;

    uint16_t proto_version;

    uint8_t loginserv_is_peer :1;

    uint16_t clientport;

    uint16_t servport;

    gcry_sexp_t privkey;

};

static struct proto_traits

get_version_traits(uint16_t version)

{

    struct proto_traits has;

    memset(&has, 0, sizeof has);

    has.gmbyte = true; /* Not sure when the GM byte first appeared */

    has.string_enc = ENC_ISO_8859_1;

    if (version >= 761) /* 761 was a test client. 770 was the first release */

        has.xtea = has.rsa = true;

    if (version >= 780)

        has.outfit_addons = has.stamina = has.lvl_on_msg = true;

    if (version >= 830)

        has.adler32 = has.acc_name = true;

    if (version >= 841)

        has.hwinfo = has.nonce = true;

    if (version >= 953)

        has.ping = true;

    if (version >= 980)

        has.client_version = has.game_preview = true;

    if (version >= 1010)

        has.worldlist_in_charlist = true;

    if (version >= 1061)

        has.extra_gpu_info = true;

    if (version >= 1071)

        has.game_content_revision = true;

    if (version >= 1072)

        has.auth_token = true;

    if (version >= 1074)

        has.session_key = true;

    if (version >= 1101)

        has.login_webservice = true;

    if (version >= 1111) {

        has.compression = true; /* with DEFLATE */

        has.adler32 = false;

    }

#if 0 /* With the legacy client being phased out, maybe Unicode support incoming? */

    if (version >= 11xy)

        has.string_enc = ENC_UTF_8;

#endif

    return has;

}

static uint16_t

get_version_get_charlist_packet_size(struct proto_traits *has)

{

    uint16_t size = 2;

    if (has->adler32 || has->compression)

        size += 4;

    size += 17;

    if (has->extra_gpu_info)

        size += 222;

    if (has->rsa)

        size += 128;

    return size;

}

static uint16_t

get_version_char_login_packet_size(struct proto_traits *has)

{

    uint16_t size = 2;

    if (has->adler32 || has->compression)

        size += 4;

    size += 5;

    if (has->client_version)

        size += 4;

    if (has->game_content_revision)

        size += 2;

    if (has->game_preview)

        size += 1;

    if (has->rsa)

        size += 128;

    return size;

}

#define XTEA_FROM_UAT 0

#define XTEA_UNKNOWN  0xFFFFFFFF

static struct tibia_convo *

tibia_get_convo(packet_info *pinfo)

{

    conversation_t *epan_conversation = find_or_create_conversation(pinfo);

    struct tibia_convo *convo = (struct tibia_convo*)conversation_get_proto_data(epan_conversation, proto_tibia);

    if (!convo) {

        address *servaddr;

        convo = wmem_new0(wmem_file_scope(), struct tibia_convo);

        /* FIXME there gotta be a cleaner way... */

        if (pinfo->srcport >= 0xC000) {

            convo->clientport = pinfo->srcport;

            convo->servport = pinfo->destport;

            servaddr = &pinfo->dst;

        } else {

            convo->clientport = pinfo->destport;

            convo->servport = pinfo->srcport;

            servaddr = &pinfo->src;

        }

        (void)servaddr;

#ifdef HAVE_LIBGNUTLS

        struct rsakey rsa_key;

        rsa_key.port = convo->servport;

        rsa_key.addr = *servaddr;

        convo->privkey = (gcry_sexp_t)g_hash_table_lookup(rsakeys, &rsa_key);

#endif

        convo->xtea_framenum = XTEA_UNKNOWN;

        conversation_add_proto_data(epan_conversation, proto_tibia, (void *)convo);

    }

    if (convo->xtea_framenum == XTEA_UNKNOWN) {

        uint8_t *xtea_key = (uint8_t*)g_hash_table_lookup(xteakeys, GUINT_TO_POINTER(pinfo->num));

        if (xtea_key) {

            memcpy(convo->xtea_key, xtea_key, XTEA_KEY_LEN);

            convo->xtea_framenum = XTEA_FROM_UAT;

        }

    }

    return convo;

}

static uint32_t

ipv4tonl(const char *str)

{

        uint32_t ipaddr = 0;

        for (int octet = 0; octet < 4; octet++) {

            ws_strtou8(str, &str, &((uint8_t*)&ipaddr)[octet]);

            str++;

        }

        return ipaddr;

}

static void

register_gameserv_addr(struct tibia_convo *convo, uint32_t ipaddr, uint16_t port)

{

    (void)convo; (void)ipaddr; (void)port;

#if HAVE_LIBGNUTLS

    /* Game servers in the list inherit the same RSA key as the login server */

    if (convo->has.rsa) {

        struct rsakey *entry = g_new(struct rsakey, 1);

        alloc_address_wmem(NULL, &entry->addr, AT_IPv4, sizeof ipaddr, &ipaddr);

        entry->port = port;

        entry->privkey = NULL;

        if (g_hash_table_lookup(rsakeys, entry) == NULL) {

            entry->privkey = convo->privkey;

            g_hash_table_insert(rsakeys, entry, entry->privkey);

        } else {

            rsakey_free(entry);

        }

    }

    /* TODO Mark all communication with the IP/Port pair above

     * as Tibia communication. How?

     */

#endif

}

static gcry_sexp_t otserv_key;

static gcry_sexp_t

convo_get_privkey(struct tibia_convo *convo)

{

    return convo->privkey ? convo->privkey

         : try_otserv_key ? otserv_key

         : NULL;

}

enum client_cmd {

    /* from TibiaAPI */

    C_GET_CHARLIST          = 0x01,

    C_LOGIN_CHAR            = 0x0A,

    C_LOGOUT                = 0x14, /* I think this is a 7.7+ thing */

    C_PONG                  = 0x1E,

    C_AUTO_WALK             = 0x64,

    C_GO_NORTH              = 0x65,

    C_GO_EAST               = 0x66,

    C_GO_SOUTH              = 0x67,

    C_GO_WEST               = 0x68,

    C_AUTO_WALK_CANCEL      = 0x69,

    C_GO_NE                 = 0x6A,

    C_GO_SE                 = 0x6B,

    C_GO_SW                 = 0x6C,

    C_GO_NW                 = 0x6D,

    C_TURN_NORTH            = 0x6F,

    C_TURN_EAST             = 0x70,

    C_TURN_SOUTH            = 0x71,

    C_TURN_WEST             = 0x72,

    C_MOVE_ITEM             = 0x78,

    C_SHOP_BUY              = 0x7A,

    C_SHOP_SELL             = 0x7B,

    C_SHOP_CLOSE            = 0x7C,

    C_ITEM_USE              = 0x82,

    C_ITEM_USE_ON           = 0x83,

    C_ITEM_USE_BATTLELIST   = 0x84,

    C_ITEM_ROTATE           = 0x85,

    C_CONTAINER_CLOSE       = 0x87,

    C_CONTAINER_OPEN_PARENT = 0x88,

    C_LOOK_AT               = 0x8C,

    C_PLAYER_SPEECH         = 0x96,

    C_CHANNEL_LIST          = 0x97,

    C_CHANNEL_OPEN          = 0x98,

    C_CHANNEL_CLOSE         = 0x99,

    C_PRIVATE_CHANNEL_OPEN  = 0x9A,

    C_NPC_CHANNEL_CLOSE     = 0x9E,

    C_FIGHT_MODES           = 0xA0,

    C_ATTACK                = 0xA1,

    C_FOLLOW                = 0xA2,

    C_CANCEL_GO             = 0xBE,

    C_TILE_UPDATE           = 0xC9,

    C_CONTAINER_UPDATE      = 0xCA,

    C_SET_OUTFIT            = 0xD3,

    C_VIP_ADD               = 0xDC,

    C_VIP_REMOVE            = 0xDD

 };

static const value_string from_client_packet_types[] = {

    { C_GET_CHARLIST,     "Charlist request" },

    { C_LOGIN_CHAR,       "Character login" },

    { C_LOGOUT,           "Logout" },

    { C_PONG,             "Pong" },

    { C_AUTO_WALK,        "Map walk" },

    { C_GO_NORTH,         "Go north"},

    { C_GO_EAST,          "Go east"},

    { C_GO_SOUTH,         "Go south"},

    { C_GO_WEST,          "Go west"},

    { C_AUTO_WALK_CANCEL, "Map walk cancel" },

    { C_GO_NE,            "Go north-east"},

    { C_GO_SE,            "Go south-east"},

    { C_GO_SW,            "Go south-west"},

    { C_GO_NW,            "Go north-west"},

    { C_TURN_NORTH,      "Turn north" },

    { C_TURN_EAST,       "Turn east" },

    { C_TURN_SOUTH,      "Turn south" },

    { C_TURN_WEST,       "Turn west" },

    { C_MOVE_ITEM,       "Move item" },

    { C_SHOP_BUY,        "Buy in shop" },

    { C_SHOP_SELL,       "Sell in shop" },

    { C_SHOP_CLOSE,      "Close shop" },

    { C_ITEM_USE,        "Use item" },

    { C_ITEM_USE_ON,     "Use item on" },

    { C_ITEM_USE_BATTLELIST,   "Use item on battle list" },

    { C_ITEM_ROTATE,           "Rotate item" },

    { C_CONTAINER_CLOSE,       "Close container" },

    { C_CONTAINER_OPEN_PARENT, "Open parent container" },

    { C_LOOK_AT,               "Look at" },

    { C_PLAYER_SPEECH,         "Speech" },

    { C_CHANNEL_LIST,          "List channels" },

    { C_CHANNEL_OPEN,          "Open public channel" },

    { C_CHANNEL_CLOSE,         "close channel" },

    { C_PRIVATE_CHANNEL_OPEN,  "Open private channel" },

    { C_NPC_CHANNEL_CLOSE,     "Open NPC channel" },

    { C_FIGHT_MODES,           "Set fight modes" },

    { C_ATTACK,                "Attack" },

    { C_FOLLOW,                "Follow" },

    { C_CANCEL_GO,             "Cancel go" },

    { C_TILE_UPDATE,           "Update tile" },

    { C_CONTAINER_UPDATE,      "Update container" },

    { C_SET_OUTFIT,            "Set outfit" },

    { C_VIP_ADD,               "Add VIP" },

    { C_VIP_REMOVE,            "Remove VIP" },

    { 0, NULL }

};

static value_string_ext from_client_packet_types_ext = VALUE_STRING_EXT_INIT(from_client_packet_types);

enum loginserv_cmd {

    LOGINSERV_DLG_ERROR    = 0x0A,

    LOGINSERV_DLG_ERROR2   = 0x0B,

    LOGINSERV_DLG_MOTD     = 0x14,

    LOGINSERV_SESSION_KEY  = 0x28,

    LOGINSERV_DLG_CHARLIST = 0x64

};

static const value_string from_loginserv_packet_types[] = {

    { LOGINSERV_DLG_ERROR,    "Error" },

    { LOGINSERV_DLG_ERROR2,   "Error" },

    { LOGINSERV_DLG_MOTD,     "MOTD" },

    { LOGINSERV_SESSION_KEY,  "Session key" },

    { LOGINSERV_DLG_CHARLIST, "Charlist" },

    { 0, NULL }

};

enum gameserv_cmd {

    /* Credit to Khaos (OBJECT Networks). Values and comments extracted from PDF table */

    S_MAPINIT =                0x0A, /* Long playerCreatureId Int unknownU16 (Byte reportBugs?) */

    S_GMACTIONS =              0x0B, /* Used to be 32 unknown bytes, but with GMs removed it                                      might not be in use anymore */

    S_DLG_ERROR =              0x14, /* String errorMessage */

    S_DLG_INFO =               0x15,

    S_DLG_TOOMANYPLAYERS =     0x16,

    S_PING =                   0x1E,

    S_NONCE =                  0x1F,

    S_PLAYERLOC =              0x64, /* Coord pos */

    S_GO_NORTH =               0x65, /* MapDescription (18,1) */

    S_GO_EAST =                0x66, /* MapDescription (1,14) */

    S_GO_SOUTH =               0x67, /* MapDescription (18,1) */

    S_GO_WEST =                0x68, /* MapDescription (1,14) */

    S_TILEUPDATE =             0x69, /* Coord pos TileDescription td */

    S_ADDITEM =                0x6a, /* Coord pos ThingDescription thing */

    S_REPLACEITEM =            0x6b, /* Coord pos Byte stackpos ThingDescription thing */

    S_REMOVEITEM =             0x6c, /* Coord pos Byte stackpos */

    S_MOVE_THING =             0x6d,

    S_CONTAINER =              0x6e, /* Byte index Short containerIcon Byte slotCount ThingDescription item */

    S_CONTAINERCLOSE =         0x6f, /* Byte index */

    S_ADDITEMCONTAINER =       0x70, /* Byte index ThingDescription itm */

    S_TRANSFORMITEMCONTAINER = 0x71, /* Byte index Byte slot */

    S_REMOVEITEMCONTAINER =    0x72, /* Byte index Byte slot */

    S_INVENTORYEMPTY =         0x78, /* Byte invSlot */

    S_INVENTORYITEM =          0x79, /* Byte invSlot ThingDescription itm */

    S_TRADEREQ =               0x7d, /* String otherperson Byte slotCount ThingDescription itm */

    S_TRADEACK =               0x7e, /* String otherperson Byte slotCount ThingDescription itm */

    S_TRADECLOSE =             0x7f,

    S_LIGHTLEVEL =             0x82, /* Byte lightlevel Byte lightcolor */

    S_MAGIC_EFFECT =           0x83,

    S_ANIMATEDTEXT =           0x84, /* Coord pos Byte color String message */

    S_DISTANCESHOT =           0x85, /* Coord pos1 Byte stackposition Coord pos2 */

    S_CREATURESQUARE =         0x86, /* Long creatureid Byte squarecolor */

    S_CREATURE_HEALTH =        0x8C,

    S_CREATURELIGHT =          0x8d, /* Long creatureid Byte ? Byte ? */

    S_SETOUTFIT =              0x8e, /* Long creatureid Byte lookType Byte headType Byte bodyType Byte legsType Byte feetType // can extended look go here too? */

    S_CREATURESPEED =          0x8f, /* YIKES! I didn't handle this! */

    S_TEXTWINDOW =             0x96, /* Long windowId Byte icon Byte maxlength String message */

    S_STATUSMSG =              0xA0, /* Status status */

    S_SKILLS =                 0xA1, /* Skills skills */

    S_PLAYER_CONDITION =       0xA2,

    S_CANCELATTACK =           0xA3,

    S_SPEAK =                  0xAA,

    S_CHANNELSDIALOG =         0xAB, /* Byte channelCount (Int channelId String channelName) */

    S_CHANNEL_OPEN =           0xAC,

    S_OPENPRIV =               0xAD, /* String playerName */

    S_TEXTMESSAGE =            0xB4, /* Byte msgClass String string */

    S_CANCELWALK =             0xB5, /* Byte direction */

    S_FLOORUP =                0xBE, /* Advanced topic; read separate text */

    S_FLOORDOWN =              0xBF, /* Advanced topic; read separate text */

    S_OUTFITLIST =             0xC8, /* Byte lookType Byte headType Byte bodyType Byte legsType Byte feetType Byte firstModel Byte lastModel */

    S_VIPADD =                 0xD2, /* long guid string name byte isonline */

    S_VIPLOGIN =               0xD3, /* long guid */

    S_VIPLOGOUT =              0xD4  /* long guid*/

};

static const value_string from_gameserv_packet_types[] = {

    { S_MAPINIT,            "Initialize map" },

    { S_GMACTIONS,          "GM actions" },

    { S_DLG_ERROR,          "Error" },

    { S_DLG_INFO,           "Info" },

    { S_DLG_TOOMANYPLAYERS, "Too many players" },

    { S_PING,               "Ping" },

    { S_NONCE,              "Nonce" },

    { S_PLAYERLOC,      "Set player location" },

    { S_GO_NORTH,       "Go north" },

    { S_GO_EAST,        "Go east" },

    { S_GO_SOUTH,       "Go south" },

    { S_GO_WEST,        "Go west" },

    { S_TILEUPDATE,     "Update tile" },

    { S_ADDITEM,        "Add item" },

    { S_REPLACEITEM,    "Replace item" },

    { S_REMOVEITEM,     "Remove item" },

    { S_MOVE_THING,     "Move thing" },

    { S_CONTAINER,      "Open container" },

    { S_CONTAINERCLOSE, "Close container" },

    { S_ADDITEMCONTAINER,       "Add item in container" },

    { S_TRANSFORMITEMCONTAINER, "Transform item in container" },

    { S_REMOVEITEMCONTAINER,    "Remove item in container" },

    { S_INVENTORYEMPTY,   "Inventory empty" },

    { S_INVENTORYITEM,    "Inventory item" },

    { S_TRADEREQ,         "Trade request" },

    { S_TRADEACK,         "Trade acknowledge" },

    { S_TRADECLOSE,       "Trade over" },

    { S_LIGHTLEVEL,       "Light level" },

    { S_MAGIC_EFFECT,     "Magic effect" },

    { S_ANIMATEDTEXT,     "Animated text" },

    { S_DISTANCESHOT,     "Distance shot" },

    { S_CREATURESQUARE,   "Creature square" },

    { S_CREATURE_HEALTH,  "Creature health" },

    { S_CREATURELIGHT,    "Creature light" },

    { S_SETOUTFIT,        "Set outfit" },

    { S_CREATURESPEED,    "Set creature speed" },

    { S_TEXTWINDOW,       "Text window" },

    { S_STATUSMSG,        "Status message" },

    { S_SKILLS,           "Skills" },

    { S_PLAYER_CONDITION, "Player condition" },

    { S_CANCELATTACK,     "Cancel attack" },

    { S_SPEAK,            "Creature speech" },

    { S_CHANNELSDIALOG,   "Channels dialog" },

    { S_CHANNEL_OPEN,     "Channel open" },

    { S_OPENPRIV,         "Private channel open" },

    { S_TEXTMESSAGE,      "Text message" },

    { S_CANCELWALK,       "Cancel walk" },

    { S_FLOORUP,          "Floor +1" },

    { S_FLOORDOWN,        "Floor -1" },

    { S_OUTFITLIST,       "Outfit list" },

    { S_VIPADD,           "Add VIP" },

    { S_VIPLOGIN,         "VIP login" },

    { S_VIPLOGOUT,        "VIP logout" },

    { 0, NULL }

};

static value_string_ext from_gameserv_packet_types_ext = VALUE_STRING_EXT_INIT(from_gameserv_packet_types);

static const unit_name_string mb_unit = {"MB", NULL};

static int

dissect_loginserv_packet(struct tibia_convo *convo, tvbuff_t *tvb, int offset, int len, packet_info *pinfo, proto_tree *tree, bool first_fragment )

{

    ptvcursor_t *ptvc = ptvcursor_new(pinfo->pool, tree, tvb, offset);

    col_append_str(pinfo->cinfo, COL_INFO, first_fragment ? " commands:" : ",");

    len += offset;

    if (ptvcursor_current_offset(ptvc) < len) {

        for (;;) {

            int cmd = tvb_get_uint8(tvb, ptvcursor_current_offset(ptvc));

            ptvcursor_add_with_subtree(ptvc, hf_tibia_loginserv_command, 1, ENC_NA, ett_command);

            ptvcursor_advance(ptvc, 1);

            switch ((enum loginserv_cmd)cmd) {

                case LOGINSERV_DLG_ERROR:

                case LOGINSERV_DLG_ERROR2:

                    ptvcursor_add(ptvc, hf_tibia_dlg_error, 2, ENC_LITTLE_ENDIAN | convo->has.string_enc);

                    break;

                case LOGINSERV_DLG_MOTD:

                    ptvcursor_add(ptvc, hf_tibia_motd, 2, ENC_LITTLE_ENDIAN | convo->has.string_enc);

                    break;

                case LOGINSERV_SESSION_KEY:

                    ptvcursor_add(ptvc, hf_tibia_session_key, 2, ENC_LITTLE_ENDIAN | convo->has.string_enc);

                    break;

                case LOGINSERV_DLG_CHARLIST:

                    if (convo->has.worldlist_in_charlist) {

                        uint8_t world_count = tvb_get_uint8(tvb, ptvcursor_current_offset(ptvc));

                        ptvcursor_add(ptvc, hf_tibia_worldlist_length, 1, ENC_NA);

                        /* Empty character list? */

                        if (world_count) {

                            ptvcursor_add_with_subtree(ptvc, hf_tibia_worldlist, SUBTREE_UNDEFINED_LENGTH, ENC_NA, ett_worldlist);

                            while (world_count--) {

                                proto_item *it = ptvcursor_add(ptvc, hf_tibia_worldlist_entry_id, 1, ENC_NA);

                                ptvcursor_push_subtree(ptvc, it, ett_world);

                                ptvcursor_add(ptvc, hf_tibia_worldlist_entry_name, 2, ENC_LITTLE_ENDIAN | convo->has.string_enc);

                                unsigned ipv4addr_len = tvb_get_letohs(tvb, ptvcursor_current_offset(ptvc));

                                char *ipv4addr_str = (char*)tvb_get_string_enc(pinfo->pool, tvb, ptvcursor_current_offset(ptvc) + 2, ipv4addr_len, ENC_LITTLE_ENDIAN | convo->has.string_enc);

                                uint32_t ipv4addr = ipv4tonl(ipv4addr_str);

                                ptvcursor_add(ptvc, hf_tibia_worldlist_entry_ip, 2, ENC_LITTLE_ENDIAN | convo->has.string_enc);

                                uint16_t port = tvb_get_letohs(tvb, ptvcursor_current_offset(ptvc));

                                ptvcursor_add(ptvc, hf_tibia_worldlist_entry_port, 2, ENC_LITTLE_ENDIAN);

                                ptvcursor_add(ptvc, hf_tibia_worldlist_entry_preview, 1, ENC_NA);

                                ptvcursor_pop_subtree(ptvc);

                                register_gameserv_addr(convo, ipv4addr, port);

                            }

                            ptvcursor_pop_subtree(ptvc);

                        }

                        uint8_t char_count = tvb_get_uint8(tvb, ptvcursor_current_offset(ptvc));

                        ptvcursor_add(ptvc, hf_tibia_charlist_length, 1, ENC_NA);

                        if (char_count) {

                            ptvcursor_add_with_subtree(ptvc, hf_tibia_charlist, SUBTREE_UNDEFINED_LENGTH, ENC_NA, ett_charlist);

                            while (char_count--) {

                                proto_item *it = ptvcursor_add(ptvc, hf_tibia_worldlist_entry_id, 1, ENC_NA);

                                ptvcursor_push_subtree(ptvc, it, ett_char);

                                ptvcursor_add(ptvc, hf_tibia_charlist_entry_name, 2, ENC_LITTLE_ENDIAN | convo->has.string_enc);

                                ptvcursor_pop_subtree(ptvc);

                            }

                            ptvcursor_pop_subtree(ptvc);

                        }

                    } else {

                        uint8_t char_count = tvb_get_uint8(tvb, ptvcursor_current_offset(ptvc));

                        ptvcursor_add(ptvc, hf_tibia_charlist_length, 1, ENC_NA);

                        if (char_count) {

                            ptvcursor_add_with_subtree(ptvc, hf_tibia_charlist, SUBTREE_UNDEFINED_LENGTH, ENC_NA, ett_charlist);

                            while (char_count--) {

                                proto_item *it = ptvcursor_add(ptvc, hf_tibia_charlist_entry_name, 2, ENC_LITTLE_ENDIAN | convo->has.string_enc);

                                ptvcursor_push_subtree(ptvc, it, ett_char);

                                ptvcursor_add(ptvc, hf_tibia_charlist_entry_world, 2, ENC_LITTLE_ENDIAN | convo->has.string_enc);

                                uint32_t ipv4addr = tvb_get_ipv4(tvb, ptvcursor_current_offset(ptvc));

                                ptvcursor_add(ptvc, hf_tibia_charlist_entry_ip, 4, ENC_BIG_ENDIAN);

                                uint16_t port = tvb_get_letohs(tvb, ptvcursor_current_offset(ptvc));

                                ptvcursor_add(ptvc, hf_tibia_charlist_entry_port, 2, ENC_BIG_ENDIAN);

                                ptvcursor_pop_subtree(ptvc);

                                register_gameserv_addr(convo, ipv4addr, port);

                            }

                            ptvcursor_pop_subtree(ptvc);

                        }

                        ptvcursor_add(ptvc, hf_tibia_pacc_days, 2, ENC_LITTLE_ENDIAN);

                    }

                    break;

                default:

                    offset = ptvcursor_current_offset(ptvc);

                    call_data_dissector(tvb_new_subset_length(tvb, offset, len - offset), pinfo, ptvcursor_tree(ptvc));

                    ptvcursor_advance(ptvc, len - offset);

            }

            ptvcursor_pop_subtree(ptvc);

            col_append_fstr(pinfo->cinfo, COL_INFO, " %s (0x%x)",

                    val_to_str_const(cmd, from_loginserv_packet_types, "Unknown"), cmd);

            if (ptvcursor_current_offset(ptvc) >= len)

                break;

            col_append_str(pinfo->cinfo, COL_INFO, ",");

        }

    }

    offset = ptvcursor_current_offset(ptvc);

    ptvcursor_free(ptvc);

    return offset;

}

static void

dissect_coord(ptvcursor_t *ptvc, bool with_stackpos)

{

    tvbuff_t *tvb;

    proto_tree *tree;

    int offset;

    uint32_t x, y, z, stackpos;

    proto_item *coords_tuple = ptvcursor_add_with_subtree(ptvc, hf_tibia_coords, SUBTREE_UNDEFINED_LENGTH, ENC_NA, ett_coords);

    {

        tvb = ptvcursor_tvbuff(ptvc);

        tree = ptvcursor_tree(ptvc);

        offset = ptvcursor_current_offset(ptvc);

        proto_tree_add_item_ret_uint(tree, hf_tibia_coords_x, tvb, offset, 2, ENC_LITTLE_ENDIAN, &x);

        offset += 2;

        proto_tree_add_item_ret_uint(tree, hf_tibia_coords_y, tvb, offset, 2, ENC_LITTLE_ENDIAN, &y);

        offset += 2;

        proto_tree_add_item_ret_uint(tree, hf_tibia_coords_z, tvb, offset, 1, ENC_NA, &z);

        offset += 1;

        ptvcursor_advance(ptvc, 5);

    }

    if (with_stackpos) {

        proto_tree_add_item_ret_uint(tree, hf_tibia_stackpos, tvb, offset, 1, ENC_NA, &stackpos);

        proto_item_set_text(coords_tuple, "Coordinates: (%u, %u, %u)[%u]", x, y, z, stackpos);

        ptvcursor_advance(ptvc, 1);

    } else {

        proto_item_set_text(coords_tuple, "Coordinates: (%u, %u, %u)", x, y, z);

    }

    ptvcursor_pop_subtree(ptvc);

}

static int

dissect_gameserv_packet(struct tibia_convo *convo, tvbuff_t *tvb, int offset, int len, packet_info *pinfo, proto_tree *tree, bool first_fragment)

{

    ptvcursor_t *ptvc = ptvcursor_new(pinfo->pool, tree, tvb, offset);

    col_append_str(pinfo->cinfo, COL_INFO, first_fragment ? " commands:" : ",");

    len += offset;

    if (ptvcursor_current_offset(ptvc) < len) {

        for (;;) {

            int cmd = tvb_get_uint8(tvb, ptvcursor_current_offset(ptvc));

            ptvcursor_add_with_subtree(ptvc, hf_tibia_gameserv_command, 1, ENC_NA, ett_command);

            ptvcursor_advance(ptvc, 1);

            switch ((enum gameserv_cmd)cmd) {

                case S_DLG_INFO:

                case S_DLG_ERROR:

                case S_DLG_TOOMANYPLAYERS:

                    ptvcursor_add(ptvc, cmd == S_DLG_ERROR ? hf_tibia_dlg_error : hf_tibia_dlg_info, 2, ENC_LITTLE_ENDIAN | convo->has.string_enc);

                    break;

                case S_GMACTIONS: /* 0x0B, Used to be 32 unknown bytes, but with GMs removed it                                     might not be in use anymore */

                    ptvcursor_add(ptvc, hf_tibia_unknown, 32, ENC_NA);

                    break;

                case S_PLAYERLOC: /* 0x64,Coord pos */

                    dissect_coord(ptvc, false);

                    break;

                case S_TILEUPDATE: /* 0x69,Coord pos TileDescription td */

                    dissect_coord(ptvc, false);

                    ptvcursor_add(ptvc, hf_tibia_unknown, len - ptvcursor_current_offset(ptvc), ENC_NA);

                    break;

                case S_ADDITEM: /* 0x6a,Coord pos ThingDescription thing */

                    dissect_coord(ptvc, false);

                    ptvcursor_add(ptvc, hf_tibia_unknown, len - ptvcursor_current_offset(ptvc), ENC_NA);

                    break;

                case S_REPLACEITEM: /* 0x6b,Coord pos Byte stackpos ThingDescription thing */

                    dissect_coord(ptvc, true);

                    ptvcursor_add(ptvc, hf_tibia_unknown, len - ptvcursor_current_offset(ptvc), ENC_NA);

                    break;

                case S_REMOVEITEM: /* 0x6c,Coord pos Byte stackpos */

                    dissect_coord(ptvc, true);

                    break;

                case S_MOVE_THING: /* 0x6d, */

                    dissect_coord(ptvc, true);

                    dissect_coord(ptvc, false);

                    break;

                case S_CONTAINER: /* 0x6e,Byte index Short containerIcon Byte slotCount ThingDescription item */

                    ptvcursor_add(ptvc, hf_tibia_container, 1, ENC_NA);

                    ptvcursor_add(ptvc, hf_tibia_container_icon, 2, ENC_LITTLE_ENDIAN);

                    ptvcursor_add(ptvc, hf_tibia_container_slots, 2, ENC_LITTLE_ENDIAN);

                    ptvcursor_add(ptvc, hf_tibia_unknown, len - ptvcursor_current_offset(ptvc), ENC_NA);

                    break;

                case S_CONTAINERCLOSE: /* 0x6f,Byte index */

                    ptvcursor_add(ptvc, hf_tibia_container, 1, ENC_NA);

                    break;

                case S_ADDITEMCONTAINER: /* 0x70,Byte index ThingDescription itm */

                    ptvcursor_add(ptvc, hf_tibia_container, 1, ENC_NA);

                    ptvcursor_add(ptvc, hf_tibia_unknown, len - ptvcursor_current_offset(ptvc), ENC_NA);

                    break;

                case S_TRANSFORMITEMCONTAINER:/* 0x71,Byte index Byte slot */

                    ptvcursor_add(ptvc, hf_tibia_container, 1, ENC_NA);

                    ptvcursor_add(ptvc, hf_tibia_container_slot, 1, ENC_NA);

                    break;