/* packet-edonkey.c

 * Routines for edonkey dissection

 * Copyright 2003, Xuan Zhang <xz@aemail4u.com>

 * Copyright 2007, Stefano Picerno <stefano.picerno@gmail.com>

 * Copyright 2008, Stefan Monhof <stefan.monhof@stud.uni-due.de>

 *

 * eDonkey dissector based on protocol descriptions from mldonkey:

 *  ftp://ftp.chatnfiles.com/gnu-mirror/savannah/files/mldonkey/docs/Edonkey-Overnet/edonkey-protocol.txt

 *  ftp://ftp.chatnfiles.com/gnu-mirror/savannah/files/mldonkey/docs/Edonkey-Overnet/overnet-protocol.txt

 *

 * Kademlia dissector based on source code inspection of aMule 2.1.3 and eMule 0.48a

 * Modified and added on the basis of information and names from the eMule 0.50 source code

 * found at http://www.emule-project.net

 *

 * 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 <stdlib.h>

#include <epan/packet.h>

#include <epan/prefs.h>

#include <epan/expert.h>

#include "packet-edonkey.h"

#include "packet-tcp.h"

void proto_reg_handoff_edonkey(void);

static dissector_handle_t edonkey_tcp_handle;

static dissector_handle_t edonkey_udp_handle;

static int proto_edonkey;

static int hf_edonkey_message;

static int hf_edonkey_protocol;

static int hf_edonkey_message_length;

static int hf_edonkey_message_type;

static int hf_edonkey_client_hash;

static int hf_edonkey_server_hash;

static int hf_edonkey_file_hash;

static int hf_edonkey_client_id;

static int hf_edonkey_metatag_namesize;

static int hf_edonkey_metatag_type;

static int hf_edonkey_metatag;

static int hf_edonkey_metatag_name;

static int hf_edonkey_metatag_id;

static int hf_edonkey_ip;

static int hf_edonkey_port;

static int hf_edonkey_hash;

static int hf_edonkey_part_count;

static int hf_edonkey_file_status;

static int hf_edonkey_directory;

static int hf_edonkey_string;

static int hf_edonkey_string_length;

static int hf_edonkey_fileinfo;

static int hf_edonkey_clientinfo;

static int hf_edonkey_serverinfo;

static int hf_edonkey_tcp_flags;

static int hf_edonkey_aux_port;

static int hf_edonkey_server_reported_ip;

static int hf_edonkey_soft_limit_files;

static int hf_edonkey_hard_limit_files;

static int hf_edonkey_number_of_lowid_users;

static int hf_edonkey_udp_flags;

static int hf_edonkey_udp_obfuscation_port;

static int hf_edonkey_tcp_obfuscation_port;

static int hf_edonkey_server_udp_key;

static int hf_emule_aich_partnum;

static int hf_emule_aich_root_hash;

static int hf_emule_aich_hash_entry;

static int hf_emule_aich_hash_id;

static int hf_emule_aich_hash;

static int hf_emule_multipacket_entry;

static int hf_emule_multipacket_opcode;

static int hf_emule_source_count;

static int hf_emule_zlib;

static int hf_emule_public_key;

static int hf_emule_signature;

static int hf_emule_sourceOBFU;

static int hf_overnet_peer;

static int hf_edonkey_unparsed_data_length;

static int hf_kademlia;

static int hf_kademlia_search_condition;

static int hf_kademlia_search_condition_argument_uint32;

static int hf_kademlia_search_condition_argument_uint64;

/* static int hf_kademlia_unparsed_data_length; */

static int hf_kademlia_peer;

static int hf_kademlia_peer_id;

static int hf_kademlia_hash;

static int hf_kademlia_file_id;

static int hf_kademlia_keyword_hash;

static int hf_kademlia_recipients_id;

static int hf_kademlia_sender_id;

static int hf_kademlia_target_id;

static int hf_kademlia_distance;

static int hf_kademlia_version;

static int hf_kademlia_peertype;

static int hf_kademlia_tag_float;

static int hf_kademlia_tag_uint64;

static int hf_kademlia_tag_uint32;

static int hf_kademlia_tag_ipv4;

static int hf_kademlia_tag_uint16;

static int hf_kademlia_tag_uint8;

static int hf_kademlia_tag_hash;

static int hf_kademlia_tag_bsob;

static int hf_kademlia_tag_string;

static int hf_kademlia_udp_port;

static int hf_kademlia_tcp_port;

static int hf_kademlia_ip;

static int hf_kademlia_tag_name;

static int hf_kademlia_tag_name_length;

static int hf_kademlia_tag_type;

static int hf_kademlia_request_type;

static int hf_kademlia_search_expression_type;

static int hf_kademlia_search_bool_op;

/* Generated from convert_proto_tree_add_text.pl */

static int hf_edonkey_list_size;

static int hf_edonkey_meta_tag_value_revision;

static int hf_edonkey_meta_tag_value_uint;

static int hf_edonkey_boolean_array_length;

static int hf_edonkey_blob_length;

static int hf_edonkey_kademlia_string;

static int hf_emule_public_key_length;

static int hf_emule_signature_length;

static int hf_edonkey_obfuscation_settings;

static int hf_edonkey_start_offset;

static int hf_edonkey_start_offset_64;

static int hf_edonkey_end_offset;

static int hf_edonkey_end_offset_64;

static int hf_edonkey_emule_file_length;

static int hf_edonkey_overnet_peer_type;

static int hf_edonkey_more_search_file_results;

static int hf_edonkey_file_size;

static int hf_edonkey_large_file_size;

static int hf_edonkey_number_of_users;

static int hf_edonkey_number_of_files;

static int hf_edonkey_message_data;

static int hf_edonkey_emule_version;

static int hf_edonkey_emule_queue_ranking;

static int hf_edonkey_emule_ident_state;

static int hf_edonkey_emule_rndchallenge;

static int hf_edonkey_emule_sig_ip_used;

static int hf_edonkey_packed_length;

static int hf_edonkey_compressed_message_data;

static int hf_edonkey_challenge;

static int hf_edonkey_max_number_of_users;

static int hf_edonkey_search_type;

static int hf_edonkey_search_range_min;

static int hf_edonkey_search_range_max;

static int hf_edonkey_kademlia_uload;

static int hf_edonkey_kademlia_start_position;

static int hf_edonkey_kademlia_filesize;

static int hf_edonkey_kademlia_restrictive;

static int hf_edonkey_broken_compressed_data;

static int hf_edonkey_search_limit;

static int hf_edonkey_search_limit_type;

static int hf_edonkey_search_ops;

static int hf_edonkey_user_hash_length;

static int ett_kademlia_tag;

static int ett_edonkey_listitem;

static int ett_kademlia_search_expression;

static int ett_edonkey;

static int ett_edonkey_message;

static int ett_edonkey_metatag;

static int ett_edonkey_search;

static int ett_edonkey_fileinfo;

static int ett_edonkey_serverinfo;

static int ett_edonkey_clientinfo;

static int ett_emule_aichhash;

static int ett_emule_multipacket;

static int ett_emule_zlib;

static int ett_overnet_peer;

static int ett_emule_sourceOBFU;

static expert_field ei_kademlia_tag_type;

static expert_field ei_kademlia_search_expression_type;

#define EDONKEY_TCP_PORT_RANGE "4661-4663" /* Not IANA registered */

#define EDONKEY_UDP_PORT_RANGE "4665,4672" /* Not IANA registered */

/* desegmentation of eDonkey over TCP */

static bool edonkey_desegment = true;

static const value_string kademlia_msgs[] = {

    { KADEMLIA2_BOOTSTRAP_REQ        ,"KADEMLIA2_BOOTSTRAP_REQ"      },

    { KADEMLIA2_BOOTSTRAP_RES        ,"KADEMLIA2_BOOTSTRAP_RES"      },

    { KADEMLIA2_HELLO_REQ            ,"KADEMLIA2_HELLO_REQ"          },

    { KADEMLIA2_HELLO_RES            ,"KADEMLIA2_HELLO_RES"          },

    { KADEMLIA2_PUBLISH_KEY_REQ      ,"KADEMLIA2_PUBLISH_KEY_REQ"    },

    { KADEMLIA2_PUBLISH_NOTES_REQ    ,"KADEMLIA2_PUBLISH_NOTES_REQ"  },

    { KADEMLIA2_PUBLISH_RES          ,"KADEMLIA2_PUBLISH_RES"        },

    { KADEMLIA2_PUBLISH_SOURCE_REQ   ,"KADEMLIA2_PUBLISH_SOURCE_REQ" },

    { KADEMLIA2_REQ                  ,"KADEMLIA2_REQ"                },

    { KADEMLIA2_RES                  ,"KADEMLIA2_RES"                },

    { KADEMLIA2_SEARCH_KEY_REQ       ,"KADEMLIA2_SEARCH_KEY_REQ"     },

    { KADEMLIA2_SEARCH_NOTES_REQ     ,"KADEMLIA2_SEARCH_NOTES_REQ"   },

    { KADEMLIA2_SEARCH_RES           ,"KADEMLIA2_SEARCH_RES"         },

    { KADEMLIA2_SEARCH_SOURCE_REQ    ,"KADEMLIA2_SEARCH_SOURCE_REQ"  },

    { KADEMLIA_BOOTSTRAP_REQ         ,"KADEMLIA_BOOTSTRAP_REQ"       },

    { KADEMLIA_BOOTSTRAP_RES         ,"KADEMLIA_BOOTSTRAP_RES"       },

    { KADEMLIA_CALLBACK_REQ          ,"KADEMLIA_CALLBACK_REQ"        },

    { KADEMLIA_FINDBUDDY_REQ         ,"KADEMLIA_FINDBUDDY_REQ"       },

    { KADEMLIA_FINDBUDDY_RES         ,"KADEMLIA_FINDBUDDY_RES"       },

    { KADEMLIA_FIREWALLED_ACK_RES    ,"KADEMLIA_FIREWALLED_ACK_RES"  },

    { KADEMLIA_FIREWALLED_REQ        ,"KADEMLIA_FIREWALLED_REQ"      },

    { KADEMLIA_FIREWALLED_RES        ,"KADEMLIA_FIREWALLED_RES"      },

    { KADEMLIA_HELLO_REQ             ,"KADEMLIA_HELLO_REQ"           },

    { KADEMLIA_HELLO_RES             ,"KADEMLIA_HELLO_RES"           },

    { KADEMLIA_PUBLISH_NOTES_REQ     ,"KADEMLIA_PUBLISH_NOTES_REQ"   },

    { KADEMLIA_PUBLISH_NOTES_RES     ,"KADEMLIA_PUBLISH_NOTES_RES"   },

    { KADEMLIA_PUBLISH_REQ           ,"KADEMLIA_PUBLISH_REQ"         },

    { KADEMLIA_PUBLISH_RES           ,"KADEMLIA_PUBLISH_RES"         },

    { KADEMLIA_REQ                   ,"KADEMLIA_REQ"                 },

    { KADEMLIA_RES                   ,"KADEMLIA_RES"                 },

    { KADEMLIA_SEARCH_NOTES_REQ      ,"KADEMLIA_SEARCH_NOTES_REQ"    },

    { KADEMLIA_SEARCH_NOTES_RES      ,"KADEMLIA_SEARCH_NOTES_RES"    },

    { KADEMLIA_SEARCH_REQ            ,"KADEMLIA_SEARCH_REQ"          },

    { KADEMLIA_SEARCH_RES            ,"KADEMLIA_SEARCH_RES"          },

    { 0, NULL }

};

static const value_string kademlia_tag_types[] = {

    { KADEMLIA_TAGTYPE_HASH          ,"TAGTYPE_HASH"      },

    { KADEMLIA_TAGTYPE_STRING        ,"TAGTYPE_STRING"    },

    { KADEMLIA_TAGTYPE_UINT32        ,"TAGTYPE_UINT32"    },

    { KADEMLIA_TAGTYPE_FLOAT32       ,"TAGTYPE_FLOAT32"   },

    { KADEMLIA_TAGTYPE_BOOL          ,"TAGTYPE_BOOL"      },

    { KADEMLIA_TAGTYPE_BOOLARRAY     ,"TAGTYPE_BOOLARRAY" },

    { KADEMLIA_TAGTYPE_BLOB          ,"TAGTYPE_BLOB"      },

    { KADEMLIA_TAGTYPE_UINT16        ,"TAGTYPE_UINT16"    },

    { KADEMLIA_TAGTYPE_UINT8         ,"TAGTYPE_UINT8"     },

    { KADEMLIA_TAGTYPE_BSOB          ,"TAGTYPE_BSOB"      },

    { KADEMLIA_TAGTYPE_UINT64        ,"TAGTYPE_UINT64"    },

    { KADEMLIA_TAGTYPE_STR1          ,"TAGTYPE_STR1"      },

    { KADEMLIA_TAGTYPE_STR2          ,"TAGTYPE_STR2"      },

    { KADEMLIA_TAGTYPE_STR3          ,"TAGTYPE_STR3"      },

    { KADEMLIA_TAGTYPE_STR4          ,"TAGTYPE_STR4"      },

    { KADEMLIA_TAGTYPE_STR5          ,"TAGTYPE_STR5"      },

    { KADEMLIA_TAGTYPE_STR6          ,"TAGTYPE_STR6"      },

    { KADEMLIA_TAGTYPE_STR7          ,"TAGTYPE_STR7"      },

    { KADEMLIA_TAGTYPE_STR8          ,"TAGTYPE_STR8"      },

    { KADEMLIA_TAGTYPE_STR9          ,"TAGTYPE_STR9"      },

    { KADEMLIA_TAGTYPE_STR10         ,"TAGTYPE_STR10"     },

    { KADEMLIA_TAGTYPE_STR11         ,"TAGTYPE_STR11"     },

    { KADEMLIA_TAGTYPE_STR12         ,"TAGTYPE_STR12"     },

    { KADEMLIA_TAGTYPE_STR13         ,"TAGTYPE_STR13"     },

    { KADEMLIA_TAGTYPE_STR14         ,"TAGTYPE_STR14"     },

    { KADEMLIA_TAGTYPE_STR15         ,"TAGTYPE_STR15"     },

    { KADEMLIA_TAGTYPE_STR16         ,"TAGTYPE_STR16"     },

    { KADEMLIA_TAGTYPE_STR17         ,"TAGTYPE_STR17"     },

    { KADEMLIA_TAGTYPE_STR18         ,"TAGTYPE_STR18"     },

    { KADEMLIA_TAGTYPE_STR19         ,"TAGTYPE_STR19"     },

    { KADEMLIA_TAGTYPE_STR20         ,"TAGTYPE_STR20"     },

    { KADEMLIA_TAGTYPE_STR21         ,"TAGTYPE_STR21"     },

    { KADEMLIA_TAGTYPE_STR22         ,"TAGTYPE_STR22"     },

    { 0, NULL }

};

static const value_string kademlia_tags[] = {

    { KADEMLIA_TAG_BUDDYHASH         ,"TAG_BUDDYHASH"    },

    { KADEMLIA_TAG_CLIENTLOWID       ,"TAG_CLIENTLOWID"  },

    { KADEMLIA_TAG_COLLECTION        ,"TAG_COLLECTION"   },

    { KADEMLIA_TAG_COPIED            ,"TAG_COPIED"       },

    { KADEMLIA_TAG_DESCRIPTION       ,"TAG_DESCRIPTION"  },

    { KADEMLIA_TAG_ENCRYPTION        ,"TAG_ENCRYPTION"   },

    { KADEMLIA_TAG_FAIL              ,"TAG_FAIL"         },

    { KADEMLIA_TAG_FILECOMMENT       ,"TAG_FILECOMMENT"  },

    { KADEMLIA_TAG_FILE_COUNT        ,"TAG_FILE_COUNT"   },

    { KADEMLIA_TAG_FILEFORMAT        ,"TAG_FILEFORMAT"   },

    { KADEMLIA_TAG_FILENAME          ,"TAG_FILENAME"     },

    { KADEMLIA_TAG_FILERATING        ,"TAG_FILERATING"   },

    { KADEMLIA_TAG_FILESIZE_HI       ,"TAG_FILESIZE_HI"  },

    { KADEMLIA_TAG_FILESIZE          ,"TAG_FILESIZE"     },

    { KADEMLIA_TAG_FILETYPE          ,"TAG_FILETYPE"     },

    { KADEMLIA_TAG_GAP_END           ,"TAG_GAP_END"      },

    { KADEMLIA_TAG_GAP_START         ,"TAG_GAP_START"    },

    { KADEMLIA_TAG_IP_ADDRESS        ,"TAG_IP_ADDRESS"   },

    { KADEMLIA_TAG_MEDIA_ALBUM       ,"TAG_MEDIA_ALBUM"  },

    { KADEMLIA_TAG_MEDIA_ARTIST      ,"TAG_MEDIA_ARTIST" },

    { KADEMLIA_TAG_MEDIA_BITRATE     ,"TAG_MEDIA_BITRATE"},

    { KADEMLIA_TAG_MEDIA_CODEC       ,"TAG_MEDIA_CODEC"  },

    { KADEMLIA_TAG_MEDIA_LENGTH      ,"TAG_MEDIA_LENGTH" },

    { KADEMLIA_TAG_MEDIA_TITLE       ,"TAG_MEDIA_TITLE"  },

    { KADEMLIA_TAG_PART_HASH         ,"TAG_PART_HASH"    },

    { KADEMLIA_TAG_PART_PATH         ,"TAG_PART_PATH"    },

    { KADEMLIA_TAG_PARTS             ,"TAG_PARTS"        },

    { KADEMLIA_TAG_PERMISSIONS       ,"TAG_PERMISSIONS"  },

    { KADEMLIA_TAG_PING              ,"TAG_PING"         },

    { KADEMLIA_TAG_PORT              ,"TAG_PORT"         },

    { KADEMLIA_TAG_PREFERENCE        ,"TAG_PREFERENCE"   },

    { KADEMLIA_TAG_PRIORITY          ,"TAG_PRIORITY"     },

    { KADEMLIA_TAG_QTIME             ,"TAG_QTIME"        },

    { KADEMLIA_TAG_SERVERIP          ,"TAG_SERVERIP"     },

    { KADEMLIA_TAG_SERVERPORT        ,"TAG_SERVERPORT"   },

    { KADEMLIA_TAG_SOURCEIP          ,"TAG_SOURCEIP"     },

    { KADEMLIA_TAG_SOURCEPORT        ,"TAG_SOURCEPORT"   },

    { KADEMLIA_TAG_SOURCES           ,"TAG_SOURCES"      },

    { KADEMLIA_TAG_SOURCETYPE        ,"TAG_SOURCETYPE"   },

    { KADEMLIA_TAG_SOURCEUPORT       ,"TAG_SOURCEUPORT"  },

    { KADEMLIA_TAG_STATUS            ,"TAG_STATUS"       },

    { KADEMLIA_TAG_TEMPFILE          ,"TAG_TEMPFILE"     },

    { KADEMLIA_TAG_USER_COUNT        ,"TAG_USER_COUNT"   },

    { KADEMLIA_TAG_VERSION           ,"TAG_VERSION"      },

    { 0, NULL }

};

static const value_string edonkey_protocols[] = {

    { EDONKEY_PROTO_EDONKEY,             "eDonkey"                  },

    { EDONKEY_PROTO_EMULE_EXT,           "eMule Extensions"         },

    { EDONKEY_PROTO_EMULE_COMP,          "eMule Compressed"         },

    { EDONKEY_PROTO_KADEMLIA,            "Kademlia"                 },

    { EDONKEY_PROTO_KADEMLIA_COMP,       "Kademlia Compressed"      },

    { EDONKEY_PROTO_ADU_KADEMLIA,        "KAdu"                     },

    { EDONKEY_PROTO_ADU_KADEMLIA_COMP,   "KAdu Compressed"          },

    { 0,                                 NULL                       }

};

static const value_string edonkey_tcp_msgs[] = {

    { EDONKEY_MSG_HELLO,                 "Hello"                    },

    { EDONKEY_MSG_BAD_PROTO,             "Bad Proto"                },

    { EDONKEY_MSG_GET_SERVER_LIST,       "Get Server List"          },

    { EDONKEY_MSG_OFFER_FILES,           "Offer Files"              },

    { EDONKEY_MSG_SEARCH_FILES,          "Search Files"             },

    { EDONKEY_MSG_DISCONNECT,            "Disconnect"               },

    { EDONKEY_MSG_GET_SOURCES,           "Get Sources"              },

    { EDONKEY_MSG_GET_SOURCES_OBFU,      "Get Sources Obfuscation"  },

    { EDONKEY_MSG_SEARCH_USER,           "Search User"              },

    { EDONKEY_MSG_CLIENT_CB_REQ,         "Client Callback Request"  },

    { EDONKEY_MSG_MORE_RESULTS,          "More Results"             },

    { EDONKEY_MSG_SERVER_LIST,           "Server List"              },

    { EDONKEY_MSG_SEARCH_FILE_RESULTS,   "Search File Results"      },

    { EDONKEY_MSG_SERVER_STATUS,         "Server Status"            },

    { EDONKEY_MSG_SERVER_CB_REQ,         "Server Callback Request"  },

    { EDONKEY_MSG_CALLBACK_FAIL,         "Callback Fail"            },

    { EDONKEY_MSG_SERVER_MESSAGE,        "Server Message"           },

    { EDONKEY_MSG_ID_CHANGE,             "ID Change"                },

    { EDONKEY_MSG_SERVER_INFO_DATA,      "Server Info Data"         },

    { EDONKEY_MSG_FOUND_SOURCES,         "Found Sources"            },

    { EDONKEY_MSG_FOUND_SOURCES_OBFU,    "Found Sources Obfuscation"},

    { EDONKEY_MSG_SEARCH_USER_RESULTS,   "Search User Results"      },

    { EDONKEY_MSG_SENDING_PART,          "Sending Part"             },

    { EDONKEY_MSG_REQUEST_PARTS,         "Request Parts"            },

    { EDONKEY_MSG_NO_SUCH_FILE,          "No Such File"             },

    { EDONKEY_MSG_END_OF_DOWNLOAD,       "End of Download"          },

    { EDONKEY_MSG_VIEW_FILES,            "View Files"               },

    { EDONKEY_MSG_VIEW_FILES_ANSWER,     "View Files Answer"        },

    { EDONKEY_MSG_HELLO_ANSWER,          "Hello Answer"             },

    { EDONKEY_MSG_NEW_CLIENT_ID,         "New Client ID"            },

    { EDONKEY_MSG_CLIENT_MESSAGE,        "Client Message"           },

    { EDONKEY_MSG_FILE_STATUS_REQUEST,   "File Status Request"      },

    { EDONKEY_MSG_FILE_STATUS,           "File Status"              },

    { EDONKEY_MSG_HASHSET_REQUEST,       "Hashset Request"          },

    { EDONKEY_MSG_HASHSET_ANSWER,        "Hashset Answer"           },

    { EDONKEY_MSG_SLOT_REQUEST,          "Slot Request"             },

    { EDONKEY_MSG_SLOT_GIVEN,            "Slot Given"               },

    { EDONKEY_MSG_SLOT_RELEASE,          "Slot Release"             },

    { EDONKEY_MSG_SLOT_TAKEN,            "Slot Taken"               },

    { EDONKEY_MSG_FILE_REQUEST,          "File Request"             },

    { EDONKEY_MSG_FILE_REQUEST_ANSWER,   "File Request Answer"      },

    { EDONKEY_MSG_GET_SHARED_DIRS,       "Get Shared Directories"   },

    { EDONKEY_MSG_GET_SHARED_FILES,      "Get Shared Files"         },

    { EDONKEY_MSG_SHARED_DIRS,           "Shared Directories"       },

    { EDONKEY_MSG_SHARED_FILES,          "Shared Files"             },

    { EDONKEY_MSG_SHARED_DENIED,         "Shared Denied"            },

    { 0,                                 NULL                       }

};

static const value_string emule_tcp_msgs[] = {

    { EMULE_MSG_HELLO,                   "Hello"                    },

    { EMULE_MSG_HELLO_ANSWER,            "Hello Answer"             },

    { EMULE_MSG_DATA_COMPRESSED,         "Data Compressed"          },

    { EMULE_MSG_QUEUE_RANKING,           "Queue Ranking"            },

    { EMULE_MSG_FILE_DESC,               "File Description"         },

    { EMULE_MSG_SOURCES_REQUEST,         "Sources Request"          },

    { EMULE_MSG_SOURCES_ANSWER,          "Sources Answer"           },

    { EMULE_MSG_SIGNATURE,               "Signature"                },

    { EMULE_MSG_PUBLIC_KEY,              "Public Key"                  },

    { EMULE_MSG_SEC_IDENT_STATE,         "Second Identification State" },

    { EMULE_MSG_MULTIPACKET,             "MultiPacket"              },

    { EMULE_MSG_MULTIPACKET_EXT,         "MultiPacketExt"           },

    { EMULE_MSG_MULTIPACKET_ANSWER,      "MultiPacket Answer"       },

    { EMULE_MSG_CALLBACK,                "Callback"                 },

    { EMULE_MSG_AICH_REQUEST,            "AICH Hashset Request"     },

    { EMULE_MSG_AICH_ANSWER,             "AICH Hashset Answer"      },

    { EMULE_MSG_AICHFILEHASH_ANSWER,     "AICH Master Hash Request" },

    { EMULE_MSG_AICHFILEHASH_REQUEST,    "AICH Master Hash Answer"  },

    { EMULE_MSG_DATA_COMPRESSED_64,      "Data Compressed (64bit)"  },

    { EMULE_MSG_SENDING_PART_64,         "Sending Part (64bit)"     },

    { EMULE_MSG_REQUEST_PARTS_64,        "Request Parts (64bit)"    },

    { 0,                                 NULL                       }

};

static const value_string edonkey_udp_msgs[] = {

    { EDONKEY_MSG_UDP_SERVER_STATUS_REQUEST,    "Server Status Request"    },

    { EDONKEY_MSG_UDP_SERVER_STATUS,            "Server Status"            },

    { EDONKEY_MSG_UDP_SEARCH_FILE,              "Search File"              },

    { EDONKEY_MSG_UDP_SEARCH_FILE_RESULTS,      "Search File Results"      },

    { EDONKEY_MSG_UDP_GET_SOURCES,              "Get Sources"              },

    { EDONKEY_MSG_UDP_FOUND_SOURCES,            "Found Sources"            },

    { EDONKEY_MSG_UDP_CALLBACK_REQUEST,         "Callback Request"         },

    { EDONKEY_MSG_UDP_CALLBACK_FAIL,            "Callback Fail"            },

    { EDONKEY_MSG_UDP_SERVER_LIST,              "Server List"              },

    { EDONKEY_MSG_UDP_GET_SERVER_INFO,          "Get Server Info"          },

    { EDONKEY_MSG_UDP_SERVER_INFO,              "Server Info"              },

    { EDONKEY_MSG_UDP_GET_SERVER_LIST,          "Get Server List"          },

    /* eMule Extensions */

    { EMULE_MSG_UDP_REASKFILEPING,              "Reask File Ping"          },

    { EMULE_MSG_UDP_REASKACK,                   "Reask ACK"                },

    { EMULE_MSG_UDP_FILE_NOT_FOUND,             "File not found"           },

    { EMULE_MSG_UDP_QUEUE_FULL,                 "Queue Full"               },

    /* Overnet Extensions */

    { OVERNET_MSG_UDP_CONNECT,                  "Connect"                  },

    { OVERNET_MSG_UDP_CONNECT_REPLY,            "Connect Reply"            },

    { OVERNET_MSG_UDP_PUBLICIZE,                "Publicize"                },

    { OVERNET_MSG_UDP_PUBLICIZE_ACK,            "Publicize ACK"            },

    { OVERNET_MSG_UDP_SEARCH,                   "Search"                   },

    { OVERNET_MSG_UDP_SEARCH_NEXT,              "Search Next"              },

    { OVERNET_MSG_UDP_SEARCH_INFO,              "Search Info"              },

    { OVERNET_MSG_UDP_SEARCH_RESULT,            "Search Result"            },

    { OVERNET_MSG_UDP_SEARCH_END,               "Search End"               },

    { OVERNET_MSG_UDP_PUBLISH,                  "Publish"                  },

    { OVERNET_MSG_UDP_PUBLISH_ACK,              "Publish ACK"              },

    { OVERNET_MSG_UDP_IDENTIFY_REPLY,           "Identify Reply"           },

    { OVERNET_MSG_UDP_IDENTIFY_ACK,             "Identify ACK"             },

    { OVERNET_MSG_UDP_FIREWALL_CONNECTION,      "Firewall Connection"      },

    { OVERNET_MSG_UDP_FIREWALL_CONNECTION_ACK,  "Firewall Connection ACK"  },

    { OVERNET_MSG_UDP_FIREWALL_CONNECTION_NACK, "Firewall Connection NACK" },

    { OVERNET_MSG_UDP_IP_QUERY,                 "IP Query"                 },

    { OVERNET_MSG_UDP_IP_QUERY_ANSWER,          "IP Query Answer"          },

    { OVERNET_MSG_UDP_IP_QUERY_END,             "IP Query End"             },

    { OVERNET_MSG_UDP_IDENTIFY,                 "Identify"                 },

    { 0,                                        NULL                       }

};

static const value_string edonkey_special_tags[] = {

    { EDONKEY_STAG_NAME,                "Name"                      },

    { EDONKEY_STAG_SIZE,                "Size"                      },

    { EDONKEY_STAG_TYPE,                "Type"                      },

    { EDONKEY_STAG_FORMAT,              "Format"                    },

    { EDONKEY_STAG_COLLECTION,          "Collection"                },

    { EDONKEY_STAG_PART_PATH,           "Part Path"                 },

    { EDONKEY_STAG_PART_HASH,           "Part Hash"                 },

    { EDONKEY_STAG_COPIED,              "Copied"                    },

    { EDONKEY_STAG_GAP_START,           "Gap Start"                 },

    { EDONKEY_STAG_GAP_END,             "Gap End"                   },

    { EDONKEY_STAG_DESCRIPTION,         "Description"               },

    { EDONKEY_STAG_PING,                "Ping"                      },

    { EDONKEY_STAG_FAIL,                "Fail"                      },

    { EDONKEY_STAG_PREFERENCE,          "Preference"                },

    { EDONKEY_STAG_PORT,                "Port"                      },

    { EDONKEY_STAG_IP,                  "IP"                        },

    { EDONKEY_STAG_VERSION,             "Version"                   },

    { EDONKEY_STAG_TEMPFILE,            "Temporary File"            },

    { EDONKEY_STAG_PRIORITY,            "Priority"                  },

    { EDONKEY_STAG_STATUS,              "Status"                    },

    { EDONKEY_STAG_AVAILABILITY,        "Availability"              },

    { EDONKEY_STAG_QTIME,               "Queue Time"                },

    { EDONKEY_STAG_PARTS,               "Parts"                     },

    { EDONKEY_STAG_MOD_VERSION,         "Mod Version"               },

    { EMULE_STAG_COMPRESSION,           "Compression"               },

    { EMULE_STAG_UDP_CLIENT_PORT,       "UDP Client Port"           },

    { EMULE_STAG_UDP_VERSION,           "UDP Version"               },

    { EMULE_STAG_SOURCE_EXCHANGE,       "Source Exchange"           },

    { EMULE_STAG_COMMENTS,              "Comments"                  },

    { EMULE_STAG_EXTENDED_REQUEST,      "Extended Request"          },

    { EMULE_STAG_COMPATIBLE_CLIENT,     "Compatible Client"         },

    { EMULE_STAG_COMPLETE_SOURCES,      "Complete Sources"          },

    { EMULE_STAG_SIZE_HI,               "Size (High Byte)"          },

    { EMULE_STAG_SERVER_VERSION,        "Server Version"            },

    { EMULE_STAG_COMPAT_OPTIONS1,       "Compatible Options"        },

    { EMULE_STAG_UDPPORTS,              "UDP Ports"                 },

    { EMULE_STAG_MISCOPTIONS1,          "Misc Options 1"            },

    { EMULE_STAG_VERSION,               "eMule Version"             },

    { EMULE_STAG_BUDDYIP,               "Buddy IP"                  },

    { EMULE_STAG_BUDDYUDP,              "Buddy UDP"                 },

    { EMULE_STAG_MISCOPTIONS2,          "Misc Options 2"            },

    { 0,                                NULL                        }

};

static const value_string edonkey_search_type_vals[] = {

    { EDONKEY_SEARCH_BOOL,              "Boolean"                   },

    { EDONKEY_SEARCH_NAME,              "Name"                      },

    { EDONKEY_SEARCH_META,              "Metadata"                  },

    { EDONKEY_SEARCH_LIMIT,             "Limit"                     },

    { 0,                                NULL                        }

};

static const value_string edonkey_search_ext_type_vals[] = {

    { 0,              "BoolOp"                   },

    { 1,              "String"                   },

    { 2,              "MetaTag"                  },

    { 3,              "32bitOp"                  },

    { 4,              "64bitOp"                  },

    { 0,              NULL                       }

};

static const value_string edonkey_search_ops[] = {

    { EDONKEY_SEARCH_AND,               "AND"                       },

    { EDONKEY_SEARCH_OR,                "OR"                        },

    { EDONKEY_SEARCH_ANDNOT,            "AND NOT"                   },

    { 0,                                NULL                        }

};

static const value_string edonkey_search_conds[] = {

    { EDONKEY_SEARCH_MIN,               "MIN"                       },

    { EDONKEY_SEARCH_MAX,               "MAX"                       },

    { 0,                                NULL                        }

};

static const value_string kademlia_search_conds[] = {

    { 0, "="  },

    { 1, ">"  },

    { 2, "<"  },

    { 3, ">=" },

    { 4, "<=" },

    { 5, "<>" },

    { 0, NULL }

};

static const value_string kademlia_versions[] = {

    { KADEMLIA_VERSION1_46c,     " (eMule <= 0.46c or compatibles)"   },

    { KADEMLIA_VERSION2_47a,     " (eMule 0.47a or compatibles)"      },

    { KADEMLIA_VERSION3_47b,     " (eMule 0.47b or compatibles)"      },

    { KADEMLIA_VERSION5_48a,     " (eMule 0.48a or compatibles)"      },

    { KADEMLIA_VERSION6_49aBETA, " (eMule 0.49aBETA1 or compatibles)" },

    { KADEMLIA_VERSION7_49a,     " (eMule 0.49a or compatibles)"      },

    { 0,                         NULL                                 }

};

static const value_string kademlia_parameter[] = {

    { KADEMLIA_FIND_VALUE,       " (Find Value)"   },

    { KADEMLIA_STORE,            " (Store)"        },

    { KADEMLIA_FIND_NODE,        " (Find Node)"    },

    { 0,                         NULL              }

};

static const value_string kademlia_tag_sourcetype[] = {

    { 1,                         "HighID Source"                                          },

    { 3,                         "Firewalled Kad Source"                                  },

    { 4,                         ">4GB file HighID Source"                                },

    { 5,                         ">4GB file Firewalled Kad Source"                        },

    { 6,                         "Firewalled Source with Direct Callback (supports >4GB)" },

    { 0,                         NULL                                                     }

};

static const value_string kademlia_tag_encryption[] = {

    { 1,                         "Supports Crypt Layer"                                              },

    { 2,                         "Requests Crypt Layer"                                              },

    { 3,                         "Supports & Requests Crypt Layer"                                   },

    { 4,                         "Requires Crypt Layer"                                              },

    { 5,                         "Supports & Requires Crypt Layer"                                   },

    { 6,                         "Requests & Requires Crypt Layer"                                   },

    { 7,                         "Supports, Requests & Requires Crypt Layer"                         },

    { 8,                         "Direct UDP Callback"                                               },

    { 9,                         "Supports Crypt Layer; Direct UDP Callback"                         },

    { 10,                        "Requests Crypt Layer; Direct UDP Callback"                         },

    { 11,                        "Supports & Requests Crypt Layer; Direct UDP Callback"              },

    { 12,                        "Requires Crypt Layer; Direct UDP Callback"                         },

    { 13,                        "Supports & Requires Crypt Layer; Direct UDP Callback"              },

    { 14,                        "Requests & Requires Crypt Layer; Direct UDP Callback"              },

    { 15,                        "Supports, Requests & Requires Crypt Layer; Direct UDP Callback"    },

    { 0,                         NULL                                                                }

};

static const range_string emule_ident_state_rvals[] = {

    { 0, 0,  "nothing is needed" },

    { 1, 1,  "signature is needed" },

    { 2, 255,  "public key and signature are needed" },

    { 0, 0, NULL }

};

/* Dissects a generic eDonkey list */

static int dissect_edonkey_list(tvbuff_t *tvb, packet_info *pinfo,

                                int offset,  proto_tree *tree,

                                int listnum_length, const char* listdesc,

                                int  (*item_dissector)(tvbuff_t  *, packet_info *, int, proto_tree *))

{

    /* <List> ::= <List Size> <Item>* */

    uint32_t listnum, i;

    proto_tree *subtree;

    proto_item* ti;

    proto_item* list_ti;

    int list_start_offset;

    list_start_offset = offset;

    switch (listnum_length) {

        case -1:

        case 1:

            listnum = tvb_get_uint8(tvb, offset);

            break;

        case -2:

            listnum = tvb_get_ntohs(tvb, offset);

            break;

        case 2:

            listnum = tvb_get_letohs(tvb, offset);

            break;

        case 4:

            listnum = tvb_get_letohl(tvb, offset);

            break;

        case -4:

            listnum = tvb_get_ntohl(tvb, offset);

            break;

        default:

            /* Not Supported */

            return offset;

    }

    if (listnum_length < 0)

        listnum_length = -listnum_length;

    /* keep the tree item object, its length will be set at the end of the function */

    list_ti = proto_tree_add_uint_format(tree, hf_edonkey_list_size, tvb, offset, listnum_length, listnum, "%s List Size: %u", listdesc, listnum);

    offset+= listnum_length;

    for (i=0; i<listnum; i++)

    {

        int item_start_offset;

        item_start_offset = offset;

        subtree = proto_tree_add_subtree_format( tree, tvb, item_start_offset, 1, ett_edonkey_listitem, &ti,

                                    "%s[%u/%u]", listdesc, i+1, listnum);

        /* dissect one list element */

        offset = (*item_dissector)(tvb, pinfo, offset, subtree);

        /* Set the container node length */

        proto_item_set_len( ti, offset - item_start_offset );

    }

    /* Set the container node length */

    proto_item_set_len(list_ti, offset - list_start_offset );

    return offset;

}

static int lookup_str_index(char* str, int length, const value_string *vs)

{

    int i = 0;

    if (str == NULL) return -1;

    while (vs[i].strptr) {

        if (g_ascii_strncasecmp(str, vs[i].strptr, length) == 0)

            return i;

        i++;

    }

    return -1;

}

static uint8_t edonkey_metatag_name_get_type(tvbuff_t *tvb, packet_info* pinfo, int start, int length, uint8_t special_tagtype)

{

    uint8_t *tag_name;

    if (try_val_to_str(special_tagtype, edonkey_special_tags) == NULL) {

        int idx;

        tag_name = tvb_get_string_enc(pinfo->pool, tvb, start, length, ENC_ASCII|ENC_NA);

        idx = lookup_str_index(tag_name, length, edonkey_special_tags);

        if (idx < 0)

            return EDONKEY_STAG_UNKNOWN;

        else return edonkey_special_tags[idx].value;

    }

    else return special_tagtype;

}

static proto_item* edonkey_tree_add_metatag_name(proto_tree *tree, tvbuff_t *tvb,

                                                 int start, int length, uint8_t special_tagtype)

{

    const char *tag_name;

    /*

     * XXX - what, in the *protocol*, distinguishes integral from string

     * tag names?  Name length > 1 means "string"?  Something else?

     */

    tag_name = try_val_to_str(special_tagtype, edonkey_special_tags);

    if (tag_name == NULL) {

        return proto_tree_add_item(tree, hf_edonkey_metatag_name, tvb, start, length, ENC_ASCII);

    }

    else {

        return proto_tree_add_uint_format(tree, hf_edonkey_metatag_id, tvb, start, length,

                                          special_tagtype, "Meta Tag Name: %s (0x%02x)",

                                          tag_name, special_tagtype);

    }

}

static int dissect_kademlia_search_condition_argument_uint64(tvbuff_t *tvb, packet_info *pinfo _U_,

                                   int offset, proto_tree *tree)

{

    proto_tree_add_item( tree, hf_kademlia_search_condition_argument_uint64, tvb, offset, 8, ENC_LITTLE_ENDIAN );

    return offset + 8;

}

static int dissect_kademlia_search_condition_argument_uint32(tvbuff_t *tvb, packet_info *pinfo _U_,

                                   int offset, proto_tree *tree)

{

    proto_tree_add_item( tree, hf_kademlia_search_condition_argument_uint32, tvb, offset, 4, ENC_LITTLE_ENDIAN );

    return offset + 4;

}

static int dissect_kademlia_search_condition(tvbuff_t *tvb, packet_info *pinfo _U_,

                                   int offset, proto_tree *tree )

{

    proto_item * ti;

    uint16_t value = tvb_get_uint8(tvb, offset);

    ti = proto_tree_add_item( tree, hf_kademlia_search_condition, tvb, offset, 1, ENC_BIG_ENDIAN );

    proto_item_append_text(ti, " [%s]", val_to_str_const( value, kademlia_search_conds, "Unknown") );

    return offset + 1;

}

/* Dissects the eDonkey meta tag */

static int dissect_edonkey_metatag(tvbuff_t *tvb, packet_info *pinfo,

                                   int offset, proto_tree *tree)

{

    /* <Meta Tag> ::= <Tag Type (uint8_t)> <Tag Name> <Tag> */

    /* <Tag Name> ::= <Tag Name Size (uint16_t)> <Special Tag> || <String> */

    /* <Tag Name> ::= <Special Tag> iff Tag Type had the top bit set */

    proto_item *ti;

    proto_tree *metatag_tree;

    uint8_t real_tag_type, tag_type, special_tagtype, trans_tagtype;

    uint16_t tag_name_size, string_length, array_length;

    uint32_t tag_length, blob_length;

    int tag_offset;

    real_tag_type = tag_type = tvb_get_uint8(tvb, offset);

    if (tag_type & EDONKEY_MTAG_SHORTNAME) {

        real_tag_type &= ~EDONKEY_MTAG_SHORTNAME;

        tag_name_size = 1;

        special_tagtype = tvb_get_uint8(tvb, offset+1);

        tag_length = 2;

    } else {

        tag_name_size = tvb_get_letohs(tvb, offset+1);

        special_tagtype = tvb_get_uint8(tvb, offset+3);

        tag_length = 3 + tag_name_size;

    }

    tag_offset = offset + tag_length;

    switch (real_tag_type)

    {

        case EDONKEY_MTAG_HASH:

            /* <Tag> ::= HASH */

            tag_length += 16;

            ti = proto_tree_add_item(tree, hf_edonkey_metatag, tvb, offset, tag_length, ENC_NA);

            metatag_tree = proto_item_add_subtree(ti, ett_edonkey_metatag);

            proto_tree_add_uint(metatag_tree, hf_edonkey_metatag_type, tvb, offset, 1, tag_type);

            if (tag_type==real_tag_type)

                proto_tree_add_uint(metatag_tree, hf_edonkey_metatag_namesize, tvb, offset+1, 2, tag_name_size);

            edonkey_tree_add_metatag_name(metatag_tree, tvb, tag_offset-tag_name_size, tag_name_size, special_tagtype);

            proto_tree_add_item(metatag_tree, hf_edonkey_hash, tvb, tag_offset, 16, ENC_NA);

            break;

        case EDONKEY_MTAG_STRING:

            /* <Tag> ::= <Length (uint16_t)> <String> */

            string_length = tvb_get_letohs(tvb, tag_offset);

            tag_length += 2+string_length;

            ti = proto_tree_add_item(tree, hf_edonkey_metatag, tvb, offset, tag_length, ENC_NA);

            metatag_tree = proto_item_add_subtree(ti, ett_edonkey_metatag);

            proto_tree_add_uint(metatag_tree, hf_edonkey_metatag_type, tvb, offset, 1, tag_type);

            if (tag_type==real_tag_type)

                proto_tree_add_uint(metatag_tree, hf_edonkey_metatag_namesize, tvb, offset+1, 2, tag_name_size);

            edonkey_tree_add_metatag_name(metatag_tree, tvb, tag_offset-tag_name_size, tag_name_size, special_tagtype);

            proto_tree_add_uint(metatag_tree, hf_edonkey_string_length, tvb, tag_offset, 2, string_length);

            proto_tree_add_item(metatag_tree, hf_edonkey_string, tvb, tag_offset+2, string_length, ENC_ASCII);

            break;

        case EDONKEY_MTAG_DWORD:

            /* <Tag> ::= uint32_t */

            tag_length += 4;

            ti = proto_tree_add_item(tree, hf_edonkey_metatag, tvb, offset, tag_length, ENC_NA);

            metatag_tree = proto_item_add_subtree(ti, ett_edonkey_metatag);

            proto_tree_add_uint(metatag_tree, hf_edonkey_metatag_type, tvb, offset, 1, tag_type);

            if (tag_type==real_tag_type)

                proto_tree_add_uint(metatag_tree, hf_edonkey_metatag_namesize, tvb, offset+1, 2, tag_name_size);

            edonkey_tree_add_metatag_name(metatag_tree, tvb, tag_offset-tag_name_size, tag_name_size, special_tagtype);

            trans_tagtype = edonkey_metatag_name_get_type(tvb, pinfo, offset+3, tag_name_size, special_tagtype);

            if (trans_tagtype == EDONKEY_STAG_IP) {

                proto_tree_add_item(metatag_tree, hf_edonkey_ip, tvb, tag_offset, 4, ENC_BIG_ENDIAN);

            }

            else if (trans_tagtype == EMULE_STAG_SERVER_VERSION) {

                proto_tree_add_item(metatag_tree, hf_edonkey_meta_tag_value_revision, tvb, tag_offset, 4, ENC_LITTLE_ENDIAN);

            }

            else {

                proto_tree_add_item(metatag_tree, hf_edonkey_meta_tag_value_uint, tvb, tag_offset, 4, ENC_LITTLE_ENDIAN);

            }

            break;

        case EDONKEY_MTAG_FLOAT:

            /* <Tag> ::=  4 byte float */

            tag_length += 4;

            ti = proto_tree_add_item(tree, hf_edonkey_metatag, tvb, offset, tag_length, ENC_NA);

            metatag_tree = proto_item_add_subtree(ti, ett_edonkey_metatag);

            proto_tree_add_uint(metatag_tree, hf_edonkey_metatag_type, tvb, offset, 1, tag_type);

            if (tag_type==real_tag_type)

                proto_tree_add_uint(metatag_tree, hf_edonkey_metatag_namesize, tvb, offset+1, 2, tag_name_size);

            edonkey_tree_add_metatag_name(metatag_tree, tvb, tag_offset-tag_name_size, tag_name_size, special_tagtype);

            break;

        case EDONKEY_MTAG_WORD:

            /* <Tag> ::= uint16_t */

            tag_length += 2;

            ti = proto_tree_add_item(tree, hf_edonkey_metatag, tvb, offset, tag_length, ENC_NA);

            metatag_tree = proto_item_add_subtree(ti, ett_edonkey_metatag);

            proto_tree_add_uint(metatag_tree, hf_edonkey_metatag_type, tvb, offset, 1, tag_type);

            if (tag_type==real_tag_type)

                proto_tree_add_uint(metatag_tree, hf_edonkey_metatag_namesize, tvb, offset+1, 2, tag_name_size);

            edonkey_tree_add_metatag_name(metatag_tree, tvb, tag_offset-tag_name_size, tag_name_size, special_tagtype);

            proto_tree_add_item(metatag_tree, hf_edonkey_meta_tag_value_uint, tvb, tag_offset, 2, ENC_LITTLE_ENDIAN);

            break;

        case EDONKEY_MTAG_BYTE:

            /* <Tag> ::= uint8_t */

            tag_length += 1;

            ti = proto_tree_add_item(tree, hf_edonkey_metatag, tvb, offset, tag_length, ENC_NA);

            metatag_tree = proto_item_add_subtree(ti, ett_edonkey_metatag);

            proto_tree_add_uint(metatag_tree, hf_edonkey_metatag_type, tvb, offset, 1, tag_type);

            if (tag_type==real_tag_type)

                proto_tree_add_uint(metatag_tree, hf_edonkey_metatag_namesize, tvb, offset+1, 2, tag_name_size);

            edonkey_tree_add_metatag_name(metatag_tree, tvb, tag_offset-tag_name_size, tag_name_size, special_tagtype);

            proto_tree_add_item(metatag_tree, hf_edonkey_meta_tag_value_uint, tvb, tag_offset, 1, ENC_LITTLE_ENDIAN);

            break;

        case EDONKEY_MTAG_BOOL:

            /* <Tag> ::= <Bool (uint8_t)> */

            tag_length += 1;

            ti = proto_tree_add_item(tree, hf_edonkey_metatag, tvb, offset, tag_length, ENC_NA);

            metatag_tree = proto_item_add_subtree(ti, ett_edonkey_metatag);

            proto_tree_add_uint(metatag_tree, hf_edonkey_metatag_type, tvb, offset, 1, tag_type);

            if (tag_type==real_tag_type)

                proto_tree_add_uint(metatag_tree, hf_edonkey_metatag_namesize, tvb, offset+1, 2, tag_name_size);

            edonkey_tree_add_metatag_name(metatag_tree, tvb, tag_offset-tag_name_size, tag_name_size, special_tagtype);

            proto_tree_add_item(metatag_tree, hf_edonkey_meta_tag_value_uint, tvb, tag_offset, 1, ENC_LITTLE_ENDIAN);

            break;

        case EDONKEY_MTAG_BOOL_ARRAY:

            /* <Tag> ::= <Length (uint16_t)> <BoolArray> */

            array_length = tvb_get_letohs(tvb, tag_offset);

            /*

             * This is allegedly what the protocol uses, rather than the

             * correct value of (array_length+7)/8

             * Therefore an extra unused byte is transmitted if the array

             * is a multiple of 8 longs.

             */

            tag_length += 2+(array_length/8)+1;

            ti = proto_tree_add_item(tree, hf_edonkey_metatag, tvb, offset, tag_length, ENC_NA);

            metatag_tree = proto_item_add_subtree(ti, ett_edonkey_metatag);

            proto_tree_add_uint(metatag_tree, hf_edonkey_metatag_type, tvb, offset, 1, tag_type);

            if (tag_type==real_tag_type)

                proto_tree_add_uint(metatag_tree, hf_edonkey_metatag_namesize, tvb, offset+1, 2, tag_name_size);

            edonkey_tree_add_metatag_name(metatag_tree, tvb, tag_offset-tag_name_size, tag_name_size, special_tagtype);

            proto_tree_add_item(metatag_tree, hf_edonkey_boolean_array_length, tvb, tag_offset, 2, ENC_LITTLE_ENDIAN);

            break;

        case EDONKEY_MTAG_BLOB:

            /* <Tag> ::= <Length (uint32_t)> <BLOB> */

            blob_length = tvb_get_letohl(tvb, tag_offset);

            tag_length += 4+blob_length;

            ti = proto_tree_add_item(tree, hf_edonkey_metatag, tvb, offset, tag_length, ENC_NA);

            metatag_tree = proto_item_add_subtree(ti, ett_edonkey_metatag);

            proto_tree_add_uint(metatag_tree, hf_edonkey_metatag_type, tvb, offset, 1, tag_type);

            if (tag_type==real_tag_type)

                proto_tree_add_uint(metatag_tree, hf_edonkey_metatag_namesize, tvb, offset+1, 2, tag_name_size);

            edonkey_tree_add_metatag_name(metatag_tree, tvb, tag_offset-tag_name_size, tag_name_size, special_tagtype);

            proto_tree_add_item(metatag_tree, hf_edonkey_blob_length, tvb, tag_offset, 2, ENC_LITTLE_ENDIAN);

            break;

        case EDONKEY_MTAG_BSOB:

            /* This is possibly a Binary Small OBject, like a BLOB but with an 8 or 16-bit length field */

            /* That's a complete guess though, so don't handle it yet. */

        case EDONKEY_MTAG_UNKNOWN:

        default:

            if (real_tag_type>=EDONKEY_MTAG_STR1 && real_tag_type<=EDONKEY_MTAG_STR16) {

                /* <Tag> ::= <String> */

                string_length = real_tag_type-EDONKEY_MTAG_STR1+1;

                tag_length += string_length;

                ti = proto_tree_add_item(tree, hf_edonkey_metatag, tvb, offset, tag_length, ENC_NA);

                metatag_tree = proto_item_add_subtree(ti, ett_edonkey_metatag);

                proto_tree_add_uint(metatag_tree, hf_edonkey_metatag_type, tvb, offset, 1, tag_type);

                if (real_tag_type==tag_type)

                    proto_tree_add_uint(metatag_tree, hf_edonkey_metatag_namesize, tvb, offset+1, 2, tag_name_size);

                edonkey_tree_add_metatag_name(metatag_tree, tvb, tag_offset-tag_name_size, tag_name_size, special_tagtype);

                proto_tree_add_item(metatag_tree, hf_edonkey_string, tvb, tag_offset, string_length, ENC_ASCII);

            } else {

                /* Unknown tag type - actual tag length is also unknown */

                ti = proto_tree_add_item(tree, hf_edonkey_metatag, tvb, offset, tag_length, ENC_NA);

                metatag_tree = proto_item_add_subtree(ti, ett_edonkey_metatag);

                proto_tree_add_uint_format(metatag_tree, hf_edonkey_metatag_type, tvb, offset, 1, tag_type, "Unknown Meta Tag Type (0x%02x)", tag_type);

                if (real_tag_type==tag_type)

                    proto_tree_add_uint(metatag_tree, hf_edonkey_metatag_namesize, tvb, offset+1, 2, tag_name_size);

                edonkey_tree_add_metatag_name(metatag_tree, tvb, tag_offset-tag_name_size, tag_name_size, special_tagtype);

            }

            break;

    }

    return offset + tag_length;

}

/* Dissects the eDonkey address */

static int dissect_edonkey_address(tvbuff_t *tvb, packet_info *pinfo _U_,

                                   int offset, proto_tree *tree)

{

    /* <Address> ::= <IP> <Port> */

    /*    uint32_t ip = tvb_get_letohl(tvb, offset);

          proto_tree_add_ipv4(tree, hf_edonkey_ip, tvb, offset, 4, ip); */

    proto_tree_add_item(tree, hf_edonkey_ip, tvb, offset, 4, ENC_BIG_ENDIAN);

    proto_tree_add_item(tree, hf_edonkey_port, tvb, offset+4, 2, ENC_LITTLE_ENDIAN);

    return offset+6;

}

static int dissect_kademlia_udp_port(tvbuff_t *tvb, packet_info *pinfo _U_,

                                 int offset, proto_tree *tree)

{

    proto_tree_add_item(tree, hf_kademlia_udp_port, tvb, offset, 2, ENC_LITTLE_ENDIAN);

    return offset +2;

}

static int dissect_kademlia_tcp_port(tvbuff_t *tvb, packet_info *pinfo _U_,

                                     int offset, proto_tree *tree)

{

    proto_tree_add_item(tree, hf_kademlia_tcp_port, tvb, offset, 2, ENC_LITTLE_ENDIAN);

    return offset +2;

}

static int dissect_kademlia_ip_address(tvbuff_t *tvb, packet_info *pinfo _U_,

                                       int offset, proto_tree *tree)

{

    proto_tree_add_item(tree, hf_kademlia_ip, tvb, offset, 4, ENC_LITTLE_ENDIAN);

    return offset + 4;

}

static int dissect_kademlia_address(tvbuff_t *tvb, packet_info *pinfo,

                                    int offset, proto_tree *tree)

{

    /* <Address> ::= <IP> <Port> <Tcp Port>*/

    offset = dissect_kademlia_ip_address( tvb, pinfo, offset, tree );

    offset = dissect_kademlia_udp_port( tvb, pinfo, offset, tree );

    offset = dissect_kademlia_tcp_port( tvb, pinfo, offset, tree );

    return offset;

}

static int dissect_kademlia_tagname(tvbuff_t *tvb, packet_info *pinfo,

                                    int offset, proto_tree *tree, const char** outputTagName, const char** outputExtendedTagName)

{

    /* <String> ::= <String length (uint16_t)> DATA */

    const char * tagname;

    const char * tag_full_name = NULL;

    uint8_t tagname_value;

    proto_item *ti, *hidden_item;

    uint16_t string_length = tvb_get_letohs(tvb, offset);

    proto_tree_add_uint(tree, hf_kademlia_tag_name_length, tvb, offset, 2, string_length);

    hidden_item = proto_tree_add_uint(tree, hf_edonkey_string_length, tvb, offset, 2, string_length);

    proto_item_set_hidden(hidden_item);

    tagname = tvb_get_string_enc(pinfo->pool, tvb, offset + 2, string_length, ENC_ASCII|ENC_NA);

    tag_full_name = "UnknownTagName";

    if ( tagname && string_length == 1 ) {

        tagname_value = *(const uint8_t*)tagname;

        /* lookup tagname */

        tag_full_name = val_to_str_const( tagname_value, kademlia_tags, tag_full_name );

    }

    ti = proto_tree_add_item(tree, hf_kademlia_tag_name, tvb, offset + 2, string_length, ENC_BIG_ENDIAN);

    proto_item_append_text(ti, " [%s]", tag_full_name);

    if (outputTagName)

        *outputTagName = tagname;

    if (outputExtendedTagName)

        *outputExtendedTagName = tag_full_name;

    return offset+2+string_length;

}

static int dissect_kademlia_string(tvbuff_t *tvb, packet_info *pinfo _U_,

                                    int offset, proto_tree *tree)

{

    /* <String> ::= <String length (uint16_t)> DATA */

    uint16_t string_length = tvb_get_letohs(tvb, offset);

    proto_tree_add_uint(tree, hf_edonkey_string_length, tvb, offset, 2, string_length);

    /* TODO: ASCII or UTF-8? */

    proto_tree_add_item(tree, hf_edonkey_kademlia_string, tvb, offset+2, string_length, ENC_ASCII);

    return offset+2+string_length;

}

/* Dissects the eDonkey address list */

static int dissect_edonkey_address_list(tvbuff_t *tvb, packet_info *pinfo,

                                        int offset,  proto_tree *tree)

{

    /* <Address List> ::= <List Size (uint8_t)> <Address>* */

    return dissect_edonkey_list(tvb, pinfo, offset, tree, 1, "Address", dissect_edonkey_address);

}

/* Dissects the eDonkey hash */

static int dissect_edonkey_hash(tvbuff_t *tvb, packet_info *pinfo _U_,

                                int offset, proto_tree *tree)

{

    /* <hash> ::= HASH (16 word MD4 digest) */

    proto_tree_add_item(tree, hf_edonkey_hash, tvb, offset, 16, ENC_NA);

    return offset+16;

}

/* Dissects the eDonkey file hash */

static int dissect_edonkey_file_hash(tvbuff_t *tvb, packet_info *pinfo _U_,

                                     int offset, proto_tree *tree)

{

    /* <File hash> ::= HASH (16 word MD4 digest) */

    proto_tree_add_item(tree, hf_edonkey_file_hash, tvb, offset, 16, ENC_NA);

    return offset+16;

}

/* Dissects the eMule public key */

static int dissect_edonkey_public_key(tvbuff_t *tvb, packet_info *pinfo _U_,

                                     int offset, proto_tree *tree)

{

    uint8_t length = tvb_get_uint8(tvb, offset);

    proto_tree_add_item(tree, hf_emule_public_key_length, tvb, offset, 1, ENC_NA);

    offset++;

    proto_tree_add_item(tree, hf_emule_public_key, tvb, offset, length, ENC_NA);

    return offset + length;

}

/* Dissects the eMule signature */

static int dissect_edonkey_signature(tvbuff_t *tvb, packet_info *pinfo _U_,

                                     int offset, proto_tree *tree)

{

    uint8_t length = tvb_get_uint8(tvb, offset);

    proto_tree_add_item(tree, hf_emule_signature_length, tvb, offset, 1, ENC_NA);

    offset++;

    proto_tree_add_item(tree, hf_emule_signature, tvb, offset, length, ENC_NA);

    return offset + length;

}

static const char *kademlia_hash(wmem_allocator_t *scope, tvbuff_t *tvb, int offset) {

    uint32_t hash[4];

    int i;

    for (i = 0; i < 4; i++)

        hash[i] = tvb_get_letohl(tvb, offset + i*4);

    return wmem_strdup_printf(scope,

              "%08X%08X%08X%08X", hash[0], hash[1], hash[2], hash[3]);

}

static int dissect_kademlia_hash_hidden(tvbuff_t *tvb, packet_info *pinfo,

                                        int offset, proto_tree *tree) {

    proto_item *hidden_item;

    const char *hash;

    hash = kademlia_hash(pinfo->pool, tvb, offset);

    /* <File hash> ::= HASH (16 word MD4 digest) */

    hidden_item = proto_tree_add_string(tree, hf_kademlia_hash, tvb, offset, 16, hash);