// Stop all listener in Cedar
void StopAllListener(CEDAR *c)
{
LISTENER **array;
UINT i, num;
// Validate arguments
if (c == NULL)
{
return;
}
LockList(c->ListenerList);
{
array = ToArray(c->ListenerList);
num = LIST_NUM(c->ListenerList);
DeleteAll(c->ListenerList);
}
UnlockList(c->ListenerList);
for (i = 0;i < num;i++)
{
StopListener(array[i]);
ReleaseListener(array[i]);
}
Free(array);
}
// Thread that processes the accepted TCP connection
void TCPAcceptedThread(THREAD *t, void *param)
{
TCP_ACCEPTED_PARAM *data;
LISTENER *r;
SOCK *s;
CONNECTION *c;
bool flag1;
char tmp[128];
// Validate arguments
if (t == NULL || param == NULL)
{
return;
}
// Initialize
data = (TCP_ACCEPTED_PARAM *)param;
r = data->r;
s = data->s;
AddRef(r->ref);
AddRef(s->ref);
// Create a connection
c = NewServerConnection(r->Cedar, s, t);
// Register to Cedar as a transient connection
AddConnection(c->Cedar, c);
NoticeThreadInit(t);
AcceptInit(s);
StrCpy(c->ClientHostname, sizeof(c->ClientHostname), s->RemoteHostname);
IPToStr(tmp, sizeof(tmp), &s->RemoteIP);
if (IS_SPECIAL_PORT(s->RemotePort) == false)
{
SLog(r->Cedar, "LS_LISTENER_ACCEPT", r->Port, tmp, s->RemoteHostname, s->RemotePort);
}
// Reception
ConnectionAccept(c);
flag1 = c->flag1;
// Release
SLog(r->Cedar, "LS_CONNECTION_END_1", c->Name);
ReleaseConnection(c);
// Release
if (flag1 == false)
{
Debug("%s %u flag1 == false\n", __FILE__, __LINE__);
IPToStr(tmp, sizeof(tmp), &s->RemoteIP);
if (IS_SPECIAL_PORT(s->RemotePort) == false)
{
SLog(r->Cedar, "LS_LISTENER_DISCONNECT", tmp, s->RemotePort);
}
Disconnect(s);
}
ReleaseSock(s);
ReleaseListener(r);
}
// Set the state to dynamic listener
void ApplyDynamicListener(DYNAMIC_LISTENER *d)
{
// Validate arguments
if (d == NULL)
{
return;
}
Lock(d->Lock);
{
// Change the state
if (*d->EnablePtr)
{
if (d->Listener == NULL)
{
// Create a listener
WHERE;
d->Listener = NewListener(d->Cedar, d->Protocol, d->Port);
}
}
else
{
// Stop the listener
if (d->Listener != NULL)
{
WHERE;
StopListener(d->Listener);
ReleaseListener(d->Listener);
d->Listener = NULL;
}
}
}
Unlock(d->Lock);
}
// Release the dynamic listener
void FreeDynamicListener(DYNAMIC_LISTENER *d)
{
// Validate arguments
if (d == NULL)
{
return;
}
Lock(d->Lock);
{
if (d->Listener != NULL)
{
StopListener(d->Listener);
ReleaseListener(d->Listener);
d->Listener = NULL;
}
}
Unlock(d->Lock);
ReleaseCedar(d->Cedar);
DeleteLock(d->Lock);
Free(d);
}
NDASHEAR_LINKAGE
HANDLE
NDASHEARAPI
NdasHeartbeatRegisterNotification(NDASHEARPROC proc, LPVOID lpContext)
{
if (::IsBadCodePtr((FARPROC)proc))
{
::SetLastError(ERROR_INVALID_PARAMETER);
return NULL;
}
CNdasDeviceHeartbeatListener* pListener = GetListenerInstance();
if (NULL == pListener)
{
return NULL;
}
CNdasDeviceHeartbeatProcHandler* pHandler =
new CNdasDeviceHeartbeatProcHandler(pListener, proc, lpContext);
if (NULL == pHandler)
{
ReleaseListener();
::SetLastError(ERROR_OUTOFMEMORY);
return NULL;
}
return CreateNdasHearHandle(pHandler);
}
NDASHEAR_LINKAGE
BOOL
NDASHEARAPI
NdasHeartbeatUnregisterNotification(HANDLE h)
{
if (IsBadNdasHearHandle(h))
{
::SetLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
DestroyNdasHearHandle(h);
ReleaseListener();
return TRUE;
}
// Listener stop
void ElStopListener(EL *e)
{
UINT i;
THREAD **threads;
SOCK **socks;
UINT num_threads, num_socks;
// Validate arguments
if (e == NULL)
{
return;
}
StopAllListener(e->Cedar);
LockList(e->AdminThreadList);
{
threads = ToArray(e->AdminThreadList);
num_threads = LIST_NUM(e->AdminThreadList);
DeleteAll(e->AdminThreadList);
socks = ToArray(e->AdminSockList);
num_socks = LIST_NUM(e->AdminSockList);
DeleteAll(e->AdminSockList);
}
UnlockList(e->AdminThreadList);
for (i = 0;i < num_socks;i++)
{
Disconnect(socks[i]);
ReleaseSock(socks[i]);
}
for (i = 0;i < num_threads;i++)
{
WaitThread(threads[i], INFINITE);
ReleaseThread(threads[i]);
}
Free(threads);
Free(socks);
ReleaseList(e->AdminSockList);
ReleaseList(e->AdminThreadList);
ReleaseListener(e->Listener);
}
// Listener Thread
void ListenerThread(THREAD *thread, void *param)
{
LISTENER *r;
// Validate arguments
if (thread == NULL || param == NULL)
{
return;
}
// Initialize
r = (LISTENER *)param;
AddRef(r->ref);
r->Thread = thread;
AddRef(thread->ref);
NoticeThreadInit(thread);
// Main loop
switch (r->Protocol)
{
case LISTENER_TCP:
case LISTENER_INPROC:
case LISTENER_RUDP:
case LISTENER_DNS:
case LISTENER_ICMP:
case LISTENER_REVERSE:
// TCP or other stream-based protocol
ListenerTCPMainLoop(r);
break;
case LISTENER_UDP:
// UDP protocol
ListenerUDPMainLoop(r);
break;
}
// Release
ReleaseListener(r);
}
// Shutdown the Listener
void StopListener(LISTENER *r)
{
UINT port;
SOCK *s = NULL;
// Validate arguments
if (r == NULL)
{
return;
}
Lock(r->lock);
if (r->Halt)
{
Unlock(r->lock);
return;
}
// Stop flag set
r->Halt = true;
if (r->Sock != NULL)
{
s = r->Sock;
AddRef(s->ref);
}
Unlock(r->lock);
port = r->Port;
if (r->ShadowIPv6 == false && r->Protocol == LISTENER_TCP)
{
SLog(r->Cedar, "LS_LISTENER_STOP_1", port);
}
// Close the socket
if (s != NULL)
{
Disconnect(s);
ReleaseSock(s);
s = NULL;
}
// Set the event
Set(r->Event);
// Wait for stopping the thread
WaitThread(r->Thread, INFINITE);
// Stop the shadow listener
if (r->ShadowIPv6 == false)
{
if (r->ShadowListener != NULL)
{
StopListener(r->ShadowListener);
ReleaseListener(r->ShadowListener);
r->ShadowListener = NULL;
}
}
if (r->ShadowIPv6 == false && r->Protocol == LISTENER_TCP)
{
SLog(r->Cedar, "LS_LISTENER_STOP_2", port);
}
}
