hq_tcp.c

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

	char temp[128];
	HFILE hf;
	OFSTRUCT os;
		
	if(GraphData.lpGraData ==NULL)
		return 0;
	if(*lpTmp++ !=GraphData.jys)
		return -1;	
	len -=1;
	if(len <=0) return -1;

	if(*(int *)lpTmp !=GraphData.recNum)
		return -1;
	lpTmp +=sizeof(int);
	len -=sizeof(int);
	if(len <=0) return -1;
		
	min_count =*(int *)lpTmp; //data num this times
	lpTmp +=sizeof(int);
	len -=sizeof(int);
	if(len <=0) return -1;
		
	min_num =*(int *)lpTmp;	  //Last data tail
	lpTmp +=sizeof(int);
	len -=sizeof(int);
	if(len <=0) return -1;
	if(min_num +min_count >GraphData.GraHead.minTotal) return -1;
		
	min_count =len/sizeof(GRA_DATA);
	memcpy(&GraphData.lpGraData[min_num], lpTmp, min_count*sizeof(GRA_DATA));
	//GraphData.GraHead.zrsp =HqData[GraphData.jys].lpPreData[GraphData.recNum].zrsp;

	GraphData.minEndPrev =min_num;
	GraphData.minEnd =min_num+min_count;
	GraphData.fRefreshDraw =TRUE;

	GraGetMinPos();	
	wsprintf(temp, "%s\\%s.dat", szDataPath, HqData[GraphData.jys].lpPreData[GraphData.recNum].zqdm);
	hf =OpenFile(temp, &os, OF_SHARE_DENY_NONE|OF_READWRITE);
	if(hf ==HFILE_ERROR)
		hf =OpenFile(temp, &os, OF_SHARE_DENY_NONE|OF_CREATE|OF_WRITE);
	if(hf !=HFILE_ERROR)
	{
		if(_lwrite(hf, &GraphData.GraHead, sizeof(GraphData.GraHead))
				==sizeof(GraphData.GraHead))
		{
			if(_llseek(hf, (long)sizeof(GRA_HEAD)
					+(long)sizeof(GRA_DATA)*min_num, SEEK_SET)
					==HFILE_ERROR)
			{
				_llseek(hf, sizeof(GRA_HEAD), SEEK_SET);
				_hwrite(hf, &GraphData.lpGraData[0],
						(long)sizeof(GRA_DATA)*min_num);
			}
			_hwrite(hf, &GraphData.lpGraData[min_num],
					(long)sizeof(GRA_DATA)*min_count);
		}
		_lclose(hf);
	}

	GraphData.fRefreshDraw =FALSE;
	if(IsWindowVisible(ghWndXlt))
	{
		if(GraRecalcJgMax() ==0)
			SendMessage(ghWndXlt, WM_READ_OK, 1, 0L);
		else SendMessage(ghWndXlt, WM_READ_OK, 0, 0L);
		
		if(GraRecalcLcMax() ==0)
			InvalidateRect(ghWndJlt, NULL, TRUE);
		else
			InvalidateRect(ghWndJlt, NULL, FALSE);
		SendMessage(ghWndCj, WM_READ_OK, 0, 0L);
	}
	return 0;
}

int UDP_Read_Gra10(LPSTR lpTmp, int len)
{
	int min_num, min_count;
	char temp[128];
	HFILE hf;
	OFSTRUCT os;
	GRA_HEAD GraHead;
		
	if(GraphData.lpGraData ==NULL) return 0;
	if(*lpTmp++ !=GraphData.jys !=0) goto readgra10Err;
    
	len -=1;
	if(len <=0) goto readgra10Err;
		
	if(*(int *)lpTmp !=GraphData.recNum) goto readgra10Err;
	lpTmp+=sizeof(int);
	len-=sizeof(int);
		
	min_count =*(int *)lpTmp;
	lpTmp +=sizeof(int);
	len -=sizeof(int);
	if(len <=0) goto readgra10Err;
	
	min_num =*(int *)lpTmp;
	if(min_num !=GraphData.minEnd)
	{
		MessageBeep(0);
		//goto readgra10Err;
	}
	lpTmp +=sizeof(int);
	len -=sizeof(int);
	if(len <=0) goto readgra10Err;
		
	//memcpy(&GraHead, lpTmp, sizeof(GRA_HEAD));
	//lpTmp +=sizeof(GRA_HEAD);
	//len -=sizeof(GRA_HEAD);
		
	min_count =len/sizeof(GRA_DATA);
	GraphData.lpGraData =(GRA_DATA huge *)GlobalReAllocPtr(
				GraphData.lpGraData,
				(long)(min_num+min_count)*sizeof(GRA_DATA),
				GMEM_MOVEABLE);
	if(GraphData.lpGraData ==NULL)
	{
		ErrMsg(NULL, "Gra10: alloc mem failed");
		return -1;
	}
	memcpy(&GraphData.lpGraData[min_num], lpTmp, min_count*sizeof(GRA_DATA));
		
	GraphData.minEndPrev =min_num;
	GraphData.GraHead.minTotal =GraphData.minEnd =min_num+min_count;
	
	GraphData.fRefreshDraw =TRUE;
	
	GraGetMinPos();
	
	if(IsWindowVisible(ghWndXlt))
	{
		if(GraRecalcJgMax() ==0)
			SendMessage(ghWndXlt, WM_READ_OK, 1, 0L);
		else SendMessage(ghWndXlt, WM_READ_OK, 0, 0L);
		
		if(GraRecalcLcMax() ==0)
			InvalidateRect(ghWndJlt, NULL, TRUE);
		else
			InvalidateRect(ghWndJlt, NULL, FALSE);
		InvalidateRect(ghWndCj, NULL, TRUE);
	}
	
	wsprintf(temp, "%s\\%s.dat", szDataPath, HqData[GraphData.jys].lpPreData[GraphData.recNum].zqdm);
	hf =OpenFile(temp, &os, OF_SHARE_DENY_NONE|OF_READ);
	if(hf !=HFILE_ERROR)
	{
		memcpy(&GraHead, &GraphData.GraHead, sizeof(GraHead));
		GraHead.minTotal =GraphData.minEnd;
		if(_lwrite(hf, &GraHead, sizeof(GraHead)) ==sizeof(GraHead))
		{
			if(_llseek(hf, (long)sizeof(GRA_HEAD)
					+(long)sizeof(GRA_DATA)*min_num, SEEK_SET)
					==HFILE_ERROR)
			{
				_llseek(hf, sizeof(GRA_HEAD), SEEK_SET);
				_hwrite(hf, &GraphData.lpGraData[0],
						(long)sizeof(GRA_DATA)*min_num);
			}
			_hwrite(hf, &GraphData.lpGraData[min_num],
					(long)sizeof(GRA_DATA)*min_count);
		}
		_lclose(hf);
	}
	GraphData.fRefreshDraw =FALSE;
	
	if(IsWindowVisible(ghWndXlt))
	{
		if(GraRecalcJgMax() ==0)
			SendMessage(ghWndXlt, WM_READ_OK, 1, 0L);
		else SendMessage(ghWndXlt, WM_READ_OK, 0, 0L);
		
		if(GraRecalcLcMax() ==0)
			InvalidateRect(ghWndJlt, NULL, TRUE);
		else
			InvalidateRect(ghWndJlt, NULL, FALSE);
		InvalidateRect(ghWndCj, NULL, TRUE);
	}

	return 0;

readgra10Err:
	DrawTime(3);
	return -1;      
}

int UDP_Read_Mmp(LPSTR lpTmp, int len)
{
	int jys;
	
	jys =*lpTmp;
	
	lpTmp ++;          
	len --;
	if(len <=0) goto readmmpErr;
		
	//if(*(int *)lpTmp !=rec_num) goto sendmmp;
	len -=sizeof(int);
	lpTmp +=sizeof(int);
	    
	if(len !=sizeof(MMP_DATA)-2*sizeof(int)) goto readmmpErr;
	memcpy(&MmpData.jwBuy[0], lpTmp, sizeof(MMP_DATA)-2*sizeof(int));
	
	InvalidateRect(ghWndMmp, NULL, TRUE);
	return 0;

readmmpErr:
	DrawTime(3);
	return -1;
}

int UDP_Read_MaxMin10(LPSTR lpTmp, int len)
{
	int jys, i, j, recCount;
	int maxmin;
	char  WriteBuf[MAX_WRITE_BUF_SIZE+1];
		   
	jys =*lpTmp;
	if(jys !=GraphData.jys) return 0;
	lpTmp +=1;          
	len -=1;

	maxmin =*lpTmp;
	if(maxmin >1)
	{
		MessageBeep(0);
		return -1;
	}

	lpTmp++;
	len --;
	if(len <sizeof(MAXMIN_DATA)) goto readmaxmin10Err;

	memcpy(&MaxMinData[jys][maxmin], lpTmp, sizeof(MAXMIN_DATA));
	MaxMinChangeHqData(jys, maxmin);
	strcpy(WriteBuf, GETZQMC_HEAD);
	len =strlen(WriteBuf);
	WriteBuf[len++] =jys;
	*(short *)&WriteBuf[len] =0;
	len +=sizeof(short);
	
	recCount =0;
	for(i =0; i<4; i++)
	{
		for(j =0; j<10; j++)
		{
			if(HqData[jys].lpPreData[MaxMinData[jys][maxmin].recNum[i][j]].zqmc[0] ==0)
			{
				*(short *)&WriteBuf[len] =MaxMinData[jys][maxmin].recNum[i][j];
				len +=sizeof(short);
				recCount ++;
			}
		}
	}
	if(recCount)
	{
		*(short *)&WriteBuf[strlen(GETZQMC_HEAD)+1] =recCount;
		UDP_Send_Hq(WriteBuf, GETZQMC_HEAD, len);
	}       
	InvalidateRect(ghWndMaxMin, NULL, TRUE);
	
	return 0;

readmaxmin10Err:
	DrawTime(3);
	return -1;
}

int UDP_Read_GetZqmc(LPSTR lpTmp, int len)
{
	int jys, i, recCount, recNum;
	
	jys =*lpTmp++;
	recCount =*(short *)lpTmp;
	lpTmp +=sizeof(short);
	for(i =0; i<recCount; i++)
	{
		recNum =*(short *)lpTmp;
		lpTmp+=sizeof(short);
		if(recNum >HqData[jys].recCount) return -1;
		strncpy(HqData[jys].lpPreData[recNum].zqmc, lpTmp, MAX_ZQMC_SIZE);
		lpTmp +=MAX_ZQMC_SIZE;
	}
	if(IsWindowVisible(ghWndMaxMin))
		InvalidateRect(ghWndMaxMin, NULL, FALSE);
		
	return 0;
}

int UDP_Read_Dp(LPSTR lpTmp, int len)
{
	int jys;
	
	if(len <sizeof(DpData)) goto readdpErr;
	memcpy(&DpData, lpTmp, sizeof(DpData));
	for(jys =0; jys<2; jys ++)
		if(DpData[jys].npbl >(float)1 || DpData[jys].npbl <(float)0)
			DpData[jys].npbl =(float)0.5;
	if(ghWndStatus) InvalidateRect(ghWndStatus, NULL, FALSE);
	return 0;
	
readdpErr:
	DrawTime(3);
	return -1;
}

int UDP_Send_Zx(void)
{
	int len;
	char  WriteBuf[MAX_WRITE_BUF_SIZE+1];
	
	strcpy(WriteBuf, ZX_HEAD);
	len =strlen(WriteBuf);
	*(long *)&WriteBuf[len] =ZxData.len;
	len +=sizeof(long);
	return UDP_Send_Hq(WriteBuf, ZX_HEAD, len);
}

int UDP_Send_Stock_Info(STOCK_INFO_FRAME *StockInfoFrame)
{
   int len;
   char  WriteBuf[MAX_WRITE_BUF_SIZE+1];
   
   strcpy(WriteBuf,STOCK_INFO_HEAD);
   len=strlen(STOCK_INFO_HEAD);
   memcpy(&WriteBuf[len],StockInfoFrame,sizeof(STOCK_INFO_FRAME));
   len+=sizeof(STOCK_INFO_FRAME);
   return UDP_Send_Hq(WriteBuf,STOCK_INFO_HEAD,len);
}

int UDP_Read_Zx(LPSTR lpTmp, int len)
{
    char temp[80];
    OFSTRUCT os;
    
	strcpy(temp, szDataPath);
	strcat(temp, "\\zx.txt");
	hfZx =OpenFile(temp, &os, OF_SHARE_DENY_NONE|OF_READWRITE);
	if(hfZx ==HFILE_ERROR) return(-1);
	if(len <=0)
	{
		_lclose(hfZx);
		return(-1);
	}	
	_llseek(hfZx, 0, SEEK_END);
	ZxData.len +=len;
	_lwrite(hfZx, lpTmp, len);
	_lclose(hfZx);
	SendMessage(ghWndCaption, WM_USER+1, 0, (LPARAM)(ZxData.len-len));
	return 0;
}

int UDP_Send_Hq00(int jys, BOOL fFirst, int fRefresh, int fSel, int recCount, short *recList)
{
	int i, len, rec_num, list_count;
	char WriteBuf[MAX_WRITE_BUF_SIZE+1];
	
	//hq_state =0;
	//hq_jys =jys;
	KillTimer(ghWndHq, 5);
	SetTimer(ghWndHq, 5, 5000, NULL);
	
	strcpy(WriteBuf, HQ00_HEAD);
	len =strlen(HQ00_HEAD);
	WriteBuf[len++] =CLIENT_VERSION;
	WriteBuf[len++] =(BYTE)jys;
	if(HqData[jys].isReadOK ==NULL || HqData[jys].isReadOK[0] ==FALSE)
		fFirst =TRUE;
	WriteBuf[len++] =(BYTE)fFirst;
	WriteBuf[len++] =(BYTE)fRefresh;
	WriteBuf[len++] =(BYTE)fSel;
	*(short *)&WriteBuf[len] =recCount;
	len +=sizeof(short);
	
	if(!fSel) list_count =1;
	else list_count =recCount;
	
	memcpy(&WriteBuf[len], recList, sizeof(short)*list_count);
	len +=sizeof(short)*list_count;
	if(fRefresh)
	{
		for(i =0; i<recCount; i++)
		{
			if(fSel) rec_num =recList[i];
			else rec_num =recList[0]+i;
			*(long *)&WriteBuf[len] =HqData[jys].lpRefData[rec_num].cjss;
			len +=sizeof(long);
		}
	}
	return UDP_Send_Hq(&WriteBuf[0], HQ00_HEAD, len);
}

////////////////////////////////////////////////////////////////////////
//Function	:to draw price-volumn diagram per min,This func open deatail 
//           data file according to stock code,compute it,biuld integer
//			 set diagram data.then send a requst to server to get other 
//           deatail voulmn file on server
//
//

int UDP_Send_Gra00(int jys, int rec_num)
{
	HFILE hf;
	OFSTRUCT os;
	char temp[100];
	int len = 0;   
	char  WriteBuf[MAX_WRITE_BUF_SIZE+1];
                
	KillTimer(ghWndHq, 5);
	
	GraphData.jys =jys;
	GraphData.recNum =rec_num;

	GraphData.minEndPrev =0;
	GraphData.minEnd =0;
	GraphData.GraHead.dateNum =date_num;
	    
	wsprintf(temp, "%s\\%s.dat", szDataPath, HqData[jys].lpPreData[rec_num].zqdm);
	hf =OpenFile(temp, &os, OF_SHARE_DENY_NONE|OF_READ);
	if(hf !=HFILE_ERROR)
	{
		if(_lread(hf, &GraphData.GraHead, sizeof(GraphData.GraHead))
				==sizeof(GraphData.GraHead))
		{
			if(gfOnLine && GraphData.GraHead.dateNum !=date_num)
			{
				GraphData.GraHead.dateNum =date_num;
				GraphData.minEnd =GraphData.minEndPrev =GraphData.GraHead.minTotal =0;
				goto read_ok;
			}
			if(GraphData.GraHead.minTotal)
			{
				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),
							GHND);
			
				if(GraphData.lpGraData !=NULL)
				{
					if(_hread(hf, &GraphData.lpGraData[0],
							(long)GraphData.GraHead.minTotal*sizeof(GRA_DATA))
							!=(long)GraphData.GraHead.minTotal*sizeof(GRA_DATA))
					{
						GraphData.GraHead.dateNum =date_num;
						GraphData.minEndPrev =GraphData.minEnd =0;
					}
					else
					{
						GraphData.minEndPrev =0;
						GraphData.minEnd =GraphData.GraHead.minTotal;
						GraGetMinPos();
						GraRecalcJgMax();
						GraRecalcLcMax();

						if(IsWindowVisible(ghWndXlt))
						{
							SendMessage(ghWndJlt, WM_READ_OK, 0, 0L);
							if(!IsZsRec(GraphData.jys, GraphData.recNum))
								SendMessage(ghWndCj, WM_READ_OK, 0, 0L);
						}
					}
				}
				else
				{
					ErrMsg(NULL, "Alloc mem failed!");
					_lclose(hf);
					return -1;
				}
			}
		}
read_ok:
		_lclose(hf);
	}                       
	//GraphData.GraHead.zrsp =HqData[jys].lpPreData[rec_num].zrsp;

	strcpy(WriteBuf, GRA00_HEAD);
	len =strlen(WriteBuf);
	WriteBuf[len++] =jys;
	WriteBuf[len++] =(BYTE)GraphData.GraHead.dateNum;
	*((int *)&WriteBuf[len]) =rec_num;
	len +=sizeof(int);
	*(short *)&WriteBuf[len] =GraphData.minEnd;
	len +=sizeof(short);
	
	return UDP_Send_Hq(&WriteBuf[0], GRA00_HEAD, len);
}

int UDP_Send_Gra01(void)//int min_first, int min_count)
{
	int len= 0;   
	char  WriteBuf[MAX_WRITE_BUF_SIZE+1];

	strcpy(WriteBuf, GRA01_HEAD);
	len =strlen(WriteBuf);
	WriteBuf[len++] =(BYTE)GraphData.jys;
	*((int *)&WriteBuf[len]) =GraphData.recNum;
	len +=sizeof(int);
	*((int *)&WriteBuf[len]) =GraphData.minEnd;
	len +=sizeof(int);
		
	return UDP_Send_Hq(&WriteBuf[0], GRA00_HEAD, len);
}

/////////////////////////////////////////////////////////
int CompString(LPSTR lpstr1, LPSTR lpstr2)
{
	int len;
	
	if(*lpstr1 =='-' && *lpstr2 !='-') return -1;
	if(*lpstr1 !='-' && *lpstr2 =='-') return 1;
	
	len =strlen(lpstr1) -strlen(lpstr2);
	if(*lpstr1 =='-' && *lpstr2 =='-')
	{
		if(len) return 0-len;
		return (0-strcmp(lpstr1, lpstr2));
	}
	else
	{
	    if(len) return len;
		return strcmp(lpstr1, lpstr2);
	}
}

int StringSub(LPSTR lpstr1, LPSTR lpstr2, LPSTR lpres, int s_type)
{
	int n;
	double f;
	long l;
	
	switch(s_type)
	{
		case SSUB_FLOAT:
			f =atof(lpstr1)-atof(lpstr2);
			wsprintf(lpres, "%f", (float)f);
		break;
		case SSUB_INT:
			n =atoi(lpstr1)-atoi(lpstr2);
			wsprintf(lpres, "%d", n);
		break;
		case SSUB_LONG:
			l =atol(lpstr1)-atol(lpstr2);
			wsprintf(lpres, "%ld", l);
		break;
		default:
		return -1;
	}
	
	return 0;
}

int GraGetMinPos(void)
{
	int i, j;
	int tim, tim1;
	long lc;
	
	if(GraphData.minEnd <=0)
	{
		GraphData.minCount =0;
		return 0;
	}
	
	tim =GraphData.lpGraData[0].tim;

	tim1 =tim;
	
	GraphData.minCount =0;
	GraphData.lpMinPos[0] =0;

	for(i =0; i<GraphData.minEnd;)
	{