void COSCStatsSender::SetEnabled(bool enabled) {
bool statusChanged = (enabled != sendingEnabled);
this->sendingEnabled = enabled;
if (statusChanged) {
if (enabled) {
oscOutputBuffer = new char[OSC_OUTPUT_BUFFER_SIZE];
oscPacker = new osc::OutboundPacketStream(oscOutputBuffer,
OSC_OUTPUT_BUFFER_SIZE);
network = new NetStruct;
network->outSocket = new boost::asio::ip::udp::socket(netcode::netservice, boost::asio::ip::udp::endpoint(boost::asio::ip::address_v6::any(), 0));
boost::asio::socket_base::broadcast option(true);
network->outSocket->set_option(option);
UpdateDestination();
LOG("Sending spring Statistics over OSC to: %s:%u",
dstAddress.c_str(), dstPort);
SendInit();
} else {
delete oscPacker;
oscPacker = NULL;
delete network->outSocket;
network->outSocket = NULL;
delete network->destination;
network->destination = NULL;
delete network;
delete [] oscOutputBuffer;
oscOutputBuffer = NULL;
}
}
}
void
StorageChild::InitRemote()
{
ContentChild* child = ContentChild::GetSingleton();
AddIPDLReference();
child->SendPStorageConstructor(this, null_t());
SendInit(mUseDB, mCanUseChromePersist, mSessionOnly, mInPrivateBrowsing, mDomain, mScopeDBKey,
mQuotaDomainDBKey, mQuotaETLDplus1DomainDBKey, mStorageType);
}
nsresult
StorageChild::CloneFrom(bool aCallerSecure, DOMStorageBase* aThat)
{
StorageChild* other = static_cast<StorageChild*>(aThat);
ContentChild* child = ContentChild::GetSingleton();
StorageClone clone(nullptr, other, aCallerSecure);
AddIPDLReference();
child->SendPStorageConstructor(this, clone);
SendInit(mUseDB, mCanUseChromePersist, mSessionOnly, mInPrivateBrowsing, mDomain,
mScopeDBKey, mQuotaDomainDBKey, mQuotaETLDplus1DomainDBKey, mStorageType);
return NS_OK;
}
nsresult
WyciwygChannelChild::Init(nsIURI* uri)
{
NS_ENSURE_ARG_POINTER(uri);
mState = WCC_INIT;
mURI = uri;
mOriginalURI = uri;
SendInit(IPC::URI(mURI));
return NS_OK;
}
CComChannel* CKadHandler::PrepareChannel(const CNodeAddress& Address, CKadNode* pNode)
{
CComChannel* pChannel = NULL;
if(CSafeAddress* pAddress = Address.GetAssistent()) // if node is firewalled
{
// Note: we can not send a direct packet we must always stream
// we dont want to use assistant nodes to relay packets, its enough thay broker the connection for us
if(!pAddress->IsValid())
return NULL; //node dont have an assistant and is not directly reachable, we cant communicate right now
const CMyAddress* pMyAddress = GetParent<CKademlia>()->Fwh()->GetAddress(Address.GetProtocol());
if(pMyAddress->GetAssistent()) // and we are two
{
GetParent<CKademlia>()->Fwh()->SendTunnel(Address, false);
if(pAddress->GetPort() == 0)
return NULL; // node can't tunnel, we could only use a callback if we ware open, but we are closed, so we cant communicate at all
pChannel = Rendevouz(Address);
}
else
{
GetParent<CKademlia>()->Fwh()->SendTunnel(Address, true);
pChannel = CallBack(Address, false);
}
}
else
pChannel = Connect(Address);
if(pChannel)
{
bool bAdded = false;
SKadData* pData = pChannel->GetData<SKadData>(&bAdded);
ASSERT(bAdded);
pData->pNode = pNode;
pChannel->AddUpLimit(pNode->GetUpLimit());
pChannel->AddDownLimit(pNode->GetDownLimit());
SendInit(pNode, pChannel);
// Encrypt and authenticate all channels by default
bool bEncrypt = true;
bool bAuthenticate = true;
pChannel->SetQueueLock(true);
m_KeyExchanges.insert(TExchangeMap::value_type(SKadNode(pNode, pChannel), SKeyExchange(bEncrypt, bAuthenticate, 0)));
ResumeExchange(pNode);
}
return pChannel;
}
nsresult
GMPDecryptorParent::Init(GMPDecryptorProxyCallback* aCallback)
{
if (mIsOpen) {
NS_WARNING("Trying to re-use an in-use GMP decrypter!");
return NS_ERROR_FAILURE;
}
mCallback = aCallback;
if (!SendInit()) {
return NS_ERROR_FAILURE;
}
mIsOpen = true;
return NS_OK;
}
nsresult
GMPDecryptorParent::Init(GMPDecryptorProxyCallback* aCallback,
bool aDistinctiveIdentifierRequired,
bool aPersistentStateRequired)
{
LOGD(("GMPDecryptorParent[%p]::Init()", this));
if (mIsOpen) {
NS_WARNING("Trying to re-use an in-use GMP decrypter!");
return NS_ERROR_FAILURE;
}
mCallback = aCallback;
if (!SendInit(aDistinctiveIdentifierRequired, aPersistentStateRequired)) {
return NS_ERROR_FAILURE;
}
mIsOpen = true;
return NS_OK;
}
void
GPUChild::Init()
{
// Build a list of prefs the GPU process will need. Note that because we
// limit the GPU process to prefs contained in gfxPrefs, we can simplify
// the message in two ways: one, we only need to send its index in gfxPrefs
// rather than its name, and two, we only need to send prefs that don't
// have their default value.
nsTArray<GfxPrefSetting> prefs;
for (auto pref : gfxPrefs::all()) {
if (pref->HasDefaultValue()) {
continue;
}
GfxPrefValue value;
pref->GetCachedValue(&value);
prefs.AppendElement(GfxPrefSetting(pref->Index(), value));
}
SendInit(prefs);
}
char *
Tk_SetAppName(
Tk_Window tkwin, /* Token for any window in the application
* to be named: it is just used to identify
* the application and the display. */
char *name) /* The name that will be used to
* refer to the interpreter in later
* "send" commands. Must be globally
* unique. */
{
TkWindow *winPtr = (TkWindow *) tkwin;
Tcl_Interp *interp = winPtr->mainPtr->interp;
int i, suffix, offset, result;
int createCommand = 0;
RegisteredInterp *riPtr, *prevPtr;
char *actualName;
Tcl_DString dString;
Tcl_Obj *resultObjPtr, *interpNamePtr;
char *interpName;
if (!initialized) {
SendInit(interp);
}
/*
* See if the application is already registered; if so, remove its
* current name from the registry. The deletion of the command
* will take care of disposing of this entry.
*/
for (riPtr = interpListPtr, prevPtr = NULL; riPtr != NULL;
prevPtr = riPtr, riPtr = riPtr->nextPtr) {
if (riPtr->interp == interp) {
if (prevPtr == NULL) {
interpListPtr = interpListPtr->nextPtr;
} else {
prevPtr->nextPtr = riPtr->nextPtr;
}
break;
}
}
/*
* Pick a name to use for the application. Use "name" if it's not
* already in use. Otherwise add a suffix such as " #2", trying
* larger and larger numbers until we eventually find one that is
* unique.
*/
actualName = name;
suffix = 1;
offset = 0;
Tcl_DStringInit(&dString);
TkGetInterpNames(interp, tkwin);
resultObjPtr = Tcl_GetObjResult(interp);
Tcl_IncrRefCount(resultObjPtr);
for (i = 0; ; ) {
result = Tcl_ListObjIndex(NULL, resultObjPtr, i, &interpNamePtr);
if (interpNamePtr == NULL) {
break;
}
interpName = Tcl_GetStringFromObj(interpNamePtr, NULL);
if (strcmp(actualName, interpName) == 0) {
if (suffix == 1) {
Tcl_DStringAppend(&dString, name, -1);
Tcl_DStringAppend(&dString, " #", 2);
offset = Tcl_DStringLength(&dString);
Tcl_DStringSetLength(&dString, offset + 10);
actualName = Tcl_DStringValue(&dString);
}
suffix++;
sprintf(actualName + offset, "%d", suffix);
i = 0;
} else {
i++;
}
}
Tcl_DecrRefCount(resultObjPtr);
Tcl_ResetResult(interp);
/*
* We have found a unique name. Now add it to the registry.
*/
riPtr = (RegisteredInterp *) ckalloc(sizeof(RegisteredInterp));
riPtr->interp = interp;
riPtr->name = ckalloc(strlen(actualName) + 1);
riPtr->nextPtr = interpListPtr;
interpListPtr = riPtr;
strcpy(riPtr->name, actualName);
Tcl_CreateObjCommand(interp, "send", Tk_SendObjCmd,
(ClientData) riPtr, NULL /* TODO: DeleteProc */);
if (Tcl_IsSafe(interp)) {
Tcl_HideCommand(interp, "send", "send");
}
Tcl_DStringFree(&dString);
return riPtr->name;
}
int WaitForInit(string& strCommandLine, string& strWorkingDir, string& strCommandParams)
{
SMsgHeader MsgHdr;
TCharVector MessageBuffer;
MessageBuffer.resize(MSGBUFF_DEFSIZE);
strCommandLine = "";
printf("Waiting for INIT - ");
bool bContinueWait = true;
int nInvalid = 0;
while (bContinueWait == true)
{
//read the header
EMessageType eType = g_DebugSocket.ReadMessageHdr(&MsgHdr);
//check to see that the socket is still connected
if (g_DebugSocket.eGetState() != CHeDbgSocket::eSOCKSTATE_CONNECTED)
{
dprintf("Socket connection closed - quitting\n");
return -1;
}
if (eType > eMSG_INVALID)
{
//read the message body (if any)
int nMsgBytes = MsgHdr.GetMsgSize(); //strtol(MsgHdr.MsgSize, NULL, 10);
int nMsgSize = 0;
MessageBuffer.resize(nMsgBytes);
if (nMsgBytes > 0)
{
memset(&(MessageBuffer[0]), 0, MessageBuffer.size());
nMsgSize = g_DebugSocket.ReadMessageBody(&(MessageBuffer[0]), &MsgHdr);
}
//ignore messages other than INIT and EXIT
switch (eType)
{
case eMSG_INIT:
//init received, store the command line, parameters and path
if (MessageBuffer.size() > 0)
{
const char* pCurStr = &(MessageBuffer[0]);
strCommandLine = pCurStr;
pCurStr += strlen(pCurStr) + 1;
strWorkingDir = pCurStr;
pCurStr += strlen(pCurStr) + 1;
strCommandParams = pCurStr;
printf("INIT received\nExecuting: %s\n", &(MessageBuffer[0]));
}
else
printf("INIT received without command line - exiting\n");
bContinueWait = false;
break;
case eMSG_SETOPTION:
SetOption(&(MessageBuffer[0]));
break;
case eMSG_EXIT:
printf("EXIT received while waiting for INIT - exiting\n");
bContinueWait = false;
break;
case eMSG_PING:
g_DebugSocket.SendMessage(eMSG_PONG, "");
break;
default:
dprintf("Invalid message for Init state: %d\n", eType);
}
}
else
{
//no message received, sleep for a bit.
Sleep(WAITINIT_SLEEPMS);
//if we wait for a while and still haven't gotten a response, resend the
//init - if the socket is closed, this will reset the socket's state, otherwise
//it will give the debug client another chance to respond
if (++nInvalid > INIT_RETRY_COUNT)
{
//resend init
SendInit();
}
}
}
if (strCommandLine.length() > 0)
return 0;
return -1;
} // WaitForInit
bool Xbox360Peripheral::start(IOService *provider)
{
const IOUSBConfigurationDescriptor *cd;
IOUSBFindInterfaceRequest intf;
IOUSBFindEndpointRequest pipe;
XBOX360_OUT_LED led;
IOWorkLoop *workloop = NULL;
/*
* Xbox One controller init packets.
* The Rock Candy Xbox One controller requires more than just 0x05
* Minimum required packets unknown.
*/
UInt8 xoneInitFirst[] = { 0x02, 0x20, 0x01, 0x1C, 0x7E, 0xED, 0x8B, 0x11, 0x0F, 0xA8, 0x00, 0x00, 0x5E, 0x04, 0xD1, 0x02, 0x01, 0x00, 0x01, 0x00, 0x17, 0x01, 0x02, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00 };
UInt8 xoneInitSecond[] = { 0x05, 0x20, 0x00, 0x09, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x55, 0x53 };
UInt8 xoneInitThird[] = { 0x05, 0x20, 0x01, 0x01, 0x00 };
UInt8 xoneInitFourth[] = { 0x0A, 0x20, 0x02, 0x03, 0x00, 0x01, 0x14 };
if (!super::start(provider))
return false;
// Get device
device=OSDynamicCast(IOUSBDevice,provider);
if(device==NULL) {
IOLog("start - invalid provider\n");
goto fail;
}
// Check for configurations
if(device->GetNumConfigurations()<1) {
device=NULL;
IOLog("start - device has no configurations!\n");
goto fail;
}
// Set configuration
cd=device->GetFullConfigurationDescriptor(0);
if(cd==NULL) {
device=NULL;
IOLog("start - couldn't get configuration descriptor\n");
goto fail;
}
// Open
if(!device->open(this)) {
device=NULL;
IOLog("start - unable to open device\n");
goto fail;
}
if(device->SetConfiguration(this,cd->bConfigurationValue,true)!=kIOReturnSuccess) {
IOLog("start - unable to set configuration\n");
goto fail;
}
// Get release
{
UInt16 release = device->GetDeviceRelease();
switch (release) {
default:
IOLog("Unknown device release %.4x\n", release);
// fall through
case 0x0110:
chatpadInit[0] = 0x01;
chatpadInit[1] = 0x02;
break;
case 0x0114:
chatpadInit[0] = 0x09;
chatpadInit[1] = 0x00;
break;
}
}
// Find correct interface
controllerType = Xbox360;
intf.bInterfaceClass=kIOUSBFindInterfaceDontCare;
intf.bInterfaceSubClass=93;
intf.bInterfaceProtocol=1;
intf.bAlternateSetting=kIOUSBFindInterfaceDontCare;
interface=device->FindNextInterface(NULL,&intf);
if(interface==NULL) {
// Find correct interface, Xbox original
intf.bInterfaceClass=kIOUSBFindInterfaceDontCare;
intf.bInterfaceSubClass=66;
intf.bInterfaceProtocol=0;
intf.bAlternateSetting=kIOUSBFindInterfaceDontCare;
interface=device->FindNextInterface(NULL,&intf);
if(interface==NULL) {
// Find correct interface, Xbox One
intf.bInterfaceClass=255;
intf.bInterfaceSubClass=71;
intf.bInterfaceProtocol=208;
intf.bAlternateSetting=kIOUSBFindInterfaceDontCare;
interface=device->FindNextInterface(NULL, &intf);
if(interface==NULL)
{
IOLog("start - unable to find the interface\n");
goto fail;
}
controllerType = XboxOne;
goto interfacefound;
}
controllerType = XboxOriginal;
goto interfacefound;
}
interfacefound:
interface->open(this);
// Find pipes
pipe.direction=kUSBIn;
pipe.interval=0;
pipe.type=kUSBInterrupt;
pipe.maxPacketSize=0;
inPipe=interface->FindNextPipe(NULL,&pipe);
if(inPipe==NULL) {
IOLog("start - unable to find in pipe\n");
goto fail;
}
inPipe->retain();
pipe.direction=kUSBOut;
outPipe=interface->FindNextPipe(NULL,&pipe);
if(outPipe==NULL) {
IOLog("start - unable to find out pipe\n");
goto fail;
}
outPipe->retain();
// Get a buffer
inBuffer=IOBufferMemoryDescriptor::inTaskWithOptions(kernel_task,0,GetMaxPacketSize(inPipe));
if(inBuffer==NULL) {
IOLog("start - failed to allocate input buffer\n");
goto fail;
}
// Find chatpad interface
intf.bInterfaceClass = kIOUSBFindInterfaceDontCare;
intf.bInterfaceSubClass = 93;
intf.bInterfaceProtocol = 2;
intf.bAlternateSetting = kIOUSBFindInterfaceDontCare;
serialIn = device->FindNextInterface(NULL, &intf);
if (serialIn == NULL) {
IOLog("start - unable to find chatpad interface\n");
goto nochat;
}
serialIn->open(this);
// Find chatpad pipe
pipe.direction = kUSBIn;
pipe.interval = 0;
pipe.type = kUSBInterrupt;
pipe.maxPacketSize = 0;
serialInPipe = serialIn->FindNextPipe(NULL, &pipe);
if (serialInPipe == NULL)
{
IOLog("start - unable to find chatpad in pipe\n");
goto fail;
}
serialInPipe->retain();
// Get a buffer for the chatpad
serialInBuffer = IOBufferMemoryDescriptor::inTaskWithOptions(kernel_task, 0, GetMaxPacketSize(serialInPipe));
if (serialInBuffer == NULL)
{
IOLog("start - failed to allocate input buffer for chatpad\n");
goto fail;
}
// Create timer for chatpad
serialTimer = IOTimerEventSource::timerEventSource(this, ChatPadTimerActionWrapper);
if (serialTimer == NULL)
{
IOLog("start - failed to create timer for chatpad\n");
goto fail;
}
workloop = getWorkLoop();
if ((workloop == NULL) || (workloop->addEventSource(serialTimer) != kIOReturnSuccess))
{
IOLog("start - failed to connect timer for chatpad\n");
goto fail;
}
// Configure ChatPad
// Send 'configuration'
SendInit(0xa30c, 0x4423);
SendInit(0x2344, 0x7f03);
SendInit(0x5839, 0x6832);
// Set 'switch'
if ((!SendSwitch(false)) || (!SendSwitch(true)) || (!SendSwitch(false))) {
// Commenting goto fail fixes the driver for the Hori Real Arcade Pro EX
//goto fail;
}
// Begin toggle
serialHeard = false;
serialActive = false;
serialToggle = false;
serialResetCount = 0;
serialTimerState = tsToggle;
serialTimer->setTimeoutMS(1000);
// Begin reading
if (!QueueSerialRead())
goto fail;
nochat:
if (!QueueRead())
goto fail;
if (controllerType == XboxOne) {
QueueWrite(&xoneInitFirst, sizeof(xoneInitFirst));
QueueWrite(&xoneInitSecond, sizeof(xoneInitSecond));
QueueWrite(&xoneInitThird, sizeof(xoneInitThird));
QueueWrite(&xoneInitFourth, sizeof(xoneInitFourth));
} else {
// Disable LED
Xbox360_Prepare(led,outLed);
led.pattern=ledOff;
QueueWrite(&led,sizeof(led));
}
// Done
PadConnect();
registerService();
return true;
fail:
ReleaseAll();
return false;
}
///////////////////////////////////////////////////////////////////////////////
//
// Check to make sure the message is adequately defined and send it.
//
bool cPipedMailMessage::Send()
{
// Be sure that everything that needs to be set has been set
if (!Ready())
{
// the message has not been adequately defined and cannot be sent.
return false;
}
SendInit();
ASSERT(mpFile != 0);
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Get Body and Attachments
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// get body
std::string sNBody = cStringUtil::TstrToStr(mstrBody);
// get attachments
std::string sAttachments;
if (!GetAttachmentsAsString(sAttachments))
{
sAttachments.erase();
}
std::string sSend = sNBody + sAttachments;
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Make sure that there's no lone LFs
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
cMailMessageUtil::LFToCRLF(sSend);
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Determine encoding needed for body or attachments
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
std::string sContentType = "Content-Transfer-Encoding: ";
if (cMailMessageUtil::HasNonAsciiChars(sSend))
{
// encode text
sSend = iMimeEncoding::GetInstance()->Encode(sSend, cMailMessageUtil::_MAX_RFC822_LINE_LEN);
// identify content type
sContentType += iMimeEncoding::GetInstance()->GetContentTypeIdentifier();
}
else
{
// do no encoding
// identify content type
sContentType += "7bit";
}
// send content type
sContentType += "\r\n";
SendString(cStringUtil::StrToTstr(sContentType));
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Send Body and Attachments
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SendString(_T("\r\n"));
SendString(cStringUtil::StrToTstr(sSend));
SendFinit();
return true;
}
bool CKadHandler::ProcessPacket(const string& Name, const CVariant& Packet, CComChannel* pChannel)
{
CKadNode* pNode = NULL;
try
{
// Process cahnnel initialisation
if(Name == KAD_INIT)
{
if(GetParent<CKademlia>()->Cfg()->GetBool("DebugTL"))
LogLine(LOG_DEBUG, L"Recived 'Transaction Init' from %s", CUInt128(Packet["NID"]).ToHex().c_str());
bool bAdded = false;
SKadData* pData = pChannel->GetData<SKadData>(&bAdded);
if(!pData->pNode)
{
pData->pNode = GetParent<CKademlia>()->Root()->GetNode(Packet["NID"]);
if(!pData->pNode)
{
pData->pNode = new CKadNode(GetParent<CKademlia>()->Root());
pData->pNode->SetID(Packet["NID"]);
GetParent<CKademlia>()->Root()->AddNode(pData->pNode);
}
pChannel->AddUpLimit(pData->pNode->GetUpLimit());
pChannel->AddDownLimit(pData->pNode->GetDownLimit());
}
else if(pData->pNode->GetID() != Packet["NID"])
throw CException(LOG_ERROR, L"KadNode Miss Match"); // this should never ever happen!
pData->pNode->SetProtocol(Packet["PROT"]);
pData->pNode->SetVersion(Packet.Get("VER")); // Version is optional
pData->Connected = true;
if(bAdded) // if it was added it means its an incomming connectziona dnwe have to answer
{
SendInit(pData->pNode, pChannel);
pData->pNode->UpdateAddress(pChannel->GetAddress()); // If this is incomming update addresses
}
return true;
}
else
{
if(SKadData* pData = pChannel->GetData<SKadData>())
pNode = pData->pNode;
if(!pNode || !pNode->GetParent())
throw CException(LOG_WARNING, L"Kad Packet Recived %S on not initialized channel", Name.c_str());
}
if(Name.compare(KAD_CRYPTO_REQUEST) == 0) HandleCryptoRequest(Packet, pNode, pChannel);
else if(Name.compare(KAD_CRYPTO_RESPONSE) == 0) HandleCryptoResponse(Packet, pNode, pChannel);
else if(Name.compare(KAD_HELLO_REQUEST) == 0) HandleHello(Packet, pNode, pChannel, true);
else if(Name.compare(KAD_HELLO_RESPONSE) == 0) HandleHello(Packet, pNode, pChannel, false);
else if(Name.compare(KAD_NODE_REQUEST) == 0) HandleNodeReq(Packet, pNode, pChannel);
else if(Name.compare(KAD_NODE_RESPONSE) == 0) HandleNodeRes(Packet, pNode, pChannel);
// Lookup Handling
else if(Name.compare(KAD_PROXY_REQUEST) == 0) HandleProxyReq(Packet, pNode, pChannel);
else if(Name.compare(KAD_PROXY_RESPONSE) == 0) HandleProxyRes(Packet, pNode, pChannel);
else if(Name.compare(KAD_CODE_REQUEST) == 0) HandleCodeReq(Packet, pNode, pChannel);
else if(Name.compare(KAD_CODE_RESPONSE) == 0) HandleCodeRes(Packet, pNode, pChannel);
else if(Name.compare(KAD_LOOKUP_MESSAGE) == 0) HandleMessagePkt(Packet, pNode, pChannel);
else if(Name.compare(KAD_EXECUTE_REQUEST) == 0) HandleExecuteReq(Packet, pNode, pChannel);
else if(Name.compare(KAD_EXECUTE_RESPONSE) == 0) HandleExecuteRes(Packet, pNode, pChannel);
else if(Name.compare(KAD_STORE_REQUEST) == 0) HandleStoreReq(Packet, pNode, pChannel);
else if(Name.compare(KAD_STORE_RESPONSE) == 0) HandleStoreRes(Packet, pNode, pChannel);
else if(Name.compare(KAD_LOAD_REQUEST) == 0) HandleLoadReq(Packet, pNode, pChannel);
else if(Name.compare(KAD_LOAD_RESPONSE) == 0) HandleLoadRes(Packet, pNode, pChannel);
else if(Name.compare(KAD_LOOKUP_REPORT) == 0) HandleReportPkt(Packet, pNode, pChannel);
// Routing Handling
else if(Name.compare(KAD_ROUTE_REQUEST) == 0) HandleRouteReq(Packet, pNode, pChannel);
else if(Name.compare(KAD_ROUTE_RESPONSE) == 0) HandleRouteRes(Packet, pNode, pChannel);
else if(Name.compare(KAD_RELAY_REQUEST) == 0) HandleRelayReq(Packet, pNode, pChannel);
else if(Name.compare(KAD_RELAY_RESPONSE) == 0) HandleRelayRes(Packet, pNode, pChannel);
else if(Name.compare(KAD_RELAY_RETURN) == 0) HandleRelayRet(Packet, pNode, pChannel);
else if(Name.compare(KAD_RELAY_CONTROL) == 0) HandleRelayCtrl(Packet, pNode, pChannel);
else if(Name.compare(KAD_RELAY_STATUS) == 0) HandleRelayStat(Packet, pNode, pChannel);
else
throw CException(LOG_WARNING, L"Unsupported Kad Packet Recived %S", Name.c_str());
}
catch(const CException& Exception)
{
LogLine(Exception.GetFlag(), L"Packet \'%S\' Error: '%s' from: %s (%s)", Name.c_str(), Exception.GetLine().c_str(), pNode ? pNode->GetID().ToHex().c_str() : L"Unknown", pChannel->GetAddress().ToString().c_str());
pChannel->Close();
return false;
}
return true;
}
