// === PUBLIC SLOTS ===
//Slots for the global Dispatcher to connect to
void EventWatcher::DispatchStarting(QString ID){
QJsonObject obj;
obj.insert("process_id", ID);
obj.insert("state", "running");
LogManager::log(LogManager::EV_DISPATCH, obj);
emit NewEvent(DISPATCHER, obj);
}
// Initialize the packet adapter
bool NullPaInit(SESSION *s)
{
NULL_LAN *n;
static UINT id_seed = 0;
// Validate arguments
if (s == NULL)
{
return false;
}
id_seed++;
n = ZeroMalloc(sizeof(NULL_LAN));
n->Id = id_seed;
s->PacketAdapter->Param = (void *)n;
n->Cancel = NewCancel();
n->PacketQueue = NewQueue();
n->Event = NewEvent();
NullGenerateMacAddress(n->MacAddr, n->Id, 0);
n->PacketGeneratorThread = NewThread(NullPacketGenerateThread, n);
return true;
}
// Initialize the IPsec server
IPSEC_SERVER *NewIPsecServer(CEDAR *cedar)
{
IPSEC_SERVER *s;
// Validate arguments
if (cedar == NULL)
{
return NULL;
}
s = ZeroMalloc(sizeof(IPSEC_SERVER));
s->LockSettings = NewLock();
s->Cedar = cedar;
AddRef(s->Cedar->ref);
s->L2TP = NewL2TPServer(cedar);
s->Ike = NewIKEServer(cedar, s);
StrCpy(s->Ike->Secret, sizeof(s->Ike->Secret), IPSEC_DEFAULT_SECRET);
s->UdpListener = NewUdpListener(IPsecServerUdpPacketRecvProc, s, &cedar->Server->ListenIP);
s->EtherIPIdList = NewList(CmpEtherIPId);
// Start an OS service monitoring thread
s->OsServiceCheckThreadEvent = NewEvent();
s->OsServiceCheckThread = NewThread(IPsecOsServiceCheckThread, s);
return s;
}
// Create new VPN Azure client
AZURE_CLIENT *NewAzureClient(CEDAR *cedar, SERVER *server)
{
AZURE_CLIENT *ac;
// Validate arguments
if (cedar == NULL || server == NULL)
{
return NULL;
}
ac = ZeroMalloc(sizeof(AZURE_CLIENT));
ac->Cedar = cedar;
ac->Server = server;
ac->Lock = NewLock();
ac->IsEnabled = false;
ac->Event = NewEvent();
// Start main thread
ac->MainThread = NewThread(AcMainThread, ac);
return ac;
}
/**
* Forwards this event onto the frame window. This must be done because
* the event may need to modify this window in a way that would cause
* aberrant behavior if done synchronously
*
* @param Event the event that is going to be forwarded
*/
void WxBrowser::OnRemove(wxCommandEvent& Event)
{
// Tell the frame to remove this browser
WxDockEvent NewEvent(DockID,DCT_Remove);
NewEvent.SetEventType( wxEVT_DOCKINGCHANGE );
// Async post this
::wxPostEvent(GApp->EditorFrame,NewEvent);
}
void EventWatcher::DispatchFinished(QString ID, bool success){
QJsonObject obj;
obj.insert("process_id", ID);
obj.insert("state", "finished");
obj.insert("result", success ? "success" : "failure");
LogManager::log(LogManager::EV_DISPATCH, obj);
emit NewEvent(DISPATCHER, obj);
}
void EventWatcher::sendLPEvent(QString system, int priority, QString msg){
QJsonObject obj;
obj.insert("message",msg);
obj.insert("priority", DisplayPriority(priority) );
obj.insert("class" , system);
HASH.insert(LIFEPRESERVER, obj);
//qDebug() << "New LP Event Object:" << obj;
if(!starting){ emit NewEvent(LIFEPRESERVER, obj); }
}
void Client::OnInitialize() {
connect((QObject*)dt::NetworkManager::Get(), SIGNAL(NewEvent(std::shared_ptr<dt::NetworkEvent>)),
this, SLOT(_HandleEvent(std::shared_ptr<dt::NetworkEvent>)));
dt::Logger::Get().GetStream("debug")->SetDisabled(true);
dt::Logger::Get().GetStream("info")->SetDisabled(true);
std::shared_ptr<dt::NetworkEvent> ptr(new ChatMessageEvent("",""));
dt::NetworkManager::Get()->RegisterNetworkEventPrototype(ptr);
dt::NetworkManager::Get()->BindSocket();
dt::NetworkManager::Get()->Connect(dt::Connection(mServerIP, 29876));
mInputThread = std::shared_ptr<sf::Thread>(new sf::Thread(&Client::InputThread, this));
mInputThread->Launch();
}
void NetworkManager::Initialize() {
// initialize the connections mananger
mConnectionsManager.Initialize();
connect(this, SIGNAL(NewEvent(std::shared_ptr<dt::NetworkEvent>)),
GetConnectionsManager(), SLOT(HandleEvent(std::shared_ptr<dt::NetworkEvent>)));
// add all default events as prototypes
std::shared_ptr<NetworkEvent> ptr;
ptr = std::shared_ptr<NetworkEvent>(new HandshakeEvent());
RegisterNetworkEventPrototype(ptr);
ptr = std::shared_ptr<NetworkEvent>(new GoodbyeEvent());
RegisterNetworkEventPrototype(ptr);
ptr = std::shared_ptr<NetworkEvent>(new PingEvent(0));
RegisterNetworkEventPrototype(ptr);
}
// Initialization of the Tick64
void InitTick64()
{
if (tk64 != NULL)
{
// Already initialized
return;
}
halt_tick_event = NewEvent();
// Initialize the structure
tk64 = ZeroMalloc(sizeof(TICK64));
tk64->TickLock = NewLock();
tk64->AdjustTime = NewList(NULL);
// Creating a thread
tk64->Thread = NewThread(Tick64Thread, NULL);
WaitThreadInit(tk64->Thread);
}
// Start the iptables tracking
bool NsStartIpTablesTracking(NATIVE_STACK *a)
{
if (a->IpTablesThread != NULL)
{
return true;
}
a->IpTablesInitOk = false;
a->IpTablesHalt = false;
a->IpTablesHaltEvent = NewEvent();
a->IpTablesThread = NewThread(NsIpTablesThread, a);
WaitThreadInit(a->IpTablesThread);
return a->IpTablesInitOk;
}
// Creating a DDNS client
DDNS_CLIENT *NewDDNSClient(CEDAR *cedar, UCHAR *key, INTERNET_SETTING *t)
{
DDNS_CLIENT *c;
UCHAR key_hash[SHA1_SIZE];
// Validate arguments
if (cedar == NULL)
{
return NULL;
}
c = ZeroMalloc(sizeof(DDNS_CLIENT));
c->Cedar = cedar;
AddRef(c->Cedar->ref);
c->Err_IPv4 = c->Err_IPv6 = ERR_TRYING_TO_CONNECT;
if (key == NULL)
{
// Create a new key
DCGenNewKey(c->Key);
}
else
{
// Set the key
Copy(c->Key, key, SHA1_SIZE);
}
HashSha1(key_hash, c->Key, sizeof(c->Key));
if (t != NULL)
{
Copy(&c->InternetSetting, t, sizeof(INTERNET_SETTING));
}
c->Lock = NewLock();
// Thread creation
c->Event = NewEvent();
c->Thread = NewThread(DCThread, c);
return c;
}
//=======================
// PRIVATE SLOTS
//=======================
//GENERIC SERVER SIGNALS
// New Connection Signals
void WebServer::NewSocketConnection(){
WebSocket *sock = 0;
if(WSServer!=0){
if(WSServer->hasPendingConnections()){
QWebSocket *ws = WSServer->nextPendingConnection();
if( !allowConnection(ws->peerAddress()) ){ ws->close(); }
else{ sock = new WebSocket( ws, generateID(), AUTH); }
}
}else if(TCPServer!=0){
if(TCPServer->hasPendingConnections()){
QSslSocket *ss = TCPServer->nextPendingConnection();
if( !allowConnection(ss->peerAddress()) ){ ss->close(); }
else{ sock = new WebSocket( ss, generateID(), AUTH); }
}
}
if(sock==0){ return; } //no new connection
//qDebug() << "New Socket Connection";
connect(sock, SIGNAL(SocketClosed(QString)), this, SLOT(SocketClosed(QString)) );
connect(EVENTS, SIGNAL(NewEvent(EventWatcher::EVENT_TYPE, QJsonValue)), sock, SLOT(EventUpdate(EventWatcher::EVENT_TYPE, QJsonValue)) );
OpenSockets << sock;
}
// Create a NAT
NAT *NiNewNatEx(SNAT *snat, VH_OPTION *o)
{
NAT *n = ZeroMalloc(sizeof(NAT));
n->lock = NewLock();
Hash(n->HashedPassword, "", 0, true);
n->HaltEvent = NewEvent();
//n->Cedar = NewCedar(NULL, NULL);
n->SecureNAT = snat;
// Raise the priority
//OSSetHighPriority();
// Initialize the settings
NiInitConfig(n);
#if 0
// Start the operation of the virtual host
if (n->Online && n->ClientOption != NULL)
{
n->Virtual = NewVirtualHostEx(n->Cedar, n->ClientOption, n->ClientAuth, &n->Option, n);
}
else
{
n->Online = false;
n->Virtual = NULL;
}
#else
n->Virtual = NewVirtualHostEx(n->Cedar, NULL, NULL, o, n);
n->Online = true;
#endif
// Start management command
//NiInitAdminAccept(n);
return n;
}
// Initialize the packet adapter
bool NullPaInit(SESSION *s)
{
NULL_LAN *n;
// Validate arguments
if (s == NULL)
{
return false;
}
n = ZeroMalloc(sizeof(NULL_LAN));
s->PacketAdapter->Param = (void *)n;
n->Cancel = NewCancel();
n->PacketQueue = NewQueue();
n->Event = NewEvent();
GenMacAddress(n->MacAddr);
n->PacketGeneratorThread = NewThread(NullPacketGenerateThread, n);
return true;
}
// NAT の作成
NAT *NiNewNatEx(SNAT *snat, VH_OPTION *o)
{
NAT *n = ZeroMalloc(sizeof(NAT));
n->lock = NewLock();
Hash(n->HashedPassword, "", 0, true);
n->HaltEvent = NewEvent();
//n->Cedar = NewCedar(NULL, NULL);
n->SecureNAT = snat;
// 優先順位を上げる
//OSSetHighPriority();
// 設定の初期化
NiInitConfig(n);
#if 0
// 仮想ホストの動作を開始
if (n->Online && n->ClientOption != NULL)
{
n->Virtual = NewVirtualHostEx(n->Cedar, n->ClientOption, n->ClientAuth, &n->Option, n);
}
else
{
n->Online = false;
n->Virtual = NULL;
}
#else
n->Virtual = NewVirtualHostEx(n->Cedar, NULL, NULL, o, n);
n->Online = true;
#endif
// 管理コマンド開始
//NiInitAdminAccept(n);
return n;
}
LISTENER *NewListenerEx5(CEDAR *cedar, UINT proto, UINT port, THREAD_PROC *proc, void *thread_param, bool local_only, bool shadow_ipv6,
volatile UINT *natt_global_udp_port, UCHAR rand_port_id, bool enable_ca)
{
LISTENER *r;
THREAD *t;
// Validate arguments
if ((proto == LISTENER_TCP && port == 0) || cedar == NULL)
{
return NULL;
}
// Check the protocol number
if (proto != LISTENER_TCP && proto != LISTENER_INPROC &&
proto != LISTENER_RUDP && proto != LISTENER_ICMP && proto != LISTENER_DNS &&
proto != LISTENER_REVERSE)
{
return NULL;
}
r = ZeroMalloc(sizeof(LISTENER));
r->ThreadProc = proc;
r->ThreadParam = thread_param;
r->Cedar = cedar;
AddRef(r->Cedar->ref);
r->lock = NewLock();
r->ref = NewRef();
r->Protocol = proto;
r->Port = port;
r->Event = NewEvent();
r->LocalOnly = local_only;
r->ShadowIPv6 = shadow_ipv6;
r->NatTGlobalUdpPort = natt_global_udp_port;
r->RandPortId = rand_port_id;
r->EnableConditionalAccept = enable_ca;
if (r->ShadowIPv6 == false)
{
if (proto == LISTENER_TCP)
{
SLog(cedar, "LS_LISTENER_START_1", port);
}
}
// Creating a thread
t = NewThread(ListenerThread, r);
WaitThreadInit(t);
ReleaseThread(t);
if (r->ShadowIPv6 == false && proto == LISTENER_TCP)
{
if (r->Cedar->DisableIPv6Listener == false)
{
// Add a shadow listener
r->ShadowListener = NewListenerEx3(cedar, proto, port, proc, thread_param,
local_only, true);
}
}
if (r->ShadowIPv6 == false)
{
// Add to the Cedar
AddListener(cedar, r);
}
return r;
}
// Create a new UDP acceleration function
UDP_ACCEL *NewUdpAccel(CEDAR *cedar, IP *ip, bool client_mode, bool random_port, bool no_nat_t)
{
UDP_ACCEL *a;
SOCK *s;
UINT max_udp_size;
bool is_in_cedar_port_list = false;
if (IsZeroIP(ip))
{
ip = NULL;
}
if (client_mode || random_port)
{
// Use a appropriate vacant port number in the case of using random port or client mode
s = NewUDPEx3(0, ip);
}
else
{
// Specify in the range in the case of server mode
UINT i;
s = NULL;
LockList(cedar->UdpPortList);
{
for (i = UDP_SERVER_PORT_LOWER;i <= UDP_SERVER_PORT_HIGHER;i++)
{
if (IsIntInList(cedar->UdpPortList, i) == false)
{
s = NewUDPEx3(i, ip);
if (s != NULL)
{
is_in_cedar_port_list = true;
break;
}
}
}
if (s == NULL)
{
// Leave the port selection to the OS because the available port is not found within the range
s = NewUDPEx3(0, ip);
}
if (s != NULL && is_in_cedar_port_list)
{
AddIntDistinct(cedar->UdpPortList, i);
}
}
UnlockList(cedar->UdpPortList);
}
if (s == NULL)
{
return NULL;
}
a = ZeroMalloc(sizeof(UDP_ACCEL));
a->Cedar = cedar;
AddRef(a->Cedar->ref);
a->NoNatT = no_nat_t;
a->NatT_TranId = Rand64();
a->CreatedTick = Tick64();
a->IsInCedarPortList = is_in_cedar_port_list;
a->ClientMode = client_mode;
a->Now = Tick64();
a->UdpSock = s;
Rand(a->MyKey, sizeof(a->MyKey));
Rand(a->YourKey, sizeof(a->YourKey));
Copy(&a->MyIp, ip, sizeof(IP));
a->MyPort = s->LocalPort;
a->IsIPv6 = IsIP6(ip);
if (a->IsIPv6)
{
a->NoNatT = true;
}
a->RecvBlockQueue = NewQueue();
Rand(a->NextIv, sizeof(a->NextIv));
do
{
a->MyCookie = Rand32();
}
while (a->MyCookie == 0);
do
{
a->YourCookie = Rand32();
}
while (a->MyCookie == 0 || a->MyCookie == a->YourCookie);
// Calculate the maximum transmittable UDP packet size
max_udp_size = MTU_FOR_PPPOE;
if (a->IsIPv6 == false)
{
// IPv4
max_udp_size -= 20;
}
else
{
// IPv6
max_udp_size -= 40;
}
// UDP
max_udp_size -= 8;
a->MaxUdpPacketSize = max_udp_size;
Debug("Udp Accel My Port = %u\n", a->MyPort);
// Initialize the NAT-T server IP address acquisition thread
a->NatT_Lock = NewLock();
a->NatT_HaltEvent = NewEvent();
if (a->NoNatT == false)
{
a->NatT_GetIpThread = NewThread(NatT_GetIpThread, a);
}
return a;
}
void MainFrame::NewClicked(wxCommandEvent& event) {
NewEvent();
}
TimerCatcher() :
counter_(0),
timer_(new TimerWnd(100)) {
timer_->setOnTimeout(NewEvent(*this, &TimerCatcher::onTimer));
}
void CustomClientEventListener::_Initialize() {
QObject::connect(dt::NetworkManager::Get(), SIGNAL(NewEvent(std::shared_ptr<dt::NetworkEvent>)),
this, SLOT(_HandleEvent(std::shared_ptr<dt::NetworkEvent>)));
}
