//------------------------------------------------------------------------------ // // Close() - Close socket and free up any memory allocated for the socket // //------------------------------------------------------------------------------ bool CSimpleSocket::Close(void) { bool bRetVal = false; //-------------------------------------------------------------------------- // delete internal buffer //-------------------------------------------------------------------------- if (m_pBuffer != NULL) { delete [] m_pBuffer; m_pBuffer = NULL; } //-------------------------------------------------------------------------- // if socket handle is currently valid, close and then invalidate //-------------------------------------------------------------------------- if (IsSocketValid()) { if (CLOSE(m_socket) != CSimpleSocket::SocketError) { m_socket = INVALID_SOCKET; bRetVal = true; } } TranslateSocketError(); return bRetVal; }
//------------------------------------------------------------------------------ // // Send() - Send data on a valid socket // //------------------------------------------------------------------------------ int32 CPassiveSocket::Send(const uint8 *pBuf, size_t bytesToSend) { SetSocketError(SocketSuccess); m_nBytesSent = 0; switch(m_nSocketType) { case CSimpleSocket::SocketTypeUdp: { if (IsSocketValid()) { if ((bytesToSend > 0) && (pBuf != NULL)) { m_timer.Initialize(); m_timer.SetStartTime(); m_nBytesSent = SENDTO(m_socket, pBuf, bytesToSend, 0, (const sockaddr *)&m_stClientSockaddr, sizeof(m_stClientSockaddr)); m_timer.SetEndTime(); if (m_nBytesSent == CSimpleSocket::SocketError) { TranslateSocketError(); } } } break; } default: CSimpleSocket::Send(pBuf, bytesToSend); break; } return m_nBytesSent; }
//------------------------------------------------------------------------------ // // Open() - Create a connection to a specified address on a specified port // //------------------------------------------------------------------------------ bool CActiveSocket::Open(const char *pAddr, uint16 nPort) { bool bRetVal = false; if (IsSocketValid() == false) { SetSocketError(CSimpleSocket::SocketInvalidSocket); return bRetVal; } if (pAddr == NULL) { SetSocketError(CSimpleSocket::SocketInvalidAddress); return bRetVal; } if (nPort == 0) { SetSocketError(CSimpleSocket::SocketInvalidPort); return bRetVal; } switch (m_nSocketType) { case CSimpleSocket::SocketTypeTcp : { bRetVal = ConnectTCP(pAddr, nPort); break; } case CSimpleSocket::SocketTypeUdp : { bRetVal = ConnectUDP(pAddr, nPort); break; } case CSimpleSocket::SocketTypeRaw : break; default: break; } //-------------------------------------------------------------------------- // If successful then create a local copy of the address and port //-------------------------------------------------------------------------- if (bRetVal) { socklen_t nSockLen = sizeof(struct sockaddr); memset(&m_stServerSockaddr, 0, nSockLen); getpeername(m_socket, (struct sockaddr *)&m_stServerSockaddr, &nSockLen); nSockLen = sizeof(struct sockaddr); memset(&m_stClientSockaddr, 0, nSockLen); getsockname(m_socket, (struct sockaddr *)&m_stClientSockaddr, &nSockLen); SetSocketError(SocketSuccess); } return bRetVal; }
int CSocket::Send(char* pBuf,int len) { if(!IsSocketValid() || !isConnected) { return 0; } if(pBuf==NULL || len<1) { return 0; } sendCount=send(csocket,pBuf,len,0); if(sendCount<=0) { cout<<GetSocketError()<<endl; } return sendCount; }
//------------------------------------------------------------------------------ // // SetSocketDscp() // //------------------------------------------------------------------------------ bool TDSocket::SetSocketDscp(i32 nDscp) { bool bRetVal = true; i32 nTempVal = nDscp; nTempVal <<= 4; nTempVal /= 4; if (IsSocketValid()) { if (SETSOCKOPT(m_socket, IPPROTO_IP, IP_TOS, &nTempVal, sizeof(nTempVal)) == SocketError) { TranslateSocketError(); bRetVal = false; } } return bRetVal; }
int CSocket::Receive(int strLen) { recvCount=0; if(!IsSocketValid() || !isConnected) { return recvCount; } if(strLen<1) { return recvCount; } if(buffer!=NULL) { delete buffer; buffer=NULL; } buffer=new char[strLen]; SetSocketError(SocketEnum::Success); while(1){ cout << "wait rec" << endl; recvCount=recv(csocket,buffer,strLen,0) ; cout << "rec over" << endl; if(recvCount>0){ buffer[recvCount]='\0'; if(IsExit()) { Send(buffer,recvCount); delete buffer; buffer=NULL; recvCount=0; break; }else{ for (int i = 0; i < recvCount; i++) { cout << buffer[i] << endl; } cout<<buffer<<endl; } } } return recvCount; }
//------------------------------------------------------------------------------ // // Close() - Close socket and free up any memory allocated for the socket // //------------------------------------------------------------------------------ bool CPassiveSocket::Close(void) { if (IsSocketValid()) { if (shutdown(m_socket, CSimpleSocket::Both) != CSimpleSocket::SocketError) { if (CLOSE(m_socket) != CSimpleSocket::SocketError) { m_socket = CSimpleSocket::SocketError; SetSocketError(CSimpleSocket::SocketInvalidSocket); return true; } } } TranslateSocketError(); return false; }
//------------------------------------------------------------------------------ // // Close() - Close socket and free up any memory allocated for the socket // //------------------------------------------------------------------------------ bool TDSocket::Close(void) { bool bRetVal = false; //-------------------------------------------------------------------------- // if socket handle is currently valid, close and then invalidate //-------------------------------------------------------------------------- if (IsSocketValid()) { if (CLOSE(m_socket) != TDSocket::SocketError) { m_socket = INVALID_SOCKET; bRetVal = true; } } m_bIsConnect = false; TranslateSocketError(); return bRetVal; }
//------------------------------------------------------------------------------ // // Initialize() - Initialize socket class // //------------------------------------------------------------------------------ bool TDSocket::Initialize() { errno = TDSocket::SocketSuccess; #ifdef WIN32 //------------------------------------------------------------------------- // Data structure containing general Windows Sockets Info //------------------------------------------------------------------------- //memset(&m_hWSAData, 0, sizeof(m_hWSAData)); WSAStartup(MAKEWORD(2, 0), &m_hWSAData); #endif //------------------------------------------------------------------------- // Create the basic Socket Handle //------------------------------------------------------------------------- m_socket = socket(m_nSocketDomain, m_nSocketType, 0); TranslateSocketError(); return (IsSocketValid()); }
//------------------------------------------------------------------------------ // // Receive() - Attempts to receive a block of data on an established // connection. Data is received in an internal buffer managed // by the class. This buffer is only valid until the next call // to Receive(), a call to Close(), or until the object goes out // of scope. // //------------------------------------------------------------------------------ i32 TDSocket::Receive(i32 nMaxBytes) { m_nBytesReceived = 0; //-------------------------------------------------------------------------- // If the socket is invalid then return false. //-------------------------------------------------------------------------- if (IsSocketValid() == false) { return m_nBytesReceived; } //-------------------------------------------------------------------------- // Free existing buffer and allocate a new buffer the size of // nMaxBytes. //-------------------------------------------------------------------------- if (nMaxBytes != m_nBufferSize) { m_nBufferSize = nMaxBytes; m_pBuffer.clear(); m_pBuffer.resize(m_nBufferSize); } SetSocketError(SocketSuccess); switch (m_nSocketType) { //---------------------------------------------------------------------- // If zero bytes are received, then return. If SocketERROR is // received, free buffer and return CSocket::SocketError (-1) to caller. //---------------------------------------------------------------------- case TDSocket::SocketTypeTcp: { do { m_nBytesReceived = RECV(m_socket, &m_pBuffer[m_nBytesReceived], nMaxBytes - m_nBytesReceived, m_nFlags); TranslateSocketError(); } while (IsSocketValid() && (GetSocketError() == TDSocket::SocketInterrupted)); break; } case TDSocket::SocketTypeUdp: { socklen_t srcSize; srcSize = sizeof(struct sockaddr_in); if (GetMulticast() == true) { do { m_nBytesReceived = RECVFROM(m_socket, &m_pBuffer[0], nMaxBytes, 0, &m_stMulticastGroup, &srcSize); TranslateSocketError(); } while (IsSocketValid() && GetSocketError() == TDSocket::SocketInterrupted); } else { do { m_nBytesReceived = RECVFROM(m_socket, &m_pBuffer[0], nMaxBytes, 0, &m_stClientSockaddr, &srcSize); TranslateSocketError(); } while (GetSocketError() == TDSocket::SocketInterrupted); } break; } default: break; } TranslateSocketError(); return m_nBytesReceived; }
//------------------------------------------------------------------------------ // // Send() - Send data on a valid socket // //------------------------------------------------------------------------------ i32 TDSocket::Send(const char *pBuf, size_t bytesToSend) { SetSocketError(SocketSuccess); m_nBytesSent = 0; switch (m_nSocketType) { case TDSocket::SocketTypeTcp: { if (IsSocketValid()) { if ((bytesToSend > 0) && (pBuf != NULL)) { //--------------------------------------------------------- // Check error condition and attempt to resend if call // was interrupted by a signal. //--------------------------------------------------------- do { m_nBytesSent = SEND(m_socket, pBuf, bytesToSend, 0); TranslateSocketError(); } while (GetSocketError() == TDSocket::SocketInterrupted); } } break; } case TDSocket::SocketTypeUdp: { if (IsSocketValid()) { if ((bytesToSend > 0) && (pBuf != NULL)) { //--------------------------------------------------------- // Check error condition and attempt to resend if call // was interrupted by a signal. //--------------------------------------------------------- // if (GetMulticast()) // { // do // { // m_nBytesSent = SENDTO(m_socket, pBuf, bytesToSend, 0, (const sockaddr *)&m_stMulticastGroup, // sizeof(m_stMulticastGroup)); // TranslateSocketError(); // } while (GetSocketError() == TDSocket::SocketInterrupted); // } // else { do { m_nBytesSent = SENDTO(m_socket, pBuf, bytesToSend, 0, (const sockaddr *)&m_stServerSockaddr, sizeof(m_stServerSockaddr)); TranslateSocketError(); } while (GetSocketError() == TDSocket::SocketInterrupted); } } } break; } default: break; } return m_nBytesSent; }
//------------------------------------------------------------------------------ // // Receive() - Attempts to receive a block of data on an established // connection. Data is received in an internal buffer managed // by the class. This buffer is only valid until the next call // to Receive(), a call to Close(), or until the object goes out // of scope. // //------------------------------------------------------------------------------ int32 CSimpleSocket::Receive(int32 nMaxBytes) { m_nBytesReceived = 0; //-------------------------------------------------------------------------- // If the socket is invalid then return false. //-------------------------------------------------------------------------- if (IsSocketValid() == false) { return m_nBytesReceived; } //-------------------------------------------------------------------------- // Free existing buffer and allocate a new buffer the size of // nMaxBytes. //-------------------------------------------------------------------------- if ((m_pBuffer != NULL) && (nMaxBytes != m_nBufferSize)) { delete [] m_pBuffer; m_pBuffer = NULL; } //-------------------------------------------------------------------------- // Allocate a new internal buffer to receive data. //-------------------------------------------------------------------------- if (m_pBuffer == NULL) { m_nBufferSize = nMaxBytes; m_pBuffer = new uint8[nMaxBytes]; } SetSocketError(SocketSuccess); switch (m_nSocketType) { m_timer.Initialize(); m_timer.SetStartTime(); //---------------------------------------------------------------------- // If zero bytes are received, then return. If SocketERROR is // received, free buffer and return CSocket::SocketError (-1) to caller. //---------------------------------------------------------------------- case CSimpleSocket::SocketTypeTcp: { do { m_nBytesReceived = RECV(m_socket, (m_pBuffer + m_nBytesReceived), nMaxBytes, m_nFlags); TranslateSocketError(); } while ((GetSocketError() == CSimpleSocket::SocketInterrupted)); break; } case CSimpleSocket::SocketTypeUdp: { uint32 srcSize; srcSize = sizeof(struct sockaddr_in); if (GetMulticast() == true) { do { m_nBytesReceived = RECVFROM(m_socket, m_pBuffer, nMaxBytes, 0, &m_stMulticastGroup, &srcSize); TranslateSocketError(); } while (GetSocketError() == CSimpleSocket::SocketInterrupted); } else { do { m_nBytesReceived = RECVFROM(m_socket, m_pBuffer, nMaxBytes, 0, &m_stClientSockaddr, &srcSize); TranslateSocketError(); } while (GetSocketError() == CSimpleSocket::SocketInterrupted); } break; } default: break; } m_timer.SetEndTime(); TranslateSocketError(); //-------------------------------------------------------------------------- // If we encounter an error translate the error code and return. One // possible error code could be EAGAIN (EWOULDBLOCK) if the socket is // non-blocking. This does not mean there is an error, but no data is // yet available on the socket. //-------------------------------------------------------------------------- if (m_nBytesReceived == CSimpleSocket::SocketError) { if (m_pBuffer != NULL) { delete [] m_pBuffer; m_pBuffer = NULL; } } return m_nBytesReceived; }