Develop and Download Open Source Software

WinCS

Browse Subversion Repository

/[wincs]/SocketX/BaseSocket.cpp

Diff of /SocketX/BaseSocket.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 13 by sho1get, Tue May 25 06:54:25 2010 UTC revision 16 by sho1get, Mon Jun 28 05:40:57 2010 UTC
# Line 157  BOOL IBaseSocket::CreateSocketWindow() Line 157  BOOL IBaseSocket::CreateSocketWindow()
157    
158  BOOL IBaseSocket::CloseSocket()  BOOL IBaseSocket::CloseSocket()
159  {  {
160          m_fInit = !doCloseSocket(m_hSocket);          if (!doCloseSocket(m_hSocket))
161          return m_fInit;          {
162                    return FALSE;
163            }
164    
165            m_lEvent = 0;
166            m_fInit = FALSE;
167    
168            return TRUE;
169  }  }
170    
171  BOOL IBaseSocket::IsLANConnection(const LPSOCKADDR lpSockAddr)  BOOL IBaseSocket::IsLANConnection(const LPSOCKADDR lpsAddr)
172  {  {
173          SOCKADDR_IN siAddr;          SOCKADDR_IN sAddrIn;
174          CopyMemory(&siAddr, lpSockAddr, sizeof(siAddr));          CopyMemory(&sAddrIn, lpsAddr, sizeof(sAddrIn));
175          return (m_LocalNet.dwNet == (m_LocalNet.dwMask & siAddr.sin_addr.s_addr));          return (m_LocalNet.dwNet == (m_LocalNet.dwMask & sAddrIn.sin_addr.s_addr));
176  }  }
177    
178  void IBaseSocket::MakeSockAddrIN(LPSOCKADDR_IN lpSockAddrIN, DWORD dwAddress,  void IBaseSocket::MakeSockAddrIN(LPSOCKADDR_IN lpsAddrIn, DWORD dwAddress,
179                                                                   WORD wPort, UINT nAF)                                                                   WORD wPort, UINT nFamily)
180  {  {
181          ZeroMemory(lpSockAddrIN, sizeof(LPSOCKADDR_IN));          ZeroMemory(lpsAddrIn, sizeof(SOCKADDR_IN));
182          lpSockAddrIN->sin_port             = htons(wPort);          lpsAddrIn->sin_port                = htons(wPort);
183          lpSockAddrIN->sin_family           = nAF;          lpsAddrIn->sin_family      = nFamily;
184          lpSockAddrIN->sin_addr.s_addr  = dwAddress;          lpsAddrIn->sin_addr.s_addr = dwAddress;
185  }  }
186    
187  void IBaseSocket::ConvertSockAddrToNetAddr(const LPSOCKADDR lpSockAddr, NETADDR &NetAddr)  void IBaseSocket::ConvertSockAddrToNetAddr(const LPSOCKADDR lpsAddr, NETADDR &NetAddr)
188  {  {
189          SOCKADDR_IN siAddr;          SOCKADDR_IN sAddrIn;
190          CopyMemory(&siAddr, lpSockAddr, sizeof(siAddr));          CopyMemory(&sAddrIn, lpsAddr, sizeof(sAddrIn));
191          NetAddr.wPort     = ntohs(siAddr.sin_port);          NetAddr.wPort     = ntohs(sAddrIn.sin_port);
192          NetAddr.nAF               = siAddr.sin_family;          NetAddr.nFamily   = sAddrIn.sin_family;
193          NetAddr.dwAddress = siAddr.sin_addr.s_addr;          NetAddr.dwAddress = sAddrIn.sin_addr.s_addr;
194  }  }
195    
196  BOOL IBaseSocket::Shutdown(int nFlag)  BOOL IBaseSocket::Shutdown(int nFlag)
# Line 228  BOOL IBaseSocket::SetBlocking() Line 235  BOOL IBaseSocket::SetBlocking()
235    
236  BOOL IBaseSocket::Bind(WORD wPort, DWORD dwAddress)  BOOL IBaseSocket::Bind(WORD wPort, DWORD dwAddress)
237  {  {
238          return doBind(m_hSocket, wPort, dwAddress);          if (!doBind(m_hSocket, wPort, dwAddress))
239            {
240                    return FALSE;
241            }
242    
243            m_wBindPort = wPort;
244    
245            return TRUE;
246  }  }
247    
248  BOOL IBaseSocket::GetSockName(LPSOCKADDR lpSockAddr)  BOOL IBaseSocket::GetSockName(LPSOCKADDR lpsAddr)
249  {  {
250          return doGetSockName(m_hSocket, lpSockAddr);          return doGetSockName(m_hSocket, lpsAddr);
251  }  }
252    
253  BOOL IBaseSocket::GetPeerName(LPSOCKADDR lpSockAddr)  BOOL IBaseSocket::GetPeerName(LPSOCKADDR lpsAddr)
254  {  {
255          return doGetPeerName(m_hSocket, lpSockAddr);          return doGetPeerName(m_hSocket, lpsAddr);
256  }  }
257    
258  BOOL IBaseSocket::SetSockOpt(int nOptionName, LPCSTR lpOptionValue,  BOOL IBaseSocket::SetSockOpt(int nOptionName, LPCSTR lpOptionValue,
# Line 265  BOOL IBaseSocket::SetRecieveTimeout(DWOR Line 279  BOOL IBaseSocket::SetRecieveTimeout(DWOR
279    
280  BOOL IBaseSocket::SetSendBufferSize(DWORD dwBufSize)  BOOL IBaseSocket::SetSendBufferSize(DWORD dwBufSize)
281  {  {
282          return doSetSendBufferSize(m_hSocket, dwBufSize);          if (!doSetSendBufferSize(m_hSocket, dwBufSize))
283            {
284                    return FALSE;
285            }
286    
287            m_dwSendBufSize = dwBufSize;
288    
289            return TRUE;
290  }  }
291    
292  BOOL IBaseSocket::SetReceiveBufferSize(DWORD dwBufSize)  BOOL IBaseSocket::SetReceiveBufferSize(DWORD dwBufSize)
293  {  {
294          return doSetReceiveBufferSize(m_hSocket, dwBufSize);          if (!doSetReceiveBufferSize(m_hSocket, dwBufSize))
295            {
296                    return FALSE;
297            }
298    
299            m_dwReceiveBufSize = dwBufSize;
300    
301            return TRUE;
302    }
303    
304    BOOL IBaseSocket::SetBufferSize(DWORD dwBufSize)
305    {
306            return (SetSendBufferSize(dwBufSize) && SetReceiveBufferSize(dwBufSize));
307  }  }
308    
309  BOOL IBaseSocket::SetKeepAlive(DWORD dwTime, DWORD dwInterval)  BOOL IBaseSocket::SetKeepAlive(DWORD dwTime, DWORD dwInterval)
# Line 317  BOOL IBaseSocket::Receive(CByteArray &da Line 350  BOOL IBaseSocket::Receive(CByteArray &da
350          return doReceive(m_hSocket, data);          return doReceive(m_hSocket, data);
351  }  }
352    
353  BOOL IBaseSocket::SendTo(const CByteArray &data, const LPSOCKADDR lpSockAddr, int nSockAddrLen)  BOOL IBaseSocket::SendTo(const CByteArray &data, const LPSOCKADDR lpsAddr, int nSockAddrLen)
354  {  {
355          return doSendTo(m_hSocket, data, lpSockAddr, nSockAddrLen);          return doSendTo(m_hSocket, data, lpsAddr, nSockAddrLen);
356  }  }
357    
358  BOOL IBaseSocket::ReceiveFrom(CByteArray &data, LPSOCKADDR lpSockAddr, int *lpSockAddrLen)  BOOL IBaseSocket::ReceiveFrom(CByteArray &data, LPSOCKADDR lpsAddr, int *lpsAddrLen)
359  {  {
360          return doReceiveFrom(m_hSocket, data, lpSockAddr, lpSockAddrLen);          return doReceiveFrom(m_hSocket, data, lpsAddr, lpsAddrLen);
361  }  }
362    
363  //////////////////////////////////////////////////////////////////////////  //////////////////////////////////////////////////////////////////////////
# Line 339  BOOL IBaseSocket::doGetHostByName(HANDLE Line 372  BOOL IBaseSocket::doGetHostByName(HANDLE
372                  return FALSE;                  return FALSE;
373          }          }
374    
375          m_SockMsg.pTgtObj->OnGetHostByNameMessage(lpHostEnt);          m_SockMsg.pCallback->OnGetHostByNameMessage(lpHostEnt);
376    
377            return TRUE;
378    }
379    
380    BOOL IBaseSocket::doCreateSocket(SOCKMSG SockMsg, int nType, int nProtocol)
381    {
382            if (!IBaseSocket::CreateSocketWindow())
383            {
384                    return FALSE;
385            }
386    
387            SetCallback(SockMsg);
388    
389            m_hSocket = socket(AF_INET, nType, nProtocol);
390    
391            if (m_hSocket == INVALID_SOCKET)
392            {
393                    TRACE1("***** ERROR: socket(%d) *****\n", GetLastError());
394                    m_dwError = GetLastError();
395                    return FALSE;
396            }
397    
398            SetSendTimeout(m_dwSendTimeout);
399            SetRecieveTimeout(m_dwReceiveTimeout);
400    
401          return TRUE;          return TRUE;
402  }  }
# Line 354  BOOL IBaseSocket::doCloseSocket(SOCKET h Line 411  BOOL IBaseSocket::doCloseSocket(SOCKET h
411          }          }
412    
413          hSocket  = INVALID_SOCKET;          hSocket  = INVALID_SOCKET;
         m_lEvent = 0;  
414    
415          return TRUE;          return TRUE;
416  }  }
# Line 407  BOOL IBaseSocket::doSetBlocking(SOCKET h Line 463  BOOL IBaseSocket::doSetBlocking(SOCKET h
463    
464  BOOL IBaseSocket::doBind(SOCKET hSocket, WORD wPort, DWORD dwAddress)  BOOL IBaseSocket::doBind(SOCKET hSocket, WORD wPort, DWORD dwAddress)
465  {  {
466          SOCKADDR_IN siAddr;          SOCKADDR_IN sAddrIn;
467    
468          MakeSockAddrIN(&siAddr, dwAddress, wPort);          MakeSockAddrIN(&sAddrIn, dwAddress, wPort);
469    
470          if (bind(hSocket, (LPSOCKADDR)&siAddr, sizeof(siAddr)) == SOCKET_ERROR)          if (bind(hSocket, (LPSOCKADDR)&sAddrIn, sizeof(sAddrIn)) == SOCKET_ERROR)
471          {          {
472                  TRACE1("***** ERROR: bind(%d) *****\n", GetLastError());                  TRACE1("***** ERROR: bind(%d) *****\n", GetLastError());
473                  m_dwError = GetLastError();                  m_dwError = GetLastError();
474                  return FALSE;                  return FALSE;
475          }          }
476    
         m_wBindPort = wPort;  
   
477          return TRUE;          return TRUE;
478  }  }
479    
480  BOOL IBaseSocket::doGetSockName(SOCKET hSocket, LPSOCKADDR lpSockAddr)  BOOL IBaseSocket::doGetSockName(SOCKET hSocket, LPSOCKADDR lpsAddr)
481  {  {
482          int nLenSA = sizeof(SOCKADDR);          int nLenSA = sizeof(SOCKADDR);
483    
484          if (getsockname(hSocket, lpSockAddr, &nLenSA) != 0)          if (getsockname(hSocket, lpsAddr, &nLenSA) != 0)
485          {          {
486                  TRACE1("***** ERROR: getsockname(%d) *****\n", GetLastError());                  TRACE1("***** ERROR: getsockname(%d) *****\n", GetLastError());
487                  m_dwError = GetLastError();                  m_dwError = GetLastError();
# Line 437  BOOL IBaseSocket::doGetSockName(SOCKET h Line 491  BOOL IBaseSocket::doGetSockName(SOCKET h
491          return TRUE;          return TRUE;
492  }  }
493    
494  BOOL IBaseSocket::doGetPeerName(SOCKET hSocket, LPSOCKADDR lpSockAddr)  BOOL IBaseSocket::doGetPeerName(SOCKET hSocket, LPSOCKADDR lpsAddr)
495  {  {
496          int nLenSA = sizeof(SOCKADDR);          int nLenSA = sizeof(SOCKADDR);
497    
498          if (getpeername(hSocket, lpSockAddr, &nLenSA) != 0)          if (getpeername(hSocket, lpsAddr, &nLenSA) != 0)
499          {          {
500                  TRACE1("***** ERROR: getpeername(%d) *****\n", GetLastError());                  TRACE1("***** ERROR: getpeername(%d) *****\n", GetLastError());
501                  m_dwError = GetLastError();                  m_dwError = GetLastError();
# Line 581  BOOL IBaseSocket::doSend(SOCKET hSocket, Line 635  BOOL IBaseSocket::doSend(SOCKET hSocket,
635    
636          header.size = dataSize;          header.size = dataSize;
637          snd.SetSize(hdrSize);          snd.SetSize(hdrSize);
         CopyMemory(snd.GetData(), &header, hdrSize);  
638          snd.FreeExtra();          snd.FreeExtra();
639            CopyMemory(snd.GetData(), &header, hdrSize);
640    
641          do          do
642          {          {
# Line 733  BOOL IBaseSocket::doReceive(SOCKET hSock Line 787  BOOL IBaseSocket::doReceive(SOCKET hSock
787          return fResult;          return fResult;
788  }  }
789    
790  BOOL IBaseSocket::doSendTo(SOCKET hSocket, const CByteArray &data, const LPSOCKADDR lpSockAddr, int nSockAddrLen)  BOOL IBaseSocket::doSendTo(SOCKET hSocket, const CByteArray &data, const LPSOCKADDR lpsAddr, int nSockAddrLen)
791  {  {
792          int     nRet;          int       nRet;
793            DWORD dwBufSize = min(m_dwSendBufSize, static_cast<DWORD>(data.GetSize()));
794    
795          nRet = sendto(hSocket, reinterpret_cast<LPSTR>(const_cast<BYTE *>(data.GetData())),          nRet = sendto(hSocket, reinterpret_cast<LPSTR>(const_cast<BYTE *>(data.GetData())),
796                                    SX_UDP_BUFSIZE, 0, lpSockAddr, nSockAddrLen);                                    dwBufSize, 0, lpsAddr, nSockAddrLen);
797    
798          if (nRet == SOCKET_ERROR)          if (nRet == SOCKET_ERROR)
799          {          {
# Line 750  BOOL IBaseSocket::doSendTo(SOCKET hSocke Line 805  BOOL IBaseSocket::doSendTo(SOCKET hSocke
805          return TRUE;          return TRUE;
806  }  }
807    
808  BOOL IBaseSocket::doReceiveFrom(SOCKET hSocket, CByteArray &data, LPSOCKADDR lpSockAddr, int *lpSockAddrLen)  BOOL IBaseSocket::doReceiveFrom(SOCKET hSocket, CByteArray &data, LPSOCKADDR lpsAddr, int *lpsAddrLen)
809  {  {
810          int     nRet;          int     nRet;
811          int     nLenSA = sizeof(SOCKADDR);          int     nLenSA = sizeof(SOCKADDR);
812    
813          if (data.GetSize() != SX_UDP_BUFSIZE)          data.SetSize(m_dwReceiveBufSize);
814          {          data.FreeExtra();
                 data.RemoveAll();  
                 data.SetSize(SX_UDP_BUFSIZE);  
         }  
815    
816          nRet = recvfrom(hSocket, reinterpret_cast<LPSTR>(data.GetData()),          nRet = recvfrom(hSocket, reinterpret_cast<LPSTR>(data.GetData()),
817                                          SX_UDP_BUFSIZE, 0, lpSockAddr, lpSockAddrLen);                                          m_dwReceiveBufSize, 0, lpsAddr, lpsAddrLen);
818    
819          if (nRet == SOCKET_ERROR)          if (nRet == SOCKET_ERROR)
820          {          {
# Line 771  BOOL IBaseSocket::doReceiveFrom(SOCKET h Line 823  BOOL IBaseSocket::doReceiveFrom(SOCKET h
823                  return FALSE;                  return FALSE;
824          }          }
825    
         data.FreeExtra();  
   
826          return TRUE;          return TRUE;
827  }  }
828    
Legend:
Removed from v.13  
changed lines
  Added in v.16
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help