blob: 6a815f98e896ece4b0a7edd907b1bcfbbf592a36 [file] [log] [blame]
/*
* Copyright (c) 2020 Project CHIP Authors
* All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
#include "Commands.h"
#include "Command.h"
#include <algorithm>
#include <iomanip>
#include <sstream>
#include <string>
#include <lib/support/Base64.h>
#include <lib/support/CHIPMem.h>
#include <lib/support/CodeUtils.h>
#include <platform/CHIPDeviceConfig.h>
#include <platform/KeyValueStoreManager.h>
#include "../clusters/JsonParser.h"
namespace {
char kInteractiveModeName[] = "";
constexpr size_t kInteractiveModeArgumentsMaxLength = 32;
constexpr char kOptionalArgumentPrefix[] = "--";
constexpr char kJsonClusterKey[] = "cluster";
constexpr char kJsonCommandKey[] = "command";
constexpr char kJsonCommandSpecifierKey[] = "command_specifier";
constexpr char kJsonArgumentsKey[] = "arguments";
#if !CHIP_DISABLE_PLATFORM_KVS
template <typename T>
struct HasInitWithString
{
template <typename U>
static constexpr auto check(U *) -> typename std::is_same<decltype(std::declval<U>().Init("")), CHIP_ERROR>::type;
template <typename>
static constexpr std::false_type check(...);
typedef decltype(check<std::remove_reference_t<T>>(nullptr)) type;
public:
static constexpr bool value = type::value;
};
// Template so we can do conditional enabling
template <typename T, std::enable_if_t<HasInitWithString<T>::value, int> = 0>
static void UseStorageDirectory(T & storageManagerImpl, const char * storageDirectory)
{
std::string platformKVS = std::string(storageDirectory) + "/chip_tool_kvs";
storageManagerImpl.Init(platformKVS.c_str());
}
template <typename T, std::enable_if_t<!HasInitWithString<T>::value, int> = 0>
static void UseStorageDirectory(T & storageManagerImpl, const char * storageDirectory)
{}
#endif // !CHIP_DISABLE_PLATFORM_KVS
bool GetArgumentsFromJson(Command * command, Json::Value & value, bool optional, std::vector<std::string> & outArgs)
{
auto memberNames = value.getMemberNames();
std::vector<std::string> args;
for (size_t i = 0; i < command->GetArgumentsCount(); i++)
{
auto argName = command->GetArgumentName(i);
auto memberNamesIterator = memberNames.begin();
while (memberNamesIterator != memberNames.end())
{
auto memberName = *memberNamesIterator;
if (strcasecmp(argName, memberName.c_str()) != 0)
{
memberNamesIterator++;
continue;
}
if (command->GetArgumentIsOptional(i) != optional)
{
memberNamesIterator = memberNames.erase(memberNamesIterator);
continue;
}
if (optional)
{
args.push_back(std::string(kOptionalArgumentPrefix) + argName);
}
auto argValue = value[memberName].asString();
args.push_back(std::move(argValue));
memberNamesIterator = memberNames.erase(memberNamesIterator);
break;
}
}
if (memberNames.size())
{
auto memberName = memberNames.front();
ChipLogError(chipTool, "The argument \"\%s\" is not supported.", memberName.c_str());
return false;
}
outArgs = args;
return true;
};
// Check for arguments with a starting '"' but no ending '"': those
// would indicate that people are using double-quoting, not single
// quoting, on arguments with spaces.
static void DetectAndLogMismatchedDoubleQuotes(int argc, char ** argv)
{
for (int curArg = 0; curArg < argc; ++curArg)
{
char * arg = argv[curArg];
if (!arg)
{
continue;
}
auto len = strlen(arg);
if (len == 0)
{
continue;
}
if (arg[0] == '"' && arg[len - 1] != '"')
{
ChipLogError(chipTool,
"Mismatched '\"' detected in argument: '%s'. Use single quotes to delimit arguments with spaces "
"in them: 'x y', not \"x y\".",
arg);
}
}
}
} // namespace
void Commands::Register(const char * commandSetName, commands_list commandsList, const char * helpText, bool isCluster)
{
VerifyOrDieWithMsg(isCluster || helpText != nullptr, chipTool, "Non-cluster command sets must have help text");
mCommandSets[commandSetName].isCluster = isCluster;
mCommandSets[commandSetName].helpText = helpText;
for (auto & command : commandsList)
{
mCommandSets[commandSetName].commands.push_back(std::move(command));
}
}
int Commands::Run(int argc, char ** argv)
{
CHIP_ERROR err = CHIP_NO_ERROR;
err = chip::Platform::MemoryInit();
VerifyOrExit(err == CHIP_NO_ERROR, ChipLogError(Controller, "Init Memory failure: %s", chip::ErrorStr(err)));
#ifdef CONFIG_USE_LOCAL_STORAGE
err = mStorage.Init();
VerifyOrExit(err == CHIP_NO_ERROR, ChipLogError(Controller, "Init Storage failure: %s", chip::ErrorStr(err)));
chip::Logging::SetLogFilter(mStorage.GetLoggingLevel());
#endif // CONFIG_USE_LOCAL_STORAGE
err = RunCommand(argc, argv);
VerifyOrExit(err == CHIP_NO_ERROR, ChipLogError(chipTool, "Run command failure: %s", chip::ErrorStr(err)));
exit:
return (err == CHIP_NO_ERROR) ? EXIT_SUCCESS : EXIT_FAILURE;
}
int Commands::RunInteractive(const char * command, const chip::Optional<char *> & storageDirectory, bool advertiseOperational)
{
std::vector<std::string> arguments;
VerifyOrReturnValue(DecodeArgumentsFromInteractiveMode(command, arguments), EXIT_FAILURE);
if (arguments.size() > (kInteractiveModeArgumentsMaxLength - 1 /* for interactive mode name */))
{
ChipLogError(chipTool, "Too many arguments. Ignoring.");
arguments.resize(kInteractiveModeArgumentsMaxLength - 1);
}
int argc = 0;
char * argv[kInteractiveModeArgumentsMaxLength] = {};
argv[argc++] = kInteractiveModeName;
std::string commandStr;
for (auto & arg : arguments)
{
argv[argc] = new char[arg.size() + 1];
strcpy(argv[argc++], arg.c_str());
commandStr += arg;
commandStr += " ";
}
ChipLogProgress(chipTool, "Command: %s", commandStr.c_str());
auto err = RunCommand(argc, argv, true, storageDirectory, advertiseOperational);
// Do not delete arg[0]
for (auto i = 1; i < argc; i++)
{
delete[] argv[i];
}
return (err == CHIP_NO_ERROR) ? EXIT_SUCCESS : EXIT_FAILURE;
}
CHIP_ERROR Commands::RunCommand(int argc, char ** argv, bool interactive,
const chip::Optional<char *> & interactiveStorageDirectory, bool interactiveAdvertiseOperational)
{
Command * command = nullptr;
if (argc <= 1)
{
ChipLogError(chipTool, "Missing cluster or command set name");
ShowCommandSets(argv[0]);
return CHIP_ERROR_INVALID_ARGUMENT;
}
auto commandSetIter = GetCommandSet(argv[1]);
if (commandSetIter == mCommandSets.end())
{
ChipLogError(chipTool, "Unknown cluster or command set: %s", argv[1]);
ShowCommandSets(argv[0]);
return CHIP_ERROR_INVALID_ARGUMENT;
}
auto & commandList = commandSetIter->second.commands;
auto * helpText = commandSetIter->second.helpText;
if (argc <= 2)
{
ChipLogError(chipTool, "Missing command name");
ShowCommandSet(argv[0], argv[1], commandList, helpText);
return CHIP_ERROR_INVALID_ARGUMENT;
}
bool isGlobalCommand = IsGlobalCommand(argv[2]);
if (!isGlobalCommand)
{
command = GetCommand(commandList, argv[2]);
if (command == nullptr)
{
ChipLogError(chipTool, "Unknown command: %s", argv[2]);
ShowCommandSet(argv[0], argv[1], commandList, helpText);
return CHIP_ERROR_INVALID_ARGUMENT;
}
}
else if (IsEventCommand(argv[2]))
{
if (argc <= 3)
{
ChipLogError(chipTool, "Missing event name");
ShowClusterEvents(argv[0], argv[1], argv[2], commandList);
return CHIP_ERROR_INVALID_ARGUMENT;
}
command = GetGlobalCommand(commandList, argv[2], argv[3]);
if (command == nullptr)
{
ChipLogError(chipTool, "Unknown event: %s", argv[3]);
ShowClusterEvents(argv[0], argv[1], argv[2], commandList);
return CHIP_ERROR_INVALID_ARGUMENT;
}
}
else
{
if (argc <= 3)
{
ChipLogError(chipTool, "Missing attribute name");
ShowClusterAttributes(argv[0], argv[1], argv[2], commandList);
return CHIP_ERROR_INVALID_ARGUMENT;
}
command = GetGlobalCommand(commandList, argv[2], argv[3]);
if (command == nullptr)
{
ChipLogError(chipTool, "Unknown attribute: %s", argv[3]);
ShowClusterAttributes(argv[0], argv[1], argv[2], commandList);
return CHIP_ERROR_INVALID_ARGUMENT;
}
}
int argumentsPosition = isGlobalCommand ? 4 : 3;
if (!command->InitArguments(argc - argumentsPosition, &argv[argumentsPosition]))
{
if (interactive)
{
DetectAndLogMismatchedDoubleQuotes(argc - argumentsPosition, &argv[argumentsPosition]);
}
ShowCommand(argv[0], argv[1], command);
return CHIP_ERROR_INVALID_ARGUMENT;
}
if (interactive)
{
return command->RunAsInteractive(interactiveStorageDirectory, interactiveAdvertiseOperational);
}
// Now that the command is initialized, get our storage from it as needed
// and set up our loging level.
#ifdef CONFIG_USE_LOCAL_STORAGE
CHIP_ERROR err = mStorage.Init(nullptr, command->GetStorageDirectory().ValueOr(nullptr));
if (err != CHIP_NO_ERROR)
{
ChipLogError(Controller, "Init Storage failure: %s", chip::ErrorStr(err));
return err;
}
chip::Logging::SetLogFilter(mStorage.GetLoggingLevel());
#if !CHIP_DISABLE_PLATFORM_KVS
UseStorageDirectory(chip::DeviceLayer::PersistedStorage::KeyValueStoreMgrImpl(), mStorage.GetDirectory());
#endif // !CHIP_DISABLE_PLATFORM_KVS
#endif // CONFIG_USE_LOCAL_STORAGE
return command->Run();
}
Commands::CommandSetMap::iterator Commands::GetCommandSet(std::string commandSetName)
{
for (auto & commandSet : mCommandSets)
{
std::string key(commandSet.first);
std::transform(key.begin(), key.end(), key.begin(), ::tolower);
if (key.compare(commandSetName) == 0)
{
return mCommandSets.find(commandSet.first);
}
}
return mCommandSets.end();
}
Command * Commands::GetCommand(CommandsVector & commands, std::string commandName)
{
for (auto & command : commands)
{
if (commandName.compare(command->GetName()) == 0)
{
return command.get();
}
}
return nullptr;
}
Command * Commands::GetGlobalCommand(CommandsVector & commands, std::string commandName, std::string attributeName)
{
for (auto & command : commands)
{
if (commandName.compare(command->GetName()) == 0 && attributeName.compare(command->GetAttribute()) == 0)
{
return command.get();
}
}
return nullptr;
}
bool Commands::IsAttributeCommand(std::string commandName) const
{
return commandName.compare("read") == 0 || commandName.compare("write") == 0 || commandName.compare("force-write") == 0 ||
commandName.compare("subscribe") == 0;
}
bool Commands::IsEventCommand(std::string commandName) const
{
return commandName.compare("read-event") == 0 || commandName.compare("subscribe-event") == 0;
}
bool Commands::IsGlobalCommand(std::string commandName) const
{
return IsAttributeCommand(commandName) || IsEventCommand(commandName);
}
void Commands::ShowCommandSetOverview(std::string commandSetName, const CommandSet & commandSet)
{
std::transform(commandSetName.begin(), commandSetName.end(), commandSetName.begin(),
[](unsigned char c) { return std::tolower(c); });
fprintf(stderr, " | * %-82s|\n", commandSetName.c_str());
ShowHelpText(commandSet.helpText);
}
void Commands::ShowCommandSets(std::string executable)
{
fprintf(stderr, "Usage:\n");
fprintf(stderr, " %s cluster_name command_name [param1 param2 ...]\n", executable.c_str());
fprintf(stderr, "or:\n");
fprintf(stderr, " %s command_set_name command_name [param1 param2 ...]\n", executable.c_str());
fprintf(stderr, "\n");
// Table of clusters
fprintf(stderr, " +-------------------------------------------------------------------------------------+\n");
fprintf(stderr, " | Clusters: |\n");
fprintf(stderr, " +-------------------------------------------------------------------------------------+\n");
for (auto & commandSet : mCommandSets)
{
if (commandSet.second.isCluster)
{
ShowCommandSetOverview(commandSet.first, commandSet.second);
}
}
fprintf(stderr, " +-------------------------------------------------------------------------------------+\n");
fprintf(stderr, "\n");
// Table of command sets
fprintf(stderr, " +-------------------------------------------------------------------------------------+\n");
fprintf(stderr, " | Command sets: |\n");
fprintf(stderr, " +-------------------------------------------------------------------------------------+\n");
for (auto & commandSet : mCommandSets)
{
if (!commandSet.second.isCluster)
{
ShowCommandSetOverview(commandSet.first, commandSet.second);
}
}
fprintf(stderr, " +-------------------------------------------------------------------------------------+\n");
}
void Commands::ShowCommandSet(std::string executable, std::string commandSetName, CommandsVector & commands, const char * helpText)
{
fprintf(stderr, "Usage:\n");
fprintf(stderr, " %s %s command_name [param1 param2 ...]\n", executable.c_str(), commandSetName.c_str());
if (helpText)
{
fprintf(stderr, "\n%s\n", helpText);
}
fprintf(stderr, "\n");
fprintf(stderr, " +-------------------------------------------------------------------------------------+\n");
fprintf(stderr, " | Commands: |\n");
fprintf(stderr, " +-------------------------------------------------------------------------------------+\n");
bool readCommand = false;
bool writeCommand = false;
bool writeOverrideCommand = false;
bool subscribeCommand = false;
bool readEventCommand = false;
bool subscribeEventCommand = false;
for (auto & command : commands)
{
bool shouldPrint = true;
if (IsGlobalCommand(command->GetName()))
{
if (strcmp(command->GetName(), "read") == 0 && !readCommand)
{
readCommand = true;
}
else if (strcmp(command->GetName(), "write") == 0 && !writeCommand)
{
writeCommand = true;
}
else if (strcmp(command->GetName(), "force-write") == 0 && !writeOverrideCommand)
{
writeOverrideCommand = true;
}
else if (strcmp(command->GetName(), "subscribe") == 0 && !subscribeCommand)
{
subscribeCommand = true;
}
else if (strcmp(command->GetName(), "read-event") == 0 && !readEventCommand)
{
readEventCommand = true;
}
else if (strcmp(command->GetName(), "subscribe-event") == 0 && !subscribeEventCommand)
{
subscribeEventCommand = true;
}
else
{
shouldPrint = false;
}
}
if (shouldPrint)
{
fprintf(stderr, " | * %-82s|\n", command->GetName());
ShowHelpText(command->GetHelpText());
}
}
fprintf(stderr, " +-------------------------------------------------------------------------------------+\n");
}
void Commands::ShowClusterAttributes(std::string executable, std::string clusterName, std::string commandName,
CommandsVector & commands)
{
fprintf(stderr, "Usage:\n");
fprintf(stderr, " %s %s %s attribute-name [param1 param2 ...]\n", executable.c_str(), clusterName.c_str(),
commandName.c_str());
fprintf(stderr, "\n");
fprintf(stderr, " +-------------------------------------------------------------------------------------+\n");
fprintf(stderr, " | Attributes: |\n");
fprintf(stderr, " +-------------------------------------------------------------------------------------+\n");
for (auto & command : commands)
{
if (commandName.compare(command->GetName()) == 0)
{
fprintf(stderr, " | * %-82s|\n", command->GetAttribute());
}
}
fprintf(stderr, " +-------------------------------------------------------------------------------------+\n");
}
void Commands::ShowClusterEvents(std::string executable, std::string clusterName, std::string commandName,
CommandsVector & commands)
{
fprintf(stderr, "Usage:\n");
fprintf(stderr, " %s %s %s event-name [param1 param2 ...]\n", executable.c_str(), clusterName.c_str(), commandName.c_str());
fprintf(stderr, "\n");
fprintf(stderr, " +-------------------------------------------------------------------------------------+\n");
fprintf(stderr, " | Events: |\n");
fprintf(stderr, " +-------------------------------------------------------------------------------------+\n");
for (auto & command : commands)
{
if (commandName.compare(command->GetName()) == 0)
{
fprintf(stderr, " | * %-82s|\n", command->GetEvent());
}
}
fprintf(stderr, " +-------------------------------------------------------------------------------------+\n");
}
void Commands::ShowCommand(std::string executable, std::string clusterName, Command * command)
{
fprintf(stderr, "Usage:\n");
std::string arguments;
std::string description;
arguments += command->GetName();
if (command->GetReadOnlyGlobalCommandArgument())
{
arguments += ' ';
arguments += command->GetReadOnlyGlobalCommandArgument();
}
size_t argumentsCount = command->GetArgumentsCount();
for (size_t i = 0; i < argumentsCount; i++)
{
std::string arg;
bool isOptional = command->GetArgumentIsOptional(i);
if (isOptional)
{
arg += "[--";
}
arg += command->GetArgumentName(i);
if (isOptional)
{
arg += "]";
}
arguments += " ";
arguments += arg;
const char * argDescription = command->GetArgumentDescription(i);
if ((argDescription != nullptr) && (strlen(argDescription) > 0))
{
description += "\n";
description += arg;
description += ":\n ";
description += argDescription;
description += "\n";
}
}
fprintf(stderr, " %s %s %s\n", executable.c_str(), clusterName.c_str(), arguments.c_str());
if (command->GetHelpText())
{
fprintf(stderr, "\n%s\n", command->GetHelpText());
}
if (description.size() > 0)
{
fprintf(stderr, "%s\n", description.c_str());
}
}
bool Commands::DecodeArgumentsFromInteractiveMode(const char * command, std::vector<std::string> & args)
{
// Remote clients may not know the ordering of arguments, so instead of a strict ordering arguments can
// be passed in as a json payload encoded in base64 and are reordered on the fly.
return IsJsonString(command) ? DecodeArgumentsFromBase64EncodedJson(command, args)
: DecodeArgumentsFromStringStream(command, args);
}
bool Commands::DecodeArgumentsFromBase64EncodedJson(const char * json, std::vector<std::string> & args)
{
Json::Value jsonValue;
bool parsed = JsonParser::ParseCustomArgument(json, json + kJsonStringPrefixLen, jsonValue);
VerifyOrReturnValue(parsed, false, ChipLogError(chipTool, "Error while parsing json."));
VerifyOrReturnValue(jsonValue.isObject(), false, ChipLogError(chipTool, "Unexpected json type."));
VerifyOrReturnValue(jsonValue.isMember(kJsonClusterKey), false,
ChipLogError(chipTool, "'%s' key not found in json.", kJsonClusterKey));
VerifyOrReturnValue(jsonValue.isMember(kJsonCommandKey), false,
ChipLogError(chipTool, "'%s' key not found in json.", kJsonCommandKey));
VerifyOrReturnValue(jsonValue.isMember(kJsonArgumentsKey), false,
ChipLogError(chipTool, "'%s' key not found in json.", kJsonArgumentsKey));
VerifyOrReturnValue(IsBase64String(jsonValue[kJsonArgumentsKey].asString().c_str()), false,
ChipLogError(chipTool, "'arguments' is not a base64 string."));
auto clusterName = jsonValue[kJsonClusterKey].asString();
auto commandName = jsonValue[kJsonCommandKey].asString();
auto arguments = jsonValue[kJsonArgumentsKey].asString();
auto clusterIter = GetCommandSet(clusterName);
VerifyOrReturnValue(clusterIter != mCommandSets.end(), false,
ChipLogError(chipTool, "Cluster '%s' is not supported.", clusterName.c_str()));
auto & commandList = clusterIter->second.commands;
auto command = GetCommand(commandList, commandName);
if (jsonValue.isMember(kJsonCommandSpecifierKey) && IsGlobalCommand(commandName))
{
auto commandSpecifierName = jsonValue[kJsonCommandSpecifierKey].asString();
command = GetGlobalCommand(commandList, commandName, commandSpecifierName);
}
VerifyOrReturnValue(nullptr != command, false, ChipLogError(chipTool, "Unknown command."));
auto encodedData = arguments.c_str();
encodedData += kBase64StringPrefixLen;
size_t encodedDataSize = strlen(encodedData);
size_t expectedMaxDecodedSize = BASE64_MAX_DECODED_LEN(encodedDataSize);
chip::Platform::ScopedMemoryBuffer<uint8_t> decodedData;
VerifyOrReturnValue(decodedData.Calloc(expectedMaxDecodedSize + 1 /* for null */), false);
size_t decodedDataSize = chip::Base64Decode(encodedData, static_cast<uint16_t>(encodedDataSize), decodedData.Get());
VerifyOrReturnValue(decodedDataSize != 0, false, ChipLogError(chipTool, "Error while decoding base64 data."));
decodedData.Get()[decodedDataSize] = '\0';
Json::Value jsonArguments;
bool parsedArguments = JsonParser::ParseCustomArgument(encodedData, chip::Uint8::to_char(decodedData.Get()), jsonArguments);
VerifyOrReturnValue(parsedArguments, false, ChipLogError(chipTool, "Error while parsing json."));
VerifyOrReturnValue(jsonArguments.isObject(), false, ChipLogError(chipTool, "Unexpected json type, expects and object."));
std::vector<std::string> mandatoryArguments;
std::vector<std::string> optionalArguments;
VerifyOrReturnValue(GetArgumentsFromJson(command, jsonArguments, false /* addOptional */, mandatoryArguments), false);
VerifyOrReturnValue(GetArgumentsFromJson(command, jsonArguments, true /* addOptional */, optionalArguments), false);
args.push_back(std::move(clusterName));
args.push_back(std::move(commandName));
if (jsonValue.isMember(kJsonCommandSpecifierKey))
{
auto commandSpecifierName = jsonValue[kJsonCommandSpecifierKey].asString();
args.push_back(std::move(commandSpecifierName));
}
args.insert(args.end(), mandatoryArguments.begin(), mandatoryArguments.end());
args.insert(args.end(), optionalArguments.begin(), optionalArguments.end());
return true;
}
bool Commands::DecodeArgumentsFromStringStream(const char * command, std::vector<std::string> & args)
{
std::string arg;
std::stringstream ss(command);
while (ss >> std::quoted(arg, '\''))
{
args.push_back(std::move(arg));
}
return true;
}
void Commands::ShowHelpText(const char * helpText)
{
if (helpText == nullptr)
{
return;
}
// We leave 82 chars for command/cluster names. The help text starts
// two chars further to the right, so there are 80 chars left
// for it.
if (strlen(helpText) > 80)
{
// Add "..." at the end to indicate truncation, and only
// show the first 77 chars, since that's what will fit.
fprintf(stderr, " | - %.77s...|\n", helpText);
}
else
{
fprintf(stderr, " | - %-80s|\n", helpText);
}
}