开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 行业应用 > 金融证券系统 > 查看源码
SV_JY.C
资源名称：inet_stock.zip　[点击查看]
上传用户：bjghjy
上传日期：2007-01-07
资源大小：379k
文件大小：39k
源码类别：

金融证券系统

开发平台：

Visual C++

SV_JY.C：源码内容
  1. #include <windows.h>
  2. #include <windowsx.h>
  4. #include <stdio.h>
  5. #include <string.h>
  6. #include <stdlib.h>
  7. #include <io.h>                 
  8. #include <sysstat.h>   
  9. #include <fcntl.h>              
  10. #include <time.h>
  12. #include "dbf_data.h"
  13. #include "sv_jy.h"
  14. #include "jydest.h"
  15. #include "rsa.h"
  18. #define MAX_PATH_LEN 128
  19. #define START_REC_NO 100
  22. DBF_DATA CommFile;
  24. typedef struct  tag_ANSFILE
  25. {
  26. int hf[MAX_ZQS_COUNT];
  27. int recnum[MAX_ZQS_COUNT];
  28. char path[MAX_ZQS_COUNT][MAX_PATH_LEN];
  29. }ANSFILE;
  30. ANSFILE AnsFile;
  32. typedef struct  tag_REQFILE
  33. {
  34. int hf[MAX_ZQS_COUNT];
  35. int recnum[MAX_ZQS_COUNT];
  36. int currec[MAX_ZQS_COUNT];
  37. }REQFILE;
  38. REQFILE ReqFile;
  40. int ZqsCount;
  41. char * CommBuffer;
  42. short rlen,hlen;
  44. char RetFilePath[80];
  45. BOOL fUseJy =FALSE,fTestJy=FALSE,fRsa=FALSE;
  46. int Thrd_SendJycx(int sd, int reqType, void *lpBuf, int);
  49. extern int sdJy;
  51. extern BOOL GetInitString(LPSTR, LPSTR, LPSTR);
  52. extern BOOL PutInitString(LPSTR, LPSTR, LPSTR);
  53. extern BOOL ErrMsg(HWND, LPSTR);
  55. //extern int UDP_SendBuff(LPSTR, int, LPSTR, int, LPDEST_INFO );
  58. int JyInit(void)
  59. {       
  60. int i;
  61.     char tmp[256], temp[256],temp1[256];
  62. char * prt;
  64. memset(&ReqFile,0,sizeof(REQFILE));
  65. memset(&AnsFile,0,sizeof(ANSFILE));
  67. CommBuffer =NULL;
  68. CommFile.hf =-1;
  70. if(GetInitString("JY", "RUN", tmp))
  71. {
  72. if(tmp[0] =='N' || tmp[0] =='n')
  73. {
  74. fUseJy =FALSE;
  75. return 0;
  76. }
  77. else
  78. fUseJy =TRUE;
  79. }
  82. if(GetInitString("JY", "TEST", tmp))
  83. {
  84. if(tmp[0] =='Y' || tmp[0] =='y')
  85. fTestJy =TRUE;
  86. else
  87. fTestJy =FALSE;
  88. }
  89. else 
  90. fTestJy =FALSE;
  91.          
  92. if(GetInitString("JY", "RSA", tmp))
  93. {
  94. if(tmp[0] =='Y' || tmp[0] =='y')
  95. {
  96. fRsa =TRUE;
  97. if(!ReadRsaFile(R,PK,SK))
  98. ErrMsg(NULL,"读RSA加密参数失败，请在系统启动后按[Init]");
  99. }
  100. }
  102. ZqsCount=0;
  104. for(i=0;i<MAX_ZQS_COUNT;i++)
  105. {
  106. wsprintf(temp,"%s%d","COMMFILE",i);
  107. if(!GetInitString("JY", temp, tmp))
  108. {
  109. if(ZqsCount==0)
  110. {
  111. wsprintf(temp, "不能发现配置%s:n %s",
  112. (LPSTR)"COMMFILE", (LPSTR)tmp);
  113. ErrMsg(NULL, temp);
  114. }
  115. break;
  116. }
  117. else
  118. {
  119. ZqsCount++;
  120. prt=strstr(tmp,";");
  121. if(prt==NULL) 
  122. {
  123. ErrMsg(NULL,"format Reqfile;AnsFile");
  124. return -1;
  125. }
  126. else *prt=0;
  128. strcpy(temp1,tmp);
  129. if(access(temp1,_S_IREAD|_S_IWRITE) <0)
  130. {
  131. wsprintf(temp, "不能存取%s:n %s",
  132. (LPSTR)"COMMFILE", (LPSTR)temp1);
  133. ErrMsg(NULL, temp);
  134. return -1;
  135. }  
  136.                 
  137. ReqFile.hf[i]=OpenDbfBase(temp1,O_RDWR);
  138. if(i==0)
  139. CommFile.hf=ReqFile.hf[0];
  141. if (ReqFile.hf[i]==-1)
  142. {
  143. wsprintf(temp, "不能打开%s:n %s",
  144. (LPSTR)"COMMFILE", (LPSTR)temp1);
  145. ErrMsg(NULL, temp);
  146. return -1;
  147. } 
  148. if(i==0)
  149. {
  150. if (InitBase(CommFile.hf,&CommFile.dbfStruct,
  151. &CommFile.fldStruct,&CommFile.fldCount)
  152. !=SUCCEED) 
  153. {
  154. wsprintf(temp, "不能处始化%s:n %s",
  155. (LPSTR)"COMMFILE", (LPSTR)temp1);
  156. ErrMsg(NULL, temp);
  157. return -1;
  158. }
  159. rlen=*(short *)CommFile.dbfStruct.rlen;
  160. hlen=*(short *)CommFile.dbfStruct.hlen;
  161. }
  163. ReqFile.recnum[i]=GetRecNum(ReqFile.hf[i]);
  165. strcpy(temp1,++prt);
  166. AnsFile.hf[i]=OpenDbfBase(temp1,O_RDWR);
  167. if (ReqFile.hf[i]==-1)
  168. {
  169. wsprintf(temp, "不能打开%s:n %s",
  170. (LPSTR)"COMMFILE", (LPSTR)temp1);
  171. ErrMsg(NULL, temp);
  172. return -1;
  173. } 
  175. prt =strrchr(temp1,'\');
  176. ++prt; *prt =0;
  177. strcpy(&AnsFile.path[i][0],temp1);
  179. AnsFile.recnum[i]=GetRecNum(AnsFile.hf[i]);
  180. AnsFile.recnum[i]=min(AnsFile.recnum[i],ReqFile.recnum[i]);
  181. ReqFile.recnum[i]=AnsFile.recnum[i];
  182. }
  183. }
  185. if(ZqsCount)
  186. if((CommBuffer =GlobalAllocPtr(GHND,*(short*)CommFile.dbfStruct.rlen))==NULL)
  187. {
  188.       ErrMsg(NULL, "不能分配交换文件记录内存!");
  189.       return -1;
  190. }
  191. return 0;
  192. }
  194. int JyExit(void)
  195. {
  196. int i;
  198. for(i=0;i<ZqsCount;i++)
  199. {
  200. if(ReqFile.hf[i]!=-1)
  201. CloseDbf(ReqFile.hf[i]);
  202. if(AnsFile.hf[i]!=-1)
  203. CloseDbf(AnsFile.hf[i]);
  204. }
  205. if(CommFile.fldStruct)
  206. GlobalFreePtr(CommFile.fldStruct);
  207. if(CommBuffer)
  208.         GlobalFreePtr(CommBuffer);
  210. return 0;
  211. }
  213. int Jy_Zqsxx(int sd)
  214. {
  215. int len;
  217. BYTE SendBuff[1024];
  219. strcpy(SendBuff, JY_ZQSXX_HEAD);
  220. len =strlen(JY_ZQSXX_HEAD);
  221. //memcpy(&SendBuff[len],&Zqsxx,sizeof(ZQSXX));
  222. //len+=sizeof(Zqsxx);
  224. memcpy(&SendBuff[len],R,DATALENGTH);
  225. len +=DATALENGTH;
  226. memcpy(&SendBuff[len],PK,DATALENGTH);
  227. len +=DATALENGTH;
  228. UDP_SendBuff("RSA.R.PK", sd, SendBuff, len,NULL);
  229. return 0;
  230. }
  232. void ClearAns(LPJY_DEST lpJyDest)
  233. {
  234. char* buff;
  235.     HANDLE hd;    
  236. if((hd =GlobalAlloc(GHND,rlen))==NULL) return;
  237.     if((buff=GlobalLock(hd))==NULL) return;
  238. memset(buff,' ',rlen);
  239. WriteRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,rlen,buff);
  240. GlobalUnlock(hd);
  241. GlobalFree(hd);
  242. }
  245. void ClearReq(LPJY_DEST lpJyDest)
  246. {
  247. char* buff;
  248.     HANDLE hd;    
  249. if((hd =GlobalAlloc(GHND,rlen))==NULL) return;
  250.     if((buff=GlobalLock(hd))==NULL) return;
  251. memset(buff,' ',rlen);
  252. buff[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]='0';
  253. WriteRecord(ReqFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,rlen,buff);
  254. GlobalUnlock(hd);
  255. GlobalFree(hd);
  256. }
  258. int Jy_ChkUsr(int sd, int jyNum, LPJY_ASK_CHKUSR AskChkUser)
  259. {
  260. int ret;
  261. LPJY_DEST lpJyDest;
  262.     char temp[20];  
  263. short Qsid;
  265. if(ZqsCount ==1)
  266. Qsid =1;
  267. else
  268. Qsid =AskChkUser->zqsid;
  270. if(ReqFile.hf[Qsid -1] ==-1)
  271. return ANS_SYS_ERR;
  273. ret =CheckJyDest(sd,REQ_CHKUSR, AskChkUser->jys,
  274. AskChkUser->gddm, -1, &lpJyDest);
  275. memset(CommBuffer,' ',rlen);
  276. StringToFld(CommBuffer,CommFile.fldStruct[fld_GDDM],AskChkUser->gddm);
  277. CommBuffer[*(short*)(CommFile.fldStruct[fld_STKNO].offset)]
  278. =(AskChkUser->jys ==0)?'Z':'H';
  279. StringToFld(CommBuffer,CommFile.fldStruct[fld_JYMM],AskChkUser->jymm);      
  280. CommBuffer[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]=REQ_CHKUSR;
  281. CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  283. wsprintf(temp,"%d",sd);
  284. StringToFld(CommBuffer,CommFile.fldStruct[fld_ADDR],temp);
  285. wsprintf(temp,"%d",jyNum);
  286. StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);
  288. if(lpJyDest==NULL)
  289. lpJyDest=GetFirstIdelRec();
  290. if(lpJyDest==NULL)
  291. {
  292. ReqFile.currec[Qsid-1]++;
  293. if(ReqFile.currec[Qsid-1]>ReqFile.recnum[Qsid-1])
  294. {
  295. ErrMsg(NULL, "无空闲交易表项!");      
  296. return ANS_SYS_ERR;
  297. }
  298. lpJyDest=AddJyDest(sd, REQ_CHKUSR, AskChkUser->jys,
  299. ReqFile.currec[Qsid-1], AskChkUser->gddm, jyNum,Qsid-1);
  301. if(lpJyDest ==NULL)
  302. {
  303. ErrMsg(NULL, "不能加交易表项!");
  304. return ANS_SYS_ERR;
  305. }
  306. ClearAns(lpJyDest);
  307. if(WriteRecord(ReqFile.hf[Qsid-1],lpJyDest->recNum,
  308. hlen,rlen,CommBuffer) !=0)
  309. {
  310. ErrMsg(NULL, "不能写交换文件!");      
  311. return ANS_SYS_ERR;
  312. }
  313. }
  314. else
  315. {
  316. ClearAns(lpJyDest);
  317. if(WriteRecord(ReqFile.hf[Qsid-1],lpJyDest->recNum,
  318. hlen,rlen,CommBuffer)!=0)
  319. {
  320. ErrMsg(NULL, "不能写交换文件1!");      
  321. return ANS_SYS_ERR;
  322. }
  323. strcpy(lpJyDest->gddm,AskChkUser->gddm);
  324. ChangeJyDest(sd, lpJyDest, REQ_CHKUSR, AskChkUser->jys,
  325. Qsid -1,jyNum);
  326. }
  328. if(fTestJy)
  329. {
  330. Sleep(1000);
  331. CommBuffer[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]=REQ_NULL;
  332. CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)]=ANS_SUCC;
  333. CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  334. wsprintf(temp,"%d",jyNum);
  335. StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);
  337. WriteRecord(AnsFile.hf[Qsid-1],lpJyDest->recNum,hlen,
  338. rlen,CommBuffer);
  339. }
  340. return 0;
  341. }
  343. int Jy_ChgPwd(int sd, int jyNum, LPJY_ASK_CHGPWD AskChgPwd)
  344. {
  345. LPJY_DEST lpJyDest=NULL;
  346. int ret;
  347. char temp[20];
  349. ret =CheckJyDest(sd, REQ_CHGPWD, AskChgPwd->jys, AskChgPwd->gddm,
  350. AskChgPwd->userId, &lpJyDest);
  352. if(ret==-1)
  353. return ANS_SYS_ERR;
  354. if(ret==-2)
  355. return ANS_SUSP_REQ;
  356. if(ret==-3)
  357. return ANS_NO_PRIV;
  359. if(ReqFile.hf[lpJyDest->zqsid] ==-1)
  360. return ANS_SYS_ERR;
  362. memset(CommBuffer,' ',*(short *)CommFile.dbfStruct.rlen);
  363. StringToFld(CommBuffer,CommFile.fldStruct[fld_GDDM],AskChgPwd->gddm);
  364. CommBuffer[*(short*)(CommFile.fldStruct[fld_STKNO].offset)]
  365. =(AskChgPwd->jys ==0)?'Z':'H';
  366. StringToFld(CommBuffer,CommFile.fldStruct[fld_JYMM],AskChgPwd->xmm);      
  367. CommBuffer[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]=REQ_CHGPWD;
  368. CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  370. wsprintf(temp,"%d",sd);
  371. StringToFld(CommBuffer,CommFile.fldStruct[fld_ADDR],temp);
  372. wsprintf(temp,"%d",jyNum);
  373. StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);
  375. ClearAns(lpJyDest);
  376. if(WriteRecord(ReqFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,rlen,CommBuffer)!=0)
  377. {
  378. ErrMsg(NULL, "不能写交换文件!");
  379. return ANS_SYS_ERR;
  380. }
  381. ChangeJyDest(sd, lpJyDest, REQ_CHGPWD, AskChgPwd->jys, -1, jyNum);
  383. if(fTestJy)
  384. {
  385. Sleep(1000);
  386. CommBuffer[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]=REQ_NULL;
  387. CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)]=ANS_SUCC;
  388. CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  389. wsprintf(temp,"%d",jyNum);
  390. StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);
  392. WriteRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,rlen,CommBuffer);
  393. }
  395. return 0;
  396. }
  398. int Jy_BuySell(int sd, int jyNum, LPJY_ASK_BUYSELL AskBuySell)
  399. {
  400. LPJY_DEST lpJyDest;
  401. int ret;
  402. char temp[20];
  404. ret =CheckJyDest(sd, REQ_BUYSEL, AskBuySell->jys, AskBuySell->gddm,
  405. AskBuySell->userId, &lpJyDest);
  407. if(ret==-1)
  408. return ANS_SYS_ERR;
  409. if(ret==-2)
  410. return ANS_SUSP_REQ;
  411. if(ret==-3)
  412. return ANS_NO_PRIV;
  414. if(ReqFile.hf[lpJyDest->zqsid] ==-1)
  415. return ANS_SYS_ERR;
  417. memset(CommBuffer,' ',*(short *)CommFile.dbfStruct.rlen);
  418. StringToFld(CommBuffer,CommFile.fldStruct[fld_GDDM],AskBuySell->gddm);
  419. CommBuffer[*(short*)(CommFile.fldStruct[fld_STKNO].offset)]
  420. =(AskBuySell->jys ==0)?'Z':'H';                         
  421. StringToFld(CommBuffer,CommFile.fldStruct[fld_GPDM],AskBuySell->gpdm);
  422. sprintf(temp,"%12ld",AskBuySell->wtgs);
  423. StringToFld(CommBuffer,CommFile.fldStruct[fld_WTGS],temp);            
  424. sprintf(temp,"%12.2f",(double)(AskBuySell->wtjg/100.00));
  425. StringToFld(CommBuffer,CommFile.fldStruct[fld_WTJG],temp);      
  426. if(AskBuySell->bs =='B')
  427. CommBuffer[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]=REQ_BUY;
  428. else if(AskBuySell->bs =='S')
  429. CommBuffer[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]=REQ_SELL;
  430. else
  431. CommBuffer[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]='E';
  433. CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  434.   wsprintf(temp,"%d",sd);
  435. StringToFld(CommBuffer,CommFile.fldStruct[fld_ADDR],temp);
  436. wsprintf(temp,"%d",jyNum);
  437. StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);
  439. ClearAns(lpJyDest);
  440. if(WriteRecord(ReqFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,rlen,CommBuffer)!=0)
  441. {
  442. ErrMsg(NULL, "不能写交换文件!");      
  443. return ANS_SYS_ERR;
  444. }
  445. if(ChangeJyDest(sd, lpJyDest, REQ_BUYSEL, AskBuySell->jys, -1, jyNum)<0)
  446. return ANS_SYS_ERR;
  448. if(fTestJy)
  449. {
  450. Sleep(1000);
  451. CommBuffer[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]=REQ_NULL;
  452. CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)]=ANS_SUCC;
  453. CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  454. StringToFld(CommBuffer,CommFile.fldStruct[fld_HTHM],"000068");
  455. wsprintf(temp,"%d",jyNum);
  456. StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);
  457.     WriteRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,rlen,CommBuffer);
  458. }
  460. return 0;
  461. }
  463. int Jy_Cancel(int sd, int jyNum, LPJY_ASK_CANCEL AskCancel)
  464. {
  465. LPJY_DEST lpJyDest;
  466. int ret,i;
  467. char temp[20];
  468. HFILE hFile;
  469. OFSTRUCT os;
  471. ret =CheckJyDest(sd, REQ_CANCEL, AskCancel->jys, 
  472. AskCancel->gddm, AskCancel->userId, &lpJyDest);
  473. if(ret==-1)
  474. return ANS_SYS_ERR;
  475. if(ret==-2)
  476. return ANS_SUSP_REQ;
  477. if(ret==-3)
  478. return ANS_NO_PRIV;
  480. if(ReqFile.hf[lpJyDest->zqsid] ==-1)
  481. return ANS_SYS_ERR;
  483. for(i=0;i<AskCancel->cancelCount;i++)
  484. {
  485. memset(CommBuffer,' ',*(short *)CommFile.dbfStruct.rlen);
  486. StringToFld(CommBuffer,CommFile.fldStruct[fld_GDDM],AskCancel->gddm);
  487. StringToFld(CommBuffer,CommFile.fldStruct[fld_HTHM],AskCancel->Cancel[i].hthm);          
  488. CommBuffer[*(short*)(CommFile.fldStruct[fld_STKNO].offset)]
  489. =(AskCancel->jys ==0)?'Z':'H';                      
  490. CommBuffer[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]=REQ_CANCEL;
  491. CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  492.   wsprintf(temp,"%d",sd);
  493. StringToFld(CommBuffer,CommFile.fldStruct[fld_ADDR],temp);
  494. wsprintf(temp,"%d",jyNum);
  495. StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);
  497. ClearAns(lpJyDest);
  498. if(WriteRecord(ReqFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,rlen,
  499. CommBuffer)!=0)
  500. {
  501. ErrMsg(NULL, "不能写交换文件!");      
  502. return ANS_SYS_ERR;
  503. }
  504. }
  505. ChangeJyDest(sd, lpJyDest, REQ_CANCEL, AskCancel->jys, -1, jyNum);
  506. lpJyDest->recCount =AskCancel->cancelCount;
  508. if(fTestJy)
  509. {
  510. Sleep(1000);
  511. CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)]=ANS_SUCC;
  512. CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  513. wsprintf(temp,"%d",AskCancel->cancelCount);
  514. StringToFld(CommBuffer,CommFile.fldStruct[fld_JYMM],temp);
  516. wsprintf(temp,"%d",jyNum);
  517. StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);
  519.     WriteRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,rlen,
  520. CommBuffer);
  522. wsprintf(temp,"%s%d%s",AnsFile.path[lpJyDest->zqsid],lpJyDest->recNum,".ANS");
  523. hFile =OpenFile(temp, &os, OF_CREATE|OF_SHARE_DENY_NONE|OF_WRITE);
  524. if(hFile ==HFILE_ERROR)
  525. return ANS_SYS_ERR;
  527. for(i=0;i<AskCancel->cancelCount;i++)
  528. {
  529. memset(CommBuffer,' ',*(short *)CommFile.dbfStruct.rlen);
  530. StringToFld(CommBuffer,CommFile.fldStruct[fld_GDDM],AskCancel->gddm);
  531. StringToFld(CommBuffer,CommFile.fldStruct[fld_HTHM],AskCancel->Cancel[i].hthm);          
  532. CommBuffer[*(short*)(CommFile.fldStruct[fld_STKNO].offset)]
  533. =(AskCancel->jys ==0)?'Z':'H';                      
  534. CommBuffer[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]=REQ_CANCEL;
  536. CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)]=ANS_SUCC;
  537. CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  539.   wsprintf(temp,"%d",sd);
  540. StringToFld(CommBuffer,CommFile.fldStruct[fld_ADDR],temp);
  541. wsprintf(temp,"%d",jyNum);
  542. StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);
  543. _lwrite(hFile,&CommBuffer[1], rlen-1);
  544. _lwrite(hFile,"rn",2);
  545. }
  546. _lclose(hFile);
  547. }
  549. return 0;
  550. }
  552. int Jy_Yecx(int sd, int jyNum, LPJY_ASK_YECX AskYecx)
  553. {
  554. LPJY_DEST lpJyDest;
  555. int ret,i=0;
  556. char temp[20];
  557. HFILE hFile;
  558. OFSTRUCT os;
  560. ret =CheckJyDest(sd, REQ_YECX, AskYecx->jys, AskYecx->gddm,
  561. AskYecx->userId, &lpJyDest);
  562. if(ret==-1)
  563. return ANS_SYS_ERR;
  564. if(ret==-2)
  565. return ANS_SUSP_REQ;
  566. if(ret==-3)
  567. return ANS_NO_PRIV;
  569. if(ReqFile.hf[lpJyDest->zqsid] ==-1)
  570. return ANS_SYS_ERR;
  572. memset(CommBuffer,' ',*(short *)CommFile.dbfStruct.rlen);
  573. StringToFld(CommBuffer,CommFile.fldStruct[fld_GDDM],AskYecx->gddm);
  574. CommBuffer[*(short*)(CommFile.fldStruct[fld_STKNO].offset)]
  575. =(AskYecx->jys ==0)?'Z':'H';                        
  576. StringToFld(CommBuffer,CommFile.fldStruct[fld_GPDM],AskYecx->gpdm);      
  577. CommBuffer[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]=REQ_YECX;
  578. CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  579.   wsprintf(temp,"%d",sd);
  580. StringToFld(CommBuffer,CommFile.fldStruct[fld_ADDR],temp);
  581. wsprintf(temp,"%d",jyNum);
  582. StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);
  584. ClearAns(lpJyDest);
  585.     wsprintf(temp,"%s%d%s",AnsFile.path[lpJyDest->zqsid],lpJyDest->recNum,".ANS");
  586.     remove(temp);
  587. if(WriteRecord(ReqFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,rlen,
  588. CommBuffer)!=0)
  589. {
  590. ErrMsg(NULL, "不能写交换文件!");
  591. return ANS_SYS_ERR;
  592. }
  593. if(ChangeJyDest(sd, lpJyDest, REQ_YECX, AskYecx->jys, -1, jyNum) <0)
  594. return ANS_SYS_ERR;
  596. if(fTestJy)
  597. {
  598. Sleep(1000);
  599. wsprintf(temp,"%s%d%s",AnsFile.path[lpJyDest->zqsid],lpJyDest->recNum,".ANS");
  600. hFile =OpenFile(temp, &os, OF_CREATE|OF_SHARE_DENY_NONE|OF_WRITE);
  601. if(hFile ==HFILE_ERROR)
  602. return 0;
  604. for(i=0;i<22;i++)
  605. {
  606. memset(CommBuffer,0,sizeof(CommBuffer));
  607. wsprintf(temp,"%04d",i+1);
  608. StringToFld(CommBuffer,CommFile.fldStruct[fld_GPDM],temp);      
  610. wsprintf(temp,"%8d",(i+1)*10);
  611. StringToFld(CommBuffer,CommFile.fldStruct[fld_WTGS],temp);      
  613. wsprintf(temp,"%8d",(i+1)*20);
  614. StringToFld(CommBuffer,CommFile.fldStruct[fld_WTJG],temp);      
  616. StringToFld(CommBuffer,CommFile.fldStruct[fld_DATE],"111111");      
  617. CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  618. _lwrite(hFile,&CommBuffer[1], rlen-1);
  619. _lwrite(hFile,"rn",2);
  620. }
  621. _lclose(hFile);
  623. CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)]=ANS_SUCC;
  624. CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  625. StringToFld(CommBuffer,CommFile.fldStruct[fld_JYMM],"22");
  627. StringToFld(CommBuffer,CommFile.fldStruct[fld_WTGS],"9000000.12");
  628. StringToFld(CommBuffer,CommFile.fldStruct[fld_WTJG],"2000000.99");
  629. wsprintf(temp,"%d",jyNum);
  630. StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);
  632.     WriteRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,rlen,
  633. CommBuffer);
  634. }
  636. return 0;
  637. }
  639. int Jy_Cjcx(int sd, int jyNum, LPJY_ASK_CJCX AskCjcx)
  640. {
  641. LPJY_DEST lpJyDest;
  642. int ret,i=0;
  643. char temp[20];
  644. HFILE hFile;
  645. OFSTRUCT os;
  647. ret =CheckJyDest(sd, REQ_CJCX, AskCjcx->jys, AskCjcx->gddm, AskCjcx->userId, &lpJyDest);
  649. if(ret==-1)
  650. return ANS_SYS_ERR;
  651. if(ret==-2)
  652. return ANS_SUSP_REQ;
  653. if(ret==-3)
  654. return ANS_NO_PRIV;
  656. if(ReqFile.hf[lpJyDest->zqsid] ==-1)
  657. return ANS_SYS_ERR;
  658.       
  659. memset(CommBuffer,' ',*(short *)CommFile.dbfStruct.rlen);
  660. StringToFld(CommBuffer,CommFile.fldStruct[fld_GDDM],AskCjcx->gddm);
  661. CommBuffer[*(short*)(CommFile.fldStruct[fld_STKNO].offset)]
  662. =(AskCjcx->jys ==0)?'Z':'H';                        
  663. StringToFld(CommBuffer,CommFile.fldStruct[fld_DATE],AskCjcx->cjrq);      
  664. StringToFld(CommBuffer,CommFile.fldStruct[fld_HTHM],AskCjcx->hthm);      
  665. CommBuffer[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]=REQ_CJCX;
  666. CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  667.   wsprintf(temp,"%d",sd);
  668. StringToFld(CommBuffer,CommFile.fldStruct[fld_ADDR],temp);
  669. wsprintf(temp,"%d",jyNum);
  670. StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);
  672. ClearAns(lpJyDest);
  673.     wsprintf(temp,"%s%d%s",AnsFile.path[lpJyDest->zqsid],lpJyDest->recNum,".ANS");
  674.     remove(temp);
  675. if(WriteRecord(ReqFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,rlen,
  676. CommBuffer)!=0)
  677. {
  678. ErrMsg(NULL, "不能写交换文件!");
  679. return ANS_SYS_ERR;
  680. }
  681. if(ChangeJyDest(sd, lpJyDest, REQ_CJCX, AskCjcx->jys, -1, jyNum) <0)
  682. {
  683. ErrMsg(NULL,"来自Jy_Cjcx:ChangeJyDest");
  684. return ANS_SYS_ERR;
  685. }
  686. if(fTestJy)
  687. {
  688. Sleep(1000);
  690. CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)]=ANS_SUCC;
  691. CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  692. StringToFld(CommBuffer,CommFile.fldStruct[fld_JYMM],"22");
  693. wsprintf(temp,"%d",jyNum);
  694. StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);
  696.     WriteRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,rlen,
  697. CommBuffer);
  699. wsprintf(temp,"%s%d%s",AnsFile.path[lpJyDest->zqsid],lpJyDest->recNum,".ANS");
  700. hFile =OpenFile(temp, &os, OF_CREATE|OF_SHARE_DENY_NONE|OF_WRITE);
  701. if(hFile ==HFILE_ERROR)
  702. return ANS_SYS_ERR;
  704. for(i=0;i<22;i++)
  705. {
  706. CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)]=i-(int)(i/2)*2==0 ?'B':'S';
  707. wsprintf(temp,"%04d",i+1);
  708. StringToFld(CommBuffer,CommFile.fldStruct[fld_GPDM],temp);      
  710. wsprintf(temp,"%8d",(i+1)*100);
  711. StringToFld(CommBuffer,CommFile.fldStruct[fld_WTGS],temp);      
  713. wsprintf(temp,"%8d",i+10);
  714. StringToFld(CommBuffer,CommFile.fldStruct[fld_WTJG],temp);      
  716. wsprintf(temp,"%06d",i+100);
  717. StringToFld(CommBuffer,CommFile.fldStruct[fld_HTHM],temp);      
  719. StringToFld(CommBuffer,CommFile.fldStruct[fld_DATE],"111111");      
  720. CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  722. _lwrite(hFile,&CommBuffer[1], rlen-1);
  723. _lwrite(hFile,"rn",2);
  724. }
  725. _lclose(hFile);
  726. }
  727. return 0;
  728. }
  730. int Jy_Wtcx(int sd, int jyNum, LPJY_ASK_WTCX AskWtcx)
  731. {
  732. LPJY_DEST lpJyDest;
  733. int ret,i=0;
  734. char temp[20];
  735. HFILE hFile;
  736. OFSTRUCT os;
  738. ret =CheckJyDest(sd, REQ_WTCX, AskWtcx->jys, AskWtcx->gddm,
  739. AskWtcx->userId, &lpJyDest);
  740. if(ret==-1)
  741. return ANS_SYS_ERR;
  742. if(ret==-2)
  743. return ANS_SUSP_REQ;
  744. if(ret==-3)
  745. return ANS_NO_PRIV;
  747. if(ReqFile.hf[lpJyDest->zqsid] ==-1)
  748. return ANS_SYS_ERR;
  750. memset(CommBuffer,' ',*(short *)CommFile.dbfStruct.rlen);
  751. StringToFld(CommBuffer,CommFile.fldStruct[fld_GDDM],AskWtcx->gddm);
  752. CommBuffer[*(short*)(CommFile.fldStruct[fld_STKNO].offset)]
  753. =(AskWtcx->jys ==0)?'Z':'H';                        
  754. StringToFld(CommBuffer,CommFile.fldStruct[fld_DATE],AskWtcx->wtrq);      
  755. StringToFld(CommBuffer,CommFile.fldStruct[fld_HTHM],AskWtcx->hthm);      
  756. CommBuffer[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]=REQ_WTCX;
  757. CommBuffer[*(short*)(CommFile.fldStruct[fld_JYMM].offset)]=AskWtcx->cdcx;
  758. CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  759. wsprintf(temp,"%d",sd);
  760. StringToFld(CommBuffer,CommFile.fldStruct[fld_ADDR],temp);
  761. wsprintf(temp,"%d",jyNum);
  762. StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);
  764. ClearAns(lpJyDest);
  765.     wsprintf(temp,"%s%d%s",AnsFile.path[lpJyDest->zqsid],lpJyDest->recNum,".ANS");
  766.     remove(temp);
  767. if(WriteRecord(ReqFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,rlen,
  768. CommBuffer)!=0)
  769. {
  770. ErrMsg(NULL, "不能写交换文件!");
  771. return ANS_SYS_ERR;
  772. }
  774. if(ChangeJyDest(sd, lpJyDest, REQ_WTCX, AskWtcx->jys, -1, jyNum) <0)
  775. return ANS_SYS_ERR;
  777. if(fTestJy)
  778. {
  779. Sleep(1000);
  781. CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)]=ANS_SUCC;
  782. CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  783. StringToFld(CommBuffer,CommFile.fldStruct[fld_JYMM],"22");
  784. wsprintf(temp,"%d",jyNum);
  785. StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);
  787.     WriteRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,
  788. rlen,CommBuffer);
  790. wsprintf(temp,"%s%d%s",AnsFile.path[lpJyDest->zqsid],lpJyDest->recNum,".ANS");
  791. hFile =OpenFile(temp, &os, OF_CREATE|OF_SHARE_DENY_NONE|OF_WRITE);
  792. if(hFile ==HFILE_ERROR)
  793. return ANS_SYS_ERR;
  794. for(i=0;i<22;i++)
  795. {
  796. CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)]=i-(int)(i/2)*2==0 ?'B':'S';
  797. wsprintf(temp,"%04d",i+1);
  798. StringToFld(CommBuffer,CommFile.fldStruct[fld_GPDM],temp);      
  800. wsprintf(temp,"%8d",(i+1)*100);
  801. StringToFld(CommBuffer,CommFile.fldStruct[fld_WTGS],temp);
  803. wsprintf(temp,"%8d",i+10);
  804. StringToFld(CommBuffer,CommFile.fldStruct[fld_WTJG],temp);      
  806. wsprintf(temp,"%06d",i+100);
  807. StringToFld(CommBuffer,CommFile.fldStruct[fld_HTHM],temp);      
  809. StringToFld(CommBuffer,CommFile.fldStruct[fld_DATE],"111111");      
  810. CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  812. _lwrite(hFile,&CommBuffer[1], rlen-1);
  813. _lwrite(hFile,"rn",2);
  814. }
  815. _lclose(hFile);
  816. }
  818. return 0;
  819. }
  821. int JyDest_ChkUsr(LPJY_DEST lpJyDest)
  822. {
  823. BYTE SendBuff[2048];
  824. int ret, len;
  825. char stat,temp[10];
  826.     JY_ANS_CHKUSR AnsUser;
  828. ReadRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,
  829. rlen,CommBuffer);
  830. stat=CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)];
  831. if(stat !=';') 
  832. return 0;
  834. FldToString(CommBuffer,&CommFile.fldStruct[fld_SERI],temp);
  835. if(lpJyDest->jyNum!=atoi(temp)) 
  836. return 0;
  838. ret=CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)];
  839. if(ret==' ')
  840. return 0;
  841. strcpy(SendBuff, JY_CHKUSR_HEAD);
  842. len =strlen(SendBuff);
  843. *(short *)&SendBuff[len] =lpJyDest->jyNum;
  844. len +=sizeof(short);
  846. AnsUser.jys=lpJyDest->curJys;
  847.     AnsUser.userId=lpJyDest->userId;
  848. strcpy(AnsUser.gddm,lpJyDest->gddm);
  849. AnsUser.flag=(char)ret;
  850. memcpy(&SendBuff[len],&AnsUser,sizeof(JY_ANS_CHKUSR));
  851. len+=sizeof(AnsUser);
  852. UDP_SendBuff("检查交易用户", lpJyDest->sd, SendBuff, len,NULL);  
  853. lpJyDest->isReqEnd =TRUE;
  855. ClearReq(lpJyDest);
  856. return 0;
  857. }
  858.        
  859. int JyDest_ChgPwd(LPJY_DEST lpJyDest)
  860. {
  861. BYTE SendBuff[100];
  862. int ret, stat, len;
  863. JY_ANS_CHGPWD AnsChgPwd;
  864.     char temp[10];
  866. ReadRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,
  867. rlen,CommBuffer);
  868. stat=CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)];                     
  869. if(stat !=';') 
  870. return 0;
  872. FldToString(CommBuffer,&CommFile.fldStruct[fld_SERI],temp);
  873. if(lpJyDest->jyNum!=atoi(temp)) 
  874. return 0;
  876. ret=CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)];
  877. if(ret==' ')
  878. return 0;
  879. AnsChgPwd.flag =(char)ret;
  880. AnsChgPwd.jys =lpJyDest->curJys;
  882. strcpy(SendBuff, JY_CHGPWD_HEAD);
  883. len =strlen(SendBuff);
  884. *(short *)&SendBuff[len] =lpJyDest->jyNum;
  885. len +=sizeof(short);
  887. strcpy(AnsChgPwd.gddm, lpJyDest->gddm);
  888. memcpy(&SendBuff[len], &AnsChgPwd, sizeof(AnsChgPwd));
  889. len +=sizeof(AnsChgPwd);
  891. UDP_SendBuff("修改交易密码", lpJyDest->sd, SendBuff, len, NULL);
  893. lpJyDest->isReqEnd =TRUE;
  894. ClearReq(lpJyDest);
  895. return 0;
  896. }
  897.        
  898. int JyDest_BuySell(LPJY_DEST lpJyDest)
  899. {
  900. char hthm[20],temp[10];
  901. BYTE SendBuff[100];
  902. int stat, ret, len;
  903.     JY_ANS_BUYSELL AnsBuySell; 
  905. ReadRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,
  906. hlen,rlen,CommBuffer);
  907. stat=CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)];                     
  908. if(stat !=';') 
  909. return 0;
  911. FldToString(CommBuffer,&CommFile.fldStruct[fld_SERI],temp);
  912. if(lpJyDest->jyNum!=atoi(temp)) 
  913. return 0;
  915. ret=CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)];
  916. if(ret==' ')
  917. return 0;
  918. hthm[0] =0;
  919. if(ret==ANS_SUCC)
  920. {
  921. FldToString(CommBuffer,&CommFile.fldStruct[fld_HTHM],hthm);
  922. memset(temp,' ',(short)CommFile.fldStruct[fld_HTHM].wid);
  923. if(strncmp(hthm,temp,(short)CommFile.fldStruct[fld_HTHM].wid)==0)
  924. return 0;
  925. }
  926. AnsBuySell.jys=lpJyDest->curJys;
  927. strcpy(AnsBuySell.gddm,lpJyDest->gddm);
  928. strcpy(AnsBuySell.hthm,hthm);
  929. AnsBuySell.bs=REQ_BUYSEL;
  930. AnsBuySell.flag=(char)ret;
  932. strcpy(SendBuff, JY_BUYSELL_HEAD);
  933. len =strlen(SendBuff);
  934. *(short *)&SendBuff[len] =lpJyDest->jyNum;
  935. len +=sizeof(short);
  937. memcpy(&SendBuff[len],&AnsBuySell,sizeof(AnsBuySell));
  938. len+=sizeof(AnsBuySell);
  940. UDP_SendBuff("买卖委托", lpJyDest->sd, SendBuff, len, NULL);
  942. lpJyDest->isReqEnd =TRUE;
  943. ClearReq(lpJyDest);
  944. return 0;
  945. }
  947.        
  948. int JyDest_Cancel(LPJY_DEST lpJyDest)
  949. {
  950. BYTE SendBuff[600];
  951. int ret, stat, len, i,retnum;
  952. JY_ANS_CANCEL AnsCancel;
  953. char temp[20],tmp[13];
  954. HFILE hFile;
  955. OFSTRUCT os;
  957. ReadRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,
  958. hlen,rlen,CommBuffer);
  960. stat=CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)];
  961. if(stat!=';') 
  962. return 0;
  964. FldToString(CommBuffer,&CommFile.fldStruct[fld_SERI],temp);
  965. if(lpJyDest->jyNum!=atoi(temp)) 
  966. return 0;
  968. ret=CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)];
  969. if(ret==' ')
  970. return 0;
  972. FldToString(CommBuffer,&CommFile.fldStruct[fld_JYMM],temp);
  973. memset(tmp,' ',(short)CommFile.fldStruct[fld_JYMM].wid);
  974. if(ret==ANS_SUCC&&strncmp(temp,tmp,(short)CommFile.fldStruct[fld_JYMM].wid)==0)
  975. return 0;
  976. retnum=atoi(temp);
  978. if(ret!=ANS_SUCC)
  979. AnsCancel.flag[0] =ret;
  980. else
  981. {
  982. if(retnum==1)
  983. {
  984. ret=CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)];
  985. AnsCancel.flag[0] =ret;
  986. }
  987. else
  988. {
  989. wsprintf(temp,"%s%d%s",AnsFile.path[lpJyDest->zqsid],lpJyDest->recNum,".ANS");
  990. hFile =OpenFile(temp, &os, OF_SHARE_DENY_NONE|OF_READ);
  992. if(hFile ==HFILE_ERROR)
  993. return 0;
  995. i=_llseek(hFile, 0L, FILE_END);
  996. if(i==HFILE_ERROR)
  997. {
  998. _lclose(hFile);
  999. return 0;
  1000. }
  1001. if((i-1)/(rlen+1)!=retnum)
  1002. {
  1003. _lclose(hFile);
  1004. return 0;
  1005. }
  1006. _llseek(hFile, 0L, FILE_BEGIN);
  1008. for(i =0; i<retnum; i++)
  1009. {
  1010. if((short)_lread(hFile,&CommBuffer[1],rlen -1)!=rlen -1)
  1011. break;
  1013. ret=CommBuffer[*(int*)(CommFile.fldStruct[fld_ANSNO].offset)];
  1014. AnsCancel.flag[i] =ret;
  1015. _llseek(hFile, 2L, FILE_CURRENT);
  1016. }
  1017. _lclose(hFile);
  1018. remove(temp);
  1019. }
  1020. }
  1021. AnsCancel.jys =lpJyDest->curJys;
  1022. strcpy(AnsCancel.gddm, lpJyDest->gddm);
  1024. strcpy(SendBuff, JY_CANCEL_HEAD);
  1025. len =strlen(SendBuff);
  1026. *(short *)&SendBuff[len] =lpJyDest->jyNum;
  1027. len +=sizeof(short);
  1029. memcpy(&SendBuff[len], &AnsCancel, sizeof(AnsCancel));
  1030. len +=sizeof(AnsCancel);
  1032. UDP_SendBuff("撤消委托", lpJyDest->sd, SendBuff, len,NULL);
  1033. lpJyDest->isReqEnd =TRUE;
  1034. ClearReq(lpJyDest);
  1035. return 0;
  1036. }
  1037.        
  1038. int JyDest_Yecx(LPJY_DEST lpJyDest)
  1039. {
  1040. char temp[40],tmp[40];
  1041. JY_ANS_YECX AnsYecx;
  1042. int ret, i,retnum;
  1043. char stat;
  1044. HFILE hFile;
  1045. OFSTRUCT os;
  1046.     HANDLE hd;
  1048. ReadRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,
  1049. hlen,rlen,CommBuffer);
  1050. stat=CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)];                     
  1051. if(stat !=';') 
  1052. return 0;
  1054. FldToString(CommBuffer,&CommFile.fldStruct[fld_SERI],temp);
  1055. if(lpJyDest->jyNum!=atoi(temp)) 
  1056. return 0;
  1058. ret=CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)];
  1059. if(ret==' ')
  1060. return 0;
  1062. FldToString(CommBuffer,&CommFile.fldStruct[fld_JYMM],temp);
  1063. memset(tmp,' ',(short)CommFile.fldStruct[fld_JYMM].wid);
  1064. if(ret==ANS_SUCC&&strncmp(temp,tmp,(short)CommFile.fldStruct[fld_JYMM].wid)==0)
  1065. return 0;
  1066. retnum=atoi(temp);
  1068. if(ret==ANS_SUCC&&retnum>0)
  1069. {
  1070. wsprintf(tmp,"%s%d%s",AnsFile.path[lpJyDest->zqsid],lpJyDest->recNum,".ANS");
  1071. hFile =OpenFile(tmp, &os, OF_SHARE_DENY_NONE|OF_READ);
  1073. if(hFile ==HFILE_ERROR)
  1074. return 0;
  1076. i=_llseek(hFile, 0L, FILE_END);
  1077. if(i==HFILE_ERROR)
  1078. {
  1079. _lclose(hFile);
  1080. return 0;
  1081. }
  1082. if((i)/(rlen+1)<retnum)
  1083. {
  1084. _lclose(hFile);
  1085. return 0;
  1086. }
  1087. _llseek(hFile, 0L, FILE_BEGIN);
  1088. }
  1090. if(ret==ANS_SUCC)
  1091. {
  1092. FldToString(CommBuffer,&CommFile.fldStruct[fld_WTJG],temp);
  1093. AnsYecx.kys=atof(temp);      
  1094. FldToString(CommBuffer,&CommFile.fldStruct[fld_WTGS],temp);
  1095. AnsYecx.zjye=atof(temp);     
  1097. if(retnum>0)
  1098. {
  1099. //AnsYecx.lpGptg=(LPJY_GPTG)malloc(sizeof(JY_GPTG)*retnum);
  1100. hd =GlobalAlloc(GHND,sizeof(JY_GPTG)*retnum);
  1101. AnsYecx.lpGptg=GlobalLock(hd);
  1102. memset(&AnsYecx.lpGptg[0],0,sizeof(JY_GPTG)*retnum);
  1103. }
  1104. for(i=0;i<retnum;i++)
  1105. {
  1106. memset(CommBuffer,0,sizeof(CommBuffer));
  1107. if((short)_lread(hFile,&CommBuffer[1],rlen -1)!=rlen -1)
  1108. break;
  1110. FldToString(CommBuffer,&CommFile.fldStruct[fld_GPDM],
  1111. &AnsYecx.lpGptg[i].gpdm[0]);
  1113. FldToString(CommBuffer,&CommFile.fldStruct[fld_WTGS],
  1114. &AnsYecx.lpGptg[i].kys[0]);
  1116. FldToString(CommBuffer,&CommFile.fldStruct[fld_WTJG],
  1117. &AnsYecx.lpGptg[i].gpye[0]);
  1119. FldToString(CommBuffer,&CommFile.fldStruct[fld_DATE],
  1120. &AnsYecx.lpGptg[i].ghrq[0]);
  1121. _llseek(hFile, 2L, FILE_CURRENT);
  1122. }
  1123. if(retnum>0)
  1124. {
  1125. _lclose(hFile);
  1126. remove(tmp);
  1127. }
  1128. AnsYecx.recnum=retnum;
  1129. AnsYecx.flag=ret;
  1130. if(AnsYecx.recnum >=0)
  1131. {
  1132. lpJyDest->isSending =TRUE;
  1133. Thrd_SendJycx(REQ_YECX, lpJyDest->sd, &AnsYecx, lpJyDest->jyNum);
  1134. if(retnum>0)
  1135. {
  1136. //free(AnsYecx.lpGptg);
  1137. GlobalUnlock(hd);
  1138. GlobalFree(hd);
  1139. }
  1140. lpJyDest->isSending =FALSE;
  1141. }
  1142. }
  1143. else
  1144. {
  1145. lpJyDest->isReqEnd =TRUE;
  1146.         ClearReq(lpJyDest);
  1147.      return ret;
  1148. }
  1149. lpJyDest->isReqEnd =TRUE;
  1150. ClearReq(lpJyDest);
  1151. return 0;
  1152. }
  1153.        
  1154. int JyDest_Cjcx(LPJY_DEST lpJyDest)
  1155. {
  1156. JY_ANS_CJCX AnsCjcx;
  1157. int i, ret,retnum;
  1158. char stat, temp[40],tmp[40];
  1159. HFILE hFile;
  1160. OFSTRUCT os;
  1161. HANDLE hd;
  1163. ReadRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,
  1164. hlen,rlen,CommBuffer);
  1165. stat=CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)];                     
  1166. if(stat !=';') 
  1167. return 0;
  1168. FldToString(CommBuffer,&CommFile.fldStruct[fld_SERI],temp);
  1169. if(lpJyDest->jyNum!=atoi(temp)) 
  1170. return 0;
  1172. ret=CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)];
  1173. if(ret==' ')
  1174. return 0;
  1175. FldToString(CommBuffer,&CommFile.fldStruct[fld_JYMM],temp);
  1176. memset(tmp,' ',(short)CommFile.fldStruct[fld_JYMM].wid);
  1177. if(ret==ANS_SUCC&&strncmp(temp,tmp,(short)CommFile.fldStruct[fld_JYMM].wid)==0)
  1178. return 0;
  1179. retnum=atoi(temp);
  1181. if(ret==ANS_SUCC&&retnum>0)
  1182. {
  1183. wsprintf(tmp,"%s%d%s",AnsFile.path[lpJyDest->zqsid],lpJyDest->recNum,".ANS");
  1184. hFile =OpenFile(tmp, &os, OF_SHARE_DENY_NONE|OF_READ);
  1186. if(hFile ==HFILE_ERROR)
  1187. return 0;
  1189. i=_llseek(hFile, 0L, FILE_END);
  1190. if(i==HFILE_ERROR)
  1191. {
  1192. _lclose(hFile);
  1193. return 0;
  1194. }
  1195. if((i)/(rlen+1)<retnum)
  1196. {
  1197. _lclose(hFile);
  1198. return 0;
  1199. }
  1200. _llseek(hFile, 0L, FILE_BEGIN);
  1201. }
  1203. if(ret==ANS_SUCC)
  1204. { 
  1205. if(retnum>0)
  1206. {
  1207. //AnsCjcx.lpCj=(LPJY_CJ)malloc(sizeof(JY_CJ)*retnum);
  1208. hd =GlobalAlloc(GHND,sizeof(JY_CJ)*retnum);
  1209. AnsCjcx.lpCj=GlobalLock(hd);
  1210. memset(&AnsCjcx.lpCj[0],0,sizeof(JY_CJ)*retnum);
  1211. }
  1212. for(i=0;i<retnum;i++)
  1213. {
  1214. memset(CommBuffer,0,sizeof(CommBuffer));
  1215. if((short)_lread(hFile,&CommBuffer[1],rlen -1)!=rlen -1)
  1216. break;
  1218. FldToString(CommBuffer,&CommFile.fldStruct[fld_HTHM],
  1219. &AnsCjcx.lpCj[i].hthm[0]);
  1221. FldToString(CommBuffer,&CommFile.fldStruct[fld_DATE],
  1222. &AnsCjcx.lpCj[i].cjsj[0]);
  1224. AnsCjcx.lpCj[i].mmbz=
  1225. CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)];
  1227. FldToString(CommBuffer,&CommFile.fldStruct[fld_GPDM],
  1228. &AnsCjcx.lpCj[i].gpdm[0]);
  1230. FldToString(CommBuffer,&CommFile.fldStruct[fld_WTGS],
  1231. &AnsCjcx.lpCj[i].cjgs[0]);
  1232. FldToString(CommBuffer,&CommFile.fldStruct[fld_WTJG],
  1233. &AnsCjcx.lpCj[i].cjjg[0]);
  1235. _llseek(hFile, 2L, FILE_CURRENT);
  1236. }
  1237. if(retnum>0)
  1238. {
  1239. _lclose(hFile);
  1240. remove(tmp);
  1241. }
  1242. AnsCjcx.recnum=retnum;
  1243. AnsCjcx.flag =ret;
  1244. if(AnsCjcx.recnum >=0)
  1245. {
  1246. lpJyDest->isSending =TRUE;
  1247. Thrd_SendJycx(REQ_CJCX, lpJyDest->sd, &AnsCjcx, lpJyDest->jyNum);
  1248. if(retnum>0)
  1249. {
  1250. //free(AnsCjcx.lpCj);
  1251. GlobalUnlock(hd);
  1252. GlobalFree(hd);
  1253. }
  1254. lpJyDest->isSending =FALSE;
  1255. }
  1256. }
  1257. else
  1258. {
  1259. lpJyDest->isReqEnd =TRUE;
  1260. ClearReq(lpJyDest);
  1261. return ret;
  1262. }
  1263. lpJyDest->isReqEnd =TRUE;
  1264. ClearReq(lpJyDest);
  1265. return 0;
  1266. }
  1268. int JyDest_Wtcx(LPJY_DEST lpJyDest)
  1269. {
  1270. JY_ANS_WTCX AnsWtcx;
  1271. int ret, i,retnum;
  1272. char stat, temp[40],tmp[40];
  1273. HFILE hFile;
  1274. OFSTRUCT os;
  1275. HANDLE hd;
  1277. ReadRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,
  1278. hlen,rlen,CommBuffer);
  1279. stat=CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)];
  1280. if(stat !=';') 
  1281. return 0;
  1283. FldToString(CommBuffer,&CommFile.fldStruct[fld_SERI],temp);
  1284. if(lpJyDest->jyNum!=atoi(temp)) return 0;
  1286. ret=CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)];
  1287. if(ret==' ')
  1288. return 0;
  1289. FldToString(CommBuffer,&CommFile.fldStruct[fld_JYMM],temp);
  1290. memset(tmp,' ',(short)CommFile.fldStruct[fld_JYMM].wid);
  1291. if(ret==ANS_SUCC&&strncmp(temp,tmp,(short)CommFile.fldStruct[fld_JYMM].wid)==0)
  1292. return 0;
  1293. retnum=atoi(temp);
  1295. if(ret==ANS_SUCC&&retnum>0)
  1296. {
  1297. wsprintf(temp,"%s%d%s",AnsFile.path[lpJyDest->zqsid],lpJyDest->recNum,".ANS");
  1298. hFile =OpenFile(temp, &os, OF_SHARE_DENY_NONE|OF_READ);
  1300. if(hFile ==HFILE_ERROR)
  1301. return 0;
  1303. i=_llseek(hFile, 0L, FILE_END);
  1304. if(i==HFILE_ERROR)
  1305. {
  1306. _lclose(hFile);
  1307. return 0;
  1308. }
  1309. if((i)/(rlen+1)<retnum)
  1310. {
  1311. _lclose(hFile);
  1312. return 0;
  1313. }
  1314. _llseek(hFile, 0L, FILE_BEGIN);
  1315. }
  1317. if(ret==ANS_SUCC)
  1318. { 
  1319. if(retnum>0)
  1320. {
  1321. //AnsWtcx.lpWt=(LPJY_WT)malloc(sizeof(JY_WT)*retnum);
  1322. hd =GlobalAlloc(GHND,sizeof(JY_WT)*retnum);
  1323. AnsWtcx.lpWt =GlobalLock(hd);
  1324. memset(&AnsWtcx.lpWt[0], 0, sizeof(JY_WT)*retnum);
  1325. }
  1326. for(i=0;i<retnum;i++)
  1327. {
  1328. memset(CommBuffer,0,sizeof(CommBuffer));
  1329. if((short)_lread(hFile,&CommBuffer[1],rlen -1)!=rlen -1)
  1330. break;
  1331. FldToString(CommBuffer,&CommFile.fldStruct[fld_HTHM],
  1332. &AnsWtcx.lpWt[i].hthm[0]);
  1334. FldToString(CommBuffer,&CommFile.fldStruct[fld_DATE],
  1335. &AnsWtcx.lpWt[i].wtsj[0]);
  1337. AnsWtcx.lpWt[i].mmbz=
  1338. CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)];
  1340. FldToString(CommBuffer,&CommFile.fldStruct[fld_GPDM],
  1341. &AnsWtcx.lpWt[i].gpdm[0]);
  1343. FldToString(CommBuffer,&CommFile.fldStruct[fld_WTGS],
  1344. &AnsWtcx.lpWt[i].wtgs[0]);
  1345. FldToString(CommBuffer,&CommFile.fldStruct[fld_WTJG],
  1346. &AnsWtcx.lpWt[i].wtjg[0]);
  1347. _llseek(hFile, 2L, FILE_CURRENT);
  1348. }
  1349. if(retnum>0)
  1350. {
  1351. _lclose(hFile);
  1352. remove(tmp);
  1353. }
  1354. AnsWtcx.recnum=retnum;
  1355. AnsWtcx.flag =ret;
  1356. if(AnsWtcx.recnum >=0)
  1357. {
  1358. lpJyDest->isSending =TRUE;
  1359. Thrd_SendJycx(REQ_WTCX, lpJyDest->sd, &AnsWtcx, lpJyDest->jyNum);
  1360. if(AnsWtcx.recnum>0)
  1361. {
  1362. //free(AnsWtcx.lpWt);
  1363. GlobalUnlock(hd);
  1364. GlobalFree(hd);
  1365. }
  1366. lpJyDest->isSending =FALSE;
  1367. }
  1368. }
  1369. else
  1370. {
  1371. lpJyDest->isReqEnd =TRUE;
  1372. ClearReq(lpJyDest);
  1373. return ret;
  1374. }
  1375. lpJyDest->isReqEnd =TRUE;
  1376. ClearReq(lpJyDest);
  1377. return 0;
  1378. }
  1380. int Thrd_SendJycx(int reqType, int sd, char *lpBuf, int jyNum)
  1381. {
  1382. char SendBuff[2048];
  1383. LPJY_ANS_YECX lpAnsYecx;
  1384. LPJY_ANS_CJCX lpAnsCjcx;
  1385. LPJY_ANS_WTCX lpAnsWtcx;
  1386. int i, len, recCount, sendCount, sendNum;
  1388. sendNum =0;
  1389. sendCount =MAX_CX_SENDCOUNT;
  1390. switch(reqType)
  1391. {
  1392. case REQ_YECX:
  1393. lpAnsYecx =(LPJY_ANS_YECX)lpBuf;
  1394. recCount =lpAnsYecx->recnum;
  1395. for(i =0; i<=recCount/MAX_CX_SENDCOUNT; i++)
  1396. {
  1397. sendNum =i*MAX_CX_SENDCOUNT;
  1398. if(sendNum+sendCount >recCount)
  1399. sendCount =recCount-sendNum;
  1401. strcpy(SendBuff, JY_YECX_HEAD);
  1402. len =strlen(SendBuff);
  1403. *(short *)&SendBuff[len] =jyNum;
  1404. len +=sizeof(short);
  1405. lpAnsYecx->recnum=sendCount;
  1406. memcpy(&SendBuff[len],lpAnsYecx,sizeof(JY_ANS_YECX)-sizeof(LPJY_GPTG));
  1407.             len+=sizeof(JY_ANS_YECX)-sizeof(LPJY_GPTG);
  1409. if(sendCount==0&&sendNum!=0)
  1410. break;
  1412. if(sendCount>0)
  1413. {
  1414. memcpy(&SendBuff[len], &lpAnsYecx->lpGptg[sendNum],
  1415. sizeof(JY_GPTG)*sendCount);
  1416. len +=sizeof(JY_GPTG)*sendCount;
  1417. }
  1418. if(UDP_SendBuff("余额查询", sd, SendBuff, len,NULL)<0)
  1419. return -1;
  1420. }
  1421. break;
  1422. case REQ_CJCX:
  1423. lpAnsCjcx =(LPJY_ANS_CJCX)lpBuf;
  1424. recCount =lpAnsCjcx->recnum;
  1425. sendCount =MAX_CX_SENDCOUNT;
  1426. for(i =0; i<=recCount/MAX_CX_SENDCOUNT; i++)
  1427. {
  1428. sendNum =i*MAX_CX_SENDCOUNT;
  1429. if(sendNum+sendCount >recCount)
  1430. sendCount =recCount-sendNum;
  1432. strcpy(SendBuff, JY_CJCX_HEAD);
  1433. len =strlen(SendBuff);
  1434. *(short *)&SendBuff[len] =jyNum;
  1435. len +=sizeof(short);
  1437. lpAnsCjcx->recnum=sendCount;
  1438.             memcpy(&SendBuff[len],lpAnsCjcx,sizeof(JY_ANS_CJCX)-sizeof(LPJY_CJ));
  1439.             len+=sizeof(JY_ANS_CJCX)-sizeof(LPJY_CJ);
  1441. if(sendCount==0&&sendNum!=0)
  1442. break;
  1443. if(sendCount>0)
  1444. {
  1445.   memcpy(&SendBuff[len], &lpAnsCjcx->lpCj[sendNum],
  1446. sizeof(JY_CJ)*sendCount);
  1447. len +=sizeof(JY_CJ)*sendCount;
  1448. }
  1449. if(UDP_SendBuff("成交查询", sd, SendBuff, len,NULL)<0)
  1450. return -1; 
  1451. }
  1452. break;
  1453. case REQ_WTCX:
  1454. lpAnsWtcx =(LPJY_ANS_WTCX)lpBuf;
  1455. recCount =lpAnsWtcx->recnum;
  1456. sendCount =MAX_CX_SENDCOUNT;
  1457. for(i =0; i<=recCount/MAX_CX_SENDCOUNT; i++)
  1458. {
  1459. sendNum =i*MAX_CX_SENDCOUNT;
  1460. if(sendNum+sendCount >recCount)
  1461. sendCount =recCount-sendNum;
  1462. strcpy(SendBuff, JY_WTCX_HEAD);
  1463. len =strlen(SendBuff);
  1464. *(short *)&SendBuff[len] =jyNum;
  1465. len +=sizeof(short);
  1467. lpAnsWtcx->recnum=sendCount;
  1468. memcpy(&SendBuff[len],lpAnsWtcx,sizeof(JY_ANS_WTCX)-sizeof(LPJY_WT));
  1469.             len+=sizeof(JY_ANS_WTCX)-sizeof(LPJY_WT);
  1470. if(sendCount>0)
  1471. {
  1472. memcpy(&SendBuff[len], &lpAnsWtcx->lpWt[sendNum],
  1473. sizeof(JY_WT)*sendCount);
  1474. len +=sizeof(JY_WT)*sendCount;
  1475. }
  1476. if(sendCount==0&&sendNum!=0)
  1477. break;
  1478. if(UDP_SendBuff("委托查询", sd, SendBuff, len,NULL)<0)
  1479. return -1;
  1480. }
  1481. break;
  1482. }
  1483. strcpy(SendBuff, JY_CXEND_HEAD);
  1484. len =strlen(SendBuff);
  1486. UDP_SendBuff("查询成功", sd, SendBuff, len,NULL);
  1487. return 0;
  1488. }
  1490. int Jy_SendRet(int sd, char reqType, char ret, int jyNum)
  1491. {
  1492. int len;
  1493. BYTE SendBuff[100];
  1494. LPSTR lpHead;
  1496. if(ret ==ANS_TIME_OUT)
  1497. lpHead =JY_TIMEOUT_HEAD;
  1498. else
  1499. switch(reqType)
  1500. {
  1501. case REQ_CHKUSR:
  1502. lpHead =JY_CHKUSR_HEAD;
  1503. break;
  1504. case REQ_CHGPWD:
  1505. lpHead =JY_CHGPWD_HEAD;
  1506. break;
  1507. case REQ_BUYSEL:
  1508. lpHead =JY_BUYSELL_HEAD;
  1509. break;
  1510. case REQ_CANCEL:
  1511. lpHead =JY_CANCEL_HEAD;
  1512. break;
  1513. case REQ_YECX:
  1514. lpHead =JY_YECX_HEAD;
  1515. break;
  1516. case REQ_CJCX:
  1517. lpHead =JY_CJCX_HEAD;
  1518. break;
  1519. case REQ_WTCX:
  1520. lpHead =JY_WTCX_HEAD;
  1521. break;
  1522. }
  1523. strcpy(SendBuff, lpHead);
  1524. len =strlen(SendBuff);
  1525. *(short *)&SendBuff[len] =jyNum;
  1526. len +=sizeof(short);
  1527. SendBuff[len++] =(char)ret;
  1529. UDP_SendBuff("发送结果", sd, SendBuff, len,NULL);
  1531. return 0;
  1532. }