sv_tcp.c

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

	short recList[5];
	short gp_rec_num, gra_rec_count, gra_rec_end;
	short dateNum;
    GRA_HEAD tmpHead;

	jys =*lpTmp++;
	if(jys > 1) return -1;
	dateNum =*lpTmp++;
	gp_rec_num =*(short *)lpTmp;
	if(gp_rec_num >=HqData[jys].recCount)
	{
		ErrMsg(ghWndMain,"来自Send_Gra01:记录尾大于记录几数");
		return -1;
	}
	lpTmp +=sizeof(short);
	gra_rec_end =*(short *)lpTmp;
	lpTmp +=sizeof(short);

	wsprintf(fileName, "%s\\%s.dat", GraphData[jys].szGraPath,
			HqData[jys].lpPreData[gp_rec_num].zqdm);
	hFile =OpenFile(fileName, &os, OF_SHARE_DENY_NONE|OF_READ);
	if(hFile ==HFILE_ERROR) return -1;

	if(_lread(hFile, &tmpHead, sizeof(GRA_HEAD))
			!=sizeof(GRA_HEAD))
	{
		_lclose(hFile);
		return -1;
	}

	if(IsZsRec(jys, gp_rec_num))
	{
		UDP_Server_Send_MaxMin10(sd, jys, 0, NULL, TRUE, NULL);
		UDP_Server_Send_MaxMin10(sd, jys, 1, NULL, TRUE, NULL);
	}
	else
	{
		UDP_Server_Send_Mmp(sd, jys, gp_rec_num, lpdest, TRUE, NULL);
		if(gra_rec_end <tmpHead.recCount)
			UDP_Server_Send_LitHq(sd, jys, gp_rec_num, 0, lpdest, TRUE, NULL);
	}

	if(gra_rec_end ==tmpHead.recCount)
	{
		_lclose(hFile);
		goto check_dest;
	}

	if(gra_rec_end >tmpHead.recCount)
		gra_rec_end =0;
		
	UDP_Server_Send_Gra00(sd, jys, gp_rec_num, &tmpHead);

	if(_llseek(hFile, sizeof(GRA_HEAD)+gra_rec_end*sizeof(GRA_DATA), FILE_BEGIN)
			==HFILE_ERROR)
	{
		_lclose(hFile);
		return -1;
	}
	gra_rec_count =tmpHead.recCount-gra_rec_end;

	hd =GlobalAlloc(GHND,strlen(GRA01_HEAD)+9+(int)sizeof(GRA_DATA)*gra_rec_count);
	if(hd ==NULL)
	{
		ErrMsg(ghWndMain,"来自Send_Gra01:分配内存失败");
		_lclose(hFile);
		return(-1);
	}

	lpGraData=GlobalLock(hd);
	if(lpGraData ==NULL)
	{
		ErrMsg(ghWndMain, "来自Send_Gra01:锁定内存失败");
		_lclose(hFile);
		return -1;
	}
	
	strcpy(lpGraData, GRA01_HEAD); 
	len =strlen(GRA01_HEAD)+sizeof(short);		//2
	lpGraData[len++] =(char)jys;				//1

	*((short *)&lpGraData[len]) =gp_rec_num;	//2
	len +=sizeof(short);
	*((short *)&lpGraData[len]) =gra_rec_count;	//2
	len +=sizeof(short);
	*((short *)&lpGraData[len]) =0;				//2
	len +=sizeof(short);
	
	if(_lread(hFile, &lpGraData[len], sizeof(GRA_DATA)*gra_rec_count)
			!=gra_rec_count*sizeof(GRA_DATA))
	{
		GlobalUnlock(hd);
		GlobalFree(hd);
		_lclose(hFile);
		return -1;
	}
	_lclose(hFile);

	len +=gra_rec_count*sizeof(GRA_DATA);

	*(short *)&lpGraData[strlen(GRA01_HEAD)] =len;
	SendMemData(sd, lpGraData, len);

	GlobalUnlock(GlobalHandle(lpGraData));
	GlobalFree(GlobalHandle(lpGraData));

check_dest:

	recList[0] =gp_rec_num;
	recList[1] =gra_rec_end+gra_rec_count;
	CheckDest(sd, lpdest, jys, REQ_GRA10, &recList[0], 2, 0);

	return 0;
}

int UDP_Server_Send_Gra01(int sd, LPSTR lpTmp, struct sockaddr *lpdest)
{
	BYTE SendBuff[MAX_SEND_BUF_SIZE+1];
	int jys, i, len;
	char fileName[128];
	HANDLE hd;
	LPGRA_DATA lpGraData =NULL;
	HFILE hFile;
	OFSTRUCT os;
	short recList[5];
	short gp_rec_num, gra_rec_count, gra_rec_end, sendCount, sendNum;
	short dateNum;
    GRA_HEAD tmpHead;

	memset(&SendBuff[0],0, sizeof(SendBuff));
	jys =*lpTmp++;
	if(jys > 1) return -1;
	dateNum =*lpTmp++;
	gp_rec_num =*(short *)lpTmp;
	if(gp_rec_num >=HqData[jys].recCount)
	{
		ErrMsg(ghWndMain,"来自Send_Gra01:记录尾大于记录几数");
		return -1;
	}
	lpTmp +=sizeof(short);
	gra_rec_end =*(short *)lpTmp;
	lpTmp +=sizeof(short);

	wsprintf(fileName, "%s\\%s.dat", GraphData[jys].szGraPath,
			HqData[jys].lpPreData[gp_rec_num].zqdm);
	hFile =OpenFile(fileName, &os, OF_SHARE_DENY_NONE|OF_READ);
	if(hFile ==HFILE_ERROR) return -1;

	if(_lread(hFile, &tmpHead, sizeof(GRA_HEAD))
			!=sizeof(GRA_HEAD))
	{
		_lclose(hFile);
		return -1;
	}

	if(IsZsRec(jys, gp_rec_num))
	{
		UDP_Server_Send_MaxMin10(sd, jys, 0, lpdest, TRUE, NULL);
		UDP_Server_Send_MaxMin10(sd, jys, 1, lpdest, TRUE, NULL);
	}
	else
	{
		UDP_Server_Send_Mmp(sd, jys, gp_rec_num, lpdest, TRUE, NULL);
		if(gra_rec_end <tmpHead.recCount)
			UDP_Server_Send_LitHq(sd, jys, gp_rec_num, 0, lpdest, TRUE, NULL);
	}

	if(gra_rec_end ==tmpHead.recCount)
	{
		_lclose(hFile);
		goto check_dest;
	}

	if(gra_rec_end >tmpHead.recCount)
		gra_rec_end =0;
		
	UDP_Server_Send_Gra00(sd, jys, gp_rec_num, &tmpHead);
	
	if(_llseek(hFile, sizeof(GRA_HEAD)+gra_rec_end*sizeof(GRA_DATA), FILE_BEGIN)
			==HFILE_ERROR)
	{
		ErrMsg(ghWndMain, "来自Send_Gra01:定位数据文件错");
		ErrMsg(ghWndMain, fileName);
		_lclose(hFile);
		return -1;
	}
	gra_rec_count =tmpHead.recCount-gra_rec_end;
	hd =GlobalAlloc(GHND,(int)sizeof(GRA_DATA)*gra_rec_count);
	if(hd ==NULL)
	{
		ErrMsg(ghWndMain,"来自Send_Gra01:分配内存失败");
		_lclose(hFile);
		return(-1);
	}
	lpGraData=GlobalLock(hd);
	if(lpGraData ==NULL)
	{
		ErrMsg(ghWndMain, "来自Send_Gra01:锁定内存失败");
		_lclose(hFile);
		return -1;
	}
	
	if(_lread(hFile, lpGraData, sizeof(GRA_DATA)*gra_rec_count)
			!=gra_rec_count*sizeof(GRA_DATA))
	{
		ErrMsg(ghWndMain, "来自Send_Gra01:读数据文件错1");
		ErrMsg(ghWndMain, fileName);
		GlobalUnlock(hd);
		GlobalFree(hd);
		_lclose(hFile);
		return -1;
	}
	_lclose(hFile);
	
	sendCount =MAX_GRA_SEND_COUNT;
	for(i =0; i<=gra_rec_count/MAX_GRA_SEND_COUNT; i++)
	{
		sendNum =i*MAX_GRA_SEND_COUNT;
		if(sendCount+sendNum >gra_rec_count)
			sendCount =gra_rec_count-sendNum;

		strcpy(SendBuff, GRA01_HEAD); 
		len =strlen(GRA01_HEAD)+sizeof(short);
		SendBuff[len++] =(char)jys;

		*((short *)&SendBuff[len]) =gp_rec_num;
		len +=sizeof(short);
		*((short *)&SendBuff[len]) =sendCount;
		len +=sizeof(short);
		*((short *)&SendBuff[len]) =sendNum;
		len +=sizeof(short);
	
		memcpy(&SendBuff[len], &lpGraData[sendNum], sendCount*sizeof(GRA_DATA));
		len +=sendCount*sizeof(GRA_DATA);
		if(sendCount)
		{
			*(short *)&SendBuff[strlen(GRA01_HEAD)] =len;
			if(UDP_SendBuff("分时图01", sd, SendBuff, len, NULL)<0)
			{
				GlobalUnlock(GlobalHandle(lpGraData));
				GlobalFree(GlobalHandle(lpGraData));
				return -1;
			}
		}
	}
	GlobalUnlock(GlobalHandle(lpGraData));
	GlobalFree(GlobalHandle(lpGraData));

check_dest:

	recList[0] =gp_rec_num;
	recList[1] =gra_rec_end+gra_rec_count;
	CheckDest(sd, lpdest, jys, REQ_GRA10, &recList[0], 2, 0);

	return 0;
}

int Send_Gra10(LPDEST_INFO lpDest)
{
	char * SendBuff =NULL;
	int jys,len;
	char fileName[128];

	HFILE hFile;
	OFSTRUCT os;
	short gp_rec_num, gra_rec_count, gra_rec_end;
	short j;
    GRA_HEAD tmpHead;
	BOOL sdMax1 =FALSE,sdMax2 =FALSE,sdMmp=FALSE,
		 sdLit=FALSE;

	jys =lpDest->curJys;
	if(lpDest->paramsCount<2)
	{
		UnlockDest(lpDest);
		return -1;
	}
	gp_rec_num =lpDest->graNo; //lpDest->params[0];
	if(gp_rec_num>=HqData[jys].recCount||
		gp_rec_num<0)
	{
		UnlockDest(lpDest);
		return 0;
	}
	gra_rec_end =lpDest->graEnd; //lpDest->params[1];
	if(gra_rec_end<0)
	{
		UnlockDest(lpDest);
		return 0;
	}

	if(IsZsRec(jys, gp_rec_num))
	{
		if(memcmp(&lpDest->lpZsGraph->Maxmin[0], &MaxMinData[lpDest->curJys][0],
				sizeof(MAXMIN_DATA)))
		{
			memcpy(&lpDest->lpZsGraph->Maxmin[0], &MaxMinData[lpDest->curJys][0],
				sizeof(MAXMIN_DATA));
			sdMax1 =TRUE;
		}
		if(memcmp(&lpDest->lpZsGraph->Maxmin[1], &MaxMinData[lpDest->curJys][1],
				sizeof(MAXMIN_DATA)))
		{
			memcpy(&lpDest->lpZsGraph->Maxmin[1], &MaxMinData[lpDest->curJys][1],
				sizeof(MAXMIN_DATA));
			sdMax2 =TRUE;
		}
	}
	else
	{
		if(memcmp(&lpDest->lpGraph->mmp, &MmpData[lpDest->curJys].lpMmp[gp_rec_num],
				sizeof(MMP)))
		{
			memcpy(&lpDest->lpGraph->mmp, &MmpData[lpDest->curJys].lpMmp[gp_rec_num],
				sizeof(MMP));
			sdMmp =TRUE;
		}
	}

	if(lpDest->cjss !=HqData[lpDest->curJys].lpRefData[gp_rec_num].cjss)
	{
		lpDest->cjss =HqData[lpDest->curJys].lpRefData[gp_rec_num].cjss;
		sdLit =TRUE;
	}

	wsprintf(fileName, "%s\\%s.dat", GraphData[jys].szGraPath,
			HqData[jys].lpPreData[gp_rec_num].zqdm);
	hFile =OpenFile(fileName, &os, OF_SHARE_DENY_NONE|OF_READ);
	if(hFile ==HFILE_ERROR)
	{
		UnlockDest(lpDest);
		return 0;
    }
	if(_lread(hFile,&tmpHead, sizeof(GRA_HEAD))
			!=sizeof(GRA_HEAD))
	{
		UnlockDest(lpDest);
		_lclose(hFile);
		return 0;
	}
    j=tmpHead.recCount;

	gra_rec_count =j-gra_rec_end;
    if(gra_rec_count<=0)
	{
		UnlockDest(lpDest);
		_lclose(hFile);
		return 0;
	}

	if(_llseek(hFile, sizeof(GRA_HEAD)+gra_rec_end*sizeof(GRA_DATA), FILE_BEGIN)
			==HFILE_ERROR)
	{
		UnlockDest(lpDest);
		_lclose(hFile);
		return 0;
	}
	SendBuff =GlobalAllocPtr(GHND,
		strlen(GRA10_HEAD)+9+sizeof(GRA_DATA)*gra_rec_count);
	if(SendBuff ==NULL)
	{
		UnlockDest(lpDest);
		_lclose(hFile);
		return 0;
	}

	strcpy(SendBuff,GRA10_HEAD);
	len =strlen(GRA01_HEAD)+sizeof(short);	//2
	SendBuff[len++] =(char)jys;				//1
	*((short *)&SendBuff[len]) =gp_rec_num;
	len +=sizeof(short);					//2
	*((short *)&SendBuff[len]) =gra_rec_count;
	len +=sizeof(short);					//2
	*((short *)&SendBuff[len]) =gra_rec_end;
	len +=sizeof(short);					//2
	
	if(_lread(hFile,&SendBuff[len], sizeof(GRA_DATA)*gra_rec_count)
			==sizeof(GRA_DATA)*gra_rec_count)
	{
		len +=gra_rec_count*sizeof(GRA_DATA);
		_lclose(hFile);
	
		*(short *)&SendBuff[strlen(GRA10_HEAD)] =len;
		if(SendMemData(lpDest->sd, SendBuff, len)>0)
		{
			//lpDest->params[1] +=gra_rec_count;	
			lpDest->graEnd +=gra_rec_count;	
		}
	}
	UnlockDest(lpDest);
	_lclose(hFile);
	GlobalFreePtr(SendBuff);

	if(sdMax1)
	UDP_Server_Send_MaxMin10(lpDest->sd, jys, 0, NULL, FALSE, lpDest);
	if(sdMax2)
	UDP_Server_Send_MaxMin10(lpDest->sd, jys, 1, NULL, FALSE, lpDest);
	if(sdMmp)
	UDP_Server_Send_Mmp(lpDest->sd, jys, gp_rec_num, NULL, FALSE, lpDest);
	if(sdLit)
	UDP_Server_Send_LitHq(lpDest->sd, jys, gp_rec_num, 0, NULL, FALSE, lpDest);

	return 0;
}

int UDP_Server_Send_Gra10(LPDEST_INFO lpDest)
{
	BYTE SendBuff[MAX_SEND_BUF_SIZE+1];
	int jys, i, len;
	char fileName[128];
	LPGRA_DATA lpGraData =NULL;
	HFILE hFile;
	OFSTRUCT os;
	short gp_rec_num, gra_rec_count, gra_rec_end, sendCount, sendNum;
	short j;
    GRA_HEAD tmpHead;
	HANDLE hd;

	memset(&SendBuff[0],0, sizeof(SendBuff));
	jys =lpDest->curJys;
	if(lpDest->paramsCount<2)
	{
		ErrMsg(ghWndMain,"来自Send_Gra10:参数个数错");
		return -1;
	}
	gp_rec_num =lpDest->graNo; //params[0];
	if(gp_rec_num>=HqData[jys].recCount||
		gp_rec_num<0)
	{
		return 0;
	}
	gra_rec_end =lpDest->graEnd; //params[1];
	if(gra_rec_end<0)
		return 0;

	if(IsZsRec(jys, gp_rec_num))
	{
		if(memcmp(&lpDest->lpZsGraph->Maxmin[0], &MaxMinData[lpDest->curJys][0],
				sizeof(MAXMIN_DATA)))
		{
			memcpy(&lpDest->lpZsGraph->Maxmin[0], &MaxMinData[lpDest->curJys][0],
				sizeof(MAXMIN_DATA));
			if(UDP_Server_Send_MaxMin10(lpDest->sd, jys, 0, NULL, FALSE, lpDest) <0)
			{
				ErrMsg(ghWndMain,"来自Send_Gra10:送MaxMin错");
				return -1;
			}
		}
		if(memcmp(&lpDest->lpZsGraph->Maxmin[1], &MaxMinData[lpDest->curJys][1],
				sizeof(MAXMIN_DATA)))
		{
			memcpy(&lpDest->lpZsGraph->Maxmin[1], &MaxMinData[lpDest->curJys][1],
				sizeof(MAXMIN_DATA));
			if(UDP_Server_Send_MaxMin10(lpDest->sd, jys, 1, NULL, FALSE, lpDest) <0)
			{
				ErrMsg(ghWndMain,"来自Send_Gra10:送MaxMin错1");
				return -1;
			}
		}
	}
	else
	{
		if(memcmp(&lpDest->lpGraph->mmp, &MmpData[lpDest->curJys].lpMmp[gp_rec_num],
				sizeof(MMP)))
		{
			memcpy(&lpDest->lpGraph->mmp, &MmpData[lpDest->curJys].lpMmp[gp_rec_num],
				sizeof(MMP));
			if(UDP_Server_Send_Mmp(lpDest->sd, jys, gp_rec_num, NULL, FALSE, lpDest) <0)
			{
				ErrMsg(ghWndMain,"来自Send_Gra10:送Mmp错");
				return -1;
			}
		}
	}
	if(lpDest->cjss !=HqData[lpDest->curJys].lpRefData[gp_rec_num].cjss)
	{
		lpDest->cjss =HqData[lpDest->curJys].lpRefData[gp_rec_num].cjss;
		if(UDP_Server_Send_LitHq(lpDest->sd, jys, gp_rec_num, 0, NULL, FALSE, lpDest) <0)
		{
			ErrMsg(ghWndMain,"来自Send_Gra10:送LitHq错");
			return -1;
		}
	}
	wsprintf(fileName, "%s\\%s.dat", GraphData[jys].szGraPath,
			HqData[jys].lpPreData[gp_rec_num].zqdm);
	hFile =OpenFile(fileName, &os, OF_SHARE_DENY_NONE|OF_READ);
	if(hFile ==HFILE_ERROR)
		return 0;
    
	if(_lread(hFile,&tmpHead, sizeof(GRA_HEAD))
			!=sizeof(GRA_HEAD))
	{
		ErrMsg(ghWndMain,"来自Send_Gra10:读数据文件错");
		ErrMsg(ghWndMain, fileName);
		_lclose(hFile);
		return 0;
	}
    j=tmpHead.recCount;

	if(gra_rec_end >=j)
	{
		_lclose(hFile);
		return 0;
	}
	gra_rec_count =j-gra_rec_end;
    
	if(gra_rec_count<=0)
	{
		_lclose(hFile);
		return 0;
	}
	if(_llseek(hFile, sizeof(GRA_HEAD)+gra_rec_end*sizeof(GRA_DATA), FILE_BEGIN)
			==HFILE_ERROR)
	{
		//ErrMsg(ghWndMain,"来自Send_Gra10:定位数据文件错");
		//ErrMsg(ghWndMain, fileName);
		_lclose(hFile);
		return 0;
	}
	hd =GlobalAlloc(GHND,(int)sizeof(GRA_DATA)*gra_rec_count);
	if(hd ==NULL)
	{
		ErrMsg(ghWndMain,"来自Send_Gra10:分配内存失败");
		_lclose(hFile);
		return 0;
	}
	lpGraData =GlobalLock(hd);
	if(lpGraData ==NULL)
	{
		ErrMsg(ghWndMain,"来自Send_Gra10:锁定内存失败");
		_lclose(hFile);
		return 0;
	}
	
	if(_lread(hFile, lpGraData, sizeof(GRA_DATA)*gra_rec_count)
			!=sizeof(GRA_DATA)*gra_rec_count)
	{
		ErrMsg(ghWndMain,"来自Send_Gra10:读数据文件错1");
		GlobalUnlock(hd);
		GlobalFree(hd);
		_lclose(hFile);
		return 0;
	}
	_lclose(hFile);
	
	if(gra_rec_count<MAX_GRA_SEND_COUNT)
	{
		strcpy(SendBuff,GRA10_HEAD);
		len =strlen(GRA01_HEAD)+sizeof(short);
		SendBuff[len++] =(char)jys;

		*((short *)&SendBuff[len]) =gp_rec_num;
		len +=sizeof(short);
		*((short *)&SendBuff[len]) =gra_rec_count;
		len +=sizeof(short);
		*((short *)&SendBuff[len]) =gra_rec_end;