/*

 * Financial Information eXchange 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/intops.h>

#include <haproxy/fix.h>

/*

 * Return the corresponding numerical tag id if <str> looks like a valid FIX

 * protocol tag ID. Otherwise, 0 is returned (0 is an invalid id).

 *

 * If <version> is given, it must be one of a defined FIX version string (see

 * FIX_X_Y macros). In this case, the function will also check tag ID ranges. If

 * no <version> is provided, any strictly positive integer is valid.

 *

 * tag ID range depends on FIX protocol version:

 *    - FIX.4.0:    1-140

 *    - FIX.4.1:    1-211

 *    - FIX.4.2:    1-446

 *    - FIX.4.3:    1-659

 *    - FIX.4.4:    1-956

 *    - FIX.5.0:    1-1139

 *    - FIX.5.0SP1: 1-1426

 *    - FIX.5.0SP2: 1-1621

 * range 10000 to 19999 is for "user defined tags"

 */

unsigned int fix_check_id(const struct ist str, const struct ist version) {

  const char *s, *end;

  unsigned int ret;

  s = istptr(str);

  end = istend(str);

  ret = read_uint(&s, end);

  /* we did not consume all characters from <str>, this is an error */

  if (s != end)

    return 0;

  /* field ID can't be 0 */

  if (ret == 0)

    return 0;

  /* we can leave now if version was not provided */

  if (!isttest(version))

    return ret;

  /* we can leave now if this is a "user defined tag id" */

  if (ret >= 10000 && ret <= 19999)

    return ret;

  /* now perform checking per FIX version */

  if (istissame(FIX_4_0, version) && (ret <= 140))

    return ret;

  else if (istissame(FIX_4_1, version) && (ret <= 211))

    return ret;

  else if (istissame(FIX_4_2, version) && (ret <= 446))

    return ret;

  else if (istissame(FIX_4_3, version) && (ret <= 659))

    return ret;

  else if (istissame(FIX_4_4, version) && (ret <= 956))

    return ret;

  /* version string is the same for all 5.0 versions, so we can only take

   * into consideration the biggest range

   */

  else if (istissame(FIX_5_0, version) && (ret <= 1621))

    return ret;

  return 0;

}

/*

 * Parse a FIX message <msg> and performs following sanity checks:

 *

 *   - checks tag ids and values are not empty

 *   - checks tag ids are numerical value

 *   - checks the first tag is BeginString with a valid version

 *   - checks the second tag is BodyLength with the right body length

 *   - checks the third tag is MsgType

 *   - checks the last tag is CheckSum with a valid checksum

 *

 * Returns:

 *  FIX_INVALID_MESSAGE if the message is invalid

 *  FIX_NEED_MORE_DATA  if we need more data to fully validate the message

 *  FIX_VALID_MESSAGE   if the message looks valid

 */

int fix_validate_message(const struct ist msg)

{

  struct ist parser, version;

  unsigned int tagnum, bodylen;

  unsigned char checksum;

  char *body;

  int ret = FIX_INVALID_MESSAGE;

  if (istlen(msg) < FIX_MSG_MINSIZE) {

    ret = FIX_NEED_MORE_DATA;

    goto end;

  }

  /* parsing the whole message to compute the checksum and check all tag

   * ids are properly set. Here we are sure to have the 2 first tags. Thus

   * the version and the body length can be checked.

   */

  parser = msg;

  version = IST_NULL;

  checksum = tagnum = bodylen = 0;

  body = NULL;

  while (istlen(parser) > 0) {

    struct ist tag, value;

    unsigned int tagid;

    const char *p, *end;

    /* parse the tag ID and its value and perform first sanity checks */

    value = iststop(istfind(parser, '='), FIX_DELIMITER);

    /* end of value not found */

    if (istend(value) == istend(parser)) {

      ret = FIX_NEED_MORE_DATA;

      goto end;

    }

    /* empty tag or empty value are forbidden */

    if (istptr(parser) == istptr(value) ||!istlen(value))

      goto end;

    /* value points on '='. get the tag and skip '=' */

    tag = ist2(istptr(parser), istptr(value) - istptr(parser));

    value = istnext(value);

    /* Check the tag id */

    tagid = fix_check_id(tag, version);

    if (!tagid)

      goto end;

    tagnum++;

    if (tagnum == 1) {

      /* the first tag must be BeginString */

      if (tagid != FIX_TAG_BeginString)

        goto end;

      version = fix_version(value);

      if (!isttest(version))

        goto end;

    }

    else if (tagnum == 2) {

      /* the second tag must be bodyLength */

      if (tagid != FIX_TAG_BodyLength)

        goto end;

      p = istptr(value);

      end = istend(value);

      bodylen = read_uint(&p, end);

      /* we did not consume all characters from <str> or no body, this is an error.

       * There is at least the message type in the body.

       */

      if (p != end || !bodylen)

        goto end;

      body = istend(value) + 1;

    }

    else if (tagnum == 3) {

      /* the third tag must be MsgType */

      if (tagid != FIX_TAG_MsgType)

        goto end;

    }

    else if (tagnum > 3 && tagid == FIX_TAG_CheckSum) {

      /* CheckSum tag should be the last one and is not taken into account

       * to compute the checksum itself and the body length. The value is

       * a three-octet representation of the checksum decimal value.

       */

      if (bodylen != istptr(parser) - body)

        goto end;

      if (istlen(value) != 3)

        goto end;

      if (checksum != strl2ui(istptr(value), istlen(value)))

        goto end;

      /* End of the message, exit from the loop */

      ret = FIX_VALID_MESSAGE;

      goto end;

    }

    /* compute checksum of tag=value<delim> */

    for (p = istptr(tag) ; p < istend(tag) ; ++p)

      checksum += *p;

    checksum += '=';

    for (p = istptr(value) ; p < istend(value) ; ++p)

      checksum += *p;

    checksum += FIX_DELIMITER;

    /* move the parser after the value and its delimiter */

    parser = istadv(parser, istlen(tag) + istlen(value) + 2);

  }

  if (body) {

    /* We start to read the body but we don't reached the checksum tag */

    ret = FIX_NEED_MORE_DATA;

  }

  end:

  return ret;

}

/*

 * Iter on a FIX message <msg> and return the value of <tagid>.

 *

 * Returns the corresponding value if <tagid> is found. If <tagid> is not found

 * because more data are required, the message with a length set to 0 is

 * returned. If <tagid> is not found in the message or if the message is

 * invalid, IST_NULL is returned.

 *

 * Note: Only simple sanity checks are performed on tags and values (not empty).

 *

 * the tag looks like

 *   <tagid>=<value>FIX_DELIMITER with <tag> and <value> not empty

 */

struct ist fix_tag_value(const struct ist msg, unsigned int tagid)

{

  struct ist parser, t, v;

  unsigned int id;

  parser = msg;

  while (istlen(parser) > 0) {

    v  = iststop(istfind(parser, '='), FIX_DELIMITER);

    /* delimiter not found, need more data */

    if (istend(v) == istend(parser))

      break;

    /* empty tag or empty value, invalid */

    if (istptr(parser) == istptr(v) || !istlen(v))

      goto not_found_or_invalid;

    t = ist2(istptr(parser), istptr(v) - istptr(parser));

    v = istnext(v);

    id = fix_check_id(t, IST_NULL);

    if (!id)

      goto not_found_or_invalid;

    if (id == tagid) {

      /* <tagId> found, return the corresponding value */

      return v;

    }

    /* CheckSum tag is the last one, no <tagid> found */

    if (id == FIX_TAG_CheckSum)

      goto not_found_or_invalid;

    parser = istadv(parser, istlen(t) + istlen(v) + 2);

  }

  /* not enough data to find <tagid> */

  return ist2(istptr(msg), 0);

  not_found_or_invalid:

  return IST_NULL;

}