| /* |
| * |
| * Copyright (c) 2013-2017 Nest Labs, Inc. |
| * 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. |
| */ |
| |
| /** |
| * @file |
| * Common command-line option handling code for test applications. |
| * |
| */ |
| |
| |
| #ifndef __STDC_LIMIT_MACROS |
| #define __STDC_LIMIT_MACROS |
| #endif |
| #define __STDC_FORMAT_MACROS |
| |
| #include <inttypes.h> |
| #include <stdint.h> |
| #include <stdio.h> |
| |
| #include "ToolCommonOptions.h" |
| #include "TestPersistedStorageImplementation.h" |
| #include <Weave/WeaveVersion.h> |
| #include <Weave/Profiles/service-directory/ServiceDirectory.h> |
| #include <SystemLayer/SystemFaultInjection.h> |
| #include <Weave/Support/WeaveFaultInjection.h> |
| #include <InetLayer/InetFaultInjection.h> |
| |
| using namespace nl::Inet; |
| using namespace nl::Weave; |
| |
| NetworkOptions gNetworkOptions; |
| WeaveNodeOptions gWeaveNodeOptions; |
| WeaveSecurityMode gWeaveSecurityMode; |
| WRMPOptions gWRMPOptions; |
| GroupKeyEncOptions gGroupKeyEncOptions; |
| ServiceDirClientOptions gServiceDirClientOptions; |
| FaultInjectionOptions gFaultInjectionOptions; |
| |
| NetworkOptions::NetworkOptions() |
| { |
| static OptionDef optionDefs[] = |
| { |
| { "local-addr", kArgumentRequired, 'a' }, |
| { "node-addr", kArgumentRequired, kToolCommonOpt_NodeAddr }, /* alias for local-addr */ |
| #if WEAVE_SYSTEM_CONFIG_USE_LWIP |
| { "tap-device", kArgumentRequired, 'I' }, |
| { "interface", kArgumentRequired, 'I' }, /* deprecated alias for tap-device */ |
| { "ipv4-gateway", kArgumentRequired, kToolCommonOpt_IPv4GatewayAddr }, |
| { "dns-server", kArgumentRequired, 'X' }, |
| { "debug-lwip", kNoArgument, kToolCommonOpt_DebugLwIP }, |
| { "event-delay", kArgumentRequired, kToolCommonOpt_EventDelay }, |
| #endif |
| { NULL } |
| }; |
| OptionDefs = optionDefs; |
| |
| HelpGroupName = "NETWORK OPTIONS"; |
| |
| OptionHelp = |
| " -a, --local-addr, --node-addr <ip-addr>\n" |
| " Local address for the node.\n" |
| "\n" |
| #if WEAVE_SYSTEM_CONFIG_USE_LWIP |
| " -I, --tap-device <tap-dev-name>\n" |
| " TAP device name for LwIP stack. Defaults to weave-dev-<node-id>.\n" |
| " (Deprecated alias: --interface)\n" |
| "\n" |
| " --ipv4-gateway <ip-addr>\n" |
| " Address of default IPv4 gateway.\n" |
| "\n" |
| " -X, --dns-server <ip-addr>\n" |
| " IPv4 address of local DNS server.\n" |
| "\n" |
| " --debug-lwip\n" |
| " Enable LwIP debug messages.\n" |
| "\n" |
| " --event-delay <int>\n" |
| " Delay event processing by specified number of iterations. Defaults to 0.\n" |
| "\n" |
| #endif |
| ; |
| |
| // Defaults. |
| LocalIPv4Addr = nl::Inet::IPAddress::Any; |
| LocalIPv6Addr = nl::Inet::IPAddress::Any; |
| |
| #if WEAVE_SYSTEM_CONFIG_USE_LWIP |
| TapDeviceName = NULL; |
| LwIPDebugFlags = 0; |
| EventDelay = 0; |
| IPv4GatewayAddr = nl::Inet::IPAddress::Any; |
| DNSServerAddr = nl::Inet::IPAddress::Any; |
| #endif // WEAVE_SYSTEM_CONFIG_USE_LWIP |
| } |
| |
| bool NetworkOptions::HandleOption(const char *progName, OptionSet *optSet, int id, const char *name, const char *arg) |
| { |
| nl::Inet::IPAddress localAddr; |
| |
| switch (id) |
| { |
| case 'a': |
| case kToolCommonOpt_NodeAddr: |
| if (!ParseIPAddress(arg, localAddr)) |
| { |
| PrintArgError("%s: Invalid value specified for local IP address: %s\n", progName, arg); |
| return false; |
| } |
| #if INET_CONFIG_ENABLE_IPV4 |
| if (localAddr.IsIPv4()) |
| { |
| LocalIPv4Addr = localAddr; |
| } |
| else |
| { |
| LocalIPv6Addr = localAddr; |
| } |
| #else // INET_CONFIG_ENABLE_IPV4 |
| LocalIPv6Addr = localAddr; |
| #endif // INET_CONFIG_ENABLE_IPV4 |
| break; |
| |
| #if WEAVE_SYSTEM_CONFIG_USE_LWIP |
| case 'X': |
| if (!ParseIPAddress(arg, DNSServerAddr)) |
| { |
| PrintArgError("%s: Invalid value specified for DNS server address: %s\n", progName, arg); |
| return false; |
| } |
| break; |
| case 'I': |
| TapDeviceName = arg; |
| break; |
| case kToolCommonOpt_DebugLwIP: |
| #if defined(LWIP_DEBUG) |
| gLwIP_DebugFlags = (LWIP_DBG_ON|LWIP_DBG_TRACE|LWIP_DBG_STATE|LWIP_DBG_FRESH|LWIP_DBG_HALT); |
| #endif |
| break; |
| case kToolCommonOpt_EventDelay: |
| if (!ParseInt(arg, EventDelay)) |
| { |
| PrintArgError("%s: Invalid value specified for event delay: %s\n", progName, arg); |
| return false; |
| } |
| break; |
| #endif // WEAVE_SYSTEM_CONFIG_USE_LWIP |
| |
| default: |
| PrintArgError("%s: INTERNAL ERROR: Unhandled option: %s\n", progName, name); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| WeaveNodeOptions::WeaveNodeOptions() |
| { |
| static OptionDef optionDefs[] = |
| { |
| { "fabric-id", kArgumentRequired, 'f' }, |
| { "node-id", kArgumentRequired, 'n' }, |
| { "subnet", kArgumentRequired, 'N' }, |
| { "pairing-code", kArgumentRequired, kToolCommonOpt_PairingCode }, |
| { "persistent-cntr-file", kArgumentRequired, kToolCommonOpt_PersistentCntrFile }, |
| { NULL } |
| }; |
| OptionDefs = optionDefs; |
| |
| HelpGroupName = "WEAVE NODE OPTIONS"; |
| |
| OptionHelp = |
| " -f, --fabric-id <num>\n" |
| " Weave fabric id. Defaults to 1 unless --node-addr specified.\n" |
| "\n" |
| " -n, --node-id <num>\n" |
| " Node id for local node. Defaults to 1 unless --node-addr specified.\n" |
| "\n" |
| " -N, --subnet <num>\n" |
| " Subnet number for local node. Defaults to 1 unless --node-addr specified.\n" |
| "\n" |
| " --pairing-code <string>\n" |
| " Pairing code string to use for PASE authentication. Defaults to 'TEST'.\n" |
| "\n" |
| " --persistent-cntr-file <counter-file>\n" |
| " File used to persist group message counter and event counters. Counters are stored in the following format:\n" |
| " CounterOneKey (e.g. EncMsgCntr)\n" |
| " CounterOneValue (e.g. 0x00000078)\n" |
| " CounterTwoKey (e.g. ProductionEIDC)\n" |
| " CounterTwoValue (e.g. 0x34FA78E4)\n" |
| " The intention was to store these data in a human interpreted format so\n" |
| " developers can manually modify this file. When this file is modified manually\n" |
| " developers should stick to this format - any other format will result in error.\n" |
| " If persistent-cntr-file option is not specified then by default counters are not persisted.\n" |
| "\n" |
| ; |
| |
| // Defaults. |
| FabricId = nl::Weave::kFabricIdDefaultForTest; |
| LocalNodeId = 1; |
| SubnetId = 1; |
| FabricIdSet = false; |
| LocalNodeIdSet = false; |
| SubnetIdSet = false; |
| PairingCode = "TEST"; |
| } |
| |
| WeaveNodeOptions::~WeaveNodeOptions() |
| { |
| if (sPersistentStoreFile != NULL) |
| fclose(sPersistentStoreFile); |
| } |
| |
| bool WeaveNodeOptions::HandleOption(const char *progName, OptionSet *optSet, int id, const char *name, const char *arg) |
| { |
| switch (id) |
| { |
| case 'f': |
| if (!ParseFabricId(arg, FabricId)) |
| { |
| PrintArgError("%s: Invalid value specified for fabric id: %s\n", progName, arg); |
| return false; |
| } |
| break; |
| case 'n': |
| if (!ParseNodeId(arg, LocalNodeId)) |
| { |
| PrintArgError("%s: Invalid value specified for local node id: %s\n", progName, arg); |
| return false; |
| } |
| LocalNodeIdSet = true; |
| break; |
| case 'N': |
| if (!ParseSubnetId(arg, SubnetId)) |
| { |
| PrintArgError("%s: Invalid value specified for local subnet: %s\n", progName, arg); |
| return false; |
| } |
| break; |
| case kToolCommonOpt_PairingCode: |
| PairingCode = arg; |
| break; |
| case kToolCommonOpt_PersistentCntrFile: |
| // If file already exists then open it for write/update. |
| if ((sPersistentStoreFile = fopen(arg, "r")) == NULL) |
| { |
| sPersistentStoreFile = fopen(arg, "w+"); |
| } |
| // If file doesn't exist then open it for read/update. |
| else |
| { |
| fclose(sPersistentStoreFile); |
| sPersistentStoreFile = fopen(arg, "r+"); |
| } |
| |
| if (sPersistentStoreFile == NULL) |
| { |
| printf("Unable to open %s\n%s\n", arg, strerror(errno)); |
| return false; |
| } |
| break; |
| default: |
| PrintArgError("%s: INTERNAL ERROR: Unhandled option: %s\n", progName, name); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| WeaveSecurityMode::WeaveSecurityMode() |
| { |
| static OptionDef optionDefs[] = |
| { |
| { "no-security", kNoArgument, kToolCommonOpt_SecurityNone }, |
| { "case", kNoArgument, kToolCommonOpt_SecurityCASE }, |
| { "case-shared", kNoArgument, kToolCommonOpt_SecurityCASEShared }, |
| { "pase", kNoArgument, kToolCommonOpt_SecurityPASE }, |
| { "group-enc", kNoArgument, kToolCommonOpt_SecurityGroupEnc }, |
| { "take", kNoArgument, kToolCommonOpt_SecurityTAKE }, |
| { NULL } |
| }; |
| |
| OptionDefs = optionDefs; |
| |
| HelpGroupName = "WEAVE SECURITY OPTIONS"; |
| |
| OptionHelp = |
| " --no-security\n" |
| " Use no security session\n" |
| "\n" |
| " --pase\n" |
| " Use PASE to create an authenticated session and encrypt messages using\n" |
| " the negotiated session key.\n" |
| "\n" |
| " --case\n" |
| " Use CASE to create an authenticated session and encrypt messages using\n" |
| " the negotiated session key.\n" |
| "\n" |
| " --case-shared\n" |
| " Use CASE to create an authenticated shared session to the Nest Core router\n" |
| " and encrypt messages using the negotiated session key.\n" |
| "\n" |
| " --take\n" |
| " Use TAKE to create an authenticated session and encrypt messages using\n" |
| " the negotiated session key.\n" |
| "\n" |
| #if WEAVE_CONFIG_USE_APP_GROUP_KEYS_FOR_MSG_ENC |
| " --group-enc\n" |
| " Use a group key to encrypt messages.\n" |
| " When group key encryption option is chosen the key id should be also specified.\n" |
| " Below are two examples how group key id can be specified:\n" |
| " --group-enc-key-id 0x00005536\n" |
| " --group-enc-key-type r --group-enc-root-key c --group-enc-epoch-key-num 2 --group-enc-app-key-num 54\n" |
| " Note that both examples describe the same rotating group key derived from client\n" |
| " root key, epoch key number 4 and app group master key number 54 (0x36).\n" |
| "\n" |
| #endif // WEAVE_CONFIG_USE_APP_GROUP_KEYS_FOR_MSG_ENC |
| ; |
| |
| // Defaults. |
| SecurityMode = kNone; |
| |
| } |
| |
| bool WeaveSecurityMode::HandleOption(const char *progName, OptionSet *optSet, int id, const char *name, const char *arg) |
| { |
| switch (id) |
| { |
| case kToolCommonOpt_SecurityNone: |
| SecurityMode = kNone; |
| break; |
| case kToolCommonOpt_SecurityCASE: |
| SecurityMode = kCASE; |
| break; |
| case kToolCommonOpt_SecurityCASEShared: |
| SecurityMode = kCASEShared; |
| break; |
| case kToolCommonOpt_SecurityPASE: |
| SecurityMode = kPASE; |
| break; |
| case kToolCommonOpt_SecurityGroupEnc: |
| SecurityMode = kGroupEnc; |
| break; |
| case kToolCommonOpt_SecurityTAKE: |
| SecurityMode = kTAKE; |
| break; |
| default: |
| PrintArgError("%s: INTERNAL ERROR: Unhandled option: %s\n", progName, name); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| |
| WRMPOptions::WRMPOptions() |
| { |
| static OptionDef optionDefs[] = |
| { |
| #if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING |
| { "wrmp-ack-delay", kArgumentRequired, kToolCommonOpt_WRMPACKDelay }, |
| { "wrmp-retrans-interval", kArgumentRequired, kToolCommonOpt_WRMPRetransInterval }, |
| { "wrmp-retrans-count", kArgumentRequired, kToolCommonOpt_WRMPRetransCount }, |
| #endif // WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING |
| { NULL } |
| }; |
| OptionDefs = optionDefs; |
| |
| HelpGroupName = "WEAVE RELIABLE MESSAGING OPTIONS"; |
| |
| OptionHelp = |
| #if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING |
| " --wrmp-ack-delay <ms>\n" |
| " Set the WRMP maximum pending ACK delay (defaults to 200ms).\n" |
| "\n" |
| " --wrmp-retrans-interval <ms>\n" |
| " Set the WRMP retransmission interval (defaults to 200ms).\n" |
| "\n" |
| " --wrmp-retrans-count <int>\n" |
| " Set the WRMP retransmission count (defaults to 3).\n" |
| "\n" |
| #endif // WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING |
| ""; |
| |
| // Defaults. |
| ACKDelay = WEAVE_CONFIG_WRMP_DEFAULT_ACK_TIMEOUT; |
| RetransInterval = WEAVE_CONFIG_WRMP_DEFAULT_ACTIVE_RETRANS_TIMEOUT; |
| RetransCount = WEAVE_CONFIG_WRMP_DEFAULT_MAX_RETRANS; |
| } |
| |
| nl::Weave::WRMPConfig WRMPOptions::GetWRMPConfig() const |
| { |
| nl::Weave::WRMPConfig wrmpConfig; |
| memset(&wrmpConfig, 0, sizeof(wrmpConfig)); |
| wrmpConfig.mInitialRetransTimeout = RetransInterval; |
| wrmpConfig.mActiveRetransTimeout = RetransInterval; |
| wrmpConfig.mAckPiggybackTimeout = ACKDelay; |
| wrmpConfig.mMaxRetrans = RetransCount; |
| return wrmpConfig; |
| } |
| |
| bool WRMPOptions::HandleOption(const char *progName, OptionSet *optSet, int id, const char *name, const char *arg) |
| { |
| switch (id) |
| { |
| #if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING |
| case kToolCommonOpt_WRMPACKDelay: |
| if (!ParseInt(arg, ACKDelay)) |
| { |
| PrintArgError("%s: Invalid value specified for WRMP ACK delay: %s\n", progName, arg); |
| return false; |
| } |
| break; |
| case kToolCommonOpt_WRMPRetransInterval: |
| if (!ParseInt(arg, RetransInterval)) |
| { |
| PrintArgError("%s: Invalid value specified for WRMP retransmission interval: %s\n", progName, arg); |
| return false; |
| } |
| break; |
| case kToolCommonOpt_WRMPRetransCount: |
| if (!ParseInt(arg, RetransCount)) |
| { |
| PrintArgError("%s: Invalid value specified for WRMP retransmission count: %s\n", progName, arg); |
| return false; |
| } |
| break; |
| #endif // WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING |
| default: |
| PrintArgError("%s: INTERNAL ERROR: Unhandled option: %s\n", progName, name); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| GroupKeyEncOptions::GroupKeyEncOptions() |
| { |
| static OptionDef optionDefs[] = |
| { |
| #if WEAVE_CONFIG_USE_APP_GROUP_KEYS_FOR_MSG_ENC |
| { "group-enc-key-id", kArgumentRequired, kToolCommonOpt_GroupEncKeyId }, |
| { "group-enc-key-type", kArgumentRequired, kToolCommonOpt_GroupEncKeyType }, |
| { "group-enc-root-key", kArgumentRequired, kToolCommonOpt_GroupEncRootKey }, |
| { "group-enc-epoch-key-num", kArgumentRequired, kToolCommonOpt_GroupEncEpochKeyNum }, |
| { "group-enc-app-key-num", kArgumentRequired, kToolCommonOpt_GroupEncAppGroupMasterKeyNum }, |
| #endif |
| { NULL } |
| }; |
| OptionDefs = optionDefs; |
| |
| HelpGroupName = "GROUP KEY MESSAGE ENCRYPTION OPTIONS"; |
| |
| OptionHelp = |
| #if WEAVE_CONFIG_USE_APP_GROUP_KEYS_FOR_MSG_ENC |
| " --group-enc-key-id <int>\n" |
| " Key id of the group key that should be used to encrypt messages. This option\n" |
| " overrides any of the following options.\n" |
| "\n" |
| " --group-enc-key-type <key-type>\n" |
| " Key type of the group key to be used for encrypting messages.\n" |
| " Valid values for <key-type> are:\n" |
| " r - rotating message encryption group key.\n" |
| " s - static message encryption group key.\n" |
| "\n" |
| " --group-enc-root-key <root-type>\n" |
| " Root key type to be used to generate the group key id for encrypting messages.\n" |
| " Valid values for <root-type> are:\n" |
| " f - fabric root key.\n" |
| " c - client root key.\n" |
| " s - service root key.\n" |
| "\n" |
| " --group-enc-epoch-key-num <int>\n" |
| " Epoch key number to be used to generate the group key id for encrypting messages.\n" |
| " when group key encyption option is chosen.\n" |
| "\n" |
| " --group-enc-app-key-num <int>\n" |
| " Application group master key number to be used to generate the group key id for\n" |
| " encrypting messages.\n" |
| "\n" |
| #endif // WEAVE_CONFIG_USE_APP_GROUP_KEYS_FOR_MSG_ENC |
| ""; |
| |
| // Defaults. |
| EncKeyId = WeaveKeyId::kNone; |
| EncKeyType = WeaveKeyId::kType_None; |
| RootKeyId = WeaveKeyId::kNone; |
| EpochKeyId = WeaveKeyId::kNone; |
| AppGroupMasterKeyId = WeaveKeyId::kNone; |
| } |
| |
| uint32_t GroupKeyEncOptions::GetEncKeyId() const |
| { |
| if (EncKeyId != WeaveKeyId::kNone) |
| return EncKeyId; |
| if (EncKeyType == WeaveKeyId::kType_None) |
| return WeaveKeyId::kNone; |
| if (RootKeyId == WeaveKeyId::kNone || AppGroupMasterKeyId == WeaveKeyId::kNone) |
| return WeaveKeyId::kNone; |
| return WeaveKeyId::MakeAppKeyId(EncKeyType, RootKeyId, |
| (EncKeyType == WeaveKeyId::kType_AppRotatingKey) ? EpochKeyId : WeaveKeyId::kNone, |
| AppGroupMasterKeyId, |
| (EncKeyType == WeaveKeyId::kType_AppRotatingKey && EpochKeyId == WeaveKeyId::kNone)); |
| } |
| |
| bool GroupKeyEncOptions::HandleOption(const char *progName, OptionSet *optSet, int id, const char *name, const char *arg) |
| { |
| switch (id) |
| { |
| #if WEAVE_CONFIG_USE_APP_GROUP_KEYS_FOR_MSG_ENC |
| case kToolCommonOpt_GroupEncKeyId: |
| if (!ParseInt(arg, EncKeyId, 0) || !WeaveKeyId::IsValidKeyId(EncKeyId) || !WeaveKeyId::IsAppGroupKey(EncKeyId)) |
| { |
| PrintArgError("%s: Invalid value specified for the group encryption key id: %s\n", progName, arg); |
| return false; |
| } |
| break; |
| case kToolCommonOpt_GroupEncKeyType: |
| { |
| bool invalidKeyType; |
| invalidKeyType = false; |
| if (strlen(arg) != 1) |
| { |
| invalidKeyType = true; |
| } |
| else if (*arg == 'r') |
| { |
| EncKeyType = WeaveKeyId::kType_AppRotatingKey; |
| } |
| else if (*arg == 's') |
| { |
| EncKeyType = WeaveKeyId::kType_AppStaticKey; |
| } |
| else |
| { |
| invalidKeyType = true; |
| } |
| |
| if (invalidKeyType) |
| { |
| PrintArgError("%s: Invalid value specified for the group encryption key type: %s\n", progName, arg); |
| return false; |
| } |
| break; |
| } |
| case kToolCommonOpt_GroupEncRootKey: |
| { |
| bool invalidRootKey; |
| invalidRootKey = false; |
| if (strlen(arg) != 1) |
| { |
| invalidRootKey = true; |
| } |
| else if (*arg == 'f') |
| { |
| RootKeyId = WeaveKeyId::kFabricRootKey; |
| } |
| else if (*arg == 'c') |
| { |
| RootKeyId = WeaveKeyId::kClientRootKey; |
| } |
| else if (*arg == 's') |
| { |
| RootKeyId = WeaveKeyId::kServiceRootKey; |
| } |
| else |
| { |
| invalidRootKey = true; |
| } |
| |
| if (invalidRootKey) |
| { |
| PrintArgError("%s: Invalid value specified for the root key: %s\n", progName, arg); |
| return false; |
| } |
| break; |
| } |
| case kToolCommonOpt_GroupEncEpochKeyNum: |
| { |
| uint32_t epochKeyNum; |
| if (!ParseInt(arg, epochKeyNum, 0) || epochKeyNum > 7) |
| { |
| PrintArgError("%s: Invalid value specified for the epoch key number: %s\n", progName, arg); |
| return false; |
| } |
| EpochKeyId = WeaveKeyId::MakeEpochKeyId(epochKeyNum); |
| break; |
| } |
| case kToolCommonOpt_GroupEncAppGroupMasterKeyNum: |
| { |
| uint32_t masterKeyNum; |
| if (!ParseInt(arg, masterKeyNum, 0) || masterKeyNum > 127) |
| { |
| PrintArgError("%s: Invalid value specified for the group master key number: %s\n", progName, arg); |
| return false; |
| } |
| AppGroupMasterKeyId = WeaveKeyId::MakeAppGroupMasterKeyId(masterKeyNum); |
| break; |
| } |
| #endif // WEAVE_CONFIG_USE_APP_GROUP_KEYS_FOR_MSG_ENC |
| default: |
| PrintArgError("%s: INTERNAL ERROR: Unhandled option: %s\n", progName, name); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| ServiceDirClientOptions::ServiceDirClientOptions() |
| { |
| static OptionDef optionDefs[] = |
| { |
| #if WEAVE_CONFIG_ENABLE_SERVICE_DIRECTORY |
| { "service-dir-server", kArgumentRequired, kToolCommonOpt_ServiceDirServer }, |
| { "service-dir-url", kArgumentRequired, kToolCommonOpt_ServiceDirServer }, // deprecated alias for service-dir-server |
| #endif // WEAVE_CONFIG_ENABLE_SERVICE_DIRECTORY |
| { NULL } |
| }; |
| OptionDefs = optionDefs; |
| |
| HelpGroupName = "SERVICE DIRECTORY OPTIONS"; |
| |
| OptionHelp = |
| #if WEAVE_CONFIG_ENABLE_SERVICE_DIRECTORY |
| " --service-dir-server <host-name-or-ip-addr>[:<port>]\n" |
| " Use the specified server when making service directory requests.\n" |
| " (Deprecated alias: --service-dir-url)\n" |
| "\n" |
| #endif // WEAVE_CONFIG_ENABLE_SERVICE_DIRECTORY |
| ""; |
| |
| // Defaults. |
| ServerHost = "frontdoor.integration.nestlabs.com"; |
| ServerPort = WEAVE_PORT; |
| } |
| |
| bool ServiceDirClientOptions::HandleOption(const char *progName, OptionSet *optSet, int id, const char *name, const char *arg) |
| { |
| WEAVE_ERROR err; |
| const char *host; |
| uint16_t hostLen; |
| |
| switch (id) |
| { |
| #if WEAVE_CONFIG_ENABLE_SERVICE_DIRECTORY |
| case kToolCommonOpt_ServiceDirServer: |
| err = ParseHostAndPort(arg, strlen(arg), host, hostLen, ServerPort); |
| if (err != WEAVE_NO_ERROR) |
| { |
| PrintArgError("%s: Invalid value specified for Service Directory server name: %s\n", progName, arg); |
| return false; |
| } |
| ServerHost = strndup(host, hostLen); |
| if (ServerPort == 0) |
| ServerPort = WEAVE_PORT; |
| break; |
| #endif // WEAVE_CONFIG_ENABLE_SERVICE_DIRECTORY |
| default: |
| PrintArgError("%s: INTERNAL ERROR: Unhandled option: %s\n", progName, name); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| WEAVE_ERROR ServiceDirClientOptions::GetRootDirectoryEntry(uint8_t *buf, uint16_t bufSize) |
| { |
| using namespace nl::Weave::Encoding; |
| using namespace nl::Weave::Profiles::ServiceDirectory; |
| |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| uint8_t serverHostLen = (uint8_t)strlen(ServerHost); |
| |
| VerifyOrExit(bufSize >= (1 + 8 + 1 + 1 + serverHostLen + 2), err = WEAVE_ERROR_BUFFER_TOO_SMALL); |
| |
| Write8(buf, 0x41); // Entry Type = Host/Port List, Host/Port List = 1 |
| LittleEndian::Write64(buf, kServiceEndpoint_Directory); // Service Endpoint Id = Directory Service |
| Write8(buf, 0x80); // Host ID Type = Fully Qualified, Suffix Index Present = false, Port Id Present = true |
| Write8(buf, serverHostLen); |
| memcpy(buf, ServerHost, serverHostLen); buf += serverHostLen; |
| LittleEndian::Write16(buf, ServerPort); |
| |
| exit: |
| return err; |
| } |
| |
| FaultInjectionOptions::FaultInjectionOptions() |
| { |
| static OptionDef optionDefs[] = |
| { |
| #if WEAVE_CONFIG_TEST || WEAVE_SYSTEM_CONFIG_TEST || INET_CONFIG_TEST |
| { "faults", kArgumentRequired, kToolCommonOpt_FaultInjection }, |
| { "iterations", kArgumentRequired, kToolCommonOpt_FaultTestIterations }, |
| { "debug-resource-usage", kNoArgument, kToolCommonOpt_DebugResourceUsage }, |
| { "print-fault-counters", kNoArgument, kToolCommonOpt_PrintFaultCounters }, |
| { "extra-cleanup-time", kArgumentRequired, kToolCommonOpt_ExtraCleanupTime }, |
| #endif |
| { NULL } |
| }; |
| OptionDefs = optionDefs; |
| |
| HelpGroupName = "FAULT INJECTION OPTIONS"; |
| |
| OptionHelp = |
| #if WEAVE_CONFIG_TEST || WEAVE_SYSTEM_CONFIG_TEST || INET_CONFIG_TEST |
| " --faults <fault-string>\n" |
| " Inject specified fault(s) into the operation of the tool at runtime.\n" |
| "\n" |
| " --iterations <int>\n" |
| " Execute the program operation the given number of times\n" |
| "\n" |
| " --debug-resource-usage\n" |
| " Print all stats counters before exiting.\n" |
| "\n" |
| " --print-fault-counters\n" |
| " Print the fault-injection counters before exiting.\n" |
| "\n" |
| " --extra-cleanup-time\n" |
| " Allow extra time before asserting resource leaks; this is useful when\n" |
| " running fault-injection tests to let the system free stale ExchangeContext\n" |
| " instances after WRMP has exhausted all retransmission; a failed WRMP transmission\n" |
| " should fail a normal happy-sequence test, but not necessarily a fault-injection test.\n" |
| " The value is in milliseconds; a common value is 10000.\n" |
| "\n" |
| #endif |
| ""; |
| |
| // Defaults |
| TestIterations = 1; |
| DebugResourceUsage = false; |
| PrintFaultCounters = false; |
| ExtraCleanupTimeMsec = 0; |
| } |
| |
| bool FaultInjectionOptions::HandleOption(const char *progName, OptionSet *optSet, int id, const char *name, const char *arg) |
| { |
| using namespace nl::FaultInjection; |
| |
| GetManagerFn faultMgrFnTable[] = |
| { |
| nl::Weave::FaultInjection::GetManager, |
| nl::Inet::FaultInjection::GetManager, |
| nl::Weave::System::FaultInjection::GetManager |
| }; |
| size_t faultMgrFnTableLen = sizeof(faultMgrFnTable) / sizeof(faultMgrFnTable[0]); |
| |
| switch (id) |
| { |
| #if WEAVE_CONFIG_TEST || WEAVE_SYSTEM_CONFIG_TEST || INET_CONFIG_TEST |
| case kToolCommonOpt_FaultInjection: |
| { |
| char *mutableArg = strdup(arg); |
| bool parseRes = ParseFaultInjectionStr(mutableArg, faultMgrFnTable, faultMgrFnTableLen); |
| free(mutableArg); |
| if (!parseRes) |
| { |
| PrintArgError("%s: Invalid string specified for fault injection option: %s\n", progName, arg); |
| return false; |
| } |
| break; |
| } |
| case kToolCommonOpt_FaultTestIterations: |
| if ((!ParseInt(arg, TestIterations)) || (TestIterations == 0)) |
| { |
| PrintArgError("%s: Invalid value specified for the number of iterations to execute: %s\n", progName, arg); |
| return false; |
| } |
| break; |
| case kToolCommonOpt_DebugResourceUsage: |
| DebugResourceUsage = true; |
| break; |
| case kToolCommonOpt_PrintFaultCounters: |
| PrintFaultCounters = true; |
| break; |
| case kToolCommonOpt_ExtraCleanupTime: |
| if ((!ParseInt(arg, ExtraCleanupTimeMsec)) || (ExtraCleanupTimeMsec == 0)) |
| { |
| PrintArgError("%s: Invalid value specified for the extra time to wait before checking for leaks: %s\n", progName, arg); |
| return false; |
| } |
| break; |
| #endif // WEAVE_CONFIG_TEST || WEAVE_SYSTEM_CONFIG_TEST || INET_CONFIG_TEST |
| default: |
| PrintArgError("%s: INTERNAL ERROR: Unhandled option: %s\n", progName, name); |
| return false; |
| } |
| |
| return true; |
| } |
