// 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); }