/*

 * MQTT Protocol

 *

 * Copyright 2020 Baptiste Assmann <bedis9@gmail.com>

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version

 * 2 of the License, or (at your option) any later version.

 *

 */

#include <haproxy/chunk.h>

#include <haproxy/mqtt.h>

uint8_t mqtt_cpt_flags[MQTT_CPT_ENTRIES] = {

  [MQTT_CPT_INVALID]     = 0x00,

  [MQTT_CPT_CONNECT]     = 0x00,

  [MQTT_CPT_CONNACK]     = 0x00,

  /* MQTT_CPT_PUBLISH flags can have different values (DUP, QoS, RETAIN), must be

   * check more carefully (any combination of the 4 bits is valid).

   */

  [MQTT_CPT_PUBLISH]     = 0x0F,

  [MQTT_CPT_PUBACK]      = 0x00,

  [MQTT_CPT_PUBREC]      = 0x00,

  [MQTT_CPT_PUBREL]      = 0x02,

  [MQTT_CPT_PUBCOMP]     = 0x00,

  [MQTT_CPT_SUBSCRIBE]   = 0x02,

  [MQTT_CPT_SUBACK]      = 0x00,

  [MQTT_CPT_UNSUBSCRIBE] = 0x02,

  [MQTT_CPT_UNSUBACK]    = 0x00,

  [MQTT_CPT_PINGREQ]     = 0x00,

  [MQTT_CPT_PINGRESP]    = 0x00,

  [MQTT_CPT_DISCONNECT]  = 0x00,

  [MQTT_CPT_AUTH]        = 0x00,

};

const struct ist mqtt_fields_string[MQTT_FN_ENTRIES] = {

  [MQTT_FN_INVALID]                            = IST(""),

  /* it's MQTT 3.1, 3.1.1 and 5.0, those fields have no unique id, so we use strings */

  [MQTT_FN_FLAGS]                              = IST("flags"),

  [MQTT_FN_REASON_CODE]                        = IST("reason_code"),       /* MQTT 3.1 and 3.1.1: return_code */

  [MQTT_FN_PROTOCOL_NAME]                      = IST("protocol_name"),

  [MQTT_FN_PROTOCOL_VERSION]                   = IST("protocol_version"),  /* MQTT 3.1.1: protocol_level */

  [MQTT_FN_CLIENT_IDENTIFIER]                  = IST("client_identifier"),

  [MQTT_FN_WILL_TOPIC]                         = IST("will_topic"),

  [MQTT_FN_WILL_PAYLOAD]                       = IST("will_payload"),      /* MQTT 3.1 and 3.1.1: will_message */

  [MQTT_FN_USERNAME]                           = IST("username"),

  [MQTT_FN_PASSWORD]                           = IST("password"),

  [MQTT_FN_KEEPALIVE]                          = IST("keepalive"),

  /* from here, it's MQTT 5.0 only */

  [MQTT_FN_PAYLOAD_FORMAT_INDICATOR]           = IST("1"),

  [MQTT_FN_MESSAGE_EXPIRY_INTERVAL]            = IST("2"),

  [MQTT_FN_CONTENT_TYPE]                       = IST("3"),

  [MQTT_FN_RESPONSE_TOPIC]                     = IST("8"),

  [MQTT_FN_CORRELATION_DATA]                   = IST("9"),

  [MQTT_FN_SUBSCRIPTION_IDENTIFIER]            = IST("11"),

  [MQTT_FN_SESSION_EXPIRY_INTERVAL]            = IST("17"),

  [MQTT_FN_ASSIGNED_CLIENT_IDENTIFIER]         = IST("18"),

  [MQTT_FN_SERVER_KEEPALIVE]                   = IST("19"),

  [MQTT_FN_AUTHENTICATION_METHOD]              = IST("21"),

  [MQTT_FN_AUTHENTICATION_DATA]                = IST("22"),

  [MQTT_FN_REQUEST_PROBLEM_INFORMATION]        = IST("23"),

  [MQTT_FN_DELAY_INTERVAL]                     = IST("24"),

  [MQTT_FN_REQUEST_RESPONSE_INFORMATION]       = IST("25"),

  [MQTT_FN_RESPONSE_INFORMATION]               = IST("26"),

  [MQTT_FN_SERVER_REFERENCE]                   = IST("28"),

  [MQTT_FN_REASON_STRING]                      = IST("31"),

  [MQTT_FN_RECEIVE_MAXIMUM]                    = IST("33"),

  [MQTT_FN_TOPIC_ALIAS_MAXIMUM]                = IST("34"),

  [MQTT_FN_TOPIC_ALIAS]                        = IST("35"),

  [MQTT_FN_MAXIMUM_QOS]                        = IST("36"),

  [MQTT_FN_RETAIN_AVAILABLE]                   = IST("37"),

  [MQTT_FN_USER_PROPERTY]                      = IST("38"),

  [MQTT_FN_MAXIMUM_PACKET_SIZE]                = IST("39"),

  [MQTT_FN_WILDCARD_SUBSCRIPTION_AVAILABLE]    = IST("40"),

  [MQTT_FN_SUBSCRIPTION_IDENTIFIERS_AVAILABLE] = IST("41"),

  [MQTT_FN_SHARED_SUBSCRIPTION_AVAILABLE]      = IST("42"),

};

/* list of supported capturable field names for each MQTT control packet type */

const uint64_t mqtt_fields_per_packet[MQTT_CPT_ENTRIES] = {

  [MQTT_CPT_INVALID]     = 0,

  [MQTT_CPT_CONNECT]     = MQTT_FN_BIT_PROTOCOL_NAME                     | MQTT_FN_BIT_PROTOCOL_VERSION                   |

                           MQTT_FN_BIT_FLAGS                             | MQTT_FN_BIT_KEEPALIVE                          |

                           MQTT_FN_BIT_SESSION_EXPIRY_INTERVAL           | MQTT_FN_BIT_RECEIVE_MAXIMUM                    |

                           MQTT_FN_BIT_MAXIMUM_PACKET_SIZE               | MQTT_FN_BIT_TOPIC_ALIAS_MAXIMUM                |

                           MQTT_FN_BIT_REQUEST_RESPONSE_INFORMATION      | MQTT_FN_BIT_REQUEST_PROBLEM_INFORMATION        |

                           MQTT_FN_BIT_USER_PROPERTY                     | MQTT_FN_BIT_AUTHENTICATION_METHOD              |

                           MQTT_FN_BIT_AUTHENTICATION_DATA               | MQTT_FN_BIT_CLIENT_IDENTIFIER                  |

                           MQTT_FN_BIT_DELAY_INTERVAL                    | MQTT_FN_BIT_PAYLOAD_FORMAT_INDICATOR           |

                           MQTT_FN_BIT_MESSAGE_EXPIRY_INTERVAL           | MQTT_FN_BIT_CONTENT_TYPE                       |

                           MQTT_FN_BIT_RESPONSE_TOPIC                    | MQTT_FN_BIT_CORRELATION_DATA                   |

                           MQTT_FN_BIT_WILL_TOPIC                        |

                           MQTT_FN_BIT_WILL_PAYLOAD                      | MQTT_FN_BIT_USERNAME                           |

                           MQTT_FN_BIT_PASSWORD,

  [MQTT_CPT_CONNACK]     = MQTT_FN_BIT_FLAGS                             | MQTT_FN_BIT_PROTOCOL_VERSION                   |

                           MQTT_FN_BIT_REASON_CODE                       | MQTT_FN_BIT_SESSION_EXPIRY_INTERVAL            |

                           MQTT_FN_BIT_RECEIVE_MAXIMUM                   | MQTT_FN_BIT_MAXIMUM_QOS                        |

                           MQTT_FN_BIT_RETAIN_AVAILABLE                  | MQTT_FN_BIT_MAXIMUM_PACKET_SIZE                |

                           MQTT_FN_BIT_ASSIGNED_CLIENT_IDENTIFIER        | MQTT_FN_BIT_TOPIC_ALIAS_MAXIMUM                |

                           MQTT_FN_BIT_REASON_STRING                     | MQTT_FN_BIT_WILDCARD_SUBSCRIPTION_AVAILABLE    |

                           MQTT_FN_BIT_SUBSCRIPTION_IDENTIFIERS_AVAILABLE| MQTT_FN_BIT_SHARED_SUBSCRIPTION_AVAILABLE      |

                           MQTT_FN_BIT_SERVER_KEEPALIVE                  | MQTT_FN_BIT_RESPONSE_INFORMATION               |

                           MQTT_FN_BIT_SERVER_REFERENCE                  | MQTT_FN_BIT_USER_PROPERTY                      |

                           MQTT_FN_BIT_AUTHENTICATION_METHOD             | MQTT_FN_BIT_AUTHENTICATION_DATA,

  [MQTT_CPT_PUBLISH]     = MQTT_FN_BIT_PAYLOAD_FORMAT_INDICATOR          | MQTT_FN_BIT_MESSAGE_EXPIRY_INTERVAL            |

                           MQTT_FN_BIT_CONTENT_TYPE                      | MQTT_FN_BIT_RESPONSE_TOPIC                     |

                           MQTT_FN_BIT_CORRELATION_DATA                  | MQTT_FN_BIT_SUBSCRIPTION_IDENTIFIER            |

                           MQTT_FN_BIT_TOPIC_ALIAS                       | MQTT_FN_BIT_USER_PROPERTY,

  [MQTT_CPT_PUBACK]      = MQTT_FN_BIT_REASON_CODE | MQTT_FN_BIT_REASON_STRING | MQTT_FN_BIT_USER_PROPERTY,

  [MQTT_CPT_PUBREC]      = MQTT_FN_BIT_REASON_CODE | MQTT_FN_BIT_REASON_STRING | MQTT_FN_BIT_USER_PROPERTY,

  [MQTT_CPT_PUBREL]      = MQTT_FN_BIT_REASON_CODE | MQTT_FN_BIT_REASON_STRING | MQTT_FN_BIT_USER_PROPERTY,

  [MQTT_CPT_PUBCOMP]     = MQTT_FN_BIT_REASON_CODE | MQTT_FN_BIT_REASON_STRING | MQTT_FN_BIT_USER_PROPERTY,

  [MQTT_CPT_SUBSCRIBE]   = MQTT_FN_BIT_SUBSCRIPTION_IDENTIFIER | MQTT_FN_BIT_USER_PROPERTY,

  [MQTT_CPT_SUBACK]      = MQTT_FN_BIT_REASON_STRING | MQTT_FN_BIT_USER_PROPERTY,

  [MQTT_CPT_UNSUBSCRIBE] = MQTT_FN_BIT_USER_PROPERTY,

  [MQTT_CPT_UNSUBACK]    = MQTT_FN_BIT_REASON_STRING | MQTT_FN_BIT_USER_PROPERTY,

  [MQTT_CPT_PINGREQ]     = 0,

  [MQTT_CPT_PINGRESP]    = 0,

  [MQTT_CPT_DISCONNECT]  = MQTT_FN_BIT_REASON_CODE                       | MQTT_FN_BIT_SESSION_EXPIRY_INTERVAL            |

                           MQTT_FN_BIT_SERVER_REFERENCE                  | MQTT_FN_BIT_REASON_STRING                      |

                           MQTT_FN_BIT_USER_PROPERTY,

  [MQTT_CPT_AUTH]        = MQTT_FN_BIT_AUTHENTICATION_METHOD             | MQTT_FN_BIT_AUTHENTICATION_DATA                |

                           MQTT_FN_BIT_REASON_STRING                     | MQTT_FN_BIT_USER_PROPERTY,

};

/* Checks the first byte of a message to read the fixed header and extract the

 * packet type and flags. <parser> is supposed to point to the fixed header byte.

 *

 * Fix header looks like:

 * +-------+-----------+-----------+-----------+---------+----------+----------+---------+------------+

 * |  bit  |    7      |     6     |    5      |    4    |     3    |     2    |     1   |     0      |

 * +-------+-----------+-----------+-----------+---------+----------+----------+---------+------------+

 * | field |          MQTT Control Packet Type           | Flags specific to each Control Packet type |

 * +-------+---------------------------------------------+--------------------------------------------+

 *

 * On success, <ptk> is updated with the packet type and flags and the new parser

 * state is returned. On error, IST_NULL is returned.

 */

static inline struct ist mqtt_read_fixed_hdr(struct ist parser, struct mqtt_pkt *pkt)

{

  uint8_t type  = (uint8_t)*istptr(parser);

  uint8_t ptype = (type & 0xF0) >> 4;

  uint8_t flags = type & 0x0F;

  if (ptype == MQTT_CPT_INVALID || ptype >= MQTT_CPT_ENTRIES ||

      (ptype != MQTT_CPT_PUBLISH && flags != mqtt_cpt_flags[ptype]))

    return IST_NULL;

  pkt->fixed_hdr.type = ptype;

  pkt->fixed_hdr.flags = flags;

  return istnext(parser);

}

/* Reads a one byte integer. more information here :

 *     https://docs.oasis-open.org/mqtt/mqtt/v5.0/os/mqtt-v5.0-os.html#_Toc3901007

 *

 * <parser> is supposed to point to the first byte of the integer. On success

 * the integer is stored in <*i>, if provided, and the new parser state is returned. On

 * error, IST_NULL is returned.

*/

static inline struct ist mqtt_read_1byte_int(struct ist parser, uint8_t *i)

{

  if (istlen(parser) < 1)

    return IST_NULL;

  if (i)

    *i = (uint8_t)*istptr(parser);

  parser = istnext(parser);

  return parser;

}

/* Reads a two byte integer. more information here :

 *     https://docs.oasis-open.org/mqtt/mqtt/v5.0/os/mqtt-v5.0-os.html#_Toc3901008

 *

 * <parser> is supposed to point to the first byte of the integer. On success

 * the integer is stored in <*i>, if provided, and the new parser state is returned. On

 * error, IST_NULL is returned.

*/

static inline struct ist mqtt_read_2byte_int(struct ist parser, uint16_t *i)

{

  if (istlen(parser) < 2)

    return IST_NULL;

  if (i) {

    *i  = (uint8_t)*istptr(parser) << 8;

    *i += (uint8_t)*(istptr(parser) + 1);

  }

  parser = istadv(parser, 2);

  return parser;

}

/* Reads a four byte integer. more information here :

 *     https://docs.oasis-open.org/mqtt/mqtt/v5.0/os/mqtt-v5.0-os.html#_Toc3901009

 *

 * <parser> is supposed to point to the first byte of the integer. On success

 * the integer is stored in <*i>, if provided, and the new parser state is returned. On

 * error, IST_NULL is returned.

*/

static inline struct ist mqtt_read_4byte_int(struct ist parser, uint32_t *i)

{

  if (istlen(parser) < 4)

    return IST_NULL;

  if (i) {

    *i  = (uint8_t)*istptr(parser) << 24;

    *i += (uint8_t)*(istptr(parser) + 1) << 16;

    *i += (uint8_t)*(istptr(parser) + 2) << 8;

    *i += (uint8_t)*(istptr(parser) + 3);

  }

  parser = istadv(parser, 4);

  return parser;

}

/* Reads a variable byte integer. more information here :

 *   https://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html#_Toc398718023

 *   https://docs.oasis-open.org/mqtt/mqtt/v5.0/os/mqtt-v5.0-os.html#_Toc3901011

 *

 * It is encoded using a variable length encoding scheme which uses a single

 * byte for values up to 127.  Larger values are handled as follows. The least

 * significant seven bits of each byte encode the data, and the most significant

 * bit is used to indicate that there are following bytes in the representation.

 * Thus each byte encodes 128 values and a "continuation bit".

 *

 * The maximum number of bytes in the Remaining Length field is four

 * (MQTT_REMAINING_LENGTH_MAX_SIZE).

 *

 * <parser> is supposed to point to the first byte of the integer. On success

 * the integer is stored in <*i> and the new parser state is returned. On

 * error, IST_NULL is returned.

 */

static inline struct ist mqtt_read_varint(struct ist parser, uint32_t *i)

{

  int off, m;

  off = m = 0;

  if (i)

    *i = 0;

  for (off = 0; off < MQTT_REMAINING_LENGTH_MAX_SIZE && istlen(parser); off++) {

    uint8_t byte = (uint8_t)*istptr(parser);

    if (i) {

      *i += (byte & 127) << m;

      m += 7; /* preparing <m> for next byte */

    }

    parser = istnext(parser);

    /* we read the latest byte for the remaining length field */

    if (byte <= 127)

      break;

  }

  if (off == MQTT_REMAINING_LENGTH_MAX_SIZE)

    return IST_NULL;

  return parser;

}

/* Reads a MQTT string. more information here :

 *   http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html#_Toc398718016

 *   https://docs.oasis-open.org/mqtt/mqtt/v5.0/os/mqtt-v5.0-os.html#_Toc3901010

 *

 * In MQTT, strings are prefixed by their size, encoded over 2 bytes:

 *   byte 1:  length MSB

 *   byte 2:  length LSB

 *   byte 3:  string

 *   ...

 *

 *   string size is MSB * 256 + LSB

 *

 * <parser> is supposed to point to the first byte of the string. On success the

 * string is stored in <*str>, if provided, and the new parser state is

 * returned. On error, IST_NULL is returned.

 */

static inline struct ist mqtt_read_string(struct ist parser, struct ist *str)

{

  uint16_t len = 0;

  /* read and compute the string length */

  if (istlen(parser) < 2)

    goto error;

  parser = mqtt_read_2byte_int(parser, &len);

  if (!isttest(parser) || istlen(parser) < len)

    goto error;

  if (str) {

    str->ptr = istptr(parser);

    str->len = len;

  }

  return istadv(parser, len);

  error:

  return IST_NULL;

}

/* Helper function to convert a unsigned integer to a string. The result is

 * written in <buf>. On success, the written size is returned, otherwise, on

 * error, 0 is returned.

 */

static inline size_t mqtt_uint2str(struct buffer *buf, uint32_t i)

{

  char *end;

  end = ultoa_o(i, buf->area, buf->size);

  if (!end)

    return 0;

  buf->data = end - buf->area;

  return buf->data;

}

/* Extracts the value of a <fieldname_id> of type <type> from a given MQTT

 * message <msg>.  IST_NULL is returned if an error occurred while parsing or if

 * the field could not be found. If more data are required, the message with a

 * length set to 0 is returned. If the field is found, the response is returned

 * as a struct ist.

 */

struct ist mqtt_field_value(struct ist msg, int type, int fieldname_id)

{

  struct buffer *trash = get_trash_chunk();

  struct mqtt_pkt mpkt;

  struct ist res;

  switch (mqtt_validate_message(msg, &mpkt)) {

  case MQTT_VALID_MESSAGE:

    if (mpkt.fixed_hdr.type != type)

      goto not_found_or_invalid;

    break;

  case MQTT_NEED_MORE_DATA:

       goto need_more;

  case MQTT_INVALID_MESSAGE:

    goto not_found_or_invalid;

  }

  switch (type) {

  case MQTT_CPT_CONNECT:

    switch (fieldname_id) {

    case MQTT_FN_FLAGS:

      if (!mqtt_uint2str(trash, mpkt.data.connect.var_hdr.flags))

        goto not_found_or_invalid;

      res = ist2(trash->area, trash->data);

      goto end;

    case MQTT_FN_PROTOCOL_NAME:

      if (!istlen(mpkt.data.connect.var_hdr.protocol_name))

        goto not_found_or_invalid;

      res = mpkt.data.connect.var_hdr.protocol_name;

      goto end;

    case MQTT_FN_PROTOCOL_VERSION:

      if (!mqtt_uint2str(trash, mpkt.data.connect.var_hdr.protocol_version))

        goto not_found_or_invalid;

      res = ist2(trash->area, trash->data);

      goto end;

    case MQTT_FN_CLIENT_IDENTIFIER:

      if (!istlen(mpkt.data.connect.payload.client_identifier))

        goto not_found_or_invalid;

      res = mpkt.data.connect.payload.client_identifier;

      goto end;

    case MQTT_FN_WILL_TOPIC:

      if (!istlen(mpkt.data.connect.payload.will_topic))

        goto not_found_or_invalid;

      res = mpkt.data.connect.payload.will_topic;

      goto end;

    case MQTT_FN_WILL_PAYLOAD:

      if (!istlen(mpkt.data.connect.payload.will_payload))

        goto not_found_or_invalid;

      res = mpkt.data.connect.payload.will_payload;

      goto end;

    case MQTT_FN_USERNAME:

      if (!istlen(mpkt.data.connect.payload.username))

        goto not_found_or_invalid;

      res = mpkt.data.connect.payload.username;

      goto end;

    case MQTT_FN_PASSWORD:

      if (!istlen(mpkt.data.connect.payload.password))

        goto not_found_or_invalid;

      res = mpkt.data.connect.payload.password;

      goto end;

    case MQTT_FN_KEEPALIVE:

          if (!mqtt_uint2str(trash, mpkt.data.connect.var_hdr.keepalive))

            goto not_found_or_invalid;

          res = ist2(trash->area, trash->data);

          goto end;

    case MQTT_FN_PAYLOAD_FORMAT_INDICATOR:

      if ((mpkt.data.connect.var_hdr.protocol_version != MQTT_VERSION_5_0) ||

          !(mpkt.data.connect.var_hdr.flags & MQTT_CONNECT_FL_WILL))

        goto not_found_or_invalid;

      if (!mqtt_uint2str(trash, mpkt.data.connect.payload.will_props.payload_format_indicator))

        goto not_found_or_invalid;

      res = ist2(trash->area, trash->data);

      goto end;

    case MQTT_FN_MESSAGE_EXPIRY_INTERVAL:

      if ((mpkt.data.connect.var_hdr.protocol_version != MQTT_VERSION_5_0) ||

          !(mpkt.data.connect.var_hdr.flags & MQTT_CONNECT_FL_WILL))

        goto not_found_or_invalid;

      if (!mqtt_uint2str(trash, mpkt.data.connect.payload.will_props.message_expiry_interval))

        goto not_found_or_invalid;

      res = ist2(trash->area, trash->data);

      goto end;

    case MQTT_FN_CONTENT_TYPE:

      if ((mpkt.data.connect.var_hdr.protocol_version != MQTT_VERSION_5_0) ||

          !(mpkt.data.connect.var_hdr.flags & MQTT_CONNECT_FL_WILL))

        goto not_found_or_invalid;

      if (!istlen(mpkt.data.connect.payload.will_props.content_type))

        goto not_found_or_invalid;

      res = mpkt.data.connect.payload.will_props.content_type;

      goto end;

    case MQTT_FN_RESPONSE_TOPIC:

      if ((mpkt.data.connect.var_hdr.protocol_version != MQTT_VERSION_5_0) ||

          !(mpkt.data.connect.var_hdr.flags & MQTT_CONNECT_FL_WILL))

        goto not_found_or_invalid;

      if (!istlen(mpkt.data.connect.payload.will_props.response_topic))

        goto not_found_or_invalid;

      res = mpkt.data.connect.payload.will_props.response_topic;

      goto end;

    case MQTT_FN_CORRELATION_DATA:

      if ((mpkt.data.connect.var_hdr.protocol_version != MQTT_VERSION_5_0) ||

          !(mpkt.data.connect.var_hdr.flags & MQTT_CONNECT_FL_WILL))

        goto not_found_or_invalid;

      if (!istlen(mpkt.data.connect.payload.will_props.correlation_data))

        goto not_found_or_invalid;

      res = mpkt.data.connect.payload.will_props.correlation_data;

      goto end;

    case MQTT_FN_SESSION_EXPIRY_INTERVAL:

      if (mpkt.data.connect.var_hdr.protocol_version != MQTT_VERSION_5_0)

        goto not_found_or_invalid;

      if (!mqtt_uint2str(trash, mpkt.data.connect.var_hdr.props.session_expiry_interval))

        goto not_found_or_invalid;

      res = ist2(trash->area, trash->data);

      goto end;

    case MQTT_FN_AUTHENTICATION_METHOD:

      if (mpkt.data.connect.var_hdr.protocol_version != MQTT_VERSION_5_0)

        goto not_found_or_invalid;

      if (!istlen(mpkt.data.connect.var_hdr.props.authentication_method))

        goto not_found_or_invalid;

      res = mpkt.data.connect.var_hdr.props.authentication_method;

      goto end;

    case MQTT_FN_AUTHENTICATION_DATA:

      if (mpkt.data.connect.var_hdr.protocol_version != MQTT_VERSION_5_0)

        goto not_found_or_invalid;

      if (!istlen(mpkt.data.connect.var_hdr.props.authentication_data))

        goto not_found_or_invalid;

      res = mpkt.data.connect.var_hdr.props.authentication_data;

      goto end;

    case MQTT_FN_REQUEST_PROBLEM_INFORMATION:

      if (mpkt.data.connect.var_hdr.protocol_version != MQTT_VERSION_5_0)

        goto not_found_or_invalid;

      if (!mqtt_uint2str(trash, mpkt.data.connect.var_hdr.props.request_problem_information))

        goto not_found_or_invalid;

      res = ist2(trash->area, trash->data);

      goto end;

    case MQTT_FN_DELAY_INTERVAL:

      if ((mpkt.data.connect.var_hdr.protocol_version != MQTT_VERSION_5_0) ||

          !(mpkt.data.connect.var_hdr.flags & MQTT_CONNECT_FL_WILL))

        goto not_found_or_invalid;

      if (!mqtt_uint2str(trash, mpkt.data.connect.payload.will_props.delay_interval))

        goto not_found_or_invalid;

      res = ist2(trash->area, trash->data);

      goto end;

    case MQTT_FN_REQUEST_RESPONSE_INFORMATION:

      if (mpkt.data.connect.var_hdr.protocol_version != MQTT_VERSION_5_0)

        goto not_found_or_invalid;

      if (!mqtt_uint2str(trash, mpkt.data.connect.var_hdr.props.request_response_information))

        goto not_found_or_invalid;

      res = ist2(trash->area, trash->data);

      goto end;

    case MQTT_FN_RECEIVE_MAXIMUM:

      if (mpkt.data.connect.var_hdr.protocol_version != MQTT_VERSION_5_0)

        goto not_found_or_invalid;

      if (!mqtt_uint2str(trash, mpkt.data.connect.var_hdr.props.receive_maximum))

        goto not_found_or_invalid;

      res = ist2(trash->area, trash->data);

      goto end;

    case MQTT_FN_TOPIC_ALIAS_MAXIMUM:

      if (mpkt.data.connect.var_hdr.protocol_version != MQTT_VERSION_5_0)

        goto not_found_or_invalid;

      if (!mqtt_uint2str(trash, mpkt.data.connect.var_hdr.props.topic_alias_maximum))

        goto not_found_or_invalid;

      res = ist2(trash->area, trash->data);

      goto end;

    case MQTT_FN_MAXIMUM_PACKET_SIZE:

      if (mpkt.data.connect.var_hdr.protocol_version != MQTT_VERSION_5_0)

        goto not_found_or_invalid;

      if (!mqtt_uint2str(trash, mpkt.data.connect.var_hdr.props.maximum_packet_size))

        goto not_found_or_invalid;

      res = ist2(trash->area, trash->data);

      goto end;

    default:

      goto not_found_or_invalid;

    }

    break;

  case MQTT_CPT_CONNACK:

    switch (fieldname_id) {

    case MQTT_FN_FLAGS:

      if (!mqtt_uint2str(trash, mpkt.data.connack.var_hdr.flags))

        goto not_found_or_invalid;

      res = ist2(trash->area, trash->data);

      goto end;

    case MQTT_FN_REASON_CODE:

      if (!mqtt_uint2str(trash, mpkt.data.connack.var_hdr.reason_code))

        goto not_found_or_invalid;

      res = ist2(trash->area, trash->data);

      goto end;

    case MQTT_FN_PROTOCOL_VERSION:

      if (!mqtt_uint2str(trash, mpkt.data.connack.var_hdr.protocol_version))

        goto not_found_or_invalid;

      res = ist2(trash->area, trash->data);

      goto end;

    case MQTT_FN_SESSION_EXPIRY_INTERVAL:

      if (mpkt.data.connack.var_hdr.protocol_version != MQTT_VERSION_5_0)

        goto not_found_or_invalid;

      if (!mqtt_uint2str(trash, mpkt.data.connack.var_hdr.props.session_expiry_interval))

        goto not_found_or_invalid;

      res = ist2(trash->area, trash->data);

      goto end;

    case MQTT_FN_ASSIGNED_CLIENT_IDENTIFIER:

      if (mpkt.data.connack.var_hdr.protocol_version != MQTT_VERSION_5_0)

        goto not_found_or_invalid;

      if (!istlen(mpkt.data.connack.var_hdr.props.assigned_client_identifier))

        goto not_found_or_invalid;

      res = mpkt.data.connack.var_hdr.props.assigned_client_identifier;

      goto end;

    case MQTT_FN_SERVER_KEEPALIVE:

      if (mpkt.data.connack.var_hdr.protocol_version != MQTT_VERSION_5_0)

        goto not_found_or_invalid;

      if (!mqtt_uint2str(trash, mpkt.data.connack.var_hdr.props.server_keepalive))

        goto not_found_or_invalid;

      res = ist2(trash->area, trash->data);

      goto end;

    case MQTT_FN_AUTHENTICATION_METHOD:

      if (mpkt.data.connack.var_hdr.protocol_version != MQTT_VERSION_5_0)

        goto not_found_or_invalid;

      if (!istlen(mpkt.data.connack.var_hdr.props.authentication_method))

        goto not_found_or_invalid;

      res = mpkt.data.connack.var_hdr.props.authentication_method;

      goto end;

    case MQTT_FN_AUTHENTICATION_DATA:

      if (mpkt.data.connack.var_hdr.protocol_version != MQTT_VERSION_5_0)

        goto not_found_or_invalid;

      if (!istlen(mpkt.data.connack.var_hdr.props.authentication_data))

        goto not_found_or_invalid;

      res = mpkt.data.connack.var_hdr.props.authentication_data;

      goto end;

    case MQTT_FN_RESPONSE_INFORMATION:

      if (mpkt.data.connack.var_hdr.protocol_version != MQTT_VERSION_5_0)

        goto not_found_or_invalid;

      if (!istlen(mpkt.data.connack.var_hdr.props.response_information))

        goto not_found_or_invalid;

      res = mpkt.data.connack.var_hdr.props.response_information;

      goto end;

    case MQTT_FN_SERVER_REFERENCE:

      if (mpkt.data.connack.var_hdr.protocol_version != MQTT_VERSION_5_0)

        goto not_found_or_invalid;

      if (!istlen(mpkt.data.connack.var_hdr.props.server_reference))

        goto not_found_or_invalid;

      res = mpkt.data.connack.var_hdr.props.server_reference;

      goto end;

    case MQTT_FN_REASON_STRING:

      if (mpkt.data.connack.var_hdr.protocol_version != MQTT_VERSION_5_0)

        goto not_found_or_invalid;

      if (!istlen(mpkt.data.connack.var_hdr.props.reason_string))

        goto not_found_or_invalid;

      res = mpkt.data.connack.var_hdr.props.reason_string;

      goto end;

    case MQTT_FN_RECEIVE_MAXIMUM:

      if (mpkt.data.connack.var_hdr.protocol_version != MQTT_VERSION_5_0)

        goto not_found_or_invalid;

      if (!mqtt_uint2str(trash, mpkt.data.connack.var_hdr.props.receive_maximum))

        goto not_found_or_invalid;

      res = ist2(trash->area, trash->data);

      goto end;

    case MQTT_FN_TOPIC_ALIAS_MAXIMUM:

      if (mpkt.data.connack.var_hdr.protocol_version != MQTT_VERSION_5_0)

        goto not_found_or_invalid;

      if (!mqtt_uint2str(trash, mpkt.data.connack.var_hdr.props.topic_alias_maximum))

        goto not_found_or_invalid;

      res = ist2(trash->area, trash->data);

      goto end;

    case MQTT_FN_MAXIMUM_QOS:

      if (mpkt.data.connack.var_hdr.protocol_version != MQTT_VERSION_5_0)

        goto not_found_or_invalid;

      if (!mqtt_uint2str(trash, mpkt.data.connack.var_hdr.props.maximum_qos))

        goto not_found_or_invalid;

      res = ist2(trash->area, trash->data);

      goto end;

    case MQTT_FN_RETAIN_AVAILABLE:

      if (mpkt.data.connack.var_hdr.protocol_version != MQTT_VERSION_5_0)

        goto not_found_or_invalid;

      if (!mqtt_uint2str(trash, mpkt.data.connack.var_hdr.props.retain_available))

        goto not_found_or_invalid;

      res = ist2(trash->area, trash->data);

      goto end;

    case MQTT_FN_MAXIMUM_PACKET_SIZE:

      if (mpkt.data.connack.var_hdr.protocol_version != MQTT_VERSION_5_0)

        goto not_found_or_invalid;

      if (!mqtt_uint2str(trash, mpkt.data.connack.var_hdr.props.maximum_packet_size))

        goto not_found_or_invalid;

      res = ist2(trash->area, trash->data);

      goto end;

    case MQTT_FN_WILDCARD_SUBSCRIPTION_AVAILABLE:

      if (mpkt.data.connack.var_hdr.protocol_version != MQTT_VERSION_5_0)

        goto not_found_or_invalid;

      if (!mqtt_uint2str(trash, mpkt.data.connack.var_hdr.props.wildcard_subscription_available))

        goto not_found_or_invalid;

      res = ist2(trash->area, trash->data);

      goto end;

    case MQTT_FN_SUBSCRIPTION_IDENTIFIERS_AVAILABLE:

      if (mpkt.data.connack.var_hdr.protocol_version != MQTT_VERSION_5_0)

        goto not_found_or_invalid;

      if (!mqtt_uint2str(trash, mpkt.data.connack.var_hdr.props.subscription_identifiers_available))

        goto not_found_or_invalid;

      res = ist2(trash->area, trash->data);

      goto end;

    case MQTT_FN_SHARED_SUBSCRIPTION_AVAILABLE:

      if (mpkt.data.connack.var_hdr.protocol_version != MQTT_VERSION_5_0)

        goto not_found_or_invalid;

      if (!mqtt_uint2str(trash, mpkt.data.connack.var_hdr.props.shared_subscription_available))

        goto not_found_or_invalid;

      res = ist2(trash->area, trash->data);

      goto end;

    default:

      goto not_found_or_invalid;

    }

    break;

  default:

    goto not_found_or_invalid;

  }

  end:

  return res;

  need_more:

  return ist2(istptr(msg), 0);

  not_found_or_invalid:

  return IST_NULL;

}

/* Parses a CONNECT packet :

 *   https://public.dhe.ibm.com/software/dw/webservices/ws-mqtt/mqtt-v3r1.html#connect

 *   https://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html#_Toc398718028

 *   https://docs.oasis-open.org/mqtt/mqtt/v5.0/os/mqtt-v5.0-os.html#_Toc3901033

 *

 * <parser> should point right after the MQTT fixed header. The remaining length

 * was already checked, thus missing data is an error. On success, the result of

 * the parsing is stored in <mpkt>.

 *

 * Returns:

 *  MQTT_INVALID_MESSAGE if the CONNECT message is invalid

 *  MQTT_VALID_MESSAGE   if the CONNECT message looks valid

 */

static int mqtt_parse_connect(struct ist parser, struct mqtt_pkt *mpkt)

{

  /* The parser length is stored to be sure exactly consumed the announced

   * remaining length. */

  size_t orig_len = istlen(parser);

  int ret = MQTT_INVALID_MESSAGE;

  /*

   * parsing variable header

   */

  /* read protocol_name */

  parser = mqtt_read_string(parser, &mpkt->data.connect.var_hdr.protocol_name);

  if (!isttest(parser) || !(isteqi(mpkt->data.connect.var_hdr.protocol_name, ist("MQTT")) || isteqi(mpkt->data.connect.var_hdr.protocol_name, ist("MQIsdp"))))

    goto end;

  /* read protocol_version */

  parser = mqtt_read_1byte_int(parser, &mpkt->data.connect.var_hdr.protocol_version);

  if (!isttest(parser))

    goto end;

  if (mpkt->data.connect.var_hdr.protocol_version != MQTT_VERSION_3_1 &&

      mpkt->data.connect.var_hdr.protocol_version != MQTT_VERSION_3_1_1 &&

      mpkt->data.connect.var_hdr.protocol_version != MQTT_VERSION_5_0)

    goto end;

  /* read flags */

  /* bit 1 is 'reserved' and must be set to 0 in CONNECT message flags */

  parser = mqtt_read_1byte_int(parser, &mpkt->data.connect.var_hdr.flags);

  if (!isttest(parser) || (mpkt->data.connect.var_hdr.flags & MQTT_CONNECT_FL_RESERVED))

    goto end;

  /* if WILL flag must be set to have WILL_QOS flag or WILL_RETAIN set */

  if ((mpkt->data.connect.var_hdr.flags & (MQTT_CONNECT_FL_WILL|MQTT_CONNECT_FL_WILL_QOS|MQTT_CONNECT_FL_WILL_RETAIN)) == MQTT_CONNECT_FL_WILL_QOS)

      goto end;

  /* read keepalive */

  parser = mqtt_read_2byte_int(parser, &mpkt->data.connect.var_hdr.keepalive);

  if (!isttest(parser))

    goto end;

  /* read properties, only available in MQTT_VERSION_5_0 */

  if (mpkt->data.connect.var_hdr.protocol_version == MQTT_VERSION_5_0) {

    struct ist props;

    unsigned int user_prop_idx = 0;

    uint64_t fields = 0;

    uint32_t plen = 0;

    parser = mqtt_read_varint(parser, &plen);

    if (!isttest(parser) || istlen(parser) < plen)

      goto end;

    props  = ist2(istptr(parser), plen);

    parser = istadv(parser, props.len);

    while (istlen(props) > 0) {

      switch (*istptr(props)) {

      case MQTT_PROP_SESSION_EXPIRY_INTERVAL:

        if (fields & MQTT_FN_BIT_SESSION_EXPIRY_INTERVAL)

          goto end;

        props = mqtt_read_4byte_int(istnext(props), &mpkt->data.connect.var_hdr.props.session_expiry_interval);

        fields |= MQTT_FN_BIT_SESSION_EXPIRY_INTERVAL;

        break;

      case MQTT_PROP_RECEIVE_MAXIMUM:

        if (fields & MQTT_FN_BIT_RECEIVE_MAXIMUM)

          goto end;

        props = mqtt_read_2byte_int(istnext(props), &mpkt->data.connect.var_hdr.props.receive_maximum);

        /* cannot be 0 */

        if (!mpkt->data.connect.var_hdr.props.receive_maximum)

          goto end;

        fields |= MQTT_FN_BIT_RECEIVE_MAXIMUM;

        break;

      case MQTT_PROP_MAXIMUM_PACKET_SIZE:

        if (fields & MQTT_FN_BIT_MAXIMUM_PACKET_SIZE)

          goto end;

        props = mqtt_read_4byte_int(istnext(props), &mpkt->data.connect.var_hdr.props.maximum_packet_size);

        /* cannot be 0 */

        if (!mpkt->data.connect.var_hdr.props.maximum_packet_size)

          goto end;

        fields |= MQTT_FN_BIT_MAXIMUM_PACKET_SIZE;

        break;

      case MQTT_PROP_TOPIC_ALIAS_MAXIMUM:

        if (fields & MQTT_FN_BIT_TOPIC_ALIAS_MAXIMUM)

          goto end;

        props = mqtt_read_2byte_int(istnext(props), &mpkt->data.connect.var_hdr.props.topic_alias_maximum);

        fields |= MQTT_FN_BIT_TOPIC_ALIAS_MAXIMUM;

        break;

      case MQTT_PROP_REQUEST_RESPONSE_INFORMATION:

        if (fields & MQTT_FN_BIT_REQUEST_RESPONSE_INFORMATION)

          goto end;

        props = mqtt_read_1byte_int(istnext(props), &mpkt->data.connect.var_hdr.props.request_response_information);

        /* can have only 2 values: 0 or 1 */

        if (mpkt->data.connect.var_hdr.props.request_response_information > 1)

          goto end;

        fields |= MQTT_FN_BIT_REQUEST_RESPONSE_INFORMATION;

        break;

      case MQTT_PROP_REQUEST_PROBLEM_INFORMATION:

        if (fields & MQTT_FN_BIT_REQUEST_PROBLEM_INFORMATION)

          goto end;

        props = mqtt_read_1byte_int(istnext(props), &mpkt->data.connect.var_hdr.props.request_problem_information);

        /* can have only 2 values: 0 or 1 */

        if (mpkt->data.connect.var_hdr.props.request_problem_information > 1)

          goto end;

        fields |= MQTT_FN_BIT_REQUEST_PROBLEM_INFORMATION;

        break;

      case MQTT_PROP_USER_PROPERTIES:

        /* if we reached MQTT_PROP_USER_PROPERTY_ENTRIES already, then

         * we start writing over the first property */

        if (user_prop_idx >= MQTT_PROP_USER_PROPERTY_ENTRIES)

          user_prop_idx = 0;

        /* read user property name and value */

        props = mqtt_read_string(istnext(props), &mpkt->data.connect.var_hdr.props.user_props[user_prop_idx].name);

        if (!isttest(props))

          goto end;

        props = mqtt_read_string(props, &mpkt->data.connect.var_hdr.props.user_props[user_prop_idx].value);

        ++user_prop_idx;

        break;

      case MQTT_PROP_AUTHENTICATION_METHOD:

        if (fields & MQTT_FN_BIT_AUTHENTICATION_METHOD)

          goto end;

        props = mqtt_read_string(istnext(props), &mpkt->data.connect.var_hdr.props.authentication_method);

        fields |= MQTT_FN_BIT_AUTHENTICATION_METHOD;

        break;

      case MQTT_PROP_AUTHENTICATION_DATA:

        if (fields & MQTT_FN_BIT_AUTHENTICATION_DATA)

          goto end;

        props = mqtt_read_string(istnext(props), &mpkt->data.connect.var_hdr.props.authentication_data);

        fields |= MQTT_FN_BIT_AUTHENTICATION_DATA;

        break;

      default:

        goto end;

      }

      if (!isttest(props))

        goto end;

    }

  }

  /* cannot have auth data without auth method */

  if (!istlen(mpkt->data.connect.var_hdr.props.authentication_method) &&

      istlen(mpkt->data.connect.var_hdr.props.authentication_data))

      goto end;

  /* parsing payload

   *

   * Content of payload is related to flags parsed above and the field order is pre-defined:

   *   Client Identifier, Will Topic, Will Message, User Name, Password

   */

  /* read client identifier */

  parser = mqtt_read_string(parser, &mpkt->data.connect.payload.client_identifier);

  if (!isttest(parser))

    goto end;

  /* read Will Properties, for MQTT v5 only

   * https://docs.oasis-open.org/mqtt/mqtt/v5.0/os/mqtt-v5.0-os.html#_Toc3901060

   */

  if ((mpkt->data.connect.var_hdr.protocol_version == MQTT_VERSION_5_0) &&

      (mpkt->data.connect.var_hdr.flags & MQTT_CONNECT_FL_WILL)) {

    struct ist props;

    unsigned int user_prop_idx = 0;

    uint64_t fields = 0;

    uint32_t plen = 0;

    parser = mqtt_read_varint(parser, &plen);

    if (!isttest(parser) || istlen(parser) < plen)