/*

XXX  Fixme : shouldn't show [malformed frame] for long packets

*/

/* packet-smb-pipe.c

 * Routines for SMB named pipe packet dissection

 * Copyright 1999, Richard Sharpe <rsharpe@ns.aus.com>

 * significant rewrite to tvbuffify the dissector, Ronnie Sahlberg and

 * Guy Harris 2001

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

 * Copied from packet-pop.c

 *

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

 */

#include "config.h"

#include <epan/packet.h>

#include <epan/exceptions.h>

#include <epan/to_str.h>

#include <epan/strutil.h>

#include <epan/expert.h>

#include <epan/reassemble.h>

#include "packet-smb.h"

#include "packet-smb-pipe.h"

#include "packet-smb-browse.h"

#include "packet-smb-common.h"

#include "packet-windows-common.h"

void proto_register_pipe_lanman(void);

void proto_register_smb_pipe(void);

static int proto_smb_pipe;

static int hf_smb_pipe_function;

static int hf_smb_pipe_priority;

static int hf_smb_pipe_peek_available;

static int hf_smb_pipe_peek_remaining;

static int hf_smb_pipe_peek_status;

static int hf_smb_pipe_getinfo_info_level;

static int hf_smb_pipe_getinfo_output_buffer_size;

static int hf_smb_pipe_getinfo_input_buffer_size;

static int hf_smb_pipe_getinfo_maximum_instances;

static int hf_smb_pipe_getinfo_current_instances;

static int hf_smb_pipe_getinfo_pipe_name_length;

static int hf_smb_pipe_getinfo_pipe_name;

static int hf_smb_pipe_write_raw_bytes_written;

static int hf_smb_pipe_fragments;

static int hf_smb_pipe_fragment;

static int hf_smb_pipe_fragment_overlap;

static int hf_smb_pipe_fragment_overlap_conflict;

static int hf_smb_pipe_fragment_multiple_tails;

static int hf_smb_pipe_fragment_too_long_fragment;

static int hf_smb_pipe_fragment_error;

static int hf_smb_pipe_fragment_count;

static int hf_smb_pipe_reassembled_in;

static int hf_smb_pipe_reassembled_length;

static int ett_smb_pipe;

static int ett_smb_pipe_fragment;

static int ett_smb_pipe_fragments;

static const fragment_items smb_pipe_frag_items = {

  &ett_smb_pipe_fragment,

  &ett_smb_pipe_fragments,

  &hf_smb_pipe_fragments,

  &hf_smb_pipe_fragment,

  &hf_smb_pipe_fragment_overlap,

  &hf_smb_pipe_fragment_overlap_conflict,

  &hf_smb_pipe_fragment_multiple_tails,

  &hf_smb_pipe_fragment_too_long_fragment,

  &hf_smb_pipe_fragment_error,

  &hf_smb_pipe_fragment_count,

  NULL,

  &hf_smb_pipe_reassembled_length,

  /* Reassembled data field */

  NULL,

  "fragments"

};

static int proto_smb_lanman;

static int hf_function_code;

static int hf_param_desc;

static int hf_return_desc;

static int hf_aux_data_desc;

static int hf_detail_level;

static int hf_padding;

static int hf_recv_buf_len;

static int hf_send_buf_len;

/* static int hf_continuation_from; */

static int hf_status;

static int hf_convert;

static int hf_param_no_descriptor;

static int hf_data_no_descriptor;

static int hf_data_no_recv_buffer;

static int hf_ecount;

static int hf_acount;

static int hf_share;

static int hf_share_name;

static int hf_share_type;

static int hf_share_comment;

static int hf_share_permissions;

static int hf_share_max_uses;

static int hf_share_current_uses;

static int hf_share_path;

static int hf_share_password;

static int hf_server;

static int hf_server_name;

static int hf_server_major;

static int hf_server_minor;

static int hf_server_comment;

static int hf_abytes;

static int hf_current_time;

static int hf_msecs;

static int hf_hour;

static int hf_minute;

static int hf_second;

static int hf_hundredths;

static int hf_tzoffset;

static int hf_timeinterval;

static int hf_day;

static int hf_month;

static int hf_year;

static int hf_weekday;

static int hf_enumeration_domain;

static int hf_last_entry;

static int hf_computer_name;

static int hf_user_name;

static int hf_group_name;

static int hf_workstation_domain;

static int hf_workstation_major;

static int hf_workstation_minor;

static int hf_logon_domain;

static int hf_other_domains;

static int hf_password;

static int hf_workstation_name;

static int hf_ustruct_size;

static int hf_logon_code;

static int hf_privilege_level;

static int hf_operator_privileges;

static int hf_num_logons;

static int hf_bad_pw_count;

static int hf_last_logon;

static int hf_last_logoff;

static int hf_logoff_time;

static int hf_kickoff_time;

static int hf_password_age;

static int hf_password_can_change;

static int hf_password_must_change;

static int hf_script_path;

static int hf_logoff_code;

static int hf_duration;

static int hf_comment;

static int hf_user_comment;

static int hf_full_name;

static int hf_homedir;

static int hf_parameters;

static int hf_logon_server;

static int hf_country_code;

static int hf_workstations;

static int hf_max_storage;

static int hf_units_per_week;

static int hf_logon_hours;

static int hf_code_page;

static int hf_new_password;

static int hf_old_password;

static int hf_reserved;

static int hf_aux_data_struct_count;

/* Generated from convert_proto_tree_add_text.pl */

static int hf_smb_pipe_stringz_param;

static int hf_smb_pipe_string_param;

static int hf_smb_pipe_bytes_param;

static int hf_smb_pipe_byte_param;

static int hf_smb_pipe_doubleword_param;

static int hf_smb_pipe_word_param;

static int ett_lanman;

static int ett_lanman_unknown_entries;

static int ett_lanman_unknown_entry;

static int ett_lanman_shares;

static int ett_lanman_share;

static int ett_lanman_groups;

static int ett_lanman_servers;

static int ett_lanman_server;

static expert_field ei_smb_pipe_bogus_netwkstauserlogon;

static expert_field ei_smb_pipe_bad_type;

/*

 * See

 *

 *  ftp://ftp.microsoft.com/developr/drg/CIFS/cifsrap2.txt

 *

 * among other documents.

 */

static const value_string status_vals[] = {

  {   0,  "Success"},

  {   5,  "User has insufficient privilege"},

  {  65,  "Network access is denied"},

  {  86,  "The specified password is invalid"},

  {SMBE_DOS_moredata, "Additional data is available"},

  {2114,  "Service is not running on the remote computer"},

  {2123,  "Supplied buffer is too small"},

  {2141,  "Server is not configured for transactions (IPC$ not shared)"},

  {2212,  "An error occurred while loading or running the logon script"},

  {2214,  "The logon was not validated by any server"},

  {2217,  "The logon server is running an older software version"},

  {2221,  "The user name was not found"},

  {2226,  "Operation not permitted on Backup Domain Controller"},

  {2240,  "The user is not allowed to logon from this computer"},

  {2241,  "The user is not allowed to logon at this time"},

  {2242,  "The user password has expired"},

  {2243,  "The password cannot be changed"},

  {2246,  "The password is too short"},

  {0,     NULL}

};

static const value_string privilege_vals[] = {

  {0, "Guest"},

  {1, "User"},

  {2, "Administrator"},

  {0, NULL}

};

static const value_string op_privilege_vals[] = {

  {0, "Print operator"},

  {1, "Communications operator"},

  {2, "Server operator"},

  {3, "Accounts operator"},

  {0, NULL}

};

static const value_string weekday_vals[] = {

  {0, "Sunday"},

  {1, "Monday"},

  {2, "Tuesday"},

  {3, "Wednesday"},

  {4, "Thursday"},

  {5, "Friday"},

  {6, "Saturday"},

  {0, NULL}

};

static int

add_word_param(tvbuff_t *tvb, int offset, int count _U_,

    packet_info *pinfo _U_, proto_tree *tree, int convert _U_, int hf_index, smb_info_t *smb_info _U_)

{

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

  offset += 2;

  return offset;

}

static int

add_dword_param(tvbuff_t *tvb, int offset, int count _U_,

    packet_info *pinfo _U_, proto_tree *tree, int convert _U_, int hf_index, smb_info_t *smb_info _U_)

{

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

  offset += 4;

  return offset;

}

static int

add_bytes_param(tvbuff_t *tvb, int offset, int count, packet_info *pinfo _U_,

    proto_tree *tree, int convert _U_, int hf_index, smb_info_t *smb_info _U_)

{

  header_field_info *hfinfo;

  if (hf_index > 0) {

    hfinfo = proto_registrar_get_nth(hf_index);

    if ((hfinfo == NULL) ||

        ((hfinfo->type == FT_INT8 || hfinfo->type == FT_UINT8)

        && (count != 1))) {

      THROW(ReportedBoundsError);

    }

    switch (hfinfo->type) {

    case FT_INT8:

    case FT_UINT8:

      proto_tree_add_item(tree, hf_index, tvb, offset, count,

          ENC_LITTLE_ENDIAN);

      break;

    case FT_STRING:

      proto_tree_add_item(tree, hf_index, tvb, offset, count,

          ENC_ASCII|ENC_NA);  /* XXX - code page? */

      break;

    default:

      proto_tree_add_item(tree, hf_index, tvb, offset, count,

          ENC_NA);

      break;

    }

  } else {

    if (count == 1) {

      proto_tree_add_item(tree, hf_smb_pipe_byte_param, tvb, offset, count, ENC_LITTLE_ENDIAN);

    } else {

      proto_tree_add_item(tree, hf_smb_pipe_bytes_param, tvb, offset, count, ENC_NA);

    }

  }

  offset += count;

  return offset;

}

static int

add_string_param_update_parent(tvbuff_t *tvb, int offset, int count, packet_info *pinfo _U_,

    proto_tree *tree, int convert _U_, int hf_index, smb_info_t *smb_info _U_)

{

  proto_item *ti, *parent_ti;

  const uint8_t *str;

  DISSECTOR_ASSERT(hf_index > 0);

  ti = proto_tree_add_item_ret_string(tree, hf_index, tvb, offset,

      count, ENC_ASCII|ENC_NA, pinfo->pool, &str);

      /* XXX - code page? */

  parent_ti = proto_item_get_parent(ti);

  proto_item_append_text(parent_ti, ": %s",

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

  offset += count;

  return offset;

}

static int

add_pad_param(tvbuff_t *tvb _U_, int offset, int count, packet_info *pinfo _U_,

    proto_tree *tree _U_, int convert _U_, int hf_index _U_, smb_info_t *smb_info _U_)

{

  /*

   * This is for parameters that have descriptor entries but that

   * are, in practice, just padding.

   */

  offset += count;

  return offset;

}

static void

add_null_pointer_param(tvbuff_t *tvb, int offset, int count _U_,

    packet_info *pinfo _U_, proto_tree *tree, int convert _U_, int hf_index, smb_info_t *smb_info _U_)

{

  if (hf_index > 0) {

    proto_tree_add_string_format_value(tree, hf_index, tvb, offset, 0, "", "(Null pointer)");

  } else {

    proto_tree_add_string_format_value(tree, hf_smb_pipe_string_param, tvb, offset, 0, "", "(Null pointer)");

  }

}

static int

add_string_param(tvbuff_t *tvb, int offset, int count _U_,

    packet_info *pinfo _U_, proto_tree *tree, int convert _U_, int hf_index, smb_info_t *smb_info _U_)

{

  unsigned string_len;

  string_len = tvb_strsize(tvb, offset);

  if (hf_index > 0) {

    proto_tree_add_item(tree, hf_index, tvb, offset, string_len,

        ENC_ASCII|ENC_NA);  /* XXX - code page? */

  } else {

    proto_tree_add_item(tree, hf_smb_pipe_string_param, tvb, offset, string_len, ENC_NA|ENC_ASCII);

  }

  offset += string_len;

  return offset;

}

static const char *

get_stringz_pointer_value(wmem_allocator_t *scope, tvbuff_t *tvb, int offset, int convert, int *cptrp,

    int *lenp)

{

  int cptr;

  int string_len;

  /* pointer to string */

  cptr = (tvb_get_letohl(tvb, offset)&0xffff)-convert;

  *cptrp = cptr;

  /* string */

  if (tvb_offset_exists(tvb, cptr) &&

      (string_len = tvb_strnlen(tvb, cptr, -1)) != -1) {

        string_len++; /* include the terminating '\0' */

      *lenp = string_len;

      return tvb_format_text(scope, tvb, cptr, string_len - 1);

  } else

    return NULL;

}

static int

add_stringz_pointer_param(tvbuff_t *tvb, int offset, int count _U_,

    packet_info *pinfo, proto_tree *tree, int convert, int hf_index, smb_info_t *smb_info _U_)

{

  int cptr;

  const char *string;

  int string_len;

  string = get_stringz_pointer_value(pinfo->pool, tvb, offset, convert, &cptr,

      &string_len);

  offset += 4;

  /* string */

  if (string != NULL) {

    if (hf_index > 0) {

      proto_tree_add_item(tree, hf_index, tvb, cptr,

          string_len, ENC_ASCII|ENC_NA);  /* XXX - code page? */

    } else {

      proto_tree_add_item(tree, hf_smb_pipe_stringz_param, tvb, cptr, string_len, ENC_NA|ENC_ASCII);

    }

  } else {

    if (hf_index > 0) {

      proto_tree_add_string(tree, hf_index, tvb, 0, 0,

          "<String goes past end of frame>");

    } else {

      proto_tree_add_string(tree, hf_smb_pipe_stringz_param, tvb, 0, 0,

          "<String goes past end of frame>");

    }

  }

  return offset;

}

static int

add_bytes_pointer_param(tvbuff_t *tvb, int offset, int count,

    packet_info *pinfo _U_, proto_tree *tree, int convert, int hf_index, smb_info_t *smb_info _U_)

{

  int cptr;

  /* pointer to byte array */

  cptr = (tvb_get_letohl(tvb, offset)&0xffff)-convert;

  offset += 4;

  /* bytes */

  if (tvb_bytes_exist(tvb, cptr, count)) {

    if (hf_index > 0) {

      proto_tree_add_item(tree, hf_index, tvb, cptr,

          count, ENC_NA);

    } else {

      proto_tree_add_item(tree, hf_smb_pipe_bytes_param, tvb, cptr, count, ENC_NA);

    }

  } else {

    if (hf_index > 0) {

      proto_tree_add_bytes_format_value(tree, hf_index, tvb, 0, 0,

          NULL, "<Bytes go past end of frame>");

    } else {

      proto_tree_add_bytes_format_value(tree, hf_smb_pipe_bytes_param, tvb, 0, 0,

          NULL, "<Bytes go past end of frame>");

    }

  }

  return offset;

}

static int

add_detail_level(tvbuff_t *tvb, int offset, int count _U_, packet_info *pinfo,

    proto_tree *tree, int convert _U_, int hf_index, smb_info_t *smb_info)

{

  smb_transact_info_t *trp = NULL;

  uint16_t level;

  if (smb_info->sip->extra_info_type == SMB_EI_TRI)

    trp = (smb_transact_info_t *)smb_info->sip->extra_info;

  level = tvb_get_letohs(tvb, offset);

  if (!pinfo->fd->visited)

    if (trp)

      trp->info_level = level; /* remember this for the response */

  proto_tree_add_uint(tree, hf_index, tvb, offset, 2, level);

  offset += 2;

  return offset;

}

static int

add_max_uses(tvbuff_t *tvb, int offset, int count _U_, packet_info *pinfo _U_,

    proto_tree *tree, int convert _U_, int hf_index, smb_info_t *smb_info _U_)

{

  uint16_t WParam;

  WParam = tvb_get_letohs(tvb, offset);

  if (WParam == 0xffff) { /* -1 */

    proto_tree_add_uint_format_value(tree, hf_index, tvb,

        offset, 2, WParam,

        "No limit");

  } else {

    proto_tree_add_uint(tree, hf_index, tvb,

          offset, 2, WParam);

  }

  offset += 2;

  return offset;

}

static int

add_server_type(tvbuff_t *tvb, int offset, int count _U_,

    packet_info *pinfo, proto_tree *tree, int convert _U_, int hf_index _U_, smb_info_t *smb_info _U_)

{

  offset = dissect_smb_server_type_flags(

    tvb, offset, pinfo, tree, NULL, false);

  return offset;

}

static int

add_server_type_info(tvbuff_t *tvb, int offset, int count _U_,

    packet_info *pinfo, proto_tree *tree, int convert _U_, int hf_index _U_, smb_info_t *smb_info _U_)

{

  offset = dissect_smb_server_type_flags(

    tvb, offset, pinfo, tree, NULL, true);

  return offset;

}

static int

add_reltime(tvbuff_t *tvb, int offset, int count _U_, packet_info *pinfo _U_,

    proto_tree *tree, int convert _U_, int hf_index, smb_info_t *smb_info _U_)

{

  nstime_t nstime;

  nstime.secs = tvb_get_letohl(tvb, offset);

  nstime.nsecs = 0;

  proto_tree_add_time_format_value(tree, hf_index, tvb, offset, 4,

      &nstime, "%s",

      signed_time_secs_to_str(pinfo->pool,  (int32_t) nstime.secs));

  offset += 4;

  return offset;

}

/*

 * Sigh.  These are for handling Microsoft's annoying almost-UNIX-time-but-

 * it's-local-time-not-UTC time.

 */

static int

add_abstime_common(tvbuff_t *tvb, int offset, proto_tree *tree, int hf_index,

    const char *absent_name)

{

  nstime_t nstime;

  struct tm *tmp;

  nstime.secs = tvb_get_letohl(tvb, offset);

  nstime.nsecs = 0;

  /*

   * Sigh.  Sometimes it appears that -1 means "unknown", and

   * sometimes it appears that 0 means "unknown", for the last

   * logoff date/time.

   */

  if (nstime.secs == -1 || nstime.secs == 0) {

    proto_tree_add_time_format_value(tree, hf_index, tvb, offset, 4,

        &nstime, "%s",

        absent_name);

  } else {

    /*

     * Run it through "gmtime()" to break it down, and then

     * run it through "mktime()" to put it back together

     * as UTC.

     */

    tmp = gmtime(&nstime.secs);

    if (tmp == NULL) {

      /*

       * Can't be represented.

       */

      proto_tree_add_time_format_value(tree, hf_index, tvb,

          offset, 4, &nstime, "Not representable");

    } else {

      tmp->tm_isdst = -1; /* we don't know if it's DST or not */

      nstime.secs = mktime(tmp);

      proto_tree_add_time(tree, hf_index, tvb, offset, 4,

          &nstime);

    }

  }

  offset += 4;

  return offset;

}

static int

add_abstime_absent_never(tvbuff_t *tvb, int offset, int count _U_,

    packet_info *pinfo _U_, proto_tree *tree, int convert _U_, int hf_index, smb_info_t *smb_info _U_)

{

  return add_abstime_common(tvb, offset, tree, hf_index, "Never");

}

static int

add_abstime_absent_unknown(tvbuff_t *tvb, int offset, int count _U_,

    packet_info *pinfo _U_, proto_tree *tree, int convert _U_, int hf_index, smb_info_t *smb_info _U_)

{

  return add_abstime_common(tvb, offset, tree, hf_index, "Unknown");

}

static int

add_nlogons(tvbuff_t *tvb, int offset, int count _U_, packet_info *pinfo _U_,

    proto_tree *tree, int convert _U_, int hf_index, smb_info_t *smb_info _U_)

{

  uint16_t nlogons;

  nlogons = tvb_get_letohs(tvb, offset);

  if (nlogons == 0xffff) /* -1 */

    proto_tree_add_uint_format_value(tree, hf_index, tvb, offset, 2,

        nlogons, "Unknown");

  else

    proto_tree_add_uint(tree, hf_index, tvb, offset, 2, nlogons);

  offset += 2;

  return offset;

}

static int

add_max_storage(tvbuff_t *tvb, int offset, int count _U_,

    packet_info *pinfo _U_, proto_tree *tree, int convert _U_, int hf_index, smb_info_t *smb_info _U_)

{

  uint32_t max_storage;

  max_storage = tvb_get_letohl(tvb, offset);

  if (max_storage == 0xffffffff)

    proto_tree_add_uint_format(tree, hf_index, tvb, offset, 4,

        max_storage, "No limit");

  else

    proto_tree_add_uint(tree, hf_index, tvb, offset, 4, max_storage);

  offset += 4;

  return offset;

}

static int

add_logon_hours(tvbuff_t *tvb, int offset, int count, packet_info *pinfo _U_,

    proto_tree *tree, int convert, int hf_index, smb_info_t *smb_info _U_)

{

  int cptr;

  /* pointer to byte array */

  cptr = (tvb_get_letohl(tvb, offset)&0xffff)-convert;

  offset += 4;

  /* bytes */

  if (tvb_bytes_exist(tvb, cptr, count)) {

    if (count == 21) {

      /*

       * The logon hours should be exactly 21 bytes long.

       *

       * XXX - should actually carve up the bits;

       * we need the units per week to do that, though.

       */

      proto_tree_add_item(tree, hf_index, tvb, cptr, count,

          ENC_NA);

    } else {

      proto_tree_add_bytes_format_value(tree, hf_index, tvb,

          cptr, count, NULL,

          "%s (wrong length, should be 21, is %d",

          tvb_bytes_to_str(pinfo->pool, tvb, cptr, count), count);

    }

  } else {

    proto_tree_add_bytes_format_value(tree, hf_index, tvb, 0, 0,

          NULL, "<Bytes go past end of frame>");

  }

  return offset;

}

static int

add_tzoffset(tvbuff_t *tvb, int offset, int count _U_, packet_info *pinfo _U_,

    proto_tree *tree, int convert _U_, int hf_index _U_, smb_info_t *smb_info _U_)

{

  int16_t tzoffset;

  tzoffset = tvb_get_letohs(tvb, offset);

  if (tzoffset < 0) {

    proto_tree_add_int_format_value(tree, hf_tzoffset, tvb, offset, 2,

        tzoffset, "%s east of UTC",

        signed_time_secs_to_str(pinfo->pool, -tzoffset*60));

  } else if (tzoffset > 0) {

    proto_tree_add_int_format_value(tree, hf_tzoffset, tvb, offset, 2,

        tzoffset, "%s west of UTC",

        signed_time_secs_to_str(pinfo->pool, tzoffset*60));

  } else {

    proto_tree_add_int_format_value(tree, hf_tzoffset, tvb, offset, 2,

        tzoffset, "at UTC");

  }

  offset += 2;

  return offset;

}

static int

add_timeinterval(tvbuff_t *tvb, int offset, int count _U_,

    packet_info *pinfo _U_, proto_tree *tree, int convert _U_, int hf_index _U_, smb_info_t *smb_info _U_)

{

  uint16_t timeinterval;

  timeinterval = tvb_get_letohs(tvb, offset);

  proto_tree_add_uint_format_value(tree, hf_timeinterval, tvb, offset, 2,

     timeinterval, "%f seconds", timeinterval*.0001);

  offset += 2;

  return offset;

}

static int

add_logon_args(tvbuff_t *tvb, int offset, int count, packet_info *pinfo _U_,

    proto_tree *tree, int convert _U_, int hf_index _U_, smb_info_t *smb_info _U_)

{

  if (count != 54) {

    proto_tree_add_expert_format(tree, pinfo, &ei_smb_pipe_bogus_netwkstauserlogon, tvb, offset, count, "Bogus NetWkstaUserLogon parameters: length is %d, should be 54", count);

    offset += count;

    return offset;

  }

  /* user name */

  proto_tree_add_item(tree, hf_user_name, tvb, offset, 21, ENC_ASCII);

  offset += 21;

  /* pad1 */

  offset += 1;

  /* password */

  proto_tree_add_item(tree, hf_password, tvb, offset, 15, ENC_ASCII);

  offset += 15;

  /* pad2 */

  offset += 1;

  /* workstation name */

  proto_tree_add_item(tree, hf_workstation_name, tvb, offset, 16, ENC_ASCII);

  offset += 16;

  return offset;

}

/*

 * The following data structure describes the Remote API requests we

 * understand.

 *

 * Simply fill in the number and parameter information.

 * Try to keep them in order.

 *

 * We will extend this data structure as we try to decode more.

 */

/*

 * This is a pointer to a function to process an item.

 */

typedef int (*item_func)(tvbuff_t *, int, int, packet_info *, proto_tree *,

           int, int, smb_info_t*);

/*

 * Type of an item; determines what parameter strings are valid for

 * the item.

 */

typedef enum {

  PARAM_NONE, /* for the end-of-list stopper */

  PARAM_WORD, /* 'W' or 'h' - 16-bit word */

  PARAM_DWORD,  /* 'D' or 'i' - 32-bit word */

  PARAM_BYTES,  /* 'B' or 'b' or 'g' or 'O' - one or more bytes */

  PARAM_STRINGZ /* 'z' or 'O' - null-terminated string */

} param_type_t;

/*

 * This structure describes an item; "hf_index" points to the index

 * for the field corresponding to that item, "func" points to the

 * function to use to add that item to the tree, and "type" is the

 * type that the item is supposed to have.

 */

typedef struct {

  int   *hf_index;

  item_func func;

  param_type_t  type;

} item_t;

/*

 * This structure describes a list of items; each list of items

 * has a corresponding detail level.

 */

typedef struct {

  int   level;

  const item_t  *item_list;

} item_list_t;

struct lanman_desc {

  int   lanman_num;

  const item_t  *req;

  proto_item  *(*req_data_item)(tvbuff_t *, packet_info *,

            proto_tree *, int);

  int   *ett_req_data;

  const item_t  *req_data;

  const item_t  *req_aux_data;

  const item_t  *resp;

  const char  *resp_data_entry_list_label;

  int   *ett_data_entry_list;

  proto_item  *(*resp_data_element_item)(tvbuff_t *, proto_tree *,

               int);

  int   *ett_resp_data_element_item;

  const item_list_t *resp_data_list;

  const item_t  *resp_aux_data;

};

static int no_hf = -1;  /* for padding crap */

static const item_t lm_params_req_netshareenum[] = {

  { &hf_detail_level, add_detail_level, PARAM_WORD },

  { &hf_recv_buf_len, add_word_param, PARAM_WORD },

  { NULL, NULL, PARAM_NONE }

};

static const item_t lm_params_resp_netshareenum[] = {

  { &hf_acount, add_word_param, PARAM_WORD },

  { NULL, NULL, PARAM_NONE }

};

/*

 * Create a subtree for a share.

 */

static proto_item *

netshareenum_share_entry(tvbuff_t *tvb, proto_tree *tree, int offset)

{

  return proto_tree_add_item(tree, hf_share, tvb, offset, -1, ENC_NA);

}

static const item_t lm_null[] = {

  { NULL, NULL, PARAM_NONE }

};

static const item_list_t lm_null_list[] = {

  { -1, lm_null }

};

static const item_t lm_data_resp_netshareenum_1[] = {

  { &hf_share_name, add_string_param_update_parent, PARAM_BYTES },

  { &no_hf, add_pad_param, PARAM_BYTES },

  { &hf_share_type, add_word_param, PARAM_WORD },

  { &hf_share_comment, add_stringz_pointer_param, PARAM_STRINGZ },

  { NULL, NULL, PARAM_NONE }

};

static const item_list_t lm_data_resp_netshareenum[] = {

  { 1, lm_data_resp_netshareenum_1 },

  { -1, lm_null }

};

static const item_t lm_params_req_netsharegetinfo[] = {

  { &hf_share_name, add_string_param, PARAM_STRINGZ },

  { &hf_detail_level, add_detail_level, PARAM_WORD },

  { NULL, NULL, PARAM_NONE }

};

static const item_t lm_params_resp_netsharegetinfo[] = {

  { &hf_abytes, add_word_param, PARAM_WORD },

  { NULL, NULL, PARAM_NONE }

};

static const item_t lm_data_resp_netsharegetinfo_0[] = {

  { &hf_share_name, add_bytes_param, PARAM_BYTES },

  { NULL, NULL, PARAM_NONE }

};

static const item_t lm_data_resp_netsharegetinfo_1[] = {

  { &hf_share_name, add_bytes_param, PARAM_BYTES },

  { &no_hf, add_pad_param, PARAM_BYTES },

  { &hf_share_type, add_word_param, PARAM_WORD },

  { &hf_share_comment, add_stringz_pointer_param, PARAM_STRINGZ },

  { NULL, NULL, PARAM_NONE }

};

static const item_t lm_data_resp_netsharegetinfo_2[] = {

  { &hf_share_name, add_bytes_param, PARAM_BYTES },

  { &no_hf, add_pad_param, PARAM_BYTES },

  { &hf_share_type, add_word_param, PARAM_WORD },

  { &hf_share_comment, add_stringz_pointer_param, PARAM_STRINGZ },

  { &hf_share_permissions, add_word_param, PARAM_WORD }, /* XXX - do as bit fields */

  { &hf_share_max_uses, add_max_uses, PARAM_WORD },

  { &hf_share_current_uses, add_word_param, PARAM_WORD },

  { &hf_share_path, add_stringz_pointer_param, PARAM_STRINGZ },

  { &hf_share_password, add_bytes_param, PARAM_BYTES },

  { NULL, NULL, PARAM_NONE }

};

static const item_list_t lm_data_resp_netsharegetinfo[] = {

  { 0, lm_data_resp_netsharegetinfo_0 },

  { 1, lm_data_resp_netsharegetinfo_1 },

  { 2, lm_data_resp_netsharegetinfo_2 },

  { -1, lm_null }

};

static const item_t lm_params_req_netservergetinfo[] = {

  { &hf_detail_level, add_detail_level, PARAM_WORD },

  { NULL, NULL, PARAM_NONE }

};

static const item_t lm_params_resp_netservergetinfo[] = {

  { &hf_abytes, add_word_param, PARAM_WORD },

  { NULL, NULL, PARAM_NONE }

};

static const item_t lm_data_serverinfo_0[] = {

  { &hf_server_name, add_string_param_update_parent, PARAM_BYTES },

  { NULL, NULL, PARAM_NONE }

};

static const item_t lm_data_serverinfo_1[] = {

  { &hf_server_name, add_string_param_update_parent, PARAM_BYTES },

  { &hf_server_major, add_bytes_param, PARAM_BYTES },

  { &hf_server_minor, add_bytes_param, PARAM_BYTES },

  { &no_hf, add_server_type, PARAM_DWORD },

  { &hf_server_comment, add_stringz_pointer_param, PARAM_STRINGZ },

  { NULL, NULL, PARAM_NONE }

};

static const item_list_t lm_data_serverinfo[] = {

  { 0, lm_data_serverinfo_0 },

  { 1, lm_data_serverinfo_1 },

  { -1, lm_null }

};

static const item_t lm_params_req_netusergetinfo[] = {

  { &hf_user_name, add_string_param, PARAM_STRINGZ },

  { &hf_detail_level, add_detail_level, PARAM_WORD },

  { NULL, NULL, PARAM_NONE }

};

static const item_t lm_params_resp_netusergetinfo[] = {

  { &hf_abytes, add_word_param, PARAM_WORD },

  { NULL, NULL, PARAM_NONE }

};

static const item_t lm_data_resp_netusergetinfo_11[] = {

  { &hf_user_name, add_bytes_param, PARAM_BYTES },

  { &no_hf, add_pad_param, PARAM_BYTES },

  { &hf_comment, add_stringz_pointer_param, PARAM_STRINGZ },

  { &hf_user_comment, add_stringz_pointer_param, PARAM_STRINGZ },

  { &hf_full_name, add_stringz_pointer_param, PARAM_STRINGZ },

  { &hf_privilege_level, add_word_param, PARAM_WORD },

  { &hf_operator_privileges, add_dword_param, PARAM_DWORD },

  { &hf_password_age, add_reltime, PARAM_DWORD },

  { &hf_homedir, add_stringz_pointer_param, PARAM_STRINGZ },

  { &hf_parameters, add_stringz_pointer_param, PARAM_STRINGZ },

  { &hf_last_logon, add_abstime_absent_unknown, PARAM_DWORD },

  { &hf_last_logoff, add_abstime_absent_unknown, PARAM_DWORD },

  { &hf_bad_pw_count, add_word_param, PARAM_WORD },

  { &hf_num_logons, add_nlogons, PARAM_WORD },

  { &hf_logon_server, add_stringz_pointer_param, PARAM_STRINGZ },

  { &hf_country_code, add_word_param, PARAM_WORD },

  { &hf_workstations, add_stringz_pointer_param, PARAM_STRINGZ },

  { &hf_max_storage, add_max_storage, PARAM_DWORD },

  { &hf_units_per_week, add_word_param, PARAM_WORD },

  { &hf_logon_hours, add_logon_hours, PARAM_BYTES },

  { &hf_code_page, add_word_param, PARAM_WORD },

  { NULL, NULL, PARAM_NONE }

};

static const item_list_t lm_data_resp_netusergetinfo[] = {

  { 11, lm_data_resp_netusergetinfo_11 },

  { -1, lm_null }

};

static const item_t lm_params_req_netusergetgroups[] = {

  { &hf_user_name, add_string_param, PARAM_STRINGZ },

  { &hf_detail_level, add_detail_level, PARAM_WORD },

  { NULL, NULL, PARAM_NONE }

};

static const item_t lm_params_resp_netusergetgroups[] = {

  { &hf_abytes, add_word_param, PARAM_WORD },

  { NULL, NULL, PARAM_NONE }

};

static const item_t lm_data_resp_netusergetgroups_0[] = {

  { &hf_group_name, add_bytes_param, PARAM_BYTES },

  { NULL, NULL, PARAM_NONE }

};

static const item_list_t lm_data_resp_netusergetgroups[] = {

  { 0, lm_data_resp_netusergetgroups_0 },

  { -1, lm_null }

};

/*

 * Has no detail level; make it the default.

 */

static const item_t lm_data_resp_netremotetod_nolevel[] = {

  { &hf_current_time, add_abstime_absent_unknown, PARAM_DWORD },

  { &hf_msecs, add_dword_param, PARAM_DWORD },

  { &hf_hour, add_bytes_param, PARAM_BYTES },

  { &hf_minute, add_bytes_param, PARAM_BYTES },

  { &hf_second, add_bytes_param, PARAM_BYTES },

  { &hf_hundredths, add_bytes_param, PARAM_BYTES },

  { &hf_tzoffset, add_tzoffset, PARAM_WORD },

  { &hf_timeinterval, add_timeinterval, PARAM_WORD },

  { &hf_day, add_bytes_param, PARAM_BYTES },

  { &hf_month, add_bytes_param, PARAM_BYTES },

  { &hf_year, add_word_param, PARAM_WORD },

  { &hf_weekday, add_bytes_param, PARAM_BYTES },

  { NULL, NULL, PARAM_NONE }

};

static const item_list_t lm_data_resp_netremotetod[] = {

  { -1, lm_data_resp_netremotetod_nolevel },

};

static const item_t lm_params_req_netserverenum2[] = {

  { &hf_detail_level, add_detail_level, PARAM_WORD },

  { &no_hf, add_server_type_info, PARAM_DWORD },

  { &hf_enumeration_domain, add_string_param, PARAM_STRINGZ },

  { NULL, NULL, PARAM_NONE }

};

/*

 * Create a subtree for a server.

 */

static proto_item *

netserverenum2_server_entry(tvbuff_t *tvb, proto_tree *tree, int offset)

{

  return proto_tree_add_item(tree, hf_server, tvb, offset, -1, ENC_NA);

}

static const item_t lm_params_resp_netserverenum2[] = {

  { &hf_acount, add_word_param, PARAM_WORD },

  { NULL, NULL, PARAM_NONE }

};

static const item_t lm_params_req_netserverenum3[] = {

  { &hf_detail_level, add_detail_level, PARAM_WORD },

  { &no_hf, add_server_type_info, PARAM_DWORD },

  { &hf_enumeration_domain, add_string_param, PARAM_STRINGZ },

  { &hf_last_entry, add_string_param, PARAM_STRINGZ },

  { NULL, NULL, PARAM_NONE }

};

static const item_t lm_params_req_netwkstagetinfo[] = {

  { &hf_detail_level, add_detail_level, PARAM_WORD },

  { NULL, NULL, PARAM_NONE }

};