开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > TAPI编程 > 查看源码
fastapi.c
资源名称：fastapi-1.0.zip　[点击查看]
上传用户：myichia
上传日期：2019-01-05
资源大小：217k
文件大小：34k
源码类别：

TAPI编程

开发平台：

C/C++

fastapi.c：源码内容
  1. // $Id: fastapi.c,v 1.2 2006/02/09 19:14:24 Daniel.May Exp $
  2. //
  3. // FIX Adapted for STreaming (sm) (FAST Protocol (sm)) 
  4. //
  5. // Copyright (c) 2005-2006, Pantor Engineering AB (http://www.pantor.com)
  6. // Copyright (c) 2005-2006, SpryWare LLC (http://www.spryware.com)
  7. // Copyright (c) 2005-2006, FIX Protocol Ltd (http://www.fixprotocol.org)
  8. // All Rights Reserved.
  9. //
  10. // This work is distributed under the W3C® Software License [1] in the
  11. // hope that it will be useful, but WITHOUT ANY WARRANTY; without even the
  12. // implied warranty of MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS 
  13. // FOR A PARTICULAR PURPOSE.
  14. //
  15. // [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231
  16. // [FPL's Intellectual Property details] http://www.fixprotocol.org/ip
  17. // [FAST Protocol details] http://www.fixprotocol.org/fast
  18. // [FAST Protocol credits] http://fixprotocol.org/fastcredits
  20. #include "common.h"
  21. #include "fastapi.h"
  23. //////////////////////////////////////////////////////////////////////
  25. static void reset_buffer (fast_buffer_t* buffer)
  26. {
  27.    buffer->head = buffer->data;
  28.    buffer->tail = buffer->data;
  29.    buffer->end  = buffer->data + sizeof (buffer->data);
  30. }
  32. static void init_buffer (fast_buffer_t* buffer, int fd)
  33. {
  34.    reset_buffer (buffer);
  36.    buffer->fd = fd;
  37. }
  39. static inline int buffer_empty_p (fast_buffer_t* buffer)
  40. {
  41.    return buffer->head >= buffer->tail;
  42. }
  44. static inline int get_buffer_left (fast_buffer_t* buffer)
  45. {
  46.    return buffer->end - buffer->tail;
  47. }
  49. static inline int get_buffer_size (fast_buffer_t* buffer)
  50. {
  51.    return buffer->end - buffer->data;
  52. }
  54. static inline int get_buffer_used (fast_buffer_t* buffer)
  55. {
  56.    return buffer->tail - buffer->head;
  57. }
  59. //////////////////////////////////////////////////////////////////////
  61. static inline u32 get_tag_op (u32 tag)
  62. {
  63.    return (tag >> TAG_SHIFT_OP) & TAG_MAX_OP;
  64. }
  66. static inline u32 get_tag_slot (u32 tag)
  67. {
  68.    return (tag >> TAG_SHIFT_SLOT) & TAG_MAX_SLOT;
  69. }
  71. static inline u32 get_tag_tid (u32 tag)
  72. {
  73.    return (tag >> TAG_SHIFT_TID) & TAG_MAX_TID;
  74. }
  76. static inline u32 get_tag_type (u32 tag)
  77. {
  78.    return (tag >> TAG_SHIFT_TYPE) & TAG_MAX_TYPE;
  79. }
  81. static inline fast_cv_t* cv_get_tag_state (fast_codec_t* codec, u32 tag)
  82. {
  83.    u32 slot = get_tag_tid (tag);
  85.    return & codec->cv [slot];
  86. }
  88. static inline i32* cv_get_i32_values (fast_codec_t* codec, u32 tag)
  89. {
  90.    return cv_get_tag_state (codec, tag)->i32_values;
  91. }
  93. static inline u32* cv_get_u32_values (fast_codec_t* codec, u32 tag)
  94. {
  95.    return cv_get_tag_state (codec, tag)->u32_values;
  96. }
  98. static inline u8** cv_get_str_values (fast_codec_t* codec, u32 tag)
  99. {
  100.    return cv_get_tag_state (codec, tag)->str_values;
  101. }
  103. static inline u32* cv_get_valid_values (fast_codec_t* codec, u32 tag)
  104. {
  105.    return cv_get_tag_state (codec, tag)->valid;
  106. }
  108. //////////////////////////////////////////////////////////////////////
  110. static inline i32 cv_get_i32 (fast_codec_t* codec, u32 tag)
  111. {
  112.    return cv_get_i32_values (codec, tag) [get_tag_slot (tag)];
  113. }
  115. static inline u32 cv_get_u32 (fast_codec_t* codec, u32 tag)
  116. {
  117.    return cv_get_u32_values (codec, tag) [get_tag_slot (tag)];
  118. }
  120. static inline u8* cv_get_str (fast_codec_t* codec, u32 tag)
  121. {
  122.    u8** str_values = cv_get_str_values (codec, tag);
  123.    u32 slot = get_tag_slot (tag);
  125.    if (str_values [slot] == NULL)
  126.    {
  127.       str_values [slot] = malloc (1024);
  128.       assert (str_values [slot] != NULL);
  129.       strcpy ((char*) str_values [slot], "");
  130.    }
  132.    return str_values [slot];
  133. }
  135. //////////////////////////////////////////////////////////////////////
  137. static inline void cv_set_valid (fast_codec_t* codec, u32 tag)
  138. {
  139.    cv_get_valid_values (codec, tag) [get_tag_slot (tag)] = 1;
  140. }
  142. static inline int cv_is_valid (fast_codec_t* codec, u32 tag)
  143. {
  144.    return cv_get_valid_values (codec, tag) [get_tag_slot (tag)] != 0;
  145. }
  147. //////////////////////////////////////////////////////////////////////
  149. static inline int cv_eq_i32 (fast_codec_t* codec, u32 tag, i32 data)
  150. {
  151.    return cv_is_valid (codec, tag) && cv_get_i32 (codec, tag) == data;
  152. }
  154. static inline int cv_eq_u32 (fast_codec_t* codec, u32 tag, u32 data)
  155. {
  156.    return cv_is_valid (codec, tag) && cv_get_u32 (codec, tag) == data;
  157. }
  159. static inline int cv_eq_str (fast_codec_t* codec, u32 tag, u8* data, int size)
  160. {
  161.    u8* cp = cv_get_str (codec, tag);
  163.    // Invalid or not the same length
  164.    // Fixme: cp [size] != '' not a valid test?
  165.    if (cv_is_valid (codec, tag) == 0 || cp [size] != '')
  166.       return 0;
  168.    return memcmp (cp, data, size) == 0;
  169. }
  171. //////////////////////////////////////////////////////////////////////
  173. //! @brief Set the current signed integer value for the specified tag
  175. static inline void cv_set_i32 (fast_codec_t* codec, u32 tag, i32 data)
  176. {
  177.    cv_get_i32_values (codec, tag) [get_tag_slot (tag)] = data;
  178.    cv_set_valid (codec, tag);
  179. }
  181. //! @brief Set the current unsigned integer value for the specified tag
  183. static inline void cv_set_u32 (fast_codec_t* codec, u32 tag, u32 data)
  184. {
  185.    cv_get_u32_values (codec, tag) [get_tag_slot (tag)] = data;
  186.    cv_set_valid (codec, tag);
  187. }
  189. //! @brief Set the current string value for the specified tag
  191. static inline void cv_set_str (fast_codec_t* codec, u32 tag,
  192.                                u8* data, int size)
  193. {
  194.    u8* cp = cv_get_str (codec, tag);
  196.    memcpy (cp, data, size);
  197.    cp [size] = '';
  199.    cv_set_valid (codec, tag);
  200. }
  201. //////////////////////////////////////////////////////////////////////
  203. static int u32_to_size (u32 data)
  204. {
  205.    if (data < 0x00000080) return 1; // 128
  206.    if (data < 0x00004000) return 2; // 16384
  207.    if (data < 0x00200000) return 3; // 2097152
  208.    if (data < 0x10000000) return 4; // 268435456
  210.    return 5;
  211. }
  213. static int i32_to_size (i32 data)
  214. {
  215.    if (data < 0)
  216.    {
  217.       if (data >= 0xffffffc0) return 1; // -64
  218.       if (data >= 0xffffe000) return 2; // -8192
  219.       if (data >= 0xfff00000) return 3; // -1048576
  220.       if (data >= 0xf8000000) return 4; // -124317728
  221.    }
  222.    else
  223.    {
  224.       if (data <  0x00000040) return 1; // 64
  225.       if (data <  0x00002000) return 2; // 8192
  226.       if (data <  0x00100000) return 3; // 1048576
  227.       if (data <  0x08000000) return 4; // 134217728
  228.    }
  229.    return 5;
  230. }
  232. //////////////////////////////////////////////////////////////////////
  234. static const char* format_error_code (fast_error_t code)
  235. {
  236.    switch (code)
  237.    {
  238.     case FAST_ERR_NONE:     return "none";
  239.     case FAST_ERR_CODEC:    return "bad codec";
  240.     case FAST_ERR_SIZE:     return "size error";
  241.     case FAST_ERR_VALUE:    return "missing value";
  242.     case FAST_ERR_TAG_OP:   return "tag op unsupported";
  243.     case FAST_ERR_TAG_TYPE: return "bad tag type";
  244.     case FAST_ERR_CALL_SEQ: return "bad call sequence";
  245.     case FAST_ERR_IO:       return "I/O library error";
  246.     default:                return "??";
  247.    }
  248. }
  250. static const char* format_tag_op (fast_op_t op)
  251. {
  252.    static char buffer [32];
  254.    switch (op)
  255.    {
  256.     case FAST_OP_NONE:  return "NONE";
  257.     case FAST_OP_COPY:  return "COPY";
  258.     case FAST_OP_INCR:  return "INCR";
  259.     case FAST_OP_DELTA: return "DELTA";
  261.     default:
  262.       snprintf (buffer, sizeof (buffer), "%u", op);
  263.       return buffer;
  264.    }
  265. }
  267. static const char* format_tag_type (fast_type_t type)
  268. {
  269.    static char buffer [32];
  271.    switch (type)
  272.    {
  273.     case FAST_TYPE_NULL: return "NULL";
  274.     case FAST_TYPE_U32:  return "U32";
  275.     case FAST_TYPE_I32:  return "I32";
  276.     case FAST_TYPE_STR:  return "STR";
  278.     default:
  279.       snprintf (buffer, sizeof (buffer), "%u", type);
  280.       return buffer;
  281.    }
  282. }
  284. //////////////////////////////////////////////////////////////////////
  286. static int set_err (const char* fn, fast_codec_t* codec,
  287.                      fast_tag_t tag, fast_error_t code,
  288.                      const char* format, ...)
  289. {
  290.    char buffer [1024];
  291.    va_list ap;
  293.    codec->error->fn   = fn;
  294.    codec->error->tag  = tag;
  295.    codec->error->code = code;
  297.    va_start (ap, format);
  298.    vsnprintf (buffer, sizeof (buffer), format, ap);
  299.    va_end   (ap);
  301.    if (codec->error->text != NULL)
  302.       free (codec->error->text);
  304.    codec->error->text = malloc (strlen (buffer) + 1);
  305.    strcpy (codec->error->text, buffer);
  307.    if (codec->verbose >= 1)
  308.       fprintf (stderr, "error: %sn", fast_error_string (codec));
  310.    return -1;
  311. }
  313. static int check_codec (const char* fn, fast_codec_t* codec)
  314. {
  315.    if (codec == NULL)
  316.    {
  317.       fprintf (stderr, "error: [%s] NULL codecn", fn);
  318.       return -1;
  319.    }
  320.    if (codec->magic != FAST_CODEC_MAGIC)
  321.       return set_err (fn, codec, -1, FAST_ERR_CODEC,
  322.                       "bad codec magic number");
  324.    return 0;
  325. }
  327. static int check_type (const char* fn, fast_codec_t* codec,
  328.                        fast_tag_t tag, u32 type)
  329. {
  330.    if (get_tag_type (tag) != type)
  331.       return set_err (fn, codec, tag, FAST_ERR_TAG_TYPE,
  332.                       "type=%s (%s expected)",
  333.                       format_tag_type (get_tag_type (tag)),
  334.                       format_tag_type (type));
  336.    return 0;
  337. }
  339. static int bad_op_error (const char* fn, fast_codec_t* codec, fast_tag_t tag)
  340. {
  341.    return set_err (fn, codec, tag, FAST_ERR_TAG_OP, "");
  342. }
  343.                                 
  344. static int value_error (const char* fn, fast_codec_t* codec, fast_tag_t tag)
  345. {
  346.    return set_err (fn, codec, tag, FAST_ERR_VALUE, "");
  347. }
  349. //! @brief Generate an error string using the current error info
  351. const char* fast_error_string (fast_codec_t* codec)
  352. {
  353.    fast_tag_t tag = codec->error->tag;
  355.    static char buffer [1024];
  357.    snprintf (buffer, sizeof (buffer), "[%s] %s|%s|%u|%u %s: %s",
  358.              codec->error->fn,
  359.              format_tag_type (get_tag_type (tag)),
  360.              format_tag_op (get_tag_op (tag)),
  361.              get_tag_tid (tag),
  362.              get_tag_slot (tag),
  363.              format_error_code (codec->error->code),
  364.              codec->error->text ? codec->error->text : "");
  366.    return buffer;
  367. }
  369. int fast_print_error (fast_codec_t* codec, FILE* fp)
  370. {
  371.    const char* msg = fast_error_string (codec);
  373.    fprintf (fp, "%sn", msg);
  374.    return 0;
  375. }
  377. //////////////////////////////////////////////////////////////////////
  379. //! @brief Get a presence bit from the current presence map
  381. static int get_pmap (fast_codec_t* codec, fast_tag_t tag)
  382. {
  383.    u32 pos = get_tag_slot (tag);
  385.    // Optimization: Don't range check pos separately
  386.    // We only need to check for the current size.
  387.    if (pos >= codec->pmap->size)
  388.       return 0;
  390.    return codec->pmap->bits [pos];
  391. }
  393. //! @brief Reset the current presence map
  395. static void reset_pmap (fast_codec_t* codec)
  396. {
  397.    // Fixme: Consider memset'ing to max_pos.
  398.    memset (codec->pmap->bits, 0, MAX_PMAP_BITS);
  399.    codec->pmap->max_pos = 0;
  400. }
  402. //! @brief Set a presence bit in the current presence map
  404. static int set_pmap (fast_codec_t* codec, fast_tag_t tag)
  405. {
  406.    u32 pos = get_tag_slot (tag);
  408.    if (pos > codec->pmap->max_pos)
  409.    {
  410.       // Optimization: Only range check pos if pos
  411.       // is larger than the current max_pos
  412.       if (pos >= MAX_PMAP_BITS)
  413.          return set_err (FUNCTION, codec, tag, FAST_ERR_SIZE,
  414.                          "pmap slot=%d (< %d expected)",
  415.                          pos, MAX_PMAP_BITS);
  417.       codec->pmap->max_pos = pos;
  418.    }
  419.    codec->pmap->bits [pos] = 1;
  420.    return 0;
  421. }
  423. static u32 bit_mask [8] = { 64, 32, 16, 8, 4, 2, 1, 0 };
  425. // emit_pmap copies the pmap into the data buffer
  426. // and returns the size of the pmap
  428. //! Serialize the current presence map
  430. static int emit_pmap (fast_codec_t* codec, u8* data)
  431. {
  432.    int bytes = align7 (codec->pmap->max_pos + 1); // get map size in bytes
  433.    int offset;
  434.    int p1;
  436.    // pack slots from map->bits (seven at a time) into
  437.    // data to form a STOP bit coded field.
  439.    for (p1 = 0, offset = 0 ; p1 < bytes ; p1 ++, offset += 7)
  440.    {
  441.       u8* bits = & codec->pmap->bits [offset];
  442.       u32 temp = 0;
  443.       int p2;
  445.       for (p2 = 0 ; p2 < 7 ; p2 ++) // pack 7 slot into temp
  446.       {
  447.          if (bits [p2] > 0)
  448.             temp |= bit_mask [p2];
  449.       }
  451.       data [p1] = temp;
  452.    }
  454.    data [bytes - 1] |= 0x80; // Set the STOP bit
  455.    return bytes;
  456. }
  458. //////////////////////////////////////////////////////////////////////
  460. //! @brief Append a byte to the message buffer
  462. static inline void emit_byte (fast_codec_t* codec, u8 data)
  463. {
  464.    *codec->msg->tail ++ = data;
  465. }
  467. //////////////////////////////////////////////////////////////////////
  469. //! @brief Verify that there is enough room in the output buffer
  470. //! to store size bytes of data into the buffer.
  472. static inline  int check_msg_avail (const char* fn, fast_codec_t* codec,
  473.                                     fast_tag_t tag, int size)
  474. {
  475.    if (get_buffer_left (codec->msg) < size)
  476.       return set_err (fn, codec, tag, FAST_ERR_SIZE,
  477.                       "message buffer overflow avail=%d needed=%d",
  478.                       get_buffer_left (codec->msg), size);
  479.    return 0;
  480. }
  482. //! @callgraph
  484. //! @brief Serialize a 32-bit signed integer field
  486. static int emit_i32 (fast_codec_t* codec, fast_tag_t tag, i32 data)
  487. {
  488.    int size = i32_to_size (data);
  490.    // Check buffer space once, not for every byte
  491.    if (check_msg_avail (FUNCTION, codec, tag, size) < 0)
  492.       return -1;
  494.    switch (size)
  495.    {
  496.       // Shifts are arithmetic (signed)
  497.       // The sign bit of data will be copied on right shifts
  498.     case 5: emit_byte (codec, (data >> 28) & 0x7f);
  499.     case 4: emit_byte (codec, (data >> 21) & 0x7f);
  500.     case 3: emit_byte (codec, (data >> 14) & 0x7f);
  501.     case 2: emit_byte (codec, (data >>  7) & 0x7f);
  502.     case 1: emit_byte (codec, (data & 0x7f) | 0x80);
  503.       {
  504.          int code = set_pmap (codec, tag);
  506.          if (code < 0)
  507.             return code;
  508.       }
  509.       return size;
  511.     default:
  512.       return set_err (FUNCTION, codec, tag, FAST_ERR_SIZE,
  513.                       "size=%d data=%d (%08x)", size, data, data);
  514.    }
  515. }
  517. //! @brief Serielize a 32-bit unsigned integer field
  519. static int emit_u32 (fast_codec_t* codec, fast_tag_t tag, u32 data)
  520. {
  521.    int size = u32_to_size (data);
  523.    // Check buffer space once, not for every byte
  524.    if (check_msg_avail (FUNCTION, codec, tag, size) < 0)
  525.       return -1;
  527.    switch (size)
  528.    {
  529.       // Shifts are logical (unsigned)
  530.     case 5: emit_byte (codec,  data >> 28);
  531.     case 4: emit_byte (codec, (data >> 21) & 0x7f);
  532.     case 3: emit_byte (codec, (data >> 14) & 0x7f);
  533.     case 2: emit_byte (codec, (data >>  7) & 0x7f);
  534.     case 1: emit_byte (codec, (data & 0x7f) | 0x80);
  535.       {
  536.          int code = set_pmap (codec, tag);
  538.          if (code < 0)
  539.             return code;
  540.       }
  541.       return size;
  543.     default:
  544.       return set_err (FUNCTION, codec, tag, FAST_ERR_SIZE,
  545.                       "size=%d data=%d (%08x)", size, data, data);
  546.    }
  547. }
  549. //! @brief Serialize an ASCII string field
  551. static int emit_str (fast_codec_t* codec, fast_tag_t tag, u8* data, int size)
  552. {
  553.    // Zero length strings cannot be encoded
  554.    if (size <= 0)
  555.       return set_err (FUNCTION, codec, tag, FAST_ERR_SIZE,
  556.                       "size=%d (>0 expected)", size);
  558.    // Check buffer space once, not for every byte
  559.    if (check_msg_avail (FUNCTION, codec, tag, size) < 0)
  560.       return -1;
  562.    {
  563.       int p1;
  565.       for (p1 = 0 ; p1 < size - 1 ; p1 ++)
  566.          emit_byte (codec, data [p1]);
  568.       emit_byte (codec, data [p1] | 0x80); // Last byte
  569.    }
  571.    {
  572.       int code = set_pmap (codec, tag);
  574.       if (code < 0)
  575.          return code;
  576.    }
  577.    return size;
  578. }
  580. //////////////////////////////////////////////////////////////////////
  582. //! @brief Deserialize an SBIT coded field
  584. static int parse_bytes (fast_codec_t* codec, u8* data, int size)
  585. {
  586.    int p1;
  588.    // Fixme: Filler may be other than space?
  589.    memset (data, 0, size);
  591.    for (p1 = 0 ; p1 < size ; p1 ++)
  592.    {
  593.       u8 temp;
  595.       fast_buffer_t* input = codec->input;
  597.       if (buffer_empty_p (input))
  598.       {
  599.          int bytes;
  601.          if (codec->skip_io == 1)
  602.             return -1;
  604.          bytes = read (input->fd, input->data, get_buffer_size (input));
  606.          if (bytes <= 0)
  607.          {
  608.             if (bytes < 0)
  609.                fprintf (stderr, "read failed: %sn", strerror (errno));
  611.             return -1;
  612.          }
  614.          input->head = input->data;
  615.          input->tail = input->head + bytes;
  617.       }
  618.       temp = *input->head ++;
  620.       data [p1] = temp;
  622.       if (temp >= 0x80)
  623.       {
  624.          data [p1] &= 0x7f;
  625.          return p1 + 1;
  626.       }
  627.    }
  629.    // Fixme: calculate the real number of bytes in the field.
  631.    return set_err (FUNCTION, codec, -1, FAST_ERR_SIZE,
  632.                    "parse buffer overflow size=%d", size);
  633. }
  635. static int parse_pmap (fast_codec_t* codec)
  636. {
  637.    fast_pmap_t* pmap = codec->pmap;
  639.    u8  data [MAX_PMAP_BYTES];
  641.    int bytes = parse_bytes (codec, data, MAX_PMAP_BYTES);
  642.    int offset;
  643.    int p1;
  645.    if (bytes < 0)
  646.       return bytes;
  648.    for (p1 = 0, offset = 0 ; p1 < bytes ; p1 ++, offset += 7)
  649.    {
  650.       u32 temp = data [p1];
  651.       int p2;
  653.       for (p2 = 0 ; p2 < 7 ; p2 ++)
  654.       {
  655.          pmap->bits [offset + p2] = (temp & bit_mask [p2]) != 0;
  656.       }
  657.    }
  659.    codec->pmap->size = 7 * bytes;
  660.    return bytes;
  661. }
  663. #define SIGN_MASK_I32 0x40
  664. #define SIGN_MASK_U32 0x00
  666. static int parse_32 (fast_codec_t* codec, fast_tag_t tag,
  667.                      u32* data, int sign_mask)
  668. {
  669.    u8  buffer [5];
  670.    int bytes;
  671.    int p1;
  672.    i32 temp;
  674.    if (get_pmap (codec, tag) == 0)
  675.       return 0;
  677.    bytes = parse_bytes (codec, buffer, sizeof (buffer));
  679.    if (bytes < 0)
  680.       return bytes;
  682.    temp = 0 - ((buffer [0] & sign_mask) != 0);
  684.    for (p1 = 0 ; p1 < bytes ; p1 ++)
  685.       temp = (temp << 7) | buffer [p1];
  687.    *data = temp;
  688.    return bytes;
  689. }
  691. //////////////////////////////////////////////////////////////////////
  693. //! @brief Deserialize a 32-bit unsigned integer
  695. static int parse_u32 (fast_codec_t* codec, fast_tag_t tag, u32* data)
  696. {
  697.    return parse_32 (codec, tag, data, SIGN_MASK_U32);
  698. }
  700. //! @brief Deserialize a 32-bit signed integer
  702. static int parse_i32 (fast_codec_t* codec, fast_tag_t tag, i32* data)
  703. {
  704.    return parse_32 (codec, tag, (u32*) data, SIGN_MASK_I32);
  705. }
  707. //! @brief Deserialize an ASCII string
  709. static int parse_str (fast_codec_t* codec, fast_tag_t tag, u8* data, int size)
  710. {
  711.    return get_pmap (codec, tag) == 0 ? 0 : parse_bytes (codec, data, size);
  712. }
  714. //////////////////////////////////////////////////////////////////////
  715. // Decoder functions
  717. //! @brief Start decoding a message
  718. //! Parse the presence map
  720. int fast_decode_new_msg (fast_codec_t* codec, fast_tag_t tag)
  721. {
  722.    if (check_codec (FUNCTION, codec) < 0)
  723.       return -1;
  725.    return parse_pmap (codec);
  726. }
  728. //! @brief Finish decoding a message
  730. int fast_decode_end_msg (fast_codec_t* codec, fast_tag_t tag)
  731. {
  732.    if (check_codec (FUNCTION, codec) < 0)
  733.       return -1;
  735.    return 0;
  736. }
  738. //////////////////////////////////////////////////////////////////////
  740. //! @brief Decode an ASCII string
  742. int fast_decode_str (fast_codec_t* codec, fast_tag_t tag,
  743.                      u8* data, int size)
  744. {
  745.    fast_op_t op = get_tag_op (tag);
  747.    int bytes;
  749.    if (check_codec (FUNCTION, codec) < 0)
  750.       return -1;
  752.    if (check_type  (FUNCTION, codec, tag, FAST_TYPE_STR) < 0)
  753.       return -1;
  755. #if 0
  756.    // Fixme: Remove arbitrary limit
  757.    if (size <= 0 || size >= 1024)
  758.       return set_err (FUNCTION, codec, tag, FAST_ERR_SIZE,
  759.                       "size=%d (1-1023 expected)", size);
  760. #endif
  762.    switch (op)
  763.    {
  764.     case FAST_OP_NONE:
  765.       bytes = parse_str (codec, tag, data, size);
  767.       if (bytes < 0) // End of input
  768.          return -1;
  770.       if (bytes == 0)
  771.          return value_error (FUNCTION, codec, tag);
  773.       break;
  775.     case FAST_OP_COPY:
  776.       bytes = parse_str (codec, tag, data, size);
  778.       if (bytes < 0)
  779.          return -1;
  781.       if (bytes > 0)
  782.       {
  783.          // Set current value
  784.          cv_set_str (codec, tag, data, size);
  785.       }
  786.       else
  787.       {
  788.          // Copy current value
  789.          memcpy (data, cv_get_str (codec, tag), size);
  790.       }
  791.       return size;
  793.     case FAST_OP_INCR:
  794.       return bad_op_error (FUNCTION, codec, tag);
  796.     case FAST_OP_DELTA:
  797.       {
  798.          u8  buffer [1024];
  799.          u8* curr = cv_get_str (codec, tag);
  801.          u32 bytes = parse_str (codec, tag, buffer, size);
  803.          if (cv_is_valid (codec, tag))
  804.          {
  805.             int temp;
  807.             if (bytes > (u32)size)
  808.                return set_err (FUNCTION, codec, tag, FAST_ERR_SIZE,
  809.                                "oversized value %d > size=%d", bytes, size);
  811.             // This implementation requires delta string field values
  812.             // to be exactly the size of the field.
  814.             temp = strlen ((char*) curr);
  816.             if (temp != size)
  817.                return set_err (FUNCTION, codec, tag, FAST_ERR_SIZE,
  818.                                "size mismatch %d != %d", temp, size);
  820.             // Replace (tail of) current value
  821.             memcpy (curr + size - bytes, buffer, bytes);
  822.          }
  823.          else
  824.          {
  825.             // Set current value
  826.             cv_set_str (codec, tag, buffer, bytes);
  827.          }
  829.          memcpy (data, cv_get_str (codec, tag), size);
  830.       }
  831.       break;
  833.     default:
  834.       bad_op_error (FUNCTION, codec, tag);
  835.    }
  836.    return 0;
  837. }
  839. //////////////////////////////////////////////////////////////////////
  841. //! @brief Decode a 32-bit signed integer
  843. int fast_decode_i32 (fast_codec_t* codec, fast_tag_t tag, i32* value)
  844. {
  845.    fast_op_t op = get_tag_op (tag);
  847.    i32 temp = 0;
  848.    int bytes;
  850.    if (check_codec (FUNCTION, codec) < 0)
  851.       return -1;
  853.    if (check_type  (FUNCTION, codec, tag, FAST_TYPE_I32) < 0)
  854.       return -1;
  856.    switch (op)
  857.    {
  858.     case FAST_OP_NONE: // Value must be present
  859.       bytes = parse_i32 (codec, tag, & temp);
  861.       if (bytes > 0)
  862.       {
  863.          cv_set_i32 (codec, tag, temp);
  864.          break;
  865.       }
  867.       if (bytes < 0) // End of input
  868.          return -1;
  870.       return value_error (FUNCTION, codec, tag);
  872.     case FAST_OP_COPY: // Use previous value if not present
  873.       bytes = parse_i32 (codec, tag, & temp);
  875.       if (bytes == 0) // No value - use previous [common case]
  876.          break;
  878.       if (bytes < 0) // End of input
  879.          return -1;
  881.       cv_set_i32 (codec, tag, temp);
  882.       break;
  884.     case FAST_OP_INCR: // Use previous value plus one if not present
  885.       bytes = parse_i32 (codec, tag, & temp);
  887.       if (bytes < 0) // End of input
  888.          return -1;
  890.       if (bytes == 0) // No value - use previous plus one
  891.       {
  892.          // Rule: The previous value must be valid
  893.          if (cv_is_valid (codec, tag) == 0)
  894.             return value_error (FUNCTION, codec, tag);
  896.          temp = cv_get_i32 (codec, tag) + 1;
  897.       }
  899.       cv_set_i32 (codec, tag, (u32) temp);
  900.       break;
  902.     case FAST_OP_DELTA:
  903.       if (cv_is_valid (codec, tag))
  904.       {
  905.          // Rule: delta defaults to ZERO if there is
  906.          // no value present
  908.          i32 delta;
  910.          bytes = parse_i32 (codec, tag, & delta);
  912.          if (bytes < 0) // error state already set
  913.             return -1;
  915.          if (bytes > 0)
  916.          {
  917.             temp = cv_get_i32 (codec, tag) + delta;
  918.             cv_set_i32 (codec, tag, temp);
  919.          }
  920.       }
  921.       else
  922.       {
  923.          // Rule: A field must be present it the
  924.          // current value isn't valid
  926.          bytes = parse_i32 (codec, tag, & temp);
  928.          if (bytes < 0) // error state already set
  929.             return -1;
  931.          if (bytes == 0)
  932.             return value_error (FUNCTION, codec, tag);
  934.          cv_set_i32 (codec, tag, temp);
  935.       }
  936.       break;
  938.     default:
  939.       return bad_op_error (FUNCTION, codec, tag);
  940.    }
  942.    *value = cv_get_i32 (codec, tag);
  943.    return 0;
  944. }
  946. //////////////////////////////////////////////////////////////////////
  948. //! @brief Decode a 32-bit unsigned integer
  950. int fast_decode_u32 (fast_codec_t* codec, fast_tag_t tag, u32* value)
  951. {
  952.    fast_op_t op = get_tag_op (tag);
  954.    u32 next = 0;
  955.    int bytes;
  957.    if (check_codec (FUNCTION, codec) < 0)
  958.       return -1;
  960.    if (check_type  (FUNCTION, codec, tag, FAST_TYPE_U32) < 0)
  961.       return -1;
  963.    switch (op)
  964.    {
  965.     case FAST_OP_NONE: // Value must be present
  966.       bytes = parse_u32 (codec, tag, & next);
  968.       if (bytes < 0) // End of input
  969.          return -1;
  971.       if (bytes == 0) // No data
  972.          return value_error (FUNCTION, codec, tag);
  974.       break;
  976.     case FAST_OP_COPY: // Use previous value if not present
  977.       bytes = parse_u32 (codec, tag, & next);
  979.       if (bytes < 0) // End of input
  980.          return -1;
  982.       if (bytes == 0) // No value - use previous [common case]
  983.       {
  984.          if (cv_is_valid (codec, tag) == 0) // must be valid
  985.             return value_error (FUNCTION, codec, tag);
  986.          
  987.          next = cv_get_u32 (codec, tag);
  988.          break;
  989.       }
  990.       break;
  992.     case FAST_OP_INCR: // use previous value plus one if not present
  993.       bytes = parse_u32 (codec, tag, & next);
  995.       if (bytes < 0) // End of input
  996.          return -1;
  998.       if (bytes == 0) // No value - use previous plus one
  999.       {
  1000.          if (cv_is_valid (codec, tag) == 0) // must be valid
  1001.             return value_error (FUNCTION, codec, tag);
  1003.          next = cv_get_u32 (codec, tag) + 1;
  1004.       }
  1005.       break;
  1007.     case FAST_OP_DELTA:
  1008.       if (cv_is_valid (codec, tag))
  1009.       {
  1010.          // Rule: delta defaults to ZERO if there is
  1011.          // no value present
  1013.          i32 delta;
  1015.          bytes = parse_i32 (codec, tag, & delta);
  1016.          
  1017.          if (bytes < 0)
  1018.             return -1;
  1020.          next = cv_get_u32 (codec, tag);
  1022.          if (bytes > 0)
  1023.             next += delta;
  1024.       }
  1025.       else
  1026.       {
  1027.          // Rule: A field must be present if the
  1028.          // current value isn't valid
  1030.          bytes = parse_u32 (codec, tag, & next);
  1032.          if (bytes < 0)
  1033.             return -1;
  1035.          if (bytes == 0)
  1036.             return value_error (FUNCTION, codec, tag);
  1037.       }
  1038.       break;
  1040.     default:
  1041.       return bad_op_error (FUNCTION, codec, tag);
  1042.    }
  1044.    cv_set_u32 (codec, tag, next);
  1046.    *value = cv_get_u32 (codec, tag);
  1047.    return 0;
  1048. }
  1050. //////////////////////////////////////////////////////////////////////
  1052. // flush_group moves the current pmap and body data to the output
  1053. // buffer.
  1054. // Currently, flush_group is only called from flush_msg, but will
  1055. // also be called from other sites when repeating groups become
  1056. // supported in this implementation. 
  1059. //! @brief Flush a group of fields
  1060. //! Emit the presence map for the group and the serialized field data
  1061. //
  1062. //! @param codec
  1064. static int flush_group (fast_codec_t* codec)
  1065. {
  1066.    fast_buffer_t* output = codec->output;
  1067.    fast_buffer_t* msg = codec->msg;
  1069.    int map_size;
  1071.    //! @remark Make sure there is room in the output buffer
  1073.    int size = get_buffer_used (msg);
  1074.    int need = MAX_PMAP_BYTES + size;
  1075.       
  1076.    if (get_buffer_left (output) <= need)
  1077.       return set_err (FUNCTION, codec, -1, FAST_ERR_SIZE,
  1078.                       "output buffer overflow left=%d need=%d",
  1079.                       get_buffer_left (output), need);
  1081.    //! Copy the pmap into the output buffer
  1082.    map_size = emit_pmap (codec, output->tail);
  1084.    output->tail += map_size;
  1086.    //! Copy the message body into the output buffer
  1087.    memcpy (output->tail, msg->head, size);
  1089.    output->tail += size;
  1091.    //! Reset the presence map
  1092.    reset_pmap (codec);
  1094.    reset_buffer (codec->msg);
  1095.    return 0;
  1096. }
  1098. //! @brief Flush a message
  1099. //! Flush the last group of the message and write serialized data
  1101. static int flush_msg (fast_codec_t* codec)
  1102. {
  1103.    fast_buffer_t* output = codec->output;
  1105.    flush_group (codec);
  1107.    if (codec->skip_io == 0)
  1108.    {
  1109.       if (write_n (output->fd, output->head, get_buffer_used (output)) < 0)
  1110.          return set_err (FUNCTION, codec, -1, FAST_ERR_IO,
  1111.                          "write_n failed: %s", strerror (errno));
  1113.       reset_buffer (output);
  1114.    }
  1116.    return 0;
  1117. }
  1119. //////////////////////////////////////////////////////////////////////
  1121. // fast_encode_new_msg is called to setup encoding for a message.
  1122. // It must not be called again without calling fast_encode_end_msg
  1123. // in between.
  1125. //! @brief Start encoding a new message
  1127. int fast_encode_new_msg (fast_codec_t* codec, fast_tag_t tag)
  1128. {
  1129.    check_codec (FUNCTION, codec);
  1131.    if (codec->in_message != 0)
  1132.       return set_err (FUNCTION, codec, tag, FAST_ERR_CALL_SEQ,
  1133.                       "already in a message");
  1135.    codec->in_message = 1;
  1136.    codec->curr_tag = tag;
  1137.    return 0;
  1138. }
  1140. //! @brief Finish encoding a message
  1142. int fast_encode_end_msg (fast_codec_t* codec, fast_tag_t tag)
  1143. {
  1144.    check_codec (FUNCTION, codec);
  1146.    if (codec->in_message == 0)
  1147.       return set_err (FUNCTION, codec, tag, FAST_ERR_CALL_SEQ,
  1148.                       "not in a message");
  1150.    codec->in_message = 0;
  1151.    return flush_msg (codec);
  1152. }
  1154. //////////////////////////////////////////////////////////////////////
  1156. //! @brief Encode a 32-bit signed integer
  1158. int fast_encode_i32 (fast_codec_t* codec, fast_tag_t tag, i32 value)
  1159. {
  1160.    fast_op_t op = get_tag_op (tag);
  1162.    if (check_codec (FUNCTION, codec) < 0)
  1163.       return -1;
  1165.    if (check_type  (FUNCTION, codec, tag, FAST_TYPE_I32) < 0)
  1166.       return -1;
  1168.    switch (op)
  1169.    {
  1170.     case FAST_OP_NONE: // Always emit value
  1171.       break;
  1173.     case FAST_OP_COPY: // Emit value if not equal to previous value
  1174.       if (cv_eq_i32 (codec, tag, value))
  1175.          return 0;
  1176.       break;
  1178.     case FAST_OP_INCR: // Fixme: Implement
  1179.       return bad_op_error (FUNCTION, codec, tag);
  1181.     case FAST_OP_DELTA: // Fixme: Implement
  1182.       return bad_op_error (FUNCTION, codec, tag);
  1184.     default:
  1185.       return bad_op_error (FUNCTION, codec, tag);
  1186.    }
  1188.    cv_set_i32 (codec, tag, value);
  1189.    return emit_i32 (codec, tag, value);
  1190. }
  1192. static int find_char_delta_offset (u8* a, u8* b, int size)
  1193. {
  1194.    int p1;
  1196.    for (p1 = 0 ; p1 < size ; p1 ++)
  1197.       if (a [p1] != b [p1])
  1198.          break;
  1200.    return p1;
  1201. }
  1203. //! @brief Encode an ASCII string
  1205. int fast_encode_str (fast_codec_t* codec, fast_tag_t tag,
  1206.                      u8* data, int size)
  1207. {
  1208.    fast_op_t op = get_tag_op (tag);
  1210.    if (check_codec (FUNCTION, codec) < 0)
  1211.       return -1;
  1213.    if (check_type  (FUNCTION, codec, tag, FAST_TYPE_STR) < 0)
  1214.       return -1;
  1216.    // Note: We don't prune the string in the codec layer
  1217.    // Pruning should be done by the app codec
  1219.    switch (op)
  1220.    {
  1221.     case FAST_OP_NONE:
  1222.       break; // Always emit value
  1224.     case FAST_OP_COPY: // Emit value if not equal to previous value
  1225.       if (cv_eq_str (codec, tag, data, size))
  1226.          return 0;
  1228.       break;
  1230.     case FAST_OP_INCR: // Not defined in the spec
  1231.       return bad_op_error (FUNCTION, codec, tag);
  1233.     case FAST_OP_DELTA:
  1234.       {
  1235.          u8* curr = cv_get_str (codec, tag);
  1236.          u32 offset = find_char_delta_offset (curr, data, size);
  1238.          if (offset == size)
  1239.             return 0;
  1241.          memcpy (curr + offset, data + offset, size - offset);
  1243.          data += offset;
  1244.          size -= offset;
  1246.          return emit_str (codec, tag, data, size);
  1247.       }
  1249.     default:
  1250.       return bad_op_error (FUNCTION, codec, tag);
  1251.    }
  1253.    cv_set_str (codec, tag, data, size);
  1254.    return emit_str (codec, tag, data, size);
  1255. }
  1257. //! @brief Encode a 32-bit unsigned integer
  1259. int fast_encode_u32 (fast_codec_t* codec, fast_tag_t tag, u32 value)
  1260. {
  1261.    fast_op_t op = get_tag_op (tag);
  1262.    u32 next = value;
  1264.    if (check_codec (FUNCTION, codec) < 0)
  1265.       return -1;
  1267.    if (check_type  (FUNCTION, codec, tag, FAST_TYPE_U32) < 0)
  1268.       return -1;
  1270.    switch (op)
  1271.    {
  1272.     case FAST_OP_NONE: // Always emit value
  1273.       break;
  1275.     case FAST_OP_COPY: // Emit value if not equal to previous value
  1276.       if (cv_eq_u32 (codec, tag, value))
  1277.          return 0;
  1279.       break;
  1281.     case FAST_OP_INCR: // Emit value if not previous value plus one
  1282.       next = value + 1;
  1284.       if (cv_eq_u32 (codec, tag, value))
  1285.       {
  1286.          cv_set_u32 (codec, tag, next);
  1287.          return 0;
  1288.       }
  1289.       break;
  1291.     case FAST_OP_DELTA:
  1292.       if (cv_is_valid (codec, tag)) // Emit value if not equal to previous
  1293.       {
  1294.          i32 delta = (i32) value - cv_get_u32 (codec, tag);
  1296.          // Fixme: use parameter to control zero deltas
  1297.          if (delta == 0)
  1298.             return 0;
  1300.          cv_set_u32 (codec, tag, value);
  1301.          return emit_i32 (codec, tag, delta);
  1302.       }
  1303.       break;
  1305.     default:
  1306.       return bad_op_error (FUNCTION, codec, tag);
  1307.    }
  1309.    cv_set_u32 (codec, tag, next); // update previous value state
  1310.    return emit_u32 (codec, tag, value); // emit the value
  1311. }
  1313. //////////////////////////////////////////////////////////////////////
  1315. //! @brief Create a CODEC (encoder/decoder)
  1317. fast_codec_t* fast_create_codec (void)
  1318. {
  1319.    fast_codec_t* codec = malloc (sizeof (*codec));
  1321.    if (codec == NULL)
  1322.    {
  1323.       fprintf (stderr, "error: [%s] malloc failedn", FUNCTION);
  1324.       return NULL;
  1325.    }
  1327.    memset (codec, 0, sizeof (*codec));
  1329.    codec->magic  = FAST_CODEC_MAGIC;
  1331.    init_buffer (codec->msg,   -1);
  1332.    init_buffer (codec->input,  0);
  1333.    init_buffer (codec->output, 1);
  1335.    return codec;
  1336. }
  1338. int fast_destroy_codec (fast_codec_t* codec)
  1339. {
  1340.    if (codec == NULL)
  1341.    {
  1342.       fprintf (stderr, "error: [%s] null codecn", FUNCTION);
  1343.       return -1;
  1344.    }
  1346.    if (codec->magic != FAST_CODEC_MAGIC)
  1347.    {
  1348.       fprintf (stderr, "error: [%s] bad codec magic numbern", FUNCTION);
  1349.       return -1;
  1350.    }
  1352.    codec->magic = 0; // To prevent dangling references
  1353.    free (codec);
  1354.    return 0;
  1355. }
  1357. u32 fast_ascii_to_u32 (u8* data, int size)
  1358. {
  1359.    u32 temp = 0;
  1360.    int p1;
  1362.    for (p1 = 0 ; p1 < size ; p1 ++)
  1363.    {
  1364.       int chr = data [p1];
  1365.       temp = temp * 10 + chr - '0';
  1366.    }
  1367.    return temp;
  1368. }