//-----------------------------------------------------------------------------

//

// Driver.cpp

//

// Communicates with a Z-Wave network

//

// Copyright (c) 2010 Mal Lansell <openzwave@lansell.org>

//

// SOFTWARE NOTICE AND LICENSE

//

// This file is part of OpenZWave.

//

// OpenZWave is free software: you can redistribute it and/or modify

// it under the terms of the GNU Lesser General Public License as published

// by the Free Software Foundation, either version 3 of the License,

// or (at your option) any later version.

//

// OpenZWave is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

// GNU Lesser General Public License for more details.

//

// You should have received a copy of the GNU Lesser General Public License

// along with OpenZWave. If not, see <http://www.gnu.org/licenses/>.

//

//-----------------------------------------------------------------------------

#include "Defs.h"

#include "Driver.h"

#include "Options.h"

#include "Manager.h"

#include "Node.h"

#include "Msg.h"

#include "Notification.h"

#include "Scene.h"

#include "ZWSecurity.h"

#include "DNSThread.h"

#include "TimerThread.h"

#include "Http.h"

#include "ManufacturerSpecificDB.h"

#include "platform/Event.h"

#include "platform/Mutex.h"

#include "platform/SerialController.h"

#ifdef USE_HID

#ifdef WINRT

#include "platform/winRT/HidControllerWinRT.h"

#else

#include "platform/HidController.h"

#endif

#endif

#include "platform/Thread.h"

#include "platform/Log.h"

#include "platform/TimeStamp.h"

#include "command_classes/CommandClasses.h"

#include "command_classes/ApplicationStatus.h"

#include "command_classes/ControllerReplication.h"

#include "command_classes/Security.h"

#include "command_classes/WakeUp.h"

#include "command_classes/SwitchAll.h"

#include "command_classes/ManufacturerSpecific.h"

#include "command_classes/NoOperation.h"

#include "value_classes/ValueID.h"

#include "value_classes/Value.h"

#include "value_classes/ValueStore.h"

#include "tinyxml.h"

#include "Utils.h"

#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))

# include <unistd.h>

#elif defined _WIN32

# include <windows.h>

#define sleep(x) Sleep(1000 * x)

#endif

#include <algorithm>

#include <iostream>

#include <sstream>

#include <iomanip>

using namespace OpenZWave;

// Version numbering for saved configurations. Any change that will invalidate

// previously saved configurations must be accompanied by an increment to the

// version number, and a comment explaining the date of, and reason for, the change.

//

// 01: 12-31-2010 - Introduced config version numbering due to ValueID format change.

// 02: 01-12-2011 - Command class m_afterMark sense corrected, and attribute named to match.

// 03: 08-04-2011 - Changed command class instance handling for non-sequential MultiChannel endpoints.

// 04: 12-07-2019 - Changed Interview Order

uint32 const c_configVersion = 4;

static char const* c_libraryTypeNames[] =

{ "Unknown", // library type 0

"Static Controller", // library type 1

"Controller", // library type 2

"Enhanced Slave", // library type 3

"Slave", // library type 4

"Installer", // library type 5

"Routing Slave", // library type 6

"Bridge Controller", // library type 7

"Device Under Test" // library type 8

};

static char const* c_controllerCommandNames[] =

{ "None", "Add Device", "Create New Primary", "Receive Configuration", "Remove Device", "Remove Failed Node", "Has Node Failed", "Replace Failed Node", "Transfer Primary Role", "Request Network Update", "Request Node Neighbor Update", "Assign Return Route", "Delete All Return Routes", "Send Node Information", "Replication Send", "Create Button", "Delete Button" };

static char const* c_sendQueueNames[] =

{ "Command", "NoOp", "Controller", "WakeUp", "Send", "Query", "Poll" };

//-----------------------------------------------------------------------------

// <Driver::Driver>

// Constructor

//-----------------------------------------------------------------------------

Driver::Driver(string const& _controllerPath, ControllerInterface const& _interface) :

m_driverThread(new Internal::Platform::Thread("driver")), m_dns(new Internal::DNSThread(this)), m_dnsThread(new Internal::Platform::Thread("dns")), m_initMutex(new Internal::Platform::Mutex()), m_exit(false), m_init(false), m_awakeNodesQueried(false), m_allNodesQueried(false), m_notifytransactions(false), m_timer(new Internal::TimerThread(this)), m_timerThread(new Internal::Platform::Thread("timer")), m_controllerInterfaceType(_interface), m_controllerPath(_controllerPath), m_controller(

NULL), m_homeId(0), m_libraryVersion(""), m_libraryTypeName(""), m_libraryType(0), m_manufacturerId(0), m_productType(0), m_productId(0), m_initVersion(0), m_initCaps(0), m_controllerCaps(0), m_Controller_nodeId(0), m_nodeMutex(new Internal::Platform::Mutex()), m_controllerReplication( NULL), m_transmitOptions( TRANSMIT_OPTION_ACK | TRANSMIT_OPTION_AUTO_ROUTE | TRANSMIT_OPTION_EXPLORE), m_waitingForAck(false), m_expectedCallbackId(0), m_expectedReply(0), m_expectedCommandClassId(

0), m_expectedNodeId(0), m_pollThread(new Internal::Platform::Thread("poll")), m_pollMutex(new Internal::Platform::Mutex()), m_pollInterval(0), m_bIntervalBetweenPolls(false), // if set to true (via SetPollInterval), the pollInterval will be interspersed between each poll (so a much smaller m_pollInterval like 100, 500, or 1,000 may be appropriate)

m_currentControllerCommand( NULL), m_SUCNodeId(0), m_controllerResetEvent( NULL), m_sendMutex(new Internal::Platform::Mutex()), m_currentMsg( NULL), m_virtualNeighborsReceived(false), m_notificationsEvent(new Internal::Platform::Event()), m_SOFCnt(0), m_ACKWaiting(0), m_readAborts(0), m_badChecksum(0), m_readCnt(0), m_writeCnt(0), m_CANCnt(0), m_NAKCnt(0), m_ACKCnt(0), m_OOFCnt(0), m_dropped(0), m_retries(0), m_callbacks(0), m_badroutes(0), m_noack(0), m_netbusy(0), m_notidle(0), m_txverified(

0), m_nondelivery(0), m_routedbusy(0), m_broadcastReadCnt(0), m_broadcastWriteCnt(0), AuthKey(0), EncryptKey(0), m_nonceReportSent(0), m_nonceReportSentAttempt(0), m_queueMsgEvent(new Internal::Platform::Event()), m_eventMutex(new Internal::Platform::Mutex())

{

// set a timestamp to indicate when this driver started

Internal::Platform::TimeStamp m_startTime;

// Create the message queue events

for (int32 i = 0; i < MsgQueue_Count; ++i)

{

m_queueEvent[i] = new Internal::Platform::Event();

}

// Clear the nodes array

memset(m_nodes, 0, sizeof(Node*) * 256);

// Clear the virtual neighbors array

memset(m_virtualNeighbors, 0, NUM_NODE_BITFIELD_BYTES);

// Initialize the Network Keys

initNetworkKeys(false);

#ifdef USE_HID

if( ControllerInterface_Hid == _interface )

{

m_controller = new Internal::Platform::HidController();

}

else

#endif

{

m_controller = new Internal::Platform::SerialController();

}

m_controller->SetSignalThreshold(1);

Options::Get()->GetOptionAsBool("NotifyTransactions", &m_notifytransactions);

Options::Get()->GetOptionAsInt("PollInterval", &m_pollInterval);

Options::Get()->GetOptionAsBool("IntervalBetweenPolls", &m_bIntervalBetweenPolls);

m_httpClient = new Internal::HttpClient(this);

m_mfs = Internal::ManufacturerSpecificDB::Create();

CheckMFSConfigRevision();

}

//-----------------------------------------------------------------------------

// <Driver::Driver>

// Destructor

//-----------------------------------------------------------------------------

Driver::~Driver()

{

/* Signal that we are going away... so at least Apps know... */

Notification* notification = new Notification(Notification::Type_DriverRemoved);

notification->SetHomeAndNodeIds(m_homeId, 0);

QueueNotification(notification);

NotifyWatchers();

// append final driver stats output to the log file

LogDriverStatistics();

// Save the driver config before deleting anything else

bool save;

if (Options::Get()->GetOptionAsBool("SaveConfiguration", &save))

{

if (save)

{

WriteCache();

Internal::Scene::WriteXML("zwscene.xml");

}

}

// The order of the statements below has been achieved by mitigating freed memory

//references using a memory allocator checker. Do not rearrange unless you are

//certain memory won't be referenced out of order. --Greg Satz, April 2010

m_initMutex->Lock();

m_exit = true;

m_initMutex->Unlock();

m_pollThread->Stop();

m_pollThread->Release();

m_dnsThread->Stop();

m_dnsThread->Release();

delete m_dns;

m_driverThread->Stop();

m_driverThread->Release();

m_timerThread->Stop();

m_timerThread->Release();

delete m_timer;

m_sendMutex->Release();

m_controller->Close();

m_controller->Release();

m_initMutex->Release();

if (m_currentMsg != NULL)

{

RemoveCurrentMsg();

}

// Clear the node data

{

Internal::LockGuard LG(m_nodeMutex);

for (int i = 0; i < 256; ++i)

{

if (GetNodeUnsafe(i))

{

delete m_nodes[i];

m_nodes[i] = NULL;

Notification* notification = new Notification(Notification::Type_NodeRemoved);

notification->SetHomeAndNodeIds(m_homeId, i);

QueueNotification(notification);

}

}

}

// Don't release until all nodes have removed their poll values

m_pollMutex->Release();

// Clear the send Queue

for (int32 i = 0; i < MsgQueue_Count; ++i)

{

while (!m_msgQueue[i].empty())

{

MsgQueueItem const& item = m_msgQueue[i].front();

if (MsgQueueCmd_SendMsg == item.m_command)

{

delete item.m_msg;

}

else if (MsgQueueCmd_Controller == item.m_command)

{

delete item.m_cci;

}

m_msgQueue[i].pop_front();

}

m_queueEvent[i]->Release();

}

/* Doing our Notification Call back here in the destructor is just asking for trouble

* as there is a good chance that the application will do some sort of GetDriver() supported

* method on the Manager Class, which by this time, most of the OZW Classes associated with the

* Driver class is 99% destructed. (mainly nodes, which cascade to CC, which cascade to ValueID

* classes etc). We might need a flag around the Manager::GetDriver() class that stops applications

* from getting a half destructed Driver Reference, but still retain a Internal GetDriver() method

* that can return half destructed Driver references for internal classes (as per Greg's note above)

*/

bool notify;

if (Options::Get()->GetOptionAsBool("NotifyOnDriverUnload", &notify))

{

if (notify)

{

NotifyWatchers();

}

}

list<Notification*>::iterator nit = m_notifications.begin();

while (nit != m_notifications.end())

{

Notification* notification = m_notifications.front();

m_notifications.pop_front();

delete notification;

nit = m_notifications.begin();

}

if (m_controllerReplication)

delete m_controllerReplication;

m_notificationsEvent->Release();

m_nodeMutex->Release();

m_queueMsgEvent->Release();

m_eventMutex->Release();

delete this->AuthKey;

delete this->EncryptKey;

delete this->m_httpClient;

}

//-----------------------------------------------------------------------------

// <Driver::Start>

// Start the driver thread

//-----------------------------------------------------------------------------

void Driver::Start()

{

// Start the thread that will handle communications with the Z-Wave network

m_driverThread->Start(Driver::DriverThreadEntryPoint, this);

m_dnsThread->Start(Internal::DNSThread::DNSThreadEntryPoint, m_dns);

m_timerThread->Start(Internal::TimerThread::TimerThreadEntryPoint, m_timer);

}

//-----------------------------------------------------------------------------

// <Driver::DriverThreadEntryPoint>

// Entry point of the thread for creating and managing the worker threads

//-----------------------------------------------------------------------------

void Driver::DriverThreadEntryPoint(Internal::Platform::Event* _exitEvent, void* _context)

{

Driver* driver = (Driver*) _context;

if (driver)

{

driver->DriverThreadProc(_exitEvent);

}

}

//-----------------------------------------------------------------------------

// <Driver::DriverThreadProc>

// Create and manage the worker threads

//-----------------------------------------------------------------------------

void Driver::DriverThreadProc(Internal::Platform::Event* _exitEvent)

{

#define WAITOBJECTCOUNT 11

uint32 attempts = 0;

bool mfsisReady = false;

while (true)

{

if (Init(attempts))

{

// Driver has been initialised

Internal::Platform::Wait* waitObjects[WAITOBJECTCOUNT];

waitObjects[0] = _exitEvent; // Thread must exit.

waitObjects[1] = m_notificationsEvent; // Notifications waiting to be sent.

waitObjects[2] = m_queueMsgEvent;

; // a DNS and HTTP Event

waitObjects[3] = m_controller; // Controller has received data.

waitObjects[4] = m_queueEvent[MsgQueue_Command]; // A controller command is in progress.

waitObjects[5] = m_queueEvent[MsgQueue_NoOp]; // Send device probes and diagnostics messages

waitObjects[6] = m_queueEvent[MsgQueue_Controller]; // A multi-part controller command is in progress

waitObjects[7] = m_queueEvent[MsgQueue_WakeUp]; // A node has woken. Pending messages should be sent.

waitObjects[8] = m_queueEvent[MsgQueue_Send]; // Ordinary requests to be sent.

waitObjects[9] = m_queueEvent[MsgQueue_Query]; // Node queries are pending.

waitObjects[10] = m_queueEvent[MsgQueue_Poll]; // Poll request is waiting.

Internal::Platform::TimeStamp retryTimeStamp;

int retryTimeout = RETRY_TIMEOUT;

Options::Get()->GetOptionAsInt("RetryTimeout", &retryTimeout);

//retryTimeout = RETRY_TIMEOUT * 10;

while (true)

{

Log::Write(LogLevel_StreamDetail, " Top of DriverThreadProc loop.");

uint32 count = WAITOBJECTCOUNT;

int32 timeout = Internal::Platform::Wait::Timeout_Infinite;

// if the ManufacturerDB class is setting up, we can't do anything yet

if (mfsisReady == false)

{

count = 3;

// If we're waiting for a message to complete, we can only

// handle incoming data, notifications, DNS/HTTP and exit events.

}

else if (m_waitingForAck || m_expectedCallbackId || m_expectedReply)

{

count = 4;

timeout = m_waitingForAck ? ACK_TIMEOUT : retryTimeStamp.TimeRemaining();

if (timeout < 0)

{

timeout = 0;

}

}

else if (m_currentControllerCommand != NULL)

{

count = 7;

}

else

{

Log::QueueClear(); // clear the log queue when starting a new message

}

// Wait for something to do

int32 res = Internal::Platform::Wait::Multiple(waitObjects, count, timeout);

switch (res)

{

case -1:

{

// Wait has timed out - time to resend

if (m_currentMsg != NULL)

{

Notification* notification = new Notification(Notification::Type_Notification);

notification->SetHomeAndNodeIds(m_homeId, m_currentMsg->GetTargetNodeId());

notification->SetNotification(Notification::Code_Timeout);

QueueNotification(notification);

}

if (WriteMsg("Wait Timeout"))

{

retryTimeStamp.SetTime(retryTimeout);

}

break;

}

case 0:

{

// Exit has been signalled

return;

}

case 1:

{

// Notifications are waiting to be sent

NotifyWatchers();

break;

}

case 2:

{

// a DNS or HTTP Event has occurred

ProcessEventMsg();

if (mfsisReady == false && m_mfs->isReady())

{

Notification* notification = new Notification(Notification::Type_ManufacturerSpecificDBReady);

QueueNotification(notification);

mfsisReady = true;

}

break;

}

case 3:

{

// Data has been received

ReadMsg();

break;

}

default:

{

// All the other events are sending message queue items

if (WriteNextMsg((MsgQueue) (res - 4)))

{

retryTimeStamp.SetTime(retryTimeout);

}

break;

}

}

}

}

++attempts;

uint32 maxAttempts = 0;

Options::Get()->GetOptionAsInt("DriverMaxAttempts", (int32 *) &maxAttempts);

if (maxAttempts && (attempts >= maxAttempts))

{

Manager::Get()->Manager::SetDriverReady(this, false);

NotifyWatchers();

break;

}

if (attempts < 25)

{

// Retry every 5 seconds for the first two minutes

if (Internal::Platform::Wait::Single(_exitEvent, 5000) == 0)

{

// Exit signalled.

return;

}

}

else

{

// Retry every 30 seconds after that

if (Internal::Platform::Wait::Single(_exitEvent, 30000) == 0)

{

// Exit signalled.

return;

}

}

}

}

//-----------------------------------------------------------------------------

// <Driver::Init>

// Initialize the controller

//-----------------------------------------------------------------------------

bool Driver::Init(uint32 _attempts)

{

m_initMutex->Lock();

if (m_exit)

{

m_initMutex->Unlock();

return false;

}

m_Controller_nodeId = 255;

m_waitingForAck = false;

// Open the controller

Log::Write(LogLevel_Info, " Opening controller %s", m_controllerPath.c_str());

if (!m_controller->Open(m_controllerPath))

{

Log::Write(LogLevel_Warning, "WARNING: Failed to init the controller (attempt %d)", _attempts);

m_initMutex->Unlock();

return false;

}

// Controller opened successfully, so we need to start all the worker threads

m_pollThread->Start(Driver::PollThreadEntryPoint, this);

// Send a NAK to the ZWave device

uint8 nak = NAK;

m_controller->Write(&nak, 1);

/* this kicks of the Init Sequence to get the Controller in shape. */

SendMsg(new Internal::Msg("FUNC_ID_ZW_GET_VERSION", 0xff, REQUEST, FUNC_ID_ZW_GET_VERSION, false), Driver::MsgQueue_Command);

//If we ever want promiscuous mode uncomment this code.

//Msg* msg = new Msg( "FUNC_ID_ZW_SET_PROMISCUOUS_MODE", 0xff, REQUEST, FUNC_ID_ZW_SET_PROMISCUOUS_MODE, false, false );

//msg->Append( 0xff );

//SendMsg( msg );

m_initMutex->Unlock();

// Init successful

return true;

}

//-----------------------------------------------------------------------------

// <Driver::RemoveQueues>

// Clean up any messages to a node

//-----------------------------------------------------------------------------

void Driver::RemoveQueues(uint8 const _nodeId)

{

if (m_currentMsg != NULL && m_currentMsg->GetTargetNodeId() == _nodeId)

{

RemoveCurrentMsg();

}

// Clear the send Queue

for (int32 i = 0; i < MsgQueue_Count; ++i)

{

list<MsgQueueItem>::iterator it = m_msgQueue[i].begin();

while (it != m_msgQueue[i].end())

{

bool remove = false;

MsgQueueItem const& item = *it;

if (MsgQueueCmd_SendMsg == item.m_command && _nodeId == item.m_msg->GetTargetNodeId())

{

delete item.m_msg;

remove = true;

}

else if (MsgQueueCmd_QueryStageComplete == item.m_command && _nodeId == item.m_nodeId)

{

remove = true;

}

else if (MsgQueueCmd_Controller == item.m_command && _nodeId == item.m_cci->m_controllerCommandNode && m_currentControllerCommand != item.m_cci)

{

delete item.m_cci;

remove = true;

}

else if (MsgQueueCmd_ReloadNode == item.m_command && _nodeId == item.m_nodeId)

{

remove = true;

}

if (remove)

{

it = m_msgQueue[i].erase(it);

}

else

{

++it;

}

}

if (m_msgQueue[i].empty())

{

m_queueEvent[i]->Reset();

}

}

}

//-----------------------------------------------------------------------------

// Configuration

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

// <Driver::ReadCache>

// Read our configuration from an XML document

//-----------------------------------------------------------------------------

bool Driver::ReadCache()

{

char str[32];

int32 intVal;

// Load the XML document that contains the driver configuration

string userPath;

Options::Get()->GetOptionAsString("UserPath", &userPath);

snprintf(str, sizeof(str), "ozwcache_0x%08x.xml", m_homeId);

string filename = userPath + string(str);

TiXmlDocument doc;

if (!doc.LoadFile(filename.c_str(), TIXML_ENCODING_UTF8))

{

return false;

}

doc.SetUserData((void *) filename.c_str());

TiXmlElement const* driverElement = doc.RootElement();

char const *xmlns = driverElement->Attribute("xmlns");

if (strcmp(xmlns, "https://github.com/OpenZWave/open-zwave"))

{

Log::Write(LogLevel_Warning, "Invalid XML Namespace. Ignoring %s", filename.c_str());

return false;

}

// Version

if (TIXML_SUCCESS != driverElement->QueryIntAttribute("version", &intVal) || (uint32) intVal != c_configVersion)

{

Log::Write(LogLevel_Warning, "WARNING: Driver::ReadCache - %s is from an older version of OpenZWave and cannot be loaded.", filename.c_str());

return false;

}

// Capabilities

if (TIXML_SUCCESS == driverElement->QueryIntAttribute("revision", &intVal))

{

m_mfs->setLatestRevision(intVal);

}

// Home ID

char const* homeIdStr = driverElement->Attribute("home_id");

if (homeIdStr)

{

char* p;

uint32 homeId = (uint32) strtoul(homeIdStr, &p, 0);

if (homeId != m_homeId)

{

Log::Write(LogLevel_Warning, "WARNING: Driver::ReadCache - Home ID in file %s is incorrect", filename.c_str());

return false;

}

}

else

{

Log::Write(LogLevel_Warning, "WARNING: Driver::ReadCache - Home ID is missing from file %s", filename.c_str());

return false;

}

// Node ID

if (TIXML_SUCCESS == driverElement->QueryIntAttribute("node_id", &intVal))

{

if ((uint8) intVal != m_Controller_nodeId)

{

Log::Write(LogLevel_Warning, "WARNING: Driver::ReadCache - Controller Node ID in file %s is incorrect", filename.c_str());

return false;

}

}

else

{

Log::Write(LogLevel_Warning, "WARNING: Driver::ReadCache - Node ID is missing from file %s", filename.c_str());

return false;

}

// Capabilities

if (TIXML_SUCCESS == driverElement->QueryIntAttribute("api_capabilities", &intVal))

{

m_initCaps = (uint8) intVal;

}

if (TIXML_SUCCESS == driverElement->QueryIntAttribute("controller_capabilities", &intVal))

{

m_controllerCaps = (uint8) intVal;

}

// Poll Interval

if (TIXML_SUCCESS == driverElement->QueryIntAttribute("poll_interval", &intVal))

{

m_pollInterval = intVal;

}

// Poll Interval--between polls or period for polling the entire pollList?

char const* cstr = driverElement->Attribute("poll_interval_between");

if (cstr)

{

m_bIntervalBetweenPolls = !strcmp(cstr, "true");

}

// Read the nodes

Internal::LockGuard LG(m_nodeMutex);

TiXmlElement const* nodeElement = driverElement->FirstChildElement();

while (nodeElement)

{

char const* str = nodeElement->Value();

if (str && !strcmp(str, "Node"))

{

// Get the node Id from the XML

if (TIXML_SUCCESS == nodeElement->QueryIntAttribute("id", &intVal))

{

uint8 nodeId = (uint8) intVal;

Node* node = new Node(m_homeId, nodeId);

m_nodes[nodeId] = node;

Notification* notification = new Notification(Notification::Type_NodeAdded);

notification->SetHomeAndNodeIds(m_homeId, nodeId);

QueueNotification(notification);

// Read the rest of the node configuration from the XML

node->ReadXML(nodeElement);

}

}

nodeElement = nodeElement->NextSiblingElement();

}

LG.Unlock();

// restore the previous state (for now, polling) for the nodes/values just retrieved

for (int i = 0; i < 256; i++)

{

if (m_nodes[i] != NULL)

{

Internal::VC::ValueStore* vs = m_nodes[i]->m_values;

for (Internal::VC::ValueStore::Iterator it = vs->Begin(); it != vs->End(); ++it)

{

Internal::VC::Value* value = it->second;

if (value->m_pollIntensity != 0)

EnablePoll(value->GetID(), value->m_pollIntensity);

}

}

}

return true;

}

//-----------------------------------------------------------------------------

// <Driver::WriteCache>

// Write ourselves to an XML document

//-----------------------------------------------------------------------------

void Driver::WriteCache()

{

char str[32];

if (!m_homeId)

{

Log::Write(LogLevel_Warning, "WARNING: Tried to write driver config with no home ID set");

return;

}

Log::Write(LogLevel_Info, "Saving Cache");

// Create a new XML document to contain the driver configuration

TiXmlDocument doc;

TiXmlDeclaration* decl = new TiXmlDeclaration("1.0", "utf-8", "");

TiXmlElement* driverElement = new TiXmlElement("Driver");

doc.LinkEndChild(decl);

doc.LinkEndChild(driverElement);

driverElement->SetAttribute("xmlns", "https://github.com/OpenZWave/open-zwave");

snprintf(str, sizeof(str), "%d", c_configVersion);

driverElement->SetAttribute("version", str);

snprintf(str, sizeof(str), "%d", GetManufacturerSpecificDB()->getRevision());

driverElement->SetAttribute("revision", str);

snprintf(str, sizeof(str), "0x%.8x", m_homeId);

driverElement->SetAttribute("home_id", str);

snprintf(str, sizeof(str), "%d", m_Controller_nodeId);

driverElement->SetAttribute("node_id", str);

snprintf(str, sizeof(str), "%d", m_initCaps);

driverElement->SetAttribute("api_capabilities", str);

snprintf(str, sizeof(str), "%d", m_controllerCaps);

driverElement->SetAttribute("controller_capabilities", str);

snprintf(str, sizeof(str), "%d", m_pollInterval);

driverElement->SetAttribute("poll_interval", str);

snprintf(str, sizeof(str), "%s", m_bIntervalBetweenPolls ? "true" : "false");

driverElement->SetAttribute("poll_interval_between", str);

{

Internal::LockGuard LG(m_nodeMutex);

for (int i = 0; i < 256; ++i)

{

if (m_nodes[i])

{

if (m_nodes[i]->GetCurrentQueryStage() >= Node::QueryStage_CacheLoad)

{

m_nodes[i]->WriteXML(driverElement);

Log::Write(LogLevel_Info, i, "Cache Save for Node %d as its QueryStage_CacheLoad", i);

}

else

{

Log::Write(LogLevel_Info, i, "Skipping Cache Save for Node %d as its not past QueryStage_CacheLoad", i);

}

}

}

}

string userPath;

Options::Get()->GetOptionAsString("UserPath", &userPath);

snprintf(str, sizeof(str), "ozwcache_0x%08x.xml", m_homeId);

string filename = userPath + string(str);

doc.SaveFile(filename.c_str());

}

//-----------------------------------------------------------------------------

// Controller

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

// <Driver::GetNodeUnsafe>

// Returns a pointer to the requested node without locking.

// Only to be used by main thread code.

//-----------------------------------------------------------------------------

Node* Driver::GetNodeUnsafe(uint8 _nodeId)

{

if (Node* node = m_nodes[_nodeId])

{

return node;

}

return NULL;

}

//-----------------------------------------------------------------------------

// <Driver::GetNode>

// Locks the nodes and returns a pointer to the requested one

//-----------------------------------------------------------------------------

Node* Driver::GetNode(uint8 _nodeId)

{

if (m_nodeMutex->IsSignalled())

{

Log::Write(LogLevel_Error, _nodeId, "Driver Thread is Not Locked during Call to GetNode");

return NULL;

}

if (Node* node = m_nodes[_nodeId])

{

return node;

}

return NULL;

}

//-----------------------------------------------------------------------------

// Sending Z-Wave messages

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

// <Driver::SendQueryStageComplete>

// Queue an item on the query queue that indicates a stage is complete

//-----------------------------------------------------------------------------

void Driver::SendQueryStageComplete(uint8 const _nodeId, Node::QueryStage const _stage)

{

MsgQueueItem item;

item.m_command = MsgQueueCmd_QueryStageComplete;

item.m_nodeId = _nodeId;

item.m_queryStage = _stage;

item.m_retry = false;

Internal::LockGuard LG(m_nodeMutex);

if (Node* node = GetNode(_nodeId))

{

if (!node->IsListeningDevice())

{

if (Internal::CC::WakeUp* wakeUp = static_cast<Internal::CC::WakeUp*>(node->GetCommandClass(Internal::CC::WakeUp::StaticGetCommandClassId())))

{

if (!wakeUp->IsAwake())

{

// If the message is for a sleeping node, we queue it in the node itself.

Log::Write(LogLevel_Info, "");

Log::Write(LogLevel_Detail, node->GetNodeId(), "Queuing (%s) Query Stage Complete (%s)", c_sendQueueNames[MsgQueue_WakeUp], node->GetQueryStageName(_stage).c_str());

wakeUp->QueueMsg(item);

return;

}

}

}

// Non-sleeping node

Log::Write(LogLevel_Detail, node->GetNodeId(), "Queuing (%s) Query Stage Complete (%s)", c_sendQueueNames[MsgQueue_Query], node->GetQueryStageName(_stage).c_str());

m_sendMutex->Lock();

m_msgQueue[MsgQueue_Query].push_back(item);

m_queueEvent[MsgQueue_Query]->Set();

m_sendMutex->Unlock();

}

}

//-----------------------------------------------------------------------------

// <Driver::RetryQueryStageComplete>

// Request the current stage will be repeated

//-----------------------------------------------------------------------------

void Driver::RetryQueryStageComplete(uint8 const _nodeId, Node::QueryStage const _stage)

{

MsgQueueItem item;

item.m_command = MsgQueueCmd_QueryStageComplete;

item.m_nodeId = _nodeId;

item.m_queryStage = _stage;

m_sendMutex->Lock();

for (list<MsgQueueItem>::iterator it = m_msgQueue[MsgQueue_Query].begin(); it != m_msgQueue[MsgQueue_Query].end(); ++it)

{

if (*it == item)

{

(*it).m_retry = true;

break;

}

}

m_sendMutex->Unlock();

}

//-----------------------------------------------------------------------------

// <Driver::SendMsg>

// Queue a message to be sent to the Z-Wave PC Interface

//-----------------------------------------------------------------------------

void Driver::SendMsg(Internal::Msg* _msg, MsgQueue const _queue)

{

MsgQueueItem item;

item.m_command = MsgQueueCmd_SendMsg;

item.m_msg = _msg;

/* make sure the HomeId is Set on this message */

_msg->SetHomeId(m_homeId);

_msg->Finalize();

{

Internal::LockGuard LG(m_nodeMutex);

if (Node* node = GetNode(_msg->GetTargetNodeId()))

{

/* if the node Supports the Security Class - check if this message is meant to be encapsulated */

if (node->GetCommandClass(Internal::CC::Security::StaticGetCommandClassId()))

{

Internal::CC::CommandClass *cc = node->GetCommandClass(_msg->GetSendingCommandClass());

if ((cc) && (cc->IsSecured()))

{

Log::Write(LogLevel_Detail, GetNodeNumber(_msg), "Setting Encryption Flag on Message For Command Class %s", cc->GetCommandClassName().c_str());

item.m_msg->setEncrypted();

}

}

// If the message is for a sleeping node, we queue it in the node itself.

if (!node->IsListeningDevice())

{

if (Internal::CC::WakeUp* wakeUp = static_cast<Internal::CC::WakeUp*>(node->GetCommandClass(Internal::CC::WakeUp::StaticGetCommandClassId())))

{

if (!wakeUp->IsAwake())

{

Log::Write(LogLevel_Detail, "");

// Handle saving multi-step controller commands

if (m_currentControllerCommand != NULL)

{

Log::Write(LogLevel_Detail, GetNodeNumber(_msg), "Queuing (%s) %s", c_sendQueueNames[MsgQueue_Controller], c_controllerCommandNames[m_currentControllerCommand->m_controllerCommand]);

delete _msg;

item.m_command = MsgQueueCmd_Controller;

item.m_cci = new ControllerCommandItem(*m_currentControllerCommand);

item.m_msg = NULL;

UpdateControllerState(ControllerState_Sleeping);

}

else

{

Log::Write(LogLevel_Detail, GetNodeNumber(_msg), "Queuing (%s) %s", c_sendQueueNames[MsgQueue_WakeUp], _msg->GetAsString().c_str());

}

wakeUp->QueueMsg(item);

return;

}

}

}

}

}

Log::Write(LogLevel_Detail, GetNodeNumber(_msg), "Queuing (%s) %s", c_sendQueueNames[_queue], _msg->GetAsString().c_str());

m_sendMutex->Lock();

m_msgQueue[_queue].push_back(item);

m_queueEvent[_queue]->Set();

m_sendMutex->Unlock();

}

//-----------------------------------------------------------------------------

// <Driver::WriteNextMsg>

// Transmit a queued message to the Z-Wave controller

//-----------------------------------------------------------------------------

bool Driver::WriteNextMsg(MsgQueue const _queue)

{

// There are messages to send, so get the one at the front of the queue

m_sendMutex->Lock();

MsgQueueItem item = m_msgQueue[_queue].front();

if (MsgQueueCmd_SendMsg == item.m_command)

{

// Send a message

m_currentMsg = item.m_msg;

m_currentMsgQueueSource = _queue;

m_msgQueue[_queue].pop_front();