| /* |
| * |
| * Copyright (c) 2020 Project CHIP Authors |
| * |
| * 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 <cstdio> |
| #include <memory> |
| #include <optional> |
| |
| #include <arpa/inet.h> |
| #include <strings.h> |
| |
| #include <TracingCommandLineArgument.h> |
| #include <lib/dnssd/Advertiser.h> |
| #include <lib/support/CHIPArgParser.hpp> |
| #include <lib/support/CHIPMem.h> |
| #include <lib/support/Span.h> |
| #include <platform/CHIPDeviceLayer.h> |
| |
| using namespace chip; |
| |
| namespace { |
| |
| enum class AdvertisingMode |
| { |
| kCommissionableNode, |
| kOperational, |
| kOperationalMultiAdmin, |
| kCommissioner, |
| }; |
| |
| struct Options |
| { |
| bool enableIpV4 = false; |
| AdvertisingMode advertisingMode = AdvertisingMode::kCommissionableNode; |
| |
| // commissionable node / commissioner params |
| std::optional<uint16_t> vendorId; |
| std::optional<uint16_t> productId; |
| std::optional<uint32_t> deviceType; |
| std::optional<const char *> deviceName; |
| |
| // commissionable node params |
| uint8_t shortDiscriminator = 52; |
| uint16_t longDiscriminator = 840; |
| Dnssd::CommissioningMode commissioningMode = Dnssd::CommissioningMode::kDisabled; |
| std::optional<const char *> rotatingId; |
| std::optional<const char *> pairingInstr; |
| std::optional<uint16_t> pairingHint; |
| |
| // operational params |
| uint64_t fabricId = 12345; |
| uint64_t nodeId = 6789; |
| uint8_t mac[6] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 }; |
| |
| } gOptions; |
| |
| using namespace chip::ArgParser; |
| |
| constexpr uint16_t kOptionEnableIpV4 = '4'; |
| constexpr uint16_t kOptionAdvertisingMode = 'm'; |
| |
| constexpr uint16_t kOptionCommissioningShortDiscriminator = 's'; |
| constexpr uint16_t kOptionCommissioningLongDiscriminaotr = 'l'; |
| constexpr uint16_t kOptionCommissioningVendorId = 0x100; // v is used by 'version' |
| constexpr uint16_t kOptionCommissioningProductId = 'p'; |
| constexpr uint16_t kOptionCommissioningPairingInstr = 0x200; // Just use the long format |
| constexpr uint16_t kOptionCommissioningPairingHint = 0x300; |
| constexpr uint16_t kOptionCommissioningDeviceType = 0x400; |
| constexpr uint16_t kOptionCommissioningDeviceName = 0x500; |
| constexpr uint16_t kOptionCommissioningMode = 0x600; |
| constexpr uint16_t kOptionCommissioningRotatingId = 0x700; |
| |
| constexpr uint16_t kOptionOperationalFabricId = 'f'; |
| constexpr uint16_t kOptionOperationalNodeId = 'n'; |
| constexpr uint16_t kOptionTraceTo = 't'; |
| |
| // Only used for argument parsing. Tracing setup owned by the main loop. |
| chip::CommandLineApp::TracingSetup * tracing_setup_for_argparse = nullptr; |
| |
| bool HandleOptions(const char * aProgram, OptionSet * aOptions, int aIdentifier, const char * aName, const char * aValue) |
| { |
| uint8_t cm; |
| switch (aIdentifier) |
| { |
| case kOptionEnableIpV4: |
| gOptions.enableIpV4 = true; |
| return true; |
| case kOptionTraceTo: |
| tracing_setup_for_argparse->EnableTracingFor(aValue); |
| return true; |
| case kOptionAdvertisingMode: |
| if (strcmp(aValue, "operational") == 0) |
| { |
| gOptions.advertisingMode = AdvertisingMode::kOperational; |
| } |
| else if (strcmp(aValue, "operational-multi-admin") == 0) |
| { |
| gOptions.advertisingMode = AdvertisingMode::kOperationalMultiAdmin; |
| } |
| else if (strcmp(aValue, "commissionable-node") == 0) |
| { |
| gOptions.advertisingMode = AdvertisingMode::kCommissionableNode; |
| } |
| else if (strcmp(aValue, "commissioner") == 0) |
| { |
| gOptions.advertisingMode = AdvertisingMode::kCommissioner; |
| } |
| else |
| { |
| PrintArgError("%s: Invalid advertising mode %s\n", aProgram, aValue); |
| |
| return false; |
| } |
| return true; |
| case kOptionCommissioningShortDiscriminator: |
| gOptions.shortDiscriminator = static_cast<uint8_t>(atoi(aValue)); |
| return true; |
| case kOptionCommissioningLongDiscriminaotr: |
| gOptions.longDiscriminator = static_cast<uint16_t>(atoi(aValue)); |
| return true; |
| case kOptionCommissioningVendorId: |
| gOptions.vendorId = std::make_optional<uint16_t>(static_cast<uint16_t>(atoi(aValue))); |
| return true; |
| case kOptionCommissioningProductId: |
| gOptions.productId = std::make_optional<uint16_t>(static_cast<uint16_t>(atoi(aValue))); |
| return true; |
| case kOptionCommissioningMode: |
| cm = static_cast<uint8_t>(atoi(aValue)); |
| if (cm == 1) |
| { |
| gOptions.commissioningMode = Dnssd::CommissioningMode::kEnabledBasic; |
| } |
| if (cm == 2) |
| { |
| gOptions.commissioningMode = Dnssd::CommissioningMode::kEnabledEnhanced; |
| } |
| return true; |
| case kOptionCommissioningDeviceType: |
| gOptions.deviceType = std::make_optional<uint32_t>(static_cast<uint32_t>(atoi(aValue))); |
| return true; |
| case kOptionCommissioningDeviceName: |
| gOptions.deviceName = std::make_optional<const char *>(static_cast<const char *>(aValue)); |
| return true; |
| case kOptionCommissioningRotatingId: |
| gOptions.rotatingId = std::make_optional<const char *>(static_cast<const char *>(aValue)); |
| return true; |
| case kOptionCommissioningPairingInstr: |
| gOptions.pairingInstr = std::make_optional<const char *>(static_cast<const char *>(aValue)); |
| return true; |
| case kOptionCommissioningPairingHint: |
| gOptions.pairingHint = std::make_optional<uint16_t>(static_cast<uint16_t>(atoi(aValue))); |
| return true; |
| case kOptionOperationalFabricId: |
| if (sscanf(aValue, "%" SCNx64, &gOptions.fabricId) != 1) |
| { |
| PrintArgError("%s: Invalid fabric id: %s\n", aProgram, aValue); |
| return false; |
| } |
| return true; |
| case kOptionOperationalNodeId: |
| if (sscanf(aValue, "%" SCNx64, &gOptions.nodeId) != 1) |
| { |
| PrintArgError("%s: Invalid node id: %s\n", aProgram, aValue); |
| return false; |
| } |
| return true; |
| default: |
| PrintArgError("%s: INTERNAL ERROR: Unhandled option: %s\n", aProgram, aName); |
| return false; |
| } |
| } |
| |
| OptionDef cmdLineOptionsDef[] = { |
| #if INET_CONFIG_ENABLE_IPV4 |
| { "enable-ip-v4", kNoArgument, kOptionEnableIpV4 }, |
| #endif |
| { "advertising-mode", kArgumentRequired, kOptionAdvertisingMode }, |
| |
| { "short-discriminator", kArgumentRequired, kOptionCommissioningShortDiscriminator }, |
| { "long-discriminator", kArgumentRequired, kOptionCommissioningLongDiscriminaotr }, |
| { "vendor-id", kArgumentRequired, kOptionCommissioningVendorId }, |
| { "product-id", kArgumentRequired, kOptionCommissioningProductId }, |
| { "commissioning-mode", kNoArgument, kOptionCommissioningMode }, |
| { "device-type", kArgumentRequired, kOptionCommissioningDeviceType }, |
| { "device-name", kArgumentRequired, kOptionCommissioningDeviceName }, |
| { "rotating-id", kArgumentRequired, kOptionCommissioningRotatingId }, |
| { "pairing-instruction", kArgumentRequired, kOptionCommissioningPairingInstr }, |
| { "pairing-hint", kArgumentRequired, kOptionCommissioningPairingHint }, |
| |
| { "fabric-id", kArgumentRequired, kOptionOperationalFabricId }, |
| { "node-id", kArgumentRequired, kOptionOperationalNodeId }, |
| { "trace-to", kArgumentRequired, kOptionTraceTo }, |
| {}, |
| }; |
| |
| OptionSet cmdLineOptions = { |
| HandleOptions, cmdLineOptionsDef, "PROGRAM OPTIONS", |
| #if INET_CONFIG_ENABLE_IPV4 |
| " -4\n" |
| " --enable-ip-v4\n" |
| " enable listening on IPv4\n" |
| #endif |
| " -m <mode>\n" |
| " --advertising-mode <mode>\n" |
| " Advertise in this mode (operational, operational-multi-admin, commissionable-node or commissioner).\n" |
| " --short-discriminator <value>\n" |
| " -s <value>\n" |
| " Commissioning/commissionable short discriminator.\n" |
| " --long-discriminator <value>\n" |
| " -l <value>\n" |
| " Commissioning/commissionable long discriminator.\n" |
| " --vendor-id <value>\n" |
| " Commissioning/commissionable vendor id.\n" |
| " --product-id <value>\n" |
| " -p <value>\n" |
| " Commissioning/commissionable product id.\n" |
| " --commissioning-mode <value>\n" |
| " Commissioning Mode (0=disabled, 1=basic, 2=enhanced).\n" |
| " --device-type <value>\n" |
| " Device type id.\n" |
| " --device-name <value>\n" |
| " Name of device.\n" |
| " --rotating-id <value>\n" |
| " Rotating Id.\n" |
| " --pairing-instruction <value>\n" |
| " Commissionable pairing instruction.\n" |
| " --pairing-hint <value>\n" |
| " Commissionable pairing hint.\n" |
| " --fabric-id <value>\n" |
| " -f <value>\n" |
| " Operational fabric id.\n" |
| " --node-id <value>\n" |
| " -n <value>\n" |
| " Operational node id.\n" |
| " -t <dest>\n" |
| " --trace-to <dest>\n" |
| " trace to the given destination (supported: " SUPPORTED_COMMAND_LINE_TRACING_TARGETS ").\n" |
| "\n" |
| }; |
| |
| HelpOptions helpOptions("advertiser", "Usage: advertiser [options]", "1.0"); |
| |
| OptionSet * allOptions[] = { &cmdLineOptions, &helpOptions, nullptr }; |
| |
| void StopSignalHandler(int signal) |
| { |
| DeviceLayer::PlatformMgr().StopEventLoopTask(); |
| } |
| |
| } // namespace |
| |
| int main(int argc, char ** args) |
| { |
| if (Platform::MemoryInit() != CHIP_NO_ERROR) |
| { |
| fprintf(stderr, "FAILED to initialize memory\n"); |
| return 1; |
| } |
| |
| if (DeviceLayer::PlatformMgr().InitChipStack() != CHIP_NO_ERROR) |
| { |
| fprintf(stderr, "FAILED to initialize chip stack\n"); |
| return 1; |
| } |
| |
| chip::CommandLineApp::TracingSetup tracing_setup; |
| |
| tracing_setup_for_argparse = &tracing_setup; |
| if (!chip::ArgParser::ParseArgs(args[0], argc, args, allOptions)) |
| { |
| return 1; |
| } |
| tracing_setup_for_argparse = nullptr; |
| |
| if (chip::Dnssd::ServiceAdvertiser::Instance().Init(DeviceLayer::UDPEndPointManager()) != CHIP_NO_ERROR) |
| { |
| fprintf(stderr, "FAILED to start MDNS advertisement\n"); |
| return 1; |
| } |
| |
| CHIP_ERROR err; |
| |
| if (gOptions.advertisingMode == AdvertisingMode::kCommissionableNode) |
| { |
| printf("Advertise Commissionable Node\n"); |
| err = chip::Dnssd::ServiceAdvertiser::Instance().Advertise(chip::Dnssd::CommissionAdvertisingParameters() |
| .EnableIpV4(gOptions.enableIpV4) |
| .SetPort(CHIP_PORT) |
| .SetShortDiscriminator(gOptions.shortDiscriminator) |
| .SetLongDiscriminator(gOptions.longDiscriminator) |
| .SetMac(chip::ByteSpan(gOptions.mac, 6)) |
| .SetVendorId(gOptions.vendorId) |
| .SetProductId(gOptions.productId) |
| .SetCommissioningMode(gOptions.commissioningMode) |
| .SetDeviceType(gOptions.deviceType) |
| .SetDeviceName(gOptions.deviceName) |
| .SetRotatingDeviceId(gOptions.rotatingId) |
| .SetPairingInstruction(gOptions.pairingInstr) |
| .SetPairingHint(gOptions.pairingHint)); |
| } |
| else if (gOptions.advertisingMode == AdvertisingMode::kOperational) |
| { |
| err = chip::Dnssd::ServiceAdvertiser::Instance().Advertise( |
| chip::Dnssd::OperationalAdvertisingParameters() |
| .EnableIpV4(gOptions.enableIpV4) |
| .SetPort(CHIP_PORT) |
| .SetMac(chip::ByteSpan(gOptions.mac, 6)) |
| .SetPeerId(PeerId().SetCompressedFabricId(gOptions.fabricId).SetNodeId(gOptions.nodeId))); |
| } |
| else if (gOptions.advertisingMode == AdvertisingMode::kOperationalMultiAdmin) |
| { |
| err = chip::Dnssd::ServiceAdvertiser::Instance().Advertise( |
| chip::Dnssd::OperationalAdvertisingParameters() |
| .EnableIpV4(gOptions.enableIpV4) |
| .SetPort(CHIP_PORT) |
| .SetMac(chip::ByteSpan(gOptions.mac, 6)) |
| .SetPeerId(PeerId().SetCompressedFabricId(gOptions.fabricId).SetNodeId(gOptions.nodeId))); |
| |
| if (err == CHIP_NO_ERROR) |
| { |
| err = chip::Dnssd::ServiceAdvertiser::Instance().Advertise( |
| chip::Dnssd::OperationalAdvertisingParameters() |
| .EnableIpV4(gOptions.enableIpV4) |
| .SetPort(CHIP_PORT + 1) |
| .SetMac(chip::ByteSpan(gOptions.mac, 6)) |
| .SetPeerId(PeerId().SetCompressedFabricId(gOptions.fabricId + 1).SetNodeId(gOptions.nodeId + 1))); |
| } |
| |
| if (err == CHIP_NO_ERROR) |
| { |
| err = chip::Dnssd::ServiceAdvertiser::Instance().Advertise( |
| chip::Dnssd::OperationalAdvertisingParameters() |
| .EnableIpV4(gOptions.enableIpV4) |
| .SetPort(CHIP_PORT + 2) |
| .SetMac(chip::ByteSpan(gOptions.mac, 6)) |
| .SetPeerId(PeerId().SetCompressedFabricId(gOptions.fabricId + 2).SetNodeId(gOptions.nodeId + 2))); |
| } |
| } |
| else if (gOptions.advertisingMode == AdvertisingMode::kCommissioner) |
| { |
| printf("Advertise Commissioner\n"); |
| err = chip::Dnssd::ServiceAdvertiser::Instance().Advertise( |
| chip::Dnssd::CommissionAdvertisingParameters() |
| .EnableIpV4(gOptions.enableIpV4) |
| .SetPort(CHIP_PORT) |
| .SetMac(chip::ByteSpan(gOptions.mac, 6)) |
| .SetVendorId(gOptions.vendorId) |
| .SetProductId(gOptions.productId) |
| .SetDeviceType(gOptions.deviceType) |
| .SetDeviceName(gOptions.deviceName) |
| .SetCommissionAdvertiseMode(chip::Dnssd::CommssionAdvertiseMode::kCommissioner)); |
| } |
| else |
| { |
| fprintf(stderr, "FAILED to determine advertising type.\n"); |
| return 1; |
| } |
| |
| if (err != CHIP_NO_ERROR) |
| { |
| fprintf(stderr, "FAILED to setup advertisement parameters err=%s\n", chip::ErrorStr(err)); |
| return 1; |
| } |
| |
| signal(SIGTERM, StopSignalHandler); |
| signal(SIGINT, StopSignalHandler); |
| |
| DeviceLayer::PlatformMgr().RunEventLoop(); |
| |
| tracing_setup.StopTracing(); |
| Dnssd::Resolver::Instance().Shutdown(); |
| DeviceLayer::PlatformMgr().Shutdown(); |
| |
| printf("Done...\n"); |
| return 0; |
| } |
