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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 棋牌游戏 > 查看源码
ts.cpp
资源名称：fchess_src.zip　[点击查看]
上传用户：hy11688
上传日期：2007-01-08
资源大小：81k
文件大小：9k
源码类别：

棋牌游戏

开发平台：

Visual C++

ts.cpp：源码内容
  1. #include "stdafx.h"
  2. #include <winsock.h>
  3. #include "string.h"
  4. #include "ts.h"
  6. struct strListen
  7. {
  8.    HWND hWnd;
  9.    WORD wPort;
  10.    BYTE bMaxListen;
  11.    UINT uMessage;
  12.    BOOL fDelAuto;
  13.    SOCKET *psockUse;
  14. };
  15. DWORD ListenThread(strListen* pstrListen);
  16. DWORD dwRet;
  18. CTCPSocket::CTCPSocket(void)
  19. {
  20.    m_sockUse[0]=m_sockUse[1]=-1;
  21.    m_hListenThread=NULL;
  22. }
  23. CTCPSocket::~CTCPSocket(void)
  24. {
  25.    Close();
  26. }
  27. void CTCPSocket::CancelListen(void)
  28. {
  29.    ASSERT(IsListenSide());
  30.    ASSERT(m_wFlag&WSA_NOTIFY||m_wFlag&THREAD_NOTIFY);
  31.    switch(m_wFlag&0X0111)
  32.    {
  33.   case(WSA_NOTIFY):
  34.   WSAAsyncSelect(m_sockUse[0],m_hWnd,0,0);
  35.   closesocket(m_sockUse[0]);
  36.   m_sockUse[0]=-1;
  37.   break;
  38.   case(THREAD_NOTIFY):
  39.   if(m_hListenThread)
  40.   {
  41.  TerminateThread(m_hListenThread,0);
  42.  m_hListenThread=NULL;
  43.   }
  44.   break;
  45.   default:
  46.   break;
  47.    }
  48.    Close();
  49. }
  50. void CTCPSocket::Close(void)
  51. {
  52.    if(m_sockUse[1]>0)
  53.  closesocket(m_sockUse[1]);
  54.    if(m_sockUse[0]>0)
  55.  closesocket(m_sockUse[0]);
  56.    m_sockUse[0]=m_sockUse[1]=-1;
  57. }
  58. void CTCPSocket::InitData(HWND hWndOwner,
  59.                           WORD wPort,
  60.                           BOOL fListen,
  61.                           WORD wFlag,
  62.                           BYTE bMax,
  63.                           UINT uAccept)
  64. {
  65.    Close();
  66.    m_hWnd=hWndOwner;
  67.    m_uAccept=uAccept;
  68.    m_wFlag=wFlag;
  69.    m_wPort=wPort;
  70.    m_bMaxListen=bMax;
  71.    m_wFlag |=( fListen )?
  72.                  LISTEN_SIDE:CONNECT_SIDE;
  74. }
  75. void CTCPSocket::CloseListenSocket(void)
  76. {
  77. if(!IsListenSide())
  78. return;
  79.    if(m_sockUse[0]>0)
  80.  closesocket(m_sockUse[0]);
  81. m_sockUse[0]=SOCKET_ERROR;
  82. }
  83. BOOL CTCPSocket::Established(HWND hWndOwner,UINT uRead)
  84. {
  85.    ASSERT(hWndOwner);
  86.    m_uRead=uRead;
  87.    int iStatus=WSAAsyncSelect(GetCommSocket(),hWndOwner,
  88.                                   m_uRead,FD_READ|FD_CLOSE);
  89.    return !(iStatus>0);
  90. }
  91. BOOL CTCPSocket::Establish(LPCSTR lpszOtherHost)
  92. {
  93.    ASSERT(m_sockUse[0]==-1);
  94.    if(IsListenSide())
  95.       return ListenSide();
  96. else
  97.    {
  98.       ASSERT(lpszOtherHost);
  99.       return ConnectSide(lpszOtherHost);
  100.    }
  101. }
  102. BOOL CTCPSocket::ListenSide(void)
  103. {
  104.    WORD wFlag=m_wFlag;
  105.    wFlag&=0X0111;
  106.    switch(wFlag)
  107.    {
  108.   case(BLOCKING_NOTIFY):
  109.   return BSDListen();
  110.   break;
  111.   case(THREAD_NOTIFY):
  112.   return ThreadListen();
  113.   break;
  114.   case(WSA_NOTIFY):
  115.   return WSAListen();
  116.   break;
  117.   default:
  118.   ASSERT(0);
  119.   break;
  120.    }
  121.  return FALSE;
  122. }
  123. BOOL CTCPSocket::WSAAccept(void)
  124. {
  125.    SOCKADDR_IN sinClient;
  126.    int iLength;
  127.    ASSERT(m_sockUse[0]!=-1);
  128.    ASSERT(m_wFlag&WSA_NOTIFY);
  129.    iLength=sizeof(sinClient);
  130.    m_sockUse[1]=accept(m_sockUse[0],
  131.                     (struct sockaddr FAR *)&sinClient,
  132.                          (int FAR*)&iLength);
  133.    
  134.    if(SOCKET_ERROR==m_sockUse[1])
  135.    {
  136.       closesocket(m_sockUse[0]);
  137.   m_sockUse[0]=-1;
  138.       return FALSE;
  139.    }
  140.   else
  141.      return TRUE;
  143. }
  144. BOOL CTCPSocket::WSAListen(void)
  145. {
  146.    SOCKADDR_IN sinLocal;
  147.    PHOSTENT pHost;
  148.    char szHostName[60];
  149.    int iStatus;
  150.    
  151.    m_sockUse[0]=socket(AF_INET,SOCK_STREAM,0);
  152.    if(m_sockUse[0]<0)
  153.       return FALSE;
  154.    
  155.    sinLocal.sin_family=AF_INET;
  156.    sinLocal.sin_port=htons(m_wPort);
  157.    
  158.    gethostname(szHostName,60);
  159.    pHost=gethostbyname(szHostName);
  160.    
  161.    if(pHost==NULL)
  162.       return FALSE;
  163.    
  164.    memcpy((LPSTR)&(sinLocal.sin_addr),
  165.              (LPSTR)pHost->h_addr,
  166.                  pHost->h_length);
  167.    
  168.    iStatus=bind(m_sockUse[0],(struct sockaddr FAR*)&sinLocal,sizeof(sinLocal));
  169.    if(iStatus<0)
  170.    {
  171.       closesocket(m_sockUse[0]);
  172.   m_sockUse[0]=-1;
  173.       return FALSE;
  174.    }
  175.    
  176.    if(0>(iStatus=listen(m_sockUse[0],m_bMaxListen)))
  177.    {
  178.       closesocket(m_sockUse[0]);
  179.   m_sockUse[0]=-1;
  180.       return FALSE;
  181.    }
  182.    iStatus=WSAAsyncSelect(m_sockUse[0],m_hWnd,m_uAccept,FD_ACCEPT);
  183.    if(iStatus>0)
  184.    {
  185.       closesocket(m_sockUse[0]);
  186.   m_sockUse[0]=-1;
  187.       return FALSE;
  188.    }
  189.   else
  190.   return TRUE;
  191. }
  192. BOOL CTCPSocket::BSDListen(void)
  193. {
  194.    SOCKADDR_IN sinLocal,sinClient;
  195.    PHOSTENT pHost;
  196.    char szHostName[60];
  197.    int iStatus;
  198.    int iLength;
  200.    m_sockUse[0]=socket(AF_INET,SOCK_STREAM,0);
  201.    if(m_sockUse[0]<0)
  202.       return FALSE;
  203.    
  204.    sinLocal.sin_family=AF_INET;
  205.    sinLocal.sin_port=htons(m_wPort);
  206.    
  207.    gethostname(szHostName,60);
  208.    pHost=gethostbyname(szHostName);
  209.    
  210.    if(pHost==NULL)
  211.       return FALSE;
  212.    
  213.    memcpy((LPSTR)&(sinLocal.sin_addr),
  214.              (LPSTR)pHost->h_addr,
  215.                  pHost->h_length);
  216.    
  217.    iStatus=bind(m_sockUse[0],(struct sockaddr FAR*)&sinLocal,sizeof(sinLocal));
  218.    if(iStatus<0)
  219.    {
  220.       closesocket(m_sockUse[0]);
  221.   m_sockUse[0]=-1;
  222.       return FALSE;
  223.    }
  224.    
  225.    if(0>(iStatus=listen(m_sockUse[0],m_bMaxListen)))
  226.    {
  227.       closesocket(m_sockUse[0]);
  228.   m_sockUse[0]=-1;
  229.       return FALSE;
  230.    }
  231.    iLength=sizeof(sinClient);
  232.    m_sockUse[1]=accept(m_sockUse[0],
  233.                     (struct sockaddr FAR *)&sinClient,
  234.                          (int FAR*)&iLength);
  235.    
  236.    if(SOCKET_ERROR==m_sockUse[1])
  237.    {
  238.       closesocket(m_sockUse[0]);
  239.   m_sockUse[0]=-1;
  240.       return FALSE;
  241.    }
  242.   else
  243.      return TRUE;
  244. }
  245. BOOL CTCPSocket::ThreadListen(void)
  246. {
  247.    strListen* pstrListen=new (strListen);
  248.    pstrListen->hWnd=m_hWnd;
  249.    pstrListen->bMaxListen=m_bMaxListen;
  250.    pstrListen->uMessage=m_uAccept;
  251.    pstrListen->fDelAuto=TRUE;
  252.    pstrListen->wPort=m_wPort;
  253.    pstrListen->psockUse=m_sockUse;
  254.    m_hListenThread=CreateThread(NULL,
  255.                                 0,
  256.                                 (LPTHREAD_START_ROUTINE)ListenThread,
  257. pstrListen,
  258. 0,
  259. &dwRet);
  260.    return (m_hListenThread!=NULL);
  261. }
  262. BOOL CTCPSocket::ConnectSide(LPCSTR lpszServer)
  263. {
  264.    //SOCKET sockConnect;
  265.    SOCKADDR_IN sinServer;
  266.    PHOSTENT pHost;
  267.    int iStatus;
  269.    sinServer.sin_family=AF_INET;
  270.    pHost=gethostbyname(lpszServer);
  271.    if(pHost==NULL)
  272.       return FALSE;
  273.    sinServer.sin_port=htons(m_wPort);
  274.    
  275.    memcpy(&sinServer.sin_addr,pHost->h_addr,pHost->h_length);
  276.    m_sockUse[0]=socket(AF_INET,SOCK_STREAM,0);
  277.    if(m_sockUse[0]<0)
  278.       return FALSE;
  279.    iStatus=connect(m_sockUse[0],(struct sockaddr*)&sinServer,sizeof(sinServer));
  280.    if(iStatus<0)
  281.    {
  282.       closesocket(m_sockUse[0]);
  283.   m_sockUse[0]=-1;
  284.       return FALSE;
  285.    }
  286. else
  287.    return TRUE;
  288. }
  289. int CTCPSocket::Read(LPSTR pRead,DWORD dwRead)
  290. {
  291.    DWORD dwR=0;
  292.    DWORD dwLeft=dwRead;
  293.    SOCKET sockRead=GetCommSocket();
  294.    while(dwLeft)
  295.    {
  296.   dwR=recv(sockRead,pRead+dwRead-dwLeft,dwLeft,0);
  297.   if(dwR==-1)
  298.   {
  299.      char szError[100];
  300.  sprintf(szError,"%X Read Error",WSAGetLastError());
  301.      //AfxMessageBox(szError,MB_OK);
  302.  return -1;
  303.   }
  304.       dwLeft-=dwR;
  305.    }
  306.    return (dwRead-dwLeft);
  307. }
  308. int CTCPSocket::Write(LPCSTR pWrite,DWORD dwWrite)
  309. {
  310.    DWORD dwW=0;
  311.    DWORD dwLeft=dwWrite;
  312.    SOCKET sockWrite=GetCommSocket();
  313.    while(dwLeft)
  314.    {
  315.   dwW=send(sockWrite,pWrite+dwWrite-dwLeft,dwLeft,0);
  316.   if(dwW==-1)
  317.      return -1;
  318.       dwLeft-=dwW;
  319.    }
  320.    return (dwWrite-dwLeft);
  321. }
  323. DWORD ListenThread(strListen *pstrListen)
  324. {
  325.    SOCKADDR_IN sinLocal,sinClient;
  326.    PHOSTENT pHost;
  327.    char szHostName[60];
  328.    int iStatus;
  329.    int iLength;
  330.    strListen strListen;
  331.    memcpy((void*)&strListen,(void*)pstrListen,sizeof(strListen));
  332.    if(pstrListen->fDelAuto)
  333.       delete pstrListen;
  334.    strListen.psockUse[0]=socket(AF_INET,SOCK_STREAM,0);
  335.    if(strListen.psockUse[0]<0)
  336.       {
  337.          SendMessage(strListen.hWnd,
  338.                      strListen.uMessage,
  339.  0,
  340.                      WSAMAKESELECTREPLY(FD_ACCEPT,1));
  341.          return 0;
  342.   }
  343.    
  344.    sinLocal.sin_family=AF_INET;
  345.    sinLocal.sin_port=htons(strListen.wPort);
  346.    
  347.    gethostname(szHostName,60);
  348.    pHost=gethostbyname(szHostName);
  349.    
  350.    if(pHost==NULL)
  351.       return FALSE;
  352.    
  353.    memcpy((LPSTR)&(sinLocal.sin_addr),
  354.              (LPSTR)pHost->h_addr,
  355.                  pHost->h_length);
  356.    
  357.    iStatus=bind(strListen.psockUse[0],(struct sockaddr FAR*)&sinLocal,sizeof(sinLocal));
  358.    if(iStatus<0)
  359.    {
  360.       closesocket(strListen.psockUse[0]);
  361.   strListen.psockUse[0]=-1;
  362.       SendMessage(strListen.hWnd,
  363.                   strListen.uMessage,
  364.   0,
  365.                   WSAMAKESELECTREPLY(FD_ACCEPT,1));
  366.   return 0;
  367.    }
  368.    
  369.    if(0>(iStatus=listen(strListen.psockUse[0],strListen.bMaxListen)))
  370.    {
  371.       closesocket(strListen.psockUse[0]);
  372.   strListen.psockUse[0]=-1;
  373.   SendMessage(strListen.hWnd,
  374.                   strListen.uMessage,
  375.   0,
  376.                   WSAMAKESELECTREPLY(FD_ACCEPT,1));
  377.   return 0;
  378.    }
  379.    iLength=sizeof(sinClient);
  380.    strListen.psockUse[1]=accept(strListen.psockUse[0],
  381.                     (struct sockaddr FAR *)&sinClient,
  382.                          (int FAR*)&iLength);
  383.    
  384.    if(SOCKET_ERROR==strListen.psockUse[1])
  385.    {
  386.       closesocket(strListen.psockUse[0]);
  387.   strListen.psockUse[0]=-1;
  388.       SendMessage(strListen.hWnd,
  389.                   strListen.uMessage,
  390.   0,
  391.                   WSAMAKESELECTREPLY(FD_ACCEPT,1));
  392.       return 0;
  393.    }
  394.   else
  395.   {
  396.      SendMessage(strListen.hWnd,
  397.                      strListen.uMessage,
  398.  0,
  399.                      WSAMAKESELECTREPLY(FD_ACCEPT,0));
  400.          return TRUE;
  401.   }
  402. }