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

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

TAPI编程

开发平台：

C/C++

arca.c：源码内容
  1. // $Id: arca.c,v 1.2 2006/02/09 19:14:25 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 "arca.h"
  22. static fast_codec_t* arca_codec = NULL;
  24. static int cl_count  = 0;
  25. static int cl_decode = 0;
  27. //////////////////////////////////////////////////////////////////////
  29. static insert_order_msg* swap_insert_order_msg (void* data)
  30. {
  31.    insert_order_msg* msg = (insert_order_msg*) data;
  33.    swap16 (msg->size);
  34.    swap32 (msg->time);
  35.    swap32 (msg->seqno);
  36.    swap32 (msg->order_ref);
  37.    swap32 (msg->shares);
  38.    swap32 (msg->price);
  40.    return msg;
  41. }
  43. static delete_order_msg* swap_delete_order_msg (void* data)
  44. {
  45.    delete_order_msg* msg = (delete_order_msg*) data;
  47.    swap16 (msg->size);
  48.    swap32 (msg->time);
  49.    swap32 (msg->seqno);
  50.    swap32 (msg->order_ref);
  52.    return msg;
  53. }
  55. static modify_order_msg* swap_modify_order_msg (void* data)
  56. {
  57.    modify_order_msg* msg = (modify_order_msg*) data;
  59.    swap16 (msg->size);
  60.    swap32 (msg->time);
  61.    swap32 (msg->seqno);
  62.    swap32 (msg->order_ref);
  63.    swap32 (msg->shares);
  64.    swap32 (msg->price);
  66.    return msg;
  67. }
  69. static imbalance_msg* swap_imbalance_msg (void* data)
  70. {
  71.    imbalance_msg* msg = (imbalance_msg*) data;
  73.    swap16 (msg->size);
  74.    swap32 (msg->time);
  75.    swap32 (msg->seqno);
  76.    swap32 (msg->shares);
  77.    swap32 (msg->total_imbal);
  78.    swap32 (msg->market_imbal);
  79.    swap32 (msg->price);
  80.    swap32 (msg->auction_time);
  82.    return msg;
  83. }
  84. //////////////////////////////////////////////////////////////////////
  86. static u32 decode_str (int tag, u8* data, int size)
  87. {
  88.    fast_decode_str (arca_codec, tag, data, size);
  89.    return 0;
  90. }
  92. static u32 decode_u32 (int tag)
  93. {
  94.    u32 temp;
  96.    fast_decode_u32 (arca_codec, tag, & temp);
  97.    return temp;
  98. }
  100. static i32 decode_i32 (int tag)
  101. {
  102.    i32 temp;
  104.    fast_decode_i32 (arca_codec, tag, & temp);
  105.    return temp;
  106. }
  108. static inline void encode_i32 (u32 tag, i32 value)
  109. {
  110.    fast_encode_u32 (arca_codec, tag, value);
  111. }
  113. static inline void encode_u32 (u32 tag, u32 value)
  114. {
  115.    fast_encode_u32 (arca_codec, tag, value);
  116. }
  118. static inline void encode_str (int tag, u8* data, int size)
  119. {
  120.    size = (int) strnlen ((char*) data, size); // remove trailing NULLs
  121.    fast_encode_str (arca_codec, tag, data, size);
  122. }
  124. //////////////////////////////////////////////////////////////////////
  126. static inline void encode_new_msg (u32 tag)
  127. {
  128.    fast_encode_new_msg (arca_codec, tag);
  129. }
  131. static inline void encode_end_msg (u32 tag)
  132. {
  133.    fast_encode_end_msg (arca_codec, tag);
  134. }
  136. //////////////////////////////////////////////////////////////////////
  138. static void decode_insert_order (int type)
  139. {
  140.    insert_order_msg msg [1];
  141.    u32 secs, msecs;
  143.    memset (msg, 0, sizeof (*msg));
  145.    msg->type = 'A';
  146.    msg->size = sizeof (insert_order_msg) - 4;
  148.    secs  = decode_u32 (TSP_SECS);
  149.    msecs = decode_u32 (TSP_MSECS);
  151.    msg->seqno     = decode_u32 (SEQNO);
  152.    msg->order_ref = decode_u32 (ORDER_REF);
  153.    msg->shares    = decode_u32 (SHARES);
  154.    msg->price     = decode_u32 (PRICE);
  155.    msg->scale     = decode_u32 (SCALE);
  156.    msg->exch_code = decode_u32 (EXCH_CODE);
  157.    msg->sys_code  = decode_u32 (SYS_CODE);
  158.    msg->buy_sell  = decode_u32 (BUY_SELL);
  160.    decode_str (STOCK,     STR_ARGS (msg->stock));
  161.    decode_str (QUOTE_ID,  STR_ARGS (msg->quote_id));
  163.    msg->time = secs * 1000 + msecs;
  165.    swap_insert_order_msg (msg);
  166.    write_n (arca_codec->output->fd, msg, sizeof (*msg));
  167. }
  169. //////////////////////////////////////////////////////////////////////
  171. static void decode_delete_order (int type)
  172. {
  173.    delete_order_msg msg [1];
  174.    u32 secs, msecs;
  176.    memset (msg, 0, sizeof (*msg));
  178.    msg->type = 'D';
  179.    msg->size = sizeof (delete_order_msg) - 4;
  181.    secs  = decode_u32 (TSP_SECS);
  182.    msecs = decode_u32 (TSP_MSECS);
  184.    msg->time = secs * 1000 + msecs;
  186.    msg->seqno     = decode_u32 (SEQNO);
  187.    msg->order_ref = decode_u32 (ORDER_REF);
  188.    msg->exch_code = decode_u32 (EXCH_CODE);
  189.    msg->sys_code  = decode_u32 (SYS_CODE);
  190.    msg->buy_sell  = decode_u32 (BUY_SELL);
  192.    decode_str (STOCK,     STR_ARGS (msg->stock));
  193.    decode_str (QUOTE_ID,  STR_ARGS (msg->quote_id));
  195.    swap_delete_order_msg (msg);
  196.    write_n (arca_codec->output->fd, msg, sizeof (*msg));
  197. }
  199. //////////////////////////////////////////////////////////////////////
  201. static void decode_modify_order (int type)
  202. {
  203.    modify_order_msg msg [1];
  204.    u32 secs, msecs;
  206.    memset (msg, 0, sizeof (*msg));
  208.    msg->type = 'M';
  209.    msg->size = sizeof (modify_order_msg) - 4;
  211.    secs  = decode_u32 (TSP_SECS);
  212.    msecs = decode_u32 (TSP_MSECS);
  214.    msg->time = secs * 1000 + msecs;
  216.    msg->seqno     = decode_u32 (SEQNO);
  217.    msg->order_ref = decode_u32 (ORDER_REF);
  218.    msg->shares    = decode_u32 (SHARES);
  219.    msg->price     = decode_u32 (PRICE);
  220.    msg->scale     = decode_u32 (SCALE);
  221.    msg->exch_code = decode_u32 (EXCH_CODE);
  222.    msg->sys_code  = decode_u32 (SYS_CODE);
  223.    msg->buy_sell  = decode_u32 (BUY_SELL);
  225.    decode_str (STOCK,     STR_ARGS (msg->stock));
  226.    decode_str (QUOTE_ID,  STR_ARGS (msg->quote_id));
  228.    swap_modify_order_msg (msg);
  229.    write_n (arca_codec->output->fd, msg, sizeof (*msg));
  230. }
  232. //////////////////////////////////////////////////////////////////////
  234. static void decode_imbalance (int type)
  235. {
  236.    imbalance_msg msg [1];
  237.    u32 secs, msecs;
  239.    memset (msg, 0, sizeof (*msg));
  241.    msg->type = 'I';
  242.    msg->size = sizeof (imbalance_msg) - 4;
  244.    secs  = decode_u32 (TSP_SECS);
  245.    msecs = decode_u32 (TSP_MSECS);
  247.    msg->time = secs * 1000 + msecs;
  249.    msg->seqno  = decode_u32 (SEQNO);
  250.    msg->shares = decode_u32 (SHARES);
  251.    
  252.    msg->price     = decode_u32 (PRICE);
  253.    msg->scale     = decode_u32 (SCALE);
  255.    msg->exch_code = decode_u32 (EXCH_CODE);
  256.    msg->sys_code  = decode_u32 (SYS_CODE);
  258.    decode_str (STOCK, STR_ARGS (msg->stock));
  260.    msg->market_imbal = decode_i32 (MARKET_IMBAL);
  261.    msg->total_imbal  = decode_i32 (TOTAL_IMBAL);
  263.    msg->auction_type = decode_u32 (AUCT_TYPE);
  264.    msg->auction_time = decode_u32 (AUCT_TIME);
  266.    swap_imbalance_msg (msg);
  267.    write_n (arca_codec->output->fd, msg, sizeof (*msg));
  268. }
  270. //////////////////////////////////////////////////////////////////////
  272. static int encode_insert_order (insert_order_msg* msg)
  273. {
  274.    encode_new_msg (ARCA_BASE_TID);
  276.    encode_u32 (MSG_TYPE,  msg->type);
  277.    encode_u32 (TSP_SECS,  msg->time / 1000);
  278.    encode_u32 (TSP_MSECS, msg->time % 1000);
  280.    encode_u32 (SEQNO,     msg->seqno);
  281.    encode_u32 (ORDER_REF, msg->order_ref);
  282.    encode_u32 (SHARES,    msg->shares);
  283.    encode_u32 (PRICE,     msg->price);
  284.    encode_u32 (SCALE,     msg->scale);
  286.    encode_u32 (EXCH_CODE, msg->exch_code);
  287.    encode_u32 (SYS_CODE,  msg->sys_code);
  288.    encode_u32 (BUY_SELL,  msg->buy_sell);
  290.    encode_str (STOCK,     STR_ARGS (msg->stock));
  291.    encode_str (QUOTE_ID,  STR_ARGS (msg->quote_id));
  293.    encode_end_msg (ARCA_BASE_TID);
  294.    return 0;
  295. }
  297. //////////////////////////////////////////////////////////////////////
  299. static int encode_delete_order (delete_order_msg* msg)
  300. {
  301.    encode_new_msg (ARCA_BASE_TID);
  303.    encode_u32 (MSG_TYPE,  msg->type);
  304.    encode_u32 (TSP_SECS,  msg->time / 1000);
  305.    encode_u32 (TSP_MSECS, msg->time % 1000);
  307.    encode_u32 (SEQNO,     msg->seqno);
  308.    encode_u32 (ORDER_REF, msg->order_ref);
  310.    encode_u32 (EXCH_CODE, msg->exch_code);
  311.    encode_u32 (SYS_CODE,  msg->sys_code);
  312.    encode_u32 (BUY_SELL,  msg->buy_sell);
  314.    encode_str (STOCK,     STR_ARGS (msg->stock));
  315.    encode_str (QUOTE_ID,  STR_ARGS (msg->quote_id));
  317.    encode_end_msg (ARCA_BASE_TID);
  318.    return 0;
  319. }
  321. //////////////////////////////////////////////////////////////////////
  323. static int encode_modify_order (modify_order_msg* msg)
  324. {
  325.    encode_new_msg (ARCA_BASE_TID);
  327.    encode_u32 (MSG_TYPE,  msg->type);
  328.    encode_u32 (TSP_SECS,  msg->time / 1000);
  329.    encode_u32 (TSP_MSECS, msg->time % 1000);
  331.    encode_u32 (SEQNO,     msg->seqno);
  332.    encode_u32 (ORDER_REF, msg->order_ref);
  333.    encode_u32 (SHARES,    msg->shares);
  334.    encode_u32 (PRICE,     msg->price);
  335.    encode_u32 (SCALE,     msg->scale);
  337.    encode_u32 (EXCH_CODE, msg->exch_code);
  338.    encode_u32 (SYS_CODE,  msg->sys_code);
  339.    encode_u32 (BUY_SELL,  msg->buy_sell);
  341.    encode_str (STOCK,     STR_ARGS (msg->stock));
  342.    encode_str (QUOTE_ID,  STR_ARGS (msg->quote_id));
  344.    encode_end_msg (ARCA_BASE_TID);
  345.    return 0;
  346. }
  348. //////////////////////////////////////////////////////////////////////
  350. static int encode_imbalance (imbalance_msg* msg)
  351. {
  352.    encode_new_msg (ARCA_BASE_TID);
  354.    encode_u32 (MSG_TYPE,     msg->type);
  355.    encode_u32 (TSP_SECS,     msg->time / 1000);
  356.    encode_u32 (TSP_MSECS,    msg->time % 1000);
  358.    encode_u32 (SEQNO,        msg->seqno);
  359.    encode_u32 (SHARES,       msg->shares);
  361.    encode_u32 (PRICE,        msg->price);
  362.    encode_u32 (SCALE,        msg->scale);
  364.    encode_u32 (EXCH_CODE,    msg->exch_code);
  365.    encode_u32 (SYS_CODE,     msg->sys_code);
  367.    encode_str (STOCK,        STR_ARGS (msg->stock));
  369.    encode_i32 (MARKET_IMBAL, msg->market_imbal);
  370.    encode_i32 (TOTAL_IMBAL,  msg->total_imbal);
  372.    encode_u32 (AUCT_TYPE,    msg->auction_type);
  373.    encode_u32 (AUCT_TIME,    msg->auction_time);
  375.    encode_end_msg (ARCA_BASE_TID);
  376.    return 0;
  377. }
  379. //////////////////////////////////////////////////////////////////////
  381. static int arca_decoder (void)
  382. {
  383.    int count;
  385.    for (count = 1 ;; count ++)
  386.    {
  387.       u32 msg_type;
  389.       if (cl_count > 0 && count > cl_count)
  390.          break;
  392.       if (fast_decode_new_msg (arca_codec, ARCA_BASE_TID) < 0)
  393.          break;
  395.       msg_type = decode_u32 (MSG_TYPE);
  397.       switch (msg_type)
  398.       {
  399.        case 'A':
  400.          decode_insert_order (msg_type);
  401.          break;
  403.        case 'D':
  404.          decode_delete_order (msg_type);
  405.          break;
  407.        case 'M':
  408.          decode_modify_order (msg_type);
  409.          break;
  411.        case 'I':
  412.          decode_imbalance (msg_type);
  413.          break;
  415.        default:
  416.          fprintf (stderr, "fatal: %02x unknown typen", msg_type);
  417.          exit (0);
  418.       }
  420.       if (fast_decode_end_msg (arca_codec, ARCA_BASE_TID) < 0)
  421.          break;
  422.    }
  423.    return 0;
  424. }
  426. static int arca_encoder (void)
  427. {
  428.    char data [128];
  430.    int error = 0;
  431.    int count;
  433.    for (count = 0 ; cl_count == 0 || count < cl_count ; count ++)
  434.    {
  435.       char* hdr  = data;
  436.       char* body = hdr + 4; // VC can't do arith on void*
  438.       int length;
  440.       // Read four bytes header
  441.       if (read_n (arca_codec->input->fd, data, 4) < 0)
  442.          return -1;
  444.       length = (hdr [0] << 8) | hdr [1];
  446.       assert (length <= sizeof (data) - 4);
  448.       // Read the body part
  449.       if (read_n (arca_codec->input->fd, body, length) < 0)
  450.       {
  451.          perror ("read_n: body part");
  452.          break;
  453.       }
  455.       switch (data [2])
  456.       {
  457.        case 'A':
  458.          encode_insert_order (swap_insert_order_msg (data));
  459.          break;
  461.        case 'D':
  462.          encode_delete_order (swap_delete_order_msg (data));
  463.          break;
  465.        case 'I':
  466.          encode_imbalance (swap_imbalance_msg (data));
  467.          break;
  469.        case 'M':
  470.          encode_modify_order (swap_modify_order_msg (data));
  471.          break;
  473.        default:
  474.          fprintf (stderr, "fatal: unknown type='%c'n", data [2]);
  475.          abort ();
  476.       }
  478.       if (error != 0)
  479.          break;
  480.    }
  481.    return 0;
  482. }
  484. //////////////////////////////////////////////////////////////////////
  486. #define OPTS "A:c:DV?"
  488. int main (int argc, char* argv [])
  489. {
  490.    init_platform_io ();
  492.    arca_codec = fast_create_codec ();
  494.    assert (arca_codec != NULL);
  496.    for (;;)
  497.    {
  498.       int option = getopt (argc, argv, OPTS);
  500.       if (option == EOF)
  501.          break;
  503.       switch (option)
  504.       {
  505.        case 'c':
  506.          cl_count = atoi (optarg);
  507.          break;
  509.        case 'D':
  510.          cl_decode = 1;
  511.          break;
  513.        case 'V':
  514.          arca_codec->verbose ++;
  515.          break;
  517.        case '?':
  518.          fprintf (stderr, "encoder [-cDV] <infile >outfilen");
  519.          exit (0);
  521.        default:
  522.          fprintf (stderr, "error: '%c' unknown optionn", option);
  523.          exit (1);
  524.       }
  525.    }
  527.    if (cl_decode)
  528.       arca_decoder ();
  529.    else
  530.       arca_encoder ();
  532.    exit (0);
  533. }