/* packet-xdmcp.c

 * Routines for XDMCP message dissection

 * Copyright 2002, Pasi Eronen <pasi.eronen@nixu.com>

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

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

 */

#include "config.h"

#include <epan/packet.h>

#include <epan/to_str.h>

#include <epan/expert.h>

#define UDP_PORT_XDMCP 177

#define XDMCP_PROTOCOL_VERSION 1

#define XDMCP_BROADCAST_QUERY 1

#define XDMCP_QUERY 2

#define XDMCP_INDIRECT_QUERY 3

#define XDMCP_FORWARD_QUERY 4

#define XDMCP_WILLING 5

#define XDMCP_UNWILLING 6

#define XDMCP_REQUEST 7

#define XDMCP_ACCEPT 8

#define XDMCP_DECLINE 9

#define XDMCP_MANAGE 10

#define XDMCP_REFUSE 11

#define XDMCP_FAILED 12

#define XDMCP_KEEPALIVE 13

#define XDMCP_ALIVE 14

void proto_register_xdmcp(void);

void proto_reg_handoff_xdmcp(void);

static dissector_handle_t xdmcp_handle;

static const value_string opcode_vals[] = {

  { XDMCP_BROADCAST_QUERY, "Broadcast_query" },

  { XDMCP_QUERY, "Query" },

  { XDMCP_INDIRECT_QUERY, "Indirect_query" },

  { XDMCP_FORWARD_QUERY, "Forward_query" },

  { XDMCP_WILLING, "Willing" },

  { XDMCP_UNWILLING, "Unwilling" },

  { XDMCP_REQUEST, "Request" },

  { XDMCP_ACCEPT, "Accept "},

  { XDMCP_DECLINE, "Decline" },

  { XDMCP_MANAGE, "Manage" },

  { XDMCP_REFUSE, "Refuse" },

  { XDMCP_FAILED, "Failed" },

  { XDMCP_KEEPALIVE, "Keepalive" },

  { XDMCP_ALIVE, "Alive" },

  { 0, NULL }

};

/* Copied from packet-x11.c */

static const value_string family_vals[] = {

  { 0, "Internet" },

  { 1, "DECnet" },

  { 2, "Chaos" },

  { 6, "InternetV6" },

  { 0, NULL }

};

static int proto_xdmcp;

static int hf_xdmcp_version;

static int hf_xdmcp_opcode;

static int hf_xdmcp_length;

static int hf_xdmcp_authentication_name;

static int hf_xdmcp_authorization_name;

static int hf_xdmcp_hostname;

static int hf_xdmcp_status;

static int hf_xdmcp_session_id;

static int hf_xdmcp_display_number;

static int hf_xdmcp_manufacturer_display_id;

static int hf_xdmcp_manufacturer_display_id_len;

static int hf_xdmcp_display_class;

static int hf_xdmcp_display_class_len;

static int hf_xdmcp_client_address_ipv4;

static int hf_xdmcp_client_address_ipv6;

static int hf_xdmcp_client_address_bytes;

static int hf_xdmcp_client_address_bytes_len;

static int hf_xdmcp_client_port_u16;

static int hf_xdmcp_client_port_bytes;

static int hf_xdmcp_client_port_len;

static int hf_xdmcp_authentication_data;

static int hf_xdmcp_authentication_data_len;

static int hf_xdmcp_authorization_data;

static int hf_xdmcp_authorization_data_len;

static int hf_xdmcp_connection_type;

static int hf_xdmcp_connection_address_ipv4;

static int hf_xdmcp_connection_address_ipv6;

static int hf_xdmcp_connection_address_bytes;

static int hf_xdmcp_session_running;

static int ett_xdmcp;

static int ett_xdmcp_authentication_names;

static int ett_xdmcp_authorization_names;

static int ett_xdmcp_connections;

static int ett_xdmcp_connection;

static expert_field ei_xdmcp_conn_address_mismatch;

static int xdmcp_add_string(proto_tree *tree, packet_info* pinfo, int hf,

                             tvbuff_t *tvb, int offset)

{

  char *str;

  unsigned len;

  len = tvb_get_ntohs(tvb, offset);

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

  proto_tree_add_string(tree, hf, tvb, offset, len+2, str);

  return len+2;

}

static int xdmcp_add_bytes(proto_tree *tree, int hf_byte, int hf_length,

                     tvbuff_t *tvb, int offset)

{

  unsigned len;

  len = tvb_get_ntohs(tvb, offset);

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

  proto_tree_add_item(tree, hf_byte, tvb, offset, len+2, ENC_NA);

  return len+2;

}

static int xdmcp_add_authentication_names(proto_tree *tree, packet_info* pinfo,

                                    tvbuff_t *tvb, int offset)

{

  proto_tree *anames_tree;

  proto_item *anames_ti;

  int anames_len, anames_start_offset;

  anames_start_offset = offset;

  anames_len = tvb_get_uint8(tvb, offset);

  anames_tree = proto_tree_add_subtree_format(tree, tvb,

                                  anames_start_offset, -1,

                                  ett_xdmcp_authentication_names, &anames_ti, "Authentication names (%d)",

                                  anames_len);

  anames_len = tvb_get_uint8(tvb, offset);

  offset++;

  while (anames_len > 0) {

    offset += xdmcp_add_string(anames_tree, pinfo, hf_xdmcp_authentication_name,

                               tvb, offset);

    anames_len--;

  }

  proto_item_set_len(anames_ti, offset - anames_start_offset);

  return offset - anames_start_offset;

}

static int xdmcp_add_authorization_names(proto_tree *tree, packet_info* pinfo,

                                    tvbuff_t *tvb, int offset)

{

  proto_tree *anames_tree;

  proto_item *anames_ti;

  int anames_len, anames_start_offset;

  anames_start_offset = offset;

  anames_len = tvb_get_uint8(tvb, offset);

  anames_tree = proto_tree_add_subtree_format(tree, tvb,

                                  anames_start_offset, -1,

                                  ett_xdmcp_authorization_names, &anames_ti, "Authorization names (%d)",

                                  anames_len);

  anames_len = tvb_get_uint8(tvb, offset);

  offset++;

  while (anames_len > 0) {

    offset += xdmcp_add_string(anames_tree, pinfo, hf_xdmcp_authorization_name,

                               tvb, offset);

    anames_len--;

  }

  proto_item_set_len(anames_ti, offset - anames_start_offset);

  return offset - anames_start_offset;

}

/*

 * I didn't find any documentation for the XDMCP protocol, so

 * this is reverse-engineered from XFree86 source files

 * xc/programs/xdm/xdmcp.c and xc/programs/Xserver/os/xdmcp.c.

 */

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

{

  int version = -1, opcode = -1;

  int offset = 0;

  proto_item *ti;

  proto_tree *xdmcp_tree = 0;

  version = tvb_get_ntohs(tvb, offset);

  if (version != XDMCP_PROTOCOL_VERSION) {

    /* Only version 1 exists, so this probably is not XDMCP at all... */

    return offset;

  }

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

  col_clear(pinfo->cinfo, COL_INFO);

  ti = proto_tree_add_item(tree, proto_xdmcp, tvb, offset, -1, ENC_NA);

  xdmcp_tree = proto_item_add_subtree(ti, ett_xdmcp);

  proto_tree_add_uint(xdmcp_tree, hf_xdmcp_version, tvb,

                        offset, 2, version);

  offset += 2;

  opcode = tvb_get_ntohs(tvb, offset);

  if (tree) {

    proto_tree_add_uint(xdmcp_tree, hf_xdmcp_opcode, tvb,

                        offset, 2, opcode);

  }

  offset += 2;

  col_add_str(pinfo->cinfo, COL_INFO,

                 val_to_str(pinfo->pool, opcode, opcode_vals, "Unknown (0x%04x)"));

  proto_tree_add_item(xdmcp_tree, hf_xdmcp_length, tvb,

                        offset, 2, ENC_BIG_ENDIAN);

  offset += 2;

  switch (opcode) {

    case XDMCP_FORWARD_QUERY:

    {

      int alen, plen;

      alen = tvb_get_ntohs(tvb, offset);

      /* I have never seen anything except IPv4 addresses here,

       * but in theory the protocol should support other address

       * families. */

      if (alen == 4) {

    proto_tree_add_item(xdmcp_tree, hf_xdmcp_client_address_ipv4, tvb, offset+2, alen, ENC_BIG_ENDIAN);

        offset += 6;

      } else if (alen == 16) {

    proto_tree_add_item(xdmcp_tree, hf_xdmcp_client_address_ipv6, tvb, offset+2, alen, ENC_NA);

        offset += 18;

      } else {

        offset += xdmcp_add_bytes(xdmcp_tree, hf_xdmcp_client_address_bytes, hf_xdmcp_client_address_bytes_len,

                              tvb, offset);

      }

      plen = tvb_get_ntohs(tvb, offset);

      if (plen == 2) {

    proto_tree_add_item(xdmcp_tree, hf_xdmcp_client_port_u16, tvb, offset+2, plen, ENC_BIG_ENDIAN);

        offset += 4;

      } else {

        offset += xdmcp_add_bytes(xdmcp_tree, hf_xdmcp_client_port_bytes, hf_xdmcp_client_port_len,

                  tvb, offset);

      }

    }

    /* fall-through */

    case XDMCP_BROADCAST_QUERY:

    case XDMCP_QUERY:

    case XDMCP_INDIRECT_QUERY:

      offset += xdmcp_add_authentication_names(xdmcp_tree, pinfo, tvb, offset);

      break;

    case XDMCP_WILLING:

      offset += xdmcp_add_string(xdmcp_tree, pinfo, hf_xdmcp_authentication_name,

                                 tvb, offset);

      offset += xdmcp_add_string(xdmcp_tree, pinfo, hf_xdmcp_hostname,

                                 tvb, offset);

      offset += xdmcp_add_string(xdmcp_tree, pinfo, hf_xdmcp_status,

                                 tvb, offset);

      break;

    case XDMCP_UNWILLING:

      offset += xdmcp_add_string(xdmcp_tree, pinfo, hf_xdmcp_hostname,

                                 tvb, offset);

      offset += xdmcp_add_string(xdmcp_tree, pinfo, hf_xdmcp_status,

                                 tvb, offset);

      break;

    case XDMCP_REQUEST:

    {

      proto_tree *clist_tree;

      proto_item *clist_ti;

      int ctypes_len, caddrs_len, n;

      int ctypes_start_offset, caddrs_offset;

      ti = proto_tree_add_item(xdmcp_tree, hf_xdmcp_display_number, tvb,

                          offset, 2, ENC_BIG_ENDIAN);

      offset += 2;

      ctypes_len = tvb_get_uint8(tvb, offset);

      ctypes_start_offset = offset;

      caddrs_offset = offset + 1 + 2*ctypes_len;

      caddrs_len = tvb_get_uint8(tvb, caddrs_offset);

      if (ctypes_len != caddrs_len) {

        expert_add_info(pinfo, ti, &ei_xdmcp_conn_address_mismatch);

        return offset;

      }

      clist_tree = proto_tree_add_subtree_format(xdmcp_tree,

                                     tvb, ctypes_start_offset, -1,

                                     ett_xdmcp_connections, &clist_ti, "Connections (%d)",

                                     ctypes_len);

      offset++;

      caddrs_offset++;

      n = 1;

      while (ctypes_len > 0) {

        proto_item *connection_ti;

        proto_tree *connection_tree;

        int alen;

        int ctype = tvb_get_ntohs(tvb, offset);

        offset += 2;

        alen = tvb_get_ntohs(tvb, caddrs_offset);

        caddrs_offset += 2;

        connection_tree = proto_tree_add_subtree_format(clist_tree, tvb, 0, 0,

                                            ett_xdmcp_connection, &connection_ti, "Connection %d", n);

        proto_tree_add_item(connection_tree, hf_xdmcp_connection_type, tvb, offset-2, 2, ENC_BIG_ENDIAN);

        if ((ctype == 0) && (alen == 4)) {

          proto_tree_add_item(connection_tree, hf_xdmcp_connection_address_ipv4, tvb, caddrs_offset, alen, ENC_BIG_ENDIAN);

          proto_item_append_text(connection_ti, ": %s", tvb_ip_to_str(pinfo->pool, tvb, caddrs_offset));

        } else if ((ctype == 6) && (alen == 16)) {

          proto_tree_add_item(connection_tree, hf_xdmcp_connection_address_ipv6, tvb, caddrs_offset, alen, ENC_NA);

          proto_item_append_text(connection_ti, ": %s", tvb_ip6_to_str(pinfo->pool, tvb, caddrs_offset));

        } else {

          proto_tree_add_item(connection_tree, hf_xdmcp_connection_address_bytes, tvb, caddrs_offset, alen, ENC_NA);

        }

        caddrs_offset += alen;

        ctypes_len--;

        n++;

      }

      offset = caddrs_offset;

      proto_item_set_len(clist_ti, offset - ctypes_start_offset);

      offset += xdmcp_add_string(xdmcp_tree, pinfo, hf_xdmcp_authentication_name,

                                 tvb, offset);

      offset += xdmcp_add_bytes(xdmcp_tree, hf_xdmcp_authentication_data, hf_xdmcp_authentication_data_len,

                                 tvb, offset);

      offset += xdmcp_add_authorization_names(xdmcp_tree, pinfo, tvb, offset);

      offset += xdmcp_add_bytes(xdmcp_tree, hf_xdmcp_manufacturer_display_id, hf_xdmcp_manufacturer_display_id_len,

                               tvb, offset);

      break;

    }

    case XDMCP_ACCEPT:

      proto_tree_add_item(xdmcp_tree, hf_xdmcp_session_id, tvb,

                          offset, 4, ENC_BIG_ENDIAN);

      offset += 4;

      offset += xdmcp_add_string(xdmcp_tree, pinfo, hf_xdmcp_authentication_name,

                                 tvb, offset);

      offset += xdmcp_add_bytes(xdmcp_tree, hf_xdmcp_authentication_data, hf_xdmcp_authentication_data_len,

                                 tvb, offset);

      offset += xdmcp_add_string(xdmcp_tree, pinfo, hf_xdmcp_authorization_name,

                                 tvb, offset);

      offset += xdmcp_add_bytes(xdmcp_tree, hf_xdmcp_authorization_data, hf_xdmcp_authorization_data_len,

                                 tvb, offset);

      break;

    case XDMCP_DECLINE:

      offset += xdmcp_add_string(xdmcp_tree, pinfo, hf_xdmcp_status,

                                 tvb, offset);

      offset += xdmcp_add_string(xdmcp_tree, pinfo, hf_xdmcp_authentication_name,

                                 tvb, offset);

      offset += xdmcp_add_bytes(xdmcp_tree, hf_xdmcp_authentication_data, hf_xdmcp_authentication_data_len,

                                 tvb, offset);

      break;

    case XDMCP_MANAGE:

      proto_tree_add_item(xdmcp_tree, hf_xdmcp_session_id, tvb,

                          offset, 4, ENC_BIG_ENDIAN);

      offset += 4;

      proto_tree_add_item(xdmcp_tree, hf_xdmcp_display_number, tvb,

                          offset, 2, ENC_BIG_ENDIAN);

      offset += 2;

      offset += xdmcp_add_bytes(xdmcp_tree, hf_xdmcp_display_class, hf_xdmcp_display_class_len,

                               tvb, offset);

      break;

    case XDMCP_REFUSE:

      proto_tree_add_item(xdmcp_tree, hf_xdmcp_session_id, tvb,

                          offset, 4, ENC_BIG_ENDIAN);

      offset += 4;

      break;

    case XDMCP_FAILED:

      proto_tree_add_item(xdmcp_tree, hf_xdmcp_session_id, tvb,

                          offset, 4, ENC_BIG_ENDIAN);

      offset += 4;

      offset += xdmcp_add_string(xdmcp_tree, pinfo, hf_xdmcp_status,

                                 tvb, offset);

      break;

    case XDMCP_KEEPALIVE:

      proto_tree_add_item(xdmcp_tree, hf_xdmcp_display_number, tvb,

                          offset, 2, ENC_BIG_ENDIAN);

      offset += 2;

      proto_tree_add_item(xdmcp_tree, hf_xdmcp_session_id, tvb,

                          offset, 4, ENC_BIG_ENDIAN);

      offset += 4;

      break;

    case XDMCP_ALIVE:

    {

      uint8_t session_running = tvb_get_uint8(tvb, offset);

      proto_tree_add_uint_format_value(xdmcp_tree, hf_xdmcp_session_running, tvb,

                          offset, 1, session_running, "%s", session_running ? "Yes" : "No");

      offset++;

      proto_tree_add_item(xdmcp_tree, hf_xdmcp_session_id, tvb,

                          offset, 4, ENC_BIG_ENDIAN);

      offset += 4;

    }

      break;

    default:

      break;

  }

  return offset;

}

/* Register the protocol with Wireshark */

void proto_register_xdmcp(void)

{

  /* Setup list of header fields */

  static hf_register_info hf[] = {

    { &hf_xdmcp_version,

      { "Version",           "xdmcp.version",

      FT_UINT16, BASE_DEC, NULL, 0,

      "Protocol version", HFILL }

    },

    { &hf_xdmcp_opcode,

      { "Opcode",              "xdmcp.opcode",

      FT_UINT16, BASE_HEX, VALS(opcode_vals), 0,

      NULL, HFILL }

    },

    { &hf_xdmcp_length,

      { "Message length",     "xdmcp.length",

      FT_UINT16, BASE_DEC, NULL, 0,

      "Length of the remaining message", HFILL }

    },

    { &hf_xdmcp_authentication_name,

      { "Authentication name",     "xdmcp.authentication_name",

      FT_STRING, BASE_NONE, NULL, 0,

      NULL, HFILL }

    },

    { &hf_xdmcp_authorization_name,

      { "Authorization name",     "xdmcp.authorization_name",

      FT_STRING, BASE_NONE, NULL, 0,

      NULL, HFILL }

    },

    { &hf_xdmcp_hostname,

      { "Hostname",     "xdmcp.hostname",

      FT_STRING, BASE_NONE, NULL, 0,

      NULL, HFILL }

    },

    { &hf_xdmcp_status,

      { "Status",     "xdmcp.status",

      FT_STRING, BASE_NONE, NULL, 0,

      NULL, HFILL }

    },

    { &hf_xdmcp_session_id,

      { "Session ID",     "xdmcp.session_id",

      FT_UINT32, BASE_HEX, NULL, 0,

      "Session identifier", HFILL }

    },

    { &hf_xdmcp_display_number,

      { "Display number",     "xdmcp.display_number",

      FT_UINT16, BASE_DEC, NULL, 0,

      NULL, HFILL }

    },

    { &hf_xdmcp_manufacturer_display_id_len,

      { "Manufacturer display ID Length",     "xdmcp.manufacturer_display_id_len",

      FT_UINT16, BASE_DEC, NULL, 0,

      NULL, HFILL }

    },

    { &hf_xdmcp_manufacturer_display_id,

      { "Manufacturer display ID",     "xdmcp.manufacturer_display_id",

      FT_BYTES, BASE_NONE, NULL, 0,

      NULL, HFILL }

    },

    { &hf_xdmcp_display_class_len,

      { "Display class Length",     "xdmcp.display_class_len",

      FT_UINT16, BASE_DEC, NULL, 0,

      NULL, HFILL }

    },

    { &hf_xdmcp_display_class,

      { "Display class",     "xdmcp.display_class",

      FT_BYTES, BASE_NONE, NULL, 0,

      NULL, HFILL }

    },

    /* XXX - the following 3 could be the same filter, but mixed types of the same filter seem to cause issues */

    { &hf_xdmcp_client_address_ipv4,

      { "Client Address",     "xdmcp.client_address_ipv4",

      FT_IPv4, BASE_NONE, NULL, 0,

      NULL, HFILL }

    },

    { &hf_xdmcp_client_address_ipv6,

      { "Client Address",     "xdmcp.client_address_ipv6",

      FT_IPv6, BASE_NONE, NULL, 0,

      NULL, HFILL }

    },

    { &hf_xdmcp_client_address_bytes,

      { "Client Address",     "xdmcp.client_address_bytes",

      FT_BYTES, BASE_NONE, NULL, 0,

      NULL, HFILL }

    },

    { &hf_xdmcp_client_address_bytes_len,

      { "Client Address Length",     "xdmcp.client_address_bytes_len",

      FT_UINT16, BASE_DEC, NULL, 0,

      NULL, HFILL }

    },

    { &hf_xdmcp_client_port_len,

      { "Client port Length",     "xdmcp.client_port_len",

      FT_UINT16, BASE_DEC, NULL, 0,

      NULL, HFILL }

    },

    { &hf_xdmcp_client_port_bytes,

      { "Client port",     "xdmcp.client_port_bytes",

      FT_BYTES, BASE_NONE, NULL, 0,

      NULL, HFILL }

    },

    { &hf_xdmcp_client_port_u16,

      { "Client port",     "xdmcp.client_port",

      FT_UINT16, BASE_DEC, NULL, 0,

      NULL, HFILL }

    },

    { &hf_xdmcp_authentication_data_len,

      { "Authentication data Length",     "xdmcp.authentication_data_len",

      FT_UINT16, BASE_DEC, NULL, 0,

      NULL, HFILL }

    },

    { &hf_xdmcp_authentication_data,

      { "Authentication data",     "xdmcp.authentication_data",

      FT_BYTES, BASE_NONE, NULL, 0,

      NULL, HFILL }

    },

    { &hf_xdmcp_authorization_data_len,

      { "Authorization data Length",     "xdmcp.authorization_data_len",

      FT_UINT16, BASE_DEC, NULL, 0,

      NULL, HFILL }

    },

    { &hf_xdmcp_authorization_data,

      { "Authorization data",     "xdmcp.authorization_data",

      FT_BYTES, BASE_NONE, NULL, 0,

      NULL, HFILL }

    },

    /* XXX - the following 3 could be the same filter, but mixed types of the same filter seem to cause issues */

    { &hf_xdmcp_connection_address_ipv4,

      { "Address",     "xdmcp.connection_address_ipv4",

      FT_IPv4, BASE_NONE, NULL, 0,

      NULL, HFILL }

    },

    { &hf_xdmcp_connection_address_ipv6,

      { "Address",     "xdmcp.connection_address_ipv6",

      FT_IPv6, BASE_NONE, NULL, 0,

      NULL, HFILL }

    },

    { &hf_xdmcp_connection_address_bytes,

      { "Address",     "xdmcp.connection_address_bytes",

      FT_BYTES, BASE_NONE, NULL, 0,

      NULL, HFILL }

    },

    { &hf_xdmcp_connection_type,

      { "Type",     "xdmcp.connection_type",

      FT_UINT16, BASE_HEX, VALS(family_vals), 0,

      NULL, HFILL }

    },

    { &hf_xdmcp_session_running,

      { "Session running",     "xdmcp.session_running",

      FT_UINT8, BASE_DEC, NULL, 0,

      NULL, HFILL }

    },

  };

  /* Setup protocol subtree array */

  static int *ett[] = {

    &ett_xdmcp,

    &ett_xdmcp_authentication_names,

    &ett_xdmcp_authorization_names,

    &ett_xdmcp_connections,

    &ett_xdmcp_connection

  };

  static ei_register_info ei[] = {

     { &ei_xdmcp_conn_address_mismatch, { "xdmcp.conn_address_mismatch", PI_PROTOCOL, PI_WARN, "Error: Connection type/address arrays don't match", EXPFILL }},

  };

  expert_module_t* expert_xdmcp;

  /* Register the protocol name and description */

  proto_xdmcp = proto_register_protocol("X Display Manager Control Protocol", "XDMCP", "xdmcp");

  /* Required function calls to register the header fields and subtrees used */

  proto_register_field_array(proto_xdmcp, hf, array_length(hf));

  proto_register_subtree_array(ett, array_length(ett));

  expert_xdmcp = expert_register_protocol(proto_xdmcp);

  expert_register_field_array(expert_xdmcp, ei, array_length(ei));

  /* Register the dissector handle */

  xdmcp_handle = register_dissector("xdmcp", dissect_xdmcp, proto_xdmcp);

}

void

proto_reg_handoff_xdmcp(void)

{

  dissector_add_uint_with_preference("udp.port", UDP_PORT_XDMCP, xdmcp_handle);

}

/*

 * Editor modelines

 *

 * Local Variables:

 * c-basic-offset: 2

 * tab-width: 8

 * indent-tabs-mode: nil

 * End:

 *

 * ex: set shiftwidth=2 tabstop=8 expandtab:

 * :indentSize=2:tabSize=8:noTabs=true:

 */