sv_jy.c

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

#include <windows.h>
#include <windowsx.h>

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <io.h>                 
#include <sys\stat.h>   
#include <fcntl.h>              
#include <time.h>

#include "dbf_data.h"
#include "sv_jy.h"
#include "jydest.h"
#include "rsa.h"


#define MAX_PATH_LEN		128
#define	START_REC_NO		100


DBF_DATA CommFile;

typedef struct  tag_ANSFILE
{
	int hf[MAX_ZQS_COUNT];
	int recnum[MAX_ZQS_COUNT];
	char path[MAX_ZQS_COUNT][MAX_PATH_LEN];
}ANSFILE;
ANSFILE AnsFile;

typedef struct  tag_REQFILE
{
	int hf[MAX_ZQS_COUNT];
	int recnum[MAX_ZQS_COUNT];
	int currec[MAX_ZQS_COUNT];
}REQFILE;
REQFILE ReqFile;

int ZqsCount;
char * CommBuffer;
short rlen,hlen;

char RetFilePath[80];
BOOL fUseJy =FALSE,fTestJy=FALSE,fRsa=FALSE;
int Thrd_SendJycx(int sd, int reqType, void *lpBuf, int);


extern int sdJy;

extern BOOL GetInitString(LPSTR, LPSTR, LPSTR);
extern BOOL PutInitString(LPSTR, LPSTR, LPSTR);
extern BOOL ErrMsg(HWND, LPSTR);

//extern int UDP_SendBuff(LPSTR, int, LPSTR, int, LPDEST_INFO );


int JyInit(void)
{       
		int i;
	    char tmp[256], temp[256],temp1[256];
		char * prt;

		memset(&ReqFile,0,sizeof(REQFILE));
		memset(&AnsFile,0,sizeof(ANSFILE));

		CommBuffer =NULL;
		CommFile.hf =-1;
		
		if(GetInitString("JY", "RUN", tmp))
		{
			if(tmp[0] =='N' || tmp[0] =='n')
			{
				fUseJy =FALSE;
				return 0;
			}
			else
				fUseJy =TRUE;
		}


		if(GetInitString("JY", "TEST", tmp))
		{
			if(tmp[0] =='Y' || tmp[0] =='y')
				fTestJy =TRUE;
			else
				fTestJy =FALSE;
		}
		else 
			fTestJy =FALSE;
         
		if(GetInitString("JY", "RSA", tmp))
		{
			if(tmp[0] =='Y' || tmp[0] =='y')
			{
				fRsa =TRUE;
				if(!ReadRsaFile(R,PK,SK))
					ErrMsg(NULL,"读RSA加密参数失败，请在系统启动后按[Init]");
			}
		}

		ZqsCount=0;

		for(i=0;i<MAX_ZQS_COUNT;i++)
		{
			wsprintf(temp,"%s%d","COMMFILE",i);
			if(!GetInitString("JY", temp, tmp))
			{
				if(ZqsCount==0)
				{
					wsprintf(temp, "不能发现配置%s:\n %s",
						(LPSTR)"COMMFILE", (LPSTR)tmp);
					ErrMsg(NULL, temp);
				}
				break;
			}
			else
			{
				ZqsCount++;
				prt=strstr(tmp,";");
				if(prt==NULL) 
				{
					ErrMsg(NULL,"format Reqfile;AnsFile");
					return -1;
				}
				else *prt=0;

				strcpy(temp1,tmp);
				if(access(temp1,_S_IREAD|_S_IWRITE) <0)
				{
					wsprintf(temp, "不能存取%s:\n %s",
					(LPSTR)"COMMFILE", (LPSTR)temp1);
					ErrMsg(NULL, temp);
					return -1;
				}  
                
				ReqFile.hf[i]=OpenDbfBase(temp1,O_RDWR);
				if(i==0)
					CommFile.hf=ReqFile.hf[0];
				
				if (ReqFile.hf[i]==-1)
				{
					wsprintf(temp, "不能打开%s:\n %s",
						(LPSTR)"COMMFILE", (LPSTR)temp1);
					ErrMsg(NULL, temp);
					return -1;
				} 
				if(i==0)
				{
					if (InitBase(CommFile.hf,&CommFile.dbfStruct,
					&CommFile.fldStruct,&CommFile.fldCount)
					!=SUCCEED) 
					{
						wsprintf(temp, "不能处始化%s:\n %s",
							(LPSTR)"COMMFILE", (LPSTR)temp1);
						ErrMsg(NULL, temp);
						return -1;
					}
					rlen=*(short *)CommFile.dbfStruct.rlen;
					hlen=*(short *)CommFile.dbfStruct.hlen;
				}

				ReqFile.recnum[i]=GetRecNum(ReqFile.hf[i]);

				strcpy(temp1,++prt);
				AnsFile.hf[i]=OpenDbfBase(temp1,O_RDWR);				
				if (ReqFile.hf[i]==-1)
				{
					wsprintf(temp, "不能打开%s:\n %s",
						(LPSTR)"COMMFILE", (LPSTR)temp1);
					ErrMsg(NULL, temp);
					return -1;
				} 

				prt =strrchr(temp1,'\\');
				++prt; *prt =0;
				strcpy(&AnsFile.path[i][0],temp1);

				AnsFile.recnum[i]=GetRecNum(AnsFile.hf[i]);
				AnsFile.recnum[i]=min(AnsFile.recnum[i],ReqFile.recnum[i]);
				ReqFile.recnum[i]=AnsFile.recnum[i];
			}
		}

		if(ZqsCount)
		if((CommBuffer =GlobalAllocPtr(GHND,*(short*)CommFile.dbfStruct.rlen))==NULL)
		{
		      ErrMsg(NULL, "不能分配交换文件记录内存!");
		      return -1;
		}
		return 0;		
}

int JyExit(void)
{
	int i;

		for(i=0;i<ZqsCount;i++)
		{
			if(ReqFile.hf[i]!=-1)
				CloseDbf(ReqFile.hf[i]);
			if(AnsFile.hf[i]!=-1)
				CloseDbf(AnsFile.hf[i]);
		}
		if(CommFile.fldStruct)
		GlobalFreePtr(CommFile.fldStruct);
		if(CommBuffer)
        GlobalFreePtr(CommBuffer);		

		return 0;
}

int Jy_Zqsxx(int sd)
{
	int len;

	BYTE SendBuff[1024];

	strcpy(SendBuff, JY_ZQSXX_HEAD);
	len =strlen(JY_ZQSXX_HEAD);
	//memcpy(&SendBuff[len],&Zqsxx,sizeof(ZQSXX));
	//len+=sizeof(Zqsxx);
	
	memcpy(&SendBuff[len],R,DATALENGTH);
	len +=DATALENGTH;
	memcpy(&SendBuff[len],PK,DATALENGTH);
	len +=DATALENGTH;
	UDP_SendBuff("RSA.R.PK", sd, SendBuff, len,NULL);
	return 0;
}

void ClearAns(LPJY_DEST lpJyDest)
{
	char* buff;
    HANDLE hd;    
	if((hd =GlobalAlloc(GHND,rlen))==NULL)	return;
    if((buff=GlobalLock(hd))==NULL)	return;
	memset(buff,' ',rlen);
	WriteRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,rlen,buff);
	GlobalUnlock(hd);
	GlobalFree(hd);
}


void ClearReq(LPJY_DEST lpJyDest)
{
	char* buff;
    HANDLE hd;    
	if((hd =GlobalAlloc(GHND,rlen))==NULL)	return;
    if((buff=GlobalLock(hd))==NULL)	return;
	memset(buff,' ',rlen);
	buff[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]='0';
	WriteRecord(ReqFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,rlen,buff);
	GlobalUnlock(hd);
	GlobalFree(hd);
}

int Jy_ChkUsr(int sd, int jyNum, LPJY_ASK_CHKUSR AskChkUser)
{
	int ret;
	LPJY_DEST lpJyDest;
    char temp[20];  
	short Qsid;

	if(ZqsCount ==1)
		Qsid =1;
	else
	Qsid =AskChkUser->zqsid;

	if(ReqFile.hf[Qsid -1] ==-1)
		return ANS_SYS_ERR;

	ret =CheckJyDest(sd,REQ_CHKUSR, AskChkUser->jys,
			AskChkUser->gddm, -1, &lpJyDest);
	memset(CommBuffer,' ',rlen);
	StringToFld(CommBuffer,CommFile.fldStruct[fld_GDDM],AskChkUser->gddm);
	CommBuffer[*(short*)(CommFile.fldStruct[fld_STKNO].offset)]
		=(AskChkUser->jys ==0)?'Z':'H';
	StringToFld(CommBuffer,CommFile.fldStruct[fld_JYMM],AskChkUser->jymm);      
	CommBuffer[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]=REQ_CHKUSR;
	CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';

	wsprintf(temp,"%d",sd);
	StringToFld(CommBuffer,CommFile.fldStruct[fld_ADDR],temp);
	wsprintf(temp,"%d",jyNum);
	StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);

	if(lpJyDest==NULL)
		lpJyDest=GetFirstIdelRec();
	if(lpJyDest==NULL)
	{
		ReqFile.currec[Qsid-1]++;
		if(ReqFile.currec[Qsid-1]>ReqFile.recnum[Qsid-1])
		{
			ErrMsg(NULL, "无空闲交易表项!");      
			return ANS_SYS_ERR;
		}
		lpJyDest=AddJyDest(sd, REQ_CHKUSR, AskChkUser->jys,
				ReqFile.currec[Qsid-1], AskChkUser->gddm, jyNum,Qsid-1);

		if(lpJyDest ==NULL)
		{
			ErrMsg(NULL, "不能加交易表项!");
			return ANS_SYS_ERR;
		}
		ClearAns(lpJyDest);
		if(WriteRecord(ReqFile.hf[Qsid-1],lpJyDest->recNum,
				hlen,rlen,CommBuffer) !=0)
		{
			ErrMsg(NULL, "不能写交换文件!");      
			return ANS_SYS_ERR;
		}
	}
	else
	{
		ClearAns(lpJyDest);
		if(WriteRecord(ReqFile.hf[Qsid-1],lpJyDest->recNum,
				hlen,rlen,CommBuffer)!=0)
		{
			ErrMsg(NULL, "不能写交换文件1!");      
			return ANS_SYS_ERR;
		}
		strcpy(lpJyDest->gddm,AskChkUser->gddm);
		ChangeJyDest(sd, lpJyDest, REQ_CHKUSR, AskChkUser->jys,
			Qsid -1,jyNum);
	}

	if(fTestJy)
	{
		Sleep(1000);
		CommBuffer[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]=REQ_NULL;
		CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)]=ANS_SUCC;
		CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
		wsprintf(temp,"%d",jyNum);
		StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);

		WriteRecord(AnsFile.hf[Qsid-1],lpJyDest->recNum,hlen,
			rlen,CommBuffer);
	}
	return 0;
}

int Jy_ChgPwd(int sd, int jyNum, LPJY_ASK_CHGPWD AskChgPwd)
{
	LPJY_DEST lpJyDest=NULL;
	int ret;
	char temp[20];

	ret =CheckJyDest(sd, REQ_CHGPWD, AskChgPwd->jys, AskChgPwd->gddm,
			AskChgPwd->userId, &lpJyDest);

	if(ret==-1)
		return ANS_SYS_ERR;
	if(ret==-2)
		return ANS_SUSP_REQ;
	if(ret==-3)
		return ANS_NO_PRIV;

	if(ReqFile.hf[lpJyDest->zqsid] ==-1)
		return ANS_SYS_ERR;

	memset(CommBuffer,' ',*(short *)CommFile.dbfStruct.rlen);
	StringToFld(CommBuffer,CommFile.fldStruct[fld_GDDM],AskChgPwd->gddm);
	CommBuffer[*(short*)(CommFile.fldStruct[fld_STKNO].offset)]
		=(AskChgPwd->jys ==0)?'Z':'H';
	StringToFld(CommBuffer,CommFile.fldStruct[fld_JYMM],AskChgPwd->xmm);      
	CommBuffer[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]=REQ_CHGPWD;
	CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';

	wsprintf(temp,"%d",sd);
	StringToFld(CommBuffer,CommFile.fldStruct[fld_ADDR],temp);
	wsprintf(temp,"%d",jyNum);
	StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);

	ClearAns(lpJyDest);	
	if(WriteRecord(ReqFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,rlen,CommBuffer)!=0)
	{
		ErrMsg(NULL, "不能写交换文件!");
		return ANS_SYS_ERR;
	}
	ChangeJyDest(sd, lpJyDest, REQ_CHGPWD, AskChgPwd->jys, -1, jyNum);

	if(fTestJy)
	{
		Sleep(1000);
		CommBuffer[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]=REQ_NULL;
		CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)]=ANS_SUCC;
		CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
		wsprintf(temp,"%d",jyNum);
		StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);

		WriteRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,rlen,CommBuffer);
	}

	return 0;
}

int Jy_BuySell(int sd, int jyNum, LPJY_ASK_BUYSELL AskBuySell)
{
	LPJY_DEST lpJyDest;
	int ret;
	char temp[20];

	ret =CheckJyDest(sd, REQ_BUYSEL, AskBuySell->jys, AskBuySell->gddm,
				AskBuySell->userId, &lpJyDest);

	if(ret==-1)
		return ANS_SYS_ERR;
	if(ret==-2)
		return ANS_SUSP_REQ;
	if(ret==-3)
		return ANS_NO_PRIV;
	
	if(ReqFile.hf[lpJyDest->zqsid] ==-1)
		return ANS_SYS_ERR;

	memset(CommBuffer,' ',*(short *)CommFile.dbfStruct.rlen);
	StringToFld(CommBuffer,CommFile.fldStruct[fld_GDDM],AskBuySell->gddm);
	CommBuffer[*(short*)(CommFile.fldStruct[fld_STKNO].offset)]
		=(AskBuySell->jys ==0)?'Z':'H';                         
	StringToFld(CommBuffer,CommFile.fldStruct[fld_GPDM],AskBuySell->gpdm);
	sprintf(temp,"%12ld",AskBuySell->wtgs);
	StringToFld(CommBuffer,CommFile.fldStruct[fld_WTGS],temp);            
	sprintf(temp,"%12.2f",(double)(AskBuySell->wtjg/100.00));
	StringToFld(CommBuffer,CommFile.fldStruct[fld_WTJG],temp);      
	if(AskBuySell->bs =='B')
		CommBuffer[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]=REQ_BUY;
	else if(AskBuySell->bs =='S')
		CommBuffer[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]=REQ_SELL;
	else
		CommBuffer[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]='E';

	CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';	
 	wsprintf(temp,"%d",sd);
	StringToFld(CommBuffer,CommFile.fldStruct[fld_ADDR],temp);
	wsprintf(temp,"%d",jyNum);
	StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);

	ClearAns(lpJyDest);	
	if(WriteRecord(ReqFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,rlen,CommBuffer)!=0)
	{
		ErrMsg(NULL, "不能写交换文件!");      
		return ANS_SYS_ERR;
	}
	if(ChangeJyDest(sd, lpJyDest, REQ_BUYSEL, AskBuySell->jys, -1, jyNum)<0)
		return ANS_SYS_ERR;

	if(fTestJy)
	{
		Sleep(1000);
		CommBuffer[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]=REQ_NULL;
		CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)]=ANS_SUCC;
		CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
		StringToFld(CommBuffer,CommFile.fldStruct[fld_HTHM],"000068");
		wsprintf(temp,"%d",jyNum);
		StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);
	    WriteRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,rlen,CommBuffer);
	}

	return 0;
}

int Jy_Cancel(int sd, int jyNum, LPJY_ASK_CANCEL AskCancel)
{
	LPJY_DEST lpJyDest;
	int ret,i;
	char temp[20];
	HFILE hFile;
	OFSTRUCT os;

	ret =CheckJyDest(sd, REQ_CANCEL, AskCancel->jys, 
			AskCancel->gddm, AskCancel->userId,	&lpJyDest);
	if(ret==-1)
		return ANS_SYS_ERR;
	if(ret==-2)
		return ANS_SUSP_REQ;
	if(ret==-3)
		return ANS_NO_PRIV;
	
	if(ReqFile.hf[lpJyDest->zqsid] ==-1)
		return ANS_SYS_ERR;
	
	for(i=0;i<AskCancel->cancelCount;i++)
	{
		memset(CommBuffer,' ',*(short *)CommFile.dbfStruct.rlen);
		StringToFld(CommBuffer,CommFile.fldStruct[fld_GDDM],AskCancel->gddm);
		StringToFld(CommBuffer,CommFile.fldStruct[fld_HTHM],AskCancel->Cancel[i].hthm);          
		CommBuffer[*(short*)(CommFile.fldStruct[fld_STKNO].offset)]
			=(AskCancel->jys ==0)?'Z':'H';                      
		CommBuffer[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]=REQ_CANCEL;
		CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
 		wsprintf(temp,"%d",sd);
		StringToFld(CommBuffer,CommFile.fldStruct[fld_ADDR],temp);
		wsprintf(temp,"%d",jyNum);
		StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);

		ClearAns(lpJyDest);		
		if(WriteRecord(ReqFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,rlen,
			CommBuffer)!=0)
		{
			ErrMsg(NULL, "不能写交换文件!");      
			return ANS_SYS_ERR;
		}
	}
	ChangeJyDest(sd, lpJyDest, REQ_CANCEL, AskCancel->jys, -1, jyNum);
	lpJyDest->recCount =AskCancel->cancelCount;

	if(fTestJy)
	{
		Sleep(1000);
		CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)]=ANS_SUCC;