// Release all links
void ReleaseAllLink(HUB *h)
{
LINK **kk;
UINT num, i;
// Validate arguments
if (h == NULL)
{
return;
}
LockList(h->LinkList);
{
num = LIST_NUM(h->LinkList);
kk = ToArray(h->LinkList);
DeleteAll(h->LinkList);
}
UnlockList(h->LinkList);
for (i = 0;i < num;i++)
{
LINK *k = kk[i];
ReleaseLink(k);
}
Free(kk);
}
// Convert the Tick value to time
UINT64 Tick64ToTime64(UINT64 tick)
{
UINT64 ret = 0;
if (tick == 0)
{
return 0;
}
LockList(tk64->AdjustTime);
{
UINT i;
for (i = 0;i < LIST_NUM(tk64->AdjustTime);i++)
{
ADJUST_TIME *t = LIST_DATA(tk64->AdjustTime, i);
if (t->Tick <= tick)
{
ret = t->Time + (tick - t->Tick);
}
}
}
UnlockList(tk64->AdjustTime);
if (ret == 0)
{
ret++;
}
return ret;
}
// Device enumeration
UINT EtEnumDevice(EL *e, RPC_ENUM_DEVICE *t)
{
bool is_beta_expired = ElIsBetaExpired();
if (is_beta_expired)
{
// The beta version has expired
return ERR_BETA_EXPIRES;
}
FreeRpcEnumDevice(t);
Zero(t, sizeof(RPC_ENUM_DEVICE));
LockList(e->DeviceList);
{
UINT i;
t->NumItem = LIST_NUM(e->DeviceList);
t->Items = ZeroMalloc(sizeof(RPC_ENUM_DEVICE_ITEM) * t->NumItem);
for (i = 0;i < t->NumItem;i++)
{
RPC_ENUM_DEVICE_ITEM *d = &t->Items[i];
EL_DEVICE *eld = LIST_DATA(e->DeviceList, i);
StrCpy(d->DeviceName, sizeof(d->DeviceName), eld->DeviceName);
d->Active = eld->Active && ((ELOG_IS_BETA || e->LicenseStatus->Valid) ? true : false);
}
}
UnlockList(e->DeviceList);
return ERR_NO_ERROR;
}
// Add a Layer-3 switch
L3SW *L3AddSw(CEDAR *c, char *name)
{
L3SW *s = NULL;
// Validate arguments
if (c == NULL || name == NULL)
{
return NULL;
}
LockList(c->L3SwList);
{
s = L3GetSw(c, name);
if (s == NULL)
{
s = NewL3Sw(c, name);
Insert(c->L3SwList, s);
AddRef(s->ref);
}
else
{
ReleaseL3Sw(s);
s = NULL;
}
}
UnlockList(c->L3SwList);
return s;
}
// Get the L3 switch
L3SW *L3GetSw(CEDAR *c, char *name)
{
L3SW t, *s;
// Validate arguments
if (c == NULL || name == NULL)
{
return NULL;
}
Zero(&t, sizeof(t));
StrCpy(t.Name, sizeof(t.Name), name);
LockList(c->L3SwList);
{
s = Search(c->L3SwList, &t);
}
UnlockList(c->L3SwList);
if (s != NULL)
{
AddRef(s->ref);
}
return s;
}
// Delete trusted CA from Cedar
bool DeleteCa(CEDAR *cedar, UINT ptr)
{
bool b = false;
// Validate arguments
if (cedar == NULL || ptr == 0)
{
return false;
}
LockList(cedar->CaList);
{
UINT i;
for (i = 0;i < LIST_NUM(cedar->CaList);i++)
{
X *x = LIST_DATA(cedar->CaList, i);
if (POINTER_TO_KEY(x) == ptr)
{
Delete(cedar->CaList, x);
FreeX(x);
b = true;
break;
}
}
}
UnlockList(cedar->CaList);
return b;
}
// Add connection to Cedar
void AddConnection(CEDAR *cedar, CONNECTION *c)
{
char tmp[MAX_SIZE];
UINT i;
// Validate arguments
if (cedar == NULL || c == NULL)
{
return;
}
// Determine the name of the connection
i = Inc(cedar->ConnectionIncrement);
Format(tmp, sizeof(tmp), "CID-%u", i);
Lock(c->lock);
{
Free(c->Name);
c->Name = CopyStr(tmp);
}
Unlock(c->lock);
LockList(cedar->ConnectionList);
{
Add(cedar->ConnectionList, c);
AddRef(c->ref);
Debug("Connection %s Inserted to Cedar.\n", c->Name);
}
UnlockList(cedar->ConnectionList);
}
VOID SoraUReleaseBuffer(PVOID Buff) {
RELEASE_KERNEL_BUFFER_IN release_kb_in = { 0 };
DWORD length;
release_kb_in.Buff = Buff;
OVERLAPPED overlap = { 0 };
DeviceIoControl(SoraDevice,
UEXT_CMD(RELEASE_KERNEL_BUFFER),
&release_kb_in,
sizeof(RELEASE_KERNEL_BUFFER_IN),
NULL,
0,
&length,
&overlap);
LockList(&LockLong);
LIST_ENTRY* entry;
entry = AllocBufferListHead.Flink;
while(entry != &AllocBufferListHead) {
struct KernelBufferEntry* be;
be = (struct KernelBufferEntry*)entry;
if (be->AllocKBOut.Buff != Buff)
entry = entry->Flink;
else {
RemoveEntryList(entry);
delete be;
break;
}
}
UnlockList(&LockLong);
}
// Lock the account database for the hub
void AcLock(HUB *h)
{
// Validate arguments
if (h == NULL)
{
return;
}
if (NO_ACCOUNT_DB(h))
{
return;
}
// Lock group list and user list
LockList(h->HubDb->GroupList);
LockList(h->HubDb->UserList);
}
HRESULT
SoraURadioTransferEx(
IN ULONG RadioNo,
IN PVOID SampleBuffer,
IN ULONG SampleSize,
OUT PULONG TxID) {
BOOL isContinuous;
isContinuous = FALSE;
LockList(&LockLong);
LIST_ENTRY* entry;
entry = AllocBufferListHead.Flink;
while(entry != &AllocBufferListHead) {
struct KernelBufferEntry* be;
be = (struct KernelBufferEntry*)entry;
if (((ULONG)SampleBuffer >= (ULONG)be->AllocKBOut.Buff) &&
((ULONG)SampleBuffer + SampleSize <= (ULONG)be->AllocKBOut.Buff + be->Size)) {
isContinuous = be->AllocKBOut.is_Continuous;
break;
}
entry = entry->Flink;
}
UnlockList(&LockLong);
if (isContinuous)
return SoraURadioTransferContinuous(SampleBuffer,
SampleSize,
TxID);
else
return SoraURadioTransferDiscontinuous(SampleBuffer, // we make OS to prepare a physical continuous memory for us, the overhead is memory copy
SampleSize, // it is still ok to force invoke SoraURadioTransferContinuous even if they are not physically continuous
TxID);
}
KernelBufferEntry* SoraUForceAllocContinuousBufferEx(ULONG Size) {
ALLOC_KERNEL_BUFFER_IN alloc_kb_in;
ALLOC_KERNEL_BUFFER_OUT alloc_kb_out = { 0 };
DWORD length;
alloc_kb_in.Size = Size;
alloc_kb_in.force_Continuous = 1;
OVERLAPPED overlap = { 0 };
if (!DeviceIoControl(SoraDevice,
UEXT_CMD(ALLOC_KERNEL_BUFFER),
&alloc_kb_in,
sizeof(ALLOC_KERNEL_BUFFER_IN),
&alloc_kb_out,
sizeof(ALLOC_KERNEL_BUFFER_OUT),
&length,
&overlap))
return NULL;
if (alloc_kb_out.Buff) {
struct KernelBufferEntry* be;
be = new struct KernelBufferEntry;
be->AllocKBOut.Buff = alloc_kb_out.Buff;
be->AllocKBOut.HiPhyBuff = alloc_kb_out.HiPhyBuff;
be->AllocKBOut.LoPhyBuff = alloc_kb_out.LoPhyBuff;
be->AllocKBOut.is_Continuous = alloc_kb_out.is_Continuous;
be->Size = Size;
LockList(&LockLong);
InsertHeadList(&AllocBufferListHead,
be);
UnlockList(&LockLong);
return be;
}
return NULL;
}
// Delete the UDP session from the UDP entry
void DelUDPEntry(CEDAR *cedar, SESSION *session)
{
UINT num, i;
// Validate arguments
if (cedar == NULL || session == NULL)
{
return;
}
LockList(cedar->UDPEntryList);
{
num = LIST_NUM(cedar->UDPEntryList);
for (i = 0;i < num;i++)
{
UDP_ENTRY *e = LIST_DATA(cedar->UDPEntryList, i);
if (e->Session == session)
{
ReleaseSession(e->Session);
Delete(cedar->UDPEntryList, e);
Free(e);
UnlockList(cedar->UDPEntryList);
Debug("UDP_Entry Deleted.\n");
return;
}
}
}
UnlockList(cedar->UDPEntryList);
}
// Get the session from the session key
SESSION *GetSessionFromUDPEntry(CEDAR *cedar, UINT key32)
{
UDP_ENTRY *e, t;
SESSION *s;
// Validate arguments
if (cedar == NULL)
{
return NULL;
}
t.SessionKey32 = key32;
LockList(cedar->UDPEntryList);
{
e = Search(cedar->UDPEntryList, &t);
if (e == NULL)
{
UnlockList(cedar->UDPEntryList);
return NULL;
}
s = e->Session;
AddRef(s->ref);
}
UnlockList(cedar->UDPEntryList);
return s;
}
// Stop all links
void StopAllLink(HUB *h)
{
LINK **link_list;
UINT num_link;
UINT i;
// Validate arguments
if (h == NULL)
{
return;
}
LockList(h->LinkList);
{
link_list = ToArray(h->LinkList);
num_link = LIST_NUM(h->LinkList);
for (i = 0;i < num_link;i++)
{
AddRef(link_list[i]->ref);
}
}
UnlockList(h->LinkList);
for (i = 0;i < num_link;i++)
{
StopLink(link_list[i]);
ReleaseLink(link_list[i]);
}
Free(link_list);
}
// Check whether the specified IP address is in Non-SSL connection list
bool IsInNoSsl(CEDAR *c, IP *ip)
{
bool ret = false;
// Validate arguments
if (c == NULL || ip == NULL)
{
return false;
}
LockList(c->NonSslList);
{
NON_SSL *n = SearchNoSslList(c, ip);
if (n != NULL)
{
if (n->EntryExpires > Tick64() && n->Count > NON_SSL_MIN_COUNT)
{
n->EntryExpires = Tick64() + (UINT64)NON_SSL_ENTRY_EXPIRES;
ret = true;
}
}
}
UnlockList(c->NonSslList);
return ret;
}
// Enumerate VLANs
TOKEN_LIST *UnixVLanEnum()
{
TOKEN_LIST *ret;
UINT i;
if (unix_vlan == NULL)
{
return NullToken();
}
ret = ZeroMalloc(sizeof(TOKEN_LIST));
LockList(unix_vlan);
{
ret->NumTokens = LIST_NUM(unix_vlan);
ret->Token = ZeroMalloc(sizeof(char *) * ret->NumTokens);
for (i = 0;i < ret->NumTokens;i++)
{
UNIX_VLAN_LIST *t = LIST_DATA(unix_vlan, i);
ret->Token[i] = CopyStr(t->Name);
}
}
UnlockList(unix_vlan);
return ret;
}
// Check whether the certificate is signed by CA which is trusted by the hub
bool CheckSignatureByCaLinkMode(SESSION *s, X *x)
{
LINK *k;
HUB *h;
bool ret = false;
// Validate arguments
if (s == NULL || x == NULL)
{
return false;
}
if (s->LinkModeClient == false || (k = s->Link) == NULL)
{
return false;
}
h = k->Hub;
if (h->HubDb != NULL)
{
LockList(h->HubDb->RootCertList);
{
X *root_cert;
root_cert = GetIssuerFromList(h->HubDb->RootCertList, x);
if (root_cert != NULL)
{
ret = true;
}
}
UnlockList(h->HubDb->RootCertList);
}
return ret;
}
// Delete the VLAN
void UnixVLanDelete(char *name)
{
// Validate arguments
if (name == NULL || unix_vlan == NULL)
{
return;
}
LockList(unix_vlan);
{
UINT i;
UNIX_VLAN_LIST *t, tt;
Zero(&tt, sizeof(tt));
StrCpy(tt.Name, sizeof(tt.Name), name);
t = Search(unix_vlan, &tt);
if (t != NULL)
{
UnixCloseTapDevice(t->fd);
Delete(unix_vlan, t);
Free(t);
}
}
UnlockList(unix_vlan);
}
// Add trusted CA to Cedar
void AddCa(CEDAR *cedar, X *x)
{
// Validate arguments
if (cedar == NULL || x == NULL)
{
return;
}
LockList(cedar->CaList);
{
UINT i;
bool ok = true;
for (i = 0;i < LIST_NUM(cedar->CaList);i++)
{
X *exist_x = LIST_DATA(cedar->CaList, i);
if (CompareX(exist_x, x))
{
ok = false;
break;
}
}
if (ok)
{
Insert(cedar->CaList, CloneX(x));
}
}
UnlockList(cedar->CaList);
}
// Get the VLAN
int UnixVLanGet(char *name)
{
int fd = -1;
// Validate arguments
if (name == NULL || unix_vlan == NULL)
{
return -1;
}
LockList(unix_vlan);
{
UINT i;
UNIX_VLAN_LIST *t, tt;
Zero(&tt, sizeof(tt));
StrCpy(tt.Name, sizeof(tt.Name), name);
t = Search(unix_vlan, &tt);
if (t != NULL)
{
fd = t->fd;
}
}
UnlockList(unix_vlan);
return fd;
}
// Stop all connections
void StopAllConnection(CEDAR *c)
{
UINT num;
UINT i;
CONNECTION **connections;
// Validate arguments
if (c == NULL)
{
return;
}
LockList(c->ConnectionList);
{
connections = ToArray(c->ConnectionList);
num = LIST_NUM(c->ConnectionList);
DeleteAll(c->ConnectionList);
}
UnlockList(c->ConnectionList);
for (i = 0;i < num;i++)
{
StopConnection(connections[i], false);
ReleaseConnection(connections[i]);
}
Free(connections);
}
//---------------------------------------------------------------------------
void TCustomMsgServer::Delete(int Index)
{
LockList();
Workers[Index] = 0;
ClientsCount--;
UnlockList();
}
// Delete the Layer-3 switch
bool L3DelSw(CEDAR *c, char *name)
{
L3SW *s;
bool ret = false;
// Validate arguments
if (c == NULL || name == NULL)
{
return false;
}
LockList(c->L3SwList);
{
s = L3GetSw(c, name);
if (s != NULL)
{
// Stop and delete
L3SwStop(s);
Delete(c->L3SwList, s);
ReleaseL3Sw(s);
ReleaseL3Sw(s);
ret = true;
}
}
UnlockList(c->L3SwList);
return ret;
}
// Get reverse listener socket in Cedar
SOCK *GetReverseListeningSock(CEDAR *c)
{
SOCK *s = NULL;
// Validate arguments
if (c == NULL)
{
return NULL;
}
LockList(c->ListenerList);
{
UINT i;
for (i = 0;i < LIST_NUM(c->ListenerList);i++)
{
LISTENER *r = LIST_DATA(c->ListenerList, i);
if (r->Protocol == LISTENER_REVERSE)
{
Lock(r->lock);
{
s = r->Sock;
AddRef(s->ref);
}
Unlock(r->lock);
break;
}
}
}
UnlockList(c->ListenerList);
return s;
}
// Stop all L3 switches in the Cedar
void L3FreeAllSw(CEDAR *c)
{
LIST *o;
UINT i;
// Validate arguments
if (c == NULL)
{
return;
}
o = NewListFast(NULL);
LockList(c->L3SwList);
{
for (i = 0;i < LIST_NUM(c->L3SwList);i++)
{
L3SW *s = LIST_DATA(c->L3SwList, i);
Insert(o, CopyStr(s->Name));
}
for (i = 0;i < LIST_NUM(o);i++)
{
char *name = LIST_DATA(o, i);
L3DelSw(c, name);
Free(name);
}
ReleaseList(o);
}
UnlockList(c->L3SwList);
}
// 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);
}
// Configuration release
void ElFreeConfig(EL *e)
{
UINT i;
LIST *o;
// Validate arguments
if (e == NULL)
{
return;
}
// Write the configuration file
ElSaveConfig(e);
FreeCfgRw(e->CfgRw);
// Stop all capture
o = NewList(NULL);
LockList(e->DeviceList);
{
for (i = 0;i < LIST_NUM(e->DeviceList);i++)
{
EL_DEVICE *d = LIST_DATA(e->DeviceList, i);
Insert(o, CopyStr(d->DeviceName));
}
for (i = 0;i < LIST_NUM(o);i++)
{
char *name = LIST_DATA(o, i);
ElDeleteCaptureDevice(e, name);
Free(name);
}
ReleaseList(o);
}
UnlockList(e->DeviceList);
ReleaseList(e->DeviceList);
}
// Get net service name
char *GetSvcName(CEDAR *cedar, bool udp, UINT port)
{
char *ret = NULL;
NETSVC t;
// Validate arguments
if (cedar == NULL)
{
return NULL;
}
t.Udp = (udp == 0 ? false : true);
t.Port = port;
LockList(cedar->NetSvcList);
{
NETSVC *n = Search(cedar->NetSvcList, &t);
if (n != NULL)
{
ret = n->Name;
}
}
UnlockList(cedar->NetSvcList);
return ret;
}
// Update the log configuration of the capture device
bool ElSetCaptureDeviceLogSetting(EL *e, char *name, HUB_LOG *log)
{
EL_DEVICE *d;
bool ret = false;
// Validate arguments
if (e == NULL || log == NULL || name == NULL)
{
return false;
}
LockList(e->DeviceList);
{
EL_DEVICE t;
Zero(&t, sizeof(t));
StrCpy(t.DeviceName, sizeof(t.DeviceName), name);
d = Search(e->DeviceList, &t);
if (d != NULL)
{
Copy(&d->LogSetting, log, sizeof(HUB_LOG));
SetLogSwitchType(d->Logger, log->PacketLogSwitchType);
ret = true;
}
}
UnlockList(e->DeviceList);
return ret;
}
// Normalize the IPsec service setttings
void IPsecNormalizeServiceSetting(IPSEC_SERVER *s)
{
CEDAR *c;
// Validate arguments
if (s == NULL)
{
return;
}
c = s->Cedar;
Lock(s->LockSettings);
{
bool reset_hub_setting = false;
if (IsEmptyStr(s->Services.IPsec_Secret))
{
// If the secret is not set, set the default one
StrCpy(s->Services.IPsec_Secret, sizeof(s->Services.IPsec_Secret), IPSEC_DEFAULT_SECRET);
}
LockList(c->HubList);
{
if (IsEmptyStr(s->Services.L2TP_DefaultHub))
{
reset_hub_setting = true;
}
else
{
if (IsHub(c, s->Services.L2TP_DefaultHub) == false)
{
reset_hub_setting = true;
}
}
if (reset_hub_setting)
{
// Select the first Virtual HUB if there is no HUB
HUB *h = NULL;
if (LIST_NUM(c->HubList) >= 1)
{
h = LIST_DATA(c->HubList, 0);
}
if (h != NULL)
{
StrCpy(s->Services.L2TP_DefaultHub, sizeof(s->Services.L2TP_DefaultHub), h->Name);
}
else
{
StrCpy(s->Services.L2TP_DefaultHub, sizeof(s->Services.L2TP_DefaultHub), "");
}
}
}
UnlockList(c->HubList);
}
Unlock(s->LockSettings);
}
