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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
zserver.cpp
资源名称：SwordOnline.rar　[点击查看]
上传用户：dzyhzl
上传日期：2019-04-29
资源大小：56270k
文件大小：19k
源码类别：

模拟服务器

开发平台：

C/C++

zserver.cpp：源码内容
  1. #ifdef WIN32
  2. #include <winsock2.h>
  3. #define socklen_t int
  4. #endif
  5. #include "IServer.h"
  6. #include "Cipher.h"
  7. #include "KSG_EncodeDecode.h"
  9. #include <time.h>
  10. #include <string.h>
  11. #include <errno.h>
  12. #include <stdlib.h>
  14. #define MAX_SIGNAL 16
  15. #define SIG_SENDDATA SIGRTMIN + MAX_SIGNAL + 1
  17. static unsigned gs_holdrand = time(NULL);
  19. static inline unsigned _Rand() {
  20.     gs_holdrand = gs_holdrand * 214013L + 2531011L;
  21.     return gs_holdrand;
  22. }
  24. static inline void RandMemSet(int nSize, unsigned char *pbyBuffer) {
  25.     while (nSize--) {
  26.         *pbyBuffer++ = (unsigned char)_Rand();
  27.     }
  28. }
  30. int do_sendData(IServer* server, client_info* client);
  31. void JustDoIt(IServer* pIServer, client_info* client)
  32. {
  33. if (client->recv_flag)
  34. {
  35. client->recv_flag = false;
  36. pIServer->receiveData(client);
  37. }
  38. if (client->state == STATE_SENDING)
  39. {
  40. do_sendData(pIServer, client);
  41. }
  42. }
  44. void DoEveryThing(IServer* pIServer)
  45. {
  46. for (int i = 0; i < pIServer->max_client; i++)
  47. {
  48. client_info& client = pIServer->clients[i];
  49. if (client.sock != INVALID_SOCKET)
  50. JustDoIt(pIServer, &client);
  51. }
  52. }
  54. int ZListenThread::action() {
  55. int index;
  56. while(true) {
  57. //响应请求-----------------
  58. struct sockaddr client_addr;
  59. socklen_t length = sizeof(client_addr);
  60. SOCKET s = accept(parent->listen_socket, &client_addr, &length);
  61. if(s == INVALID_SOCKET) continue;
  62. //分配一个连接的资源
  63. index = parent->getConnection(s);
  64. if(index== -1) {
  65. printf("server max connection reached, client attempt fail.n");
  66. closesocket(s);
  67. }
  68. else {
  69. //平台相关,创建完成端口或者事件
  70. #ifdef WIN32
  71. CreateIoCompletionPort((HANDLE)s, parent->CompletionPort, (DWORD)&parent->clients[index], 0);
  72. #else
  73. fcntl(s, F_SETSIG, SIGRTMIN);
  74. fcntl(s, F_SETOWN, parent->pid);
  75. int flags = fcntl(s, F_GETFL);
  76. flags |= O_NONBLOCK | O_ASYNC;
  77. fcntl(s, F_SETFL, flags);
  78. fcntl(s, F_SETAUXFL, O_ONESIGFD);
  79. #endif
  80. //发送key值到客户端
  81. client_info* client = &parent->clients[index];
  82. //client->mutex.lock();
  83. memcpy(&client->addr, &client_addr, length);
  84. client->server_key = _Rand();
  85. client->client_key = _Rand();
  87. #pragma pack(1)
  88. struct {
  89. unsigned short uSize;
  90. ACCOUNT_BEGIN ab;
  91. }account_begin;
  92. #pragma pack()
  94.             RandMemSet(sizeof(account_begin), (unsigned char *)&account_begin);
  95. account_begin.uSize = sizeof(ACCOUNT_BEGIN);
  96. account_begin.ab.ProtocolType = CIPHER_PROTOCOL_TYPE;
  97. account_begin.ab.Mode         = 0;
  98. account_begin.ab.ServerKey    = ~client->server_key;
  99. account_begin.ab.ClientKey    = ~client->client_key;
  100. if (sizeof(account_begin) != send(client->sock, &account_begin, sizeof(account_begin), 0))
  101. {
  102. closesocket(client->sock);
  103. client->state = STATE_IDLE;
  104. printf("client [%d] %d create failed.n", index, client->sock);
  105. client->sock = INVALID_SOCKET;
  106. }
  107. else
  108. {
  109. #ifdef WIN32
  110. client->recv_flag = true;
  111. #endif
  112. client->conn_flag = true;
  113. printf("client [%d] %d created. (%u, %u)n", index, client->sock, client->server_key, client->client_key);
  114. }
  115. //client->mutex.unlock();
  116. }
  117. }
  118. return 0;
  119. }
  122. #ifndef WIN32
  123. // flying add this functino
  124. // Data shoule be sent in a thread, so that the main-process will not be blocked.
  125. int do_sendData(IServer* server, client_info* client) {
  126. if (client->state == STATE_CLOSING)
  127. return -1;
  128. int data_length;
  129. char *data_buffer = client->buffer->getSendData(data_length);
  130. if(!data_buffer) {
  131. client->state = STATE_IDLE;
  132. return -1;
  133. }
  135. int nRetVal = send(client->sock, data_buffer, data_length, 0);
  136. if(nRetVal != -1) {
  137. client->buffer->sendData(nRetVal);
  138. if(nRetVal != data_length) { //发送的数据不够再次发送
  139. server->sendData(client);
  140. }
  141. else client->state = STATE_IDLE;
  142. return 1;
  143. }
  144. else {
  145. if (errno == EAGAIN || errno == EWOULDBLOCK) {
  146. client->state = STATE_BLOCKED;
  147. }
  148. else {
  149. printf("sending failed %d....close connection [%d].n", errno, client->index);
  150. client->state = STATE_CLOSING;
  151. return 0;
  152. }
  153. }
  154. return 1;
  155. }
  156. #endif //WIN32
  158. //实际的工作线程,平台相关
  159. #ifdef WIN32
  160. DWORD WINAPI sig_thread(LPVOID id) {
  161. #else
  162. void *sig_thread(LPVOID id) {
  163. #endif
  164. IServer *parent = (IServer *)id;
  165. #ifdef WIN32
  166. DWORD transferred;
  167. LPOVERLAPPED overlapped;
  168. DWORD flags;
  169. DWORD dwIoSize;
  170. client_info *client;
  171. while(true) {
  172. bool bIORet = GetQueuedCompletionStatus(parent->CompletionPort, &dwIoSize, (LPDWORD) &client, &overlapped, INFINITE);
  173. DWORD dwIOError = GetLastError();
  174. if(!bIORet && dwIOError != WAIT_TIMEOUT ) {
  175. closesocket(client->sock);
  176. client->buffer->clear();
  177. client->sock = INVALID_SOCKET;
  178. if(parent->call_back)
  179. parent->call_back(parent->parameter, client->index, enumClientConnectClose); //notify
  180. continue;
  181. }
  182. if(overlapped == &client->write_overlapped) {
  183. if(dwIoSize > 0) {
  184. client->buffer->sendData(dwIoSize);
  185. }
  186. parent->sendData(client);
  187. }
  188. else {
  189. if(dwIoSize > 0) {
  190. client->buffer->receiveData(dwIoSize);
  191. }
  192. parent->receiveData(client);
  193. }
  194. }
  195. #else
  196.   siginfo_t siginfo;
  197.   sigset_t sset;
  198.   parent->pid = getpid();
  199.   printf("signal thread startn");
  201. sigemptyset(&sset);
  202. sigaddset(&sset, SIGIO);
  203. sigaddset(&sset, SIGRTMIN);
  204. pthread_sigmask(SIG_BLOCK, &sset, NULL);
  206.   while(true) {
  207.     int signum = sigwaitinfo(&sset, &siginfo);
  208.     if(signum == -1)
  209. {
  210. printf("fatal signum in signal thread ...errno = %dn", errno);
  211. continue;
  212. }
  213.     if(signum == SIGIO) {
  214.   //client_info* client = (client_info*)siginfo.si_value.sival_ptr;
  215.       printf("overflow .... n");
  216.   exit(-2);
  217.     }
  218. /*if (signum == SIG_SENDDATA) {
  219. client_info* client = (client_info*)siginfo.si_value.sival_ptr;
  220. if(client->state == STATE_SENDING) {
  221. do_sendData(parent, client);
  222. }
  223. }
  224.     else*/ if(signum == SIGRTMIN) {
  225. client_info *client;
  226. int index = 0;
  227. while(index < parent->max_client) {
  228. client = &parent->clients[index];
  229. if(client->sock == siginfo.si_fd) {
  230. //client->mutex.lock();
  231. if (client->state != STATE_CLOSING)
  232. {
  233. if (siginfo.si_band & 0x01) { //有等待读入的数据
  234. client->recv_flag = true;
  235. //parent->receiveData(client);
  236. }
  237. if (siginfo.si_band & 0x04) {
  238. if(client->state == STATE_BLOCKED) {
  239. client->state = STATE_IDLE;//STATE_SENDING;
  240. //parent->sendData(client);
  241. }
  242. }
  243. else if (!(siginfo.si_band & 0x01))
  244. {
  245. printf("signal notify close connection %dn", client->index);
  246. client->state = STATE_CLOSING;
  247. }
  248. }
  249. //client->mutex.unlock();
  250. break;
  251. }
  252. index++;
  253. }
  254.     }
  255.   }
  256. sigprocmask(SIG_UNBLOCK, &sset, NULL);
  257. #endif
  258. }
  260. void IServer::closeConnection(client_info *client) {
  261. if(client->sock == INVALID_SOCKET) return;
  262. closesocket(client->sock);
  263. client->buffer->clear();
  264. client->state = STATE_IDLE;
  265. client->conn_flag = false;
  266. client->recv_flag = false;
  267. client->sock = INVALID_SOCKET;
  268. }
  270. bool IServer::sendData(client_info *client) {
  271. //int nRetryTime = 0;
  272. //平台相关代码,实际发出重叠的IO请求,发送数据---------------------------------------
  273. int size;
  274. #ifdef WIN32
  275. client->m_wsaOutBuffer.buf = client->buffer->getSendData((int &)client->m_wsaOutBuffer.len);
  276. if(client->m_wsaOutBuffer.buf) {
  277. ULONG ulFlags = MSG_PARTIAL;
  278. ZeroMemory(&client->write_overlapped, sizeof(OVERLAPPED));
  279. int nRetVal = WSASend(client->sock, &client->m_wsaOutBuffer, 1, &client->m_wsaOutBuffer.len, 
  280. ulFlags, &client->write_overlapped, NULL);
  281. if ( nRetVal == SOCKET_ERROR && WSAGetLastError() != WSA_IO_PENDING ) { //出现错误
  282. closeConnection(client);
  283. }
  284. else return true;
  285. }
  286. #else
  287. if(client->state == STATE_IDLE) {
  288. /* union sigval info;
  289. info.sival_ptr = (void*)client;
  290. int nRet = 0;*/
  291. client->state = STATE_SENDING;
  292. /*if (0 != (nRet = sigqueue(pids[client->index % max_thread], SIG_SENDDATA, info))) {
  293. printf("sigqueue failed...%dn", nRet);
  294. }*/
  295. }
  296. #endif
  297. return false;
  298. }
  300. bool IServer::receiveData(client_info *client) {
  301. //平台相关代码,实际发出重叠的IO请求,接收数据---------------------------------------
  302. #ifdef WIN32
  303. ULONG ulFlags = MSG_PARTIAL;
  304. DWORD dwIoSize;
  305. int bufsize = 0;
  306. client->m_wsaInBuffer.buf = (char *)client->buffer->getReceiveBuffer(bufsize);
  307. client->m_wsaInBuffer.len = bufsize;
  308. if (!client->m_wsaInBuffer.buf)
  309. {
  310. printf("receive buffer full...close connection [%d].n", client->index);
  311. closeConnection(client);
  312. return false;
  313. }
  314. UINT nRetVal = WSARecv(client->sock, &client->m_wsaInBuffer, 1, &dwIoSize, &ulFlags, &client->read_overlapped, NULL);
  315. if(nRetVal == SOCKET_ERROR && WSAGetLastError() != WSA_IO_PENDING) {
  316.     printf("receive data pending? close connection [%d].n", client->index);
  317. closeConnection(client);
  318. return false;
  319. }
  320. #else
  321.   int bufsize = 0;
  322.   if (client->state == STATE_CLOSING)
  323.   return false;
  324.   char* recv_buffer = client->buffer->getReceiveBuffer(bufsize);
  325. if (!recv_buffer)
  326. {
  327. printf("receive buffer full...close connection [%d].n", client->index);
  328. client->state = STATE_CLOSING;
  329. return false;
  330. }
  331.   int ret = recv(client->sock, recv_buffer, bufsize, 0);
  332.   if(ret <= 0) {
  333. if (errno != EAGAIN)
  334. {
  335.     printf("receive data pending? close connection [%d].n", client->index);
  336. client->state = STATE_CLOSING;
  337. }
  338.     return false;
  339.   }
  340.   client->buffer->receiveData(ret);
  341. #endif
  342.   return true;
  343. }
  345. IServer::IServer(int number, int thread_number, int max_send, int max_receive) {
  346. clients = new client_info[number];
  347. max_client = number;
  348. int index;
  349. for(index = 0; index < max_client; index++) {
  350. clients[index].buffer = new ZBuffer(max_send, max_receive);
  351. clients[index].buffer->startPerf(&recvPerf, &sendPerf);
  352. clients[index].sock = INVALID_SOCKET;
  353. clients[index].index = index;
  354. }
  355. call_back = NULL;
  356. max_thread = thread_number;
  357. #ifndef WIN32
  358. //current_thread = 0;
  359. //pids = new int[max_thread];
  360. //sigsets = new sigset_t[max_thread];
  361. //send_threads = new ZSendThread[max_thread];
  362. //recv_threads = new ZRecvThread[max_thread];
  363. create_callback_thread = new ZCreateCallBackThread(this);
  364. close_callback_thread = new ZCloseCallBackThread(this);
  365. for (index = 0; index < max_thread; index++)
  366. {
  367. //send_threads[index].parent = this;
  368. //send_threads[index].index = index;
  370. //recv_threads[index].parent = this;
  371. //recv_threads[index].index = index;
  372. }
  373. #endif //WIN32
  374. listen_thread = new ZListenThread(this);
  375. }
  377. IServer::~IServer() {
  378. printf("destruct IServer....n");
  379. listen_thread->stop();
  380. int index;
  381. for (index = 0; index < max_thread; index++)
  382. {
  383. //send_threads[index].stop();
  384. //recv_threads[index].stop();
  385. }
  386. create_callback_thread->stop();
  387. close_callback_thread->stop();
  388. #ifndef WIN32
  389. //delete[] pids;
  390. //delete[] sigsets;
  391. //delete send_threads;
  392. //delete recv_threads;
  393. delete create_callback_thread;
  394. delete close_callback_thread;
  395. #endif //WIN32
  396. delete listen_thread;
  397. delete[] clients;
  398. }
  400. int IServer::getConnection(SOCKET sock) {
  401. int index;
  402. for(index = 0; index < max_client; index++) {
  403. //clients[index].mutex.lock();
  404. if(clients[index].sock == INVALID_SOCKET) {
  405. clients[index].sock = sock;
  406. //clients[index].mutex.unlock();
  407. return index;
  408. }
  409. //clients[index].mutex.unlock();
  410. }
  411. return -1;
  412. }
  414. int init_socket = 0;
  415. int IServer::Startup() {
  416. if(!init_socket) {
  417. #ifdef WIN32
  418. WSADATA wsa_data;
  419. WSAStartup(MAKEWORD(1, 1), &wsa_data);
  420. /*#else
  421. int index;
  422. int signal_number;
  423. for(index = 0; index < max_thread; index++) {
  424. sigemptyset(&sigsets[index]);
  425. sigaddset(&sigsets[index], SIGIO);
  426. //sigaddset(&sigsets[index], SIG_SENDDATA);
  427. signal_number = SIGRTMIN + index;
  428. while(signal_number < SIGRTMIN + MAX_SIGNAL) {
  429. sigaddset(&sigsets[index], signal_number);
  430. signal_number += max_thread;
  431. }
  432. pthread_sigmask(SIG_BLOCK, &sigsets[index], NULL);
  433. }*/
  434. #endif
  435. init_socket++;
  436. }
  437. return 0;
  438. }
  440. int IServer::Cleanup() {
  441. if(init_socket--) {
  442. #ifdef WIN32
  443. WSACleanup();
  444. #endif
  445. }
  446. return 0;
  447. }
  449. int IServer::Release() {
  450. return 0;
  451. }
  453. int IServer::Open(const unsigned long &ulnAddressToListenOn, const unsigned short &usnPortToListenOn) {
  454. //在此创建套接字,绑定,启动侦听线程
  455. #ifdef WIN32
  456. CompletionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
  457. int index;
  458. DWORD thread_id;
  459. for(index = 0; index < max_thread; index++) {
  460. HANDLE hThread;
  461. hThread = CreateThread(NULL, 0, sig_thread, this, 0, &thread_id);
  462. CloseHandle(hThread);
  463. }
  464. listen_socket = WSASocket(AF_INET, SOCK_STREAM, 0, NULL, 0, WSA_FLAG_OVERLAPPED);
  465. #else
  466.     listen_socket = socket(AF_INET, SOCK_STREAM, 0);
  467.     pthread_t work;
  468. int index;
  469. //for(index = 0; index < max_thread; index++)
  470. {
  471. int ret = pthread_create(&work, NULL, sig_thread, this);
  472. if (ret == 0)
  473. pthread_detach(work);
  474. else
  475. return 0;
  476. }
  477. #endif
  478. if(listen_socket == INVALID_SOCKET) return 0;
  479. struct sockaddr_in addr;
  481. memset((void*)&addr, 0, sizeof(addr));
  482. addr.sin_family = AF_INET;
  483. addr.sin_port = htons(usnPortToListenOn);
  484. addr.sin_addr.s_addr = INADDR_ANY;
  485. if(bind(listen_socket, (const sockaddr *)&addr, sizeof(addr))) {
  486. return 0;
  487. }
  488. if(listen(listen_socket, 5)) return 0;
  489. listen_thread->start();
  490. create_callback_thread->start();
  491. close_callback_thread->start();
  492. #ifndef WIN32
  493. for (index = 0; index < max_thread; index++)
  494. {
  495. //send_threads[index].start();
  496. //recv_threads[index].start();
  497. }
  498. #endif
  499. printf("GameServer on Port %d started....n", usnPortToListenOn);
  500. return 1;
  501. }
  503. int IServer::CloseService() {
  504. closesocket(listen_socket);
  506. #ifdef _COND_SEND_
  507. pthread_cond_destroy(&cond_send_data);
  508. #endif
  510. return 0;
  511. }
  513. int IServer::RegisterMsgFilter(void * lpParam, CALLBACK_SERVER_EVENT pfnEventNotify) {
  514. call_back = pfnEventNotify;
  515. parameter = lpParam;
  516. return 0;
  517. }
  519. int IServer::PreparePackSink() { //准备开始数据封装
  520. return 0;
  521. }
  523. int IServer::PackDataToClient(const unsigned long &ulnClientID, const void * pData, unsigned long datalength) {
  524. if (ulnClientID < 0 || ulnClientID >= max_client)
  525. return -1;
  527. if(clients[ulnClientID].sock != INVALID_SOCKET) {
  528. if (clients[ulnClientID].state != STATE_CLOSING &&
  529. !clients[ulnClientID].buffer->packData((const char *)pData, datalength))
  530. {
  531. printf("sending buffer exceed....close connection [%d].n", clients[ulnClientID].index);
  532. clients[ulnClientID].state = STATE_CLOSING;
  533. return -1;
  534. }
  535. }
  536. JustDoIt(this, &clients[ulnClientID]);
  537. return 0;
  538. }
  540. int IServer::SendPackToClient() {
  541. int index;
  542. int nTotalLength = 0;
  543. for(index = 0; index < max_client; index++) {
  544. client_info& client = clients[index];
  545. //clients[index].mutex.lock();
  546. if (client.sock != INVALID_SOCKET) {
  547. JustDoIt(this, &client);
  548. int length = 0;
  549. char *data = client.buffer->completePacket(length);
  550. if(data && client.server_key) {
  551. KSG_EncodeBuf(length, (unsigned char *)data, (unsigned int *)&client.server_key);
  552. client.buffer->sendPacket();
  553. //printf("_<%08X>_", data);
  554. {
  555. //if (client.sock != INVALID_SOCKET && client.state == STATE_SENDING)
  556. {
  557. //client.mutex.lock();
  558. sendData(&client);
  559. //client.mutex.unlock();
  560. }
  561. }
  562. }
  563. nTotalLength += length;
  564. }
  565. JustDoIt(this, &client);
  566. //clients[index].mutex.unlock();
  567. }
  568. return nTotalLength;
  569. }
  571. int IServer::SendPackToClient(int index) {
  572. if (index < 0 || index >= max_client)
  573. {
  574. return SendPackToClient();
  575. }
  576. //clients[index].mutex.lock();
  577. client_info& client = clients[index];
  578. if(client.sock != INVALID_SOCKET) {
  579. int length;
  580. char *data = client.buffer->completePacket(length);
  581. if(data) {
  582. KSG_EncodeBuf(length, (unsigned char *)data, (unsigned int *)&client.server_key);
  583. client.buffer->sendPacket();
  584. sendData(&client);
  585. }
  586. //clients[index].mutex.unlock();
  587. JustDoIt(this, &client);
  588. return length;
  589. }
  590. //clients[index].mutex.unlock();
  591. return 0;
  592. }
  594. int IServer::SendData(const unsigned long &ulnClientID, const void * pData, unsigned long datalength) {
  595. PackDataToClient(ulnClientID, pData, datalength);
  596. SendPackToClient(ulnClientID);
  597. //发送一个消息
  598. return 0;
  599. }
  601. const void *IServer::GetPackFromClient(unsigned long ulnClientID, unsigned int &datalength) {
  602. if (ulnClientID < 0 || ulnClientID >= max_client)
  603. return NULL;
  604. client_info& client = clients[ulnClientID];
  605. JustDoIt(this, &client);
  606. if(client.sock != INVALID_SOCKET) {
  607. //clients[ulnClientID].mutex.lock();
  608. char *data = (char*)client.buffer->getPacket((int &)datalength);
  609. if(data) {
  610. KSG_DecodeBuf(datalength, (unsigned char *)data, (unsigned int *)&client.client_key);
  611. //client.mutex.unlock();
  612. return data;
  613. }
  614. //clients[ulnClientID].mutex.unlock();
  615. }
  616. return NULL; 
  617. }
  619. int IServer::ShutdownClient(const unsigned long &ulnClientID) { 
  620. if (ulnClientID < 0 || ulnClientID >= max_client)
  621. return NULL;
  623. //clients[ulnClientID].mutex.lock();
  624. if(clients[ulnClientID].sock != INVALID_SOCKET) {
  625. clients[ulnClientID].state = STATE_CLOSING;
  626. }
  627. //clients[ulnClientID].mutex.unlock();
  628. return 0; 
  629. }
  631. const char * IServer::GetClientInfo(const unsigned long &ulnClientID)
  632. {
  633. return inet_ntoa(((sockaddr_in*)&(clients[ulnClientID].addr))->sin_addr);
  634. }
  636. #ifndef WIN32
  637. int ZCloseCallBackThread::action()
  638. {
  639. int i = 0;
  640. printf("Close CallBack Thread...startn");
  641. while (1) {
  642. usleep(5000);
  643. for (i = 0; i < parent->max_client; i++)
  644. {
  645. client_info& client = parent->clients[i];
  646. {
  647. if (client.state == STATE_CLOSING) {
  648. //client.mutex.lock();
  649. parent->closeConnection(&client);
  650. //client.mutex.unlock();
  651. if(parent->call_back) {
  652. //printf("close call_back %dn", i);
  653. parent->call_back(parent->parameter, i, enumClientConnectClose);
  654. usleep(200000);
  655. }
  656. }
  657. }
  658. }
  659. }
  660. return 0;
  661. }
  663. int ZCreateCallBackThread::action()
  664. {
  665. int i = 0;
  666. printf("Create CallBack Thread...startn");
  667. while (1) {
  668. usleep(5000);
  669. for (i = 0; i < parent->max_client; i++)
  670. {
  671. client_info& client = parent->clients[i];
  672. {
  673. if (client.conn_flag)
  674. {
  675. //client.mutex.lock();
  676. client.conn_flag = false;
  677. //client.mutex.unlock();
  678. if(parent->call_back) {
  679. //printf("create call_back %dn", i);
  680. parent->call_back(parent->parameter, i, enumClientConnectCreate); //notify
  681. }
  682. }
  683. }
  684. }
  685. }
  686. return 0;
  687. }
  689. int ZRecvThread::action()
  690. {
  691. int i = 0;
  692. printf("receiving thread %d...startn", index);
  693. while (1) {
  694. usleep(5000);
  695. for (i = index; i < parent->max_client; i += parent->max_thread)
  696. {
  697. client_info& client = parent->clients[i];
  698. {
  699. if (client.sock != INVALID_SOCKET && client.recv_flag)
  700. {
  701. //client.mutex.lock();
  702. parent->receiveData(&client);
  703. client.recv_flag = false;
  704. //client.mutex.unlock();
  705. }
  706. }
  707. }
  708. }
  709. printf("receiving thread...endn");
  710. return 0;
  711. }
  713. int ZSendThread::action()
  714. {
  715. int i = 0;
  716. printf("sending thread %d...startn", index);
  717. while (1) {
  718. usleep(5000);
  719. for (i = index; i < parent->max_client; i += parent->max_thread)
  720. {
  721. client_info& client = parent->clients[i];
  722. {
  723. if (client.sock != INVALID_SOCKET && client.state == STATE_SENDING)
  724. {
  725. //client.mutex.lock();
  726. do_sendData(parent, &client);
  727. //client.mutex.unlock();
  728. }
  729. }
  730. }
  731. }
  732. printf("sending thread...endn");
  733. return 0;
  734. }
  735. #endif