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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 行业应用 > 金融证券系统 > 查看源码
TW.cpp
资源名称：NetTS.rar　[点击查看]
上传用户：nameszq
上传日期：2014-08-12
资源大小：336k
文件大小：26k
源码类别：

金融证券系统

开发平台：

Visual C++

TW.cpp：源码内容
  1. // TW.cpp : implementation file
  2. //
  4. #include "stdafx.h"
  5. #include "TW.h"
  6. #include "SPTime.h"
  7. #include "TSCache.h"
  9. #include <math.h>
  11. #ifdef _DEBUG
  12. #define new DEBUG_NEW
  13. #undef THIS_FILE
  14. static char THIS_FILE[] = __FILE__;
  15. #endif
  17. /////////////////////////////////////////////////////////////////////////////
  18. // TW Interface
  20. static BYTE g_serial = 0x00;
  21. static CTWStockArray g_serial_stocks[0x80];
  22. static int g_serial_count[0x80];
  24. BYTE GetNextSerial( TW_STOCK & stock, int count = 0 )
  25. {
  26. g_serial ++;
  27. if( g_serial > 0x7f ) g_serial = 0x01;
  28. if( g_serial >= 1 && g_serial <= 0x7f )
  29. {
  30. g_serial_stocks[g_serial].RemoveAll();
  31. g_serial_stocks[g_serial].Add(stock);
  32. g_serial_count[g_serial] = count;
  33. }
  34. return g_serial;
  35. }
  37. BYTE GetNextSerial( CTWStockArray & stocks, int count = 0 )
  38. {
  39. g_serial ++;
  40. if( g_serial > 0x7f ) g_serial = 0x01;
  41. if( g_serial >= 1 && g_serial <= 0x7f )
  42. {
  43. g_serial_stocks[g_serial].RemoveAll();
  44. g_serial_stocks[g_serial].Copy(stocks);
  45. g_serial_count[g_serial] = count;
  46. }
  47. return g_serial;
  48. }
  50. BOOL GetSerialStock( BYTE serial, TW_STOCK & stock, int * pcount = NULL )
  51. {
  52. if( serial >= 1 && serial <= 0x7f )
  53. {
  54. memset( &stock, 0, sizeof(stock) );
  55. if( g_serial_stocks[serial].GetSize() > 0 )
  56. memcpy( &stock, &(g_serial_stocks[serial].ElementAt(0)), sizeof(stock) );
  57. if( pcount )
  58. *pcount = g_serial_count[serial];
  59. return TRUE;
  60. }
  61. return FALSE;
  62. }
  64. BOOL GetSerialStock( BYTE serial, CTWStockArray & stocks, int * pcount = NULL )
  65. {
  66. if( serial >= 1 && serial <= 0x7f )
  67. {
  68. stocks.RemoveAll();
  69. if( g_serial_stocks[serial].GetSize() > 0 )
  70. stocks.Copy( g_serial_stocks[serial] );
  71. if( pcount )
  72. *pcount = g_serial_count[serial];
  73. return TRUE;
  74. }
  75. return FALSE;
  76. }
  78. int ConstructLength( TW_HEADER & header, int len )
  79. {
  80. CString string = itoa(len,header.m_length,16);
  81. int nZeros = TW_LENGTH_LEN-string.GetLength();
  82. int i;
  83. for( i=0; i<nZeros; i++ )
  85. for( i=0; i<TW_LENGTH_LEN; i++ )
  86. {
  87. if( i< nZeros )
  88. header.m_length[i] = '0';
  89. else
  90. header.m_length[i] = string[i-nZeros];
  91. }
  92. return len;
  93. }
  95. int ConstructLoginBuffer( BYTE * buffer, size_t maxlen, LPCTSTR lpszUser, LPCTSTR lpszPasswd )
  96. {
  97. int nLen = 0;
  98. int nLenUser = strlen(lpszUser);
  99. int nLenPasswd = strlen(lpszPasswd);
  101. TW_LOGIN packet;
  102. memset(&packet,0,sizeof(packet));
  103. packet.m_header.m_magic = TW_MAGIC;
  104. if( maxlen < (int)(5 + sizeof(TW_HEADER) + nLenUser + nLenPasswd) )
  105. {
  106. nLen = 5 + sizeof(TW_HEADER);
  107. return -1;
  108. }
  109. packet.m_name_len = (WORD)nLenUser;
  110. memcpy( packet.m_data, lpszUser, nLenUser );
  111. *(WORD*)(packet.m_data + nLenUser) = (WORD)nLenPasswd;
  112. memcpy( packet.m_data + nLenUser + sizeof(WORD), lpszPasswd, nLenPasswd );
  114. nLen = 5 + sizeof(TW_HEADER) + nLenUser + nLenPasswd;
  115. ConstructLength( packet.m_header, nLen - sizeof(packet.m_header) );
  117. if( buffer )
  118. memcpy( buffer, &packet, nLen );
  119. return nLen;
  120. }
  122. int ConstructAskInitBuffer( TW_ASK & ask )
  123. {
  124. memset( &ask, 0, sizeof(ask) );
  125. ask.m_header.m_magic = TW_MAGIC;
  127. const char * str_tag = "E013.45D013.04D022.03D043.20xcs1.00.is2.00";
  129. ask.m_tag1 = 0x01;
  130. ask.m_tag2 = 0x01;
  131. ask.m_serial = 0x00;
  132. ask.m_size = 0x0007;
  134. CSPTime sptime = CTSCache::GetInstance().GetLocalLatest();
  135. DWORD date = sptime.ToStockTimeDay();
  136. memcpy( &(ask.m_stocks[0].m_type), &date, sizeof(date) );
  137. // ask.m_stocks[0].m_type = 0xdc;
  138. // ask.m_stocks[0].m_code[0] = (char)0xcc;
  139. // ask.m_stocks[0].m_code[1] = 0x31;
  140. // ask.m_stocks[0].m_code[2] = (char)0x01; //0xdc cc 31 01 = 20040924
  141. ask.m_stocks[0].m_code[3] = 0x00;
  142. ask.m_stocks[0].m_code[4] = 0x00;
  143. ask.m_stocks[0].m_code[5] = 0x00;
  144. memcpy( &(ask.m_stocks[1]), str_tag, strlen(str_tag) );
  145. int ret = (6 + sizeof(ask.m_header) + sizeof(TW_STOCK) + strlen(str_tag));
  146. ConstructLength( ask.m_header, ret - sizeof(ask.m_header) );
  147. return ret;
  148. }
  150. int ConstructAskReportBuffer( TW_ASK & ask, TW_STOCK * pStocks, size_t size )
  151. {
  152. memset( &ask, 0, sizeof(ask) );
  153. ask.m_header.m_magic = TW_MAGIC;
  155. SHORT shortSize = (SHORT)size;
  156. if( shortSize > sizeof(ask.m_stocks)/sizeof(TW_STOCK) )
  157. shortSize = sizeof(ask.m_stocks)/sizeof(TW_STOCK);
  158. if( shortSize <= 0 )
  159. return -1;
  161. ask.m_tag1 = 0x00;
  162. ask.m_tag2 = 0x03;
  163. CTWStockArray astocks;
  164. astocks.SetSize( 0, size+1 );
  165. for( size_t i=0; i<size; i++ ) astocks.Add( pStocks[i] );
  166. ask.m_serial = GetNextSerial(astocks);
  167. ask.m_size = shortSize;
  169. if( size > sizeof(ask.m_stocks)/sizeof(TW_STOCK) )
  170. return -1;
  172. if( pStocks && shortSize > 0 )
  173. memcpy( ask.m_stocks, pStocks, shortSize*sizeof(TW_STOCK) );
  175. int ret = (6 + sizeof(ask.m_header) + shortSize * sizeof(TW_STOCK));
  176. ConstructLength( ask.m_header, ret - sizeof(ask.m_header) );
  177. return ret;
  178. }
  180. int ConstructAskMinuteBuffer( TW_ASK & ask, TW_STOCK * pStock )
  181. {
  182. memset( &ask, 0, sizeof(ask) );
  183. ask.m_header.m_magic = TW_MAGIC;
  185. ask.m_tag1 = 0x01;
  186. ask.m_tag2 = 0x04;
  187. ask.m_size = 0x0001;
  188. memcpy( &(ask.m_stocks[0]), pStock, sizeof(TW_STOCK) );
  189. ask.m_serial = GetNextSerial(ask.m_stocks[0]);
  191. int ret = (6 + sizeof(ask.m_header) + sizeof(TW_STOCK));
  192. ConstructLength( ask.m_header, ret - sizeof(ask.m_header) );
  193. return ret;
  194. }
  196. int ConstructAskHistoryBuffer(TW_ASK & ask, TW_STOCK * pStock, int nKType, int nDataCount,
  197.   BOOL bChangeStock, BOOL bFirstRequest )
  198. {
  199. memset( &ask, 0, sizeof(ask) );
  200. ask.m_header.m_magic = TW_MAGIC;
  202. SHORT shortSize = (SHORT)nDataCount;
  204. ask.m_tag1 = 0x00;
  205. ask.m_tag2 = 0x09;
  206. ask.m_size = - shortSize;
  207. memcpy( &(ask.m_stocks[0]), pStock, sizeof(TW_STOCK) );
  208. ask.m_serial = GetNextSerial(ask.m_stocks[0],nDataCount);
  210. if( ktypeMin5 == nKType )
  211. ask.m_tag1 |= 0x30;
  212. else if( ktypeMin15 == nKType )
  213. ask.m_tag1 |= 0x40;
  214. else if( ktypeMin30 == nKType )
  215. ask.m_tag1 |= 0x50;
  216. else if( ktypeMin60 == nKType )
  217. ask.m_tag1 |= 0x60;
  218. else if( ktypeDay == nKType )
  219. ask.m_tag1 |= 0x10;
  220. else if( ktypeWeek == nKType )
  221. ask.m_tag1 |= 0x80;
  222. else if( ktypeMonth == nKType )
  223. ask.m_tag1 |= 0x90;
  225. if( bChangeStock )
  226. ask.m_tag1 |= 0x03;
  227. else if( bFirstRequest )
  228. ask.m_tag1 |= 0x01;
  229. else
  230. ask.m_tag1 |= 0x02;
  231. if( ktypeDay == nKType && bChangeStock )
  232. ask.m_tag1 = 0x20;
  234. int ret = (6 + sizeof(ask.m_header) + sizeof(TW_STOCK));
  235. ConstructLength( ask.m_header, ret - sizeof(ask.m_header) );
  236. return ret;
  237. }
  239. int ConstructAskMultisortBuffer( TW_ASK & ask, TW_STOCK * pStock )
  240. {
  241. memset( &ask, 0, sizeof(ask) );
  242. ask.m_header.m_magic = TW_MAGIC;
  244. BYTE type = typeshA;
  245. if( pStock )
  246. type = pStock->m_type;
  248. TW_STOCK stock;
  249. memset( &stock, 0, sizeof(stock) );
  251. SHORT shortSize = 9;
  253. ask.m_tag1 = 0x0a;
  254. ask.m_tag2 = 0x08;
  255. ask.m_size = - shortSize;
  256. ask.m_stocks[0].m_type = type;
  257. ask.m_stocks[0].m_code[0] = 0x06;
  258. ask.m_stocks[0].m_code[1] = 0x00;
  259. ask.m_stocks[0].m_code[2] = (char)0xff;
  260. ask.m_stocks[0].m_code[3] = 0x01;
  261. ask.m_stocks[0].m_code[4] = 0x00;
  262. ask.m_stocks[0].m_code[5] = 0x00;
  263. ask.m_serial = GetNextSerial(stock);
  264. int ret = (6 + sizeof(ask.m_header) + sizeof(TW_STOCK));
  265. ConstructLength( ask.m_header, ret - sizeof(ask.m_header) );
  266. return ret;
  267. }
  269. int ConstructAskDetailBuffer( TW_ASK & ask, TW_STOCK * pStock )
  270. {
  271. memset( &ask, 0, sizeof(ask) );
  272. ask.m_header.m_magic = TW_MAGIC;
  274. ask.m_tag1 = 0x01;
  275. ask.m_tag2 = 0x02;
  276. ask.m_size = 0x0001;
  277. memcpy( &(ask.m_stocks[0]), pStock, sizeof(TW_STOCK) );
  278. ask.m_serial = GetNextSerial(ask.m_stocks[0]);
  279. int ret = (6 + sizeof(ask.m_header) + sizeof(TW_STOCK));
  280. ConstructLength( ask.m_header, ret - sizeof(ask.m_header) );
  281. return ret;
  282. }
  284. int ConstructAskBaseBuffer( TW_ASK & ask, TW_STOCK * pStock )
  285. {
  286. memset( &ask, 0, sizeof(ask) );
  287. ask.m_header.m_magic = TW_MAGIC;
  289. ask.m_tag1 = 0x05;
  290. ask.m_tag2 = 0x0b;
  291. ask.m_size = 0x0005;
  292. memcpy( &(ask.m_stocks[0]), pStock, sizeof(TW_STOCK) );
  293. ask.m_serial = GetNextSerial(ask.m_stocks[0]);
  294. int ret = (6 + sizeof(ask.m_header) + 5*sizeof(TW_STOCK));
  295. ConstructLength( ask.m_header, ret - sizeof(ask.m_header) );
  296. return ret;
  297. }
  299. size_t TryGetLength( TW_HEADER & header )
  300. {
  301. if( TW_MAGIC != header.m_magic || 0 != header.m_end )
  302. return 0;
  303. int len = (int)strtol(header.m_length,NULL,16);
  304. if( len < 0 )
  305. return 0;
  306. return (size_t)len;
  307. }
  309. size_t TryGetLength( BYTE * buffer, size_t len )
  310. {
  311. if( len < sizeof(TW_HEADER) )
  312. return 0;
  313. TW_HEADER * pheader = (TW_HEADER*)buffer;
  314. return TryGetLength( *pheader );
  315. }
  317. BOOL IsLoginOK( BYTE * buffer, size_t len )
  318. {
  319. if( len < sizeof(TW_ANS) )
  320. return FALSE;
  321. TW_ANS * pans = (TW_ANS *)buffer;
  322. if( TW_MAGIC != pans->m_header.m_magic )
  323. return FALSE;
  324. if( 0x00 != pans->m_tag1 || 0x00 != pans->m_tag2 )
  325. return FALSE;
  326. return TRUE;
  327. }
  329. int TryGetInit( BYTE * buffer, size_t len, PRCV_DATA pRCV_DATA )
  330. {
  331. if( len < sizeof(TW_ANS) )
  332. return 0;
  333. TW_ANS * pans = (TW_ANS*)buffer;
  334. if( TW_MAGIC != pans->m_header.m_magic )
  335. return 0;
  336. if( 0x02 != pans->m_tag1 || 0x01 != pans->m_tag2 )
  337. return 0;
  339. // get it, fill pRCV_DATA
  340. size_t dataoffset = 469;
  341. int datalen = len - dataoffset;
  343. CSPTime tLatest( CSPTime::GetLatestTradeTime(time(NULL)) );
  344. if( len > 128 )
  345. {
  346. DWORD date = (*(DWORD*)(buffer+45));
  347. CSPTime sptime;
  348. if( sptime.FromStockTimeDay( date ) )
  349. tLatest = CSPTime(sptime.GetYear(),sptime.GetMonth(),sptime.GetDay(),9,15,0).GetTime();
  350. }
  351. if( pRCV_DATA && datalen >= (int)sizeof(TW_ANS_INIT) )
  352. {
  353. // 每组28个字节, 共XXXX组,最后以0xfdfdfdfd为结尾
  354. TW_ANS_INIT * pinit = (TW_ANS_INIT*)(buffer+dataoffset);
  355. int packetsize = datalen/(int)sizeof(TW_ANS_INIT);
  357. memset( pRCV_DATA, 0, sizeof(RCV_DATA) );
  358. pRCV_DATA->m_wDataType = RCV_REPORT; // no use
  359. pRCV_DATA->m_nPacketNum = packetsize;
  360. pRCV_DATA->m_bDISK = FALSE;
  361. pRCV_DATA->m_pReport = new RCV_REPORT_STRUCTEx[packetsize];
  362. memset( pRCV_DATA->m_pReport, 0, sizeof(RCV_REPORT_STRUCTEx)*packetsize );
  364. for( int i=0;i <packetsize; i++ )
  365. {
  366. if( pinit[i].m_tag != TW_MAGIC_BYTE )
  367. continue;
  368. pRCV_DATA->m_pReport[i].m_cbSize = sizeof(RCV_REPORT_STRUCTEx);
  369. pRCV_DATA->m_pReport[i].m_time = tLatest.GetTime();
  371. pRCV_DATA->m_pReport[i].m_wMarket = (pinit[i].m_type & 0x20) ? SZ_MARKET_EX : SH_MARKET_EX;
  372. pRCV_DATA->m_pReport[i].m_fLastClose = (float)(pinit[i].m_lastclose * 0.001);
  373. strncpy(pRCV_DATA->m_pReport[i].m_szLabel, pinit[i].m_code,
  374. min(sizeof(pRCV_DATA->m_pReport[i].m_szLabel),sizeof(pinit[i].m_code)));
  375. strncpy(pRCV_DATA->m_pReport[i].m_szName, pinit[i].m_name,
  376. min(sizeof(pRCV_DATA->m_pReport[i].m_szName),sizeof(pinit[i].m_name)));
  377. strncpy(pRCV_DATA->m_pReport[i].m_szName+sizeof(pinit[i].m_name)+2, pinit[i].m_shortname,
  378. min(sizeof(pRCV_DATA->m_pReport[i].m_szName)-sizeof(pinit[i].m_name)-2,sizeof(pinit[i].m_shortname)));
  379. }
  381. return len;
  382. }
  384. return 0;
  385. }
  387. int TryGetReport( BYTE * buffer, size_t len, PRCV_DATA pRCV_DATA )
  388. {
  389. if( len < sizeof(TW_ANS) )
  390. return 0;
  392. TW_ANS * pans = (TW_ANS*)buffer;
  393. if( TW_MAGIC != pans->m_header.m_magic )
  394. return 0;
  395. if( 0x00 != pans->m_tag1 || 0x03 != pans->m_tag2 )
  396. return 0;
  397. CTWStockArray astocks;
  398. BOOL bStockOK = GetSerialStock( pans->m_serial, astocks );
  400. // get it, fill pRCV_DATA
  401. size_t dataoffset = 43;
  402. int datalen = len - dataoffset;
  403. if( pRCV_DATA && bStockOK && astocks.GetSize() > 0 && datalen >= (int)sizeof(TW_ANS_REPORT) )
  404. {
  405. TW_ANS_REPORT * preport = (TW_ANS_REPORT*)(buffer+dataoffset);
  407. memset( pRCV_DATA, 0, sizeof(RCV_DATA) );
  408. pRCV_DATA->m_wDataType = RCV_REPORT; // no use
  409. pRCV_DATA->m_nPacketNum = astocks.GetSize();
  410. pRCV_DATA->m_bDISK = FALSE;
  411. pRCV_DATA->m_pReport = new RCV_REPORT_STRUCTEx[astocks.GetSize()];
  412. memset( pRCV_DATA->m_pReport, 0, sizeof(RCV_REPORT_STRUCTEx)*astocks.GetSize() );
  414. CSPTime tLatest = CTSCache::GetInstance().GetLocalLatest( );
  415. for( int i=0; i<astocks.GetSize() && i<datalen/(int)sizeof(TW_ANS_REPORT); i++ )
  416. {
  417. pRCV_DATA->m_pReport[i].m_cbSize = sizeof(RCV_REPORT_STRUCTEx);
  418. pRCV_DATA->m_pReport[i].m_time = tLatest.GetTime();
  420. pRCV_DATA->m_pReport[i].m_wMarket = (astocks[i].m_type & 0x20) ? SZ_MARKET_EX : SH_MARKET_EX;
  421. strncpy(pRCV_DATA->m_pReport[i].m_szLabel, astocks[i].m_code,
  422. min(sizeof(pRCV_DATA->m_pReport[i].m_szLabel),sizeof(astocks[i].m_code)));
  424. // unknown pRCV_DATA->m_pReport[i].m_fLastClose = (float)(0.001*preport->m_open);
  425. pRCV_DATA->m_pReport[i].m_fOpen = (float)(0.001*preport[i].m_open);
  426. pRCV_DATA->m_pReport[i].m_fHigh = (float)(0.001*preport[i].m_high);
  427. pRCV_DATA->m_pReport[i].m_fLow = (float)(0.001*preport[i].m_low);
  428. pRCV_DATA->m_pReport[i].m_fNewPrice = (float)(0.001*preport[i].m_new);
  429. pRCV_DATA->m_pReport[i].m_fVolume = (float)(0.01*preport[i].m_volume);
  430. pRCV_DATA->m_pReport[i].m_fAmount = (float)(0.01*preport[i].m_amount);
  432. pRCV_DATA->m_pReport[i].m_fBuyPrice[0]= (float)(0.001*preport[i].m_buy1);
  433. pRCV_DATA->m_pReport[i].m_fBuyPrice[1]= (float)(0.001*preport[i].m_buy2);
  434. pRCV_DATA->m_pReport[i].m_fBuyPrice[2]= (float)(0.001*preport[i].m_buy3);
  435. pRCV_DATA->m_pReport[i].m_fBuyVolume[0]= (float)(0.01*preport[i].m_buy1vol);
  436. pRCV_DATA->m_pReport[i].m_fBuyVolume[1]= (float)(0.01*preport[i].m_buy2vol);
  437. pRCV_DATA->m_pReport[i].m_fBuyVolume[2]= (float)(0.01*preport[i].m_buy3vol);
  438. pRCV_DATA->m_pReport[i].m_fSellPrice[0]= (float)(0.001*preport[i].m_sell1);
  439. pRCV_DATA->m_pReport[i].m_fSellPrice[1]= (float)(0.001*preport[i].m_sell2);
  440. pRCV_DATA->m_pReport[i].m_fSellPrice[2]= (float)(0.001*preport[i].m_sell3);
  441. pRCV_DATA->m_pReport[i].m_fSellVolume[0]= (float)(0.01*preport[i].m_sell1vol);
  442. pRCV_DATA->m_pReport[i].m_fSellVolume[1]= (float)(0.01*preport[i].m_sell2vol);
  443. pRCV_DATA->m_pReport[i].m_fSellVolume[2]= (float)(0.01*preport[i].m_sell3vol);
  444. }
  446. return len;
  447. }
  449. return 0;
  450. }
  452. int TryGetMinute( BYTE * buffer, size_t len, PRCV_DATA pRCV_MINUTE, PRCV_DATA pRCV_REPORT )
  453. {
  454. if( len < sizeof(TW_ANS) )
  455. return 0;
  457. TW_ANS * pans = (TW_ANS*)buffer;
  458. if( TW_MAGIC != pans->m_header.m_magic )
  459. return 0;
  460. if( 0x01 != pans->m_tag1 || 0x04 != pans->m_tag2 )
  461. return 0;
  462. TW_STOCK stock;
  463. memset( &stock, 0, sizeof(stock) );
  464. BOOL bStockOK = GetSerialStock( pans->m_serial, stock );
  466. // get it, fill pRCV_DATA
  467. size_t dataoffset = 43;
  468. int datalen = len - dataoffset;
  469. if( pRCV_MINUTE && pRCV_REPORT && bStockOK && datalen >= (int)(sizeof(TW_ANS_MINUTE)-240*sizeof(TW_MINUTE)) )
  470. {
  471. TW_ANS_MINUTE * pminute = (TW_ANS_MINUTE*)(buffer+dataoffset);
  473. CSPTime tLatest = CTSCache::GetInstance().GetLocalLatest( );
  475. int nCount = min(241,pminute->m_offset+1);
  477. int count1 = 0, count2 = 0;
  478. for( int k=0; k<nCount; k++ )
  479. {
  480. if( pminute->m_minutes[k].m_data1 <= pminute->m_high && pminute->m_minutes[k].m_data1 >= pminute->m_low )
  481. count1 ++;
  482. if( pminute->m_minutes[k].m_data2 <= pminute->m_high && pminute->m_minutes[k].m_data2 >= pminute->m_low )
  483. count2 ++;
  484. }
  485. int mode = ( count1 > count2 ? 1 : 2 );
  487. // minute
  488. memset( pRCV_MINUTE, 0, sizeof(RCV_DATA) );
  489. pRCV_MINUTE->m_wDataType = FILE_MINUTE_EX;
  490. pRCV_MINUTE->m_nPacketNum = 1+nCount;
  491. pRCV_MINUTE->m_bDISK = FALSE;
  492. pRCV_MINUTE->m_pMinute = new RCV_MINUTE_STRUCTEx[1+nCount];
  493. memset( pRCV_MINUTE->m_pMinute, 0, sizeof(RCV_MINUTE_STRUCTEx)*(1+nCount) );
  494. pRCV_MINUTE->m_pMinute[0].m_head.m_dwHeadTag = EKE_HEAD_TAG;
  495. pRCV_MINUTE->m_pMinute[0].m_head.m_wMarket = (stock.m_type & 0x20) ? SZ_MARKET_EX : SH_MARKET_EX;
  496. strncpy(pRCV_MINUTE->m_pMinute[0].m_head.m_szLabel, stock.m_code,
  497. min(sizeof(pRCV_MINUTE->m_pMinute[0].m_head.m_szLabel),sizeof(stock.m_code)));
  499. for( int i=0; i<nCount; i++ )
  500. {
  501. pRCV_MINUTE->m_pMinute[i+1].m_time = CSPTime::GetTradeOffsetToTime(i,tLatest.GetTime());
  502. if( 1 == mode )
  503. {
  504. pRCV_MINUTE->m_pMinute[i+1].m_fPrice = (float)(0.001 * pminute->m_minutes[i].m_data1);
  505. pRCV_MINUTE->m_pMinute[i+1].m_fVolume = (float)(0.01 * pminute->m_minutes[i].m_data2);
  506. }
  507. else
  508. {
  509. pRCV_MINUTE->m_pMinute[i+1].m_fPrice = (float)(0.001 * pminute->m_minutes[i].m_data2);
  510. pRCV_MINUTE->m_pMinute[i+1].m_fVolume = (float)(0.01 * pminute->m_minutes[i].m_data1);
  511. }
  512. pRCV_MINUTE->m_pMinute[i+1].m_fAmount = (float)(100. * pRCV_MINUTE->m_pMinute[i+1].m_fVolume * pRCV_MINUTE->m_pMinute[i+1].m_fPrice);
  513. }
  515. // report
  516. memset( pRCV_REPORT, 0, sizeof(RCV_DATA) );
  517. pRCV_REPORT->m_wDataType = RCV_REPORT; // no use
  518. pRCV_REPORT->m_nPacketNum = 11;
  519. pRCV_REPORT->m_bDISK = FALSE;
  520. pRCV_REPORT->m_pReport = new RCV_REPORT_STRUCTEx[11];
  521. memset( pRCV_REPORT->m_pReport, 0, sizeof(RCV_REPORT_STRUCTEx)*11 );
  522. for( i=0;i <11; i++ )
  523. {
  524. pRCV_REPORT->m_pReport[i].m_cbSize = sizeof(RCV_REPORT_STRUCTEx);
  525. pRCV_REPORT->m_pReport[i].m_time = CSPTime::GetTradeOffsetToTime(pminute->m_details[i].m_offset,tLatest.GetTime());
  527. pRCV_REPORT->m_pReport[i].m_wMarket = (stock.m_type & 0x20) ? SZ_MARKET_EX : SH_MARKET_EX;
  528. strncpy(pRCV_REPORT->m_pReport[i].m_szLabel, stock.m_code,
  529. min(sizeof(pRCV_REPORT->m_pReport[i].m_szLabel),sizeof(stock.m_code)));
  531. // unknown pRCV_REPORT->m_pReport[i].m_fLastClose = (float)(0.001*pminute->m_open);
  532. pRCV_REPORT->m_pReport[i].m_fOpen = (float)(0.001*pminute->m_open);
  533. pRCV_REPORT->m_pReport[i].m_fHigh = (float)(0.001*pminute->m_high);
  534. pRCV_REPORT->m_pReport[i].m_fLow = (float)(0.001*pminute->m_low);
  535. pRCV_REPORT->m_pReport[i].m_fNewPrice = (float)(0.001*pminute->m_details[i].m_price);
  536. pRCV_REPORT->m_pReport[i].m_fVolume = (float)(0.01*pminute->m_details[i].m_volume);
  537. pRCV_REPORT->m_pReport[i].m_fAmount = (float)(100.*pRCV_REPORT->m_pReport[i].m_fVolume*pRCV_REPORT->m_pReport[i].m_fNewPrice);
  539. pRCV_REPORT->m_pReport[i].m_fBuyPrice[0]= (float)(0.001*pminute->m_details[i].m_buy);
  540. if(10==i) pRCV_REPORT->m_pReport[i].m_fBuyPrice[1]= (float)(0.001*pminute->m_buy2);
  541. if(10==i) pRCV_REPORT->m_pReport[i].m_fBuyPrice[2]= (float)(0.001*pminute->m_buy3);
  542. if(10==i) pRCV_REPORT->m_pReport[i].m_fBuyVolume[0]= (float)(0.01*pminute->m_buy1vol);
  543. if(10==i) pRCV_REPORT->m_pReport[i].m_fBuyVolume[1]= (float)(0.01*pminute->m_buy2vol);
  544. if(10==i) pRCV_REPORT->m_pReport[i].m_fBuyVolume[2]= (float)(0.01*pminute->m_buy3vol);
  545. pRCV_REPORT->m_pReport[i].m_fSellPrice[0]= (float)(0.001*pminute->m_details[i].m_sell);
  546. if(10==i) pRCV_REPORT->m_pReport[i].m_fSellPrice[1]= (float)(0.001*pminute->m_sell2);
  547. if(10==i) pRCV_REPORT->m_pReport[i].m_fSellPrice[2]= (float)(0.001*pminute->m_sell3);
  548. if(10==i) pRCV_REPORT->m_pReport[i].m_fSellVolume[0]= (float)(0.01*pminute->m_sell1vol);
  549. if(10==i) pRCV_REPORT->m_pReport[i].m_fSellVolume[1]= (float)(0.01*pminute->m_sell2vol);
  550. if(10==i) pRCV_REPORT->m_pReport[i].m_fSellVolume[2]= (float)(0.01*pminute->m_sell3vol);
  551. }
  553. return len;
  554. }
  556. return 0;
  557. }
  559. int TryGetHistory( BYTE * buffer, size_t len, PRCV_DATA pRCV_DATA )
  560. {
  561. if( len < sizeof(TW_ANS) )
  562. return 0;
  564. TW_ANS * pans = (TW_ANS*)buffer;
  565. if( TW_MAGIC != pans->m_header.m_magic )
  566. return 0;
  567. if( 0x09 != pans->m_tag2 )
  568. return 0;
  569. TW_STOCK stock;
  570. memset( &stock, 0, sizeof(stock) );
  571. int nCount = 0;
  572. BOOL bStockOK = GetSerialStock( pans->m_serial, stock, &nCount );
  573. if( 1 == nCount ) nCount = 2;
  575. int ktype = ktypeDay;
  576. if( 0x20 == pans->m_tag1 )
  577. ktype = ktypeDay;
  578. else if( 0x30 == (0xf0 & pans->m_tag1) )
  579. ktype = ktypeMin5;
  580. else if( 0x40 == (0xf0 & pans->m_tag1) )
  581. ktype = ktypeMin15;
  582. else if( 0x50 == (0xf0 & pans->m_tag1) )
  583. ktype = ktypeMin30;
  584. else if( 0x60 == (0xf0 & pans->m_tag1) )
  585. ktype = ktypeMin60;
  586. else if( 0x10 == (0xf0 & pans->m_tag1) )
  587. ktype = ktypeDay;
  588. else if( 0x80 == (0xf0 & pans->m_tag1) )
  589. ktype = ktypeWeek;
  590. else if( 0x90 == (0xf0 & pans->m_tag1) )
  591. ktype = ktypeMonth;
  593. // get it, fill pRCV_DATA
  594. size_t dataoffset = 43;
  595. int datalen = len - dataoffset;
  596. if( pRCV_DATA && bStockOK && nCount > 0 && datalen >= nCount*(int)(sizeof(TW_ANS_HISTORY)+sizeof(DWORD)) )
  597. {
  598. int dataprefix = datalen - nCount*(int)(sizeof(TW_ANS_HISTORY)+sizeof(DWORD));
  599. if( 2 == nCount && datalen >= nCount*(int)(sizeof(TW_ANS_HISTORY)+sizeof(DWORD))+36 )
  600. {
  601. dataprefix = datalen - nCount*(int)(sizeof(TW_ANS_HISTORY)+sizeof(DWORD)) - 36;
  602. }
  604. TW_ANS_HISTORY * phistory = (TW_ANS_HISTORY*)(buffer+dataoffset+dataprefix);
  606. CSPTime tLatest = CTSCache::GetInstance().GetLocalLatest( );
  608. // minute
  609. memset( pRCV_DATA, 0, sizeof(RCV_DATA) );
  610. pRCV_DATA->m_wDataType = FILE_HISTORY_EX;
  611. pRCV_DATA->m_nPacketNum = 1 + nCount;
  612. pRCV_DATA->m_bDISK = FALSE;
  613. pRCV_DATA->m_pDay = new RCV_HISTORY_STRUCTEx[pRCV_DATA->m_nPacketNum+1];
  614. memset( pRCV_DATA->m_pDay, 0, sizeof(RCV_HISTORY_STRUCTEx)*(pRCV_DATA->m_nPacketNum+1) );
  616. pRCV_DATA->m_pDay[0].m_head.m_dwHeadTag = EKE_HEAD_TAG;
  617. pRCV_DATA->m_pDay[0].m_head.m_wMarket = (stock.m_type & 0x20) ? SZ_MARKET_EX : SH_MARKET_EX;
  618. strncpy(pRCV_DATA->m_pDay[0].m_head.m_szLabel, stock.m_code,
  619. min(sizeof(pRCV_DATA->m_pDay[0].m_head.m_szLabel),sizeof(stock.m_code)));
  621. for( int i=0; i<nCount; i++ )
  622. {
  623. CSPTime sptime;
  624. if( sptime.FromStockTime( phistory[i].m_date, ktype, tLatest.GetYear() ) )
  625. pRCV_DATA->m_pDay[i+1].m_time = sptime.GetTime();
  626. else
  627. return 0;
  628. pRCV_DATA->m_pDay[i+1].m_fOpen = (float)(0.001 * phistory[i].m_open);
  629. pRCV_DATA->m_pDay[i+1].m_fHigh = (float)(0.001 * phistory[i].m_high);
  630. pRCV_DATA->m_pDay[i+1].m_fLow = (float)(0.001 * phistory[i].m_low);
  631. pRCV_DATA->m_pDay[i+1].m_fClose = (float)(0.001 * phistory[i].m_close);
  632. pRCV_DATA->m_pDay[i+1].m_fVolume = (float)(phistory[i].m_volume);
  633. pRCV_DATA->m_pDay[i+1].m_fAmount = (float)(1000. * ((DWORD*)&(phistory[nCount]))[i] );
  634. }
  636. return len;
  637. }
  639. return 0;
  640. }
  642. int TryGetMultisort( BYTE * buffer, size_t len, PRCV_DATA pRCV_DATA )
  643. {
  644. if( len < sizeof(TW_ANS) )
  645. return 0;
  647. TW_ANS * pans = (TW_ANS*)buffer;
  648. if( TW_MAGIC != pans->m_header.m_magic )
  649. return 0;
  650. if( 0x0a != pans->m_tag1 || 0x08 != pans->m_tag2 )
  651. return 0;
  653. // get it, fill pRCV_DATA
  654. size_t dataoffset = 41;
  655. int datalen = len - dataoffset;
  656. if( pRCV_DATA && datalen >= (int)sizeof(TW_ANS_MULTISORT) )
  657. {
  658. TW_ANS_MULTISORT * pmultisort = (TW_ANS_MULTISORT*)(buffer+dataoffset);
  660. if( 0x0006 == pmultisort->m_tag1 || datalen == sizeof(TW_ANS_MULTISORT) )
  661. {
  662. memset( pRCV_DATA, 0, sizeof(RCV_DATA) );
  663. pRCV_DATA->m_wDataType = FILE_MULTISORT_EX; // no use
  664. pRCV_DATA->m_nPacketNum = 1;
  665. pRCV_DATA->m_bDISK = FALSE;
  666. pRCV_DATA->m_pMultisort = new RCV_MULTISORT_STRUCTEx[1];
  667. memset( pRCV_DATA->m_pMultisort, 0, sizeof(RCV_MULTISORT_STRUCTEx)*1 );
  668. memcpy( pRCV_DATA->m_pMultisort, pmultisort, sizeof(TW_ANS_MULTISORT) );
  669. return len;
  670. }
  671. }
  673. return 0;
  674. }
  676. int TryGetDetail( BYTE * buffer, size_t len, PRCV_DATA pRCV_DATA )
  677. {
  678. if( len < sizeof(TW_ANS) )
  679. return 0;
  681. TW_ANS * pans = (TW_ANS*)buffer;
  682. if( TW_MAGIC != pans->m_header.m_magic )
  683. return 0;
  684. if( 0x01 != pans->m_tag1 || 0x02 != pans->m_tag2 )
  685. return 0;
  686. TW_STOCK stock;
  687. memset( &stock, 0, sizeof(stock) );
  688. BOOL bStockOK = GetSerialStock( pans->m_serial, stock );
  690. // get it, fill pRCV_DATA
  691. size_t dataoffset = 43;
  692. int datalen = len - dataoffset;
  693. if( pRCV_DATA && bStockOK && datalen >= (int)sizeof(TW_ANS_DETAIL) )
  694. {
  695. TW_ANS_DETAIL * pdetail = (TW_ANS_DETAIL*)(buffer+dataoffset);
  696. int packetsize = datalen/(int)sizeof(TW_ANS_DETAIL);
  698. memset( pRCV_DATA, 0, sizeof(RCV_DATA) );
  699. pRCV_DATA->m_wDataType = RCV_REPORT; // no use
  700. pRCV_DATA->m_nPacketNum = packetsize;
  701. pRCV_DATA->m_bDISK = FALSE;
  702. pRCV_DATA->m_pReport = new RCV_REPORT_STRUCTEx[packetsize];
  703. memset( pRCV_DATA->m_pReport, 0, sizeof(RCV_REPORT_STRUCTEx)*packetsize );
  705. CSPTime tLatest = CTSCache::GetInstance().GetLocalLatest( );
  707. for( int i=0;i <packetsize; i++ )
  708. {
  709. pRCV_DATA->m_pReport[i].m_cbSize = sizeof(RCV_REPORT_STRUCTEx);
  710. pRCV_DATA->m_pReport[i].m_time = CSPTime::GetTradeOffsetToTime( pdetail[i].m_offset, tLatest.GetTime() );
  712. pRCV_DATA->m_pReport[i].m_wMarket = (stock.m_type & 0x20) ? SZ_MARKET_EX : SH_MARKET_EX;
  713. strncpy(pRCV_DATA->m_pReport[i].m_szLabel, stock.m_code,
  714. min(sizeof(pRCV_DATA->m_pReport[i].m_szLabel),sizeof(stock.m_code)));
  716. pRCV_DATA->m_pReport[i].m_fNewPrice = (float)(0.001*pdetail[i].m_price);
  717. pRCV_DATA->m_pReport[i].m_fVolume = (float)(0.01*pdetail[i].m_volume);
  718. pRCV_DATA->m_pReport[i].m_fAmount = (float)(100.*pRCV_DATA->m_pReport[i].m_fVolume*pRCV_DATA->m_pReport[i].m_fNewPrice);
  720. pRCV_DATA->m_pReport[i].m_fBuyPrice[0]= (float)(0.001*pdetail[i].m_buy1);
  721. pRCV_DATA->m_pReport[i].m_fSellPrice[0]= (float)(0.001*pdetail[i].m_sell1);
  722. }
  724. return len;
  725. }
  727. return 0;
  728. }
  730. int TryGetBase( BYTE * buffer, size_t len, PRCV_DATA pRCV_DATA )
  731. {
  732. if( len < sizeof(TW_ANS) )
  733. return 0;
  735. TW_ANS * pans = (TW_ANS*)buffer;
  736. if( TW_MAGIC != pans->m_header.m_magic )
  737. return 0;
  738. if( 0x05 != pans->m_tag1 || 0x0b != pans->m_tag2 )
  739. return 0;
  740. TW_STOCK stock;
  741. memset( &stock, 0, sizeof(stock) );
  742. BOOL bStockOK = GetSerialStock( pans->m_serial, stock );
  744. // get it, fill pRCV_DATA
  745. size_t dataoffset = 45;
  746. int datalen = len - dataoffset;
  747. if( pRCV_DATA && bStockOK && datalen > 0 )
  748. {
  749. memset( pRCV_DATA, 0, sizeof(RCV_DATA) );
  750. pRCV_DATA->m_wDataType = FILE_BASE_EX;
  751. pRCV_DATA->m_nPacketNum = 1;
  752. pRCV_DATA->m_bDISK = FALSE;
  754. pRCV_DATA->m_File.m_dwLen = datalen;
  755. strncpy( pRCV_DATA->m_File.m_szFileName, stock.m_code, min(sizeof(stock.m_code),sizeof(pRCV_DATA->m_File.m_szFileName)-1) );
  756. if( strlen(pRCV_DATA->m_File.m_szFileName)+5 < sizeof(pRCV_DATA->m_File.m_szFileName) )
  757. strcat(pRCV_DATA->m_File.m_szFileName, ".txt");
  758. pRCV_DATA->m_pData = new BYTE[datalen+1];
  759. memcpy( pRCV_DATA->m_pData, buffer + dataoffset, datalen );
  760. ((char*)pRCV_DATA->m_pData)[datalen] = 0;
  761. return len;
  762. }
  764. return 0;
  765. }