void PropertyWriter::WriteVariableEnd(IWriter& aWriter, const Brx& aName)
{ // static
static const Brn kPropertyEnd("></e:property>");
aWriter.Write(Brn("</"));
aWriter.Write(aName);
aWriter.Write(kPropertyEnd);
}
void ShellCommandHelp::DisplayHelp(IWriter& aResponse)
{
aResponse.Write(Brn("Usage for command \'help\':\n"));
aResponse.Write(Brn(" available shell commands if called with no args\n"));
aResponse.Write(Brn(" help for given command if called with one arg\n"));
aResponse.Write(Brn(" ...ignores any args 1..n\n"));
}
void PropertyWriter::WriteVariableStart(IWriter& aWriter, const Brx& aName)
{ // static
static const Brn kPropertyStart("<e:property><");
aWriter.Write(kPropertyStart);
aWriter.Write(aName);
aWriter.Write('>');
}
void WriterRingBuffer::Read(IWriter& aWriter) const
{
if (iWrapped)
{
aWriter.Write(Brn(&(iData[iCursor]), iBytes - iCursor));
}
aWriter.Write(Brn(&(iData[0]), iCursor));
}
void PropertyUpdatesFlattened::WriteUpdates(IWriter& aWriter)
{
aWriter.Write(Brn("<root>"));
UpdatesMap::iterator it = iUpdatesMap.begin();
while (it != iUpdatesMap.end()) {
it->second->Write(aWriter);
delete it->second;
it++;
}
iUpdatesMap.clear();
aWriter.Write(Brn("</root>"));
}
void ShellCommandRun::DisplayHelp(IWriter& aResponse)
{
aResponse.Write(Brn("Run a unit test. Options are:\n"));
TestMap::iterator it = iTests.begin();
while (it != iTests.end()) {
Test* test = it->second;
aResponse.Write(Brn(" "));
aResponse.Write(Brn(test->Name()));
if (test->HelpAvailable()) {
aResponse.Write(Brn(" (--help for arguments)"));
}
aResponse.Write(Brn("\n"));
it++;
}
}
void PropertyWriter::WriteVariable(IWriter& aWriter, const Brx& aName, const Brx& aValue)
{ // static
aWriter.Write(Brn("<e:property>"));
aWriter.Write('<');
aWriter.Write(aName);
aWriter.Write('>');
aWriter.Write(aValue);
aWriter.Write(Brn("</"));
aWriter.Write(aName);
aWriter.Write('>');
aWriter.Write(Brn("</e:property>"));
}
void Shell::HandleShellCommand(Brn aCommand, const std::vector<Brn>& aArgs, IWriter& aResponse)
{
AutoMutex a(iLock);
CommandMap::iterator it = iCommands.find(aCommand);
if (it == iCommands.end()) {
aResponse.Write(Brn("Unrecognised command: "));
aResponse.Write(Brn(aCommand));
aResponse.Write(Brn("\n"));
}
else {
// Holding iLock for the duration of the following call is poor practice
// We get away with it here by assuming that command handlers are registered on
// startup, before commands are likely to run.
it->second->HandleShellCommand(aCommand, aArgs, aResponse);
aResponse.Write(Brn("\n")); // add blank line after test output for the sake of readability
}
}
void ShellCommandQuit::HandleShellCommand(Brn aCommand, const std::vector<Brn>& aArgs, IWriter& aResponse)
{
if (aArgs.size() > 0 ) {
aResponse.Write(Brn("Quit command does not take any arguments!\n"));
return;
}
iBlocker.Signal();
}
void ShellCommandRun::HandleShellCommand(Brn aCommand, const std::vector<Brn>& aArgs, IWriter& aResponse)
{
iResponseWriter = &aResponse;
FunctorMsg logger = MakeFunctorMsg(*this, &OpenHome::Net::ShellCommandRun::Log);
OpenHome::TestFramework::SetPrinter(logger);
if (aArgs.size() == 0) {
aResponse.Write(Brn("No program specified for command \'run\'\n"));
return;
}
Brn program = aArgs[0];
TestMap::iterator it = iTests.find(program);
if (it != iTests.end()) {
it->second->Run(aArgs);
}
else {
aResponse.Write(Brn("Unexpected test name for command \'run\': "));
aResponse.Write(program);
aResponse.Write(Brn("\n"));
}
iResponseWriter = NULL;
}
void Package::Write(IWriter & writer) const
{
//write package id
writer.Write((const lemon::byte_t*)&_uuid,sizeof(_uuid));
lemon::uint16_t major = htons(_version.Major);
lemon::uint16_t minor = htons(_version.Minor);
lemon::uint16_t build = htons(_version.Build);
lemon::uint16_t reversion = htons(_version.Reversion);
writer.Write((const lemon::byte_t*)&major,sizeof(major));
writer.Write((const lemon::byte_t*)&minor,sizeof(minor));
writer.Write((const lemon::byte_t*)&build,sizeof(build));
writer.Write((const lemon::byte_t*)&reversion,sizeof(reversion));
lemon::uint8_t tables = (lemon::uint8_t)_resourceTables.size();
writer.Write((const lemon::byte_t*)&tables,sizeof(tables));
LocaleResourceTables::const_iterator iter ,end = _resourceTables.end();
for(iter = _resourceTables.begin(); iter != end; ++ iter)
{
iter->second.Write(iter->first,writer);
}
}
static void WriteTag(IWriter& aWriter, const Brx& aTag, const Brx& aValue)
{
aWriter.Write('<');
aWriter.Write(aTag);
aWriter.Write('>');
aWriter.Write(aValue);
aWriter.Write('<');
aWriter.Write('/');
aWriter.Write(aTag);
aWriter.Write('>');
}
void PropertyUpdate::Write(IWriter& aWriter)
{
aWriter.Write('<');
aWriter.Write(WebSocket::kTagSubscription);
aWriter.Write('>');
WriteTag(aWriter, WebSocket::kTagMethod, WebSocket::kMethodPropertyUpdate);
WriteTag(aWriter, WebSocket::kTagSid, iSid);
Bws<Ascii::kMaxUintStringBytes> seq;
(void)Ascii::AppendDec(seq, iSeqNum);
WriteTag(aWriter, WebSocket::kTagSeq, seq);
aWriter.Write(Brn("<e:propertyset xmlns:e=\"urn:schemas-upnp-org:event-1-0\">"));
for (TUint i=0; i<(TUint)iProperties.size(); i++) {
PropertyWriter::WriteVariable(aWriter, iProperties[i]->Name(), iProperties[i]->Value());
}
aWriter.Write(Brn("</e:propertyset>"));
aWriter.Write('<');
aWriter.Write('/');
aWriter.Write(WebSocket::kTagSubscription);
aWriter.Write('>');
}
void Ssdp::WriteServiceType(IWriter& aWriter, const Brx& aDomain, const Brx& aType, TUint aVersion)
{
aWriter.Write(kUrn);
Bws<kMaxDomainBytes> domain;
Ssdp::CanonicalDomainToUpnp(aDomain, domain);
aWriter.Write(domain);
aWriter.Write(kServiceSeparator);
aWriter.Write(aType);
aWriter.Write(kVersionSeparator);
Bws<Ascii::kMaxUintStringBytes> version;
(void)Ascii::AppendDec(version, aVersion);
aWriter.Write(version);
}
void ShellCommandWatchDog::HandleShellCommand(Brn aCommand, const std::vector<Brn>& aArgs, IWriter& aResponse)
{
if ( aArgs.size() < 1 ) {
DisplayHelp(aResponse);
return;
}
if ( aArgs[0] == Brn("feed") )
{
if ( aArgs.size() != 1 )
{
DisplayHelp(aResponse);
return;
}
iWatchDog->Feed();
}
else if ( aArgs[0] == Brn("status") )
{
if ( aArgs.size() != 1 )
{
DisplayHelp(aResponse);
return;
}
Bws<16> buffer;
Ascii::AppendDec(buffer, iWatchDog->RemainingSeconds());
aResponse.Write(buffer);
}
else if ( aArgs[0] == Brn("update") )
{
if ( aArgs.size() != 2 )
{
DisplayHelp(aResponse);
return;
}
// read integer, update watchdog.
iWatchDog->Update(Ascii::Uint(aArgs[1]));
}
}
void ShellCommandHelp::HandleShellCommand(Brn aCommand, const std::vector<Brn>& aArgs, IWriter& aResponse)
{
if (aArgs.size() == 0) {
aResponse.Write(Brn("Available shell commands are:\n"));
Shell::CommandMap::iterator it = iShell.iCommands.begin();
while (it != iShell.iCommands.end()) {
aResponse.Write(Brn(" "));
aResponse.Write(it->first);
aResponse.Write(Brn("\n"));
it++;
}
}
else {
Shell::CommandMap::iterator it = iShell.iCommands.find(aArgs[0]);
if (it != iShell.iCommands.end()) {
it->second->DisplayHelp(aResponse);
}
else {
aResponse.Write(Brn("Error: unrecognised command - "));
aResponse.Write(aArgs[0]);
aResponse.Write(Brn(" - so no help available\n"));
}
}
}
void PropertyWriter::WriteVariable(IWriter& aWriter, const Brx& aName, const Brx& aValue)
{ // static
WriteVariableStart(aWriter, aName);
aWriter.Write(aValue);
WriteVariableEnd(aWriter, aName);
}
void DviProtocolUpnpServiceXmlWriter::WriteStateVariable(IWriter& aWriter, const OpenHome::Net::Parameter& aParam, TBool aEvented, const Action* aAction)
{
aWriter.Write(Brn("<stateVariable sendEvents="));
if (aEvented) {
aWriter.Write(Brn("\"yes\">"));
}
else {
aWriter.Write(Brn("\"no\">"));
}
aWriter.Write(Brn("<name>"));
if (aEvented) {
aWriter.Write(aParam.Name());
}
else {
Bwh name;
GetRelatedVariableName(name, aAction->Name(), aParam.Name());
aWriter.Write(name);
}
aWriter.Write(Brn("</name>"));
aWriter.Write(Brn("<dataType>"));
switch (aParam.Type())
{
case OpenHome::Net::Parameter::eTypeBool:
aWriter.Write(Brn("boolean"));
break;
case OpenHome::Net::Parameter::eTypeInt:
aWriter.Write(Brn("i4"));
break;
case OpenHome::Net::Parameter::eTypeUint:
aWriter.Write(Brn("ui4"));
break;
case OpenHome::Net::Parameter::eTypeString:
aWriter.Write(Brn("string"));
break;
case OpenHome::Net::Parameter::eTypeBinary:
aWriter.Write(Brn("bin.base64"));
break;
case OpenHome::Net::Parameter::eTypeRelated:
ASSERTS();
break;
}
aWriter.Write(Brn("</dataType>"));
switch (aParam.Type())
{
case OpenHome::Net::Parameter::eTypeBool:
case OpenHome::Net::Parameter::eTypeBinary:
break;
case OpenHome::Net::Parameter::eTypeInt:
{
const OpenHome::Net::ParameterInt& paramInt = static_cast<const OpenHome::Net::ParameterInt&>(aParam);
if (paramInt.MinValue() != ParameterInt::kValueMin ||
paramInt.MaxValue() != ParameterInt::kValueMax ||
paramInt.Step() != ParameterInt::kStep) {
aWriter.Write(Brn("<allowedValueRange>"));
aWriter.Write(Brn("<minimum>"));
WriterAscii writerAscii(aWriter);
writerAscii.WriteInt(paramInt.MinValue());
aWriter.Write(Brn("</minimum>"));
aWriter.Write(Brn("<maximum>"));
writerAscii.WriteInt(paramInt.MaxValue());
aWriter.Write(Brn("</maximum>"));
aWriter.Write(Brn("<step>"));
writerAscii.WriteInt(paramInt.Step());
aWriter.Write(Brn("</step>"));
aWriter.Write(Brn("</allowedValueRange>"));
}
}
break;
case OpenHome::Net::Parameter::eTypeUint:
{
const OpenHome::Net::ParameterUint& paramUint = static_cast<const OpenHome::Net::ParameterUint&>(aParam);
if (paramUint.MinValue() != ParameterUint::kValueMin ||
paramUint.MaxValue() != ParameterUint::kValueMax ||
paramUint.Step() != ParameterUint::kStep) {
aWriter.Write(Brn("<allowedValueRange>"));
aWriter.Write(Brn("<minimum>"));
WriterAscii writerAscii(aWriter);
writerAscii.WriteUint(paramUint.MinValue());
aWriter.Write(Brn("</minimum>"));
aWriter.Write(Brn("<maximum>"));
writerAscii.WriteUint(paramUint.MaxValue());
aWriter.Write(Brn("</maximum>"));
aWriter.Write(Brn("<step>"));
writerAscii.WriteUint(paramUint.Step());
aWriter.Write(Brn("</step>"));
aWriter.Write(Brn("</allowedValueRange>"));
}
}
break;
case OpenHome::Net::Parameter::eTypeString:
{
const OpenHome::Net::ParameterString& paramStr = static_cast<const OpenHome::Net::ParameterString&>(aParam);
const ParameterString::Map& allowedVals = paramStr.AllowedValues();
if (allowedVals.size() > 0) {
aWriter.Write(Brn("<allowedValueList>"));
ParameterString::Map::const_iterator it = allowedVals.begin();
while (it != allowedVals.end()) {
aWriter.Write(Brn("<allowedValue>"));
aWriter.Write(*(it->second));
aWriter.Write(Brn("</allowedValue>"));
it++;
}
aWriter.Write(Brn("</allowedValueList>"));
}
}
break;
case OpenHome::Net::Parameter::eTypeRelated:
ASSERTS();
break;
}
aWriter.Write(Brn("</stateVariable>"));
}
void Ssdp::WriteRoot(IWriter& aWriter)
{
aWriter.Write(kUpnpRoot);
}
void Ssdp::WriteUuid(IWriter& aWriter, const Brx& aUuid)
{
aWriter.Write(kUuid);
aWriter.Write(kUuidSeparator);
aWriter.Write(aUuid);
}
void ResourceTable::Write(const lemon::String & locale,IWriter & writer) const
{
std::string utf8 = lemon::to_utf8(locale);
char localeString[5] = {0};
memset(localeString,0,5);
size_t localeStringLength = utf8.size();
if(utf8.size() > 5) localeStringLength = 5;
memcpy(localeString,utf8.c_str(),localeStringLength);
writer.Write((const lemon::byte_t*)&localeString,5);
//i18n -> l10n text table size
lemon::uint16_t i18nTextTableSize = htons((lemon::uint16_t)_textTable.size());
writer.Write((const lemon::byte_t*)&i18nTextTableSize,sizeof(i18nTextTableSize));
//trace message table size
lemon::uint16_t traceMessageTableSize = htons((lemon::uint16_t)_traceMessageTable.size());
writer.Write((const lemon::byte_t*)&traceMessageTableSize,sizeof(traceMessageTableSize));
//trace catalog table size
lemon::uint16_t traceCatalogTableSize = htons((lemon::uint16_t)_traceCatalogTable.size());
writer.Write((const lemon::byte_t*)&traceCatalogTableSize,sizeof(traceCatalogTableSize));
//trace catalog table size
lemon::uint16_t errorMessageTableSize = htons((lemon::uint16_t)_errorMessageTable.size());
writer.Write((const lemon::byte_t*)&errorMessageTableSize,sizeof(errorMessageTableSize));
// string table size
lemon::uint16_t stringTableSize = htons((lemon::uint16_t)_stringTable.Items());
writer.Write((const lemon::byte_t*)&stringTableSize,sizeof(stringTableSize));
//i18n -> l10n text table
{
TextTable::const_iterator iter,end = _textTable.end();
for(iter = _textTable.begin() ; iter != end; ++ iter)
{
const I18nText & text = iter->second;
lemon::uint32_t index = htonl(text.key);
writer.Write((const lemon::byte_t*)&index,sizeof(index));
index = htonl(text.Message);
writer.Write((const lemon::byte_t*)&index,sizeof(index));
}
}
//trace message table size
{
TraceMessageTable::const_iterator iter,end = _traceMessageTable.end();
for(iter = _traceMessageTable.begin() ; iter != end; ++ iter)
{
const TraceMessage & text = iter->second;
lemon::uint32_t index = htonl(text.Id);
writer.Write((const lemon::byte_t*)&index,sizeof(index));
index = htonl(text.Message);
writer.Write((const lemon::byte_t*)&index,sizeof(index));
}
}
//trace catalog table size
{
TraceCatalogTable::const_iterator iter,end = _traceCatalogTable.end();
for(iter = _traceCatalogTable.begin() ; iter != end; ++ iter)
{
const TraceCatalog & text = iter->second;
lemon::uint32_t index = htonl(text.Value);
writer.Write((const lemon::byte_t*)&index,sizeof(index));
index = htonl(text.Name);
writer.Write((const lemon::byte_t*)&index,sizeof(index));
index = htonl(text.Description);
writer.Write((const lemon::byte_t*)&index,sizeof(index));
}
}
// error message
{
ErrorMessageTable::const_iterator iter,end = _errorMessageTable.end();
for(iter = _errorMessageTable.begin() ; iter != end; ++ iter)
{
const ErrorMessage & text = iter->second;
lemon::uint32_t index = htonl(text.Code);
writer.Write((const lemon::byte_t*)&index,sizeof(index));
index = htonl(text.Name);
writer.Write((const lemon::byte_t*)&index,sizeof(index));
index = htonl(text.Description);
writer.Write((const lemon::byte_t*)&index,sizeof(index));
}
}
// string table
StringTable table;
for(size_t i = 0 ; i < _stringTable.Items(); ++ i)
{
tuple<const lemon::byte_t*,size_t> result = _stringTable.Get((lemon::uint32_t)i);
std::string utf8 = lemon::to_utf8((const char_t*)get<0>(result));
table.Push(__cbuf(utf8.c_str()));
}
table.Write(writer);
}
void ShellCommandQuit::DisplayHelp(IWriter& aResponse)
{
aResponse.Write(Brn("Terminate shell.\n"));
}
void ShellCommandWatchDog::DisplayHelp(IWriter& aResponse)
{
aResponse.Write(Brn("feed - reset the watchdog\nstatus - show time remaining\nupdate SECONDS - set the watchdog counter\n"));
}
