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

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

金融证券系统

开发平台：

Visual C++

HQDEST.C：源码内容
  1. #include <windows.h>
  2. #include <time.h>
  4. #include "main.h"
  6. #include "hq.h"
  7. #include "pctcp.h"
  8. #include "hqdest.h"
  9. #include "monitor.h"
  11. #include "cl_hq.h"
  12. #include "cl_data.h"
  13. #include "cl_main.h"
  15. CRITICAL_SECTION hqCriticalSection;
  17. DEST_INFOS dest_infos;
  19. DEST_INFO dest_info[MAX_USER_COUNT];
  20. int  dest_info_count=0;
  22. BOOL fDestInited =FALSE;
  23. BOOL gfIsNewsSrcDel=FALSE;
  25. HANDLE hThrdScanDest =NULL;
  26. HANDLE hNewsManager =NULL;      
  28. void FreeDest(void);
  30. LPDEST_INFO GetDestByUser(LPSTR userID);
  31. LPDEST_INFO GetFirstDeadDest(void);
  32. int FillDpMain(LPDP_MAIN lpDpMain);
  34. extern BOOL run_cancelled,gfReadData;
  36. extern int Delay_Send_Hq01(LPDEST_INFO lpDest);
  38. extern int UDP_Server_Send_Hq10(LPDEST_INFO);
  39. extern int Send_Hq10(LPDEST_INFO lpDest);
  41. extern int UDP_Server_Send_Gra10(LPDEST_INFO);
  42. extern int Send_Gra10(LPDEST_INFO lpDest);
  44. extern int UDP_Server_Send_Dp(int sd, struct sockaddr *lpdest, BOOL fThrd, LPDEST_INFO lpDest);
  45. extern int UDP_ReadHq(int sd,char * RecvBuf,int len,struct sockaddr_in dest);
  47. extern void HqResetChangedTimes(void);
  48. extern void SetHqUsers(int);
  49. extern BOOL IsZsRec(int, short);
  50. extern int sdHq;
  51. extern MONITOR Monitor;
  53. extern int RefreshHq(int jys);
  55. extern char szDataPath[128],szNewsPath[128],szNewsSrc[128];
  56. extern char ZxDataFile[128];
  57. extern HFILE hfZx;
  59. extern int SendMsg(int sd, LPSTR);
  60. extern BOOL ZlibCompressFile(char *infile,char *outfile);
  62. BOOL DestInit(void)
  63. {
  64. fDestInited =TRUE;
  65. memset(&dest_infos, 0, sizeof(dest_infos));
  66. memset(&dest_info[0],0,sizeof(DEST_INFO)*MAX_USER_COUNT);
  67. dest_infos.lpDestHead =&dest_info[0];
  68. dest_info_count=0;
  69. return TRUE;
  70. }
  72. void DestExit(void)
  73. {
  74. if(!fDestInited) return;
  75. fDestInited =FALSE;
  76. if(hThrdScanDest) CloseHandle(hThrdScanDest);
  77. FreeDest();
  78. }
  80. long GetDestCount(void)
  81. {
  82. return MAKELONG(dest_infos.destCount, dest_infos.aliveCount);
  83. }
  85. int LockDest(LPDEST_INFO lpDestTmp,int num)
  86. {
  87. int i;
  89. i=0;
  91. lpDestTmp->isUsing = TRUE;
  92. return TRUE;
  93. /*
  94. EnterCriticalSection(&hqCriticalSection);
  95. do
  96. {
  97. if(!lpDestTmp->isUsing)
  98. {
  99. lpDestTmp->isUsing = TRUE;
  100. LeaveCriticalSection(&hqCriticalSection);
  101. return TRUE;
  102. }
  103. LeaveCriticalSection(&hqCriticalSection);
  104. ShoutBlockingHook();
  105. Sleep(40);
  106. EnterCriticalSection(&hqCriticalSection);
  107. i++;
  108. }while(lpDestTmp->isUsing&&i<num);
  109. LeaveCriticalSection(&hqCriticalSection);
  110. return FALSE;
  111. */
  112. }
  114. int xLockDest(LPDEST_INFO lpDestTmp,int num)
  115. {
  116. int i =0;
  118. do
  119. {
  120. if(!lpDestTmp->isUsing)
  121. {
  122. lpDestTmp->isUsing = TRUE;
  123. return TRUE;
  124. }
  125. i++;
  126. }while(lpDestTmp->isUsing&&i<num);
  127. return FALSE;
  128. }
  130. void UnlockDest(LPDEST_INFO lpDestTmp)
  131. {
  132. // EnterCriticalSection(&hqCriticalSection);
  133. lpDestTmp->isUsing=FALSE;
  134. // LeaveCriticalSection(&hqCriticalSection);
  135. }
  137. int HqDestActiveUsr(int sd, struct sockaddr *lpdest, LPSTR userID,int ret)
  138. {
  139. LPDEST_INFO lpDestTmp;  //lpDestTmp1;
  141. lpDestTmp =GetDestBySd(sd);
  143. if(lpDestTmp ==NULL) return -1;
  144. if(!LockDest(lpDestTmp,10))
  145. {
  146. ErrMsg(ghWndMain,"来自HqDestActiveUsr:加锁失败!");
  147. return -1;
  148. }
  149. strcpy(lpDestTmp->userID, userID);
  150. lpDestTmp->isDead =FALSE;
  151. lpDestTmp->recNum=ret;
  152. time(&lpDestTmp->startTime);
  153. lpDestTmp->inactive =0;
  154. dest_infos.aliveCount++;
  155. UnlockDest(lpDestTmp);
  156. return ((int)(lpDestTmp->version));
  157. }
  159. int AddDest(int sd, struct sockaddr *dest, int curJys,
  160. int reqType, short *params, short paramsCount,BYTE version)
  161. {
  162. int i;
  163. LPDEST_INFO lpDestNext, lpDestTmp;
  164. LPDEST_INFO *lpDestNew =NULL;
  166. lpDestNext =dest_infos.lpDestHead;
  167. lpDestNew =&dest_infos.lpDestHead;
  169.     if(paramsCount<0||paramsCount>MAX_PARA_COUNT)
  170. {
  171. ErrMsg(ghWndMain,"来自AddDest:错误的参数个数!");
  172. return -1;
  173. }
  175. if(dest_info_count>MAX_USER_COUNT)
  176. {
  177. ErrMsg(ghWndMain,"来自AddDest:无空闲的地址表项!");
  178. return -1;
  179. }
  180. lpDestTmp=&dest_info[dest_info_count];
  181. if(dest_info_count>0)
  182. dest_info[dest_info_count-1].lpNext=&dest_info[dest_info_count];
  183. dest_info_count++;
  185. lpDestTmp->isUsing=FALSE;
  186. if(!LockDest(lpDestTmp,10)) 
  187. {
  188. ErrMsg(ghWndMain,"来自AddDest:加锁失败!");
  189. return -1;
  190. }
  192. memset(lpDestTmp, 0, sizeof(DEST_INFO));
  193. lpDestTmp->sd =sd;
  194. lpDestTmp->curJys =curJys;
  195. lpDestTmp->reqType =reqType;
  196. lpDestTmp->isDead =FALSE;
  197. lpDestTmp->inactive =0;
  199. if(lpDestTmp->params==NULL)
  200. lpDestTmp->params =GlobalLock(GlobalAlloc(GHND,(MAX_PARA_COUNT+1)*sizeof(short)));
  202. if(lpDestTmp->params ==NULL)
  203. {
  204. ErrMsg(ghWndMain,"来自AddDest:不能分配参数内存区!");
  205. UnlockDest(lpDestTmp);
  206. return -1;
  207. }
  208. if(reqType ==REQ_GRA10)
  209. {
  210. lpDestTmp->graNo =params[0];
  211. lpDestTmp->graEnd =params[1];
  212. }
  213. else
  214. memcpy(lpDestTmp->params, params, sizeof(short)*paramsCount);
  216. if(lpDestTmp->lpCjss ==NULL)
  217. lpDestTmp->lpCjss =GlobalLock(GlobalAlloc(GHND,MAX_PARA_COUNT*sizeof(int)));
  218. if(lpDestTmp->lpCjss ==NULL)
  219. {
  220. GlobalUnlock(GlobalHandle(lpDestTmp->params));
  221. GlobalFree(GlobalHandle(lpDestTmp->params));
  222. lpDestTmp->params ==NULL;
  224. ErrMsg(ghWndMain,"来自AddDest:不能分配lpCjss参数内存区!");
  225. UnlockDest(lpDestTmp);
  226. return -1;
  227. }
  229. if(reqType ==REQ_HQ10||reqType ==REQ_HQ01)
  230. {
  231. for(i =0; i<params[0]; i++)
  232. {
  233. lpDestTmp->lpCjss[i] =HqData[curJys].lpRefData[params[i+1]].cjss;
  234. }
  235. }
  236. else if(reqType ==REQ_GRA10)
  237. {
  238. if(IsZsRec(curJys, params[0]))
  239. {
  240. lpDestTmp->lpZsGraph =GlobalLock(GlobalAlloc(GHND,sizeof(ZS_GRAPH)));   
  241. if(lpDestTmp->lpZsGraph ==NULL)
  242. {
  243. ErrMsg(ghWndMain,"来自AddDest:不能分配ZS_RGAPH内存区!");
  244. UnlockDest(lpDestTmp);
  245. return -1;
  246. }
  247. memcpy(lpDestTmp->lpZsGraph->Maxmin, MaxMinData[curJys],
  248. sizeof(MAXMIN_DATA)*2);
  249. }
  250. else
  251. {
  252. lpDestTmp->lpGraph =GlobalLock(GlobalAlloc(GHND,sizeof(GRAPH)));
  253. if(lpDestTmp->lpGraph ==NULL)
  254. {
  255. ErrMsg(ghWndMain,"来自AddDest:不能分配GRAPH内存区!");
  256. UnlockDest(lpDestTmp);
  257. return -1;
  258. }
  259. memcpy(&lpDestTmp->lpGraph->mmp, &MmpData[curJys].lpMmp[params[0]],
  260. sizeof(MMP));
  261. }
  262. lpDestTmp->cjss =HqData[curJys].lpRefData[params[0]].cjss;
  263. }
  264. else
  265. {
  266. ErrMsg(ghWndMain, "来自AddDest:错误的请求!");
  267. UnlockDest(lpDestTmp);
  268. return -1;
  269. }
  271. FillDpMain(&lpDestTmp->DpData[0]);
  273. if(version!=0)
  274. lpDestTmp->version =version;
  276. lpDestTmp->paramsCount =paramsCount;
  277. *lpDestNew =lpDestTmp;
  278. dest_infos.destCount ++;
  279. UnlockDest(lpDestTmp);
  280. return 0;
  281. }
  283. int ChangeDest(int sd, LPDEST_INFO lpDestTmp, struct sockaddr *dest, int curJys,
  284. int reqType, short *params, short paramsCount,BYTE version)
  285. {
  286. int i;
  288. if(lpDestTmp ==NULL) return 0;
  289. if(!LockDest(lpDestTmp,10)) return -1;     
  291. lpDestTmp->isDead =FALSE;
  292. lpDestTmp->sd =sd;
  293. lpDestTmp->curJys =curJys;
  294. lpDestTmp->reqType =reqType;
  295. lpDestTmp->inactive =0;
  296. if(version!=0)
  297. lpDestTmp->version=version;
  298. if(paramsCount<0||paramsCount>MAX_PARA_COUNT||lpDestTmp->params ==NULL)
  299. {
  300. ErrMsg(ghWndMain,"来自ChangeDest:错误的参数个数!");
  301. UnlockDest(lpDestTmp);
  302. return -1;
  303. }
  305. if(reqType ==REQ_HQ10||reqType ==REQ_HQ01)
  306. {
  307. if(params[0]+params[1]+1>HqData[curJys].recCount)
  308. {
  309. params[0]=HqData[curJys].recCount-params[1];
  310. }       
  311. for(i =0; i<params[0]; i++)
  312. {
  313. if(params[i+1]<0||params[i+1]>=HqData[curJys].recCount)
  314. {
  315. ErrMsg(NULL,"来自ChangeDest:错误的列表参数!");
  316. UnlockDest(lpDestTmp);
  317. return -1;
  318. }
  319. lpDestTmp->lpCjss[i] =HqData[curJys].lpRefData[params[i+1]].cjss;
  320. }
  321. }
  322. else if(reqType ==REQ_GRA10)
  323. {
  324. if(IsZsRec(curJys, params[0]))
  325. {
  326. if(lpDestTmp->lpZsGraph ==NULL)
  327. {
  328. lpDestTmp->lpZsGraph =GlobalLock(GlobalAlloc(GHND,sizeof(ZS_GRAPH)));
  329. if(lpDestTmp->lpZsGraph ==NULL)
  330. {
  331. ErrMsg(ghWndMain, "来自ChangeDest:分配ZS_GARPH内存失败!");
  332. UnlockDest(lpDestTmp);
  333. return -1;
  334. }
  335. }
  336. memcpy(lpDestTmp->lpZsGraph->Maxmin, MaxMinData[curJys],
  337. sizeof(MAXMIN_DATA)*2);
  338. }
  339. else
  340. {
  341. if(lpDestTmp->lpGraph ==NULL)
  342. {
  343. lpDestTmp->lpGraph =GlobalLock(GlobalAlloc(GHND,sizeof(GRAPH)));
  344. if(lpDestTmp->lpGraph ==NULL)
  345. {
  346. ErrMsg(ghWndMain, "来自ChangeDest:分配GARPH内存失败!");
  347. UnlockDest(lpDestTmp);      
  348. return -1;
  349. }
  350. }
  351. memcpy(&lpDestTmp->lpGraph->mmp, &MmpData[curJys].lpMmp[params[0]],
  352. sizeof(MMP));
  353. }
  354. lpDestTmp->cjss =HqData[curJys].lpRefData[params[0]].cjss;
  355. }
  356. else
  357. {
  358. UnlockDest(lpDestTmp);
  359. ErrMsg(ghWndMain, "来自ChangeDest:错误的请求!");
  360. return -1;
  361. }
  362. if(reqType ==REQ_GRA10)
  363. {
  364. lpDestTmp->graNo =params[0];
  365. lpDestTmp->graEnd =params[1];
  366. }
  367. else
  368. memcpy(lpDestTmp->params, params, sizeof(short)*paramsCount);
  370. FillDpMain(&lpDestTmp->DpData[0]);
  372. lpDestTmp->paramsCount =paramsCount;
  373. UnlockDest(lpDestTmp);
  374. return 0;
  375. }
  377. int CheckDest(int sd, struct sockaddr *dest, int curJys,
  378. int reqType, short *params, short paramsCount,BYTE version)
  379. {
  380. int ret;
  381. LPDEST_INFO lpDestTmp;
  383. lpDestTmp=GetDestBySd(sd);
  385. if(lpDestTmp ==NULL)
  386. {
  387. lpDestTmp =GetFirstDeadDest();
  388. if(!lpDestTmp) goto add_dest;
  389. }
  390. ret=ChangeDest(sd, lpDestTmp, dest, curJys, reqType,
  391. params, paramsCount,version);
  392. return ret;
  394. add_dest:
  395. ret=AddDest(sd, dest, curJys, reqType, params, paramsCount,version);
  397. return ret;
  398. }
  400. int HqDestSetDeadByPrt(LPDEST_INFO lpDestTmp)
  401. {
  403. if(lpDestTmp->isDead ==FALSE)
  404. {
  405. if(--dest_infos.aliveCount <0) dest_infos.aliveCount =0;
  406. }
  407. shutdown(lpDestTmp->sd,2);
  408. closesocket(lpDestTmp->sd);
  410. lpDestTmp->sd=0;
  411. strcpy(lpDestTmp->userID,"");
  412. lpDestTmp->recNum=0;
  413. lpDestTmp->isDead =TRUE;
  414. lpDestTmp->isUsing=FALSE;
  415. lpDestTmp->inactive =0;
  417. return 0;
  418. }
  420. int HqDestSetDeadBySd(int sd)
  421. {
  422. LPDEST_INFO lpDestTmp;
  423. // int i;
  425. lpDestTmp=GetDestBySd(sd);
  426. if(lpDestTmp!=NULL)
  427. {
  428. //if(!LockDest(lpDestTmp))
  429. //{
  430. //      ErrMsg(ghWndMain,"来自HqDestSetDeadBySd:加锁失败!");
  431. //      return -1;
  432. //}
  433. if(lpDestTmp->isDead ==FALSE)
  434. {
  435. if(--dest_infos.aliveCount <0) dest_infos.aliveCount =0;
  436. }
  437. shutdown(lpDestTmp->sd,2);
  439. //for(i=0;i<10;i++)
  440. //{
  441. // if(closesocket(lpDestTmp->sd)==0)
  442. // break;
  443. // Sleep(100);
  444. //}
  445. closesocket(lpDestTmp->sd);
  447. lpDestTmp->sd=0;
  448. strcpy(lpDestTmp->userID,"");
  449. lpDestTmp->recNum=0;
  450. lpDestTmp->isDead =TRUE;
  451. lpDestTmp->isUsing=FALSE;
  452. lpDestTmp->inactive =0;
  453. //UnlockDest(lpDestTmp);
  454. }
  455. return 0;
  456. }
  458. int HqDestStopBySd(sd)
  459. {
  460. LPDEST_INFO lpDestTmp;
  461. // int i;
  463. lpDestTmp=GetDestBySd(sd);
  464. if(lpDestTmp!=NULL)
  465. {
  466. if(lpDestTmp->isDead ==FALSE)
  467. {
  468. if(--dest_infos.aliveCount <0) dest_infos.aliveCount =0;
  469. }
  470. shutdown(lpDestTmp->sd,2);
  471. //for(i=0;i<10;i++)
  472. //{
  473. // if(closesocket(lpDestTmp->sd)==0)
  474. // break;
  475. // Sleep(100);
  476. //}
  477. closesocket(lpDestTmp->sd);
  479. lpDestTmp->isDead =TRUE;
  480. lpDestTmp->sd=0;
  481. strcpy(lpDestTmp->userID,"");
  482. lpDestTmp->recNum=0;
  483. lpDestTmp->isUsing=FALSE;
  484. lpDestTmp->inactive =0;
  485. }
  486. return 0;
  487. }
  489. LPDEST_INFO GetDestByUser(LPSTR userID)
  490. {
  491. int i;
  492. LPDEST_INFO lpDestTmp;
  494. lpDestTmp =dest_infos.lpDestHead;
  496. for(i =0; i<dest_infos.destCount; i++)
  497. {
  498. if(!lpDestTmp) break;
  499. if(strcmp(lpDestTmp->userID, userID) ==0)
  500. {
  501. return lpDestTmp; 
  502. }
  503. lpDestTmp =lpDestTmp->lpNext;
  504. }
  506. return NULL;
  507. }
  509. LPDEST_INFO GetDestBySd(int sd)
  510. {
  511. int i;
  512. LPDEST_INFO lpDestTmp;
  514. for(i =0; i<dest_info_count; i++)
  515. {
  516. lpDestTmp=&dest_info[i];
  517. if(!lpDestTmp) break;
  518. if(lpDestTmp->sd==sd)
  519. {
  520. return lpDestTmp;
  521. }
  522. }
  524. return NULL;
  525. }
  527. LPDEST_INFO GetAnotherUserById(char *Id,int sd)
  528. {
  529. int i;
  530. LPDEST_INFO lpDestTmp;
  532. for(i =0; i<dest_info_count; i++)
  533. {
  534. lpDestTmp=&dest_info[i];
  535. if(!lpDestTmp) break;
  536. if(lpDestTmp->sd!=sd&&strncmp(Id,lpDestTmp->userID,6)==0)
  537. {
  538. return lpDestTmp;
  539. }
  540. }
  542. return NULL;
  543. }
  544. LPDEST_INFO HqDestSendClose()
  545. {
  546. int i;
  547. LPDEST_INFO lpDestTmp;
  549. for(i =0; i<dest_infos.destCount; i++)
  550. {
  551. lpDestTmp=&dest_info[i];
  552. if(lpDestTmp)
  553. {
  554. if(!lpDestTmp->isDead)
  555. SendMsg(lpDestTmp->sd, "服务器开始关闭!");
  556. }
  557. }
  559. for(i =0; i<dest_infos.destCount; i++)
  560. {
  561. lpDestTmp=&dest_info[i];
  563. if(lpDestTmp)
  564. HqDestSetDeadByPrt(lpDestTmp);
  565. }
  566. return lpDestTmp;
  567. }
  569. LPDEST_INFO GetFirstDeadDest(void)
  570. {
  571. int i;
  572. LPDEST_INFO lpDestTmp;
  574. for(i =0; i<dest_info_count; i++)
  575. {
  576. lpDestTmp=&dest_info[i];
  577. if(!lpDestTmp) break;
  578. if(lpDestTmp->isDead ==TRUE && lpDestTmp-> isUsing==FALSE)
  579. {
  580. lpDestTmp->recNum =0;
  581. strcpy(lpDestTmp->userID,"");
  582. return lpDestTmp;
  583. }
  584. }
  585. return NULL;
  586. }
  588. void DelDeads(void)
  589. {
  590. LPDEST_INFO lpDestPrev, lpDestNext, lpDestTmp;
  591. int i, count =0;
  592. if(dest_infos.aliveCount ==dest_infos.destCount)
  593. return;
  594. lpDestNext =lpDestTmp =dest_infos.lpDestHead;
  595. if(lpDestTmp ==NULL) return;
  597. for(i =0; i<dest_infos.destCount; i++)
  598. {
  599. if(!lpDestTmp) break;
  600. if(!LockDest(lpDestTmp,10)) return ;
  601. lpDestNext =lpDestTmp->lpNext;
  602. if(!LockDest(lpDestNext,10)) return ;
  603. if(lpDestTmp->isDead)
  604. {
  605. lpDestTmp->isDead =TRUE;
  606. if(lpDestTmp ==dest_infos.lpDestHead)
  607. dest_infos.lpDestHead =lpDestNext;
  608. else lpDestPrev->lpNext =lpDestNext;
  609. GlobalUnlock(GlobalHandle(lpDestTmp->params));
  610. GlobalFree(GlobalHandle(lpDestTmp->params));
  611. lpDestTmp->paramsCount =0;
  612. if(lpDestTmp->lpCjss)
  613. {                               
  614. GlobalUnlock(GlobalHandle(lpDestTmp->lpCjss));
  615. GlobalFree(GlobalHandle(lpDestTmp->lpCjss));
  616. }
  617. lpDestTmp->lpCjss =NULL;
  618. if(lpDestTmp->lpGraph)
  619. {
  620. GlobalUnlock(GlobalHandle(lpDestTmp->lpGraph));
  621. GlobalFree(GlobalHandle(lpDestTmp->lpGraph));
  622. }
  623. lpDestTmp->lpGraph =NULL;
  624. if(lpDestTmp->lpZsGraph)
  625. {
  626. GlobalUnlock(GlobalHandle(lpDestTmp->lpZsGraph));
  627. GlobalFree(GlobalHandle(lpDestTmp->lpZsGraph));
  628. }
  629. lpDestTmp->lpZsGraph =NULL;
  630. count++;
  631. }
  632. else
  633. lpDestPrev =lpDestTmp;
  634. UnlockDest(lpDestTmp);
  635. UnlockDest(lpDestNext);
  636. lpDestTmp =lpDestNext;
  637. }
  638. dest_infos.destCount -=count;
  639. }
  641. void FreeDest(void)
  642. {
  643. LPDEST_INFO lpDestTmp;
  644. int i;
  646. for(i =0; i<MAX_USER_COUNT; i++)
  647. {
  648. lpDestTmp =&dest_info[i];       
  649. if(lpDestTmp ==NULL) 
  650. continue;
  651. if(lpDestTmp->params)
  652. {
  653. GlobalUnlock(GlobalHandle(lpDestTmp->params));
  654. GlobalFree(GlobalHandle(lpDestTmp->params));
  655. }
  656. if(lpDestTmp->lpCjss) 
  657. {
  658. GlobalUnlock(GlobalHandle(lpDestTmp->lpCjss));
  659. GlobalFree(GlobalHandle(lpDestTmp->lpCjss));
  660. }
  661. if(lpDestTmp->lpGraph)
  662. {
  663. GlobalUnlock(GlobalHandle(lpDestTmp->lpGraph));
  664. GlobalFree(GlobalHandle(lpDestTmp->lpGraph));
  665. }
  666. if(lpDestTmp->lpZsGraph)
  667. {
  668. GlobalUnlock(GlobalHandle(lpDestTmp->lpZsGraph));
  669. GlobalFree(GlobalHandle(lpDestTmp->lpZsGraph));
  670. }
  671. }
  672. dest_info_count =0;
  673. }
  675. int check_socket_status(int sd)
  676. {
  677. struct timeval wait;
  678. fd_set send_ready,except;
  680. wait.tv_sec =wait.tv_usec=0;
  681. FD_ZERO(&send_ready);
  682. FD_ZERO(&except);
  683. FD_SET(sd,&send_ready);
  684. FD_SET(sd,&except);
  685. if(select(FD_SETSIZE,(fd_set *)0,&send_ready,
  686. &except,&wait)<0)
  687. return(-1);
  688. if(FD_ISSET(sd,&send_ready))
  689. return(0);
  690. else if(FD_ISSET(sd,&except))
  691. return(-2);
  692. else
  693. return(-3);
  694. }
  697. long TF_ScanDest(void)
  698. {
  699. int i,j,ret,jys;
  700. LPDEST_INFO lpDestNext;
  701. DP_MAIN DpMain[2];
  703. while(1)
  704. {
  705. if(run_cancelled) break;
  707. if(IsClectRun)
  708. {
  709. if(clCheckTime(TRUE) >=0)
  710. {
  711. if(HqTime[0].fRunning)
  712. {
  713. if(!RefreshHqData(0))
  714. {
  715. MsgLocal("深圳行情刷新失败，重新启动");
  716. HqTime[0].fRunning =FALSE;
  717. CloseDbfFile(0);
  718. }
  719. CreateLzwMemData(0);
  720. }
  721. if(HqTime[1].fRunning)  
  722. {
  723. if(!RefreshHqData(1))
  724. {
  725. MsgLocal("上海行情刷新失败，重新启动");
  726. HqTime[1].fRunning =FALSE;
  727. CloseDbfFile(1);                                
  728. }
  729. CreateLzwMemData(1);
  730. }
  731. }       
  732. }
  733. else
  734. {
  735. RefreshHq(0);
  736. RefreshHq(1);
  737. }
  739. MsgLocal("扫描行情用户...");
  740. for(i =0,j=0; i<dest_info_count; i++)
  741. {
  742. if(run_cancelled) break;
  743. lpDestNext=&dest_info[i];
  745. if(!lpDestNext) 
  746. break;
  747. if(lpDestNext->isDead)
  748. continue;
  750. lpDestNext->inactive++;
  751. ret =check_socket_status(lpDestNext->sd);
  752. if(ret ==0)
  753. {
  754. if(!xLockDest(lpDestNext,3))
  755. continue;
  757. switch(lpDestNext->reqType)
  758. {
  759. case REQ_HQ01:
  760. Delay_Send_Hq01(lpDestNext);
  761. UnlockDest(lpDestNext);
  762. break;
  763. case REQ_HQ10:
  764. if(lpDestNext->version <12)
  765. {
  766. ret =UDP_Server_Send_Hq10(lpDestNext);
  767. UnlockDest(lpDestNext);
  768. }
  769. if(lpDestNext->version ==12)
  770. ret =Send_Hq10(lpDestNext);
  771. if(ret<0) continue;
  772. break;
  773. case REQ_GRA10:
  774. if(lpDestNext->version <12)
  775. {
  776. ret =UDP_Server_Send_Gra10(lpDestNext);
  777. UnlockDest(lpDestNext);
  778. }
  779. if(lpDestNext->version ==12)
  780. ret =Send_Gra10(lpDestNext);
  781. if(ret<0) continue;
  782. break;
  783. default:
  784. UnlockDest(lpDestNext);
  785. break;
  786. }       
  787. //}
  788.     FillDpMain(&DpMain[0]);
  789. //if(ret ==0)
  790. //{
  791. if(memcmp(&lpDestNext->DpData, &DpMain, sizeof(DpMain))||
  792. lpDestNext->inactive>10)
  793. {
  794. if(UDP_Server_Send_Dp(lpDestNext->sd,NULL, FALSE,lpDestNext) >0)
  795. memcpy(&lpDestNext->DpData, &DpMain, sizeof(DpMain));                   
  796. if(lpDestNext->inactive>10)
  797. lpDestNext->inactive =0;
  798. }
  799. }
  800. else
  801. {
  802. if(ret == -2) HqDestStopBySd(lpDestNext->sd);
  803. }
  805. j++;
  806. }
  807. SetHqUsers(j);
  808. Sleep(2000);
  809. }
  811. if(IsClectRun)
  812. {
  813. for(jys =0;jys<2;jys++)
  814. {
  815. WriteHqData(jys);
  816. WriteMmpData(jys);
  817. WriteMaxMinData(jys);
  818. WriteDpData(jys);
  819. }
  820. SetEvent(g_hEventDataWrite);
  821. }
  823. ExitThread(0);
  824. return 0;
  825. }
  828. int CreateScanDestThread(void)
  829. {
  830.       LONG lThreadId;
  832. hThrdScanDest =CreateThread(NULL, 0,
  833.       (LPTHREAD_START_ROUTINE)TF_ScanDest,
  834.       NULL, CREATE_SUSPENDED, (LPDWORD)&lThreadId);
  835. if(!hThrdScanDest) return -1;
  836. //SetThreadPriority(hThrdScanDest, THREAD_PRIORITY_NORMAL);
  837. SetThreadPriority(hThrdScanDest, THREAD_PRIORITY_ABOVE_NORMAL);
  839. ResumeThread(hThrdScanDest);
  841. return 0;
  842. }
  844. int FillDpMain(LPDP_MAIN lpDpMain)
  845. {
  846. int jys;
  848. for(jys =0; jys<2; jys++)
  849. {
  850. lpDpMain[jys].zs =DpData[jys].zs[0];
  851. lpDpMain[jys].zd =DpData[jys].zd[0];
  852. lpDpMain[jys].cjzje =DpData[jys].cjzje;
  853. lpDpMain[jys].npbl =DpData[jys].npbl;
  854. lpDpMain[jys].cjss =DpData[jys].cjss;
  855. lpDpMain[jys].upCount =DpData[jys].upCount;
  856. lpDpMain[jys].downCount =DpData[jys].downCount;
  857. lpDpMain[jys].equalCount =DpData[jys].equalCount;
  858. }
  860. return 0;
  861. }
  863. extern BOOL FileTranLock;
  865. BOOL GetNewsIndex(char * szNewsDir)
  866. {
  867. HFILE hFile;
  868. OFSTRUCT os;
  869. char file[80],search[128],content[200];
  870.     WIN32_FIND_DATA FindData;
  871.     HANDLE hFindFile;
  872. BOOL fFind;
  873. SYSTEMTIME SysTime;
  874. BOOL ret =FALSE;
  876. sprintf(file,"%s\news.idx",szDataPath);
  877. hFile =OpenFile(file, &os, OF_SHARE_DENY_READ|OF_WRITE|OF_CREATE);
  878. if(hFile ==HFILE_ERROR) 
  879. return ret;
  880. sprintf(search,"%s\*.*",szNewsDir);
  881. hFindFile =FindFirstFile(search,&FindData);
  882. if(hFindFile!=INVALID_HANDLE_VALUE)
  883. {
  884. FileTimeToSystemTime((FILETIME *)&FindData.ftLastWriteTime,
  885. (SYSTEMTIME*)&SysTime);
  886. sprintf(content,"%12s %ld.%02ld.%02ld %02ld.%02ld:%02ld %ldn",
  887. FindData.cFileName,
  888. SysTime.wYear,
  889. SysTime.wMonth,
  890. SysTime.wDay,
  891. SysTime.wHour,
  892. SysTime.wMinute,
  893. SysTime.wSecond,
  894. FindData.nFileSizeLow +FindData.nFileSizeHigh *256);
  895. if(FindData.dwFileAttributes!=FILE_ATTRIBUTE_DIRECTORY) 
  896. {
  897. _lwrite(hFile,content,strlen(content));
  898. ret =TRUE;
  899. }
  900. do
  901. {
  902. fFind =FindNextFile(hFindFile,&FindData);
  903. if(fFind)
  904. {
  905. FileTimeToSystemTime((FILETIME *)&FindData.ftLastWriteTime,
  906. (SYSTEMTIME*)&SysTime);
  907. sprintf(content,"%12s %ld.%02ld.%02ld %02ld.%02ld:%02ld %ldn",
  908. FindData.cFileName,
  909. SysTime.wYear,
  910. SysTime.wMonth,
  911. SysTime.wDay,
  912. SysTime.wHour,
  913. SysTime.wMinute,
  914. SysTime.wSecond,
  915. FindData.nFileSizeLow +FindData.nFileSizeHigh *256);                    
  916. if(FindData.dwFileAttributes!=FILE_ATTRIBUTE_DIRECTORY) 
  917. {
  918. _lwrite(hFile,content,strlen(content));
  919. ret =TRUE;
  920. }
  921. }
  922. }while(fFind);
  923. FindClose(hFindFile);
  924. }
  925. _lclose(hFile);
  926. return ret;
  927. }
  929. void DelNews(LPSTR szNewsDir)
  930. {
  931. char file[128],search[128];
  932.     WIN32_FIND_DATA FindData;
  933.     HANDLE hFindFile;
  934. BOOL fFind;
  936. sprintf(search,"%s\*.*",szNewsDir);
  937. hFindFile =FindFirstFile(search,&FindData);
  938. if(hFindFile!=INVALID_HANDLE_VALUE)
  939. {
  940. sprintf(file,"%s\%s",szNewsDir,FindData.cFileName);
  941. if(FindData.dwFileAttributes!=FILE_ATTRIBUTE_DIRECTORY) 
  942. DeleteFile(file);
  943. do
  944. {
  945. fFind =FindNextFile(hFindFile,&FindData);
  946. if(fFind)
  947. {
  948. sprintf(file,"%s\%s",szNewsDir,FindData.cFileName);
  949. if(FindData.dwFileAttributes!=FILE_ATTRIBUTE_DIRECTORY) 
  950. DeleteFile(file);
  951. }
  952. }while(fFind);
  953. FindClose(hFindFile);
  954. }
  955. }
  957. void MoveNews(LPSTR szNewsTo,LPSTR szNewsFrom)
  958. {
  960. char to[128],search[128],from[128],temp[128];
  961.     WIN32_FIND_DATA FindData;
  962.     HANDLE hFindFile;
  963. BOOL fFind;
  964. OFSTRUCT os;
  965. SYSTEMTIME CurDate,FileDate;
  967. if(szNewsTo[0]==0||szNewsFrom[0]==0) 
  968. return;
  969. GetSystemTime(&CurDate);
  970. sprintf(search,"%s\*.*",szNewsFrom);
  971. hFindFile =FindFirstFile(search,&FindData);
  972. if(hFindFile!=INVALID_HANDLE_VALUE)
  973. {
  974. sprintf(to,"%s\%s",szNewsTo,FindData.cFileName);
  975. sprintf(from,"%s\%s",szNewsFrom,FindData.cFileName);
  976. FileTimeToSystemTime((FILETIME *)&FindData.ftLastWriteTime,
  977. (SYSTEMTIME*)&FileDate);
  979. if(FindData.dwFileAttributes!=FILE_ATTRIBUTE_DIRECTORY &&
  980. FileDate.wMonth ==CurDate.wMonth &&
  981. FileDate.wDay ==CurDate.wDay) 
  982. {
  983. strcpy(temp,FindData.cFileName);
  984. strupr(temp);
  985. if(strstr(temp,".DBF")==NULL&&strstr(temp,".EXE")==NULL)
  986. {
  987. if(strstr(ZxDataFile,temp)==NULL)
  988. {
  989. CopyFile(from,to,TRUE);                 
  990. if(gfIsNewsSrcDel) DeleteFile(from);
  991. }
  992. else
  993. {
  994. _lclose(hfZx);
  995. CopyFile(from,ZxDataFile,TRUE);
  996. DeleteFile(from);
  997. hfZx =OpenFile(ZxDataFile, &os, OF_SHARE_DENY_NONE|OF_READ);
  998. }
  999. }
  1000. }
  1002. do
  1003. {
  1004. fFind =FindNextFile(hFindFile,&FindData);
  1005. if(fFind)
  1006. {
  1007. sprintf(to,"%s\%s",szNewsTo,FindData.cFileName);
  1008. sprintf(from,"%s\%s",szNewsFrom,FindData.cFileName);
  1010. FileTimeToSystemTime((FILETIME *)&FindData.ftLastWriteTime,
  1011. (SYSTEMTIME*)&FileDate);
  1013. if(FindData.dwFileAttributes!=FILE_ATTRIBUTE_DIRECTORY &&
  1014. FileDate.wMonth==CurDate.wMonth &&
  1015. FileDate.wDay ==CurDate.wDay) 
  1016. {
  1017. strcpy(temp,FindData.cFileName);
  1018. strupr(temp);
  1019. if(strstr(temp,".DBF")==NULL&&strstr(temp,".EXE")==NULL)
  1020. {
  1021. if(strstr(ZxDataFile,temp)==NULL)
  1022. {
  1023. CopyFile(from,to,TRUE);
  1024. if(gfIsNewsSrcDel) DeleteFile(from);
  1025. }
  1026. else
  1027. {
  1028. _lclose(hfZx);
  1029. CopyFile(from,ZxDataFile,TRUE);
  1030. DeleteFile(from);
  1031. hfZx =OpenFile(ZxDataFile, &os, OF_SHARE_DENY_NONE|OF_READ);
  1032. }
  1033. }
  1034. }
  1035. }
  1036. }while(fFind);
  1037. FindClose(hFindFile);
  1038. }
  1039. }
  1041. void RefreshNews(LPSTR szNewsTo,LPSTR szNewsFrom)
  1042. {
  1043. char to[128],search[128],from[128],temp[200];
  1044.     WIN32_FIND_DATA FindData;
  1045.     HANDLE hFindFile ;
  1046. HFILE hFile;
  1047. BOOL fFind;
  1048. OFSTRUCT os;
  1049. SYSTEMTIME CurDate,FileDate;
  1051. if(szNewsTo[0]==0||szNewsFrom[0]==0) 
  1052. return;
  1053. sprintf(temp,"%s\news.idx",szDataPath);
  1054. hFile =OpenFile(temp, &os, OF_SHARE_DENY_NONE|OF_WRITE);
  1055. if(hFile ==HFILE_ERROR)
  1056. return;
  1057. if(_llseek(hFile, 0, SEEK_END)==HFILE_ERROR)
  1058. {
  1059. _lclose(hFile);
  1060. return;
  1061. }
  1063. GetSystemTime(&CurDate);
  1064. sprintf(search,"%s\*.*",szNewsFrom);
  1065. hFindFile =FindFirstFile(search,&FindData);
  1066. if(hFindFile!=INVALID_HANDLE_VALUE)
  1067. {
  1068. sprintf(to,"%s\%s",szNewsTo,FindData.cFileName);
  1069. sprintf(from,"%s\%s",szNewsFrom,FindData.cFileName);
  1070. FileTimeToSystemTime((FILETIME *)&FindData.ftLastWriteTime,
  1071. (SYSTEMTIME*)&FileDate);
  1073. if(FileDate.wMonth ==CurDate.wMonth &&
  1074. FileDate.wDay ==CurDate.wDay) 
  1075. {
  1076. strcpy(temp,FindData.cFileName);
  1077. strupr(temp);                   
  1078. if(strstr(ZxDataFile,temp)==NULL&&strstr(temp,".DBF")==NULL
  1079. &&strstr(temp,".EXE")==NULL)
  1080. {
  1081. if(CopyFile(from,to,TRUE))
  1082. {
  1083. sprintf(temp,"%12s %ld.%02ld.%02ld %02ld.%02ld:%02ld %ldn",
  1084. FindData.cFileName,
  1085. FileDate.wYear,
  1086. FileDate.wMonth,
  1087. FileDate.wDay,
  1088. FileDate.wHour,
  1089. FileDate.wMinute,
  1090. FileDate.wSecond,
  1091. FindData.nFileSizeLow +FindData.nFileSizeHigh *256);
  1092. _lwrite(hFile,temp,strlen(temp));
  1093. }
  1094. if(gfIsNewsSrcDel) DeleteFile(from);
  1095. }
  1096. }
  1097. do
  1098. {
  1099. fFind =FindNextFile(hFindFile,&FindData);
  1100. if(fFind)
  1101. {
  1102. sprintf(to,"%s\%s",szNewsTo,FindData.cFileName);
  1103. sprintf(from,"%s\%s",szNewsFrom,FindData.cFileName);
  1105. FileTimeToSystemTime((FILETIME *)&FindData.ftLastWriteTime,
  1106. (SYSTEMTIME*)&FileDate);
  1108. if(FileDate.wMonth==CurDate.wMonth &&
  1109. FileDate.wDay ==CurDate.wDay) 
  1110. {
  1111. strcpy(temp,FindData.cFileName);
  1112. strupr(temp);
  1113. if(strstr(ZxDataFile,temp)==NULL&&strstr(temp,".DBF")==NULL
  1114. &&strstr(temp,".EXE")==NULL)
  1115. {
  1116. if(CopyFile(from,to,TRUE))
  1117. {
  1118. sprintf(temp,"%12s %ld.%02ld.%02ld %02ld.%02ld:%02ld %ldn",
  1119. FindData.cFileName,
  1120. FileDate.wYear,
  1121. FileDate.wMonth,
  1122. FileDate.wDay,
  1123. FileDate.wHour,
  1124. FileDate.wMinute,
  1125. FileDate.wSecond,
  1126. FindData.nFileSizeLow +FindData.nFileSizeHigh *256);
  1127. _lwrite(hFile,temp,strlen(temp));
  1128. }
  1129. if(gfIsNewsSrcDel) DeleteFile(from);
  1130. }
  1131. }
  1132. }
  1133. }while(fFind);
  1134. FindClose(hFindFile);           
  1135. }       
  1136. _lclose(hFile);
  1137. }
  1139. long TF_NewsManager(void)
  1140. {
  1141. SYSTEMTIME SysTime;
  1142. static BOOL IsInit =FALSE;
  1143. int minute ;
  1145. while(1)
  1146. {
  1147. if(run_cancelled) break;
  1148. GetLocalTime(&SysTime);
  1149. minute = SysTime.wHour*60+SysTime.wMinute;
  1150. if(minute<HqTime[0].am_min_start)
  1151. IsInit =FALSE;
  1152. else
  1153. {
  1154. if(!IsInit)
  1155. {
  1156. if(!FileTranLock)
  1157. {
  1158. FileTranLock =TRUE;
  1159. Sleep(3000);
  1160. DelNews(szNewsPath);
  1161. }
  1162. MoveNews(szNewsPath,szNewsSrc);
  1163. if(GetNewsIndex(szNewsPath))
  1164. {
  1165. IsInit =TRUE;   
  1166. FileTranLock =FALSE;
  1167. }
  1168. }
  1169. else
  1170. {
  1171. RefreshNews(szNewsPath,szNewsSrc);
  1172. }
  1173. }
  1174. Sleep(1000*60);
  1175. }
  1176. CloseHandle(hNewsManager);
  1177. ExitThread(0);
  1178. return 0;
  1179. }
  1181. int CreateNewsManagerThread(void)
  1182. {
  1183.       LONG lThreadId;
  1185. hNewsManager =CreateThread(NULL, 0,
  1186.       (LPTHREAD_START_ROUTINE)TF_NewsManager,
  1187.       NULL, CREATE_SUSPENDED, (LPDWORD)&lThreadId);
  1188. if(!hNewsManager) return -1;
  1189. SetThreadPriority(hNewsManager, THREAD_PRIORITY_NORMAL);
  1191. ResumeThread(hNewsManager);
  1193. return 0;
  1194. }