bool Socket::SetIpRecvTTL(bool x)
{
int optval = x ? 1 : 0;
if (setsockopt(GetSocket(), IPPROTO_IP, IP_RECVTTL, (char *)&optval, sizeof(optval)) == -1)
{
Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_RECVTTL)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
return false;
}
return true;
}
BOOL CXMMTCtrl::SendCode(short nIndex, short bCode)
{
if( bCode == CODE_CUSTOMSESSION ) return FALSE;
int r = FALSE;
CCSocket *pSocket = GetSocket(nIndex);
if( pSocket ){
BYTE b = BYTE(bCode);
r = SendBuf(pSocket, &b, sizeof(b));
}
return r;
}
bool ConnectionDescriptor::GetPeername (struct sockaddr *s)
{
bool ok = false;
if (s) {
socklen_t len = sizeof(*s);
int gp = getpeername (GetSocket(), s, &len);
if (gp == 0)
ok = true;
}
return ok;
}
int32_t CSSLClientAsync::ReConnectAsync()
{
int32_t nErrorCode = 0;
if (S_INVALID_SOCKET == GetSocket())
{
_InitSocket();
InitSSL(GetCertFile().c_str(), GetKeyFile().c_str(), GetKeyPassword().c_str());
nErrorCode = ConnectAsync(GetRemoteIP(), GetRemotePort());
}
return nErrorCode;
}
void CSSLClientAsync::_Close()
{
if (m_ssl)
{
UnInitSSL();
}
if (GetSocket() != S_INVALID_SOCKET)
{
if (m_pio)
{
m_pio->Remove_Handler(this);
}
SetSSLConnectStatus(FALSE);
S_CloseSocket(GetSocket());
SOCKET_IO_WARN("close ssl socket, sock %d, real sock: %d.", GetSocketID(), GetSocket());
m_socket = S_INVALID_SOCKET;
DoClose(GetSocketID());
_ClearSendBuffer();
}
}
bool AcceptorDescriptor::GetSockname (struct sockaddr *s)
{
bool ok = false;
if (s) {
socklen_t len = sizeof(*s);
int gp = getsockname (GetSocket(), s, &len);
if (gp == 0)
ok = true;
}
return ok;
}
bool UdpSocket::Open(SocketAddress& ad)
{
if (GetSocket() == INVALID_SOCKET)
{
Attach(CreateSocket(ad.GetFamily(), SOCK_DGRAM, "udp"));
}
if (GetSocket() != INVALID_SOCKET)
{
SetNonblocking(true);
if (connect(GetSocket(), ad, ad) == -1)
{
Handler().LogError(this, "connect", Errno, StrError(Errno), LOG_LEVEL_FATAL);
SetCloseAndDelete();
return false;
}
SetConnected();
return true;
}
return false;
}
///////////////////////////////////////////////////////////////////////////////
/// @fn CConnection::Stop
/// @description Stops the socket and cancels the timeout timer. Does not
/// need to be called on a listening connection (ie one that has had
/// Start() called on it.
/// @pre Any initialized CConnection object.
/// @post The underlying socket is closed and the message timeout timer is
/// cancelled.
///////////////////////////////////////////////////////////////////////////////
void CConnection::Stop()
{
Logger.Debug << __PRETTY_FUNCTION__ << std::endl;
ProtocolMap::iterator sit;
for(sit = m_protocols.begin(); sit != m_protocols.end(); sit++)
{
(*sit).second->Stop();
}
Logger.Debug << __PRETTY_FUNCTION__ << std::endl;
GetSocket().close();
}
/** Returns local port number for bound socket file descriptor. */
port_t Socket::GetSockPort()
{
#ifdef ENABLE_IPV6
#ifdef IPPROTO_IPV6
if (IsIpv6())
{
struct sockaddr_in6 sa;
socklen_t sockaddr_length = sizeof(struct sockaddr_in6);
if (getsockname(GetSocket(), (struct sockaddr *)&sa, (socklen_t*)&sockaddr_length) == -1)
memset(&sa, 0, sizeof(sa));
return ntohs(sa.sin6_port);
}
#endif
#endif
struct sockaddr_in sa;
socklen_t sockaddr_length = sizeof(struct sockaddr_in);
if (getsockname(GetSocket(), (struct sockaddr *)&sa, (socklen_t*)&sockaddr_length) == -1)
memset(&sa, 0, sizeof(sa));
return ntohs(sa.sin_port);
}
/** @fn HPR_INT32 CTCPClient::Connect(const char* szIP, HPR_INT32 nPort)
* @brief
* @param[in] szIP
* @param[in] nPort
* @return
*/
HPR_INT32 CTCPClient::Connect( const char* szIP, HPR_INT32 nPort )
{
HPR_INT32 nErrorCode = LIB_DEV_PROXY_ERROR_OK;
HPR_ADDR_T addr;
memset(&addr, 0, sizeof(HPR_ADDR_T));
HPR_MakeAddrByString(AF_INET, szIP, nPort, &addr);
if (HPR_ConnectWithTimeOut(GetSocket(), &addr, 5000) != 0)
{
nErrorCode = LIB_DEV_PROXY_ERROR_CONNECT;
}
return nErrorCode;
}
BOOL CXMMTCtrl::SendChar(short nIndex, short bChar)
{
if( bChar >= TNC_PTTON ) return FALSE;
int r = FALSE;
CCSocket *pSocket = GetSocket(nIndex);
if( pSocket ){
if( m_bBusy[nIndex] ) return FALSE;
BYTE b = BYTE(bChar);
r = SendBuf(pSocket, &b, sizeof(b));
}
return r;
}
void CItem::StopTimerBasedOnWearExpireEvent()
{
if (!m_pkTimerBasedOnWearExpireEvent)
return;
int remain_time = GetSocket(ITEM_SOCKET_REMAIN_SEC) - event_processing_time(m_pkTimerBasedOnWearExpireEvent) / passes_per_sec;
SetSocket(ITEM_SOCKET_REMAIN_SEC, remain_time);
event_cancel(&m_pkTimerBasedOnWearExpireEvent);
ITEM_MANAGER::instance().SaveSingleItem(this);
}
/** send to connected address */
void UdpSocket::SendBuf(const char *data, size_t len, int flags)
{
if (!IsConnected())
{
Handler().LogError(this, "SendBuf", 0, "not connected", LOG_LEVEL_ERROR);
return;
}
if ((m_last_size_written = send(GetSocket(), data, (int)len, flags)) == -1)
{
Handler().LogError(this, "send", Errno, StrError(Errno), LOG_LEVEL_ERROR);
}
}
void OnLine(const std::string& line) {
#ifdef ENABLE_DETACH
if (g_b_detach2 && !IsDetach())
{
m_line = line;
if (!Detach())
{
fprintf(stderr, "\nDetach failed\n");
}
return;
}
DEB(printf("fd %d OnLine; %s\n", GetSocket(), Handler().IsSlave() ? "slave" : "master");)
void Client::Connect(const std::string& ip, int port)
{
tcp::resolver resolver(ioService);
tcp::resolver::query query(ip, std::to_string(port));
auto endpointIt = resolver.resolve(query);
boost::system::error_code ec;
auto newConn = Connection::create(ioService);
boost::asio::async_connect(newConn->GetSocket(), endpointIt, std::bind(&Client::OnConnect, this, newConn, _1, _2));
}
///////////////////////////////////////////////////////////////////////////////
/// CConnection::HandleResend
/// @description: After being called, this method sends up WINDOWSIZE messages
/// to retry delievery.
/// @pre: Initialized CConnection.
/// @post: Upto WINDOWSIZE messages are rewritten to the channel.
///////////////////////////////////////////////////////////////////////////////
void CConnection::HandleResend()
{
Logger::Debug << __PRETTY_FUNCTION__ << std::endl;
SlidingWindow<QueueItem>::iterator sit;
sit = m_queue.begin();
for(unsigned int i=0; sit != m_queue.end() && i < GetWindowSize(); i++,sit++ )
{
GetSocket().get_io_service().post(
boost::bind(&CConnection::HandleSend, this,(*sit).second));
}
}
bool NetSocket::PostRecv()
{
_netStatus.fetch_or(NET_STATUS_RECV_PENDING);
NetIoBuffer* recvOP = new NetIoBuffer(NetCompletionOP::OP_READ);
recvOP->Reset(GetSocket());
MemoryBlock* buffer = recvOP->Alloc(MAX_PACKET_SIZE);
WSABUF wbuf;
wbuf.buf = buffer->GetData();
wbuf.len = buffer->GetDataLen();
DWORD flags = 0;
int rc = WSARecv(
GetSocket(),
&wbuf,
1,
NULL,
&flags,
&(recvOP->ol),
NULL
);
if (rc == SOCKET_ERROR)
{
int error = WSAGetLastError();
if (error != WSA_IO_PENDING)
{
delete recvOP;
DebugPrint("PostRecv: WSARecv* failed: %s", SocketGetErrorString(error).c_str());
Disconnect(NET_CTYPE_SYSTEM);
return false;
}
}
return true;
}
bool LRTGroupSession::Connect(const std::string addr, int port)
{
m_addr = addr;
m_port = port;
OS_Error err = GetSocket()->Connect(SocketUtils::ConvertStringToAddr(m_addr.c_str()), m_port);
if (err == OS_NoErr || err == EISCONN) {
m_connectingStatus = 1;
return true;
} else {
LE("%s ERR:%d\n", __FUNCTION__, err);
return false;
}
}
void UdpSocket::DropMulticastMembership(const std::string& group, const std::string& local_if, int if_index)
{
if (GetSocket() == INVALID_SOCKET)
{
CreateConnection();
}
#ifdef ENABLE_IPV6
#ifdef IPPROTO_IPV6
if (IsIpv6())
{
struct ipv6_mreq x;
struct in6_addr addr;
if (Utility::u2ip( group, addr ))
{
x.ipv6mr_multiaddr = addr;
x.ipv6mr_interface = if_index;
if (setsockopt(GetSocket(), IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP, (char *)&x, sizeof(struct ipv6_mreq)) == -1)
{
Handler().LogError(this, "DropMulticastMembership(ipv6)", Errno, StrError(Errno), LOG_LEVEL_WARNING);
}
}
return;
}
#endif
#endif
struct ip_mreq x; // ip_mreqn
ipaddr_t addr;
if (Utility::u2ip( group, addr ))
{
memcpy(&x.imr_multiaddr.s_addr, &addr, sizeof(addr));
Utility::u2ip( local_if, addr);
memcpy(&x.imr_interface.s_addr, &addr, sizeof(addr));
// x.imr_ifindex = if_index;
if (setsockopt(GetSocket(), SOL_IP, IP_DROP_MEMBERSHIP, (char *)&x, sizeof(struct ip_mreq)) == -1)
{
Handler().LogError(this, "DropMulticastMembership(ipv4)", Errno, StrError(Errno), LOG_LEVEL_WARNING);
}
}
}
int SctpSocket::Open(SocketAddress& ad)
{
if (!ad.IsValid())
{
Handler().LogError(this, "SctpSocket", -1, "invalid address", LOG_LEVEL_ERROR);
return -1;
}
if (GetSocket() == INVALID_SOCKET)
{
Attach(CreateSocket(ad.GetFamily(), m_type, "sctp"));
}
if (GetSocket() != INVALID_SOCKET)
{
if (!SetNonblocking(true))
{
return -1;
}
int n = connect(GetSocket(), ad, ad);
if (n == -1)
{
// check error code that means a connect is in progress
#ifdef _WIN32
if (Errno == WSAEWOULDBLOCK)
#else
if (Errno == EINPROGRESS)
#endif
{
Handler().LogError(this, "connect: connection pending", Errno, StrError(Errno), LOG_LEVEL_INFO);
SetConnecting( true ); // this flag will control fd_set's
}
else
{
Handler().LogError(this, "SctpSocket", -1, "connect() failed", LOG_LEVEL_ERROR);
}
}
return n;
}
return -1;
}
BSTR CXMMTCtrl::GetAddress(short nIndex)
{
CString strResult;
CCSocket *pSocket = GetSocket(nIndex);
if( pSocket ){
UINT PeerPort;
pSocket->GetPeerName(strResult, PeerPort);
}
else {
strResult = _T("Unknown");
}
return strResult.AllocSysString();
}
/** Returns local ipv6 address as text for bound socket file descriptor. */
std::string Socket::GetSockAddress6()
{
if (IsIpv6())
{
struct sockaddr_in6 sa;
socklen_t sockaddr_length = sizeof(struct sockaddr_in6);
if (getsockname(GetSocket(), (struct sockaddr *)&sa, (socklen_t*)&sockaddr_length) == -1)
memset(&sa, 0, sizeof(sa));
Ipv6Address addr( sa );
return addr.Convert();
}
return "";
}
void PacketHandlerCL::HandleSelectServer(ServerSocketCL* socket
, const void* data, int length) {
const auto req = static_cast<const SelectServerCL*>(data);
::printf("SelectServer: userId[%lld] serverId[%d]\n", req->m_userId, req->m_serverId);
SelectServerLC rsp;
const auto userId = req->m_userId;
User* user = UserManager::Instance().GetUser(userId);
if (NS_MZ::IsNull(user)) {
rsp.m_authCode = -1;
socket->m_packeter.SendData(rsp.COMMAND, &rsp, sizeof(rsp));
return;
}
const auto serverId = req->m_serverId;
const auto serverGroup = g_serverApp->m_serverGroupManager.GetServerGroup(serverId);
if (NS_MZ::IsNull(serverGroup)) {
rsp.m_authCode = -2;
socket->m_packeter.SendData(rsp.COMMAND, &rsp, sizeof(rsp));
return;
}
const auto status = serverGroup->GetStatus();
if (status == 0) {
rsp.m_authCode = -3;
socket->m_packeter.SendData(rsp.COMMAND, &rsp, sizeof(rsp));
return;
}
const auto address = serverGroup->SelectRandomAddress();
if (NS_MZ::IsNull(address)) {
rsp.m_authCode = -4;
socket->m_packeter.SendData(rsp.COMMAND, &rsp, sizeof(rsp));
return;
}
static NS_MZ_SHARE::Random s_random;
const auto authCode = s_random.GetRangeInt(1000000, 1000000000);
rsp.m_authCode = authCode;
rsp.m_address = *address;
socket->m_packeter.SendData(rsp.COMMAND, &rsp, sizeof(rsp));
UserCandidateLM reqLM;
reqLM.m_userId = userId;
reqLM.m_authCode = authCode;
serverGroup->GetSocket()->m_packeter.SendData(reqLM.COMMAND, &reqLM, sizeof(reqLM));
UserManager::Instance().RemoveUser(userId);
}
void ChatServerConnection::OnReceive(const char *pBuffer, uint32 nSize)
{
if (pBuffer) {
// Compose server message (we use the string copy constructor to ensure that there's a correct terminating zero)
const String sMessage = GetSocket().GetSocketAddress().GetHost() + ": '" + String(pBuffer, true, nSize-1) + '\''; // -1 = excluding the terminating zero
// Write the message into the log and start a new line
System::GetInstance()->GetConsole().Print(sMessage + '\n');
// Send message to all clients
for (uint32 i=0; i<GetHost().GetConnections().GetNumOfElements(); i++)
GetHost().GetConnections().Get(i)->Send(sMessage.GetASCII(), sMessage.GetLength()+1); // +1 so we also send the terminating zero
}
}
bool CItem::OnAfterCreatedItem()
{
// ¾ÆÀÌÅÛÀ» ÇÑ ¹øÀÌ¶óµµ »ç¿ëÇß´Ù¸é, ±× ÀÌÈÄ¿£ »ç¿ë ÁßÀÌÁö ¾Ê¾Æµµ ½Ã°£ÀÌ Â÷°¨µÇ´Â ¹æ½Ä
if (-1 != this->GetProto()->cLimitRealTimeFirstUseIndex)
{
// Socket1¿¡ ¾ÆÀÌÅÛÀÇ »ç¿ë Ƚ¼ö°¡ ±â·ÏµÇ¾î ÀÖÀ¸´Ï, ÇÑ ¹øÀÌ¶óµµ »ç¿ëÇÑ ¾ÆÀÌÅÛÀº ŸÀ̸Ӹ¦ ½ÃÀÛÇÑ´Ù.
if (0 != GetSocket(1))
{
StartRealTimeExpireEvent();
}
}
return true;
}
bool Socket::SetSoSndtimeo(struct timeval& tv)
{
#ifdef SO_SNDTIMEO
if (setsockopt(GetSocket(), SOL_SOCKET, SO_SNDTIMEO, (char *)&tv, sizeof(tv)) == -1)
{
Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_SNDTIMEO)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
return false;
}
return true;
#else
Handler().LogError(this, "socket option not available", 0, "SO_SNDTIMEO", LOG_LEVEL_INFO);
return false;
#endif
}
bool Socket::SetIpOptions(const void *p, socklen_t len)
{
#ifdef IP_OPTIONS
if (setsockopt(GetSocket(), IPPROTO_IP, IP_OPTIONS, (char *)p, len) == -1)
{
Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_OPTIONS)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
return false;
}
return true;
#else
Handler().LogError(this, "ip option not available", 0, "IP_OPTIONS", LOG_LEVEL_INFO);
return false;
#endif
}
/** Returns local ipv6 address for bound socket file descriptor. */
struct in6_addr Socket::GetSockIP6()
{
if (IsIpv6())
{
struct sockaddr_in6 sa;
socklen_t sockaddr_length = sizeof(struct sockaddr_in6);
if (getsockname(GetSocket(), (struct sockaddr *)&sa, (socklen_t*)&sockaddr_length) == -1)
memset(&sa, 0, sizeof(sa));
return sa.sin6_addr;
}
struct in6_addr a;
memset(&a, 0, sizeof(a));
return a;
}
bool Socket::SetSoSndbuf(int x)
{
#ifdef SO_SNDBUF
if (setsockopt(GetSocket(), SOL_SOCKET, SO_SNDBUF, (char *)&x, sizeof(x)) == -1)
{
Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_SNDBUF)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
return false;
}
return true;
#else
Handler().LogError(this, "socket option not available", 0, "SO_SNDBUF", LOG_LEVEL_INFO);
return false;
#endif
}
int Socket::SoType()
{
int value = 0;
#ifdef SO_TYPE
socklen_t len = sizeof(value);
if (getsockopt(GetSocket(), SOL_SOCKET, SO_TYPE, (char *)&value, &len) == -1)
{
Handler().LogError(this, "getsockopt(SOL_SOCKET, SO_TYPE)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
}
#else
Handler().LogError(this, "socket option not available", 0, "SO_TYPE", LOG_LEVEL_INFO);
#endif
return value;
}
