{

#if SRT_ENABLE_BONDING

m_GroupOf = NULL;

m_GroupMemberData = NULL;

#endif

setupMutex(m_AcceptLock, "Accept");

setupCond(m_AcceptCond, "Accept");

setupMutex(m_ControlLock, "Control");

{

++m_iBusy;

HLOGC(smlog.Debug, log << "@" << id() << " ACQUIRE; BUSY=" << int(m_iBusy) << " {");

return m_iBusy;

{

--m_iBusy;

HLOGC(smlog.Debug, log << "@" << id() << " RELEASE; BUSY=" << int(m_iBusy) << " }");

return m_iBusy;

{

m_UDT.resetAtFork();

resetCond(m_AcceptCond);

{

// TTL in CRendezvousQueue::updateConnStatus() will set m_bConnecting to false.

// Although m_Status is still SRTS_CONNECTING, the connection is in fact to be closed due to TTL expiry.

// In this case m_bConnected is also false. Both checks are required to avoid hitting

// a regular state transition from CONNECTING to CONNECTED.

if (m_UDT.m_bBroken)

return SRTS_BROKEN;

// Connecting timed out

if ((m_Status == SRTS_CONNECTING) && !m_UDT.m_bConnecting && !m_UDT.m_bConnected)

return SRTS_BROKEN;

return m_Status;

{

// This function is intended to be called from GC,

// under a lock of m_GlobControlLock.

m_UDT.m_bBroken = true;

// SET THIS to true because this function is called always for a socket

// that will never have any chance in the future to be manually closed.

m_UDT.m_bManaged = true;

m_UDT.m_iBrokenCounter = 0;

HLOGC(smlog.Debug, log << "@" << m_UDT.m_SocketID << " CLOSING AS SOCKET");

m_UDT.closeEntity(reason);

setClosed();

{

m_Status = SRTS_CLOSED;

// a socket will not be immediately removed when it is closed

// in order to prevent other methods from accessing invalid address

// a timer is started and the socket will be removed after approximately

// 1 second

m_tsClosureTimeStamp = steady_clock::now();

{

m_UDT.m_iBrokenCounter = 60;

m_UDT.m_bBroken = true;

setClosed();

{

if (m_UDT.m_bConnected && m_UDT.isRcvBufferReady())

return true;

if (m_UDT.m_bListening)

return !m_QueuedSockets.empty();

return broken();

: m_Sockets()

, m_GlobControlLock()

, m_IDLock()

, m_mMultiplexer()

, m_pCache(new CCache<CInfoBlock>)

, m_bGCClosing(false)

, m_GCStopCond()

, m_InitLock()

, m_iInstanceCount(0)

, m_bGCStatus(false)

{

// Socket ID MUST start from a random value

m_SocketIDGenerator = genRandomInt(1, MAX_SOCKET_VAL);

m_SocketIDGenerator_init = m_SocketIDGenerator;

// XXX An unlikely exception thrown from the below calls

// might destroy the application before `main`. This shouldn't

// be a problem in general.

setupMutex(m_GCStartLock, "GCStart");

setupMutex(m_GCStopLock, "GCStop");

setupCond(m_GCStopCond, "GCStop");

setupMutex(m_GlobControlLock, "GlobControl");

setupMutex(m_IDLock, "ID");

setupMutex(m_InitLock, "Init");

// Global initialization code

#ifdef _WIN32

WORD wVersionRequested;

WSADATA wsaData;

wVersionRequested = MAKEWORD(2, 2);

if (0 != WSAStartup(wVersionRequested, &wsaData))

throw CUDTException(MJ_SETUP, MN_NONE, WSAGetLastError());

#endif

CCryptoControl::globalInit();

HLOGC(inlog.Debug, log << "SRT Clock Type: " << SRT_SYNC_CLOCK_STR);

{

if (int32_t(sock) <= 0) // embraces SRT_INVALID_SOCK, SRT_SOCKID_CONNREQ and illegal negative domain

return "";

return hvu::fmtcat("@", int(sock), ":");

{

ScopedLock guard(m_GCStartLock);

if (!m_bGCStatus)

{

m_bGCClosing = false;

m_bGCStatus = StartThread(m_GCThread, garbageCollect, this, "SRT:GC");

}

return m_bGCStatus;

{

ScopedLock guard(m_GCStartLock);

if (m_bGCStatus)

{

m_bGCStatus = false;

{

CUniqueSync gclock (m_GCStopLock, m_GCStopCond);

m_bGCClosing = true;

gclock.notify_all();

}

m_GCThread.join();

}

{

for (sockets_t::iterator i = m_Sockets.begin(); i != m_Sockets.end(); ++i)

{

CUDTSocket* s = i->second;

#if ENABLE_BONDING

if (s->m_GroupOf)

{

s->removeFromGroup(false);

}

#endif

// remove from listener's queue

sockets_t::iterator ls = m_Sockets.find(s->m_ListenSocket);

if (ls == m_Sockets.end())

{

ls = m_ClosedSockets.find(s->m_ListenSocket);

}

if (ls != m_ClosedSockets.end())

{

ls->second->m_QueuedSockets.erase(s->id());

}

s->core().closeAtFork();

s->resetAtFork();

delete(s);

}

m_Sockets.clear();

#if ENABLE_BONDING

for (groups_t::iterator j = m_Groups.begin(); j != m_Groups.end(); ++j)

{

delete j->second;

}

m_Groups.clear();

#endif

for (map<int, CMultiplexer>::iterator i = m_mMultiplexer.begin(); i != m_mMultiplexer.end(); ++i)

{

CMultiplexer &multiplexer = i->second;

multiplexer.resetAtFork();

}

m_mMultiplexer.clear();

{

// remove all sockets and multiplexers

HLOGC(inlog.Debug, log << "GC: GLOBAL EXIT - releasing all pending sockets. Acquiring control lock...");

{

// Pre-closing: run over all open sockets and close them.

SharedLock glock(m_GlobControlLock);

for (sockets_t::iterator i = m_Sockets.begin(); i != m_Sockets.end(); ++i)

{

CUDTSocket* s = i->second;

s->breakSocket_LOCKED(SRT_CLS_CLEANUP);

#if SRT_ENABLE_BONDING

if (s->m_GroupOf)

{

HLOGC(smlog.Debug,

log << "@" << s->id() << " IS MEMBER OF $" << s->m_GroupOf->id()

<< " (IPE?) - REMOVING FROM GROUP");

s->removeFromGroup(false);

}

#endif

}

}

{

ExclusiveLock glock(m_GlobControlLock);

// Do not do generative expiry removal - there's no chance

// anyone can extract the close reason information since this point on.

m_ClosedDatabase.clear();

for (sockets_t::iterator i = m_Sockets.begin(); i != m_Sockets.end(); ++i)

{

CUDTSocket* s = i->second;

// NOTE: not removing the socket from m_Sockets.

// This is a loop over m_Sockets and after this loop ends,

// this whole container will be cleared.

swipeSocket_LOCKED(i->first, s, SWIPE_LATER);

if (s->m_ListenSocket != SRT_SOCKID_CONNREQ)

{

// remove from listener's queue

sockets_t::iterator ls = m_Sockets.find(s->m_ListenSocket);

if (ls == m_Sockets.end())

{

ls = m_ClosedSockets.find(s->m_ListenSocket);

if (ls == m_ClosedSockets.end())

continue;

}

HLOGC(smlog.Debug, log << "@" << s->id() << " removed from queued sockets of listener @" << ls->second->id());

enterCS(ls->second->m_AcceptLock);

ls->second->m_QueuedSockets.erase(s->id());

leaveCS(ls->second->m_AcceptLock);

}

}

m_Sockets.clear();

for (sockets_t::iterator j = m_ClosedSockets.begin(); j != m_ClosedSockets.end(); ++j)

{

j->second->m_tsClosureTimeStamp = steady_clock::time_point();

}

#if SRT_ENABLE_BONDING

for (groups_t::iterator j = m_Groups.begin(); j != m_Groups.end(); ++j)

{

SRTSOCKET id = j->second->m_GroupID;

m_ClosedGroups[id] = j->second;

}

m_Groups.clear();

#endif

}

HLOGC(inlog.Debug, log << "GC: GLOBAL EXIT - releasing all CLOSED sockets.");

while (true)

{

checkBrokenSockets();

enterCS(m_GlobControlLock);

bool empty = m_ClosedSockets.empty();

size_t remmuxer = m_mMultiplexer.size();

#if HVU_ENABLE_HEAVY_LOGGING

ostringstream om;

if (remmuxer)

{

om << "[";

for (map<int, CMultiplexer>::iterator i = m_mMultiplexer.begin(); i != m_mMultiplexer.end(); ++i)

om << " " << i->first;

om << " ]";

}

#endif

leaveCS(m_GlobControlLock);

if (empty && remmuxer == 0)

break;

HLOGC(inlog.Debug, log << "GC: checkBrokenSockets didn't wipe all sockets or muxers="

<< remmuxer << om.str() << ", repeating after 0.1s sleep");

sync::this_thread::sleep_for(milliseconds_from(100));

}

{

ScopedLock gcinit(m_InitLock);

m_iInstanceCount++;

if (m_bGCStatus)

return (m_iInstanceCount == 1) ? SRT_RUN_ALREADY : SRT_RUN_OK;

else

return startGarbageCollector() ? SRT_RUN_OK : SRT_RUN_ERROR;

{

cleanupAllSockets();

resetThread(&m_GCThread);

resetCond(m_GCStopCond);

m_GCStopLock.unlock();

setupCond(m_GCStopCond, "GCStop");

m_iInstanceCount=0;

m_bGCStatus = false;

return 0;

{

// IMPORTANT!!!

// In this function there must be NO LOGGING AT ALL. This function may

// potentially be called from within the global program destructor, and

// therefore some of the facilities used by the logging system - including

// the default std::cerr object bound to it by default, but also a different

// stream that the user's app has bound to it, and which got destroyed

// together with already exited main() - may be already deleted when

// executing this procedure.

ScopedLock gcinit(m_InitLock);

if (--m_iInstanceCount > 0)

return SRT_STATUS_OK;

stopGarbageCollector();

closeAllSockets();

return SRT_STATUS_OK;

{

ScopedLock guard(m_IDLock);

int sockval = m_SocketIDGenerator - 1;

// First problem: zero-value should be avoided by various reasons.

if (sockval <= 0)

{

// We have a rollover on the socket value, so

// definitely we haven't made the Columbus mistake yet.

m_SocketIDGenerator = MAX_SOCKET_VAL;

sockval = MAX_SOCKET_VAL;

}

// Check all sockets if any of them has this value.

// Socket IDs are begin created this way:

//

// Initial random

// |

// |

// |

// |

// ...

// The only problem might be if the number rolls over

// and reaches the same value from the opposite side.

// This is still a valid socket value, but this time

// we have to check, which sockets have been used already.

if (sockval == m_SocketIDGenerator_init)

{

// Mark that since this point on the checks for

// whether the socket ID is in use must be done.

m_SocketIDGenerator_init = 0;

}

// This is when all socket numbers have been already used once.

// This may happen after many years of running an application

// constantly when the connection breaks and gets restored often.

if (m_SocketIDGenerator_init == 0)

{

int startval = sockval;

for (;;) // Roll until an unused value is found

{

enterCS(m_GlobControlLock);

const bool exists =

#if SRT_ENABLE_BONDING

for_group

? m_Groups.count(SRTSOCKET(sockval | SRTGROUP_MASK))

:

#endif

m_Sockets.count(SRTSOCKET(sockval));

leaveCS(m_GlobControlLock);

if (exists)

{

// The socket value is in use.

--sockval;

if (sockval <= 0)

sockval = MAX_SOCKET_VAL;

// Before continuing, check if we haven't rolled back to start again

// This is virtually impossible, so just make an RTI error.

if (sockval == startval)

{

// Of course, we don't lack memory, but actually this is so impossible

// that a complete memory extinction is much more possible than this.

// So treat this rather as a formal fallback for something that "should

// never happen". This should make the socket creation functions, from

// socket_create and accept, return this error.

m_SocketIDGenerator = sockval + 1; // so that any next call will cause the same error

throw CUDTException(MJ_SYSTEMRES, MN_MEMORY, 0);

}

// try again, if this is a free socket

continue;

}

// No socket found, this ID is free to use

m_SocketIDGenerator = sockval;

break;

}

}

else

{

m_SocketIDGenerator = sockval;

}

// The socket value counter remains with the value rolled

// without the group bit set; only the returned value may have

// the group bit set.

if (for_group)

sockval = m_SocketIDGenerator | SRTGROUP_MASK;

else

sockval = m_SocketIDGenerator;

LOGC(smlog.Debug, log << "generateSocketID: " << (for_group ? "(group)" : "") << ": @" << sockval);

return SRTSOCKET(sockval);

{

// XXX consider using some replacement of std::unique_ptr

// so that exceptions will clean up the object without the

// need for a dedicated code.

CUDTSocket* ns = NULL;

try

{

ns = new CUDTSocket;

}

catch (...)

{

delete ns;

throw CUDTException(MJ_SYSTEMRES, MN_MEMORY, 0);

}

try

{

ns->core().m_SocketID = generateSocketID();

}

catch (...)

{

delete ns;

throw;

}

ns->m_Status = SRTS_INIT;

ns->m_ListenSocket = SRT_SOCKID_CONNREQ; // A value used for socket if it wasn't listener-spawned

ns->core().m_pCache = m_pCache;

ns->core().m_bManaged = managed;

try

{

HLOGC(smlog.Debug, log << CONID(ns->id()) << "newSocket: mapping socket " << ns->id());

// protect the m_Sockets structure.

ExclusiveLock cs(m_GlobControlLock);

m_Sockets[ns->id()] = ns;

}

catch (...)

{

// failure and rollback

delete ns;

ns = NULL;

throw CUDTException(MJ_SYSTEMRES, MN_MEMORY, 0);

}

{

ScopedLock glk (m_InitLock);

startGarbageCollector();

}

if (pps)

*pps = ns;

return ns->id();

{

m_ClosedSockets[id] = s;

if (!lateremove)

{

m_Sockets.erase(id);

}

const sockaddr_any& peer,

const CPacket& hspkt,

CHandShake& w_hs,

int& w_error,

CUDT*& w_acpu)

{

CUDTSocket* ns = NULL;

w_acpu = NULL;

w_error = SRT_REJ_IPE;

// Can't manage this error through an exception because this is

// running in the listener loop.

CUDTSocket* ls = locateSocket(listener);

if (!ls)

{

LOGC(cnlog.Error, log << "IPE: newConnection by listener socket id=" << listener << " which DOES NOT EXIST.");

return -1;

}

HLOGC(cnlog.Debug,

log << "newConnection: creating new socket after listener @" << listener

<< " contacted with backlog=" << ls->m_uiBackLog);

// if this connection has already been processed

if ((ns = locatePeer(peer, w_hs.m_iID, w_hs.m_iISN)) != NULL)

{

if (ns->core().m_bBroken)

{

// last connection from the "peer" address has been broken

ns->setClosed();

HLOGC(cnlog.Debug, log << "newConnection: @" << ns->id() << " broken - deleting from queued");

ScopedLock acceptcg(ls->m_AcceptLock);

ls->m_QueuedSockets.erase(ns->id());

}

else

{

// connection already exist, this is a repeated connection request

// respond with existing HS information

HLOGC(cnlog.Debug, log << "newConnection: located a WORKING peer @" << w_hs.m_iID << " - ADAPTING.");

w_hs.m_iISN = ns->core().m_iISN;

w_hs.m_iMSS = ns->core().MSS();

w_hs.m_iFlightFlagSize = ns->core().m_config.iFlightFlagSize;

w_hs.m_iReqType = URQ_CONCLUSION;

w_hs.m_iID = ns->id();

// Report the original UDT because it will be

// required to complete the HS data for conclusion response.

w_acpu = &ns->core();

return 0;

// except for this situation a new connection should be started

}

}

else

{

HLOGC(cnlog.Debug,

log << "newConnection: NOT located any peer @" << w_hs.m_iID << " - resuming with initial connection.");

}

// exceeding backlog, refuse the connection request

enterCS(ls->m_AcceptLock);

size_t backlog = ls->m_QueuedSockets.size();

leaveCS(ls->m_AcceptLock);

if (backlog >= ls->m_uiBackLog)

{

w_error = SRT_REJ_BACKLOG;

LOGC(cnlog.Note, log << "newConnection: listen backlog=" << ls->m_uiBackLog << " EXCEEDED");

return -1;

}

try

{

// Protect the config of the listener socket from a data race.

ScopedLock lck(ls->core().m_ConnectionLock);

ns = new CUDTSocket(*ls);

// No need to check the peer, this is the address from which the request has come.

ns->m_PeerAddr = peer;

}

catch (...)

{

w_error = SRT_REJ_RESOURCE;

delete ns;

LOGC(cnlog.Error, log << "IPE: newConnection: unexpected exception (probably std::bad_alloc)");

return -1;

}

ns->core().m_RejectReason = SRT_REJ_UNKNOWN; // pre-set a universal value

try

{

ns->core().m_SocketID = generateSocketID();

}

catch (const CUDTException&)

{

LOGC(cnlog.Fatal, log << "newConnection: IPE: all sockets occupied? Last gen=" << m_SocketIDGenerator);

// generateSocketID throws exception, which can be naturally handled

// when the call is derived from the API call, but here it's called

// internally in response to receiving a handshake. It must be handled

// here and turned into an erroneous return value.

delete ns;

return -1;

}

ns->m_ListenSocket = listener;

ns->core().m_PeerID = w_hs.m_iID;

ns->m_iISN = w_hs.m_iISN;

HLOGC(cnlog.Debug,

log << "newConnection: DATA: lsnid=" << listener << " id=" << ns->id()

<< " peerid=" << ns->core().m_PeerID << " ISN=" << ns->m_iISN);

int error = 0;

bool should_submit_to_accept = true;

// Set the error code for all prospective problems below.

// It won't be interpreted when result was successful.

w_error = SRT_REJ_RESOURCE;

// These can throw exception only when the memory allocation failed.

// CUDT::connect() translates exception into CUDTException.

// CUDT::open() may only throw original std::bad_alloc from new.

// This is only to make the library extra safe (when your machine lacks

// memory, it will continue to work, but fail to accept connection).

try

{

// This assignment must happen b4 the call to CUDT::connect() because

// this call causes sending the SRT Handshake through this socket.

// Without this mapping the socket cannot be found and therefore

// the SRT Handshake message would fail.

HLOGC(cnlog.Debug, log <<

"newConnection: incoming " << peer.str() << ", mapping socket " << ns->id());

{

ExclusiveLock cg(m_GlobControlLock);

m_Sockets[ns->id()] = ns;

}

if (ls->core().m_cbAcceptHook)

{

if (!ls->core().runAcceptHook(&ns->core(), peer.get(), w_hs, hspkt))

{

w_error = ns->core().m_RejectReason;

error = 1;

goto ERR_ROLLBACK;

}

}

// bind to the same addr of listening socket

ns->core().open();

if (!updateListenerMux(ns, ls))

{

// This is highly unlikely if not impossible, but there's

// a theoretical runtime chance of failure so it should be

// handled

ns->core().m_RejectReason = SRT_REJ_IPE;

throw false; // let it jump directly into the omni exception handler

}

ns->core().acceptAndRespond(ls, peer, hspkt, (w_hs));

}

catch (...)

{

// Extract the error that was set in this new failed entity.

w_error = ns->core().m_RejectReason;

error = 1;

goto ERR_ROLLBACK;

}

ns->m_Status = SRTS_CONNECTED;

// copy address information of local node

// Precisely, what happens here is:

// - Get the IP address and port from the system database

ns->m_SelfAddr = ns->core().channel()->getSockAddr();

// - OVERWRITE just the IP address itself by a value taken from piSelfIP

// (the family is used exactly as the one taken from what has been returned

// by getsockaddr)

CIPAddress::decode(ns->core().m_piSelfIP, peer, (ns->m_SelfAddr));

{

// protect the m_PeerRec structure (and group existence)

ExclusiveLock glock(m_GlobControlLock);

try

{

HLOGC(cnlog.Debug, log << "newConnection: mapping peer " << ns->core().m_PeerID

<< " to that socket (" << ns->id() << ")");

m_PeerRec[ns->getPeerSpec()].insert(ns->id());

LOGC(cnlog.Note, log << "@" << ns->id() << " connection on listener @" << listener

<< " (" << ns->m_SelfAddr.str() << ") from peer @" << ns->core().m_PeerID << " (" << peer.str() << ")");

}

catch (...)

{

LOGC(cnlog.Error, log << "newConnection: error when mapping peer!");

error = 2;

}

// The access to m_GroupOf should be also protected, as the group

// could be requested deletion in the meantime. This will hold any possible

// removal from group and resetting m_GroupOf field.

#if SRT_ENABLE_BONDING

if (ns->m_GroupOf)

{

// XXX this might require another check of group type.

// For redundancy group, at least, update the status in the group

CUDTGroup* g = ns->m_GroupOf;

ScopedLock grlock(g->m_GroupLock);

if (g->m_bClosing)

{

error = 1; // "INTERNAL REJECTION"

goto ERR_ROLLBACK;

}

// Acceptance of the group will have to be done through accepting

// of one of the pending sockets. There can be, however, multiple

// such sockets at a time, some of them might get broken before

// being accepted, and therefore we need to make all sockets ready.

// But then, acceptance of a group may happen only once, so if any

// sockets of the same group were submitted to accept, they must

// be removed from the accept queue at this time.

should_submit_to_accept = g->groupPending_LOCKED();

// Update the status in the group so that the next

// operation can include the socket in the group operation.

CUDTGroup::SocketData* gm = ns->m_GroupMemberData;

HLOGC(cnlog.Debug,

log << "newConnection(GROUP): Socket @" << ns->id() << " BELONGS TO $" << g->id() << " - will "

<< (should_submit_to_accept ? "" : "NOT ") << "report in accept");

gm->sndstate = SRT_GST_IDLE;

gm->rcvstate = SRT_GST_IDLE;

gm->laststatus = SRTS_CONNECTED;

g->setGroupConnected();

// Add also per-direction subscription for the about-to-be-accepted socket.

// Both first accepted socket that makes the group-accept and every next

// socket that adds a new link.

int read_modes = SRT_EPOLL_IN | SRT_EPOLL_ERR;

int write_modes = SRT_EPOLL_OUT | SRT_EPOLL_ERR;

epoll_add_usock_INTERNAL(g->m_RcvEID, ns, &read_modes);

epoll_add_usock_INTERNAL(g->m_SndEID, ns, &write_modes);

// With app reader, do not set groupPacketArrival (block the

// provider array feature completely for now).

/* SETUP HERE IF NEEDED

}

else

{

HLOGC(cnlog.Debug, log << "newConnection: Socket @" << ns->id() << " is not in a group");

}

#endif

}

if (should_submit_to_accept)

{

enterCS(ls->m_AcceptLock);

try

{

ls->m_QueuedSockets[ns->id()] = ns->m_PeerAddr;

HLOGC(cnlog.Debug, log << "newConnection: Socket @" << ns->id() << " added to queued of @" << ls->id());

}

catch (...)

{

LOGC(cnlog.Error, log << "newConnection: error when queuing socket!");

error = 3;

}

leaveCS(ls->m_AcceptLock);

HLOGC(cnlog.Debug, log << "ACCEPT: new socket @" << ns->id() << " submitted for acceptance");

// acknowledge users waiting for new connections on the listening socket

m_EPoll.update_events(listener, ls->core().m_sPollID, SRT_EPOLL_ACCEPT, true);

CGlobEvent::triggerEvent();

// XXX the exact value of 'error' is ignored

if (error > 0)

{

goto ERR_ROLLBACK;

}

// wake up a waiting accept() call

CSync::lock_notify_one(ls->m_AcceptCond, ls->m_AcceptLock);

}

else

{

HLOGC(cnlog.Debug,

log << "ACCEPT: new socket @" << ns->id()

<< " NOT submitted to acceptance, another socket in the group is already connected");

// acknowledge INTERNAL users waiting for new connections on the listening socket

// that are reported when a new socket is connected within an already connected group.

m_EPoll.update_events(listener, ls->core().m_sPollID, SRT_EPOLL_UPDATE, true);

#if SRT_ENABLE_BONDING

// Note that the code in this current IF branch can only be executed in case

// of group members. Otherwise should_submit_to_accept will be always true.

if (ns->m_GroupOf)

{

HLOGC(gmlog.Debug, log << "GROUP UPDATE $" << ns->m_GroupOf->id() << " per connected socket @" << ns->id());

m_EPoll.update_events(ns->m_GroupOf->id(), ns->m_GroupOf->m_sPollID, SRT_EPOLL_UPDATE, true);

}

#endif

CGlobEvent::triggerEvent();

}

ERR_ROLLBACK:

// XXX the exact value of 'error' is ignored

if (error > 0)

{

#if HVU_ENABLE_LOGGING

static const char* why[] = {

"UNKNOWN ERROR", "INTERNAL REJECTION", "IPE when mapping a socket", "IPE when inserting a socket"};

LOGC(cnlog.Warn,

log << CONID(ns->id()) << "newConnection: connection rejected due to: " << why[error] << " - "