// Release the NAT
void NiFreeNat(NAT *n)
{
// Validate arguments
if (n == NULL)
{
return;
}
// Complete management command
//NiFreeAdminAccept(n);
// Stop if the virtual host is running
Lock(n->lock);
{
if (n->Virtual != NULL)
{
StopVirtualHost(n->Virtual);
ReleaseVirtual(n->Virtual);
n->Virtual = NULL;
}
}
Unlock(n->lock);
// Release the settings
NiFreeConfig(n);
// Delete the object
ReleaseCedar(n->Cedar);
ReleaseEvent(n->HaltEvent);
DeleteLock(n->lock);
Free(n);
}
// 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);
}
// NAT の解放
void NiFreeNat(NAT *n)
{
// 引数チェック
if (n == NULL)
{
return;
}
// 管理コマンド終了
//NiFreeAdminAccept(n);
// 仮想ホストが動作中の場合は停止
Lock(n->lock);
{
if (n->Virtual != NULL)
{
StopVirtualHost(n->Virtual);
ReleaseVirtual(n->Virtual);
n->Virtual = NULL;
}
}
Unlock(n->lock);
// 設定の解放
NiFreeConfig(n);
// オブジェクトの削除
ReleaseCedar(n->Cedar);
ReleaseEvent(n->HaltEvent);
DeleteLock(n->lock);
Free(n);
}
// Create a new stack
NATIVE_STACK *NewNativeStack(CEDAR *cedar, char *device_name, char *mac_address_seed)
{
ETH *eth;
NATIVE_STACK *a;
IP localhost;
char tmp[64];
bool release_cedar = false;
// Validate arguments
if (device_name == NULL || mac_address_seed == NULL)
{
return NULL;
}
GetLocalHostIP4(&localhost);
// Open the Eth device
eth = OpenEth(device_name, false, false, NULL);
if (eth == NULL)
{
return NULL;
}
if (cedar == NULL)
{
cedar = NewCedar(NULL, NULL);
release_cedar = true;
}
a = ZeroMalloc(sizeof(NATIVE_STACK));
NewSocketPair(&a->Sock1, &a->Sock2, &localhost, 1, &localhost, 1);
a->Cedar = cedar;
AddRef(a->Cedar->ref);
NsGenMacAddress(a->MacAddress, mac_address_seed, device_name);
BinToStr(tmp, sizeof(tmp), a->MacAddress, sizeof(a->MacAddress));
Debug("NewNativeStack: MAC Address = %s\n", tmp);
a->Ipc = NewIPCBySock(cedar, a->Sock2, a->MacAddress);
StrCpy(a->DeviceName, sizeof(a->DeviceName), device_name);
a->Eth = eth;
a->Cancel = EthGetCancel(eth);
a->MainThread = NewThread(NsMainThread, a);
if (release_cedar)
{
ReleaseCedar(cedar);
}
a->IsIpRawMode = a->Eth->IsRawIpMode;
return a;
}
// Release the SSTP server
void FreeSstpServer(SSTP_SERVER *s)
{
// Validate arguments
if (s == NULL)
{
return;
}
TubeDisconnect(s->TubeRecv);
TubeDisconnect(s->TubeSend);
WaitThread(s->PPPThread, INFINITE);
ReleaseThread(s->PPPThread);
while (true)
{
BLOCK *b = GetNext(s->RecvQueue);
if (b == NULL)
{
break;
}
FreeBlock(b);
}
while (true)
{
BLOCK *b = GetNext(s->SendQueue);
if (b == NULL)
{
break;
}
FreeBlock(b);
}
ReleaseQueue(s->RecvQueue);
ReleaseQueue(s->SendQueue);
ReleaseSockEvent(s->SockEvent);
FreeInterruptManager(s->Interrupt);
ReleaseCedar(s->Cedar);
ReleaseTube(s->TubeSend);
ReleaseTube(s->TubeRecv);
Free(s);
}
// Release and stop the IPsec server
void FreeIPsecServer(IPSEC_SERVER *s)
{
UINT i;
IPSEC_SERVICES sl;
// Validate arguments
if (s == NULL)
{
return;
}
s->NoMoreChangeSettings = true;
// Stopp the L2TP server
StopL2TPServer(s->L2TP, false);
// Stop the IKE server
StopIKEServer(s->Ike);
// Stop all the services explicitly
Zero(&sl, sizeof(sl));
IPsecServerSetServices(s, &sl);
// Releasing process
FreeUdpListener(s->UdpListener);
ReleaseCedar(s->Cedar);
FreeL2TPServer(s->L2TP);
FreeIKEServer(s->Ike);
for (i = 0;i < LIST_NUM(s->EtherIPIdList);i++)
{
ETHERIP_ID *k = LIST_DATA(s->EtherIPIdList, i);
Free(k);
}
ReleaseList(s->EtherIPIdList);
// Stop the OS monitoring thread
s->Halt = true;
Set(s->OsServiceCheckThreadEvent);
WaitThread(s->OsServiceCheckThread, INFINITE);
ReleaseThread(s->OsServiceCheckThread);
ReleaseEvent(s->OsServiceCheckThreadEvent);
DeleteLock(s->LockSettings);
Free(s);
}
// Release the UDP acceleration function
void FreeUdpAccel(UDP_ACCEL *a)
{
// Validate arguments
if (a == NULL)
{
return;
}
while (true)
{
BLOCK *b = GetNext(a->RecvBlockQueue);
if (b == NULL)
{
break;
}
FreeBlock(b);
}
ReleaseQueue(a->RecvBlockQueue);
ReleaseSock(a->UdpSock);
if (a->IsInCedarPortList)
{
LockList(a->Cedar->UdpPortList);
{
DelInt(a->Cedar->UdpPortList, a->MyPort);
}
UnlockList(a->Cedar->UdpPortList);
}
// Release of NAT-T related
a->NatT_Halt = true;
Set(a->NatT_HaltEvent);
if (a->NatT_GetIpThread != NULL)
{
WaitThread(a->NatT_GetIpThread, INFINITE);
ReleaseThread(a->NatT_GetIpThread);
}
ReleaseEvent(a->NatT_HaltEvent);
DeleteLock(a->NatT_Lock);
ReleaseCedar(a->Cedar);
Free(a);
}
// Release
void FreeNM()
{
if (nm == NULL)
{
// Uninitialized
return;
}
FreeSM();
FreeCM();
ReleaseCedar(nm->Cedar);
FreeWinUi();
Free(nm);
nm = NULL;
}
// Release the stack
void FreeNativeStack(NATIVE_STACK *a)
{
// Validate arguments
if (a == NULL)
{
return;
}
if (a->Ipc != NULL && IsZero(&a->CurrentDhcpOptionList, sizeof(a->CurrentDhcpOptionList)) == false)
{
IP dhcp_server;
UINTToIP(&dhcp_server, a->CurrentDhcpOptionList.ServerAddress);
IPCDhcpFreeIP(a->Ipc, &dhcp_server);
SleepThread(200);
}
a->Halt = true;
Cancel(a->Cancel);
Disconnect(a->Sock1);
Disconnect(a->Sock2);
WaitThread(a->MainThread, INFINITE);
ReleaseThread(a->MainThread);
CloseEth(a->Eth);
FreeIPC(a->Ipc);
NsStopIpTablesTracking(a);
ReleaseCancel(a->Cancel);
ReleaseSock(a->Sock1);
ReleaseSock(a->Sock2);
ReleaseCedar(a->Cedar);
Free(a);
}
// Release of DDNS client
void FreeDDNSClient(DDNS_CLIENT *c)
{
// Validate arguments
if (c == NULL)
{
return;
}
// Stop the thread
c->Halt = true;
Set(c->Event);
WaitThread(c->Thread, INFINITE);
ReleaseThread(c->Thread);
ReleaseEvent(c->Event);
ReleaseCedar(c->Cedar);
DeleteLock(c->Lock);
Free(c);
}
void CleanupEtherIPServer(ETHERIP_SERVER *s)
{
UINT i;
// Validate arguments
if (s == NULL)
{
return;
}
EtherIPLog(s, "LE_STOP");
if (s->IpcConnectThread != NULL)
{
ReleaseThread(s->IpcConnectThread);
}
if (s->Ipc != NULL)
{
FreeIPC(s->Ipc);
}
for (i = 0;i < LIST_NUM(s->SendPacketList);i++)
{
BLOCK *b = LIST_DATA(s->SendPacketList, i);
FreeBlock(b);
}
ReleaseList(s->SendPacketList);
ReleaseSockEvent(s->SockEvent);
ReleaseCedar(s->Cedar);
DeleteLock(s->Lock);
Free(s);
}
// Cleanup the listener
void CleanupListener(LISTENER *r)
{
UINT i = 0;
// Validate arguments
if (r == NULL)
{
return;
}
if (r->Sock != NULL)
{
ReleaseSock(r->Sock);
}
DeleteLock(r->lock);
ReleaseThread(r->Thread);
ReleaseEvent(r->Event);
ReleaseCedar(r->Cedar);
Free(r);
}
// Clean-up the EL
void CleanupEl(EL *e)
{
// Validate arguments
if (e == NULL)
{
return;
}
// Stop Eraser
FreeEraser(e->Eraser);
// Stop Listener
ElStopListener(e);
// Setting release
ElFreeConfig(e);
// Free the license system
if(e->LicenseSystem != NULL)
{
}
// Free the license status
if(e->LicenseStatus != NULL)
{
Free(e->LicenseStatus);
}
// Ethernet release
FreeEth();
ReleaseCedar(e->Cedar);
DeleteLock(e->lock);
Free(e);
}
// Remote connection dialog procedure
UINT EmRemoteDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
{
WINUI_REMOTE *r = (WINUI_REMOTE *)param;
CEDAR *c;
// Validate arguments
if (hWnd == NULL)
{
return 0;
}
switch (msg)
{
case WM_INITDIALOG:
RemoteDlgInit(hWnd, r);
SetTimer(hWnd, 1, 100, NULL);
break;
case WM_TIMER:
switch (wParam)
{
case 1:
KillTimer(hWnd, 1);
RemoteDlgRefresh(hWnd, r);
SetTimer(hWnd, 1, 100, NULL);
break;
}
break;
case WM_COMMAND:
switch (wParam)
{
case R_LOCAL:
if (IsChecked(hWnd, R_LOCAL) == false)
{
SetTextA(hWnd, C_HOSTNAME, "");
RemoteDlgRefresh(hWnd, r);
FocusEx(hWnd, C_HOSTNAME);
}
else
{
SetTextA(hWnd, C_HOSTNAME, "localhost");
RemoteDlgRefresh(hWnd, r);
Focus(hWnd, IDOK);
}
break;
case IDCANCEL:
Close(hWnd);
break;
case IDOK:
RemoteDlgOnOk(hWnd, r);
break;
case B_ABOUT:
c = NewCedar(NULL, NULL);
About(hWnd, c, _UU("PRODUCT_NAME_ELOGMGR"));
ReleaseCedar(c);
}
switch (LOWORD(wParam))
{
case R_LOCAL:
case C_HOSTNAME:
RemoteDlgRefresh(hWnd, r);
break;
}
break;
case WM_CLOSE:
FreeCandidateList(r->CandidateList);
EndDialog(hWnd, false);
break;
}
return 0;
}
