/* packet-slsk.c

 * Routines for SoulSeek Protocol dissection

 * Copyright 2003, Christian Wagner <Christian.Wagner@stud.uni-karlsruhe.de>

 * Institute of Telematics - University of Karlsruhe

 * part of this work supported by

 *  Deutsche Forschungsgemeinschaft (DFG) Grant Number FU448/1

 *

 * The SoulSeek Protocol is proprietary, with official site:

 * https://www.slsknet.org/news/

 * This dissector is based on protocol descriptions from various open source

 * reverse engineering projects (some no longer active), including SoleSeek Project:

 * https://web.archive.org/web/20060223004530/http://cvs.sourceforge.net/viewcvs.py/soleseek/SoleSeek/doc/protocol.html?rev=HEAD

 * Museek+

 * https://web.archive.org/web/20220327151706/https://www.museek-plus.org/wiki/SoulseekProtocol

 * https://github.com/eLvErDe/museek-plus

 * and Nicotine+

 * https://nicotine-plus.org/doc/SLSKPROTOCOL.html

 * Updated for SoulSeek client version 151

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

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

 */

#include "config.h"

#include <epan/packet.h>

#include <epan/prefs.h>

#include <epan/strutil.h>

#include <epan/expert.h>

#include "packet-tcp.h"

void proto_register_slsk(void);

void proto_reg_handoff_slsk(void);

static dissector_handle_t slsk_handle;

/* Initialize the protocol and registered fields */

static int proto_slsk;

static int hf_slsk_integer;

static int hf_slsk_string;

static int hf_slsk_byte;

static int hf_slsk_message_length;

static int hf_slsk_message_code;

static int hf_slsk_embedded_message_type;

static int hf_slsk_client_ip;

/* static int hf_slsk_server_ip; */

static int hf_slsk_directory_name;

static int hf_slsk_username;

static int hf_slsk_password;

static int hf_slsk_version;

static int hf_slsk_login_successful;

static int hf_slsk_login_message;

static int hf_slsk_port;

static int hf_slsk_ip;

static int hf_slsk_user_exists;

static int hf_slsk_status_code;

static int hf_slsk_room;

static int hf_slsk_chat_message;

static int hf_slsk_users_in_room;

static int hf_slsk_token;

static int hf_slsk_connection_type;

static int hf_slsk_chat_message_id;

static int hf_slsk_timestamp;

static int hf_slsk_search_text;

static int hf_slsk_folder_count;

static int hf_slsk_file_count;

static int hf_slsk_average_speed;

static int hf_slsk_download_number;

static int hf_slsk_files;

static int hf_slsk_directories;

static int hf_slsk_slotsfull;

static int hf_slsk_place_in_queue;

static int hf_slsk_number_of_rooms;

static int hf_slsk_filename;

static int hf_slsk_filename_ext;

static int hf_slsk_directory;

static int hf_slsk_size;

/* static int hf_slsk_checksum; */

static int hf_slsk_code;

static int hf_slsk_number_of_users;

static int hf_slsk_number_of_days;

static int hf_slsk_transfer_direction;

static int hf_slsk_user_description;

static int hf_slsk_picture_exists;

static int hf_slsk_picture;

/* static int hf_slsk_user_uploads; */

static int hf_slsk_total_uploads;

static int hf_slsk_queued_uploads;

static int hf_slsk_slots_available;

static int hf_slsk_allowed;

static int hf_slsk_compr_packet;

static int hf_slsk_parent_min_speed;

static int hf_slsk_parent_speed_connection_ratio;

static int hf_slsk_seconds_parent_inactivity_before_disconnect;

static int hf_slsk_seconds_server_inactivity_before_disconnect;

static int hf_slsk_nodes_in_cache_before_disconnect;

static int hf_slsk_seconds_before_ping_children;

static int hf_slsk_recommendation;

static int hf_slsk_user;

static int hf_slsk_ranking;

static int hf_slsk_compressed_packet_length;

static int hf_slsk_uncompressed_packet_length;

static int hf_slsk_num_directories;

static int hf_slsk_upload_speed;

static int hf_slsk_in_queue;

static int hf_slsk_num_slotsfull_records;

static int hf_slsk_num_recommendations;

static int hf_slsk_num_files;

static int hf_slsk_num_strings;

static int hf_slsk_file_code;

static int hf_slsk_file_size1;

static int hf_slsk_file_size2;

static int hf_slsk_file_num_attributes;

static int hf_slsk_file_attribute_type;

static int hf_slsk_file_attribute_value;

static int hf_slsk_free_upload_slots;

static int hf_slsk_bytes;

static int hf_slsk_same_recommendation;

static int hf_slsk_number_of_priv_users;

static int hf_slsk_num_parent_address;

/* Initialize the subtree pointers */

static int ett_slsk;

static int ett_slsk_compr_packet;

static int ett_slsk_directory;

static int ett_slsk_file;

static int ett_slsk_file_attribute;

static int ett_slsk_user;

static int ett_slsk_recommendation;

static int ett_slsk_room;

static int ett_slsk_string;

static expert_field ei_slsk_unknown_data;

static expert_field ei_slsk_zlib_decompression_failed;

static expert_field ei_slsk_decompression_failed;

#define SLSK_TCP_PORT_RANGE   "2234,2240,5534"

/* desegmentation of SoulSeek Message over TCP */

static bool slsk_desegment = true;

#if defined (HAVE_ZLIB) || defined (HAVE_ZLIBNG)

static bool slsk_decompress = true;

#else

static bool slsk_decompress;

#endif

static const value_string slsk_tcp_msgs[] = {

  { 1, "Login"},

  { 2, "Set Wait Port"},

  { 3, "Get Peer Address"},

  { 4, "Get Shared File List"},

  { 5, "User Exists / Shared File List"},

  { 7, "Get User Status"},

  { 9, "File Search Result"},

  { 13, "Say ChatRoom"},

  { 14, "Join Room"},

  { 15, "Leave Room / User Info Request"},

  { 16, "User Joined Room / User Info Reply"},

  { 17, "User Left Room"},

  { 18, "Connect To Peer"},

  { 22, "Message User"},

  { 23, "Message User Ack"},

  { 26, "File Search"},

  { 28, "Set Status"},

  { 32, "Ping"},

  { 34, "Update Upload Speed"},

  { 35, "Shared Files & Folders"},

  { 36, "Get User Stats / Folder Contents Request"},

  { 37, "Folder Contents Response"},

  { 40, "Queued Downloads / Transfer Request"},

  { 41, "Transfer Response"},

  { 42, "Placehold Upload"},

  { 43, "Queue Upload"},

  { 44, "Place In Queue"},

  { 46, "Upload Failed"},

  { 50, "Queue Failed / Own Recommendation"},

  { 51, "Add Things I like / Place In Queue Request"},

  { 52, "Remove Things I like"},

  { 54, "Get Recommendations"},

  { 55, "Type 55"},

  { 56, "Get Global Rankings"},

  { 57, "Get User Recommendations"},

  { 58, "Admin Command"},

  { 60, "Place In Line Response"},

  { 62, "Room Added"},

  { 63, "Room Removed"},

  { 64, "Room List"},

  { 65, "Exact File Search"},

  { 66, "Admin Message"},

  { 67, "Global User List"},

  { 68, "Tunneled Message"},

  { 69, "Privileged User List"},

  { 71, "Get Parent List"},

  { 73, "Type 73"},

  { 83, "Parent Min Speed"},

  { 84, "Parent Speed Connection Ratio"},

  { 86, "Parent Inactivity Before Disconnect"},

  { 87, "Server Inactivity Before Disconnect"},

  { 88, "Nodes In Cache Before Disconnect"},

  { 90, "Seconds Before Ping Children"},

  { 91, "Add To Privileged"},

  { 92, "Check Privileges"},

  { 93, "Embedded Message"},

  { 100, "Become Parent"},

  { 102, "Random Parent Addresses"},

  { 103, "Send Wishlist Entry"},

  { 104, "Type 104"},

  { 110, "Get Similar Users"},

  { 111, "Get Recommendations for Item"},

  { 112, "Get Similar Users for Item"},

  { 1001, "Can't Connect To Peer"},

  { 0, NULL }

};

static const value_string slsk_status_codes[] = {

  { -1, "Unknown"},

  { 0, "Offline"},

  { 1, "Away"},

  { 2, "Online"},

  { 0, NULL }

};

static const value_string slsk_transfer_direction[] = {

  { 0, "Download"},

  { 1, "Upload"},

  { 0, NULL }

};

static const value_string slsk_yes_no[] = {

  { 0, "No"},

  { 1, "Yes"},

  { 0, NULL }

};

static const value_string slsk_attr_type[] = {

  { 0, "Bitrate"},

  { 1, "Length"},

  { 2, "VBR"},

  { 0, NULL }

};

static const char* connection_type(const char con_type[]) {

  if (strlen(con_type) != 1) return "Unknown";

  if (con_type[0] == 'D') return "Distributed Search";

  if (con_type[0] == 'P') return "Peer Connection";    /* "File Search Result / User Info Request / Get Shared File List" */

  if (con_type[0] == 'F') return "File Transfer";

  return "Unknown";

}

// NOLINTNEXTLINE(misc-no-recursion)

static bool check_slsk_format(tvbuff_t *tvb, packet_info *pinfo, unsigned offset, const char format[]){

  /*

  * Returns true if tvbuff beginning at offset matches a certain format

  * The format is given by an array of characters standing for a special field type

  *     i - integer  (4 bytes)

  *     b - byte  (1 byte)

  *    s - string  (string_length + 4 bytes)

  *

  *    * - can be used at the end of a format to ignore any following bytes

  */

  switch ( format[0] ) {

    case 'i':

      if (tvb_captured_length_remaining(tvb, offset) < 4) return false;

      offset += 4;

    break;

    case 'b':

      if (tvb_captured_length_remaining(tvb, offset) < 1) return false;

      offset += 1;

    break;

    case 's':

      if (tvb_captured_length_remaining(tvb, offset) < 4) return false;

      if (tvb_captured_length_remaining(tvb, offset + 4) < tvb_get_letohl(tvb, offset)) return false;

      offset += tvb_get_letohl(tvb, offset)+4;

    break;

    case '*':

      return true;

    default:

      return false;

  }

  if (format[1] == '\0' ) {

    if (tvb_captured_length_remaining(tvb, offset) > 0) /* Checks for additional bytes at the end */

      return false;

    return true;

  }

  increment_dissection_depth(pinfo);

  bool valid = check_slsk_format(tvb, pinfo, offset, &format[1]);

  decrement_dissection_depth(pinfo);

  return valid;

}

static const char* get_message_type(tvbuff_t *tvb, packet_info *pinfo) {

  /*

  * Checks if the Message Code is known.

  * If unknown checks if the Message Code is stored in a byte.

  * Returns the Message Type.

  */

  int msg_code = tvb_get_letohl(tvb, 4);

  const char *message_type =  try_val_to_str(msg_code, slsk_tcp_msgs);

  if (message_type == NULL) {

    if (check_slsk_format(tvb, pinfo, 4, "bisis"))

      message_type = "Distributed Search";

    else if (check_slsk_format(tvb, pinfo, 4, "bssi"))

      message_type = "Peer Init";

    else if (check_slsk_format(tvb, pinfo, 4, "bi"))

      message_type = "Pierce Fw";

    else

      message_type = "Unknown";

  }

  return message_type;

}

static unsigned get_slsk_pdu_len(packet_info *pinfo _U_, tvbuff_t *tvb,

                              int offset, void *data _U_)

{

  uint32_t msg_len;

  msg_len = tvb_get_letohl(tvb, offset);

  /* That length doesn't include the length field itself; add that in. */

  msg_len += 4;

  return msg_len;

}

/* Code to actually dissect the packets */

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

{

/* Set up structures needed to add the protocol subtree and manage it */

  proto_item *ti, *ti_len, *ti_subtree, *ti_subtree2;

  proto_tree *slsk_tree, *subtree, *subtree2, *subtree3;

  unsigned offset = 0;

  unsigned i, j;

  uint32_t msg_len, msg_code;

  const char *str;

  int str_len, start_offset, start_offset2;

  int comprlen = 0, uncomprlen = 0, uncompr_tvb_offset = 0;

  unsigned i2 = 0, j2 = 0;

  unsigned i3 = 0, j3 = 0;

/* Make entries in Protocol column and Info column on summary display */

  col_set_str(pinfo->cinfo, COL_PROTOCOL, "slsk");

/* This field shows up as the "Info" column in the display  */

  col_set_str(pinfo->cinfo, COL_INFO, "SoulSeek Message");

  col_append_fstr(pinfo->cinfo, COL_INFO, ": %s", get_message_type(tvb, pinfo));

/* create display subtree for the protocol */

    ti = proto_tree_add_item(tree, proto_slsk, tvb, 0, -1, ENC_NA);

    slsk_tree = proto_item_add_subtree(ti, ett_slsk);

/* Continue adding tree items to process the packet here */

    ti_len = proto_tree_add_item_ret_uint(slsk_tree, hf_slsk_message_length, tvb, offset, 4, ENC_LITTLE_ENDIAN, &msg_len);

    offset += 4;

    msg_code = tvb_get_letohl(tvb, offset);

    switch (msg_code) {

      case  1:

        if (check_slsk_format(tvb, pinfo, offset, "issi")) {

          /* Client-to-Server */

          proto_tree_add_uint_format_value(slsk_tree, hf_slsk_message_code, tvb, offset, 4, msg_code,

                     "Login (Code: %02d)", msg_code);

          offset += 4;

          proto_tree_add_item_ret_length(slsk_tree, hf_slsk_username, tvb, offset, 4, ENC_ASCII|ENC_LITTLE_ENDIAN, &str_len);

          offset += str_len;

          proto_tree_add_item_ret_length(slsk_tree, hf_slsk_password, tvb, offset, 4, ENC_ASCII|ENC_LITTLE_ENDIAN, &str_len);

          offset += str_len;

          proto_tree_add_item(slsk_tree, hf_slsk_version, tvb, offset, 4, ENC_LITTLE_ENDIAN);

          offset += 4;

        }

        else if (check_slsk_format(tvb, pinfo, offset, "ibs") || check_slsk_format(tvb, pinfo, offset, "ibsi")) {

          /* Server-to-Client */

          proto_tree_add_uint_format_value(slsk_tree, hf_slsk_message_code, tvb, offset, 4, msg_code,

                     "Login Reply (Code: %02d)", msg_code);

          offset += 4;

          i=tvb_get_uint8(tvb, offset);

          proto_tree_add_item(slsk_tree, hf_slsk_login_successful, tvb, offset, 1, ENC_NA);

          offset += 1;

          proto_tree_add_item_ret_length(slsk_tree, hf_slsk_login_message, tvb, offset, 4, ENC_ASCII|ENC_LITTLE_ENDIAN, &str_len);

          offset += str_len;

          if (i == 1){

            proto_tree_add_item(slsk_tree, hf_slsk_client_ip, tvb, offset, 4, ENC_BIG_ENDIAN);

            offset += 4;

          }

        }

      break;

      case  2:

        if (check_slsk_format(tvb, pinfo, offset, "ii")) {

          /* Client-to-Server */

          proto_tree_add_uint_format_value(slsk_tree, hf_slsk_message_code, tvb, offset, 4, msg_code,

                     "Set Wait Port (Code: %02d)", msg_code);

          offset += 4;

          proto_tree_add_item(slsk_tree, hf_slsk_port, tvb, offset, 4, ENC_LITTLE_ENDIAN);

          offset += 4;

        }

      break;

      case  3:

        if (check_slsk_format(tvb, pinfo, offset, "isii")) {

          /* Server-to-Client */

          proto_tree_add_uint_format_value(slsk_tree, hf_slsk_message_code, tvb, offset, 4, msg_code,

                     "Get Peer Address Reply (Code: %02d)", msg_code);

          offset += 4;

          proto_tree_add_item_ret_length(slsk_tree, hf_slsk_username, tvb, offset, 4, ENC_ASCII|ENC_LITTLE_ENDIAN, &str_len);

          offset += str_len;

          proto_tree_add_item(slsk_tree, hf_slsk_ip, tvb, offset, 4, ENC_BIG_ENDIAN);

          offset += 4;

          proto_tree_add_item(slsk_tree, hf_slsk_port, tvb, offset, 4, ENC_LITTLE_ENDIAN);

          offset += 4;

        }

        else if (check_slsk_format(tvb, pinfo, offset, "is")) {

          /* Client-to-Server */

          proto_tree_add_uint_format_value(slsk_tree, hf_slsk_message_code, tvb, offset, 4, msg_code,

                     "Get Peer Address (Code: %02d)", msg_code);

          offset += 4;

          proto_tree_add_item_ret_length(slsk_tree, hf_slsk_username, tvb, offset, 4, ENC_ASCII|ENC_LITTLE_ENDIAN, &str_len);

          offset += str_len;

        }

      break;

      case 4:

        if (check_slsk_format(tvb, pinfo, offset, "i")) {

          /* Client-to-Client */

          proto_tree_add_uint_format_value(slsk_tree, hf_slsk_message_code, tvb, offset, 4, msg_code,

                     "Get Shared File List (Code: %02d)", msg_code);

          offset += 4;

        }

      break;

      case  5:

        if (check_slsk_format(tvb, pinfo, offset, "isb")) {

          /* Server-to-Client */

          proto_tree_add_uint_format_value(slsk_tree, hf_slsk_message_code, tvb, offset, 4, msg_code,

                     "User Exists Reply (Code: %02d)", msg_code);

          offset += 4;

          proto_tree_add_item_ret_length(slsk_tree, hf_slsk_username, tvb, offset, 4, ENC_ASCII|ENC_LITTLE_ENDIAN, &str_len);

          offset += str_len;

          proto_tree_add_item(slsk_tree, hf_slsk_user_exists, tvb, offset, 1, ENC_NA);

          offset += 1;

        }

        else if (check_slsk_format(tvb, pinfo, offset, "is")) {

          /* Client-to-Server */

          proto_tree_add_uint_format_value(slsk_tree, hf_slsk_message_code, tvb, offset, 4, msg_code,

                     "User Exists Request (Code: %02d)", msg_code);

          offset += 4;

          proto_tree_add_item_ret_length(slsk_tree, hf_slsk_username, tvb, offset, 4, ENC_ASCII|ENC_LITTLE_ENDIAN, &str_len);

          offset += str_len;

        }

        else if (check_slsk_format(tvb, pinfo, offset, "i*")) {

          /* Client-to-Client */

          proto_tree_add_uint_format_value(slsk_tree, hf_slsk_message_code, tvb, offset, 4, msg_code,

                     "Shared File List (Code: %02d)", msg_code);

          offset += 4;

          /* [zlib compressed] */

          comprlen = tvb_captured_length_remaining(tvb, offset);

          if (slsk_decompress == true){

            tvbuff_t *uncompr_tvb = tvb_child_uncompress_zlib(tvb, tvb, offset, comprlen);

            if (uncompr_tvb == NULL) {

              proto_tree_add_expert_remaining(slsk_tree, pinfo, &ei_slsk_zlib_decompression_failed, tvb, offset);

              offset += tvb_captured_length_remaining(tvb, offset);

            } else {

              proto_item *ti2 = proto_tree_add_item(slsk_tree, hf_slsk_compr_packet, tvb, offset, -1, ENC_NA);

              proto_tree *slsk_compr_packet_tree = proto_item_add_subtree(ti2, ett_slsk_compr_packet);

              proto_item_set_generated(ti2);

              ti = proto_tree_add_uint(slsk_tree, hf_slsk_compressed_packet_length, tvb, offset, 0, comprlen);

              proto_item_set_generated(ti);

              uncomprlen = tvb_reported_length_remaining(uncompr_tvb, 0);

              ti = proto_tree_add_uint(slsk_tree, hf_slsk_uncompressed_packet_length, tvb, offset, 0, uncomprlen);

              proto_item_set_generated(ti);

              add_new_data_source(pinfo, uncompr_tvb, "Uncompressed SoulSeek data");

              uncompr_tvb_offset = 0;

              if (check_slsk_format(uncompr_tvb, pinfo, uncompr_tvb_offset, "i*")) {

                proto_tree_add_item_ret_uint(slsk_compr_packet_tree, hf_slsk_num_directories, uncompr_tvb, uncompr_tvb_offset, 4, ENC_LITTLE_ENDIAN, &j);

                uncompr_tvb_offset += 4;

                for (i = 0; i < j; i++) {

                  if (check_slsk_format(uncompr_tvb, pinfo, uncompr_tvb_offset, "si*")) {

                    start_offset = uncompr_tvb_offset;

                    subtree = proto_tree_add_subtree_format(slsk_compr_packet_tree, uncompr_tvb, uncompr_tvb_offset, 1, ett_slsk_directory, &ti_subtree, "Directory #%d", i+1);

                    proto_tree_add_item_ret_length(subtree, hf_slsk_directory_name, uncompr_tvb, uncompr_tvb_offset, 4, ENC_ASCII|ENC_LITTLE_ENDIAN, &str_len);

                    uncompr_tvb_offset += str_len;

                    proto_tree_add_item_ret_uint(subtree, hf_slsk_num_files, uncompr_tvb, uncompr_tvb_offset, 4, ENC_LITTLE_ENDIAN, &j2);

                    uncompr_tvb_offset += 4;

                    for (i2 = 0; i2 < j2; i2++) {

                      if (check_slsk_format(uncompr_tvb, pinfo, uncompr_tvb_offset, "bsiisi*")) {

                        start_offset2 = uncompr_tvb_offset;

                        subtree2 = proto_tree_add_subtree_format(subtree, uncompr_tvb, uncompr_tvb_offset, 1, ett_slsk_file, &ti_subtree2, "File #%d", i2+1);

                        proto_tree_add_item(subtree2, hf_slsk_file_code, uncompr_tvb, uncompr_tvb_offset, 1, ENC_NA);

                        uncompr_tvb_offset += 1;

                        proto_tree_add_item_ret_length(subtree2, hf_slsk_filename, uncompr_tvb, uncompr_tvb_offset, 4, ENC_ASCII|ENC_LITTLE_ENDIAN, &str_len);

                        uncompr_tvb_offset += str_len;

                        proto_tree_add_item(subtree2, hf_slsk_file_size1, uncompr_tvb, uncompr_tvb_offset, 4, ENC_LITTLE_ENDIAN);

                        uncompr_tvb_offset += 4;

                        proto_tree_add_item(subtree2, hf_slsk_file_size2, uncompr_tvb, uncompr_tvb_offset, 4, ENC_LITTLE_ENDIAN);

                        uncompr_tvb_offset += 4;

                        proto_tree_add_item_ret_length(subtree2, hf_slsk_filename_ext, uncompr_tvb, uncompr_tvb_offset, 4, ENC_ASCII|ENC_LITTLE_ENDIAN, &str_len);

                        uncompr_tvb_offset += str_len;

                        proto_tree_add_item_ret_uint(subtree2, hf_slsk_file_num_attributes, uncompr_tvb, uncompr_tvb_offset, 4, ENC_LITTLE_ENDIAN, &j3);

                        uncompr_tvb_offset += 4;

                        for (i3 = 0; i3 < j3; i3++) {

                          if (check_slsk_format(uncompr_tvb, pinfo, uncompr_tvb_offset, "ii*")) {

                            subtree3 = proto_tree_add_subtree_format(subtree2, uncompr_tvb, uncompr_tvb_offset, 8, ett_slsk_file_attribute, NULL, "Attribute #%d", i3+1);

                            proto_tree_add_item(subtree3, hf_slsk_file_attribute_type, uncompr_tvb, uncompr_tvb_offset, 4, ENC_LITTLE_ENDIAN);

                            uncompr_tvb_offset += 4;

                            proto_tree_add_item(subtree3, hf_slsk_file_attribute_value, uncompr_tvb, uncompr_tvb_offset, 4, ENC_LITTLE_ENDIAN);

                            uncompr_tvb_offset += 4;

                          } else {

                            break; /* invalid format */

                          }

                        }

                        proto_item_set_len(ti_subtree2, uncompr_tvb_offset-start_offset2);

                      } else {

                        break; /* invalid format */

                      }

                    }

                    proto_item_set_len(ti_subtree, uncompr_tvb_offset-start_offset);

                  } else {

                    break; /* invalid format */

                  }

                }

              }

            }

          }else {

            ti = proto_tree_add_item(slsk_tree, hf_slsk_compr_packet, tvb, offset, -1, ENC_NA);

            proto_item_set_generated(ti);

            ti = proto_tree_add_uint(slsk_tree, hf_slsk_compressed_packet_length, tvb, offset, 0, comprlen);

            proto_item_set_generated(ti);

            offset += tvb_captured_length_remaining(tvb, offset);

          }

        }

      break;

      case  7:

        if (check_slsk_format(tvb, pinfo, offset, "isi")) {

          /* Server-to-Client */

          proto_tree_add_uint_format_value(slsk_tree, hf_slsk_message_code, tvb, offset, 4, msg_code,

                     "Get User Status Reply (Code: %02d)", msg_code);

          offset += 4;

          proto_tree_add_item_ret_length(slsk_tree, hf_slsk_username, tvb, offset, 4, ENC_ASCII|ENC_LITTLE_ENDIAN, &str_len);

          offset += str_len;

          proto_tree_add_item(slsk_tree, hf_slsk_status_code, tvb, offset, 4, ENC_LITTLE_ENDIAN);

          offset += 4;

        }

        else if (check_slsk_format(tvb, pinfo, offset, "is")) {

          /* Client-to-Server */

          proto_tree_add_uint_format_value(slsk_tree, hf_slsk_message_code, tvb, offset, 4, msg_code,

                     "Get User Status (Code: %02d)", msg_code);

          offset += 4;

          proto_tree_add_item_ret_length(slsk_tree, hf_slsk_username, tvb, offset, 4, ENC_ASCII|ENC_LITTLE_ENDIAN, &str_len);

          offset += str_len;

        }

      break;

      case 9:

        if (check_slsk_format(tvb, pinfo, offset, "i*")) {

          /* Client-to-Client */

          proto_tree_add_uint_format_value(slsk_tree, hf_slsk_message_code, tvb, offset, 4, msg_code,

                     "File Search Result (Code: %02d)", msg_code);

          offset += 4;

          /* [zlib compressed] */

          comprlen = tvb_captured_length_remaining(tvb, offset);

          if (slsk_decompress == true){

            tvbuff_t *uncompr_tvb = tvb_child_uncompress_zlib(tvb, tvb, offset, comprlen);

            if (uncompr_tvb == NULL) {

              ti = proto_tree_add_item(slsk_tree, hf_slsk_compr_packet, tvb, offset, tvb_captured_length_remaining(tvb, offset), ENC_NA);

              proto_item_set_generated(ti);

              offset += tvb_captured_length_remaining(tvb, offset);

              expert_add_info(pinfo, ti, &ei_slsk_decompression_failed);

            } else {

              proto_item *ti2 = proto_tree_add_item(slsk_tree, hf_slsk_compr_packet, tvb, offset, -1, ENC_NA);

              proto_tree *slsk_compr_packet_tree = proto_item_add_subtree(ti2, ett_slsk_compr_packet);

              proto_item_set_generated(ti2);

              ti = proto_tree_add_uint(slsk_tree, hf_slsk_compressed_packet_length, tvb, offset, 0, comprlen);

              proto_item_set_generated(ti);

              uncomprlen = tvb_captured_length_remaining(uncompr_tvb, 0);

              ti = proto_tree_add_uint(slsk_tree, hf_slsk_uncompressed_packet_length, tvb, offset, 0, uncomprlen);

              proto_item_set_generated(ti);

              add_new_data_source(pinfo, uncompr_tvb, "Uncompressed SoulSeek data");

              uncompr_tvb_offset = 0;

              if (check_slsk_format(uncompr_tvb, pinfo, uncompr_tvb_offset, "sii*")) {

                proto_tree_add_item_ret_length(slsk_compr_packet_tree, hf_slsk_username, uncompr_tvb, uncompr_tvb_offset, 4, ENC_ASCII|ENC_NA, &str_len);

                uncompr_tvb_offset += str_len;

                proto_tree_add_item(slsk_compr_packet_tree, hf_slsk_token, uncompr_tvb, uncompr_tvb_offset, 4, ENC_LITTLE_ENDIAN);

                uncompr_tvb_offset += 4;

                proto_tree_add_item_ret_uint(slsk_compr_packet_tree, hf_slsk_num_files, uncompr_tvb, uncompr_tvb_offset, 4, ENC_LITTLE_ENDIAN, &j);

                uncompr_tvb_offset += 4;

                for (i = 0; i < j; i++) {

                  if (check_slsk_format(uncompr_tvb, pinfo, uncompr_tvb_offset, "bsiisi*")) {

                    start_offset2 = uncompr_tvb_offset;

                    subtree2 = proto_tree_add_subtree_format(slsk_compr_packet_tree, uncompr_tvb, uncompr_tvb_offset, 1, ett_slsk_file, &ti_subtree2, "File #%d", i+1);

                    proto_tree_add_item(subtree2, hf_slsk_file_code, uncompr_tvb, uncompr_tvb_offset, 1, ENC_NA);

                    uncompr_tvb_offset += 1;

                    proto_tree_add_item_ret_length(subtree2, hf_slsk_filename, uncompr_tvb, uncompr_tvb_offset, 4, ENC_ASCII|ENC_LITTLE_ENDIAN, &str_len);

                    uncompr_tvb_offset += str_len;

                    proto_tree_add_item(subtree2, hf_slsk_file_size1, uncompr_tvb, uncompr_tvb_offset, 4, ENC_LITTLE_ENDIAN);

                    uncompr_tvb_offset += 4;

                    proto_tree_add_item(subtree2, hf_slsk_file_size2, uncompr_tvb, uncompr_tvb_offset, 4, ENC_LITTLE_ENDIAN);

                    uncompr_tvb_offset += 4;

                    proto_tree_add_item_ret_length(subtree2, hf_slsk_filename_ext, uncompr_tvb, uncompr_tvb_offset, 4, ENC_ASCII|ENC_LITTLE_ENDIAN, &str_len);

                    uncompr_tvb_offset += str_len;

                    proto_tree_add_item_ret_uint(subtree2, hf_slsk_file_num_attributes, uncompr_tvb, uncompr_tvb_offset, 4, ENC_LITTLE_ENDIAN, &j2);

                    uncompr_tvb_offset += 4;

                    for (i2 = 0; i2 < j2; i2++) {

                      if (check_slsk_format(uncompr_tvb, pinfo, uncompr_tvb_offset, "ii*")) {

                        subtree3 = proto_tree_add_subtree_format(subtree2, uncompr_tvb, uncompr_tvb_offset, 8, ett_slsk_file_attribute, NULL, "Attribute #%d", i2+1);

                        proto_tree_add_item(subtree3, hf_slsk_file_attribute_type, uncompr_tvb, uncompr_tvb_offset, 4, ENC_LITTLE_ENDIAN);

                        uncompr_tvb_offset += 4;

                        proto_tree_add_item(subtree3, hf_slsk_file_attribute_value, uncompr_tvb, uncompr_tvb_offset, 4, ENC_LITTLE_ENDIAN);

                        uncompr_tvb_offset += 4;

                      } else {

                        break; /* invalid format */

                      }

                    }

                    proto_item_set_len(ti_subtree2, uncompr_tvb_offset-start_offset2);

                  } else {

                    break; /* invalid format */

                  }

                }

                proto_tree_add_item(slsk_compr_packet_tree, hf_slsk_free_upload_slots, uncompr_tvb, uncompr_tvb_offset, 1, ENC_LITTLE_ENDIAN);

                uncompr_tvb_offset += 1;

                proto_tree_add_item(slsk_compr_packet_tree, hf_slsk_upload_speed, uncompr_tvb, uncompr_tvb_offset, 4, ENC_LITTLE_ENDIAN);

                uncompr_tvb_offset += 4;

                proto_tree_add_item(slsk_compr_packet_tree, hf_slsk_in_queue, uncompr_tvb, uncompr_tvb_offset, 4, ENC_LITTLE_ENDIAN);

              }

            }

          }else {

            ti = proto_tree_add_item(slsk_tree, hf_slsk_compr_packet, tvb, offset, -1, ENC_NA);

            proto_item_set_generated(ti);

            ti = proto_tree_add_uint(slsk_tree, hf_slsk_compressed_packet_length, tvb, offset, 0, comprlen);

            proto_item_set_generated(ti);

            offset += tvb_captured_length_remaining(tvb, offset);

          }

        }

      break;

      case 13:

        if (check_slsk_format(tvb, pinfo, offset, "isss")) {

          /* Server-to-Client */

          proto_tree_add_uint_format_value(slsk_tree, hf_slsk_message_code, tvb, offset, 4, msg_code,

                     "Say ChatRoom (Code: %02d)", msg_code);

          offset += 4;

          proto_tree_add_item_ret_length(slsk_tree, hf_slsk_room, tvb, offset, 4, ENC_ASCII|ENC_LITTLE_ENDIAN, &str_len);

          offset += str_len;

          proto_tree_add_item_ret_length(slsk_tree, hf_slsk_username, tvb, offset, 4, ENC_ASCII|ENC_LITTLE_ENDIAN, &str_len);

          offset += str_len;

          proto_tree_add_item_ret_length(slsk_tree, hf_slsk_chat_message, tvb, offset, 4, ENC_ASCII|ENC_LITTLE_ENDIAN, &str_len);

          offset += str_len;

        }

        else if (check_slsk_format(tvb, pinfo, offset, "iss")) {

          /* Client-to-Server */

          proto_tree_add_uint_format_value(slsk_tree, hf_slsk_message_code, tvb, offset, 4, msg_code,

                     "Say ChatRoom (Code: %02d)", msg_code);

          offset += 4;

          proto_tree_add_item_ret_length(slsk_tree, hf_slsk_room, tvb, offset, 4, ENC_ASCII|ENC_LITTLE_ENDIAN, &str_len);

          offset += str_len;

          proto_tree_add_item_ret_length(slsk_tree, hf_slsk_chat_message, tvb, offset, 4, ENC_ASCII|ENC_LITTLE_ENDIAN, &str_len);

          offset += str_len;

        }

      break;

      case 14:

        if (check_slsk_format(tvb, pinfo, offset, "is")) {

          /* Client-to-Server */

          proto_tree_add_uint_format_value(slsk_tree, hf_slsk_message_code, tvb, offset, 4, msg_code,

                     "Join/Add Room (Code: %02d)", msg_code);

          offset += 4;

          proto_tree_add_item_ret_length(slsk_tree, hf_slsk_room, tvb, offset, 4, ENC_ASCII|ENC_LITTLE_ENDIAN, &str_len);

          offset += str_len;

        }

        else if (check_slsk_format(tvb, pinfo, offset, "isi*")) {

          /* Server-to-Client */

          proto_tree_add_uint_format_value(slsk_tree, hf_slsk_message_code, tvb, offset, 4, msg_code,

                     "Join Room User List (Code: %02d)", msg_code);

          offset += 4;

          proto_tree_add_item_ret_length(slsk_tree, hf_slsk_room, tvb, offset, 4, ENC_ASCII|ENC_LITTLE_ENDIAN, &str_len);

          offset += str_len;

          proto_tree_add_item_ret_uint(slsk_tree, hf_slsk_users_in_room, tvb, offset, 4, ENC_LITTLE_ENDIAN, &j);

          offset += 4;

          for (i = 0; i < j; i++) {

            if (check_slsk_format(tvb, pinfo, offset, "s*")) {

              proto_tree_add_item_ret_length(slsk_tree, hf_slsk_user, tvb, offset, 4, ENC_ASCII|ENC_LITTLE_ENDIAN, &str_len);

              offset += str_len;

            } else {

              break; /* invalid format */

            }

          }

          if (check_slsk_format(tvb, pinfo, offset, "i*")) {

            proto_tree_add_item_ret_uint(slsk_tree, hf_slsk_users_in_room, tvb, offset, 4, ENC_LITTLE_ENDIAN, &j);

            offset += 4;

            for (i = 0; i < j; i++) {

              if (check_slsk_format(tvb, pinfo, offset, "i*")) {

                proto_tree_add_item(slsk_tree, hf_slsk_status_code, tvb, offset, 4, ENC_LITTLE_ENDIAN);

                offset += 4;

              } else {

                break; /* invalid format */

              }

            }

          }

          if (check_slsk_format(tvb, pinfo, offset, "i*")) {

            proto_tree_add_item_ret_uint(slsk_tree, hf_slsk_users_in_room, tvb, offset, 4, ENC_LITTLE_ENDIAN, &j);

            offset += 4;

            for (i = 0; i < j; i++) {

              if (check_slsk_format(tvb, pinfo, offset, "iiiii*")) {

                subtree = proto_tree_add_subtree_format(slsk_tree, tvb, offset, 20, ett_slsk_user, NULL, "User #%d", i+1);

                proto_tree_add_item(subtree, hf_slsk_average_speed, tvb, offset, 4, ENC_LITTLE_ENDIAN);

                offset += 4;

                proto_tree_add_item(subtree, hf_slsk_download_number, tvb, offset, 4, ENC_LITTLE_ENDIAN);

                offset += 4;

                proto_tree_add_item(subtree, hf_slsk_integer, tvb, offset, 4, ENC_LITTLE_ENDIAN);

                offset += 4;

                proto_tree_add_item(subtree, hf_slsk_files, tvb, offset, 4, ENC_LITTLE_ENDIAN);

                offset += 4;

                proto_tree_add_item(subtree, hf_slsk_directories, tvb, offset, 4, ENC_LITTLE_ENDIAN);

                offset += 4;

              } else {

                break; /* invalid format */

              }

            }

          }

          if (check_slsk_format(tvb, pinfo, offset, "i*")) {

            proto_tree_add_item_ret_uint(slsk_tree, hf_slsk_num_slotsfull_records, tvb, offset, 4, ENC_LITTLE_ENDIAN, &j);

            offset += 4;

            for (i = 0; i < j; i++) {

              if (check_slsk_format(tvb, pinfo, offset, "i*")) {

                subtree = proto_tree_add_subtree_format(slsk_tree, tvb, offset, 4, ett_slsk_user, NULL, "User #%d", i+1);

                proto_tree_add_item(subtree, hf_slsk_slotsfull, tvb, offset, 4, ENC_LITTLE_ENDIAN);

                offset += 4;

              } else {

                break; /* invalid format */

              }

            }

          }

        }

      break;

      case 15:

        if (check_slsk_format(tvb, pinfo, offset, "is")) {

          /* Client-to-Server & Server-to-Client */

          proto_tree_add_uint_format_value(slsk_tree, hf_slsk_message_code, tvb, offset, 4, msg_code,

                     "Leave Room (Code: %02d)", msg_code);

          offset += 4;

          proto_tree_add_item_ret_length(slsk_tree, hf_slsk_room, tvb, offset, 4, ENC_ASCII|ENC_LITTLE_ENDIAN, &str_len);

          offset += str_len;

        }

        else if (check_slsk_format(tvb, pinfo, offset, "i")) {

          /* Client-to-Client */

          proto_tree_add_uint_format_value(slsk_tree, hf_slsk_message_code, tvb, offset, 4, msg_code,

                     "User Info Request (Code: %02d)", msg_code);

          offset += 4;

        }

      break;

      case 16:

        if (check_slsk_format(tvb, pinfo, offset, "issiiiiiii")) {

          /* Server-to-Client */

          proto_tree_add_uint_format_value(slsk_tree, hf_slsk_message_code, tvb, offset, 4, msg_code,

                     "User Joined Room (Code: %02d)", msg_code);

          offset += 4;

          proto_tree_add_item_ret_length(slsk_tree, hf_slsk_room, tvb, offset, 4, ENC_ASCII|ENC_LITTLE_ENDIAN, &str_len);

          offset += str_len;

          proto_tree_add_item_ret_length(slsk_tree, hf_slsk_username, tvb, offset, 4, ENC_ASCII|ENC_LITTLE_ENDIAN, &str_len);

          offset += str_len;

          proto_tree_add_item(slsk_tree, hf_slsk_total_uploads, tvb, offset, 4, ENC_LITTLE_ENDIAN);

          offset += 4;

          proto_tree_add_item(slsk_tree, hf_slsk_average_speed, tvb, offset, 4, ENC_LITTLE_ENDIAN);

          offset += 4;

          proto_tree_add_item(slsk_tree, hf_slsk_download_number, tvb, offset, 4, ENC_LITTLE_ENDIAN);

          offset += 4;

          proto_tree_add_item(slsk_tree, hf_slsk_integer, tvb, offset, 4, ENC_LITTLE_ENDIAN);

          offset += 4;

          proto_tree_add_item(slsk_tree, hf_slsk_files, tvb, offset, 4, ENC_LITTLE_ENDIAN);

          offset += 4;

          proto_tree_add_item(slsk_tree, hf_slsk_directories, tvb, offset, 4, ENC_LITTLE_ENDIAN);

          offset += 4;

          proto_tree_add_item(slsk_tree, hf_slsk_slotsfull, tvb, offset, 4, ENC_LITTLE_ENDIAN);

          offset += 4;

        }

        else if (check_slsk_format(tvb, pinfo, offset, "isbiib") || check_slsk_format(tvb, pinfo, offset, "isbsiib")) {

          /* Client-to-Client */

          proto_tree_add_uint_format_value(slsk_tree, hf_slsk_message_code, tvb, offset, 4, msg_code,

                     "User Info Reply (Code: %02d)", msg_code);

          offset += 4;

          proto_tree_add_item_ret_length(slsk_tree, hf_slsk_user_description, tvb, offset, 4, ENC_ASCII|ENC_LITTLE_ENDIAN, &str_len);

          offset += str_len;

          proto_tree_add_item(slsk_tree, hf_slsk_picture_exists, tvb, offset, 1, ENC_NA);

          offset += 1;

          if ( tvb_get_uint8(tvb, offset -1 ) == 1 ) {

            proto_tree_add_item_ret_length(slsk_tree, hf_slsk_picture, tvb, offset, 4, ENC_ASCII|ENC_LITTLE_ENDIAN, &str_len);

            offset += str_len;

          }

          proto_tree_add_item(slsk_tree, hf_slsk_total_uploads, tvb, offset, 4, ENC_LITTLE_ENDIAN);

          offset += 4;

          proto_tree_add_item(slsk_tree, hf_slsk_queued_uploads, tvb, offset, 4, ENC_LITTLE_ENDIAN);

          offset += 4;

          proto_tree_add_item(slsk_tree, hf_slsk_slots_available, tvb, offset, 1, ENC_NA);

          offset += 1;

        }

      break;

      case 17:

        if (check_slsk_format(tvb, pinfo, offset, "iss")) {

          /* Server-to-Client */

          proto_tree_add_uint_format_value(slsk_tree, hf_slsk_message_code, tvb, offset, 4, msg_code,

                     "User Left Room (Code: %02d)", msg_code);

          offset += 4;

          proto_tree_add_item_ret_length(slsk_tree, hf_slsk_room, tvb, offset, 4, ENC_ASCII|ENC_LITTLE_ENDIAN, &str_len);

          offset += str_len;

          proto_tree_add_item_ret_length(slsk_tree, hf_slsk_username, tvb, offset, 4, ENC_ASCII|ENC_LITTLE_ENDIAN, &str_len);

          offset += str_len;

        }

      break;

      case 18:

        if (check_slsk_format(tvb, pinfo, offset, "iiss")) {

          /* Client-to-Server */

          uint32_t len;

          proto_tree_add_uint_format_value(slsk_tree, hf_slsk_message_code, tvb, offset, 4, msg_code,

                     "Connect To Peer (Code: %02d)", msg_code);

          offset += 4;

          proto_tree_add_item(slsk_tree, hf_slsk_token, tvb, offset, 4, ENC_LITTLE_ENDIAN);

          offset += 4;

          proto_tree_add_item_ret_length(slsk_tree, hf_slsk_username, tvb, offset, 4, ENC_ASCII|ENC_LITTLE_ENDIAN, &str_len);

          offset += str_len;

          len = tvb_get_letohl(tvb, offset);

          str = (char*)tvb_get_string_enc(pinfo->pool, tvb, offset+4, len, ENC_ASCII);

          proto_tree_add_string_format_value(slsk_tree, hf_slsk_connection_type, tvb, offset, 4+len, str,

            "%s (Char: %s)", connection_type(str),

            format_text(pinfo->pool, str, len));

          offset += 4+len;

        }

        else if (check_slsk_format(tvb, pinfo, offset, "issiii")) {

          /* Server-to-Client */

          uint32_t len;

          proto_tree_add_uint_format_value(slsk_tree, hf_slsk_message_code, tvb, offset, 4, msg_code,

                     "Connect To Peer (Code: %02d)", msg_code);

          offset += 4;

          proto_tree_add_item_ret_length(slsk_tree, hf_slsk_username, tvb, offset, 4, ENC_ASCII|ENC_LITTLE_ENDIAN, &str_len);

          offset += str_len;

          len = tvb_get_letohl(tvb, offset);

          str = (char*)tvb_get_string_enc(pinfo->pool, tvb, offset+4, len, ENC_ASCII);

          proto_tree_add_string_format_value(slsk_tree, hf_slsk_connection_type, tvb, offset, 4+len, str,

            "%s (Char: %s)", connection_type(str),

            format_text(pinfo->pool, str, len));

          offset += 4+len;

          proto_tree_add_item(slsk_tree, hf_slsk_ip, tvb, offset, 4, ENC_BIG_ENDIAN);

          offset += 4;

          proto_tree_add_item(slsk_tree, hf_slsk_port, tvb, offset, 4, ENC_LITTLE_ENDIAN);

          offset += 4;

          proto_tree_add_item(slsk_tree, hf_slsk_token, tvb, offset, 4, ENC_LITTLE_ENDIAN);

          offset += 4;

        }

      break;

      case 22:

        if (check_slsk_format(tvb, pinfo, offset, "iss")) {

          /* Client-to-Server */

          proto_tree_add_uint_format_value(slsk_tree, hf_slsk_message_code, tvb, offset, 4, msg_code,

                     "Message User Send (Code: %02d)", msg_code);

          offset += 4;

          proto_tree_add_item_ret_length(slsk_tree, hf_slsk_username, tvb, offset, 4, ENC_ASCII|ENC_LITTLE_ENDIAN, &str_len);

          offset += str_len;

          proto_tree_add_item_ret_length(slsk_tree, hf_slsk_chat_message, tvb, offset, 4, ENC_ASCII|ENC_LITTLE_ENDIAN, &str_len);

          offset += str_len;

        }

        else if (check_slsk_format(tvb, pinfo, offset, "iiiss")) {

          /* Server-to-Client */

          proto_tree_add_uint_format_value(slsk_tree, hf_slsk_message_code, tvb, offset, 4, msg_code,

                     "Message User Receive (Code: %02d)", msg_code);

          offset += 4;

          proto_tree_add_item(slsk_tree, hf_slsk_chat_message_id, tvb, offset, 4, ENC_LITTLE_ENDIAN);

          offset += 4;

          proto_tree_add_item(slsk_tree, hf_slsk_timestamp, tvb, offset, 4, ENC_LITTLE_ENDIAN);

          offset += 4;

          proto_tree_add_item_ret_length(slsk_tree, hf_slsk_username, tvb, offset, 4, ENC_ASCII|ENC_LITTLE_ENDIAN, &str_len);

          offset += str_len;

          proto_tree_add_item_ret_length(slsk_tree, hf_slsk_chat_message, tvb, offset, 4, ENC_ASCII|ENC_LITTLE_ENDIAN, &str_len);

          offset += str_len;

        }

      break;