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

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

金融证券系统

开发平台：

Visual C++

Heng.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"
  17. #define __SERVER_CCR
  18. #include "heng.h"
  20. #define MAX_PATH_LEN 128
  21. #define START_REC_NO 94
  23. //DBF_DATA CommFile;
  25. typedef struct  tag_ANSFILE
  26. {
  27. HANDLE hf[MAX_ZQS_COUNT];
  28. int recnum[MAX_ZQS_COUNT];
  29. char path[MAX_ZQS_COUNT][MAX_PATH_LEN];
  30. }ANSFILE;
  31. ANSFILE AnsFile;
  33. typedef struct  tag_REQFILE
  34. {
  35. HANDLE hf[MAX_ZQS_COUNT];
  36. int recnum[MAX_ZQS_COUNT];
  37. int currec[MAX_ZQS_COUNT];
  38. }REQFILE;
  39. REQFILE ReqFile;
  41. int ZqsCount;
  43. //char * CommBuffer;
  44. short rlen,hlen;
  46. char RetFilePath[80];
  47. BOOL fUseJy =FALSE,fTestJy=FALSE,fRsa=FALSE;
  48. int Thrd_SendJycx(int sd, int reqType, void *lpBuf, int);
  51. extern int sdJy;
  53. extern BOOL GetInitString(LPSTR, LPSTR, LPSTR);
  54. extern BOOL PutInitString(LPSTR, LPSTR, LPSTR);
  55. extern BOOL ErrMsg(HWND, LPSTR);
  57. //extern int UDP_SendBuff(LPSTR, int, LPSTR, int, LPDEST_INFO );
  59. #define WriteRecord WriteDatRec
  60. int WriteDatRec(HANDLE hd,int no,short hlen,short rlen,char  *rbuff)
  61. {
  62. DWORD bytes;
  63. int i=0;
  65. SetFilePointer(hd,(long)(hlen + rlen*(START_REC_NO +no -1)),NULL,FILE_BEGIN);
  66. do
  67. {
  68. if(LockFile(hd,(DWORD)(hlen + rlen*(START_REC_NO +no -1)),0,rlen,0))
  69. break;
  70. else
  71. Sleep(RETRY_DELAY +RETRY_DELAY/2);
  72. }while(i<LOCK_RETRY_TIMES);
  74. if(i>=LOCK_RETRY_TIMES)
  75. return -1;
  77. if(WriteFile(hd,rbuff,rlen,&bytes,NULL))
  78. {
  79. if(bytes!=(DWORD)rlen)
  80. {
  81. UnlockFile(hd,(DWORD)(hlen + rlen*(START_REC_NO +no -1)),0,rlen,0);
  82. return -1;
  83. }
  84. }
  85. else
  86. {
  87. UnlockFile(hd,(DWORD)(hlen + rlen*(START_REC_NO +no -1)),0,rlen,0);
  88. return -1;
  89. }
  90. UnlockFile(hd,(DWORD)(hlen + rlen*(START_REC_NO +no -1)),0,rlen,0);
  91. return 0;
  92. }
  94. #define  ReadRecord   ReadDatRec
  95. int ReadDatRec(HANDLE hd,int no,short hlen,short rlen,char *rbuff)
  96. {
  97. DWORD bytes;
  98. int i=0;
  100. SetFilePointer(hd,(long)(hlen + rlen*(START_REC_NO+no -1)),NULL,FILE_BEGIN);
  101. do
  102. {
  103. if(LockFile(hd,(DWORD)(hlen + rlen*(START_REC_NO +no -1)),0,rlen,0))
  104. break;
  105. else
  106. Sleep(RETRY_DELAY +RETRY_DELAY/2);
  107. }while(i<LOCK_RETRY_TIMES);
  109. if(i>=LOCK_RETRY_TIMES)
  110. return -1;
  112. if(ReadFile(hd,rbuff,rlen,&bytes,NULL))
  113. {
  114. if(bytes!=(DWORD)rlen)
  115. {
  116. UnlockFile(hd,(DWORD)(hlen + rlen*(START_REC_NO +no -1)),0,rlen,0);
  117. return -1;
  118. }
  119. }
  120. else
  121. {
  122. UnlockFile(hd,(DWORD)(hlen + rlen*(START_REC_NO +no -1)),0,rlen,0);
  123. return -1;
  124. }
  125. UnlockFile(hd,(DWORD)(hlen + rlen*(START_REC_NO +no -1)),0,rlen,0);
  126. return 0;
  127. }
  129. int JyInit(void)
  130. {       
  131. int i,j;
  132.     char tmp[256], temp[256],temp1[256];
  133. char * prt;
  134. REQUEST_BUFFER ReqBuf;
  135. ANSWER Answer;
  137. DWORD bytes;
  139. memset(&ReqFile,0,sizeof(REQFILE));
  140. memset(&AnsFile,0,sizeof(ANSFILE));
  142. memset(&ReqBuf,0,sizeof(REQUEST_BUFFER));
  143. memset(&Answer,0,sizeof(ANSWER));
  145. if(GetInitString("JY", "RUN", tmp))
  146. {
  147. if(tmp[0] =='N' || tmp[0] =='n')
  148. {
  149. fUseJy =FALSE;
  150. return 0;
  151. }
  152. else
  153. fUseJy =TRUE;
  154. }
  157. if(GetInitString("JY", "TEST", tmp))
  158. {
  159. if(tmp[0] =='Y' || tmp[0] =='y')
  160. fTestJy =TRUE;
  161. else
  162. fTestJy =FALSE;
  163. }
  164. else fTestJy =FALSE;
  165.          
  166. if(GetInitString("JY", "RSA", tmp))
  167. {
  168. if(tmp[0] =='Y' || tmp[0] =='y')
  169. {
  170. fRsa =TRUE;
  171. if(!ReadRsaFile(R,PK,SK))
  172. ErrMsg(NULL,"读RSA加密参数失败，请在系统启动后按[Init]");
  173. }
  174. }
  176. ZqsCount=0;
  178. for(i=0;i<MAX_ZQS_COUNT;i++)
  179. {
  180. wsprintf(temp,"%s%d","COMMFILE",i);
  181. if(!GetInitString("JY", temp, tmp))
  182. {
  183. if(ZqsCount==0)
  184. {
  185. wsprintf(temp, "不能发现配置%s:n %s",
  186. (LPSTR)"COMMFILE", (LPSTR)tmp);
  187. ErrMsg(NULL, temp);
  188. }
  189. break;
  190. }
  191. else
  192. {
  193. ZqsCount++;
  194. prt=strstr(tmp,";");
  195. if(prt==NULL) 
  196. {
  197. ErrMsg(NULL,"format Reqfile;AnsFile");
  198. return -1;
  199. }
  200. else *prt=0;
  202. strcpy(temp1,tmp);
  203. if(access(temp1,0)!=0)
  204. {
  205. ReqFile.hf[i]=CreateFile(temp1,GENERIC_READ|GENERIC_WRITE,
  206. FILE_SHARE_READ|FILE_SHARE_WRITE,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
  207. if(ReqFile.hf[i] ==INVALID_HANDLE_VALUE)
  208. {
  209. ErrMsg(NULL, "can not create comm file!");
  210. return -1;
  211. }
  212. for(j=0;j<REQUESTLEN;j++)
  213. {
  214. if(WriteFile(ReqFile.hf[i],&ReqBuf,sizeof(REQUEST_BUFFER),&bytes,NULL))
  215. {
  216. if(bytes!=sizeof(REQUEST_BUFFER))
  217. {
  218. CloseHandle(ReqFile.hf[i]);
  219. return -1;
  220. }
  221. }
  222. else
  223. {
  224. CloseHandle(ReqFile.hf[i]);
  225. return -1;
  226. }
  227. }
  228. }
  229. else
  230. {
  231. if(access(temp1,_S_IREAD|_S_IWRITE) <0)
  232. {
  233. wsprintf(temp, "不能存取%s:n %s",
  234. (LPSTR)"COMMFILE", (LPSTR)temp1);
  235. ErrMsg(NULL, temp);
  236. return -1;
  237. }  
  238. ReqFile.hf[i]=CreateFile(temp1,GENERIC_READ|GENERIC_WRITE,
  239. FILE_SHARE_READ|FILE_SHARE_WRITE,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
  240. if(ReqFile.hf[i] ==INVALID_HANDLE_VALUE)
  241. {
  242. ErrMsg(NULL, "can not create comm file!");
  243. return -1;
  244. }
  245.                 }
  246. //ReqFile.hf[i]=OpenDbfBase(temp1,O_RDWR);
  248. // if(i==0)
  249. // CommFile.hf=ReqFile.hf[0];
  251. //if (ReqFile.hf[i]==-1)
  252. //{
  253. // wsprintf(temp, "不能打开%s:n %s",
  254. // (LPSTR)"COMMFILE", (LPSTR)temp1);
  255. // ErrMsg(NULL, temp);
  256. // return -1;
  257. //} 
  258. if(i==0)
  259. {
  260. // if (InitBase(CommFile.hf,&CommFile.dbfStruct,
  261. // &CommFile.fldStruct,&CommFile.fldCount)
  262. // !=SUCCEED) 
  263. // {
  264. // wsprintf(temp, "不能处始化%s:n %s",
  265. // (LPSTR)"COMMFILE", (LPSTR)temp1);
  266. // ErrMsg(NULL, temp);
  267. // return -1;
  268. // }
  269. rlen= sizeof(REQUEST_BUFFER);
  270. hlen= 0;
  271. }
  272. //ReqFile.recnum[i]= REQUESTLEN;
  274. strcpy(temp1,++prt);
  275. if(access(temp1,0)!=0)
  276. {
  277. AnsFile.hf[i]=CreateFile(temp1,GENERIC_READ|GENERIC_WRITE,
  278. FILE_SHARE_READ|FILE_SHARE_WRITE,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
  279. if(ReqFile.hf[i] ==INVALID_HANDLE_VALUE)
  280. {
  281. ErrMsg(NULL, "can not create comm ans file!");
  282. return -1;
  283. }
  284. for(j=0;j<ANSWERLEN;j++)
  285. {
  286. if(WriteFile(AnsFile.hf[i],&Answer,sizeof(ANSWER),&bytes,NULL))
  287. {
  288. if(bytes!=sizeof(ANSWER))
  289. {
  290. CloseHandle(ReqFile.hf[i]);
  291. CloseHandle(AnsFile.hf[i]);
  292. return -1;
  293. }
  294. }
  295. else
  296. {
  297. CloseHandle(AnsFile.hf[i]);
  298. return -1;
  299. }
  300. }
  301. }
  302. else
  303. {
  304. if(access(temp1,_S_IREAD|_S_IWRITE) <0)
  305. {
  306. wsprintf(temp, "不能存取%s:n %s",
  307. (LPSTR)"COMMFILE", (LPSTR)temp1);
  308. ErrMsg(NULL, temp);
  309. return -1;
  310. }  
  311. AnsFile.hf[i]=CreateFile(temp1,GENERIC_READ|GENERIC_WRITE,
  312. FILE_SHARE_READ|FILE_SHARE_WRITE,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
  313. if(AnsFile.hf[i] ==INVALID_HANDLE_VALUE)
  314. {
  315. ErrMsg(NULL, "can not create comm ans file!");
  316. return -1;
  317. }
  318.                 }
  319. //AnsFile.hf[i]=OpenDbfBase(temp1,O_RDWR);
  320. //if (ReqFile.hf[i]==-1)
  321. //{
  322. // wsprintf(temp, "不能打开%s:n %s",
  323. // (LPSTR)"COMMFILE", (LPSTR)temp1);
  324. // ErrMsg(NULL, temp);
  325. // return -1;
  326. //} 
  328. prt =strrchr(temp1,'\');
  329. ++prt; *prt =0;
  330. strcpy(&AnsFile.path[i][0],temp1);
  332. AnsFile.recnum[i]=ANSWERLEN;
  333. ReqFile.recnum[i]=REQUESTLEN;
  334. }
  335. }
  336. return 0;
  337. }
  339. int JyExit(void)
  340. {
  341. int i;
  343. for(i=0;i<ZqsCount;i++)
  344. {
  345. if(ReqFile.hf[i]!=INVALID_HANDLE_VALUE)
  346. CloseHandle(ReqFile.hf[i]);
  347. if(AnsFile.hf[i]!=INVALID_HANDLE_VALUE)
  348. CloseHandle(AnsFile.hf[i]);
  349. }
  350. return 0;
  351. }
  353. int Jy_Zqsxx(int sd)
  354. {
  355. int len;
  357. BYTE SendBuff[1024];
  359. strcpy(SendBuff, JY_ZQSXX_HEAD);
  360. len =strlen(JY_ZQSXX_HEAD);
  361. //memcpy(&SendBuff[len],&Zqsxx,sizeof(ZQSXX));
  362. //len+=sizeof(Zqsxx);
  364. memcpy(&SendBuff[len],R,DATALENGTH);
  365. len +=DATALENGTH;
  366. memcpy(&SendBuff[len],PK,DATALENGTH);
  367. len +=DATALENGTH;
  368. UDP_SendBuff("RSA.R.PK", sd, SendBuff, len,NULL);
  369. return 0;
  370. }
  372. void ClearAns(LPJY_DEST lpJyDest)
  373. {
  374. char* buff;
  376. buff =GlobalAllocPtr(GHND,rlen);
  377. if(buff !=NULL)
  378. {
  379. memset(buff,0,rlen);
  380. WriteRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,rlen,buff);
  381. GlobalFreePtr(buff);
  382. }
  383. }
  386. void ClearReq(LPJY_DEST lpJyDest)
  387. {
  388. char* buff;
  390. buff =GlobalAllocPtr(GHND,rlen);
  391. if(buff !=NULL)
  392. {
  393. memset(buff,0,rlen);
  394. buff[0] =0;
  395. WriteRecord(ReqFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,rlen,buff);
  396. GlobalFreePtr(buff);
  397. }
  398. }
  400. int Jy_ChkUsr(int sd, int jyNum, LPJY_ASK_CHKUSR AskChkUser)
  401. {
  402. int ret;
  403. LPJY_DEST lpJyDest;
  404. short Qsid;
  405. REQUEST_BUFFER ReqBuf;
  406. ANSWER Answer;
  408. if(ZqsCount ==1)
  409. Qsid =1;
  410. else
  411. Qsid =AskChkUser->zqsid;
  413. if(ReqFile.hf[Qsid -1] ==INVALID_HANDLE_VALUE)
  414. return ANS_SYS_ERR;
  416. ret =CheckJyDest(sd,REQ_CHKUSR, AskChkUser->jys,
  417. AskChkUser->gddm, -1, &lpJyDest);
  419. memset(&ReqBuf,0,rlen);
  420. memset(&Answer,0,sizeof(ANSWER));
  422. ReqBuf.command =3;
  423. ReqBuf.status ='01';
  424. strcpy(ReqBuf.request.r_inq_account.argment,AskChkUser->gddm);
  425. ReqBuf.request.r_inq_account.arg_type ='2';
  426. ReqBuf.request.r_inq_account.password =atoi(AskChkUser->jymm);
  428. //StringToFld(CommBuffer,CommFile.fldStruct[fld_GDDM],AskChkUser->gddm);
  429. //CommBuffer[*(short*)(CommFile.fldStruct[fld_STKNO].offset)]
  430. // =(AskChkUser->jys ==0)?'Z':'H';
  431. //StringToFld(CommBuffer,CommFile.fldStruct[fld_JYMM],AskChkUser->jymm);      
  432. //CommBuffer[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]=REQ_CHKUSR;
  433. //CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  435. //wsprintf(temp,"%d",sd);
  436. //StringToFld(CommBuffer,CommFile.fldStruct[fld_ADDR],temp);
  437. //wsprintf(temp,"%d",jyNum);
  438. //StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);
  440. if(lpJyDest==NULL)
  441. lpJyDest=GetFirstIdelRec();
  442. if(lpJyDest==NULL)
  443. {
  444. ReqFile.currec[Qsid-1]++;
  445. if(ReqFile.currec[Qsid-1]>ReqFile.recnum[Qsid-1])
  446. {
  447. ErrMsg(NULL, "无空闲交易表项!");      
  448. return ANS_SYS_ERR;
  449. }
  450. lpJyDest=AddJyDest(sd, REQ_CHKUSR, AskChkUser->jys,
  451. ReqFile.currec[Qsid-1], AskChkUser->gddm, jyNum,Qsid-1);
  453. if(lpJyDest ==NULL)
  454. {
  455. ErrMsg(NULL, "不能加交易表项!");
  456. return ANS_SYS_ERR;
  457. }
  458. //ClearAns(lpJyDest);
  459. if(WriteRecord(ReqFile.hf[Qsid-1],lpJyDest->recNum,
  460. hlen,rlen,(char *)&ReqBuf) !=0)
  461. {
  462. ErrMsg(NULL, "不能写交换文件!");      
  463. return ANS_SYS_ERR;
  464. }
  465. }
  466. else
  467. {
  468. //ClearAns(lpJyDest);
  469. if(WriteRecord(ReqFile.hf[Qsid-1],lpJyDest->recNum,
  470. hlen,rlen,(char *)&ReqBuf)!=0)
  471. {
  472. ErrMsg(NULL, "不能写交换文件1!");      
  473. return ANS_SYS_ERR;
  474. }
  475. strcpy(lpJyDest->gddm,AskChkUser->gddm);
  476. ChangeJyDest(sd, lpJyDest, REQ_CHKUSR, AskChkUser->jys,
  477. Qsid -1,jyNum);
  478. }
  480. strcpy(lpJyDest->jymm,AskChkUser->jymm);
  482. if(fTestJy)
  483. {
  484. Sleep(1000);
  485. //CommBuffer[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]=REQ_NULL;
  486. //CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)]=ANS_SUCC;
  487. //CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  488. //wsprintf(temp,"%d",jyNum);
  489. //StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);
  490. strcpy(Answer.a_inq_account.status,"000");
  491. Answer.a_inq_account.fund_account=atoi(AskChkUser->gddm);
  492. WriteRecord(AnsFile.hf[Qsid-1],lpJyDest->recNum,
  493. 0,sizeof(ANSWER),(char *)&Answer);
  494. }
  495. return 0;
  496. }
  498. int Jy_ChgPwd(int sd, int jyNum, LPJY_ASK_CHGPWD AskChgPwd)
  499. {
  500. LPJY_DEST lpJyDest=NULL;
  501. int ret;
  502. REQUEST_BUFFER ReqBuf;
  503. ANSWER Answer;
  505. ret =CheckJyDest(sd, REQ_CHGPWD, AskChgPwd->jys, AskChgPwd->gddm,
  506. AskChgPwd->userId, &lpJyDest);
  508. if(ret==-1)
  509. return ANS_SYS_ERR;
  510. if(ret==-2)
  511. return ANS_SUSP_REQ;
  512. if(ret==-3)
  513. return ANS_NO_PRIV;
  515. if(ReqFile.hf[lpJyDest->zqsid] ==INVALID_HANDLE_VALUE)
  516. return ANS_SYS_ERR;
  518. memset(&ReqBuf,0,rlen);
  519. memset(&Answer,0,sizeof(ANSWER));
  521. ReqBuf.command =2;
  522. ReqBuf.status ='01';
  524. ReqBuf.request.r_chg_password.fund_account 
  525. =lpJyDest->jyzh;
  527. ReqBuf.request.r_chg_password.password =atoi(lpJyDest->jymm);
  528. ReqBuf.request.r_chg_password.password_new =atoi(AskChgPwd->xmm);
  530. //memset(CommBuffer,' ',*(short *)CommFile.dbfStruct.rlen);
  531. //StringToFld(CommBuffer,CommFile.fldStruct[fld_GDDM],AskChgPwd->gddm);
  532. //CommBuffer[*(short*)(CommFile.fldStruct[fld_STKNO].offset)]
  533. // =(AskChgPwd->jys ==0)?'Z':'H';
  534. //StringToFld(CommBuffer,CommFile.fldStruct[fld_JYMM],AskChgPwd->xmm);      
  535. //CommBuffer[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]=REQ_CHGPWD;
  536. //CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  538. //wsprintf(temp,"%d",sd);
  539. //StringToFld(CommBuffer,CommFile.fldStruct[fld_ADDR],temp);
  540. //wsprintf(temp,"%d",jyNum);
  541. //StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);
  543. if(WriteRecord(ReqFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,rlen,(char *)&ReqBuf)!=0)
  544. {
  545. ErrMsg(NULL, "不能写交换文件!");
  546. return ANS_SYS_ERR;
  547. }
  548. ChangeJyDest(sd, lpJyDest, REQ_CHGPWD, AskChgPwd->jys, -1, jyNum);
  550. if(fTestJy)
  551. {
  552. Sleep(1000);
  553. //CommBuffer[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]=REQ_NULL;
  554. //CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)]=ANS_SUCC;
  555. //CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  556. //wsprintf(temp,"%d",jyNum);
  557. //StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);
  559. WriteRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,
  560. 0,sizeof(ANSWER),(char *)&Answer);
  561. }
  562. return 0;
  563. }
  565. int Jy_BuySell(int sd, int jyNum, LPJY_ASK_BUYSELL AskBuySell)
  566. {
  567. LPJY_DEST lpJyDest;
  568. int ret;
  570. REQUEST_BUFFER ReqBuf;
  571. ANSWER Answer;
  573. ret =CheckJyDest(sd, REQ_BUYSEL, AskBuySell->jys, AskBuySell->gddm,
  574. AskBuySell->userId, &lpJyDest);
  576. if(ret==-1)
  577. return ANS_SYS_ERR;
  578. if(ret==-2)
  579. return ANS_SUSP_REQ;
  580. if(ret==-3)
  581. return ANS_NO_PRIV;
  583. if(ReqFile.hf[lpJyDest->zqsid] ==INVALID_HANDLE_VALUE)
  584. return ANS_SYS_ERR;
  586. memset(&ReqBuf,0,rlen);
  587. ReqBuf.command =5;
  588. ReqBuf.status ='01';
  589. ReqBuf.request.r_ent_enter.exchange_type =
  590. (AskBuySell->jys ==0)?'2':'1';
  592. if(AskBuySell->jys ==0)
  593. strcpy(ReqBuf.request.r_ent_enter.stock_account,
  594. AskBuySell->gddm);
  595. else
  596. sprintf(ReqBuf.request.r_ent_enter.stock_account,
  597. "A%s",AskBuySell->gddm);
  599. ReqBuf.request.r_ent_enter.password =
  600. atol(lpJyDest->jymm);
  601. ReqBuf.request.r_ent_enter.entrust_bs =
  602. (AskBuySell->bs =='B')?'1':'2';
  603. strcpy(ReqBuf.request.r_ent_enter.stock_code,
  604. AskBuySell->gpdm);
  605. ReqBuf.request.r_ent_enter.entrust_price=
  606. (float)AskBuySell->wtjg/(float)100.00;
  607. ReqBuf.request.r_ent_enter.entrust_amount=
  608. AskBuySell->wtgs;
  609. ReqBuf.request.r_ent_enter.entrust_type='0';
  611. //memset(CommBuffer,' ',*(short *)CommFile.dbfStruct.rlen);
  612. //StringToFld(CommBuffer,CommFile.fldStruct[fld_GDDM],AskBuySell->gddm);
  613. //CommBuffer[*(short*)(CommFile.fldStruct[fld_STKNO].offset)]
  614. // =(AskBuySell->jys ==0)?'Z':'H';                         
  615. //StringToFld(CommBuffer,CommFile.fldStruct[fld_GPDM],AskBuySell->gpdm);
  616. //sprintf(temp,"%12ld",AskBuySell->wtgs);
  617. //StringToFld(CommBuffer,CommFile.fldStruct[fld_WTGS],temp);            
  618. //sprintf(temp,"%12.2f",(double)(AskBuySell->wtjg/100.00));
  619. //StringToFld(CommBuffer,CommFile.fldStruct[fld_WTJG],temp);      
  620. //if(AskBuySell->bs =='B')
  621. // CommBuffer[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]=REQ_BUY;
  622. //else if(AskBuySell->bs =='S')
  623. // CommBuffer[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]=REQ_SELL;
  624. //else
  625. // CommBuffer[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]='E';
  627. //CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  628.   //wsprintf(temp,"%d",sd);
  629. //StringToFld(CommBuffer,CommFile.fldStruct[fld_ADDR],temp);
  630. //wsprintf(temp,"%d",jyNum);
  631. //StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);
  632. //ClearAns(lpJyDest);
  634. if(WriteRecord(ReqFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,rlen,(char *)&ReqBuf)!=0)
  635. {
  636. ErrMsg(NULL, "不能写交换文件!");      
  637. return ANS_SYS_ERR;
  638. }
  639. if(ChangeJyDest(sd, lpJyDest, REQ_BUYSEL, AskBuySell->jys, -1, jyNum)<0)
  640. return ANS_SYS_ERR;
  642. if(fTestJy)
  643. {
  644. Sleep(1000);
  645. //CommBuffer[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]=REQ_NULL;
  646. //CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)]=ANS_SUCC;
  647. //CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  648. //StringToFld(CommBuffer,CommFile.fldStruct[fld_HTHM],"000068");
  649. //wsprintf(temp,"%d",jyNum);
  650. //StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);
  651.     WriteRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,
  652. 0,sizeof(ANSWER),(char *)&Answer);
  653. }
  655. return 0;
  656. }
  658. int Jy_Cancel(int sd, int jyNum, LPJY_ASK_CANCEL AskCancel)
  659. {
  660. LPJY_DEST lpJyDest;
  661. int ret;
  663. REQUEST_BUFFER ReqBuf;
  664. ANSWER Answer;
  666. ret =CheckJyDest(sd, REQ_CANCEL, AskCancel->jys, 
  667. AskCancel->gddm, AskCancel->userId, &lpJyDest);
  668. if(ret==-1)
  669. return ANS_SYS_ERR;
  670. if(ret==-2)
  671. return ANS_SUSP_REQ;
  672. if(ret==-3)
  673. return ANS_NO_PRIV;
  675. if(ReqFile.hf[lpJyDest->zqsid] ==INVALID_HANDLE_VALUE)
  676. return ANS_SYS_ERR;
  678. memset(&ReqBuf,0,rlen);
  679. memset(&Answer,0,sizeof(ANSWER));
  680. ReqBuf.command =6;
  681. ReqBuf.status ='01';
  683. ReqBuf.request.r_ent_cancel.fund_account=
  684. lpJyDest->jyzh;
  686. ReqBuf.request.r_ent_cancel.password =
  687. atoi(lpJyDest->jymm);
  688. ReqBuf.request.r_ent_cancel.entrust_serial_no =
  689. atoi(AskCancel->Cancel[0].hthm);
  690. /*
  691. for(i=0;i<AskCancel->cancelCount;i++)
  692. {
  693. memset(CommBuffer,' ',*(short *)CommFile.dbfStruct.rlen);
  694. StringToFld(CommBuffer,CommFile.fldStruct[fld_GDDM],AskCancel->gddm);
  695. StringToFld(CommBuffer,CommFile.fldStruct[fld_HTHM],AskCancel->Cancel[i].hthm);          
  696. CommBuffer[*(short*)(CommFile.fldStruct[fld_STKNO].offset)]
  697. =(AskCancel->jys ==0)?'Z':'H';                      
  698. CommBuffer[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]=REQ_CANCEL;
  699. CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  700.   wsprintf(temp,"%d",sd);
  701. StringToFld(CommBuffer,CommFile.fldStruct[fld_ADDR],temp);
  702. wsprintf(temp,"%d",jyNum);
  703. StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);
  705. ClearAns(lpJyDest);
  706. if(WriteRecord(ReqFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,rlen,
  707. CommBuffer)!=0)
  708. {
  709. ErrMsg(NULL, "不能写交换文件!");      
  710. return ANS_SYS_ERR;
  711. }
  712. }
  713. */
  715. if(WriteRecord(ReqFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,rlen,
  716. (char *)&ReqBuf)!=0)
  717. {
  718. ErrMsg(NULL, "不能写交换文件!");      
  719. return ANS_SYS_ERR;
  720. }
  722. ChangeJyDest(sd, lpJyDest, REQ_CANCEL, AskCancel->jys, -1, jyNum);
  723. lpJyDest->recCount =1; //;AskCancel->cancelCount;
  725. if(fTestJy)
  726. {
  727. Sleep(1000);
  728. /*
  729. CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)]=ANS_SUCC;
  730. CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  731. wsprintf(temp,"%d",AskCancel->cancelCount);
  732. StringToFld(CommBuffer,CommFile.fldStruct[fld_JYMM],temp);
  734. wsprintf(temp,"%d",jyNum);
  735. StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);
  737.     WriteRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,rlen,
  738. CommBuffer);
  740. wsprintf(temp,"%s%d%s",AnsFile.path[lpJyDest->zqsid],lpJyDest->recNum,".ANS");
  741. hFile =OpenFile(temp, &os, OF_CREATE|OF_SHARE_DENY_NONE|OF_WRITE);
  742. if(hFile ==HFILE_ERROR)
  743. return ANS_SYS_ERR;
  745. for(i=0;i<AskCancel->cancelCount;i++)
  746. {
  747. memset(CommBuffer,' ',*(short *)CommFile.dbfStruct.rlen);
  748. StringToFld(CommBuffer,CommFile.fldStruct[fld_GDDM],AskCancel->gddm);
  749. StringToFld(CommBuffer,CommFile.fldStruct[fld_HTHM],AskCancel->Cancel[i].hthm);          
  750. CommBuffer[*(short*)(CommFile.fldStruct[fld_STKNO].offset)]
  751. =(AskCancel->jys ==0)?'Z':'H';                      
  752. CommBuffer[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]=REQ_CANCEL;
  754. CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)]=ANS_SUCC;
  755. CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  757.   wsprintf(temp,"%d",sd);
  758. StringToFld(CommBuffer,CommFile.fldStruct[fld_ADDR],temp);
  759. wsprintf(temp,"%d",jyNum);
  760. StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);
  761. _lwrite(hFile,&CommBuffer[1], rlen-1);
  762. _lwrite(hFile,"rn",2);
  763. }
  764. _lclose(hFile);
  765. */
  766. WriteRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,
  767. 0,sizeof(ANSWER),(char *)&Answer);
  768. }
  770. return 0;
  771. }
  773. int Jy_Yecx(int sd, int jyNum, LPJY_ASK_YECX AskYecx)
  774. {
  775. LPJY_DEST lpJyDest;
  776. int ret,i=0;
  778. REQUEST_BUFFER ReqBuf;
  779. ANSWER Answer;
  781. ret =CheckJyDest(sd, REQ_YECX, AskYecx->jys, AskYecx->gddm,
  782. AskYecx->userId, &lpJyDest);
  783. if(ret==-1)
  784. return ANS_SYS_ERR;
  785. if(ret==-2)
  786. return ANS_SUSP_REQ;
  787. if(ret==-3)
  788. return ANS_NO_PRIV;
  790. if(ReqFile.hf[lpJyDest->zqsid] ==INVALID_HANDLE_VALUE)
  791. return ANS_SYS_ERR;
  793. memset(&ReqBuf,0,rlen);
  794. memset(&Answer,0,sizeof(ANSWER));
  795. ReqBuf.command =10;
  796. ReqBuf.status ='01';
  797. ReqBuf.request.r_inq_stock.arg_type ='3';
  799. if(AskYecx->jys ==0)
  800. strcpy(ReqBuf.request.r_inq_stock.stock_account,
  801. AskYecx->gddm);
  802. else
  803. sprintf(ReqBuf.request.r_inq_stock.stock_account,
  804. "A%s",AskYecx->gddm);
  806. strcpy(ReqBuf.request.r_inq_stock.stock_code,"");
  807. ReqBuf.request.r_inq_stock.exchange_type =
  808. (AskYecx->jys ==0)?'2':'1';
  810. ReqBuf.request.r_inq_stock.inquire_mode = '1';
  812. //memset(CommBuffer,' ',*(short *)CommFile.dbfStruct.rlen);
  813. //StringToFld(CommBuffer,CommFile.fldStruct[fld_GDDM],AskYecx->gddm);
  814. //CommBuffer[*(short*)(CommFile.fldStruct[fld_STKNO].offset)]
  815. // =(AskYecx->jys ==0)?'Z':'H';                        
  816. //StringToFld(CommBuffer,CommFile.fldStruct[fld_GPDM],AskYecx->gpdm);      
  817. //CommBuffer[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]=REQ_YECX;
  818. //CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  819.   //wsprintf(temp,"%d",sd);
  820. //StringToFld(CommBuffer,CommFile.fldStruct[fld_ADDR],temp);
  821. //wsprintf(temp,"%d",jyNum);
  822. //StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);
  824. //ClearAns(lpJyDest);
  825.     //wsprintf(temp,"%s%d%s",AnsFile.path[lpJyDest->zqsid],lpJyDest->recNum,".ANS");
  826.     //remove(temp);
  828. if(WriteRecord(ReqFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,rlen,
  829. (char *)&ReqBuf)!=0)
  830. {
  831. ErrMsg(NULL, "不能写交换文件!");
  832. return ANS_SYS_ERR;
  833. }
  834. if(ChangeJyDest(sd, lpJyDest, REQ_YECX, AskYecx->jys, -1, jyNum) <0)
  835. return ANS_SYS_ERR;
  837. if(fTestJy)
  838. {
  839. Sleep(1000);
  840. /*
  841. wsprintf(temp,"%s%d%s",AnsFile.path[lpJyDest->zqsid],lpJyDest->recNum,".ANS");
  842. hFile =OpenFile(temp, &os, OF_CREATE|OF_SHARE_DENY_NONE|OF_WRITE);
  843. if(hFile ==HFILE_ERROR)
  844. return 0;
  846. for(i=0;i<22;i++)
  847. {
  848. memset(CommBuffer,0,sizeof(CommBuffer));
  849. wsprintf(temp,"%04d",i+1);
  850. StringToFld(CommBuffer,CommFile.fldStruct[fld_GPDM],temp);      
  852. wsprintf(temp,"%8d",(i+1)*10);
  853. StringToFld(CommBuffer,CommFile.fldStruct[fld_WTGS],temp);      
  855. wsprintf(temp,"%8d",(i+1)*20);
  856. StringToFld(CommBuffer,CommFile.fldStruct[fld_WTJG],temp);      
  858. StringToFld(CommBuffer,CommFile.fldStruct[fld_DATE],"111111");      
  859. CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  860. _lwrite(hFile,&CommBuffer[1], rlen-1);
  861. _lwrite(hFile,"rn",2);
  862. }
  863. _lclose(hFile);
  865. CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)]=ANS_SUCC;
  866. CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  867. StringToFld(CommBuffer,CommFile.fldStruct[fld_JYMM],"22");
  869. StringToFld(CommBuffer,CommFile.fldStruct[fld_WTGS],"9000000.12");
  870. StringToFld(CommBuffer,CommFile.fldStruct[fld_WTJG],"2000000.99");
  871. wsprintf(temp,"%d",jyNum);
  872. StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);
  873. */
  874.     WriteRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,
  875. 0,sizeof(ANSWER),(char *)&Answer);
  876. }
  878. return 0;
  879. }
  881. int Jy_Cjcx(int sd, int jyNum, LPJY_ASK_CJCX AskCjcx)
  882. {
  883. LPJY_DEST lpJyDest;
  884. int ret,i=0;
  886. REQUEST_BUFFER ReqBuf;
  887. ANSWER Answer;
  889. ret =CheckJyDest(sd, REQ_CJCX, AskCjcx->jys, AskCjcx->gddm, AskCjcx->userId, &lpJyDest);
  891. if(ret==-1)
  892. return ANS_SYS_ERR;
  893. if(ret==-2)
  894. return ANS_SUSP_REQ;
  895. if(ret==-3)
  896. return ANS_NO_PRIV;
  898. if(ReqFile.hf[lpJyDest->zqsid] ==INVALID_HANDLE_VALUE)
  899. return ANS_SYS_ERR;
  901. memset(&ReqBuf,0,rlen);
  902. memset(&Answer,0,sizeof(ANSWER));
  903. ReqBuf.command =9;
  904. ReqBuf.status ='01';
  905. ReqBuf.request.r_inq_real.arg_type ='3';
  907. if(AskCjcx->jys ==0)
  908. strcpy(ReqBuf.request.r_inq_real.stock_account,
  909. AskCjcx->gddm);
  910. else
  911. sprintf(ReqBuf.request.r_inq_real.stock_account,
  912. "A%s",AskCjcx->gddm);
  914. ReqBuf.request.r_inq_real.exchange_type =
  915. (AskCjcx->jys ==0)?'2':'1';
  917. //memset(CommBuffer,' ',*(short *)CommFile.dbfStruct.rlen);
  918. //StringToFld(CommBuffer,CommFile.fldStruct[fld_GDDM],AskCjcx->gddm);
  919. //CommBuffer[*(short*)(CommFile.fldStruct[fld_STKNO].offset)]
  920. // =(AskCjcx->jys ==0)?'Z':'H';                        
  921. //StringToFld(CommBuffer,CommFile.fldStruct[fld_DATE],AskCjcx->cjrq);      
  922. //StringToFld(CommBuffer,CommFile.fldStruct[fld_HTHM],AskCjcx->hthm);      
  923. //CommBuffer[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]=REQ_CJCX;
  924. //CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  925.   //wsprintf(temp,"%d",sd);
  926. //StringToFld(CommBuffer,CommFile.fldStruct[fld_ADDR],temp);
  927. //wsprintf(temp,"%d",jyNum);
  928. //StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);
  929. //ClearAns(lpJyDest);
  930.     //wsprintf(temp,"%s%d%s",AnsFile.path[lpJyDest->zqsid],lpJyDest->recNum,".ANS");
  931.     //remove(temp);
  933. if(WriteRecord(ReqFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,rlen,
  934. (char *)&ReqBuf)!=0)
  935. {
  936. ErrMsg(NULL, "不能写交换文件!");
  937. return ANS_SYS_ERR;
  938. }
  939. if(ChangeJyDest(sd, lpJyDest, REQ_CJCX, AskCjcx->jys, -1, jyNum) <0)
  940. {
  941. ErrMsg(NULL,"来自Jy_Cjcx:ChangeJyDest");
  942. return ANS_SYS_ERR;
  943. }
  944. if(fTestJy)
  945. {
  946. Sleep(1000);
  947. /*
  948. CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)]=ANS_SUCC;
  949. CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  950. StringToFld(CommBuffer,CommFile.fldStruct[fld_JYMM],"22");
  951. wsprintf(temp,"%d",jyNum);
  952. StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);
  954.     WriteRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,rlen,
  955. CommBuffer);
  957. wsprintf(temp,"%s%d%s",AnsFile.path[lpJyDest->zqsid],lpJyDest->recNum,".ANS");
  958. hFile =OpenFile(temp, &os, OF_CREATE|OF_SHARE_DENY_NONE|OF_WRITE);
  959. if(hFile ==HFILE_ERROR)
  960. return ANS_SYS_ERR;
  962. for(i=0;i<22;i++)
  963. {
  964. CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)]=i-(int)(i/2)*2==0 ?'B':'S';
  965. wsprintf(temp,"%04d",i+1);
  966. StringToFld(CommBuffer,CommFile.fldStruct[fld_GPDM],temp);      
  968. wsprintf(temp,"%8d",(i+1)*100);
  969. StringToFld(CommBuffer,CommFile.fldStruct[fld_WTGS],temp);      
  971. wsprintf(temp,"%8d",i+10);
  972. StringToFld(CommBuffer,CommFile.fldStruct[fld_WTJG],temp);      
  974. wsprintf(temp,"%06d",i+100);
  975. StringToFld(CommBuffer,CommFile.fldStruct[fld_HTHM],temp);      
  977. StringToFld(CommBuffer,CommFile.fldStruct[fld_DATE],"111111");      
  978. CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  980. _lwrite(hFile,&CommBuffer[1], rlen-1);
  981. _lwrite(hFile,"rn",2);
  982. }
  983. _lclose(hFile);
  984. */
  985.     WriteRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,
  986. 0,sizeof(ANSWER),(char *)&Answer);
  987. }
  988. return 0;
  989. }
  991. int Jy_Wtcx(int sd, int jyNum, LPJY_ASK_WTCX AskWtcx)
  992. {
  993. LPJY_DEST lpJyDest;
  994. int ret,i=0;
  996. REQUEST_BUFFER ReqBuf;
  997. ANSWER Answer;
  999. ret =CheckJyDest(sd, REQ_WTCX, AskWtcx->jys, AskWtcx->gddm,
  1000. AskWtcx->userId, &lpJyDest);
  1001. if(ret==-1)
  1002. return ANS_SYS_ERR;
  1003. if(ret==-2)
  1004. return ANS_SUSP_REQ;
  1005. if(ret==-3)
  1006. return ANS_NO_PRIV;
  1008. if(ReqFile.hf[lpJyDest->zqsid] ==INVALID_HANDLE_VALUE)
  1009. return ANS_SYS_ERR;
  1011. memset(&ReqBuf,0,rlen);
  1012. memset(&Answer,0,sizeof(ANSWER));
  1013. ReqBuf.command =8;
  1014. ReqBuf.status ='01';
  1015. ReqBuf.request.r_inq_entrust.arg_type ='3';
  1017. if(AskWtcx->jys ==0)
  1018. strcpy(ReqBuf.request.r_inq_entrust.stock_account,
  1019. AskWtcx->gddm);
  1020. else
  1021. sprintf(ReqBuf.request.r_inq_entrust.stock_account,
  1022. "A%s",AskWtcx->gddm);
  1024. ReqBuf.request.r_inq_real.exchange_type =
  1025. (AskWtcx->jys ==0)?'2':'1';
  1027. ReqBuf.request.r_inq_entrust.inquire_mode ='1';
  1029. // memset(CommBuffer,' ',*(short *)CommFile.dbfStruct.rlen);
  1030. // StringToFld(CommBuffer,CommFile.fldStruct[fld_GDDM],AskWtcx->gddm);
  1031. // CommBuffer[*(short*)(CommFile.fldStruct[fld_STKNO].offset)]
  1032. // =(AskWtcx->jys ==0)?'Z':'H';                        
  1033. // StringToFld(CommBuffer,CommFile.fldStruct[fld_DATE],AskWtcx->wtrq);      
  1034. // StringToFld(CommBuffer,CommFile.fldStruct[fld_HTHM],AskWtcx->hthm);      
  1035. // CommBuffer[*(short*)(CommFile.fldStruct[fld_ASKNO].offset)]=REQ_WTCX;
  1036. // CommBuffer[*(short*)(CommFile.fldStruct[fld_JYMM].offset)]=AskWtcx->cdcx;
  1037. // CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  1038. // wsprintf(temp,"%d",sd);
  1039. // StringToFld(CommBuffer,CommFile.fldStruct[fld_ADDR],temp);
  1040. // wsprintf(temp,"%d",jyNum);
  1041. // StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);
  1043. // ClearAns(lpJyDest);
  1044. //    wsprintf(temp,"%s%d%s",AnsFile.path[lpJyDest->zqsid],lpJyDest->recNum,".ANS");
  1045. //    remove(temp);
  1046. if(WriteRecord(ReqFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,rlen,
  1047. (char *)&ReqBuf)!=0)
  1048. {
  1049. ErrMsg(NULL, "不能写交换文件!");
  1050. return ANS_SYS_ERR;
  1051. }
  1053. if(ChangeJyDest(sd, lpJyDest, REQ_WTCX, AskWtcx->jys, -1, jyNum) <0)
  1054. return ANS_SYS_ERR;
  1056. if(fTestJy)
  1057. {
  1058. Sleep(1000);
  1059. /*
  1060. CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)]=ANS_SUCC;
  1061. CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  1062. StringToFld(CommBuffer,CommFile.fldStruct[fld_JYMM],"22");
  1063. wsprintf(temp,"%d",jyNum);
  1064. StringToFld(CommBuffer,CommFile.fldStruct[fld_SERI],temp);
  1066.     WriteRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,
  1067. rlen,CommBuffer);
  1069. wsprintf(temp,"%s%d%s",AnsFile.path[lpJyDest->zqsid],lpJyDest->recNum,".ANS");
  1070. hFile =OpenFile(temp, &os, OF_CREATE|OF_SHARE_DENY_NONE|OF_WRITE);
  1071. if(hFile ==HFILE_ERROR)
  1072. return ANS_SYS_ERR;
  1073. for(i=0;i<22;i++)
  1074. {
  1075. CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)]=i-(int)(i/2)*2==0 ?'B':'S';
  1076. wsprintf(temp,"%04d",i+1);
  1077. StringToFld(CommBuffer,CommFile.fldStruct[fld_GPDM],temp);      
  1079. wsprintf(temp,"%8d",(i+1)*100);
  1080. StringToFld(CommBuffer,CommFile.fldStruct[fld_WTGS],temp);
  1082. wsprintf(temp,"%8d",i+10);
  1083. StringToFld(CommBuffer,CommFile.fldStruct[fld_WTJG],temp);      
  1085. wsprintf(temp,"%06d",i+100);
  1086. StringToFld(CommBuffer,CommFile.fldStruct[fld_HTHM],temp);      
  1088. StringToFld(CommBuffer,CommFile.fldStruct[fld_DATE],"111111");      
  1089. CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)]=';';
  1091. _lwrite(hFile,&CommBuffer[1], rlen-1);
  1092. _lwrite(hFile,"rn",2);
  1093. }
  1094. _lclose(hFile);
  1095. */
  1096.     WriteRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,
  1097. 0,sizeof(ANSWER),(char *)&Answer);
  1098. }
  1100. return 0;
  1101. }
  1103. int JyDest_ChkUsr(LPJY_DEST lpJyDest)
  1104. {
  1105. BYTE SendBuff[2048];
  1106. int ret, len;
  1107.     JY_ANS_CHKUSR AnsUser;
  1109. //ReadRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,
  1110. // rlen,CommBuffer);
  1111. //stat=CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)];
  1112. //if(stat !=';') 
  1113. // return 0;
  1115. REQUEST_BUFFER ReqBuf;
  1116. ANSWER Answer;
  1118. memset(&ReqBuf,0,rlen);
  1119. memset(&Answer,0,sizeof(ANSWER));
  1121. ReadRecord(ReqFile.hf[lpJyDest->zqsid],lpJyDest->recNum,
  1122. hlen,rlen,(char *)&ReqBuf);
  1123. if(ReqBuf.status !='02')
  1124. return 0;
  1125. if(ReadRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,
  1126. 0,sizeof(ANSWER),(char *)&Answer)!=0)
  1127. ret =-1;
  1128. else
  1129. {
  1130. //if(strncmp(Answer.a_inq_account.status,"000",3) ==0)
  1131. ret =ReqBuf.error;
  1132. if(ret>=0)
  1133. {
  1134. //ret =0;
  1135. lpJyDest->jyzh =Answer.a_inq_account.fund_account;
  1136. lpJyDest->zjye =Answer.a_inq_account.current_balance;
  1137. lpJyDest->kyje =Answer.a_inq_account.enable_balance;
  1138. }
  1139. }
  1141. //FldToString(CommBuffer,&CommFile.fldStruct[fld_SERI],temp);
  1142. //if(lpJyDest->jyNum!=atoi(temp)) 
  1143. // return 0;
  1145. //ret=CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)];
  1146. //if(ret==' ')
  1147. // return 0;
  1149. if(ret<0)
  1150. {
  1151. //ret =ANS_SYS_ERR;
  1152. switch(ret)
  1153. {
  1154. case -51:
  1155. ret ='1';
  1156. break;
  1157. case -52:
  1158. ret ='6';
  1159. break;
  1160. default:
  1161. ret ='1';
  1162. }
  1163. }
  1164. else ret =ANS_SUCC;
  1166. strcpy(SendBuff, JY_CHKUSR_HEAD);
  1167. len =strlen(SendBuff);
  1168. *(short *)&SendBuff[len] =lpJyDest->jyNum;
  1169. len +=sizeof(short);
  1171. AnsUser.jys=lpJyDest->curJys;
  1172.     AnsUser.userId=lpJyDest->userId;
  1173. strcpy(AnsUser.gddm,lpJyDest->gddm);
  1174. AnsUser.flag=(char)ret;
  1175. memcpy(&SendBuff[len],&AnsUser,sizeof(JY_ANS_CHKUSR));
  1176. len+=sizeof(AnsUser);
  1177. UDP_SendBuff("检查交易用户", lpJyDest->sd, SendBuff, len,NULL);  
  1178. lpJyDest->isReqEnd =TRUE;
  1180. //ClearReq(lpJyDest);
  1181. return 0;
  1182. }
  1183.        
  1184. int JyDest_ChgPwd(LPJY_DEST lpJyDest)
  1185. {
  1186. BYTE SendBuff[100];
  1187. int ret,len;
  1188. JY_ANS_CHGPWD AnsChgPwd;
  1190. // ReadRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,hlen,
  1191. // rlen,CommBuffer);
  1192. // stat=CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)];                     
  1193. // if(stat !=';') 
  1194. // return 0;
  1196. // FldToString(CommBuffer,&CommFile.fldStruct[fld_SERI],temp);
  1197. // if(lpJyDest->jyNum!=atoi(temp)) 
  1198. // return 0;
  1199. //
  1200. // ret=CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)];
  1201. // if(ret==' ')
  1202. // return 0;
  1204. REQUEST_BUFFER ReqBuf;
  1205. ANSWER Answer;
  1207. memset(&ReqBuf,0,rlen);
  1208. memset(&Answer,0,sizeof(ANSWER));
  1210. ReadRecord(ReqFile.hf[lpJyDest->zqsid],lpJyDest->recNum,
  1211. hlen,rlen,(char *)&ReqBuf);
  1212. if(ReqBuf.status !='02')
  1213. return 0;
  1214. // if(ReadRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,
  1215. // 0,sizeof(ANSWER),(char *)&Answer)!=0)
  1216. // ret =-1;
  1217. // else 
  1219. ret =ReqBuf.error;
  1221. if(ret<0)
  1222. ret =ANS_SYS_ERR;
  1223. else
  1224. ret =ANS_SUCC;
  1226. AnsChgPwd.flag =(char)ret;
  1227. AnsChgPwd.jys =lpJyDest->curJys;
  1229. strcpy(SendBuff, JY_CHGPWD_HEAD);
  1230. len =strlen(SendBuff);
  1231. *(short *)&SendBuff[len] =lpJyDest->jyNum;
  1232. len +=sizeof(short);
  1234. strcpy(AnsChgPwd.gddm, lpJyDest->gddm);
  1235. memcpy(&SendBuff[len], &AnsChgPwd, sizeof(AnsChgPwd));
  1236. len +=sizeof(AnsChgPwd);
  1238. UDP_SendBuff("修改交易密码", lpJyDest->sd, SendBuff, len, NULL);
  1240. lpJyDest->isReqEnd =TRUE;
  1241. // ClearReq(lpJyDest);
  1242. return 0;
  1243. }
  1244.        
  1245. int JyDest_BuySell(LPJY_DEST lpJyDest)
  1246. {
  1247. char hthm[20];
  1248. BYTE SendBuff[100];
  1249. int ret, len;
  1250.     JY_ANS_BUYSELL AnsBuySell; 
  1252. /*
  1253. ReadRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,
  1254. hlen,rlen,CommBuffer);
  1255. stat=CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)];                     
  1256. if(stat !=';') 
  1257. return 0;
  1259. FldToString(CommBuffer,&CommFile.fldStruct[fld_SERI],temp);
  1260. if(lpJyDest->jyNum!=atoi(temp)) 
  1261. return 0;
  1263. ret=CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)];
  1264. if(ret==' ')
  1265. return 0;
  1266. hthm[0] =0;
  1267. */
  1269. REQUEST_BUFFER ReqBuf;
  1270. ANSWER Answer;
  1272. memset(&ReqBuf,0,rlen);
  1273. memset(&Answer,0,sizeof(ANSWER));
  1275. ReadRecord(ReqFile.hf[lpJyDest->zqsid],lpJyDest->recNum,
  1276. hlen,rlen,(char *)&ReqBuf);
  1277. if(ReqBuf.status !='02')
  1278. return 0;
  1279. if(ReadRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,
  1280. 0,sizeof(ANSWER),(char *)&Answer)!=0)
  1281. ret =-1;
  1282. else ret =ReqBuf.error;
  1284. if(ret<0)
  1285. {
  1286. ret =ANS_SYS_ERR;
  1287. }
  1288. else
  1289. {
  1290. //FldToString(CommBuffer,&CommFile.fldStruct[fld_HTHM],hthm);
  1291. //memset(temp,' ',(short)CommFile.fldStruct[fld_HTHM].wid);
  1292. //if(strncmp(hthm,temp,(short)CommFile.fldStruct[fld_HTHM].wid)==0)
  1293. // return 0;
  1294. lpJyDest->zjye =Answer.a_ent_enter.current_balance;
  1295. lpJyDest->kyje =Answer.a_ent_enter.enable_balance;
  1296. sprintf(hthm,"%06d",ret);
  1297. ret =ANS_SUCC;
  1298. }
  1300. AnsBuySell.jys=lpJyDest->curJys;
  1301. strcpy(AnsBuySell.gddm,lpJyDest->gddm);
  1302. strcpy(AnsBuySell.hthm,hthm);
  1303. AnsBuySell.bs=REQ_BUYSEL;
  1304. AnsBuySell.flag=(char)ret;
  1306. strcpy(SendBuff, JY_BUYSELL_HEAD);
  1307. len =strlen(SendBuff);
  1308. *(short *)&SendBuff[len] =lpJyDest->jyNum;
  1309. len +=sizeof(short);
  1311. memcpy(&SendBuff[len],&AnsBuySell,sizeof(AnsBuySell));
  1312. len+=sizeof(AnsBuySell);
  1314. UDP_SendBuff("买卖委托", lpJyDest->sd, SendBuff, len, NULL);
  1316. lpJyDest->isReqEnd =TRUE;
  1317. //ClearReq(lpJyDest);
  1318. return 0;
  1319. }
  1321.        
  1322. int JyDest_Cancel(LPJY_DEST lpJyDest)
  1323. {
  1324. BYTE SendBuff[600];
  1325. int ret,len,retnum;
  1326. JY_ANS_CANCEL AnsCancel;
  1328. /*
  1329. ReadRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,
  1330. hlen,rlen,CommBuffer);
  1332. stat=CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)];
  1333. if(stat!=';') 
  1334. return 0;
  1336. FldToString(CommBuffer,&CommFile.fldStruct[fld_SERI],temp);
  1337. if(lpJyDest->jyNum!=atoi(temp)) 
  1338. return 0;
  1340. ret=CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)];
  1341. if(ret==' ')
  1342. return 0;
  1343. */
  1344. REQUEST_BUFFER ReqBuf;
  1345. ANSWER Answer;
  1347. memset(&ReqBuf,0,rlen);
  1348. memset(&Answer,0,sizeof(ANSWER));
  1349.     memset(&AnsCancel,0,sizeof(JY_ANS_CANCEL));
  1351. ReadRecord(ReqFile.hf[lpJyDest->zqsid],lpJyDest->recNum,
  1352. hlen,rlen,(char *)&ReqBuf);
  1353. if(ReqBuf.status !='02')
  1354. return 0;
  1355. if(ReadRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,
  1356. 0,sizeof(ANSWER),(char *)&Answer)!=0)
  1357. ret =-1;
  1358. else ret =ReqBuf.error;
  1360. //FldToString(CommBuffer,&CommFile.fldStruct[fld_JYMM],temp);
  1361. //memset(tmp,' ',(short)CommFile.fldStruct[fld_JYMM].wid);
  1362. //if(ret==ANS_SUCC&&strncmp(temp,tmp,(short)CommFile.fldStruct[fld_JYMM].wid)==0)
  1363. // return 0;
  1364. //retnum=atoi(temp);
  1366. retnum =1;
  1368. if(ret<0)
  1369. {
  1370. AnsCancel.flag[0] =ANS_SYS_ERR;
  1371. }
  1372. else
  1373. {
  1374. // if(retnum==1)
  1375. // {
  1376. // ret=CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)];
  1377. lpJyDest->zjye =Answer.a_ent_cancel.current_balance;
  1378. lpJyDest->kyje =Answer.a_ent_cancel.enable_balance;
  1379. AnsCancel.flag[0] =ANS_SUCC;
  1380. // }
  1381. /*
  1382. else
  1383. {
  1384. wsprintf(temp,"%s%d%s",AnsFile.path[lpJyDest->zqsid],lpJyDest->recNum,".ANS");
  1385. hFile =OpenFile(temp, &os, OF_SHARE_DENY_NONE|OF_READ);
  1387. if(hFile ==HFILE_ERROR)
  1388. return 0;
  1390. i=_llseek(hFile, 0L, FILE_END);
  1391. if(i==HFILE_ERROR)
  1392. {
  1393. _lclose(hFile);
  1394. return 0;
  1395. }
  1396. if((i-1)/(rlen+1)!=retnum)
  1397. {
  1398. _lclose(hFile);
  1399. return 0;
  1400. }
  1401. _llseek(hFile, 0L, FILE_BEGIN);
  1403. for(i =0; i<retnum; i++)
  1404. {
  1405. if((short)_lread(hFile,&CommBuffer[1],rlen -1)!=rlen -1)
  1406. break;
  1408. ret=CommBuffer[*(int*)(CommFile.fldStruct[fld_ANSNO].offset)];
  1409. AnsCancel.flag[i] =ret;
  1410. _llseek(hFile, 2L, FILE_CURRENT);
  1411. }
  1412. _lclose(hFile);
  1413. remove(temp);
  1414. }
  1415. */
  1416. }
  1418. AnsCancel.jys =lpJyDest->curJys;
  1419. strcpy(AnsCancel.gddm, lpJyDest->gddm);
  1421. strcpy(SendBuff, JY_CANCEL_HEAD);
  1422. len =strlen(SendBuff);
  1423. *(short *)&SendBuff[len] =lpJyDest->jyNum;
  1424. len +=sizeof(short);
  1426. memcpy(&SendBuff[len], &AnsCancel, sizeof(AnsCancel));
  1427. len +=sizeof(AnsCancel);
  1429. UDP_SendBuff("撤消委托", lpJyDest->sd, SendBuff, len,NULL);
  1430. lpJyDest->isReqEnd =TRUE;
  1431. // ClearReq(lpJyDest);
  1432. return 0;
  1433. }
  1434.        
  1435. int JyDest_Yecx(LPJY_DEST lpJyDest)
  1436. {
  1437. JY_ANS_YECX AnsYecx;
  1438. int ret, i,retnum;
  1440. // ReadRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,
  1441. // hlen,rlen,CommBuffer);
  1442. // stat=CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)];                     
  1443. // if(stat !=';') 
  1444. // return 0;
  1446. // FldToString(CommBuffer,&CommFile.fldStruct[fld_SERI],temp);
  1447. // if(lpJyDest->jyNum!=atoi(temp)) 
  1448. // return 0;
  1450. // ret=CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)];
  1451. // if(ret==' ')
  1452. // return 0;
  1454. // FldToString(CommBuffer,&CommFile.fldStruct[fld_JYMM],temp);
  1455. // memset(tmp,' ',(short)CommFile.fldStruct[fld_JYMM].wid);
  1456. // if(ret==ANS_SUCC&&strncmp(temp,tmp,(short)CommFile.fldStruct[fld_JYMM].wid)==0)
  1457. // return 0;
  1458. // retnum=atoi(temp);
  1460. // if(ret==ANS_SUCC&&retnum>0)
  1461. // {
  1462. // wsprintf(tmp,"%s%d%s",AnsFile.path[lpJyDest->zqsid],lpJyDest->recNum,".ANS");
  1463. // hFile =OpenFile(tmp, &os, OF_SHARE_DENY_NONE|OF_READ);
  1464. //
  1465. // if(hFile ==HFILE_ERROR)
  1466. // return 0;
  1467. //
  1468. // i=_llseek(hFile, 0L, FILE_END);
  1469. // if(i==HFILE_ERROR)
  1470. // {
  1471. // _lclose(hFile);
  1472. // return 0;
  1473. // }
  1474. // if((i)/(rlen+1)<retnum)
  1475. // {
  1476. // _lclose(hFile);
  1477. // return 0;
  1478. // }
  1479. // _llseek(hFile, 0L, FILE_BEGIN);
  1480. // }
  1482. REQUEST_BUFFER ReqBuf;
  1483. ANSWER Answer;
  1485. memset(&ReqBuf,0,rlen);
  1486. memset(&Answer,0,sizeof(Answer));
  1487. ReadRecord(ReqFile.hf[lpJyDest->zqsid],lpJyDest->recNum,
  1488. hlen,rlen,(char *)&ReqBuf);
  1489. if(ReqBuf.status !='02')
  1490. return 0;
  1491. ReadRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,
  1492. 0,sizeof(ANSWER),(char *)&Answer);
  1494. ret =ReqBuf.error;
  1496. AnsYecx.kys=lpJyDest->kyje;
  1497. AnsYecx.zjye=lpJyDest->zjye;
  1499. if(ret>=0)
  1500. {
  1501. retnum =ret;
  1502. ret =ANS_SUCC;
  1504. //FldToString(CommBuffer,&CommFile.fldStruct[fld_WTJG],temp);
  1505. //AnsYecx.kys=atof(temp);      
  1506. //FldToString(CommBuffer,&CommFile.fldStruct[fld_WTGS],temp);
  1507. //AnsYecx.zjye=atof(temp);     
  1509. if(retnum>0)
  1510. {
  1511. AnsYecx.lpGptg=GlobalAllocPtr(GHND,sizeof(JY_GPTG)*retnum);
  1512. memset(&AnsYecx.lpGptg[0],0,sizeof(JY_GPTG)*retnum);
  1513. }
  1515. for(i=0;i<retnum && i<ITEMS;i++)
  1516. {
  1517. //if((short)_lread(hFile,&CommBuffer[1],rlen -1)!=rlen -1)
  1518. // break;
  1520. strcpy(AnsYecx.lpGptg[i].gpdm,Answer.a_inq_stock[i].stock_code);
  1521. sprintf(AnsYecx.lpGptg[i].kys,"%8d",
  1522. Answer.a_inq_stock[i].enable_balance);
  1523. sprintf(AnsYecx.lpGptg[i].gpye,"%8d",
  1524. Answer.a_inq_stock[i].current_balance);
  1525. /*
  1526. FldToString(CommBuffer,&CommFile.fldStruct[fld_GPDM],
  1527. &AnsYecx.lpGptg[i].gpdm[0]);
  1529. FldToString(CommBuffer,&CommFile.fldStruct[fld_WTGS],
  1530. &AnsYecx.lpGptg[i].kys[0]);
  1532. FldToString(CommBuffer,&CommFile.fldStruct[fld_WTJG],
  1533. &AnsYecx.lpGptg[i].gpye[0]);
  1535. FldToString(CommBuffer,&CommFile.fldStruct[fld_DATE],
  1536. &AnsYecx.lpGptg[i].ghrq[0]);
  1537. _llseek(hFile, 2L, FILE_CURRENT);
  1538. */
  1539. }
  1541. // if(retnum>0)
  1542. // {
  1543. // _lclose(hFile);
  1544. // remove(tmp);
  1545. // }
  1547. AnsYecx.recnum=i;
  1548. AnsYecx.flag=ret;
  1549. if(AnsYecx.recnum >=0)
  1550. {
  1551. lpJyDest->isSending =TRUE;
  1552. Thrd_SendJycx(REQ_YECX, lpJyDest->sd, &AnsYecx, lpJyDest->jyNum);
  1553. if(retnum>0)
  1554. GlobalFreePtr(AnsYecx.lpGptg);
  1555. lpJyDest->isSending =FALSE;
  1556. }
  1557. }
  1558. else
  1559. {
  1560. AnsYecx.recnum=0;
  1561. AnsYecx.flag=ANS_SUCC;
  1563. lpJyDest->isSending =TRUE;
  1564. Thrd_SendJycx(REQ_YECX, lpJyDest->sd, &AnsYecx, lpJyDest->jyNum);
  1565. lpJyDest->isSending =FALSE;
  1567. // lpJyDest->isReqEnd =TRUE;
  1568. //        ClearReq(lpJyDest);
  1569. //     return ret;
  1570. }
  1571. lpJyDest->isReqEnd =TRUE;
  1572. return 0;
  1573. }
  1574.        
  1575. int JyDest_Cjcx(LPJY_DEST lpJyDest)
  1576. {
  1577. JY_ANS_CJCX AnsCjcx;
  1578. int i, ret,retnum;
  1580. /*
  1581. ReadRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,
  1582. hlen,rlen,CommBuffer);
  1583. stat=CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)];                     
  1584. if(stat !=';') 
  1585. return 0;
  1586. FldToString(CommBuffer,&CommFile.fldStruct[fld_SERI],temp);
  1587. if(lpJyDest->jyNum!=atoi(temp)) 
  1588. return 0;
  1590. ret=CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)];
  1591. if(ret==' ')
  1592. return 0;
  1593. FldToString(CommBuffer,&CommFile.fldStruct[fld_JYMM],temp);
  1594. memset(tmp,' ',(short)CommFile.fldStruct[fld_JYMM].wid);
  1595. if(ret==ANS_SUCC&&strncmp(temp,tmp,(short)CommFile.fldStruct[fld_JYMM].wid)==0)
  1596. return 0;
  1597. retnum=atoi(temp);
  1599. if(ret==ANS_SUCC&&retnum>0)
  1600. {
  1601. wsprintf(tmp,"%s%d%s",AnsFile.path[lpJyDest->zqsid],lpJyDest->recNum,".ANS");
  1602. hFile =OpenFile(tmp, &os, OF_SHARE_DENY_NONE|OF_READ);
  1604. if(hFile ==HFILE_ERROR)
  1605. return 0;
  1607. i=_llseek(hFile, 0L, FILE_END);
  1608. if(i==HFILE_ERROR)
  1609. {
  1610. _lclose(hFile);
  1611. return 0;
  1612. }
  1613. if((i)/(rlen+1)<retnum)
  1614. {
  1615. _lclose(hFile);
  1616. return 0;
  1617. }
  1618. _llseek(hFile, 0L, FILE_BEGIN);
  1619. }
  1620. */
  1622. REQUEST_BUFFER ReqBuf;
  1623. ANSWER Answer;
  1625. memset(&ReqBuf,0,rlen);
  1626. ReadRecord(ReqFile.hf[lpJyDest->zqsid],lpJyDest->recNum,
  1627. hlen,rlen,(char *)&ReqBuf);
  1628. if(ReqBuf.status !='02')
  1629. return 0;
  1630. memset(&Answer,0,sizeof(Answer));
  1631. ReadRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,
  1632. 0,sizeof(ANSWER),(char *)&Answer);
  1634. ret =ReqBuf.error;
  1636. if(ret>=0)
  1637. { 
  1638. retnum =ret;
  1639. ret =ANS_SUCC;
  1641. if(retnum>0)
  1642. {
  1643. AnsCjcx.lpCj=GlobalAllocPtr(GHND,sizeof(JY_CJ)*retnum);
  1644. memset(&AnsCjcx.lpCj[0],0,sizeof(JY_CJ)*retnum);
  1645. }
  1647. for(i=0;i<retnum && i<ITEMS;i++)
  1648. {
  1649. //memset(CommBuffer,0,sizeof(CommBuffer));
  1650. //if((short)_lread(hFile,&CommBuffer[1],rlen -1)!=rlen -1)
  1651. // break;
  1653. //if(Answer.a_inq_real[i].real_status =='2')
  1654. // continue;
  1655. sprintf(AnsCjcx.lpCj[i].hthm,"%06d",
  1656. Answer.a_inq_real[i].serial_no);
  1657. sprintf(AnsCjcx.lpCj[i].cjsj,"%06d",
  1658. Answer.a_inq_real[i].business_time);
  1659. AnsCjcx.lpCj[i].mmbz=(Answer.a_inq_real[i].bs=='1')?'B':'S';
  1660. strcpy(AnsCjcx.lpCj[i].gpdm,
  1661. Answer.a_inq_real[i].stock_code);
  1662. sprintf(AnsCjcx.lpCj[i].cjgs,"%8d",
  1663. Answer.a_inq_real[i].business_amount);
  1664. sprintf(AnsCjcx.lpCj[i].cjjg,"%6.2f",
  1665. Answer.a_inq_real[i].business_price);
  1666. /*
  1667. FldToString(CommBuffer,&CommFile.fldStruct[fld_HTHM],
  1668. &AnsCjcx.lpCj[i].hthm[0]);
  1670. FldToString(CommBuffer,&CommFile.fldStruct[fld_DATE],
  1671. &AnsCjcx.lpCj[i].cjsj[0]);
  1673. AnsCjcx.lpCj[i].mmbz=
  1674. CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)];
  1676. FldToString(CommBuffer,&CommFile.fldStruct[fld_GPDM],
  1677. &AnsCjcx.lpCj[i].gpdm[0]);
  1679. FldToString(CommBuffer,&CommFile.fldStruct[fld_WTGS],
  1680. &AnsCjcx.lpCj[i].cjgs[0]);
  1681. FldToString(CommBuffer,&CommFile.fldStruct[fld_WTJG],
  1682. &AnsCjcx.lpCj[i].cjjg[0]);
  1684. _llseek(hFile, 2L, FILE_CURRENT);
  1685. */
  1686. }
  1687. AnsCjcx.recnum=i;
  1688. AnsCjcx.flag =ret;
  1689. if(AnsCjcx.recnum >=0)
  1690. {
  1691. lpJyDest->isSending =TRUE;
  1692. Thrd_SendJycx(REQ_CJCX, lpJyDest->sd, &AnsCjcx, lpJyDest->jyNum);
  1693. if(retnum>0)
  1694. GlobalFreePtr(AnsCjcx.lpCj);
  1695. lpJyDest->isSending =FALSE;
  1696. }
  1697. }
  1698. else
  1699. {
  1700. AnsCjcx.recnum=0;
  1701. AnsCjcx.flag =ANS_SUCC;
  1702. lpJyDest->isSending =TRUE;
  1703. Thrd_SendJycx(REQ_CJCX, lpJyDest->sd, &AnsCjcx, lpJyDest->jyNum);
  1704. lpJyDest->isSending =FALSE;
  1705. }
  1706. lpJyDest->isReqEnd =TRUE;
  1707. return 0;
  1708. }
  1710. int JyDest_Wtcx(LPJY_DEST lpJyDest)
  1711. {
  1712. JY_ANS_WTCX AnsWtcx;
  1713. int ret, i,retnum;
  1715. /*
  1716. ReadRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,
  1717. hlen,rlen,CommBuffer);
  1718. stat=CommBuffer[*(short*)(CommFile.fldStruct[fld_STAT].offset)];
  1719. if(stat !=';') 
  1720. return 0;
  1722. FldToString(CommBuffer,&CommFile.fldStruct[fld_SERI],temp);
  1723. if(lpJyDest->jyNum!=atoi(temp)) return 0;
  1725. ret=CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)];
  1726. if(ret==' ')
  1727. return 0;
  1728. FldToString(CommBuffer,&CommFile.fldStruct[fld_JYMM],temp);
  1729. memset(tmp,' ',(short)CommFile.fldStruct[fld_JYMM].wid);
  1730. if(ret==ANS_SUCC&&strncmp(temp,tmp,(short)CommFile.fldStruct[fld_JYMM].wid)==0)
  1731. return 0;
  1732. retnum=atoi(temp);
  1734. if(ret==ANS_SUCC&&retnum>0)
  1735. {
  1736. wsprintf(temp,"%s%d%s",AnsFile.path[lpJyDest->zqsid],lpJyDest->recNum,".ANS");
  1737. hFile =OpenFile(temp, &os, OF_SHARE_DENY_NONE|OF_READ);
  1739. if(hFile ==HFILE_ERROR)
  1740. return 0;
  1742. i=_llseek(hFile, 0L, FILE_END);
  1743. if(i==HFILE_ERROR)
  1744. {
  1745. _lclose(hFile);
  1746. return 0;
  1747. }
  1748. if((i)/(rlen+1)<retnum)
  1749. {
  1750. _lclose(hFile);
  1751. return 0;
  1752. }
  1753. _llseek(hFile, 0L, FILE_BEGIN);
  1754. }
  1755. */
  1757. REQUEST_BUFFER ReqBuf;
  1758. ANSWER Answer;
  1760. memset(&ReqBuf,0,rlen);
  1761. ReadRecord(ReqFile.hf[lpJyDest->zqsid],lpJyDest->recNum,
  1762. hlen,rlen,(char *)&ReqBuf);
  1763. if(ReqBuf.status !='02')
  1764. return 0;
  1765. memset(&Answer,0,sizeof(Answer));
  1766. ReadRecord(AnsFile.hf[lpJyDest->zqsid],lpJyDest->recNum,
  1767. 0,sizeof(ANSWER),(char *)&Answer);
  1769. ret =ReqBuf.error;
  1771. if(ret>=0)
  1772. { 
  1773. retnum =ret;
  1774. ret =ANS_SUCC;
  1776. if(retnum>0)
  1777. {
  1778. AnsWtcx.lpWt =GlobalAllocPtr(GHND,sizeof(JY_WT)*retnum);
  1779. memset(&AnsWtcx.lpWt[0], 0, sizeof(JY_WT)*retnum);
  1780. }
  1782. for(i=0;i<retnum && i<ITEMS;i++)
  1783. {
  1784. //if(Answer.a_inq_entrust[i].entrust_status=='4')
  1785. // continue;
  1786. sprintf(AnsWtcx.lpWt[i].hthm,"%06d",
  1787. Answer.a_inq_entrust[i].entrust_serial_no);
  1789. sprintf(AnsWtcx.lpWt[i].wtsj,"  :  : ");
  1790. AnsWtcx.lpWt[i].mmbz=
  1791. (Answer.a_inq_entrust[i].entrust_bs=='1')?'B':'S';
  1792. strcpy(AnsWtcx.lpWt[i].gpdm,
  1793. Answer.a_inq_entrust[i].stock_code);
  1794. sprintf(AnsWtcx.lpWt[i].wtgs,"%8d",
  1795. Answer.a_inq_entrust[i].entrust_amount);
  1796. sprintf(AnsWtcx.lpWt[i].wtjg,"%6.2f",
  1797. Answer.a_inq_entrust[i].entrust_price);
  1798. /*
  1799. memset(CommBuffer,0,sizeof(CommBuffer));
  1800. if((short)_lread(hFile,&CommBuffer[1],rlen -1)!=rlen -1)
  1801. break;
  1802. FldToString(CommBuffer,&CommFile.fldStruct[fld_HTHM],
  1803. &AnsWtcx.lpWt[i].hthm[0]);
  1805. FldToString(CommBuffer,&CommFile.fldStruct[fld_DATE],
  1806. &AnsWtcx.lpWt[i].wtsj[0]);
  1808. AnsWtcx.lpWt[i].mmbz=
  1809. CommBuffer[*(short*)(CommFile.fldStruct[fld_ANSNO].offset)];
  1811. FldToString(CommBuffer,&CommFile.fldStruct[fld_GPDM],
  1812. &AnsWtcx.lpWt[i].gpdm[0]);
  1814. FldToString(CommBuffer,&CommFile.fldStruct[fld_WTGS],
  1815. &AnsWtcx.lpWt[i].wtgs[0]);
  1816. FldToString(CommBuffer,&CommFile.fldStruct[fld_WTJG],
  1817. &AnsWtcx.lpWt[i].wtjg[0]);
  1818. _llseek(hFile, 2L, FILE_CURRENT);
  1819. */
  1820. }
  1821. AnsWtcx.recnum=i;
  1822. AnsWtcx.flag =ret;
  1823. if(AnsWtcx.recnum >=0)
  1824. {
  1825. lpJyDest->isSending =TRUE;
  1826. Thrd_SendJycx(REQ_WTCX, lpJyDest->sd, &AnsWtcx, lpJyDest->jyNum);
  1827. if(AnsWtcx.recnum>0)
  1828. GlobalFreePtr(AnsWtcx.lpWt);
  1829. lpJyDest->isSending =FALSE;
  1830. }
  1831. }
  1832. else
  1833. {
  1834. AnsWtcx.recnum=0;
  1835. AnsWtcx.flag =ANS_SUCC;
  1837. lpJyDest->isSending =TRUE;
  1838. Thrd_SendJycx(REQ_WTCX, lpJyDest->sd, &AnsWtcx, lpJyDest->jyNum);
  1839. lpJyDest->isSending =FALSE;
  1840. }
  1841. lpJyDest->isReqEnd =TRUE;
  1842. return 0;
  1843. }
  1845. int Thrd_SendJycx(int reqType, int sd, char *lpBuf, int jyNum)
  1846. {
  1847. char SendBuff[2048];
  1848. LPJY_ANS_YECX lpAnsYecx;
  1849. LPJY_ANS_CJCX lpAnsCjcx;
  1850. LPJY_ANS_WTCX lpAnsWtcx;
  1851. int i, len, recCount, sendCount, sendNum;
  1853. sendNum =0;
  1854. sendCount =MAX_CX_SENDCOUNT;
  1855. switch(reqType)
  1856. {
  1857. case REQ_YECX:
  1858. lpAnsYecx =(LPJY_ANS_YECX)lpBuf;
  1859. recCount =lpAnsYecx->recnum;
  1860. for(i =0; i<=recCount/MAX_CX_SENDCOUNT; i++)
  1861. {
  1862. sendNum =i*MAX_CX_SENDCOUNT;
  1863. if(sendNum+sendCount >recCount)
  1864. sendCount =recCount-sendNum;
  1866. strcpy(SendBuff, JY_YECX_HEAD);
  1867. len =strlen(SendBuff);
  1868. *(short *)&SendBuff[len] =jyNum;
  1869. len +=sizeof(short);
  1870. lpAnsYecx->recnum=sendCount;
  1871. memcpy(&SendBuff[len],lpAnsYecx,sizeof(JY_ANS_YECX)-sizeof(LPJY_GPTG));
  1872.             len+=sizeof(JY_ANS_YECX)-sizeof(LPJY_GPTG);
  1874. if(sendCount==0&&sendNum!=0)
  1875. break;
  1877. if(sendCount>0)
  1878. {
  1879. memcpy(&SendBuff[len], &lpAnsYecx->lpGptg[sendNum],
  1880. sizeof(JY_GPTG)*sendCount);
  1881. len +=sizeof(JY_GPTG)*sendCount;
  1882. }
  1883. if(UDP_SendBuff("余额查询", sd, SendBuff, len,NULL)<0)
  1884. return -1;
  1885. }
  1886. break;
  1887. case REQ_CJCX:
  1888. lpAnsCjcx =(LPJY_ANS_CJCX)lpBuf;
  1889. recCount =lpAnsCjcx->recnum;
  1890. sendCount =MAX_CX_SENDCOUNT;
  1891. for(i =0; i<=recCount/MAX_CX_SENDCOUNT; i++)
  1892. {
  1893. sendNum =i*MAX_CX_SENDCOUNT;
  1894. if(sendNum+sendCount >recCount)
  1895. sendCount =recCount-sendNum;
  1897. strcpy(SendBuff, JY_CJCX_HEAD);
  1898. len =strlen(SendBuff);
  1899. *(short *)&SendBuff[len] =jyNum;
  1900. len +=sizeof(short);
  1902. lpAnsCjcx->recnum=sendCount;
  1903.             memcpy(&SendBuff[len],lpAnsCjcx,sizeof(JY_ANS_CJCX)-sizeof(LPJY_CJ));
  1904.             len+=sizeof(JY_ANS_CJCX)-sizeof(LPJY_CJ);
  1906. if(sendCount==0&&sendNum!=0)
  1907. break;
  1908. if(sendCount>0)
  1909. {
  1910.   memcpy(&SendBuff[len], &lpAnsCjcx->lpCj[sendNum],
  1911. sizeof(JY_CJ)*sendCount);
  1912. len +=sizeof(JY_CJ)*sendCount;
  1913. }
  1914. if(UDP_SendBuff("成交查询", sd, SendBuff, len,NULL)<0)
  1915. return -1; 
  1916. }
  1917. break;
  1918. case REQ_WTCX:
  1919. lpAnsWtcx =(LPJY_ANS_WTCX)lpBuf;
  1920. recCount =lpAnsWtcx->recnum;
  1921. sendCount =MAX_CX_SENDCOUNT;
  1922. for(i =0; i<=recCount/MAX_CX_SENDCOUNT; i++)
  1923. {
  1924. sendNum =i*MAX_CX_SENDCOUNT;
  1925. if(sendNum+sendCount >recCount)
  1926. sendCount =recCount-sendNum;
  1927. strcpy(SendBuff, JY_WTCX_HEAD);
  1928. len =strlen(SendBuff);
  1929. *(short *)&SendBuff[len] =jyNum;
  1930. len +=sizeof(short);
  1932. lpAnsWtcx->recnum=sendCount;
  1933. memcpy(&SendBuff[len],lpAnsWtcx,sizeof(JY_ANS_WTCX)-sizeof(LPJY_WT));
  1934.             len+=sizeof(JY_ANS_WTCX)-sizeof(LPJY_WT);
  1935. if(sendCount>0)
  1936. {
  1937. memcpy(&SendBuff[len], &lpAnsWtcx->lpWt[sendNum],
  1938. sizeof(JY_WT)*sendCount);
  1939. len +=sizeof(JY_WT)*sendCount;
  1940. }
  1941. if(sendCount==0&&sendNum!=0)
  1942. break;
  1943. if(UDP_SendBuff("委托查询", sd, SendBuff, len,NULL)<0)
  1944. return -1;
  1945. }
  1946. break;
  1947. }
  1948. strcpy(SendBuff, JY_CXEND_HEAD);
  1949. len =strlen(SendBuff);
  1951. UDP_SendBuff("查询成功", sd, SendBuff, len,NULL);
  1952. return 0;
  1953. }
  1955. int Jy_SendRet(int sd, char reqType, char ret, int jyNum)
  1956. {
  1957. int len;
  1958. BYTE SendBuff[100];
  1959. LPSTR lpHead;
  1961. if(ret ==ANS_TIME_OUT)
  1962. lpHead =JY_TIMEOUT_HEAD;
  1963. else
  1964. switch(reqType)
  1965. {
  1966. case REQ_CHKUSR:
  1967. lpHead =JY_CHKUSR_HEAD;
  1968. break;
  1969. case REQ_CHGPWD:
  1970. lpHead =JY_CHGPWD_HEAD;
  1971. break;
  1972. case REQ_BUYSEL:
  1973. lpHead =JY_BUYSELL_HEAD;
  1974. break;
  1975. case REQ_CANCEL:
  1976. lpHead =JY_CANCEL_HEAD;
  1977. break;
  1978. case REQ_YECX:
  1979. lpHead =JY_YECX_HEAD;
  1980. break;
  1981. case REQ_CJCX:
  1982. lpHead =JY_CJCX_HEAD;
  1983. break;
  1984. case REQ_WTCX:
  1985. lpHead =JY_WTCX_HEAD;
  1986. break;
  1987. }
  1988. strcpy(SendBuff, lpHead);
  1989. len =strlen(SendBuff);
  1990. *(short *)&SendBuff[len] =jyNum;
  1991. len +=sizeof(short);
  1992. SendBuff[len++] =(char)ret;
  1994. UDP_SendBuff("发送结果", sd, SendBuff, len,NULL);
  1996. return 0;
  1997. }