hq_tcp.c

站长96年写的一个Internet上用的股票行情、分析、交易、资讯程序源码

#include <windows.h>
#include <windowsx.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <malloc.h>
#include <winsock.h>
#include <time.h>
#include <dos.h>
#include <io.h>

#include "appmain.h"
#include "pctcp.h"
#include "hq.h"
#include "hq_cl.h"
#include "hq_tcp.h" 
#include "caption.h"
#include "msg.h"

#include "fx.h"
#include "lzw.h"
#include "zlib.h"

extern BOOL ErrMsg(HWND, LPSTR);
extern HWND ghWndMain, ghWndHq, ghWndXlt, ghWndJlt, ghWndCj, ghWndLitHq,
			ghWndMmp, ghWndMaxMin, ghWndStatus, ghWndCaption;
extern HWND ghDlgJy, ghDlgChkUsr, ghDlgChgPwd, ghDlgBuySell, ghDlgCancel,
			ghDlgYecx, ghDlgWtcx, ghDlgCjcx;

extern BOOL run_cancelled;
extern int sdHq, sdJy;
extern char * ReadBuf;	//[MAX_READ_BUF_SIZE+1];  

extern char szDataPath[128];

extern BOOL IsZsRec(int, int);
extern LPSTR GetError(LPSTR);
extern HFILE hfZx;
extern int FxInit(LPFX Fx);
extern LPFX Fx;
extern BOOL gfOnLine,gfConnecting;

BOOL HqAllocMem(int);

int date_num =-1;
int GraRecalcJgMax();
int GraRecalcLcMax();
int MaxMinChangeHqData(int jys, int maxmin);
int GraGetMinPos(void);
void WriteMsg(LPSTR msg);
int UDP_Read_GetZqmc(LPSTR lpTmp, int len);
int UDP_Read_DataDay(LPSTR lpTmp, int len);
int UDP_Read_ChkUsr(LPSTR lpTmp, int len);

#define 	DATA_START_SIGN 	-16

extern char *IpSendBuffer,*IpCommitBuffer;
extern unsigned int IpSendLen,IpCommitLen;

void Ip_Commit_Pack(int len,char *buff)
{   
	IpCommitLen =len;
	memcpy(IpCommitBuffer,buff,len);	
}
	
BOOL  Ip_Send_Pack()
{   
	int x,k,this;
    char tmp[100];
	
	if(IpCommitLen ==0)	
		return TRUE;
	if(IpSendLen!=0)	
		return TRUE;
	//if((x=check_socket_status(sdHq))!=0)
	//	return TRUE;
	
	memcpy(IpSendBuffer,IpCommitBuffer,IpCommitLen);
	IpSendLen = IpCommitLen;
	IpCommitLen =0;
	
	for(k=0,x=0;k<1000;k++)
	{
		this = send(sdHq,IpSendBuffer, IpSendLen-x, 0);
		if (this == SOCKET_ERROR)
		{                          
			if ((this =h_errno) != WSAEWOULDBLOCK)
			{
				strcpy(tmp,"不能接收主机信息！");
				ErrMsg(ghWndMain, GetError(tmp));
				gfOnLine=FALSE;
				return FALSE;
			}
		}
		if(x+this!=(int)IpSendLen)
			x+=this;
		else
			break;		
	}
	IpSendLen =0;
	return	TRUE;
}   

int UDP_Send_Hq(LPSTR lpString, LPSTR lpHead, int len)
{
	char tmp2[MAX_WRITE_BUF_SIZE+1];
	int x=0,tlen;
	
	if(!gfOnLine||gfConnecting) return 0;
    
    memset(&tmp2[0],0,sizeof(MAX_WRITE_BUF_SIZE));
    tmp2[0]=DATA_START_SIGN;
    *(int *)&tmp2[1]=len;    
	memcpy(&tmp2[1+sizeof(int)], lpString, len);
	
	tlen = 1+sizeof(int) + len;
	
	Ip_Commit_Pack(tlen, &tmp2[0]);
	return len;
}

extern FILE *fp;

#define		DATA_HEAD_SIZE	3

char dataHead[DATA_HEAD_SIZE+1];
int  HeadPrt=0,dataPrt=0 ;
 
int AnaRecvData(void)
{
  int prt,len,try_times,dataNum,ret;
  char temp[MAX_READ_BUF_SIZE+1];  

   prt=len=try_times=dataNum=0;
   
retry_read:
	if(try_times ++>MAX_UDP_TRY_TIMES)
	{
		ErrMsg(ghDlgJy, "recv error");
		DrawTime(RED_SIGN);
		return -1;
	}	
	DrawTime(GREEN_SIGN);
	memset((char *)&temp[0],0,MAX_READ_BUF_SIZE*sizeof(char));
	len = recv(sdHq,(char *)&temp[0],MAX_READ_BUF_SIZE*sizeof(char),0);
	if (len == SOCKET_ERROR) 
	{
		ret =h_errno;
		if (ret == WSAEWOULDBLOCK)
			goto retry_read;
		else if(ret ==WSAEINPROGRESS)
			return 0;
		else
		{
			ErrMsg(ghDlgJy, GetError("recv cancel error"));
			if(ConnectHost(0, -1)<0)
			{
				ErrMsg(ghDlgJy, "Reconnect failed");
				DrawTime(RED_SIGN);
				return -1;
			}
		}
	}
	if(len <=0) 
	{
		DrawTime(RED_SIGN);
		return -1;
    } 
    if(len>4)
    {
    	if(temp[0]==DATA_START_SIGN && HeadPrt!=0 &&temp[3]>='A' && temp[3]<='Z')
    	{
     		dataPrt=0; 
     		HeadPrt=0;
    	}
    }	
    while(prt<len)
    {
     	if(HeadPrt<DATA_HEAD_SIZE)
     	{
     		if(HeadPrt==0)
     		{
     			if(temp[prt]!=DATA_START_SIGN)
     			{
     				prt++;         //Data frame lose its start mark!
					DrawTime(RED_SIGN);
     				continue;
     			}     			
     			else
     			{
					DrawTime(GREEN_SIGN);
     			    dataHead[HeadPrt]=temp[prt];
     			    HeadPrt++;
     				prt++;
     			}	
     		}
     		if(prt>=len)
     		{                      //Data frame just include its start mark
     			DrawTime(YELLOW_SIGN);
     			return 0;
     		}	
     		if(DATA_HEAD_SIZE - HeadPrt	>len-prt)
     		{                      //data frame not total head info
     			memcpy((char*)&dataHead[HeadPrt],(char*)&temp[prt],len-prt);
     			HeadPrt+=len-prt;
				DrawTime(YELLOW_SIGN);
		   		return 0;
     		}
     		else
     		{
     			memcpy((char*)&dataHead[HeadPrt],(char*)&temp[prt],DATA_HEAD_SIZE - HeadPrt);
     			prt+=DATA_HEAD_SIZE - HeadPrt;
     			HeadPrt=DATA_HEAD_SIZE;
     		}     			
     	}
     	
     	if(prt>=len)
     	{                          //Just head info
			DrawTime(YELLOW_SIGN);
     		return 0;
     	}	
     	dataNum=*(int *)&dataHead[1];
     	if(dataNum<=0)
     	{                          //Data Error,we must lose this bad data frame!
			DrawTime(RED_SIGN);
     		return -1;
     	}
     	if(dataNum-dataPrt  > len - prt)
     	{                          //Not total data frame
     		memcpy((char FAR *)&ReadBuf[dataPrt],(char*)&temp[prt],len-prt);
     		dataPrt+=len-prt;
			DrawTime(YELLOW_SIGN);
     		return 0;
     	}
     	else
     	{
     		memcpy((char FAR *)&ReadBuf[dataPrt],(char*)&temp[prt],dataNum-dataPrt);
     		prt+=dataNum-dataPrt;
     		dataPrt=dataNum;

     		UDP_Client_ReadHq();
     		dataPrt=0; 
     		HeadPrt=0;
     		dataNum=0;
     	}
     	
     	if(prt>=len)
     	{
     		dataPrt=0; 
     		HeadPrt=0;
     		dataNum=0;
			DrawTime(BLACK_SIGN);
     		return 0;     		
     	}	
    }
    DrawTime(BLACK_SIGN);
    return 0;    
    
}

int curPos =0, curLen =0;;
int UDP_Client_ReadHq(void)
{
	LPSTR lpTmp;
	int len;        
    
    len=dataPrt;
    
	lpTmp =&ReadBuf[0];
	
	if(!strnicmp(HQ00_HEAD, lpTmp, strlen(HQ00_HEAD)))
		UDP_Read_Hq00(lpTmp+strlen(HQ00_HEAD)+sizeof(short), len -strlen(HQ00_HEAD)-sizeof(short));
	else if(!strnicmp(HQ01_HEAD, lpTmp, strlen(HQ01_HEAD)))
		UDP_Read_Hq01(lpTmp+strlen(HQ01_HEAD)+sizeof(short), len -strlen(HQ01_HEAD)-sizeof(short));
	else if(!strnicmp(HQ10_HEAD, lpTmp, strlen(HQ10_HEAD)))
		UDP_Read_Hq10(lpTmp+strlen(HQ10_HEAD)+sizeof(short), len -strlen(HQ10_HEAD)-sizeof(short));
	else if(!strnicmp(GRA00_HEAD, lpTmp, strlen(GRA00_HEAD)))
		UDP_Read_Gra00(lpTmp+strlen(GRA00_HEAD)+sizeof(short), len -strlen(GRA00_HEAD)-sizeof(short));
	else if(!strnicmp(GRA01_HEAD, lpTmp, strlen(GRA01_HEAD)))
		UDP_Read_Gra01(lpTmp+strlen(GRA01_HEAD)+sizeof(short), len -strlen(GRA01_HEAD)-sizeof(short));
	else if(!strnicmp(GRA10_HEAD, lpTmp, strlen(GRA10_HEAD)))
		UDP_Read_Gra10(lpTmp+strlen(GRA10_HEAD)+sizeof(short), len -strlen(GRA10_HEAD)-sizeof(short));
	else if(!strnicmp(MMP_HEAD, lpTmp, strlen(MMP_HEAD)))
		UDP_Read_Mmp(lpTmp+strlen(MMP_HEAD)+sizeof(short), len -strlen(MMP_HEAD)-sizeof(short));
	else if(!strnicmp(MAXMIN10_HEAD, lpTmp, strlen(MAXMIN10_HEAD)))
		UDP_Read_MaxMin10(lpTmp+strlen(MAXMIN10_HEAD)+sizeof(short), len -strlen(MAXMIN10_HEAD)-sizeof(short));
	else if(!strnicmp(DP_HEAD, lpTmp, strlen(DP_HEAD)))
		UDP_Read_Dp(lpTmp+strlen(DP_HEAD)+sizeof(short), len -strlen(DP_HEAD)-sizeof(short));
	else if(!strnicmp(ZX_HEAD, lpTmp, strlen(ZX_HEAD)))
		UDP_Read_Zx(lpTmp+strlen(ZX_HEAD)+sizeof(short), len -strlen(ZX_HEAD)-sizeof(short));
	else if(!strnicmp(MSG_HEAD, lpTmp, strlen(MSG_HEAD)))
		MessageBox(NULL, lpTmp+strlen(MSG_HEAD)+sizeof(short),"主机信息", MB_OK);
	else if(!strnicmp(GETZQMC_HEAD, lpTmp, strlen(GETZQMC_HEAD)))
		UDP_Read_GetZqmc(lpTmp+strlen(GETZQMC_HEAD)+sizeof(short), len -strlen(GETZQMC_HEAD)-sizeof(short));
	else if(!strnicmp(DATA_DAY_HEAD,lpTmp,strlen(DATA_DAY_HEAD)))
		UDP_Read_DataDay(lpTmp+strlen(DATA_DAY_HEAD)+sizeof(short),len -strlen(DATA_DAY_HEAD)-sizeof(short));
	else if(!strnicmp(HQ_CHKUSR_HEAD, lpTmp, strlen(HQ_CHKUSR_HEAD)))
		UDP_Read_ChkUsr(lpTmp+strlen(HQ_CHKUSR_HEAD)+sizeof(short),len -strlen(HQ_CHKUSR_HEAD)-sizeof(short));
	else if(!strnicmp(RECV_FILE_HEAD, lpTmp, strlen(RECV_FILE_HEAD)))
		UDP_Recv_File(lpTmp+strlen(RECV_FILE_HEAD),len-strlen(RECV_FILE_HEAD));	
	else if(!strnicmp(ERROR_HEAD, lpTmp, strlen(ERROR_HEAD)))
		MessageBeep(0);
	else
	{
		DrawTime(3);
		MessageBeep(0);
	}       
	curPos =len-curLen;
	
	return 0;
}

int UDP_Read_NotRun(LPSTR lpTmp, int len)
{
	HqTime[HqPaintData.jys].fRunning =FALSE;
	
	return 0;
}

extern int CheckTime(BOOL);
int hq_state =-1, hq_jys =0, hq_rec_first =0, hq_rec_count =0;
int UDP_Read_Hq00(LPSTR lpTmp, int len)
{
	int i, j, jys;
	static int fFirst[2];
	time_t ltime;
	//struct tm *ptm;
	//struct _dostime_t dtime;
	
	jys =*lpTmp;

	lpTmp +=1;          
	len -=1;
	if(len <=0) goto readhq00Err;
	
	HqData[jys].recCount =*(short *)lpTmp;
	if(jys ==HqPaintData.jys)
		HqPaintData.recCount =HqData[jys].recCount;
	
	if(HqData[jys].recCount >MAX_HQ_REC_COUNT) goto readhq00Err;
	lpTmp +=sizeof(short);
	len -=sizeof(short);
		
	if(len <sizeof(short)*4) goto readhq00Err;
		
	memcpy(&HqTime[jys], lpTmp, sizeof(HqTime[jys])-sizeof(BOOL));
		
	len -=sizeof(HqTime[jys])-sizeof(BOOL);
	lpTmp +=sizeof(HqTime[jys])-sizeof(BOOL);
	
	if(jys ==0 && len >0)
	{
		memcpy(&ltime, lpTmp, sizeof(time_t));
		len -=sizeof(time_t);
		lpTmp +=sizeof(time_t);
		//ptm =gmtime(&ltime);
		//dtime.hour =ptm->tm_hour;
		//dtime.minute =ptm->tm_min;
		//dtime.second =ptm->tm_sec;
		//_dos_settime(&dtime);
		date_num =*lpTmp;
		lpTmp ++;
		len --;
	}
	
	HqTime[jys].am_min_count -=HqTime[jys].am_min_start;
	HqTime[jys].pm_min_count -=HqTime[jys].pm_min_start;
		
	i =HqTime[0].am_min_count+HqTime[0].pm_min_count+2;
	j =HqTime[1].am_min_count+HqTime[1].pm_min_count+2;
	if(j>i) i =j;

	if(GraphData.lpMinPos ==NULL)
		GraphData.lpMinPos =(short *)GlobalAllocPtr(GHND, i*sizeof(short));
	else
		GraphData.lpMinPos =(short *)GlobalReAllocPtr(GraphData.lpMinPos,
					i*sizeof(short), GMEM_MOVEABLE);

	if(GraphData.lpMinPos ==NULL)
	{
		GraphData.minEnd =0;
		ErrMsg(NULL,"alloc record data memory failed!");
		return FALSE;
	}
		
	if(GraphData.lpMinLc ==NULL)
		GraphData.lpMinLc =(long *)GlobalAllocPtr(GHND, i*sizeof(long));
	else
		GraphData.lpMinLc =(long *)GlobalReAllocPtr(GraphData.lpMinLc,
					i*sizeof(long), GHND);

	if(GraphData.lpMinLc ==NULL)
	{
		GraphData.minEnd =0;
		ErrMsg(NULL,"alloc record data memory failed!");
		return FALSE;
	}
		
	if(!HqAllocMem(jys))
		goto readhq00Err;
		
	if(HqPaintData.fldCount <=0)
	{
		HqPaintData.fldCount =HQ_FLDS_COUNT;
		for(i =0; i<HqPaintData.fldCount; i++)
			HqPaintData.fldNum[i] =i;
	}
	for(i =0; i<HqData[jys].recCount; i++)
		HqPaintData.sortData.key[i] =i;
		
	fFirst[jys] =0;
	CheckTime(FALSE);
	hq_state =1;
	return 0;
readhq00Err:
	DrawTime(3);
	MessageBeep(0);
	return -1;
}

int UDP_Read_Hq01(LPSTR lpTmp, int len)
{
	int i, jys;
	int recCount, recNum;
	BOOL isRefresh =FALSE, isSel =FALSE;
	
	jys =(BOOL)*lpTmp;
	lpTmp +=1; len -=1;
	if(len <=0)
	{
		KillTimer(ghWndHq, 5);	
		ErrMsg(ghWndMain, "读HQ01错，数据包长度不足!");	
	 	goto readhq01Err;		 	
	}
	if(HqData[jys].recCount <=0)
	{ 
		KillTimer(ghWndHq, 5);	
		ErrMsg(ghWndMain, "读HQ01错，数据包记录数错！");
		goto readhq01Err;
	}
	isRefresh =(BOOL)*lpTmp;
	lpTmp++; len --;
	isSel =(BOOL)*lpTmp;
	lpTmp++; len --;
	recCount =*(short *)lpTmp; 
	if(recCount <=0)
	{
		KillTimer(ghWndHq, 5);
		ErrMsg(ghWndMain, "读HQ01错，读记录数为零!");
		goto readhq01Err;
	}
	lpTmp +=sizeof(short);
	len -=sizeof(short);
	if(len <=0) goto readhq01Err;   
	
	for(i =0; i<recCount; i++)
	{
		if(len <0) break;
		recNum =*(short *)lpTmp;
		len-=2; lpTmp +=2;
		if(recNum >=HqData[jys].recCount)
		{
			ErrMsg(ghWndMain, "读HQ01错，读记录编号大于记录数!");
			goto readhq01Err;
		}   	
		if(!isRefresh)
		{
			memcpy(&HqData[jys].lpPreData[recNum],
				lpTmp, sizeof(HQ_PRE_DATA));
			len -=sizeof(HQ_PRE_DATA);
			lpTmp +=sizeof(HQ_PRE_DATA);
		}
		memcpy(&HqData[jys].lpRefData[recNum],
			lpTmp, sizeof(HQ_REF_DATA));
		len -=sizeof(HQ_REF_DATA);
		lpTmp +=sizeof(HQ_REF_DATA);
		HqData[jys].isReadOK[recNum] =TRUE;
	}
	if(IsWindowVisible(ghWndHq))
		SendMessage(ghWndHq, WM_HQ_REFRESH, jys, 0L);
	return 0;
readhq01Err:
	DrawTime(3);
	MessageBeep(0);
	return -1;
}

int UDP_Read_Hq10(LPSTR lpTmp, int len)
{
	int i, jys;
	int rec_count, rec_num;
	float oldjg;
	//long lc;
	
	jys =*lpTmp++;
	len --;
	if(jys >1) goto readhq10Err;
	
	rec_count =*(short *)lpTmp; 
	lpTmp+=2; len -=2;
	if(rec_count >HqData[jys].recCount || rec_count <=0) goto readhq10Err;
	//if(rec_count >MAX_HQ_SENDCOUNT) goto readhq10Err;
	if(len <rec_count*(int)sizeof(HQ_REF_DATA))
		goto readhq10Err;
		
	//memcpy(&HqData[jys].lpRefData[rec_first], rec_count*sizeof(HQ_REF_DATA));
	
	for(i =0; i<rec_count; i++)
	{
		if(len <=0) break;
		rec_num =*(short *)lpTmp;
		if(rec_num >HqData[jys].recCount) break;
		lpTmp+=sizeof(short);
		len -=sizeof(short);
		oldjg =HqData[jys].lpRefData[rec_num].zjjg;
		memcpy(&HqData[jys].lpRefData[rec_num], lpTmp, sizeof(HQ_REF_DATA));
		HqData[jys].isJgChanged[rec_num] =(BOOL)((HqData[jys].lpRefData[rec_num].zjjg-oldjg)*100);
		if(HqData[jys].isJgChanged[rec_num])    MessageBeep(0);
		len -=sizeof(HQ_REF_DATA);
		lpTmp +=sizeof(HQ_REF_DATA);

		HqData[jys].isLcChanged[rec_num] =TRUE;
	}
	
	if(IsWindowVisible(ghWndHq))
		SendMessage(ghWndHq, WM_HQ_REFRESH, jys, 0L);
	else if(IsWindowVisible(ghWndLitHq))
	{
		SendMessage(ghWndLitHq, WM_READ_OK, jys, 0L);
	}
	
	return 0;

readhq10Err:
	DrawTime(3);
	return -1;
}
////////////////////////////////////////////////////////////////////////////
//Function:This func receive deatial pricr voulmn file head information data
//         from server,then get memory according to minTotal data.
//
int UDP_Read_Gra00(LPSTR lpTmp, int len)
{
	int jys;
	
	jys =*lpTmp;
	if(GraphData.jys !=jys) return 0;

	lpTmp +=1; len -=1;
	if(len <=0) return -1;

	memcpy(&GraphData.GraHead, lpTmp, sizeof(GRA_HEAD));
	//GraphData.GraHead.zrsp =HqData[jys].lpPreData[GraphData.recNum].zrsp;

	if(GraphData.lpGraData ==NULL)
		GraphData.lpGraData =(GRA_DATA huge *)GlobalAllocPtr(GHND,
				(long)GraphData.GraHead.minTotal*sizeof(GRA_DATA));
	else
		GraphData.lpGraData =(GRA_DATA huge *)GlobalReAllocPtr(
			GraphData.lpGraData,(long)GraphData.GraHead.minTotal*sizeof(GRA_DATA),
			GMEM_MOVEABLE);
			
	if(GraphData.lpGraData ==NULL)
	{
		ErrMsg(NULL, "不能分配成交明细数据内存!");
		return -1;
	}
	
	GraRecalcJgMax();
	GraRecalcLcMax();
	return 0;
}

////////////////////////////////////////////////////////////////////////
//This func to get data info from server,then compute it
//
int UDP_Read_Gra01(LPSTR lpTmp, int len)
{
	int min_num, min_count;