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

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

金融证券系统

开发平台：

Visual C++

HQDEST.C：源码内容
  1. #include <windows.h>
  2. #include "hq.h"
  3. #include "pctcp.h"
  4. #include "hqdest.h"
  6. DEST_INFOS dest_infos;
  7. BOOL fDestInited =FALSE;
  8. HANDLE hThrdScanDest =NULL;
  10. void FreeDest(void);
  11. LPDEST_INFO GetDest(struct sockaddr *dest);
  12. LPDEST_INFO GetDestByUser(LPSTR userID);
  13. LPDEST_INFO GetFirstDeadDest(void);
  14. int FillDpMain(LPDP_MAIN lpDpMain);
  16. extern HWND ghWndMain;
  17. extern BOOL run_cancelled;
  18. extern void ErrMsg(HWND, LPSTR);
  19. extern int UDP_Server_Send_Hq10(LPDEST_INFO);
  20. extern int UDP_Server_Send_Gra10(LPDEST_INFO);
  21. extern int UDP_Server_Send_Dp(struct sockaddr *, BOOL);
  22. extern void HqResetChangedTimes(void);
  23. extern void SetHqUsers(int);
  24. extern BOOL IsZsRec(int, short);
  25. extern int sdHq;
  26. extern void SendMsg(int sd, LPSTR lpMsg, struct sockaddr * lpdest);
  27. BOOL DestInit(void)
  28. {
  29. fDestInited =TRUE;
  30. memset(&dest_infos, 0, sizeof(dest_infos));
  31. return TRUE;
  32. }
  34. void DestExit(void)
  35. {
  36. if(!fDestInited) return;
  37. fDestInited =FALSE;
  38. FreeDest();
  39. if(hThrdScanDest) CloseHandle(hThrdScanDest);
  40. }
  42. long GetDestCount(void)
  43. {
  44. return MAKELONG(dest_infos.destCount, dest_infos.aliveCount);
  45. }
  47. int HqDestActiveUsr(int sd, struct sockaddr *lpdest, LPSTR userID)
  48. {
  49. LPDEST_INFO lpDestTmp, lpDestTmp1;
  51. lpDestTmp =GetDest(lpdest);
  52. if(lpDestTmp ==NULL)return -1;
  53. lpDestTmp1 =GetDestByUser(userID);
  54. if(lpDestTmp1 !=NULL)
  55. {
  56. if(lpDestTmp1->isDead ==FALSE)
  57. {
  58. if(((struct sockaddr_in *)&lpDestTmp1->dest)->sin_addr.s_addr
  59. !=((struct sockaddr_in *)lpdest)->sin_addr.s_addr)
  60. SendMsg(sd, "Another user using your userID, killed it!", lpdest);
  61. lpDestTmp1->isDead =TRUE;
  62. return 1;
  63. }
  64. }
  65. strcpy(lpDestTmp->userID, userID);
  66. lpDestTmp->isDead =FALSE;
  68. return 0;
  69. }
  71. int AddDest(int sd, struct sockaddr *dest, int curJys,
  72. int reqType, short *params, short paramsCount)
  73. {
  74. int i;
  75. LPDEST_INFO lpDestNext, lpDestTmp;
  76. LPDEST_INFO *lpDestNew =NULL;
  77. //while(dest_infos.isUsing ==TRUE);
  78. //dest_infos.isUsing =TRUE;
  80. lpDestNext =dest_infos.lpDestHead;
  81. lpDestNew =&dest_infos.lpDestHead;
  83. for(i =0; i<dest_infos.destCount; i++)
  84. {
  85. if(!lpDestNext) break;
  86. lpDestNew =&lpDestNext->lpNext;
  87. lpDestNext =lpDestNext->lpNext;
  88. }
  90. lpDestTmp = malloc(sizeof(DEST_INFO));
  91. if(lpDestTmp ==NULL)
  92. {
  93. ErrMsg(ghWndMain, "addDest: alloc dest_info failed!");
  94. return -1;
  95. }
  96. memset(lpDestTmp, 0, sizeof(DEST_INFO));
  97. lpDestTmp->sd =sd;
  98. lpDestTmp->curJys =curJys;
  99. lpDestTmp->reqType =reqType;
  100. lpDestTmp->isDead =FALSE;
  101. lpDestTmp->isEchoed =TRUE;
  102. lpDestTmp->params =(short *)malloc(paramsCount*sizeof(short));
  103. if(lpDestTmp->params ==NULL)
  104. {
  105. free(lpDestTmp);
  106. ErrMsg(ghWndMain, "addDest: alloc params failed!");
  107. return -1;
  108. }
  109. memcpy(lpDestTmp->params, params, sizeof(short)*paramsCount);
  110. if(reqType ==REQ_HQ10)
  111. {
  112. lpDestTmp->lpCjss =(int *)malloc(params[0]*sizeof(int));
  113. if(lpDestTmp->lpCjss ==NULL)
  114. {
  115. free(lpDestTmp->params);
  116. free(lpDestTmp);
  117. ErrMsg(ghWndMain, "addDest: alloc lpCjss failed!");
  118. return -1;
  119. }
  120. for(i =0; i<params[0]; i++)
  121. {
  122. lpDestTmp->lpCjss[i] =HqData[curJys].lpRefData[params[i+1]].cjss;
  123. }
  124. }
  125. else if(reqType ==REQ_GRA10)
  126. {
  127. if(lpDestTmp->lpCjss)
  128. {
  129. free(lpDestTmp->lpCjss);
  130. lpDestTmp->lpCjss =NULL;
  131. }
  132. if(IsZsRec(curJys, params[0]))
  133. {
  134. lpDestTmp->lpZsGraph =malloc(sizeof(ZS_GRAPH));
  135. if(lpDestTmp->lpZsGraph ==NULL)
  136. {
  137. free(lpDestTmp->params);
  138. free(lpDestTmp);
  139. ErrMsg(NULL, "alloc zsgraph failed!");
  140. return -1;
  141. }
  142. memcpy(lpDestTmp->lpZsGraph->Maxmin, MaxMinData[curJys],
  143. sizeof(MAXMIN_DATA)*2);
  144. }
  145. else
  146. {
  147. lpDestTmp->lpGraph =(LPGRAPH)malloc(sizeof(GRAPH));
  148. if(lpDestTmp->lpGraph ==NULL)
  149. {
  150. free(lpDestTmp->params);
  151. free(lpDestTmp);
  152. ErrMsg(NULL, "alloc graph failed!");
  153. return -1;
  154. }
  155. memcpy(&lpDestTmp->lpGraph->mmp, &MmpData[curJys].lpMmp[params[0]],
  156. sizeof(MMP));
  157. }
  158. lpDestTmp->cjss =HqData[curJys].lpRefData[params[0]].cjss;
  159. }
  160. else
  161. {
  162. free(lpDestTmp->params);
  163. free(lpDestTmp);
  164. return -1;
  165. }
  167. FillDpMain(&lpDestTmp->DpData[0]);
  169. lpDestTmp->paramsCount =paramsCount;
  170. memcpy(&lpDestTmp->dest, dest, sizeof(struct sockaddr));
  171. lpDestTmp->isDead =TRUE;
  172. *lpDestNew =lpDestTmp;
  174. dest_infos.destCount ++;
  175. dest_infos.aliveCount ++;
  176. //dest_infos.isUsing =FALSE;
  178. return 0;
  179. }
  181. int ChangeDest(int sd, LPDEST_INFO lpDestTmp, struct sockaddr *dest, int curJys,
  182. int reqType, short *params, short paramsCount)
  183. {
  184. int i;
  186. if(lpDestTmp ==NULL) return 0;
  188. //while(dest_infos.isUsing ==TRUE);
  189. //while(lpDestTmp->isUsing ==TRUE);
  191. dest_infos.isUsing =TRUE;
  192. lpDestTmp->isUsing =TRUE;
  194. lpDestTmp->isDead =TRUE;
  195. lpDestTmp->paramsCount =0;
  196. if(--dest_infos.aliveCount<0) dest_infos.aliveCount =0;
  197. SetHqUsers(dest_infos.aliveCount);
  199. lpDestTmp->sd =sd;
  200. lpDestTmp->curJys =curJys;
  201. lpDestTmp->reqType =reqType;
  202. lpDestTmp->isEchoed =TRUE;
  203. if(lpDestTmp->paramsCount <paramsCount)
  204. lpDestTmp->params =(short *)realloc(lpDestTmp->params, paramsCount*sizeof(short));
  205. if(lpDestTmp->params ==NULL)
  206. {
  207. ErrMsg(ghWndMain, "ChangeDest: alloc params failed!");
  208. dest_infos.isUsing =FALSE;
  209. lpDestTmp->isUsing =FALSE;
  210. return -1;
  211. }
  212. if(reqType ==REQ_HQ10)
  213. {
  214. /*if(lpDestTmp->lpGraph)
  215. {
  216. free(lpDestTmp->lpGraph);
  217. lpDestTmp->lpGraph =NULL;
  218. }
  219. if(lpDestTmp->lpZsGraph)
  220. {
  221. free(lpDestTmp->lpZsGraph);
  222. lpDestTmp->lpZsGraph =NULL;
  223. }*/
  224. if(lpDestTmp->params[0] <params[0])
  225. lpDestTmp->lpCjss =(int *)realloc(lpDestTmp->lpCjss, params[0]*sizeof(int));
  226. if(lpDestTmp->lpCjss ==NULL)
  227. {
  228. ErrMsg(ghWndMain, "ChangeDest: alloc lpCjss failed!");
  229. dest_infos.isUsing =FALSE;
  230. lpDestTmp->isUsing =FALSE;
  231. return -1;
  232. }
  233. for(i =0; i<params[0]; i++)
  234. {
  235. lpDestTmp->lpCjss[i] =HqData[curJys].lpRefData[params[i+1]].cjss;
  236. }
  237. }
  238. else if(reqType ==REQ_GRA10)
  239. {
  240. /*if(lpDestTmp->lpCjss)
  241. {
  242. free(lpDestTmp->lpCjss);
  243. lpDestTmp->lpCjss =NULL;
  244. }*/
  245. if(IsZsRec(curJys, params[0]))
  246. {
  247. /*if(lpDestTmp->lpGraph)
  248. {
  249. free(lpDestTmp->lpGraph);
  250. lpDestTmp->lpGraph =NULL;
  251. }*/
  252. if(lpDestTmp->lpZsGraph ==NULL)
  253. {
  254. lpDestTmp->lpZsGraph =malloc(sizeof(ZS_GRAPH));
  255. if(lpDestTmp->lpZsGraph ==NULL)
  256. {
  257. ErrMsg(NULL, "alloc zsgraph failed!");
  258. return -1;
  259. }
  260. }
  261. memcpy(lpDestTmp->lpZsGraph->Maxmin, MaxMinData[curJys],
  262. sizeof(MAXMIN_DATA)*2);
  263. }
  264. else
  265. {
  266. /*if(lpDestTmp->lpZsGraph)
  267. {
  268. free(lpDestTmp->lpZsGraph);
  269. lpDestTmp->lpZsGraph =NULL;
  270. }*/
  271. if(lpDestTmp->lpGraph ==NULL)
  272. {
  273. lpDestTmp->lpGraph =(LPGRAPH)malloc(sizeof(GRAPH));
  274. if(lpDestTmp->lpGraph ==NULL)
  275. {
  276. ErrMsg(NULL, "alloc graph failed!");
  277. return -1;
  278. }
  279. }
  280. memcpy(&lpDestTmp->lpGraph->mmp, &MmpData[curJys].lpMmp[params[0]],
  281. sizeof(MMP));
  282. }
  283. lpDestTmp->cjss =HqData[curJys].lpRefData[params[0]].cjss;
  284. }
  285. else return -1;
  286. memcpy(lpDestTmp->params, params, sizeof(short)*paramsCount);
  288. FillDpMain(&lpDestTmp->DpData[0]);
  290. memcpy(&lpDestTmp->dest, dest, sizeof(struct sockaddr));
  291. lpDestTmp->paramsCount =paramsCount;
  293. dest_infos.isUsing =FALSE;
  294. lpDestTmp->isUsing =FALSE;
  295. lpDestTmp->isDead =FALSE;
  296. SetHqUsers(++dest_infos.aliveCount);
  297. return 0;
  298. }
  300. int CheckDest(int sd, struct sockaddr *dest, int curJys,
  301. int reqType, short *params, short paramsCount)
  302. {
  303. LPDEST_INFO lpDestTmp;
  305. lpDestTmp =GetDest(dest);
  306. if(lpDestTmp ==NULL)
  307. {
  308. lpDestTmp =GetFirstDeadDest();
  309. if(!lpDestTmp) goto add_dest;
  310. }
  311. if(lpDestTmp->isDead)
  312. dest_infos.aliveCount++;
  313. ChangeDest(sd, lpDestTmp, dest, curJys, reqType,
  314. params, paramsCount);
  315. SetHqUsers(dest_infos.aliveCount);
  316. return 0;
  318. add_dest:
  319. AddDest(sd, dest, curJys, reqType, params, paramsCount);
  320. SetHqUsers(dest_infos.aliveCount);
  322. return 0;
  323. }
  325. void HqDestSetDead(struct sockaddr *lpdest)
  326. {
  327. LPDEST_INFO lpDestTmp;
  329. lpDestTmp =GetDest(lpdest);
  330. if(lpDestTmp)
  331. {
  332. lpDestTmp->isDead =TRUE;
  333. if(--dest_infos.aliveCount <0) dest_infos.aliveCount =0;
  334. SetHqUsers(dest_infos.aliveCount);
  335. }
  336. }
  338. void CheckDestEcho(int sd, struct sockaddr *dest)
  339. {
  340. LPDEST_INFO lpDestTmp;
  342. lpDestTmp =GetDest(dest);
  343. if(lpDestTmp !=NULL)
  344. lpDestTmp->isEchoed =TRUE;
  345. }
  347. LPDEST_INFO GetDest(struct sockaddr *dest)
  348. {
  349. int i;
  350. LPDEST_INFO lpDestTmp;
  352. //while(dest_infos.isUsing ==TRUE);
  353. //dest_infos.isUsing =TRUE;
  355. lpDestTmp =dest_infos.lpDestHead;
  357. for(i =0; i<dest_infos.destCount; i++)
  358. {
  359. if(!lpDestTmp) break;
  360. if(((struct sockaddr_in *)&lpDestTmp->dest)->sin_addr.s_addr
  361. ==((struct sockaddr_in *)dest)->sin_addr.s_addr)
  362. break;
  363. lpDestTmp =lpDestTmp->lpNext;
  364. }
  365. ////////////
  366. //dest_infos.isUsing =FALSE;
  368. return lpDestTmp;
  369. }
  371. LPDEST_INFO GetDestByUser(LPSTR userID)
  372. {
  373. int i;
  374. LPDEST_INFO lpDestTmp;
  376. lpDestTmp =dest_infos.lpDestHead;
  378. for(i =0; i<dest_infos.destCount; i++)
  379. {
  380. if(!lpDestTmp) break;
  381. if(strcmp(lpDestTmp->userID, userID) ==0)
  382. break;
  383. lpDestTmp =lpDestTmp->lpNext;
  384. }
  385. ////////////
  387. return lpDestTmp;
  388. }
  390. LPDEST_INFO HqDestSendClose(int sd, struct sockaddr *dest)
  391. {
  392. int i;
  393. LPDEST_INFO lpDestTmp;
  395. lpDestTmp =dest_infos.lpDestHead;
  397. for(i =0; i<dest_infos.destCount; i++)
  398. {
  399. if(!lpDestTmp) break;
  400. lpDestTmp =lpDestTmp->lpNext;
  401. SendMsg(sd, "Server have closed!", &lpDestTmp->dest);
  402. }
  404. return lpDestTmp;
  405. }
  407. LPDEST_INFO GetFirstDeadDest(void)
  408. {
  409. int i;
  410. LPDEST_INFO lpDestTmp;
  412. while(dest_infos.isUsing ==TRUE);
  413. dest_infos.isUsing =TRUE;
  415. lpDestTmp =dest_infos.lpDestHead;
  417. for(i =0; i<dest_infos.destCount; i++)
  418. {
  419. if(!lpDestTmp) break;
  420. if(lpDestTmp->isDead ==TRUE)
  421. break;
  422. lpDestTmp =lpDestTmp->lpNext;
  423. }
  424. dest_infos.isUsing =FALSE;
  425. return lpDestTmp;
  426. }
  428. void DelDeads(void)
  429. {
  430. LPDEST_INFO lpDestPrev, lpDestNext, lpDestTmp;
  431. int i, count =0;
  432. if(dest_infos.aliveCount ==dest_infos.destCount)
  433. return;
  434. lpDestNext =lpDestTmp =dest_infos.lpDestHead;
  435. if(lpDestTmp ==NULL) return;
  437. while(dest_infos.isUsing ==TRUE);
  439. dest_infos.isUsing =TRUE;
  440. for(i =0; i<dest_infos.destCount; i++)
  441. {
  442. if(!lpDestTmp) break;
  443. lpDestNext =lpDestTmp->lpNext;
  444. if(!lpDestTmp->isEchoed || lpDestTmp->isDead)
  445. {
  446. lpDestTmp->isDead =TRUE;
  447. if(--dest_infos.aliveCount <0) dest_infos.aliveCount =0;
  448. SetHqUsers(dest_infos.aliveCount);
  449. if(lpDestTmp ==dest_infos.lpDestHead)
  450. dest_infos.lpDestHead =lpDestNext;
  451. else lpDestPrev->lpNext =lpDestNext;
  452. free(lpDestTmp->params);
  453. lpDestTmp->paramsCount =0;
  454. if(lpDestTmp->lpCjss) free(lpDestTmp->lpCjss);
  455. lpDestTmp->lpCjss =NULL;
  456. if(lpDestTmp->lpGraph) free(lpDestTmp->lpGraph);
  457. lpDestTmp->lpGraph =NULL;
  458. if(lpDestTmp->lpZsGraph) free(lpDestTmp->lpZsGraph);
  459. lpDestTmp->lpZsGraph =NULL;
  460. free(lpDestTmp);
  461. count++;
  462. }
  463. else
  464. lpDestPrev =lpDestTmp;
  465. lpDestTmp =lpDestNext;
  466. }
  467. dest_infos.destCount -=count;
  468. dest_infos.isUsing =FALSE;
  470. }
  472. void FreeDest(void)
  473. {
  474. LPDEST_INFO lpDestNext, lpDestTmp;
  475. int i;
  477. lpDestNext =lpDestTmp =dest_infos.lpDestHead;
  479. while(dest_infos.isUsing ==TRUE);
  481. dest_infos.isUsing =TRUE;
  482. for(i =0; i<dest_infos.destCount; i++)
  483. {
  484. if(lpDestTmp ==NULL) break;
  485. lpDestNext =lpDestTmp->lpNext;
  486. if(lpDestTmp->params)
  487. free(lpDestTmp->params);
  488. if(lpDestTmp->lpCjss) free(lpDestTmp->lpCjss);
  489. free(lpDestTmp);
  490. lpDestTmp =lpDestNext;
  491. }
  493. dest_infos.destCount =0;
  494. dest_infos.isUsing =FALSE;
  495. }
  497. // can use WM_TIMER to run this function
  498. long TF_ScanDest(void)
  499. {
  500. int i;
  501. LPDEST_INFO lpDestNext;
  502. DP_MAIN DpMain[2];
  504. while(1)
  505. {
  506. lpDestNext=dest_infos.lpDestHead;
  508. if(run_cancelled) return 0;
  509. for(i =0; i<dest_infos.destCount; i++)
  510. {
  511. if(run_cancelled) return 0;
  513. if(!lpDestNext) break;
  514. if(HqTime[lpDestNext->curJys].fRunning ==FALSE)
  515. goto do_next;
  516. if(lpDestNext->isDead) goto do_next;
  517. if(lpDestNext->isUsing) goto do_next;
  518. //lpDestNext->isUsing =TRUE;
  519. switch(lpDestNext->reqType)
  520. {
  521. case REQ_HQ10:
  522. if(UDP_Server_Send_Hq10(lpDestNext)<0)
  523. {
  524. lpDestNext->isDead =TRUE;
  525. if(--dest_infos.aliveCount <0) dest_infos.aliveCount =0;
  526. SetHqUsers(dest_infos.aliveCount);
  527. goto do_next;
  528. }
  529. break;
  530. case REQ_GRA10:
  531. if(UDP_Server_Send_Gra10(lpDestNext)<0)
  532. {
  533. lpDestNext->isDead =TRUE;
  534. if(--dest_infos.aliveCount <0) dest_infos.aliveCount =0;
  535. SetHqUsers(dest_infos.aliveCount);
  536. goto do_next;
  537. }
  538. break;
  539. default: goto do_next;
  540. }
  541. if(!lpDestNext->isDead)
  542. {
  543. FillDpMain(&DpMain[0]);
  544. if(memcmp(&lpDestNext->DpData, &DpMain, sizeof(DpMain)))
  545. {
  546. if(UDP_Server_Send_Dp(&lpDestNext->dest, FALSE) <0)
  547. {
  548. lpDestNext->isDead =TRUE;
  549. if(--dest_infos.aliveCount <0) dest_infos.aliveCount =0;
  550. SetHqUsers(dest_infos.aliveCount);
  551. }
  552. else memcpy(&lpDestNext->DpData, &DpMain, sizeof(DpMain));
  554. }
  555. }
  556. do_next:
  557. //lpDestNext->isUsing =FALSE;
  558. lpDestNext =lpDestNext->lpNext;
  559. }
  560. //HqResetChangedTimes();
  561. //DelDeads();
  562. Sleep(1000);
  563. }
  564. ExitThread(0);
  565. //CloseHandle(hThrdScanDest);
  566. //hThrdScanDest =0;
  567. return 0;
  568. }
  570. int CreateScanDestThread(void)
  571. {
  572. LONG lThreadId;
  574. hThrdScanDest =CreateThread(NULL, 0,
  575. (LPTHREAD_START_ROUTINE)TF_ScanDest,
  576. NULL, CREATE_SUSPENDED, (LPDWORD)&lThreadId);
  577. if(!hThrdScanDest) return -1;
  578. SetThreadPriority(hThrdScanDest, THREAD_PRIORITY_NORMAL);
  580. ResumeThread(hThrdScanDest);
  582. return 0;
  583. }
  585. int FillDpMain(LPDP_MAIN lpDpMain)
  586. {
  587. int jys;
  589. for(jys =0; jys<2; jys++)
  590. {
  591. lpDpMain[jys].zs =DpData[jys].zs[0];
  592. lpDpMain[jys].zd =DpData[jys].zd[0];
  593. lpDpMain[jys].cjzje =DpData[jys].cjzje;
  594. lpDpMain[jys].npbl =DpData[jys].npbl;
  595. lpDpMain[jys].cjss =DpData[jys].cjss;
  596. lpDpMain[jys].upCount =DpData[jys].upCount;
  597. lpDpMain[jys].downCount =DpData[jys].downCount;
  598. lpDpMain[jys].equalCount =DpData[jys].equalCount;
  599. }
  601. return 0;
  602. }