| // Copyright 2017 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "src/connectivity/network/mdns/util/commands.h" |
| |
| #include <lib/syslog/cpp/macros.h> |
| |
| #include <functional> |
| #include <iostream> |
| |
| #include "src/lib/fxl/strings/split_string.h" |
| |
| namespace mdns { |
| namespace { |
| |
| // Concatenates argv[1]..argv[argc - 1] with space separators. |
| std::string Concatenate(int argc, const char** argv) { |
| if (argc == 1) { |
| return ""; |
| } |
| |
| std::string result; |
| size_t result_size = 0; |
| |
| for (int i = 1; i < argc; ++i) { |
| result_size += strlen(argv[i]) + 1; |
| } |
| |
| result_size -= 1; |
| |
| result.reserve(result_size); |
| |
| result.append(argv[1]); |
| for (int i = 2; i < argc; ++i) { |
| result.append(" "); |
| result.append(argv[i]); |
| } |
| |
| return result; |
| } |
| |
| const std::string kTimeoutOption = "timeout"; |
| const std::string kMediaOption = "media"; |
| const std::string kIpVersionsOption = "ip-versions"; |
| const std::string kExcludeLocalOption = "exclude-local"; |
| const std::string kExcludeLocalProxyOption = "exclude-local-proxies"; |
| const std::string kProbeOption = "probe"; |
| const std::string kSrvPriorityOption = "srv-priority"; |
| const std::string kSrvWeightOption = "srv-weight"; |
| const std::string kPtrTtlOption = "ptr-ttl"; |
| const std::string kSrvTtlOption = "srv-ttl"; |
| const std::string kTxtTtlOption = "txt-ttl"; |
| const std::string kProxyHostOption = "proxy-host"; |
| |
| const std::string kBoolValueTrue = "true"; |
| const std::string kBoolValueFalse = "false"; |
| const std::string kMediaValueWired = "wired"; |
| const std::string kMediaValueWireless = "wireless"; |
| const std::string kIpVersionsValueV4 = "4"; |
| const std::string kIpVersionsValueV6 = "6"; |
| |
| const std::string kLabelSeparator = "."; |
| const std::string kValueSeparator = ","; |
| const std::string kOptionPrefix = "--"; |
| const std::string kOptionSeparator = "="; |
| const std::string kHostSuffix = "local."; |
| const std::string kTcpSuffix = "._tcp."; |
| const std::string kUdpSuffix = "._udp."; |
| |
| constexpr size_t kMaxServiceNameLabelLength = 16; |
| constexpr size_t kMaxHostNameLength = 253 - 6; // 6 for local domain. |
| |
| } // namespace |
| |
| const std::string Command::kResolve = "resolve"; |
| const std::string Command::kSubscribe = "subscribe"; |
| const std::string Command::kPublish = "publish"; |
| const std::string Command::kUnsubscribe = "unsubscribe"; |
| const std::string Command::kUnpublish = "unpublish"; |
| const std::string Command::kHelp = "help"; |
| const std::string Command::kQuit = "quit"; |
| |
| const std::string Command::kAllServices = "all"; |
| |
| CommandParser::CommandParser(const std::string& command_line) : str_(command_line) {} |
| |
| CommandParser::CommandParser(int argc, const char** argv) |
| : CommandParser(Concatenate(argc, argv)) {} |
| |
| Command CommandParser::Parse() { |
| MatchWhitespace(); |
| |
| if (MatchEnd()) { |
| // Whitespace only. |
| return Command::Empty(); |
| } else if (MatchLiteral(Command::kResolve)) { |
| if (!MatchWhitespace()) { |
| return Command::Malformed(); |
| } |
| |
| std::string host_name; |
| std::string service_name; |
| std::string instance_name; |
| if (MatchHostName(host_name)) { |
| auto command = Command::ResolveHost(host_name); |
| if (MatchOptions(command)) { |
| return command; |
| } else { |
| return Command::Help(CommandVerb::kResolveHost); |
| } |
| } else if (MatchInstanceName(instance_name, service_name)) { |
| auto command = Command::ResolveInstance(instance_name, service_name); |
| if (MatchOptions(command)) { |
| return command; |
| } else { |
| return Command::Help(CommandVerb::kResolveInstance); |
| } |
| } else { |
| return Command::Help(CommandVerb::kResolveHost); |
| } |
| } else if (MatchLiteral(Command::kSubscribe)) { |
| if (!MatchWhitespace()) { |
| return Command::Malformed(); |
| } |
| |
| std::string host_name; |
| std::string service_name; |
| if (MatchHostName(host_name)) { |
| auto command = Command::SubscribeHost(host_name); |
| if (MatchOptions(command)) { |
| return command; |
| } else { |
| return Command::Help(CommandVerb::kSubscribeHost); |
| } |
| } else if (MatchServiceName(service_name)) { |
| auto command = Command::SubscribeService(service_name); |
| if (MatchOptions(command)) { |
| return command; |
| } else { |
| return Command::Help(CommandVerb::kSubscribeService); |
| } |
| } else if (MatchLiteral(Command::kAllServices)) { |
| auto command = Command::SubscribeService(Command::kAllServices); |
| if (MatchOptions(command)) { |
| return command; |
| } else { |
| return Command::Help(CommandVerb::kSubscribeService); |
| } |
| } else { |
| return Command::Help(CommandVerb::kSubscribeHost); |
| } |
| } else if (MatchLiteral(Command::kPublish)) { |
| if (!MatchWhitespace()) { |
| return Command::Malformed(); |
| } |
| |
| std::string host_name; |
| std::string service_name; |
| std::string instance_name; |
| if (MatchHostName(host_name)) { |
| std::vector<inet::IpAddress> addresses; |
| if (!MatchWhitespace() || !(MatchAddresses(addresses))) { |
| return Command::Help(CommandVerb::kPublishHost); |
| } |
| |
| auto command = Command::PublishHost(host_name, addresses); |
| if (MatchOptions(command)) { |
| return command; |
| } else { |
| return Command::Help(CommandVerb::kPublishHost); |
| } |
| } else if (MatchInstanceName(instance_name, service_name)) { |
| uint16_t port; |
| std::vector<std::string> text; |
| |
| if (!MatchWhitespace() || !(MatchUint16(port)) || !MatchWhitespace() || !(MatchText(text))) { |
| return Command::Help(CommandVerb::kPublishInstance); |
| } |
| |
| auto command = Command::PublishInstance(instance_name, service_name, port, text); |
| if (MatchOptions(command)) { |
| return command; |
| } else { |
| return Command::Help(CommandVerb::kPublishInstance); |
| } |
| } else { |
| return Command::Help(CommandVerb::kUnpublishHost); |
| } |
| } else if (MatchLiteral(Command::kUnsubscribe)) { |
| if (!MatchWhitespace()) { |
| return Command::Malformed(); |
| } |
| |
| std::string host_name; |
| std::string service_name; |
| if (MatchHostName(host_name)) { |
| auto command = Command::UnsubscribeHost(host_name); |
| if (MatchOptions(command)) { |
| return command; |
| } else { |
| return Command::Help(CommandVerb::kUnsubscribeHost); |
| } |
| } else if (MatchServiceName(service_name)) { |
| auto command = Command::UnsubscribeService(service_name); |
| if (MatchOptions(command)) { |
| return command; |
| } else { |
| return Command::Help(CommandVerb::kUnsubscribeService); |
| } |
| } else if (MatchLiteral(Command::kAllServices)) { |
| auto command = Command::UnsubscribeService(Command::kAllServices); |
| if (MatchOptions(command)) { |
| return command; |
| } else { |
| return Command::Help(CommandVerb::kSubscribeService); |
| } |
| } else { |
| return Command::Help(CommandVerb::kUnsubscribeHost); |
| } |
| } else if (MatchLiteral(Command::kUnpublish)) { |
| if (!MatchWhitespace()) { |
| return Command::Malformed(); |
| } |
| |
| std::string host_name; |
| std::string service_name; |
| std::string instance_name; |
| if (MatchHostName(host_name)) { |
| auto command = Command::UnpublishHost(host_name); |
| if (MatchOptions(command)) { |
| return command; |
| } else { |
| return Command::Help(CommandVerb::kUnpublishHost); |
| } |
| } else if (MatchInstanceName(instance_name, service_name)) { |
| auto command = Command::UnpublishInstance(instance_name, service_name); |
| if (MatchOptions(command)) { |
| return command; |
| } else { |
| return Command::Help(CommandVerb::kUnpublishHost); |
| } |
| } else { |
| return Command::Help(CommandVerb::kUnpublishHost); |
| } |
| } else if (MatchLiteral(Command::kHelp)) { |
| if (MatchWhitespaceEnd()) { |
| return Command::Help(); |
| } |
| |
| if (!MatchWhitespace()) { |
| return Command::Malformed(); |
| } |
| |
| // Here we are using e.g. |CommandVerb::kResolveHost| to specify help for both the 'resolve' |
| // commands (both kResolveHost or kResolveInstance). |
| if (MatchLiteral(Command::kResolve)) { |
| return MatchWhitespaceEnd() ? Command::Help(CommandVerb::kResolveHost) : Command::Malformed(); |
| } else if (MatchLiteral(Command::kSubscribe)) { |
| return MatchWhitespaceEnd() ? Command::Help(CommandVerb::kSubscribeHost) |
| : Command::Malformed(); |
| } else if (MatchLiteral(Command::kPublish)) { |
| return MatchWhitespaceEnd() ? Command::Help(CommandVerb::kPublishHost) : Command::Malformed(); |
| } else if (MatchLiteral(Command::kUnsubscribe)) { |
| return MatchWhitespaceEnd() ? Command::Help(CommandVerb::kUnsubscribeHost) |
| : Command::Malformed(); |
| return Command::Help(CommandVerb::kUnsubscribeHost); |
| } else if (MatchLiteral(Command::kUnpublish)) { |
| return MatchWhitespaceEnd() ? Command::Help(CommandVerb::kUnpublishHost) |
| : Command::Malformed(); |
| } else { |
| return Command::Malformed(); |
| } |
| } else if (MatchLiteral(Command::kQuit)) { |
| if (MatchWhitespaceEnd()) { |
| return Command::Quit(); |
| } else { |
| return Command::Malformed(); |
| } |
| } else { |
| return Command::Malformed(); |
| } |
| } |
| |
| bool CommandParser::MatchOptions(Command& command) { |
| size_t saved_chars_remaining = chars_remaining(); |
| |
| while (true) { |
| if (MatchWhitespaceEnd()) { |
| return true; |
| } |
| |
| if (!MatchWhitespace()) { |
| break; |
| } |
| |
| if (!MatchLiteral(kOptionPrefix)) { |
| break; |
| } |
| |
| if (MatchLiteral(kTimeoutOption)) { |
| switch (command.verb()) { |
| case CommandVerb::kResolveHost: |
| case CommandVerb::kResolveInstance: |
| break; |
| default: |
| SetCharsRemaining(saved_chars_remaining); |
| return false; |
| } |
| |
| if (!MatchLiteral(kOptionSeparator) || !MatchSeconds(command.timeout_)) { |
| break; |
| } |
| } else if (MatchLiteral(kMediaOption)) { |
| switch (command.verb()) { |
| case CommandVerb::kResolveHost: |
| case CommandVerb::kResolveInstance: |
| case CommandVerb::kSubscribeHost: |
| case CommandVerb::kSubscribeService: |
| case CommandVerb::kPublishHost: |
| case CommandVerb::kPublishInstance: |
| break; |
| default: |
| SetCharsRemaining(saved_chars_remaining); |
| return false; |
| } |
| |
| if (!MatchLiteral(kOptionSeparator) || !MatchMedia(command.media_)) { |
| break; |
| } |
| } else if (MatchLiteral(kIpVersionsOption)) { |
| switch (command.verb()) { |
| case CommandVerb::kResolveHost: |
| case CommandVerb::kResolveInstance: |
| case CommandVerb::kSubscribeHost: |
| case CommandVerb::kSubscribeService: |
| case CommandVerb::kPublishHost: |
| case CommandVerb::kPublishInstance: |
| break; |
| default: |
| SetCharsRemaining(saved_chars_remaining); |
| return false; |
| } |
| |
| if (!MatchLiteral(kOptionSeparator) || !MatchIpVersions(command.ip_versions_)) { |
| break; |
| } |
| } else if (MatchLiteral(kExcludeLocalOption)) { |
| switch (command.verb()) { |
| case CommandVerb::kResolveHost: |
| case CommandVerb::kResolveInstance: |
| case CommandVerb::kSubscribeHost: |
| case CommandVerb::kSubscribeService: |
| break; |
| default: |
| SetCharsRemaining(saved_chars_remaining); |
| return false; |
| } |
| |
| if (!MatchLiteral(kOptionSeparator) || !MatchBool(command.exclude_local_)) { |
| break; |
| } |
| } else if (MatchLiteral(kExcludeLocalProxyOption)) { |
| switch (command.verb()) { |
| case CommandVerb::kResolveHost: |
| case CommandVerb::kResolveInstance: |
| case CommandVerb::kSubscribeHost: |
| case CommandVerb::kSubscribeService: |
| break; |
| default: |
| SetCharsRemaining(saved_chars_remaining); |
| return false; |
| } |
| |
| if (!MatchLiteral(kOptionSeparator) || !MatchBool(command.exclude_local_proxies_)) { |
| break; |
| } |
| } else if (MatchLiteral(kProbeOption)) { |
| switch (command.verb()) { |
| case CommandVerb::kPublishHost: |
| case CommandVerb::kPublishInstance: |
| break; |
| default: |
| SetCharsRemaining(saved_chars_remaining); |
| return false; |
| } |
| |
| if (!MatchLiteral(kOptionSeparator) || !MatchBool(command.probe_)) { |
| break; |
| } |
| } else if (MatchLiteral(kSrvPriorityOption)) { |
| if (command.verb() != CommandVerb::kPublishInstance) { |
| break; |
| } |
| |
| if (!MatchLiteral(kOptionSeparator) || !MatchUint16(command.srv_priority_)) { |
| break; |
| } |
| } else if (MatchLiteral(kSrvWeightOption)) { |
| if (command.verb() != CommandVerb::kPublishInstance) { |
| break; |
| } |
| |
| if (!MatchLiteral(kOptionSeparator) || !MatchUint16(command.srv_weight_)) { |
| break; |
| } |
| } else if (MatchLiteral(kPtrTtlOption)) { |
| if (command.verb() != CommandVerb::kPublishInstance) { |
| break; |
| } |
| |
| if (!MatchLiteral(kOptionSeparator) || !MatchSeconds(command.ptr_ttl_)) { |
| break; |
| } |
| } else if (MatchLiteral(kSrvTtlOption)) { |
| if (command.verb() != CommandVerb::kPublishInstance) { |
| break; |
| } |
| |
| if (!MatchLiteral(kOptionSeparator) || !MatchSeconds(command.srv_ttl_)) { |
| break; |
| } |
| } else if (MatchLiteral(kTxtTtlOption)) { |
| if (command.verb() != CommandVerb::kPublishInstance) { |
| break; |
| } |
| |
| if (!MatchLiteral(kOptionSeparator) || !MatchSeconds(command.txt_ttl_)) { |
| break; |
| } |
| } else if (MatchLiteral(kProxyHostOption)) { |
| switch (command.verb()) { |
| case CommandVerb::kPublishInstance: |
| case CommandVerb::kUnpublishInstance: |
| break; |
| default: |
| SetCharsRemaining(saved_chars_remaining); |
| return false; |
| } |
| |
| if (!MatchLiteral(kOptionSeparator) || !MatchHostName(command.proxy_host_name_)) { |
| break; |
| } |
| } |
| } |
| |
| SetCharsRemaining(saved_chars_remaining); |
| return false; |
| } |
| |
| bool CommandParser::MatchHostName(std::string& value_out) { |
| size_t saved_chars_remaining = chars_remaining(); |
| |
| std::string label; |
| if (!MatchDnsLabel(label)) { |
| return false; |
| } |
| |
| std::string value = std::move(label); |
| |
| while (!MatchEnd() && value.size() <= kMaxHostNameLength) { |
| if (!MatchLiteral(kLabelSeparator)) { |
| break; |
| } |
| |
| if (MatchLiteral(kHostSuffix)) { |
| value_out = value; |
| return true; |
| } |
| |
| value.append(kLabelSeparator); |
| |
| if (!MatchDnsLabel(label)) { |
| break; |
| } |
| |
| value.append(label); |
| } |
| |
| SetCharsRemaining(saved_chars_remaining); |
| return false; |
| } |
| |
| bool CommandParser::MatchInstanceName(std::string& instance_name_out, |
| std::string& service_name_out) { |
| size_t saved_chars_remaining = chars_remaining(); |
| |
| std::string instance_name; |
| if (MatchDnsLabel(instance_name) && MatchLiteral(kLabelSeparator) && |
| MatchServiceName(service_name_out)) { |
| instance_name_out = std::move(instance_name); |
| return true; |
| } |
| |
| SetCharsRemaining(saved_chars_remaining); |
| return false; |
| } |
| |
| bool CommandParser::MatchServiceName(std::string& value_out) { |
| size_t saved_chars_remaining = chars_remaining(); |
| |
| if (!MatchLiteral("_")) { |
| return false; |
| } |
| |
| std::string label; |
| if (MatchDnsLabel(label, kMaxServiceNameLabelLength - 1)) { |
| if (MatchLiteral(kTcpSuffix)) { |
| value_out = "_"; |
| value_out.append(label); |
| value_out.append(kTcpSuffix); |
| return true; |
| } else if (MatchLiteral(kUdpSuffix)) { |
| value_out = "_"; |
| value_out.append(label); |
| value_out.append(kUdpSuffix); |
| return true; |
| } |
| } |
| |
| SetCharsRemaining(saved_chars_remaining); |
| return false; |
| } |
| |
| bool CommandParser::MatchUint16(uint16_t& value_out) { |
| size_t saved_chars_remaining = chars_remaining(); |
| |
| uint8_t digit; |
| if (!MatchDigit(digit)) { |
| return false; |
| } |
| |
| uint16_t value = digit; |
| while (MatchDigit(digit)) { |
| if (value > (std::numeric_limits<uint16_t>::max() - digit) / 10) { |
| // Too large. |
| SetCharsRemaining(saved_chars_remaining); |
| return false; |
| } |
| |
| value = value * 10 + digit; |
| } |
| |
| value_out = value; |
| return true; |
| } |
| |
| bool CommandParser::MatchText(std::vector<std::string>& value_out) { |
| std::vector<std::string> value; |
| |
| while (true) { |
| std::string text_string; |
| if (!MatchTextString(text_string)) { |
| break; |
| } |
| |
| value.push_back(text_string); |
| MatchWhitespace(); |
| } |
| |
| value_out = std::move(value); |
| return true; |
| } |
| |
| bool CommandParser::MatchTextString(std::string& value_out) { |
| size_t saved_chars_remaining = chars_remaining(); |
| |
| std::string terminator = "\""; |
| if (!MatchLiteral(terminator) && (terminator = "'", !MatchLiteral(terminator))) { |
| return false; |
| } |
| |
| auto start = remaining_chars(); |
| while (!MatchLiteral(terminator)) { |
| if (MatchEnd()) { |
| SetCharsRemaining(saved_chars_remaining); |
| return false; |
| } |
| |
| ConsumeChars(1); |
| } |
| |
| value_out = std::string(start, (remaining_chars() - start) - 1); |
| return true; |
| } |
| |
| bool CommandParser::MatchAddresses(std::vector<inet::IpAddress>& value_out) { |
| size_t saved_chars_remaining = chars_remaining(); |
| |
| inet::IpAddress address; |
| if (!MatchAddress(address)) { |
| return false; |
| } |
| |
| std::vector<inet::IpAddress> value; |
| value.push_back(address); |
| |
| while (MatchLiteral(",")) { |
| if (!MatchAddress(address)) { |
| SetCharsRemaining(saved_chars_remaining); |
| return false; |
| } |
| |
| value.push_back(address); |
| } |
| |
| value_out = std::move(value); |
| return true; |
| } |
| |
| bool CommandParser::MatchAddress(inet::IpAddress& value_out) { |
| auto pair = |
| inet::IpAddress::FromStringView(std::string_view(remaining_chars(), chars_remaining())); |
| if (!pair.first.is_valid()) { |
| return false; |
| } |
| |
| value_out = pair.first; |
| ConsumeChars(pair.second); |
| return true; |
| } |
| |
| bool CommandParser::MatchDnsLabel(std::string& value_out, size_t max_length) { |
| size_t saved_chars_remaining = chars_remaining(); |
| |
| std::string value; |
| |
| while (!MatchEnd() && *remaining_chars() != '.' && !isspace(*remaining_chars())) { |
| if (value.size() == max_length) { |
| // Too long. |
| value.clear(); |
| break; |
| } |
| |
| value.push_back(*remaining_chars()); |
| ConsumeChars(1); |
| } |
| |
| if (value.empty()) { |
| SetCharsRemaining(saved_chars_remaining); |
| return false; |
| } |
| |
| value_out = value; |
| return true; |
| } |
| |
| bool CommandParser::MatchSeconds(zx::duration& value_out) { |
| size_t saved_chars_remaining = chars_remaining(); |
| |
| uint8_t digit; |
| if (!MatchDigit(digit)) { |
| return false; |
| } |
| |
| uint32_t value = digit; |
| while (MatchDigit(digit)) { |
| if (value > (std::numeric_limits<uint32_t>::max() - digit) / 10) { |
| // Too large. |
| SetCharsRemaining(saved_chars_remaining); |
| return false; |
| } |
| |
| value = value * 10 + digit; |
| } |
| |
| value_out = zx::sec(value); |
| return true; |
| } |
| |
| bool CommandParser::MatchMedia(fuchsia::net::mdns::Media& value_out) { |
| size_t saved_chars_remaining = chars_remaining(); |
| |
| fuchsia::net::mdns::Media value; |
| if (!MatchMedium(value)) { |
| return false; |
| } |
| |
| while (MatchLiteral(kValueSeparator)) { |
| fuchsia::net::mdns::Media v; |
| if (!MatchMedium(v)) { |
| SetCharsRemaining(saved_chars_remaining); |
| return false; |
| } |
| |
| value |= v; |
| } |
| |
| value_out = value; |
| return true; |
| } |
| |
| bool CommandParser::MatchMedium(fuchsia::net::mdns::Media& value_out) { |
| if (MatchLiteral(kMediaValueWired)) { |
| value_out = fuchsia::net::mdns::Media::WIRED; |
| return true; |
| } |
| |
| if (MatchLiteral(kMediaValueWireless)) { |
| value_out = fuchsia::net::mdns::Media::WIRELESS; |
| return true; |
| } |
| |
| return false; |
| } |
| |
| bool CommandParser::MatchIpVersions(fuchsia::net::mdns::IpVersions& value_out) { |
| size_t saved_chars_remaining = chars_remaining(); |
| |
| fuchsia::net::mdns::IpVersions value; |
| if (!MatchIpVersion(value)) { |
| return false; |
| } |
| |
| while (MatchLiteral(kValueSeparator)) { |
| fuchsia::net::mdns::IpVersions v; |
| if (!MatchIpVersion(v)) { |
| SetCharsRemaining(saved_chars_remaining); |
| return false; |
| } |
| |
| value |= v; |
| } |
| |
| value_out = value; |
| return true; |
| } |
| |
| bool CommandParser::MatchIpVersion(fuchsia::net::mdns::IpVersions& value_out) { |
| if (MatchLiteral(kIpVersionsValueV4)) { |
| value_out = fuchsia::net::mdns::IpVersions::V4; |
| return true; |
| } |
| |
| if (MatchLiteral(kIpVersionsValueV6)) { |
| value_out = fuchsia::net::mdns::IpVersions::V6; |
| return true; |
| } |
| |
| return false; |
| } |
| |
| bool CommandParser::MatchBool(bool& value_out) { |
| if (MatchLiteral(kBoolValueTrue)) { |
| value_out = true; |
| return true; |
| } |
| |
| if (MatchLiteral(kBoolValueFalse)) { |
| value_out = false; |
| return true; |
| } |
| |
| return false; |
| } |
| |
| bool CommandParser::MatchLiteral(const std::string& literal) { |
| if (chars_remaining() < literal.size()) { |
| return false; |
| } |
| |
| if (strncmp(literal.data(), remaining_chars(), literal.size()) != 0) { |
| return false; |
| } |
| |
| ConsumeChars(literal.size()); |
| return true; |
| } |
| |
| bool CommandParser::MatchDigit(uint8_t& value_out) { |
| if (MatchEnd() || !isdigit(*remaining_chars())) { |
| return false; |
| } |
| |
| value_out = *remaining_chars() - '0'; |
| ConsumeChars(1); |
| |
| return true; |
| } |
| |
| bool CommandParser::MatchWhitespace() { |
| if (MatchEnd()) { |
| return false; |
| } |
| |
| if (!isspace(*remaining_chars())) { |
| return false; |
| } |
| |
| for (ConsumeChars(1); !MatchEnd() && isspace(*remaining_chars()); ConsumeChars(1)) { |
| } |
| |
| return true; |
| } |
| |
| bool CommandParser::MatchWhitespaceEnd() { |
| size_t saved_chars_remaining = chars_remaining(); |
| |
| MatchWhitespace(); |
| |
| if (MatchEnd()) { |
| return true; |
| } |
| |
| SetCharsRemaining(saved_chars_remaining); |
| return false; |
| } |
| |
| // static |
| void Command::ShowHelp(CommandVerb command_verb) { |
| switch (command_verb) { |
| case CommandVerb::kResolveHost: |
| case CommandVerb::kResolveInstance: |
| std::cout << "resolve <host name>\n"; |
| std::cout << " resolves a host\n"; |
| std::cout << " <host name>: name of host including `.local.` suffix\n"; |
| std::cout << " --timeout=<seconds> default: '3'\n"; |
| std::cout << " --media=<media> default: `wired,wireless`\n"; |
| std::cout << " --ip-versions=<versions> default: `4,6`\n"; |
| std::cout << " --exclude-local=<true|false> default: `false`\n"; |
| std::cout << " --exclude-local-proxies=<true|false> default: `false`\n"; |
| std::cout << "\n"; |
| std::cout << "resolve <instance name>\n"; |
| std::cout << " resolves a service instance\n"; |
| std::cout << " <instance name>: instance.service including `._tcp.` or `._udp.` suffix\n"; |
| std::cout << " --timeout=<seconds> default: '3'\n"; |
| std::cout << " --media=<media> default: `wired,wireless`\n"; |
| std::cout << " --ip-versions=<versions> default: `4,6`\n"; |
| std::cout << " --exclude-local=<true|false> default: `false`\n"; |
| std::cout << " --exclude-local-proxies=<true|false> default: `false`\n"; |
| break; |
| case CommandVerb::kSubscribeHost: |
| case CommandVerb::kSubscribeService: |
| std::cout << "subscribe <host name>\n"; |
| std::cout << " subscribes to a host\n"; |
| std::cout << " <host name>: name of host including `.local.` suffix\n"; |
| std::cout << " --media=<media> default: `wired,wireless`\n"; |
| std::cout << " --ip-versions=<versions> default: `4,6`\n"; |
| std::cout << " --exclude-local=<true|false> default: `false`\n"; |
| std::cout << " --exclude-local-proxies=<true|false> default: `false`\n"; |
| std::cout << "\n"; |
| std::cout << "subscribe <service name>\n"; |
| std::cout << " subscribes to a service\n"; |
| std::cout << " <service name>: name of service including `._tcp.` or `._udp.` suffix\n"; |
| std::cout << " --media=<media> default: `wired,wireless`\n"; |
| std::cout << " --ip-versions=<versions> default: `4,6`\n"; |
| std::cout << " --exclude-local=<true|false> default: `false`\n"; |
| std::cout << " --exclude-local-proxies=<true|false> default: `false`\n"; |
| std::cout << "\n"; |
| std::cout << "subscribe all\n"; |
| std::cout << " subscribes to all services\n"; |
| std::cout << " --media=<media> default: `wired,wireless`\n"; |
| std::cout << " --ip-versions=<versions> default: `4,6`\n"; |
| std::cout << " --exclude-local=<true|false> default: `false`\n"; |
| std::cout << " --exclude-local-proxies=<true|false> default: `false`\n"; |
| break; |
| case CommandVerb::kPublishHost: |
| case CommandVerb::kPublishInstance: |
| std::cout << "publish <host name> <addresses>\n"; |
| std::cout << " publishes a proxy host\n"; |
| std::cout << " <host name>: name of proxy host including `.local.` suffix\n"; |
| std::cout << " <addresses>: IP addresses of proxy host\n"; |
| std::cout << " --probe=<true|false> default: `true`\n"; |
| std::cout << " --media=<media> default: `wired,wireless`\n"; |
| std::cout << " --ip-versions=<versions> default: `4,6`\n"; |
| std::cout << "\n"; |
| std::cout << "publish <instance name> <port> <text>*\n"; |
| std::cout << " publishes to a service instance\n"; |
| std::cout << " <instance name>: instance.service including `._tcp.` or `._udp.` suffix\n"; |
| std::cout << " <port>: port number (decimal)\n"; |
| std::cout << " <text>: text string (in single or double quotes)\n"; |
| std::cout << " --probe=<true|false> default: `true`\n"; |
| std::cout << " --media=<media> default: `wired,wireless`\n"; |
| std::cout << " --ip-versions=<versions> default: `4,6`\n"; |
| std::cout << " --srv-priority=<uint16> default: `0`\n"; |
| std::cout << " --srv-weight=<uint16> default: `0`\n"; |
| std::cout << " --ptr-ttl=<seconds> default: `4500`\n"; |
| std::cout << " --srv-ttl=<seconds> default: `120`\n"; |
| std::cout << " --txt-ttl=<seconds> default: `4500`\n"; |
| std::cout << " --proxy-host=<host name> default: none (local)\n"; |
| break; |
| case CommandVerb::kUnsubscribeHost: |
| case CommandVerb::kUnsubscribeService: |
| std::cout << "unsubscribe <host name>\n"; |
| std::cout << " cancels 'subscribe <host name>'\n"; |
| std::cout << " <host name>: name of host including `.local.` suffix\n"; |
| std::cout << "\n"; |
| std::cout << "unsubscribe <service name>\n"; |
| std::cout << " cancels 'subscribe <service name>'\n"; |
| std::cout << " <service name>: name of service including `._tcp.` or `._udp.` suffix\n"; |
| std::cout << "\n"; |
| std::cout << "unsubscribe all\n"; |
| std::cout << " cancels 'subscribe all'\n"; |
| break; |
| case CommandVerb::kUnpublishHost: |
| case CommandVerb::kUnpublishInstance: |
| std::cout << "unpublish <host name>\n"; |
| std::cout << " cancels `publish <host name> ...`\n"; |
| std::cout << " <host name>: name of proxy host including `.local.` suffix\n"; |
| std::cout << "\n"; |
| std::cout << "unpublish <instance name>\n"; |
| std::cout << " cancels `publish <instance name> ...`\n"; |
| std::cout << " <instance name>: instance.service including `._tcp.` or `._udp.` suffix\n"; |
| std::cout << " --proxy-host=<host name> default: none (local)\n"; |
| break; |
| case CommandVerb::kHelp: |
| case CommandVerb::kQuit: |
| case CommandVerb::kEmpty: |
| case CommandVerb::kMalformed: |
| std::cout << "commands:\n"; |
| std::cout << " resolve <host name> | <instance name>\n"; |
| std::cout << " subscribe <host name> | <service name>\n"; |
| std::cout << " publish ( <host name> <addresses>) | ( <instance name> <port> <text>) \n"; |
| std::cout << " unsubscribe <host name> | <service_name>\n"; |
| std::cout << " unpublish <host name> | <instance name>\n"; |
| std::cout << " quit\n"; |
| std::cout << " help\n"; |
| std::cout << " help <command>\n"; |
| break; |
| } |
| } |
| |
| void Command::ShowHelp() const { ShowHelp(help_verb()); } |
| |
| } // namespace mdns |
