RakNet.cpp

Go to the documentation of this file.

#include "RakNet.h"
#include "Extensions.h"

#include "D:/Rise Base/RakNet/Source/EmailSender.h"

#include <thread>

#include "RakNetUserPackets.h"

namespace Devices
{
        void RakNet::Initialize(Logger* prmLogger, RakNetConfig* prmConfig, Bus* prmBus)
        {
                logger = prmLogger;
                config = prmConfig;
                bus = prmBus;

                rak4Peers = RakPeerInterface::GetInstance();

                SocketDescriptor socketdesc(static_cast<USHORT>(config->clientPort), config->hostAddress.c_str()); // INADDR_ANY

                int result = rak4Peers->Startup(config->maxPeer + 1, &socketdesc, 1);
                if (result == StartupResult::RAKNET_STARTED)
                {
                        rak4Peers->SetMaximumIncomingConnections(static_cast<USHORT>(config->maxPeer));
                        char msg[99];
                        sprintf_s(msg, 99, "RakNet::ctor Ready to accept peer connection(s) on port: %i", config->clientPort);
                        logger->Log(msg);
                        sprintf_s(msg, 99, "RakNet::ctor MTU size: %i", rak4Peers->GetMTUSize(serverC));
                        logger->Log(msg);
                }
                else
                {
                        logger->Log("RakNet::ctor Failed to host for peer connections!", Logger::Error, result);
                        return;
                }

                SendEmail("Avionics startup!");
        }

        RakNet::~RakNet()
        {
                if (!config || !config->enabled) return;

                logger->Log("RakNet::dtor...");
                if (rak4Peers && rak4Peers->IsActive())
                {
                        rak4Peers->Shutdown(500, 0);
                }
                ::RakNet::RakPeerInterface::DestroyInstance(rak4Peers);
        }

        void RakNet::FrameMove(float fElapsed)
        {
                static float timeSinceLastEmail = 60.0f;
                timeSinceLastEmail += fElapsed;

                for (UINT i = 0; i < bus->commandStream.size(); i++)
                {
                        Command command = bus->commandStream.at(i);
                        if (command.delay != 0.0f) continue;

                        if (command.name == "SendEmail" && timeSinceLastEmail >= 60.0f)
                        {
                                SendEmail(command.svalue);
                                bus->commandStream.erase(bus->commandStream.begin() + i);
                        }
                        else if (command.name == "Display-Reset")
                        {
                                SendInitialData();
                                bus->commandStream.erase(bus->commandStream.begin() + i);
                        }
                        else if (command.name == "Display-Event")
                        {
                                SEvents cs;
                                cs.type = ID_USER_PACKET_ENUM + 3;
                                cs.eventType = command.ivalue;

                                if (command.ivalue == 3) // stop music
                                        bus->FlightFreeze = false;
                                else if (command.ivalue == 2) // start music
                                        bus->FlightFreeze = true;

                                SPacketSetting setting;
                                setting.bytes = sizeof(SEvents);
                                setting.priority = PacketPriority::HIGH_PRIORITY;
                                setting.reliability = PacketReliability::RELIABLE;
                                cs.Send(rak4Peers, setting);

                                bus->commandStream.erase(bus->commandStream.begin() + i);
                        }
                }

                if (rak4Peers)
                {
                        while ((p = rak4Peers->Receive()) != nullptr)
                        {
                                if (p->data[0] == ID_NEW_INCOMING_CONNECTION)
                                {
                                        char msg[199];
                                        sprintf_s(msg, 199, "RakNet::RakNetMessageHandler ID_NEW_INCOMING_CONNECTION: %s", p->systemAddress.ToString());
                                        logger->Log(msg);
                                        displayC = p->systemAddress;
                                        SendInitialData();
                                }
                                else if (p->systemAddress == displayC)
                                {
                                        RakNetMessageHandlerPeer();
                                }
                                else if (p->systemAddress == serverC)
                                {
                                }
                                rak4Peers->DeallocatePacket(p);
                        }

                        static float timeSinceControlUpdate = 0.0f;
                        timeSinceControlUpdate += fElapsed;
                        if (timeSinceControlUpdate >= 0.1f)
                        {
                                timeSinceControlUpdate = 0.0f;
                                // send certain data from bus?
                                SControlSurfaces cs;
                                cs.type = ID_USER_PACKET_ENUM + 0;
                                memcpy_s(cs.discreet, sizeof(cs.discreet), bus->DiscreetSurfacePostion, sizeof(bus->DiscreetSurfacePostion));
                                memcpy_s(cs.engineThrustPounds, sizeof(cs.engineThrustPounds), bus->EngineThrustOutput, sizeof(bus->EngineThrustOutput));
                                cs.weight = bus->GrossWeight();


                                SPacketSetting setting;
                                setting.bytes = sizeof(SControlSurfaces);
                                setting.priority = PacketPriority::MEDIUM_PRIORITY;
                                setting.reliability = PacketReliability::UNRELIABLE_SEQUENCED;
                                cs.Send(rak4Peers, setting);
                        }
                }
        }

        void RakNet::RakNetMessageHandlerPeer()
        {
                char msg[199];

                switch (p->data[0])
                {
                case ID_CONNECTION_LOST:
                        sprintf_s(msg, 199, "RakNet::RakNetMessageHandler ID_CONNECTION_LOST: %s", p->systemAddress.ToString());
                        logger->Log(msg);
                        displayC = UNASSIGNED_SYSTEM_ADDRESS;
                        break;
                case ID_DISCONNECTION_NOTIFICATION:
                        sprintf_s(msg, 199, "RakNet::RakNetMessageHandler ID_DISCONNECTION_NOTIFICATION: %s", p->systemAddress.ToString());
                        logger->Log(msg);
                        displayC = UNASSIGNED_SYSTEM_ADDRESS;
                        break;
                case ID_USER_PACKET_ENUM + 2:
                        //peer->Send((const char*)p->data, p->length, HIGH_PRIORITY, RELIABLE_ORDERED, 0, p->guid, true);

                        SFromDisplay* cs = reinterpret_cast<SFromDisplay*>(p->data);
                        bus->AngleOfAttack = cs->aoa;
                        bus->IndicatedAirspeed = cs->ias;
                        bus->FlightPathAngle = cs->fpa;
                        // we need yaw rate or relative wind information left and right
                        bus->Location = cs->location;
                        bus->PitchAttitude = cs->pitchAttitude;
                        //bus->HeadingMagnetic = cs->heading; /// @TODO need magnetic variation? GPS is TRUE, magnetic is deprecated
                        bus->HeadingTrue = cs->heading;
                        bus->RollAttitude = cs->rollAttitude;
                        bus->NormalAcceleration = cs->sumOfForces;
                        bus->PressureAltitude = -bus->Location.z;

                        bus->DisplayFps = cs->fps;

                        // we have no idea where we are... except altitude (which is exact above a reference line)
                        // so we need lat/long ... 

                        break;
                }
        }

        //void RakNet::SendToPeer(SystemAddress dwTo, void* pData, DWORD dwSize, PacketReliability reliability, bool broadcast)
        //{
        //      /// @todo got to be a better way with vectors and std::strings
        //      char newdata[32768]; // 28676
        //      newdata[0] = (unsigned char)ID_USER_PACKET_ENUM;
        //      memcpy(&newdata[1], pData, dwSize);
        //      rak4Peers->Send(newdata, dwSize + 1, MEDIUM_PRIORITY, reliability, newdata[0], dwTo, broadcast);
        //}

        void RakNet::SendEmail(std::string subject, std::string body, int severity)
        {
                if (!config->sendEmails)
                {
                        char msg[999];
                        sprintf_s(msg, 999, "RakNet::SendEmail Disabled, would have sent email: %s", subject.c_str());
                        logger->Log(msg);
                        return;
                }

                char msg[999];
                sprintf_s(msg, 999, "RakNet::SendEmail Sending message: %s", subject.c_str());
                logger->Log(msg);

                std::thread first(&RakNet::AsyncEmailSender, this, subject, body, severity);
                first.detach();
                logger->Log("RakNet::SendEmail Detached as asynchronous thread...");
        }

        void RakNet::AsyncEmailSender(std::string subject, std::string body, int severity) const
        {
                std::string tempTo = config->recipientEmail;
                Library::StringUtils::Replace(tempTo, "%i", std::to_string(severity));

                EmailSender* emailSender = EmailSender::GetInstance();
                const char* sendResult = emailSender->Send(
                        config->smtpServer.c_str(),
                        static_cast<USHORT>(config->smtpServerPort),
                        config->senderEmail.c_str(),
                        tempTo.c_str(),
                        config->senderName.c_str(),
                        config->recipientName.c_str(),
                        subject.c_str(),
                        body.c_str(),
                        nullptr,
                        config->useSsl,
                        config->password.c_str());
                if (sendResult != nullptr)
                {
                        char msg[999];
                        sprintf_s(msg, 999, "RakNet::AsyncEmailSender Send failed: %s", sendResult);
                        logger->Log(msg, Logger::Error);
                }
                else
                {
                        logger->Log("RakNet::AsyncEmailSender Sent successfully!");
                }
                EmailSender::DestroyInstance(emailSender);
        }

        void RakNet::SendInitialData() const
        {
                SInitialData cs;
                cs.type = ID_USER_PACKET_ENUM + 1;
                cs.reset = true;

                SPacketSetting setting;
                setting.bytes = sizeof(SInitialData);
                setting.priority = PacketPriority::HIGH_PRIORITY;
                setting.reliability = PacketReliability::RELIABLE;
                cs.Send(rak4Peers, setting);
        }
}