tw.cpp

接收证券行情数据接口的VC源代码,配合上mystock,可很好了解股票软件的内部源代码

// TW.cpp : implementation file
//

#include "stdafx.h"
#include "TW.h"
#include "SPTime.h"
#include "TSCache.h"

#include <math.h>

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// TW Interface

static BYTE g_serial = 0x00;
static CTWStockArray g_serial_stocks[0x80];
static int g_serial_count[0x80];

BYTE GetNextSerial( TW_STOCK & stock, int count = 0 )
{
	g_serial ++;
	if( g_serial > 0x7f )	g_serial = 0x01;
	if( g_serial >= 1 && g_serial <= 0x7f )
	{
		g_serial_stocks[g_serial].RemoveAll();
		g_serial_stocks[g_serial].Add(stock);
		g_serial_count[g_serial] = count;
	}
	return g_serial;
}

BYTE GetNextSerial( CTWStockArray & stocks, int count = 0 )
{
	g_serial ++;
	if( g_serial > 0x7f )	g_serial = 0x01;
	if( g_serial >= 1 && g_serial <= 0x7f )
	{
		g_serial_stocks[g_serial].RemoveAll();
		g_serial_stocks[g_serial].Copy(stocks);
		g_serial_count[g_serial] = count;
	}
	return g_serial;
}

BOOL GetSerialStock( BYTE serial, TW_STOCK & stock, int * pcount = NULL )
{
	if( serial >= 1 && serial <= 0x7f )
	{
		memset( &stock, 0, sizeof(stock) );
		if( g_serial_stocks[serial].GetSize() > 0 )
			memcpy( &stock, &(g_serial_stocks[serial].ElementAt(0)), sizeof(stock) );
		if( pcount )
			*pcount = g_serial_count[serial];
		return TRUE;
	}
	return FALSE;
}

BOOL GetSerialStock( BYTE serial, CTWStockArray & stocks, int * pcount = NULL )
{
	if( serial >= 1 && serial <= 0x7f )
	{
		stocks.RemoveAll();
		if( g_serial_stocks[serial].GetSize() > 0 )
			stocks.Copy( g_serial_stocks[serial] );
		if( pcount )
			*pcount = g_serial_count[serial];
		return TRUE;
	}
	return FALSE;
}

int ConstructLength( TW_HEADER & header, int len )
{
	CString	string = itoa(len,header.m_length,16);
	int nZeros = TW_LENGTH_LEN-string.GetLength();
	int i;
	for( i=0; i<nZeros; i++ )
		
	for( i=0; i<TW_LENGTH_LEN; i++ )
	{
		if( i< nZeros )
			header.m_length[i] = '0';
		else
			header.m_length[i] = string[i-nZeros];
	}
	return len;
}

int ConstructLoginBuffer( BYTE * buffer, size_t maxlen, LPCTSTR lpszUser, LPCTSTR lpszPasswd )
{
	int nLen = 0;
	int nLenUser = strlen(lpszUser);
	int nLenPasswd = strlen(lpszPasswd);

	TW_LOGIN	packet;
	memset(&packet,0,sizeof(packet));
	packet.m_header.m_magic = TW_MAGIC;
	if( maxlen < (int)(5 + sizeof(TW_HEADER) + nLenUser + nLenPasswd) )
	{
		nLen = 5 + sizeof(TW_HEADER);
		return -1;
	}
	packet.m_name_len = (WORD)nLenUser;
	memcpy( packet.m_data, lpszUser, nLenUser );
	*(WORD*)(packet.m_data + nLenUser)	=	(WORD)nLenPasswd;
	memcpy( packet.m_data + nLenUser + sizeof(WORD), lpszPasswd, nLenPasswd );

	nLen = 5 + sizeof(TW_HEADER) + nLenUser + nLenPasswd;
	ConstructLength( packet.m_header, nLen - sizeof(packet.m_header) );

	if( buffer )
		memcpy( buffer, &packet, nLen );
	return nLen;
}

int ConstructAskInitBuffer( TW_ASK & ask )
{
	memset( &ask, 0, sizeof(ask) );
	ask.m_header.m_magic = TW_MAGIC;

	const char * str_tag = "E013.45D013.04D022.03D043.20xcs1.00.is2.00";

	ask.m_tag1 = 0x01;
	ask.m_tag2 = 0x01;
	ask.m_serial = 0x00;
	ask.m_size = 0x0007;

	CSPTime sptime = CTSCache::GetInstance().GetLocalLatest();
	DWORD	date = sptime.ToStockTimeDay();
	memcpy( &(ask.m_stocks[0].m_type), &date, sizeof(date) );
//	ask.m_stocks[0].m_type = 0xdc;
//	ask.m_stocks[0].m_code[0] = (char)0xcc;
//	ask.m_stocks[0].m_code[1] = 0x31;
//	ask.m_stocks[0].m_code[2] = (char)0x01;	//0xdc cc 31 01 = 20040924
	ask.m_stocks[0].m_code[3] = 0x00;
	ask.m_stocks[0].m_code[4] = 0x00;
	ask.m_stocks[0].m_code[5] = 0x00;
	memcpy( &(ask.m_stocks[1]), str_tag, strlen(str_tag) );
	int ret = (6 + sizeof(ask.m_header) + sizeof(TW_STOCK) + strlen(str_tag));
	ConstructLength( ask.m_header, ret - sizeof(ask.m_header) );
	return ret;
}

int ConstructAskReportBuffer( TW_ASK & ask, TW_STOCK * pStocks, size_t size )
{
	memset( &ask, 0, sizeof(ask) );
	ask.m_header.m_magic = TW_MAGIC;

	SHORT shortSize = (SHORT)size;
	if( shortSize > sizeof(ask.m_stocks)/sizeof(TW_STOCK) )
		shortSize = sizeof(ask.m_stocks)/sizeof(TW_STOCK);
	if( shortSize <= 0 )
		return -1;

	ask.m_tag1 = 0x00;
	ask.m_tag2 = 0x03;
	CTWStockArray astocks;
	astocks.SetSize( 0, size+1 );
	for( size_t i=0; i<size; i++ )	astocks.Add( pStocks[i] );
	ask.m_serial = GetNextSerial(astocks);
	ask.m_size = shortSize;

	if( size > sizeof(ask.m_stocks)/sizeof(TW_STOCK) )
		return -1;

	if( pStocks && shortSize > 0 )
		memcpy( ask.m_stocks, pStocks, shortSize*sizeof(TW_STOCK) );

	int ret = (6 + sizeof(ask.m_header) + shortSize * sizeof(TW_STOCK));
	ConstructLength( ask.m_header, ret - sizeof(ask.m_header) );
	return ret;
}

int ConstructAskMinuteBuffer( TW_ASK & ask, TW_STOCK * pStock )
{
	memset( &ask, 0, sizeof(ask) );
	ask.m_header.m_magic = TW_MAGIC;

	ask.m_tag1 = 0x01;
	ask.m_tag2 = 0x04;
	ask.m_size = 0x0001;
	memcpy( &(ask.m_stocks[0]), pStock, sizeof(TW_STOCK) );
	ask.m_serial = GetNextSerial(ask.m_stocks[0]);
	
	int ret = (6 + sizeof(ask.m_header) + sizeof(TW_STOCK));
	ConstructLength( ask.m_header, ret - sizeof(ask.m_header) );
	return ret;
}

int ConstructAskHistoryBuffer(TW_ASK & ask, TW_STOCK * pStock, int nKType, int nDataCount,
							  BOOL bChangeStock, BOOL bFirstRequest )
{
	memset( &ask, 0, sizeof(ask) );
	ask.m_header.m_magic = TW_MAGIC;

	SHORT shortSize = (SHORT)nDataCount;

	ask.m_tag1 = 0x00;
	ask.m_tag2 = 0x09;
	ask.m_size = - shortSize;
	memcpy( &(ask.m_stocks[0]), pStock, sizeof(TW_STOCK) );
	ask.m_serial = GetNextSerial(ask.m_stocks[0],nDataCount);

	if( ktypeMin5 == nKType )
		ask.m_tag1	|=	0x30;
	else if( ktypeMin15 == nKType )
		ask.m_tag1	|=	0x40;
	else if( ktypeMin30 == nKType )
		ask.m_tag1	|=	0x50;
	else if( ktypeMin60 == nKType )
		ask.m_tag1	|=	0x60;
	else if( ktypeDay == nKType )
		ask.m_tag1	|=	0x10;
	else if( ktypeWeek == nKType )
		ask.m_tag1	|=	0x80;
	else if( ktypeMonth == nKType )
		ask.m_tag1	|=	0x90;

	if( bChangeStock )
		ask.m_tag1	|=	0x03;
	else if( bFirstRequest )
		ask.m_tag1	|=	0x01;
	else
		ask.m_tag1	|=	0x02;
	if( ktypeDay == nKType && bChangeStock )
		ask.m_tag1	=	0x20;

	int ret = (6 + sizeof(ask.m_header) + sizeof(TW_STOCK));
	ConstructLength( ask.m_header, ret - sizeof(ask.m_header) );
	return ret;
}

int ConstructAskMultisortBuffer( TW_ASK & ask, TW_STOCK * pStock )
{
	memset( &ask, 0, sizeof(ask) );
	ask.m_header.m_magic = TW_MAGIC;

	BYTE	type = typeshA;
	if( pStock )
		type = pStock->m_type;

	TW_STOCK	stock;
	memset( &stock, 0, sizeof(stock) );

	SHORT shortSize = 9;

	ask.m_tag1 = 0x0a;
	ask.m_tag2 = 0x08;
	ask.m_size = - shortSize;
	ask.m_stocks[0].m_type = type;
	ask.m_stocks[0].m_code[0] = 0x06;
	ask.m_stocks[0].m_code[1] = 0x00;
	ask.m_stocks[0].m_code[2] = (char)0xff;
	ask.m_stocks[0].m_code[3] = 0x01;
	ask.m_stocks[0].m_code[4] = 0x00;
	ask.m_stocks[0].m_code[5] = 0x00;
	ask.m_serial = GetNextSerial(stock);
	int ret = (6 + sizeof(ask.m_header) + sizeof(TW_STOCK));
	ConstructLength( ask.m_header, ret - sizeof(ask.m_header) );
	return ret;
}

int ConstructAskDetailBuffer( TW_ASK & ask, TW_STOCK * pStock )
{
	memset( &ask, 0, sizeof(ask) );
	ask.m_header.m_magic = TW_MAGIC;

	ask.m_tag1 = 0x01;
	ask.m_tag2 = 0x02;
	ask.m_size = 0x0001;
	memcpy( &(ask.m_stocks[0]), pStock, sizeof(TW_STOCK) );
	ask.m_serial = GetNextSerial(ask.m_stocks[0]);
	int ret = (6 + sizeof(ask.m_header) + sizeof(TW_STOCK));
	ConstructLength( ask.m_header, ret - sizeof(ask.m_header) );
	return ret;
}

int ConstructAskBaseBuffer( TW_ASK & ask, TW_STOCK * pStock )
{
	memset( &ask, 0, sizeof(ask) );
	ask.m_header.m_magic = TW_MAGIC;

	ask.m_tag1 = 0x05;
	ask.m_tag2 = 0x0b;
	ask.m_size = 0x0005;
	memcpy( &(ask.m_stocks[0]), pStock, sizeof(TW_STOCK) );
	ask.m_serial = GetNextSerial(ask.m_stocks[0]);
	int ret = (6 + sizeof(ask.m_header) + 5*sizeof(TW_STOCK));
	ConstructLength( ask.m_header, ret - sizeof(ask.m_header) );
	return ret;
}

size_t TryGetLength( TW_HEADER & header )
{
	if( TW_MAGIC != header.m_magic || 0 != header.m_end )
		return 0;
	int len = (int)strtol(header.m_length,NULL,16);
	if( len < 0 )
		return 0;
	return (size_t)len;
}

size_t TryGetLength( BYTE * buffer, size_t len )
{
	if( len < sizeof(TW_HEADER) )
		return 0;
	TW_HEADER * pheader = (TW_HEADER*)buffer;
	return TryGetLength( *pheader );
}

BOOL IsLoginOK( BYTE * buffer, size_t len )
{
	if( len < sizeof(TW_ANS) )
		return FALSE;
	TW_ANS * pans = (TW_ANS *)buffer;
	if( TW_MAGIC != pans->m_header.m_magic )
		return FALSE;
	if( 0x00 != pans->m_tag1 || 0x00 != pans->m_tag2 )
		return FALSE;
	return TRUE;
}

int TryGetInit( BYTE * buffer, size_t len, PRCV_DATA pRCV_DATA )
{
	if( len < sizeof(TW_ANS) )
		return 0;
	TW_ANS * pans = (TW_ANS*)buffer;
	if( TW_MAGIC != pans->m_header.m_magic )
		return 0;
	if( 0x02 != pans->m_tag1 || 0x01 != pans->m_tag2 )
		return 0;

	// get it, fill pRCV_DATA
	size_t dataoffset = 469;
	int datalen = len - dataoffset;

	CSPTime tLatest( CSPTime::GetLatestTradeTime(time(NULL)) );
	if( len > 128 )
	{
		DWORD date = (*(DWORD*)(buffer+45));
		CSPTime sptime;
		if( sptime.FromStockTimeDay( date ) )
			tLatest = CSPTime(sptime.GetYear(),sptime.GetMonth(),sptime.GetDay(),9,15,0).GetTime();
	}
	if( pRCV_DATA && datalen >= (int)sizeof(TW_ANS_INIT) )
	{
		// 每组28个字节, 共XXXX组,最后以0xfdfdfdfd为结尾
		TW_ANS_INIT * pinit = (TW_ANS_INIT*)(buffer+dataoffset);
		int packetsize = datalen/(int)sizeof(TW_ANS_INIT);

		memset( pRCV_DATA, 0, sizeof(RCV_DATA) );
		pRCV_DATA->m_wDataType	=	RCV_REPORT;	// no use
		pRCV_DATA->m_nPacketNum	=	packetsize;
		pRCV_DATA->m_bDISK		=	FALSE;
		pRCV_DATA->m_pReport	=	new RCV_REPORT_STRUCTEx[packetsize];
		memset( pRCV_DATA->m_pReport, 0, sizeof(RCV_REPORT_STRUCTEx)*packetsize );

		for( int i=0;i <packetsize; i++ )
		{
			if( pinit[i].m_tag != TW_MAGIC_BYTE )
				continue;
			pRCV_DATA->m_pReport[i].m_cbSize = sizeof(RCV_REPORT_STRUCTEx);
			pRCV_DATA->m_pReport[i].m_time = tLatest.GetTime();

			pRCV_DATA->m_pReport[i].m_wMarket = (pinit[i].m_type & 0x20) ? SZ_MARKET_EX : SH_MARKET_EX;
			pRCV_DATA->m_pReport[i].m_fLastClose = (float)(pinit[i].m_lastclose * 0.001);
			strncpy(pRCV_DATA->m_pReport[i].m_szLabel, pinit[i].m_code,
					min(sizeof(pRCV_DATA->m_pReport[i].m_szLabel),sizeof(pinit[i].m_code)));
			strncpy(pRCV_DATA->m_pReport[i].m_szName, pinit[i].m_name,
					min(sizeof(pRCV_DATA->m_pReport[i].m_szName),sizeof(pinit[i].m_name)));
			strncpy(pRCV_DATA->m_pReport[i].m_szName+sizeof(pinit[i].m_name)+2, pinit[i].m_shortname,
					min(sizeof(pRCV_DATA->m_pReport[i].m_szName)-sizeof(pinit[i].m_name)-2,sizeof(pinit[i].m_shortname)));
		}

		return len;
	}