/* packet-socks.c

 * Routines for socks versions 4 &5  packet dissection

 * Copyright 2000, Jeffrey C. Foster <jfoste@woodward.com>

 * Copyright 2008, Jelmer Vernooij <jelmer@samba.org>

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

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

 *

 *

 * The Version 4 decode is based on SOCKS4.protocol and SOCKS4A.protocol.

 * The Version 5 decoder is based upon rfc-1928

 * The Version 5 User/Password authentication is based on rfc-1929.

 *

 * See

 *  http://www.openssh.org/txt/socks4.protocol

 *  http://www.openssh.org/txt/socks4a.protocol

 *

 * for information on SOCKS version 4 and 4a.

 *

 * Revisions:

 *

 * 2003-09-18 JCFoster Fixed problem with socks tunnel in socks tunnel

 *          causing heap overflow because of an infinite loop

 *          where the socks dissect was call over and over.

 *

 *          Also remove some old code marked with __JUNK__

 *

 * 2001-01-08 JCFoster Fixed problem with NULL pointer for hash data.

 *          Now test and exit if hash_info is null.

 */

/* Possible enhancements -

 *

 * Add GSS-API authentication per rfc-1961

 * Add CHAP authentication

 * Decode FLAG bits per

 *  https://tools.ietf.org/html/draft-ietf-aft-socks-pro-v5-04

 * In call_next_dissector, could load the destination address into

 *  pinfo->src or pinfo->dst structure before calling next dissector.

*/

#include "config.h"

#include <epan/packet.h>

#include <epan/exceptions.h>

#include <epan/proto_data.h>

#include "packet-tcp.h"

#include "packet-udp.h"

#include "packet-tls.h"

#include <epan/strutil.h>

#define TCP_PORT_SOCKS 1080

/**************** Socks commands ******************/

#define CONNECT_COMMAND         1

#define BIND_COMMAND            2

#define UDP_ASSOCIATE_COMMAND   3

#define PING_COMMAND            0x80

#define TRACERT_COMMAND         0x81

/********** V5 Authentication methods *************/

#define NO_AUTHENTICATION           0

#define GSS_API_AUTHENTICATION      1

#define USER_NAME_AUTHENTICATION    2

#define CHAP_AUTHENTICATION         3

#define AUTHENTICATION_FAILED       0xff

void proto_register_socks(void);

void proto_reg_handoff_socks(void);

/*********** Header field identifiers *************/

static int proto_socks;

static int ett_socks;

static int ett_socks_auth;

static int ett_socks_name;

static int hf_socks_ver;

static int hf_socks_ip_dst;

static int hf_socks_ip6_dst;

static int hf_gssapi_payload;

static int hf_gssapi_command;

static int hf_gssapi_length;

static int hf_v4a_dns_name;

static int hf_socks_dstport;

static int hf_socks_cmd;

static int hf_socks_results_4;

static int hf_socks_results_5;

static int hf_client_auth_method_count;

static int hf_client_auth_method;

static int hf_socks_reserved;

static int hf_socks_reserved2;

static int hf_client_port;

static int hf_server_accepted_auth_method;

static int hf_server_auth_status;

static int hf_server_remote_host_port;

static int hf_socks_subnegotiation_version;

static int hf_socks_username;

static int hf_socks_password;

static int hf_socks_remote_name;

static int hf_socks_address_type;

static int hf_socks_fragment_number;

static int hf_socks_ping_end_command;

static int hf_socks_ping_results;

static int hf_socks_traceroute_end_command;

static int hf_socks_traceroute_results;

/************* Dissector handles ***********/

static dissector_handle_t socks_handle;

static dissector_handle_t socks_handle_tls;

static dissector_handle_t socks_udp_handle;

/************* State Machine names ***********/

enum ClientState {

    clientNoInit = -1,

    clientStart = 0,

    clientWaitForAuthReply,

    clientV5Command,

    clientUserNameRequest,

    clientGssApiAuthRequest,

    clientDone,

    clientError

};

enum ServerState {

    serverNoInit = -1,

    serverStart = 0,

    serverInitReply,

    serverCommandReply,

    serverUserReply,

    serverGssApiReply,

    serverBindReply,

    serverDone,

    serverError

};

typedef struct {

    int in_socks_dissector_flag;

    enum ClientState client;

    enum ServerState server;

} sock_state_t;

typedef struct {

    conversation_t *proxy_conv;

    enum ClientState clientState;

    enum ServerState serverState;

    int     version;

    int     command;

    int     authentication_method;

    uint32_t server_port;

    uint32_t port;

    uint32_t udp_port;

    uint32_t udp_remote_port;

    address dst_addr;

    uint32_t start_done_frame;

}socks_hash_entry_t;

static const value_string address_type_table[] = {

    {1, "IPv4"},

    {3, "Domain Name"},

    {4, "IPv6"},

    {0, NULL}

};

/* String table for the V4 reply status messages */

static const value_string reply_table_v4[] = {

    {90, "Granted"},

    {91, "Rejected or Failed"},

    {92, "Rejected because SOCKS server cannot connect to identd on the client"},

    {93, "Rejected because the client program and identd report different user-ids"},

    {0, NULL}

};

/* String table for the V5 reply status messages */

static const value_string reply_table_v5[] = {

    {0, "Succeeded"},

    {1, "General SOCKS server failure"},

    {2, "Connection not allowed by ruleset"},

    {3, "Network unreachable"},

    {4, "Host unreachable"},

    {5, "Connection refused"},

    {6, "TTL expired"},

    {7, "Command not supported"},

    {8, "Address type not supported"},

    {0, NULL},

};

static const value_string cmd_strings[] = {

    {CONNECT_COMMAND,       "Connect"},

    {BIND_COMMAND,          "Bind"},

    {UDP_ASSOCIATE_COMMAND, "UdpAssociate"},

    {PING_COMMAND,          "Ping"},

    {TRACERT_COMMAND,       "Traceroute"},

    {0, NULL}

};

static const value_string gssapi_command_table[] = {

    { 1,    "Authentication" },

    { 0xFF, "Failure" },

    { 0, NULL }

};

/************************* Support routines ***************************/

static const char *get_auth_method_name( unsigned Number){

/* return the name of the authentication method */

    if ( Number == 0) return "No authentication";

    if ( Number == 1) return "GSSAPI";

    if ( Number == 2) return "Username/Password";

    if ( Number == 3) return "Chap";

    if (( Number >= 4) && ( Number <= 0x7f))return "IANA assigned";

    if (( Number >= 0x80) && ( Number <= 0xfe)) return "private method";

    if ( Number == 0xff) return "no acceptable method";

    /* shouldn't reach here */

    return "Bad method number (not 0-0xff)";

}

static int display_address(packet_info *pinfo, tvbuff_t *tvb, int offset, proto_tree *tree) {

/* decode and display the v5 address, return offset of next byte */

    int a_type = tvb_get_uint8(tvb, offset);

    proto_tree_add_item( tree, hf_socks_address_type, tvb, offset, 1, ENC_BIG_ENDIAN);

    offset += 1;

    switch (a_type)

    {

    case 1: /* IPv4 address */

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

        offset += 4;

        break;

    case 3: /* domain name address */

        {

        uint8_t len;

        char* str;

        len = tvb_get_uint8(tvb, offset);

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

        proto_tree_add_string(tree, hf_socks_remote_name, tvb, offset, len+1, str);

        offset += (len+1);

        }

        break;

    case 4: /* IPv6 address */

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

        offset += 16;

        break;

    }

    return offset;

}

static int get_address_v5(tvbuff_t *tvb, int offset,

    socks_hash_entry_t *hash_info) {

    /* decode the v5 address and return offset of next byte */

    int     a_type;

    address addr;

    a_type = tvb_get_uint8(tvb, offset);

    offset += 1;

    switch(a_type)

    {

    case 1: /* IPv4 address */

        if ( hash_info) {

            set_address_tvb(&addr, AT_IPv4, 4, tvb, offset);

            copy_address_wmem(wmem_file_scope(), &hash_info->dst_addr, &addr);

        }

        offset += 4;

        break;

    case 4: /* IPv6 address */

        if ( hash_info) {

            set_address_tvb(&addr, AT_IPv6, 16, tvb, offset);

            copy_address_wmem(wmem_file_scope(), &hash_info->dst_addr, &addr);

        }

        offset += 16;

        break;

    case 3: /* domain name address */

        offset += tvb_get_uint8(tvb, offset) + 1;

        break;

    }

    return offset;

}

/********************* V5 UDP Associate handlers ***********************/

static int

socks_udp_dissector(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) {

/* Conversation dissector called from UDP dissector. Decode and display */

/* the socks header, the pass the rest of the data to the udp port  */

/* decode routine to  handle the payload.               */

    int                 offset = 0;

    uint32_t           *ptr;

    socks_hash_entry_t *hash_info;

    conversation_t     *conversation;

    proto_tree         *socks_tree;

    proto_item         *ti;

    conversation = find_conversation_pinfo( pinfo, 0);

    DISSECTOR_ASSERT( conversation);    /* should always find a conversation */

    hash_info = (socks_hash_entry_t *)conversation_get_proto_data(conversation, proto_socks);

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

    col_set_str(pinfo->cinfo, COL_INFO, "Version: 5, UDP Associated packet");

    if ( tree) {

        ti = proto_tree_add_protocol_format( tree, proto_socks, tvb, offset, -1, "Socks" );

        socks_tree = proto_item_add_subtree(ti, ett_socks);

        proto_tree_add_item(socks_tree, hf_socks_reserved2, tvb, offset, 2, ENC_BIG_ENDIAN);

        offset += 2;

        proto_tree_add_item(socks_tree, hf_socks_fragment_number, tvb, offset, 1, ENC_BIG_ENDIAN);

        offset += 1;

        offset = display_address(pinfo, tvb, offset, socks_tree);

        hash_info->udp_remote_port = tvb_get_ntohs(tvb, offset);

        proto_tree_add_uint( socks_tree, hf_socks_dstport, tvb,

            offset, 2, hash_info->udp_remote_port);

        offset += 2;

    }

    else {      /* no tree, skip past the socks header */

        offset += 3;

        offset = get_address_v5( tvb, offset, 0) + 2;

    }

    /* set pi src/dst port and call the udp sub-dissector lookup */

    if ( pinfo->srcport == hash_info->port)

        ptr = &pinfo->destport;

    else

        ptr = &pinfo->srcport;

    *ptr = hash_info->udp_remote_port;

    decode_udp_ports( tvb, offset, pinfo, tree, pinfo->srcport, pinfo->destport, -1);

    *ptr = hash_info->udp_port;

    return tvb_captured_length(tvb);

}

static void

new_udp_conversation( socks_hash_entry_t *hash_info, packet_info *pinfo){

    conversation_t *conversation = conversation_new( pinfo->num, &pinfo->src, &pinfo->dst, CONVERSATION_UDP,

            hash_info->udp_port, hash_info->port, 0);

    DISSECTOR_ASSERT( conversation);

    conversation_add_proto_data(conversation, proto_socks, hash_info);

    conversation_set_dissector(conversation, socks_udp_handle);

}

static void

save_client_state(packet_info *pinfo, enum ClientState state)

{

    sock_state_t* state_info = (sock_state_t *)p_get_proto_data(wmem_file_scope(), pinfo, proto_socks, 0);

    if ((state_info != NULL) && (state_info->client == clientNoInit)) {

        state_info->client = state;

    }

}

static void

save_server_state(packet_info *pinfo, enum ServerState state)

{

    sock_state_t* state_info = (sock_state_t *)p_get_proto_data(wmem_file_scope(), pinfo, proto_socks, 0);

    if ((state_info != NULL) && (state_info->server == serverNoInit)) {

        state_info->server = state;

    }

}

/**************** Protocol Tree Display routines  ******************/

static void

display_socks_v4(tvbuff_t *tvb, int offset, packet_info *pinfo,

    proto_tree *tree, socks_hash_entry_t *hash_info, sock_state_t* state_info) {

/* Display the protocol tree for the V4 version. This routine uses the  */

/* stored frame information to decide what to do with the row.  */

    unsigned char ipaddr[4];

    unsigned      str_len;

    /* Either there is an error, or we're done with the state machine

      (so there's nothing to display) */

    if (state_info == NULL)

        return;

    if (hash_info->server_port == pinfo->destport) {

        /* Client side */

        switch (state_info->client)

        {

        case clientStart:

            proto_tree_add_item( tree, hf_socks_ver, tvb, offset, 1, ENC_BIG_ENDIAN);

            offset += 1;

            proto_tree_add_item( tree, hf_socks_cmd, tvb, offset, 1, ENC_BIG_ENDIAN);

            offset += 1;

            /* Do remote port */

            proto_tree_add_item( tree, hf_socks_dstport, tvb, offset, 2, ENC_BIG_ENDIAN);

            offset += 2;

            /* Do destination address */

            tvb_memcpy(tvb, ipaddr, offset, 4);

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

            offset += 4;

            /* display user name */

            str_len = tvb_strsize(tvb, offset);

            proto_tree_add_item( tree, hf_socks_username, tvb, offset, str_len, ENC_ASCII);

            offset += str_len;

            if ( ipaddr[0] == 0 && ipaddr[1] == 0 &&

                 ipaddr[2] == 0 && ipaddr[3] != 0) {

                /* 0.0.0.x , where x!=0 means v4a support */

                str_len = tvb_strsize(tvb, offset);

                proto_tree_add_item( tree, hf_v4a_dns_name, tvb, offset, str_len, ENC_ASCII);

            }

            break;

        default:

            break;

        }

    } else {

        /* Server side */

        switch (state_info->server)

        {

        case serverStart:

            proto_tree_add_item( tree, hf_socks_ver, tvb, offset, 1, ENC_BIG_ENDIAN);

            offset += 1;

                            /* Do results code */

            proto_tree_add_item( tree, hf_socks_results_4, tvb, offset, 1, ENC_BIG_ENDIAN);

            offset += 1;

                            /* Do remote port */

            proto_tree_add_item( tree, hf_socks_dstport, tvb, offset, 2, ENC_BIG_ENDIAN);

            offset += 2;

                            /* Do remote address */

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

            break;

        default:

            break;

        }

    }

}

static void

// NOLINTNEXTLINE(misc-no-recursion)

client_display_socks_v5(tvbuff_t *tvb, int offset, packet_info *pinfo,

    proto_tree *tree, socks_hash_entry_t *hash_info, sock_state_t* state_info) {

/* Display the protocol tree for the version. This routine uses the */

/* stored conversation information to decide what to do with the row.   */

/* Per packet information would have been better to do this, but we */

/* didn't have that when I wrote this. And I didn't expect this to get  */

/* so messy.                                */

    unsigned int  i;

    const char   *AuthMethodStr;

    sock_state_t  new_state_info;

    proto_item *ti;

    /* Either there is an error, or we're done with the state machine

      (so there's nothing to display) */

    if (state_info == NULL)

        return;

    if (state_info->client == clientStart)

    {

        proto_tree      *AuthTree;

        uint8_t num_auth_methods, auth;

        col_append_str(pinfo->cinfo, COL_INFO, " Connect to server request");

        proto_tree_add_item( tree, hf_socks_ver, tvb, offset, 1, ENC_BIG_ENDIAN);

        offset += 1;

        AuthTree = proto_tree_add_subtree( tree, tvb, offset, -1, ett_socks_auth, &ti, "Client Authentication Methods");

        num_auth_methods = tvb_get_uint8(tvb, offset);

        proto_item_set_len(ti, num_auth_methods+1);

        proto_tree_add_item( AuthTree, hf_client_auth_method_count, tvb, offset, 1, ENC_BIG_ENDIAN);

        offset += 1;

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

            auth = tvb_get_uint8( tvb, offset);

            AuthMethodStr = get_auth_method_name(auth);

            proto_tree_add_uint_format(AuthTree, hf_client_auth_method, tvb, offset, 1, auth,

                                        "Method[%u]: %u (%s)", i, auth, AuthMethodStr);

            offset += 1;

        }

        if ((num_auth_methods == 1) &&

            (tvb_bytes_exist(tvb, offset + 2, 1)) &&

            (tvb_get_uint8(tvb, offset + 2) == 0) &&

            (tvb_reported_length_remaining(tvb, offset + 2 + num_auth_methods) > 0)) {

                new_state_info.client = clientV5Command;

                increment_dissection_depth(pinfo);

                client_display_socks_v5(tvb, offset, pinfo, tree, hash_info, &new_state_info);

                decrement_dissection_depth(pinfo);

        }

    }

    else if (state_info->client == clientV5Command) {

        col_append_fstr(pinfo->cinfo, COL_INFO, " Command Request - %s",

                val_to_str_const(hash_info->command, cmd_strings, "Unknown"));

        proto_tree_add_item( tree, hf_socks_ver, tvb, offset, 1, ENC_BIG_ENDIAN);

        offset += 1;

        proto_tree_add_item( tree, hf_socks_cmd, tvb, offset, 1, ENC_BIG_ENDIAN);

        offset += 1;

        proto_tree_add_item( tree, hf_socks_reserved, tvb, offset, 1, ENC_BIG_ENDIAN);

        offset += 1;

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

        proto_tree_add_item( tree, hf_client_port, tvb, offset, 2, ENC_BIG_ENDIAN);

    }

    else if ((state_info->client == clientWaitForAuthReply) &&

             (state_info->server == serverInitReply)) {

        uint16_t len;

        char* str;

        ti = proto_tree_add_uint( tree, hf_socks_ver, tvb, offset, 0, 5);

        proto_item_set_generated(ti);

        proto_tree_add_item( tree, hf_socks_subnegotiation_version, tvb, offset, 1, ENC_BIG_ENDIAN);

        offset += 1;

        switch(hash_info->authentication_method)

        {

        case NO_AUTHENTICATION:

            break;

        case USER_NAME_AUTHENTICATION:

            col_append_str(pinfo->cinfo, COL_INFO, " User authentication request");

            /* process user name */

            len = tvb_get_uint8(tvb, offset);

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

            proto_tree_add_string(tree, hf_socks_username, tvb, offset, len+1, str);

            offset += (len+1);

            len = tvb_get_uint8(tvb, offset);

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

            proto_tree_add_string(tree, hf_socks_password, tvb, offset, len+1, str);

            /* offset += (len+1); */

            break;

        case GSS_API_AUTHENTICATION:

            col_append_str(pinfo->cinfo, COL_INFO, " GSSAPI authentication request");

            proto_tree_add_item( tree, hf_gssapi_command, tvb, offset, 1, ENC_BIG_ENDIAN);

            proto_tree_add_item( tree, hf_gssapi_length, tvb, offset+1, 2, ENC_BIG_ENDIAN);

            len = tvb_get_ntohs(tvb, offset+1);

            if (len > 0)

                proto_tree_add_item( tree, hf_gssapi_payload, tvb, offset+3, len, ENC_NA);

            break;

        default:

            break;

        }

    }

    else {

        if (hash_info->port != 0)

            col_append_fstr(pinfo->cinfo, COL_INFO, ", Remote Port: %u",

                hash_info->port);

    }

}

static void

server_display_socks_v5(tvbuff_t *tvb, int offset, packet_info *pinfo,

    proto_tree *tree, socks_hash_entry_t *hash_info _U_, sock_state_t* state_info) {

/* Display the protocol tree for the version. This routine uses the */

/* stored conversation information to decide what to do with the row.   */

/* Per packet information would have been better to do this, but we */

/* didn't have that when I wrote this. And I didn't expect this to get  */

/* so messy.                                */

    const char *AuthMethodStr;

    uint8_t     auth, auth_status;

    proto_item *ti;

    /* Either there is an error, or we're done with the state machine

      (so there's nothing to display) */

    if (state_info == NULL)

        return;

    switch(state_info->server)

    {

    case serverStart:

        col_append_str(pinfo->cinfo, COL_INFO, " Connect to server response");

        proto_tree_add_item( tree, hf_socks_ver, tvb, offset, 1, ENC_BIG_ENDIAN);

        offset += 1;

        auth = tvb_get_uint8( tvb, offset);

        AuthMethodStr = get_auth_method_name(auth);

        proto_tree_add_uint_format_value(tree, hf_server_accepted_auth_method, tvb, offset, 1, auth,

                                        "0x%0x (%s)", auth, AuthMethodStr);

        break;

    case serverUserReply:

        col_append_str(pinfo->cinfo, COL_INFO, " User authentication reply");

        ti = proto_tree_add_uint( tree, hf_socks_ver, tvb, offset, 0, 5);

        proto_item_set_generated(ti);

        proto_tree_add_item( tree, hf_socks_subnegotiation_version, tvb, offset, 1, ENC_BIG_ENDIAN);

        offset += 1;

        ti = proto_tree_add_item_ret_uint8(tree, hf_server_auth_status, tvb, offset, 1, ENC_BIG_ENDIAN, &auth_status);

        if(auth_status != 0)

            proto_item_append_text(ti, " (failure)");

        else

            proto_item_append_text(ti, " (success)");

        break;

    case serverGssApiReply:

        col_append_str(pinfo->cinfo, COL_INFO, " GSSAPI authentication reply");

        ti = proto_tree_add_uint( tree, hf_socks_ver, tvb, offset, 0, 5);

        proto_item_set_generated(ti);

        proto_tree_add_item( tree, hf_socks_subnegotiation_version, tvb, offset, 1, ENC_BIG_ENDIAN);

        offset += 1;

        auth_status = tvb_get_uint8(tvb, offset);

        proto_tree_add_item( tree, hf_gssapi_command, tvb, offset, 1, ENC_BIG_ENDIAN);

        if (auth_status != 0xFF) {

            uint16_t len;

            proto_tree_add_item( tree, hf_gssapi_length, tvb, offset+1, 2, ENC_BIG_ENDIAN);

            len = tvb_get_ntohs(tvb, offset+1);

            if (len > 0)

                proto_tree_add_item( tree, hf_gssapi_payload, tvb, offset+3, len, ENC_NA);

        }

        break;

    case serverCommandReply:

        col_append_fstr(pinfo->cinfo, COL_INFO, " Command Response - %s",

                val_to_str_const(hash_info->command, cmd_strings, "Unknown"));

        proto_tree_add_item( tree, hf_socks_ver, tvb, offset, 1, ENC_BIG_ENDIAN);

        offset += 1;

        proto_tree_add_item( tree, hf_socks_results_5, tvb, offset, 1, ENC_BIG_ENDIAN);

        offset += 1;

        proto_tree_add_item( tree, hf_socks_reserved, tvb, offset, 1, ENC_BIG_ENDIAN);

        offset += 1;

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

        proto_tree_add_item( tree, hf_client_port, tvb, offset, 2, ENC_BIG_ENDIAN);

        break;

    case serverBindReply:

        col_append_str(pinfo->cinfo, COL_INFO, " Command Response: Bind remote host info");

        proto_tree_add_item( tree, hf_socks_ver, tvb, offset, 1, ENC_BIG_ENDIAN);

        offset += 1;

        proto_tree_add_item( tree, hf_socks_results_5, tvb, offset, 1, ENC_BIG_ENDIAN);

        offset += 1;

        proto_tree_add_item( tree, hf_socks_reserved, tvb, offset, 1, ENC_BIG_ENDIAN);

        offset += 1;

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

        proto_tree_add_item( tree, hf_server_remote_host_port, tvb, offset, 2, ENC_BIG_ENDIAN);

        break;

    default:

        if ( hash_info->port != 0)

            col_append_fstr(pinfo->cinfo, COL_INFO, ", Remote Port: %u",

                hash_info->port);

        break;

    }

}

/**************** Decoder State Machines ******************/

static void

state_machine_v4( socks_hash_entry_t *hash_info, tvbuff_t *tvb,

    int offset, packet_info *pinfo) {

/* Decode V4 protocol.  This is done on the first pass through the  */

/* list.  Based upon the current state, decode the packet and determine */

/* what the next state should be.  */

    address addr;

    if (hash_info->clientState != clientDone)

        save_client_state(pinfo, hash_info->clientState);

    if (hash_info->serverState != serverDone)

        save_server_state(pinfo, hash_info->serverState);

    if (hash_info->server_port == pinfo->destport) {

        /* Client side, only a single request */

        col_append_str(pinfo->cinfo, COL_INFO, " Connect to server request");

        hash_info->command = tvb_get_uint8(tvb, offset + 1);

        /* get remote port */

        if ( hash_info->command == CONNECT_COMMAND)

            hash_info->port =  tvb_get_ntohs(tvb, offset + 2);

        /* get remote address */

        set_address_tvb(&addr, AT_IPv4, 4, tvb, offset);

        copy_address_wmem(wmem_file_scope(), &hash_info->dst_addr, &addr);

        hash_info->clientState = clientDone;

    }

    else {

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

        if (tvb_get_uint8(tvb, offset + 1) == 90)

            hash_info->serverState = serverDone;

        else

            hash_info->serverState = serverError;

    }

}

static void

// NOLINTNEXTLINE(misc-no-recursion)

client_state_machine_v5( socks_hash_entry_t *hash_info, tvbuff_t *tvb,

    int offset, packet_info *pinfo, bool start_of_frame) {

/* Decode client side of V5 protocol.  This is done on the first pass through the   */

/* list.  Based upon the current state, decode the packet and determine */

/* what the next state should be. */

    if (start_of_frame) {

        save_client_state(pinfo, hash_info->clientState);

        save_server_state(pinfo, hash_info->serverState);

    }

    if (hash_info->clientState == clientStart)

    {

        uint8_t num_auth_methods;

        num_auth_methods = tvb_get_uint8(tvb, offset + 1);

                        /* skip past auth methods */

        if ((num_auth_methods == 0) ||

            ((num_auth_methods == 1) &&

             (tvb_get_uint8(tvb, offset + 2) == 0))) {

            /* No authentication needed */

            hash_info->clientState = clientV5Command;

            if (tvb_reported_length_remaining(tvb, offset + 2 + num_auth_methods) > 0) {

                increment_dissection_depth(pinfo);

                client_state_machine_v5(hash_info, tvb, offset + 2 + num_auth_methods, pinfo, false);

                decrement_dissection_depth(pinfo);

            }

        } else {

            hash_info->clientState = clientWaitForAuthReply;

        }

    } else if ((hash_info->clientState == clientWaitForAuthReply) &&

               (hash_info->serverState == serverInitReply)) {

        switch(hash_info->authentication_method)

        {

        case NO_AUTHENTICATION:

            hash_info->clientState = clientV5Command;

            hash_info->serverState = serverCommandReply;

            break;

        case USER_NAME_AUTHENTICATION:

            hash_info->clientState = clientV5Command;

            hash_info->serverState = serverUserReply;

            break;

        case GSS_API_AUTHENTICATION:

            hash_info->clientState = clientV5Command;

            hash_info->serverState = serverGssApiReply;

            break;

        default:

            hash_info->clientState = clientError;   /*Auth failed or error*/

            break;

        }

    } else if (hash_info->clientState == clientV5Command) {

        hash_info->command = tvb_get_uint8(tvb, offset + 1); /* get command */

        offset += 3;            /* skip to address type */

        offset = get_address_v5(tvb, offset, hash_info);

        /** temp = tvb_get_uint8(tvb, offset);  XX: what was this for ? **/

        if (( hash_info->command == CONNECT_COMMAND) ||

            ( hash_info->command == UDP_ASSOCIATE_COMMAND))

                        /* get remote port  */

            hash_info->port =  tvb_get_ntohs(tvb, offset);

        hash_info->clientState = clientDone;

    }

}

static void

server_state_machine_v5( socks_hash_entry_t *hash_info, tvbuff_t *tvb,

    int offset, packet_info *pinfo, bool start_of_frame) {

/* Decode server side of V5 protocol.  This is done on the first pass through the   */

/* list.  Based upon the current state, decode the packet and determine */

/* what the next state should be. */

    if (start_of_frame)

        save_server_state(pinfo, hash_info->serverState);

    switch (hash_info->serverState) {

    case serverStart:

        hash_info->authentication_method = tvb_get_uint8(tvb, offset + 1);

        switch (hash_info->authentication_method)

        {

        case NO_AUTHENTICATION:

            /* If there is no authentication, client should expect command immediately */

            hash_info->serverState = serverCommandReply;

            hash_info->clientState = clientV5Command;

            break;

        case USER_NAME_AUTHENTICATION:

            hash_info->serverState = serverInitReply;

            break;

        case GSS_API_AUTHENTICATION:

            hash_info->serverState = serverInitReply;

            break;

        default:

            hash_info->serverState = serverError;

            break;

        }

        break;

    case serverUserReply:

        hash_info->serverState = serverCommandReply;

        break;

    case serverGssApiReply:

        if (tvb_get_uint8(tvb, offset+1) == 0xFF) {

            hash_info->serverState = serverError;

        } else {

            if (tvb_get_ntohs(tvb, offset+2) == 0)

                hash_info->serverState = serverCommandReply;

        }

        break;

    case serverCommandReply:

        switch(hash_info->command)

        {

        case CONNECT_COMMAND:

        case PING_COMMAND:

        case TRACERT_COMMAND:

            hash_info->serverState = serverDone;

            break;

        case BIND_COMMAND:

            hash_info->serverState = serverBindReply;

            if ((tvb_get_uint8(tvb, offset + 2) == 0) &&

                (tvb_reported_length_remaining(tvb, offset) > 5)) {

                    offset = display_address(pinfo, tvb, offset, NULL);

                    client_state_machine_v5(hash_info, tvb, offset, pinfo, false);

            }

            break;

        case UDP_ASSOCIATE_COMMAND:

            offset += 3;        /* skip to address type */

            offset = get_address_v5(tvb, offset, hash_info);

            /* save server udp port and create udp conversation */

            hash_info->udp_port =  tvb_get_ntohs(tvb, offset);

            if (!pinfo->fd->visited)

                new_udp_conversation( hash_info, pinfo);

            break;

        }

        break;

    case serverBindReply:

        break;

    default:

        break;

    }

}

static void

display_ping_and_tracert(tvbuff_t *tvb, unsigned offset, packet_info *pinfo, proto_tree *tree, socks_hash_entry_t *hash_info) {

/* Display the ping/trace_route conversation */

    unsigned      linelen;

                /* handle the end command */

    if ( pinfo->destport == pinfo->match_uint){

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

        proto_tree_add_item(tree, (hash_info->command  == PING_COMMAND) ? hf_socks_ping_end_command : hf_socks_traceroute_end_command, tvb, offset, 1, ENC_NA);

    }

    else {      /* display the PING or Traceroute results */

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

        if ( tree){

            proto_tree_add_item(tree, (hash_info->command  == PING_COMMAND) ? hf_socks_ping_results : hf_socks_traceroute_results, tvb, offset, -1, ENC_NA);

            while (tvb_captured_length_remaining(tvb, offset)) {

                unsigned next_offset;

                tvb_find_line_end_remaining(tvb, offset, NULL, &next_offset);

                /* Use the linelen including the line terminator. */

                linelen = next_offset - offset;

                proto_tree_add_format_text( tree, tvb, offset, linelen);

                offset = next_offset;

            }

        }

    }

}

static void clear_in_socks_dissector_flag(void *s)

{

    sock_state_t* state_info = (sock_state_t*)s;

    state_info->in_socks_dissector_flag = 0; /* avoid recursive overflow */

}

static void call_next_dissector(tvbuff_t *tvb, int offset, packet_info *pinfo,

    proto_tree *tree, proto_tree *socks_tree,

    socks_hash_entry_t *hash_info, sock_state_t* state_info, struct tcpinfo *tcpinfo)

{

/* Display the results for PING and TRACERT extensions or       */

/* Call TCP dissector for the port that was passed during the           */

/* connect process                                  */

/* Load pointer to pinfo->XXXport depending upon the direction,     */

/* change pinfo port to the remote port, call next dissector to decode  */

/* the payload, and restore the pinfo port after that is done.      */

    uint32_t *ptr;

    uint16_t save_port;

    uint16_t save_can_desegment;

    struct tcp_analysis *tcpd=NULL;