| // Copyright 2016 The ChromiumOS Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "patchpanel/dbus/client.h" |
| |
| #include <fcntl.h> |
| |
| #include <algorithm> |
| #include <optional> |
| #include <ostream> |
| |
| #include <base/functional/bind.h> |
| #include <base/logging.h> |
| #include <base/memory/weak_ptr.h> |
| #include <base/strings/string_util.h> |
| #include <base/synchronization/waitable_event.h> |
| #include <base/task/bind_post_task.h> |
| #include <base/time/time.h> |
| #include <brillo/errors/error.h> |
| #include <brillo/http/http_transport.h> |
| #include <chromeos/dbus/service_constants.h> |
| #include <chromeos/net-base/technology.h> |
| #include <dbus/message.h> |
| #include <dbus/object_path.h> |
| #include <patchpanel/proto_bindings/patchpanel_service.pb.h> |
| #include <patchpanel/proto_bindings/traffic_annotation.pb.h> |
| |
| #include "patchpanel/dbus-proxies.h" |
| |
| namespace patchpanel { |
| |
| namespace { |
| |
| using org::chromium::PatchPanelProxyInterface; |
| |
| patchpanel::TrafficCounter::Source ConvertTrafficSource( |
| Client::TrafficSource source) { |
| switch (source) { |
| case Client::TrafficSource::kUnknown: |
| return patchpanel::TrafficCounter::UNKNOWN; |
| case Client::TrafficSource::kChrome: |
| return patchpanel::TrafficCounter::CHROME; |
| case Client::TrafficSource::kUser: |
| return patchpanel::TrafficCounter::USER; |
| case Client::TrafficSource::kUpdateEngine: |
| return patchpanel::TrafficCounter::UPDATE_ENGINE; |
| case Client::TrafficSource::kSystem: |
| return patchpanel::TrafficCounter::SYSTEM; |
| case Client::TrafficSource::kVpn: |
| return patchpanel::TrafficCounter::VPN; |
| case Client::TrafficSource::kArc: |
| return patchpanel::TrafficCounter::ARC; |
| case Client::TrafficSource::kBorealisVM: |
| return patchpanel::TrafficCounter::BOREALIS_VM; |
| case Client::TrafficSource::kBruschettaVM: |
| return patchpanel::TrafficCounter::BRUSCHETTA_VM; |
| case Client::TrafficSource::kCrostiniVM: |
| return patchpanel::TrafficCounter::CROSTINI_VM; |
| case Client::TrafficSource::kParallelsVM: |
| return patchpanel::TrafficCounter::PARALLELS_VM; |
| case Client::TrafficSource::kTethering: |
| return patchpanel::TrafficCounter::TETHERING; |
| case Client::TrafficSource::kWiFiDirect: |
| return patchpanel::TrafficCounter::WIFI_DIRECT; |
| case Client::TrafficSource::kWiFiLOHS: |
| return patchpanel::TrafficCounter::WIFI_LOHS; |
| } |
| } |
| |
| Client::TrafficSource ConvertTrafficSource( |
| patchpanel::TrafficCounter::Source source) { |
| switch (source) { |
| case patchpanel::TrafficCounter::CHROME: |
| return Client::TrafficSource::kChrome; |
| case patchpanel::TrafficCounter::USER: |
| return Client::TrafficSource::kUser; |
| case patchpanel::TrafficCounter::UPDATE_ENGINE: |
| return Client::TrafficSource::kUpdateEngine; |
| case patchpanel::TrafficCounter::SYSTEM: |
| return Client::TrafficSource::kSystem; |
| case patchpanel::TrafficCounter::VPN: |
| return Client::TrafficSource::kVpn; |
| case patchpanel::TrafficCounter::ARC: |
| return Client::TrafficSource::kArc; |
| case patchpanel::TrafficCounter::BOREALIS_VM: |
| return Client::TrafficSource::kBorealisVM; |
| case patchpanel::TrafficCounter::BRUSCHETTA_VM: |
| return Client::TrafficSource::kBruschettaVM; |
| case patchpanel::TrafficCounter::CROSTINI_VM: |
| return Client::TrafficSource::kCrostiniVM; |
| case patchpanel::TrafficCounter::PARALLELS_VM: |
| return Client::TrafficSource::kParallelsVM; |
| case patchpanel::TrafficCounter::TETHERING: |
| return Client::TrafficSource::kTethering; |
| case patchpanel::TrafficCounter::WIFI_DIRECT: |
| return Client::TrafficSource::kWiFiDirect; |
| case patchpanel::TrafficCounter::WIFI_LOHS: |
| return Client::TrafficSource::kWiFiLOHS; |
| default: |
| return Client::TrafficSource::kUnknown; |
| } |
| } |
| |
| patchpanel::NeighborReachabilityEventSignal::Role ConvertNeighborRole( |
| Client::NeighborRole role) { |
| switch (role) { |
| case Client::NeighborRole::kGateway: |
| return patchpanel::NeighborReachabilityEventSignal::GATEWAY; |
| case Client::NeighborRole::kDnsServer: |
| return patchpanel::NeighborReachabilityEventSignal::DNS_SERVER; |
| case Client::NeighborRole::kGatewayAndDnsServer: |
| return patchpanel::NeighborReachabilityEventSignal:: |
| GATEWAY_AND_DNS_SERVER; |
| } |
| } |
| |
| patchpanel::NeighborReachabilityEventSignal::EventType ConvertNeighborStatus( |
| Client::NeighborStatus status) { |
| switch (status) { |
| case Client::NeighborStatus::kFailed: |
| return patchpanel::NeighborReachabilityEventSignal::FAILED; |
| case Client::NeighborStatus::kReachable: |
| return patchpanel::NeighborReachabilityEventSignal::REACHABLE; |
| } |
| } |
| |
| patchpanel::ModifyPortRuleRequest::Operation ConvertFirewallRequestOperation( |
| Client::FirewallRequestOperation op) { |
| switch (op) { |
| case Client::FirewallRequestOperation::kCreate: |
| return ModifyPortRuleRequest::CREATE; |
| case Client::FirewallRequestOperation::kDelete: |
| return ModifyPortRuleRequest::DELETE; |
| } |
| } |
| |
| patchpanel::ModifyPortRuleRequest::RuleType ConvertFirewallRequestType( |
| Client::FirewallRequestType type) { |
| switch (type) { |
| case Client::FirewallRequestType::kAccess: |
| return ModifyPortRuleRequest::ACCESS; |
| case Client::FirewallRequestType::kLockdown: |
| return ModifyPortRuleRequest::LOCKDOWN; |
| case Client::FirewallRequestType::kForwarding: |
| return ModifyPortRuleRequest::FORWARDING; |
| } |
| } |
| |
| patchpanel::ModifyPortRuleRequest::Protocol ConvertFirewallRequestProtocol( |
| Client::FirewallRequestProtocol protocol) { |
| switch (protocol) { |
| case Client::FirewallRequestProtocol::kTcp: |
| return ModifyPortRuleRequest::TCP; |
| case Client::FirewallRequestProtocol::kUdp: |
| return ModifyPortRuleRequest::UDP; |
| } |
| } |
| |
| patchpanel::SetDnsRedirectionRuleRequest::RuleType |
| ConvertDnsRedirectionRequestType(Client::DnsRedirectionRequestType type) { |
| switch (type) { |
| case Client::DnsRedirectionRequestType::kDefault: |
| return patchpanel::SetDnsRedirectionRuleRequest::DEFAULT; |
| case Client::DnsRedirectionRequestType::kArc: |
| return patchpanel::SetDnsRedirectionRuleRequest::ARC; |
| case Client::DnsRedirectionRequestType::kUser: |
| return patchpanel::SetDnsRedirectionRuleRequest::USER; |
| case Client::DnsRedirectionRequestType::kExcludeDestination: |
| return patchpanel::SetDnsRedirectionRuleRequest::EXCLUDE_DESTINATION; |
| } |
| } |
| |
| patchpanel::SetFeatureFlagRequest::FeatureFlag ConvertFeatureFlag( |
| Client::FeatureFlag flag) { |
| switch (flag) { |
| case Client::FeatureFlag::kWiFiQoS: |
| return patchpanel::SetFeatureFlagRequest::FeatureFlag:: |
| SetFeatureFlagRequest_FeatureFlag_WIFI_QOS; |
| case Client::FeatureFlag::kClat: |
| return patchpanel::SetFeatureFlagRequest::FeatureFlag:: |
| SetFeatureFlagRequest_FeatureFlag_CLAT; |
| } |
| } |
| |
| std::optional<net_base::IPv4CIDR> ConvertIPv4Subnet(const IPv4Subnet& in) { |
| return net_base::IPv4CIDR::CreateFromBytesAndPrefix( |
| in.addr(), static_cast<int>(in.prefix_len())); |
| } |
| |
| std::optional<Client::TrafficCounter> ConvertTrafficCounter( |
| const TrafficCounter& in) { |
| auto out = std::make_optional<Client::TrafficCounter>(); |
| out->traffic.rx_bytes = in.rx_bytes(); |
| out->traffic.tx_bytes = in.tx_bytes(); |
| out->traffic.rx_packets = in.rx_packets(); |
| out->traffic.tx_packets = in.tx_packets(); |
| out->ifname = in.device(); |
| out->source = ConvertTrafficSource(in.source()); |
| switch (in.ip_family()) { |
| case patchpanel::TrafficCounter::IPV4: |
| out->ip_family = Client::IPFamily::kIPv4; |
| break; |
| case patchpanel::TrafficCounter::IPV6: |
| out->ip_family = Client::IPFamily::kIPv6; |
| break; |
| default: |
| LOG(ERROR) << __func__ << ": Unknown IpFamily " |
| << patchpanel::TrafficCounter::IpFamily_Name(in.ip_family()); |
| return std::nullopt; |
| } |
| return out; |
| } |
| |
| std::optional<Client::VirtualDevice> ConvertVirtualDevice( |
| const NetworkDevice& in) { |
| auto out = std::make_optional<Client::VirtualDevice>(); |
| out->ifname = in.ifname(); |
| out->phys_ifname = in.phys_ifname(); |
| out->guest_ifname = in.guest_ifname(); |
| out->ipv4_addr = net_base::IPv4Address(in.ipv4_addr()); |
| out->host_ipv4_addr = net_base::IPv4Address(in.host_ipv4_addr()); |
| out->ipv4_subnet = ConvertIPv4Subnet(in.ipv4_subnet()); |
| |
| out->dns_proxy_ipv4_addr = |
| net_base::IPv4Address::CreateFromBytes(in.dns_proxy_ipv4_addr()); |
| out->dns_proxy_ipv6_addr = |
| net_base::IPv6Address::CreateFromBytes(in.dns_proxy_ipv6_addr()); |
| switch (in.technology_type()) { |
| case patchpanel::NetworkDevice::CELLULAR: |
| out->technology = net_base::Technology::kCellular; |
| break; |
| case patchpanel::NetworkDevice::ETHERNET: |
| out->technology = net_base::Technology::kEthernet; |
| break; |
| case patchpanel::NetworkDevice::WIFI: |
| out->technology = net_base::Technology::kWiFi; |
| break; |
| default: |
| out->technology = std::nullopt; |
| break; |
| } |
| |
| switch (in.guest_type()) { |
| case patchpanel::NetworkDevice::ARC: |
| out->guest_type = Client::GuestType::kArcContainer; |
| break; |
| case patchpanel::NetworkDevice::ARCVM: |
| out->guest_type = Client::GuestType::kArcVm; |
| break; |
| case patchpanel::NetworkDevice::TERMINA_VM: |
| out->guest_type = Client::GuestType::kTerminaVm; |
| break; |
| case patchpanel::NetworkDevice::PARALLELS_VM: |
| out->guest_type = Client::GuestType::kParallelsVm; |
| break; |
| default: |
| LOG(ERROR) << __func__ << ": Unknown GuestType " |
| << patchpanel::NetworkDevice::GuestType_Name(in.guest_type()); |
| return std::nullopt; |
| } |
| return out; |
| } |
| |
| std::optional<Client::TerminaAllocation> ConvertTerminaAllocation( |
| const TerminaVmStartupResponse& in) { |
| if (!in.has_ipv4_subnet()) { |
| LOG(ERROR) << __func__ << ": No Termina IPv4 subnet found"; |
| return std::nullopt; |
| } |
| if (!in.has_container_ipv4_subnet()) { |
| LOG(ERROR) << __func__ << ": No Termina container IPv4 subnet found"; |
| return std::nullopt; |
| } |
| const auto termina_subnet = ConvertIPv4Subnet(in.ipv4_subnet()); |
| const auto termina_address = |
| net_base::IPv4Address::CreateFromBytes(in.ipv4_address()); |
| const auto gateway_address = |
| net_base::IPv4Address::CreateFromBytes(in.gateway_ipv4_address()); |
| const auto container_subnet = ConvertIPv4Subnet(in.container_ipv4_subnet()); |
| const auto container_address = |
| net_base::IPv4Address::CreateFromBytes(in.container_ipv4_address()); |
| if (!termina_subnet) { |
| LOG(ERROR) << __func__ << ": Invalid Termina IPv4 subnet"; |
| return std::nullopt; |
| } |
| if (!termina_address || !termina_subnet->InSameSubnetWith(*termina_address)) { |
| LOG(ERROR) << __func__ << ": Invalid Termina IPv4 address"; |
| return std::nullopt; |
| } |
| if (!gateway_address || !termina_subnet->InSameSubnetWith(*gateway_address)) { |
| LOG(ERROR) << __func__ << ": Invalid Termina gateway IPv4 address"; |
| return std::nullopt; |
| } |
| if (!container_subnet) { |
| LOG(ERROR) << __func__ << ": Invalid Termina container IPv4 subnet"; |
| return std::nullopt; |
| } |
| if (!container_address) { |
| LOG(ERROR) << __func__ << ": Invalid Termina container IPv4 address"; |
| return std::nullopt; |
| } |
| Client::TerminaAllocation termina_alloc; |
| termina_alloc.tap_device_ifname = in.tap_device_ifname(); |
| termina_alloc.termina_ipv4_subnet = *termina_subnet; |
| termina_alloc.termina_ipv4_address = *termina_address; |
| termina_alloc.gateway_ipv4_address = *gateway_address; |
| termina_alloc.container_ipv4_subnet = *container_subnet; |
| termina_alloc.container_ipv4_address = *container_address; |
| return termina_alloc; |
| } |
| |
| std::optional<Client::ParallelsAllocation> ConvertParallelsAllocation( |
| const ParallelsVmStartupResponse& in) { |
| if (!in.has_ipv4_subnet()) { |
| LOG(ERROR) << __func__ << ": No Parallels IPv4 subnet found"; |
| return std::nullopt; |
| } |
| const auto parallels_subnet = ConvertIPv4Subnet(in.ipv4_subnet()); |
| const auto parallels_address = |
| net_base::IPv4Address::CreateFromBytes(in.ipv4_address()); |
| if (!parallels_subnet) { |
| LOG(ERROR) << __func__ << ": Invalid Parallels IPv4 subnet"; |
| return std::nullopt; |
| } |
| if (!parallels_address || |
| !parallels_subnet->InSameSubnetWith(*parallels_address)) { |
| LOG(ERROR) << __func__ << ": Invalid Parallels IPv4 address"; |
| return std::nullopt; |
| } |
| Client::ParallelsAllocation parallels_alloc; |
| parallels_alloc.tap_device_ifname = in.tap_device_ifname(); |
| parallels_alloc.parallels_ipv4_subnet = *parallels_subnet; |
| parallels_alloc.parallels_ipv4_address = *parallels_address; |
| return parallels_alloc; |
| } |
| |
| std::optional<Client::BruschettaAllocation> ConvertBruschettaAllocation( |
| const BruschettaVmStartupResponse& in) { |
| if (in.tap_device_ifname().empty()) { |
| LOG(ERROR) << __func__ << ": No Bruschetta device interface found"; |
| return std::nullopt; |
| } |
| if (!in.has_ipv4_subnet()) { |
| LOG(ERROR) << __func__ << ": No Bruschetta IPv4 subnet found"; |
| return std::nullopt; |
| } |
| const auto bruschetta_subnet = ConvertIPv4Subnet(in.ipv4_subnet()); |
| const auto bruschetta_address = |
| net_base::IPv4Address::CreateFromBytes(in.ipv4_address()); |
| const auto gateway_address = |
| net_base::IPv4Address::CreateFromBytes(in.gateway_ipv4_address()); |
| if (!bruschetta_subnet) { |
| LOG(ERROR) << __func__ << ": Invalid Bruschetta IPv4 subnet"; |
| return std::nullopt; |
| } |
| if (!bruschetta_address || |
| !bruschetta_subnet->InSameSubnetWith(*bruschetta_address)) { |
| LOG(ERROR) << __func__ << ": Invalid Bruschetta IPv4 address"; |
| return std::nullopt; |
| } |
| if (!gateway_address || |
| !bruschetta_subnet->InSameSubnetWith(*gateway_address)) { |
| LOG(ERROR) << __func__ << ": Invalid Bruschetta gateway IPv4 address"; |
| return std::nullopt; |
| } |
| |
| Client::BruschettaAllocation bruschetta_alloc; |
| bruschetta_alloc.tap_device_ifname = in.tap_device_ifname(); |
| bruschetta_alloc.bruschetta_ipv4_subnet = *bruschetta_subnet; |
| bruschetta_alloc.bruschetta_ipv4_address = *bruschetta_address; |
| bruschetta_alloc.gateway_ipv4_address = *gateway_address; |
| return bruschetta_alloc; |
| } |
| |
| std::optional<Client::BorealisAllocation> ConvertBorealisAllocation( |
| const BorealisVmStartupResponse& in) { |
| if (in.tap_device_ifname().empty()) { |
| LOG(ERROR) << __func__ << ": No Borealis device interface found"; |
| return std::nullopt; |
| } |
| if (!in.has_ipv4_subnet()) { |
| LOG(ERROR) << __func__ << ": No Borealis IPv4 subnet found"; |
| return std::nullopt; |
| } |
| const auto borealis_subnet = ConvertIPv4Subnet(in.ipv4_subnet()); |
| const auto borealis_address = |
| net_base::IPv4Address::CreateFromBytes(in.ipv4_address()); |
| const auto gateway_address = |
| net_base::IPv4Address::CreateFromBytes(in.gateway_ipv4_address()); |
| if (!borealis_subnet) { |
| LOG(ERROR) << __func__ << ": Invalid Borealis IPv4 subnet"; |
| return std::nullopt; |
| } |
| if (!borealis_address || |
| !borealis_subnet->InSameSubnetWith(*borealis_address)) { |
| LOG(ERROR) << __func__ << ": Invalid Borealis IPv4 address"; |
| return std::nullopt; |
| } |
| if (!gateway_address || |
| !borealis_subnet->InSameSubnetWith(*gateway_address)) { |
| LOG(ERROR) << __func__ << ": Invalid Borealis gateway IPv4 address"; |
| return std::nullopt; |
| } |
| |
| Client::BorealisAllocation borealis_alloc; |
| borealis_alloc.tap_device_ifname = in.tap_device_ifname(); |
| borealis_alloc.borealis_ipv4_subnet = *borealis_subnet; |
| borealis_alloc.borealis_ipv4_address = *borealis_address; |
| borealis_alloc.gateway_ipv4_address = *gateway_address; |
| return borealis_alloc; |
| } |
| |
| std::optional<Client::NetworkClientInfo> ConvertNetworkClientInfo( |
| const NetworkClientInfo& in) { |
| auto out = std::make_optional<Client::NetworkClientInfo>(); |
| std::copy(in.mac_addr().begin(), in.mac_addr().end(), |
| std::back_inserter(out->mac_addr)); |
| const auto ipv4_addr = net_base::IPv4Address::CreateFromBytes(in.ipv4_addr()); |
| if (!ipv4_addr) { |
| LOG(ERROR) << "Failed to convert protobuf bytes to IPv4Address. size=" |
| << in.ipv4_addr().size(); |
| return std::nullopt; |
| } |
| out->ipv4_addr = *ipv4_addr; |
| for (const auto& in_ipv6_addr : in.ipv6_addresses()) { |
| const auto ipv6_addr = net_base::IPv6Address::CreateFromBytes(in_ipv6_addr); |
| if (!ipv6_addr) { |
| LOG(ERROR) << "Failed to convert protobuf bytes to IPv6Address. size=" |
| << in_ipv6_addr.size(); |
| return std::nullopt; |
| } |
| out->ipv6_addresses.push_back(*ipv6_addr); |
| } |
| out->hostname = in.hostname(); |
| out->vendor_class = in.vendor_class(); |
| return out; |
| } |
| |
| std::optional<Client::DownstreamNetwork> ConvertDownstreamNetwork( |
| const DownstreamNetwork& in) { |
| auto out = std::make_optional<Client::DownstreamNetwork>(); |
| out->network_id = in.network_id(); |
| out->ifname = in.downstream_ifname(); |
| |
| const auto ipv4_subnet = ConvertIPv4Subnet(in.ipv4_subnet()); |
| if (!ipv4_subnet) { |
| LOG(ERROR) << "Failed to create IPv4CIDR for ipv4_subnet"; |
| return std::nullopt; |
| } |
| out->ipv4_subnet = *ipv4_subnet; |
| |
| const auto ipv4_gateway_addr = |
| net_base::IPv4Address::CreateFromBytes(in.ipv4_gateway_addr()); |
| if (!ipv4_gateway_addr) { |
| LOG(ERROR) << "Failed to create IPv4Address for gateway address: size=" |
| << in.ipv4_gateway_addr().size(); |
| return std::nullopt; |
| } |
| out->ipv4_gateway_addr = *ipv4_gateway_addr; |
| return out; |
| } |
| |
| patchpanel::NetworkTechnology ConvertNetworkTechnology( |
| Client::NetworkTechnology network_technology) { |
| switch (network_technology) { |
| case Client::NetworkTechnology::kCellular: |
| return patchpanel::NetworkTechnology::CELLULAR; |
| case Client::NetworkTechnology::kEthernet: |
| return patchpanel::NetworkTechnology::ETHERNET; |
| case Client::NetworkTechnology::kVPN: |
| return patchpanel::NetworkTechnology::VPN; |
| case Client::NetworkTechnology::kWiFi: |
| return patchpanel::NetworkTechnology::WIFI; |
| } |
| } |
| |
| TagSocketRequest::VpnRoutingPolicy ConvertVpnRoutingPolicy( |
| Client::VpnRoutingPolicy policy) { |
| switch (policy) { |
| case Client::VpnRoutingPolicy::kDefaultRouting: |
| return TagSocketRequest::DEFAULT_ROUTING; |
| case Client::VpnRoutingPolicy::kBypassVpn: |
| return TagSocketRequest::BYPASS_VPN; |
| case Client::VpnRoutingPolicy::kRouteOnVpn: |
| return TagSocketRequest::ROUTE_ON_VPN; |
| } |
| } |
| |
| traffic_annotation::TrafficAnnotation::Id ConvertTrafficAnnotationId( |
| Client::TrafficAnnotationId id) { |
| switch (id) { |
| case Client::TrafficAnnotationId::kUnspecified: |
| return traffic_annotation::TrafficAnnotation::UNSPECIFIED; |
| case Client::TrafficAnnotationId::kShillPortalDetector: |
| return traffic_annotation::TrafficAnnotation::SHILL_PORTAL_DETECTOR; |
| case Client::TrafficAnnotationId::kShillCapportClient: |
| return traffic_annotation::TrafficAnnotation::SHILL_CAPPORT_CLIENT; |
| case Client::TrafficAnnotationId::kShillCarrierEntitlement: |
| return traffic_annotation::TrafficAnnotation::SHILL_CARRIER_ENTITLEMENT; |
| } |
| } |
| |
| std::optional<Client::NeighborReachabilityEvent> |
| ConvertNeighborReachabilityEvent(const NeighborReachabilityEventSignal& in) { |
| auto out = std::make_optional<Client::NeighborReachabilityEvent>(); |
| out->ifindex = in.ifindex(); |
| out->ip_addr = in.ip_addr(); |
| switch (in.role()) { |
| case patchpanel::NeighborReachabilityEventSignal::GATEWAY: |
| out->role = Client::NeighborRole::kGateway; |
| break; |
| case patchpanel::NeighborReachabilityEventSignal::DNS_SERVER: |
| out->role = Client::NeighborRole::kDnsServer; |
| break; |
| case patchpanel::NeighborReachabilityEventSignal::GATEWAY_AND_DNS_SERVER: |
| out->role = Client::NeighborRole::kGatewayAndDnsServer; |
| break; |
| default: |
| LOG(ERROR) << __func__ << ": Unknown NeighborReachability role " |
| << patchpanel::NeighborReachabilityEventSignal::Role_Name( |
| in.role()); |
| return std::nullopt; |
| } |
| switch (in.type()) { |
| case patchpanel::NeighborReachabilityEventSignal::FAILED: |
| out->status = Client::NeighborStatus::kFailed; |
| break; |
| case patchpanel::NeighborReachabilityEventSignal::REACHABLE: |
| out->status = Client::NeighborStatus::kReachable; |
| break; |
| default: |
| LOG(ERROR) << __func__ << ": Unknown NeighborReachability event type " |
| << patchpanel::NeighborReachabilityEventSignal::EventType_Name( |
| in.type()); |
| return std::nullopt; |
| } |
| return out; |
| } |
| |
| std::optional<Client::VirtualDeviceEvent> ConvertVirtualDeviceEvent( |
| const NetworkDeviceChangedSignal& in) { |
| switch (in.event()) { |
| case patchpanel::NetworkDeviceChangedSignal::DEVICE_ADDED: |
| return Client::VirtualDeviceEvent::kAdded; |
| case patchpanel::NetworkDeviceChangedSignal::DEVICE_REMOVED: |
| return Client::VirtualDeviceEvent::kRemoved; |
| default: |
| LOG(ERROR) << __func__ << ": Unknown NetworkDeviceChangedSignal event " |
| << patchpanel::NetworkDeviceChangedSignal::Event_Name( |
| in.event()); |
| return std::nullopt; |
| } |
| } |
| |
| std::optional<Client::ConnectedNamespace> ConvertConnectedNamespace( |
| const ConnectNamespaceResponse& in) { |
| auto out = std::make_optional<Client::ConnectedNamespace>(); |
| |
| const auto ipv4_subnet = ConvertIPv4Subnet(in.ipv4_subnet()); |
| if (!ipv4_subnet) { |
| LOG(ERROR) << "Failed to create IPv4CIDR for ipv4_subnet"; |
| return std::nullopt; |
| } |
| out->ipv4_subnet = *ipv4_subnet; |
| |
| out->peer_ifname = in.peer_ifname(); |
| out->peer_ipv4_address = net_base::IPv4Address(in.peer_ipv4_address()); |
| out->host_ifname = in.host_ifname(); |
| out->host_ipv4_address = net_base::IPv4Address(in.host_ipv4_address()); |
| out->netns_name = in.netns_name(); |
| return out; |
| } |
| |
| std::ostream& operator<<(std::ostream& stream, |
| const ModifyPortRuleRequest& request) { |
| stream << "{ operation: " |
| << ModifyPortRuleRequest::Operation_Name(request.op()) |
| << ", rule type: " |
| << ModifyPortRuleRequest::RuleType_Name(request.type()) |
| << ", protocol: " |
| << ModifyPortRuleRequest::Protocol_Name(request.proto()); |
| if (!request.input_ifname().empty()) { |
| stream << ", input interface name: " << request.input_ifname(); |
| } |
| if (!request.input_dst_ip().empty()) { |
| stream << ", input destination IP: " << request.input_dst_ip(); |
| } |
| stream << ", input destination port: " << request.input_dst_port(); |
| if (!request.dst_ip().empty()) { |
| stream << ", destination IP: " << request.dst_ip(); |
| } |
| if (request.dst_port() != 0) { |
| stream << ", destination port: " << request.dst_port(); |
| } |
| stream << " }"; |
| return stream; |
| } |
| |
| std::ostream& operator<<(std::ostream& stream, |
| const SetDnsRedirectionRuleRequest& request) { |
| stream << "{ proxy type: " |
| << SetDnsRedirectionRuleRequest::RuleType_Name(request.type()); |
| if (!request.input_ifname().empty()) { |
| stream << ", input interface name: " << request.input_ifname(); |
| } |
| if (!request.proxy_address().empty()) { |
| stream << ", proxy IPv4 address: " << request.proxy_address(); |
| } |
| if (!request.nameservers().empty()) { |
| std::vector<std::string> nameservers; |
| for (const auto& ns : request.nameservers()) { |
| nameservers.emplace_back(ns); |
| } |
| stream << ", nameserver(s): " << base::JoinString(nameservers, ","); |
| } |
| stream << " }"; |
| return stream; |
| } |
| |
| std::ostream& operator<<(std::ostream& stream, const Client::FeatureFlag flag) { |
| switch (flag) { |
| case Client::FeatureFlag::kWiFiQoS: |
| return stream << "WiFiQoS"; |
| case Client::FeatureFlag::kClat: |
| return stream << "Clat"; |
| } |
| } |
| |
| // Prepares a pair of ScopedFDs corresponding to the write end (pair first |
| // element) and read end (pair second element) of a Linux pipe. The client must |
| // keep the write end alive until the setup requested from patchpanel is not |
| // necessary anymore. |
| std::pair<base::ScopedFD, base::ScopedFD> CreateLifelineFd() { |
| int pipe_fds[2] = {-1, -1}; |
| if (pipe2(pipe_fds, O_CLOEXEC) < 0) { |
| PLOG(ERROR) << "Failed to create a pair of fds with pipe2()"; |
| return {}; |
| } |
| return {base::ScopedFD(pipe_fds[0]), base::ScopedFD(pipe_fds[1])}; |
| } |
| |
| void OnGetTrafficCountersDBusResponse( |
| Client::GetTrafficCountersCallback callback, |
| const TrafficCountersResponse& response) { |
| std::vector<Client::TrafficCounter> counters; |
| for (const auto& proto_counter : response.counters()) { |
| auto client_counter = ConvertTrafficCounter(proto_counter); |
| if (client_counter) { |
| counters.push_back(*client_counter); |
| } |
| } |
| std::move(callback).Run(counters); |
| } |
| |
| void OnGetTrafficCountersError(Client::GetTrafficCountersCallback callback, |
| brillo::Error* error) { |
| LOG(ERROR) << __func__ << "(): " << error->GetMessage(); |
| std::move(callback).Run({}); |
| } |
| |
| void OnNetworkDeviceChanged( |
| Client::VirtualDeviceEventHandler handler, |
| const patchpanel::NetworkDeviceChangedSignal& signal) { |
| const auto event = ConvertVirtualDeviceEvent(signal); |
| if (!event) { |
| return; |
| } |
| |
| const auto device = ConvertVirtualDevice(signal.device()); |
| if (!device) { |
| return; |
| } |
| |
| handler.Run(*event, *device); |
| } |
| |
| void OnNeighborReachabilityEvent( |
| const Client::NeighborReachabilityEventHandler& handler, |
| const NeighborReachabilityEventSignal& signal) { |
| const auto event = ConvertNeighborReachabilityEvent(signal); |
| if (event) { |
| handler.Run(*event); |
| } |
| } |
| |
| void OnSignalConnectedCallback(const std::string& interface_name, |
| const std::string& signal_name, |
| bool success) { |
| if (!success) |
| LOG(ERROR) << "Failed to connect to " << signal_name; |
| } |
| |
| // Helper static function to process answers to CreateTetheredNetwork calls. |
| void OnTetheredNetworkResponse(Client::CreateTetheredNetworkCallback callback, |
| base::ScopedFD fd_local, |
| const TetheredNetworkResponse& response) { |
| if (response.response_code() != DownstreamNetworkResult::SUCCESS) { |
| LOG(ERROR) << kCreateTetheredNetworkMethod << " failed: " |
| << patchpanel::DownstreamNetworkResult_Name( |
| response.response_code()); |
| std::move(callback).Run({}, {}); |
| return; |
| } |
| |
| std::optional<Client::DownstreamNetwork> downstream_network = |
| ConvertDownstreamNetwork(response.downstream_network()); |
| if (!downstream_network) { |
| std::move(callback).Run({}, {}); |
| return; |
| } |
| |
| std::move(callback).Run(std::move(fd_local), *downstream_network); |
| } |
| |
| void OnTetheredNetworkError(Client::CreateTetheredNetworkCallback callback, |
| brillo::Error* error) { |
| LOG(ERROR) << __func__ << "(): " << error->GetMessage(); |
| std::move(callback).Run({}, {}); |
| } |
| |
| // Helper static function to process answers to CreateLocalOnlyNetwork calls. |
| void OnLocalOnlyNetworkResponse(Client::CreateLocalOnlyNetworkCallback callback, |
| base::ScopedFD fd_local, |
| const LocalOnlyNetworkResponse& response) { |
| if (response.response_code() != DownstreamNetworkResult::SUCCESS) { |
| LOG(ERROR) << kCreateLocalOnlyNetworkMethod << " failed: " |
| << patchpanel::DownstreamNetworkResult_Name( |
| response.response_code()); |
| std::move(callback).Run({}, {}); |
| return; |
| } |
| |
| std::optional<Client::DownstreamNetwork> downstream_network = |
| ConvertDownstreamNetwork(response.downstream_network()); |
| if (!downstream_network) { |
| std::move(callback).Run({}, {}); |
| return; |
| } |
| |
| std::move(callback).Run(std::move(fd_local), *downstream_network); |
| } |
| |
| void OnLocalOnlyNetworkError(Client::CreateLocalOnlyNetworkCallback callback, |
| brillo::Error* error) { |
| LOG(ERROR) << __func__ << "(): " << error->GetMessage(); |
| std::move(callback).Run({}, {}); |
| } |
| |
| // Helper static function to process answers to GetDownstreamNetworkInfo calls. |
| void OnGetDownstreamNetworkInfoResponse( |
| Client::GetDownstreamNetworkInfoCallback callback, |
| const GetDownstreamNetworkInfoResponse& response) { |
| std::optional<Client::DownstreamNetwork> downstream_network = |
| ConvertDownstreamNetwork(response.downstream_network()); |
| if (!downstream_network) { |
| std::move(callback).Run(false, {}, {}); |
| return; |
| } |
| |
| std::vector<Client::NetworkClientInfo> clients_info; |
| for (const auto& ci : response.clients_info()) { |
| const auto info = ConvertNetworkClientInfo(ci); |
| if (info) { |
| clients_info.push_back(*info); |
| } |
| } |
| |
| std::move(callback).Run(true, *downstream_network, clients_info); |
| } |
| |
| void OnGetDownstreamNetworkInfoError( |
| Client::GetDownstreamNetworkInfoCallback callback, brillo::Error* error) { |
| LOG(ERROR) << __func__ << "(): " << error->GetMessage(); |
| std::move(callback).Run(false, {}, {}); |
| } |
| |
| void OnConfigureNetworkResponse( |
| Client::ConfigureNetworkCallback callback, |
| const std::string& ifname, |
| const patchpanel::ConfigureNetworkResponse& response) { |
| if (!response.success()) { |
| LOG(ERROR) << __func__ << ": Failed to configure Network on " << ifname; |
| std::move(callback).Run(false); |
| return; |
| } |
| std::move(callback).Run(true); |
| } |
| |
| void OnConfigureNetworkError(Client::ConfigureNetworkCallback callback, |
| const std::string& ifname, |
| brillo::Error* error) { |
| LOG(ERROR) << __func__ << "() on " << ifname << ": " << error->GetMessage(); |
| std::move(callback).Run(false); |
| } |
| |
| void OnTagSocketResponse(Client::TagSocketCallback callback, |
| const patchpanel::TagSocketResponse& response) { |
| if (!response.success()) { |
| LOG(ERROR) << __func__ << "(): failed to tag socket"; |
| std::move(callback).Run(false); |
| return; |
| } |
| std::move(callback).Run(true); |
| } |
| |
| void OnTagSocketError(Client::TagSocketCallback callback, |
| brillo::Error* error) { |
| LOG(ERROR) << __func__ << "(): " << error->GetMessage(); |
| std::move(callback).Run(false); |
| } |
| |
| class ClientImpl : public Client { |
| public: |
| ClientImpl(scoped_refptr<dbus::Bus> bus, |
| std::unique_ptr<org::chromium::PatchPanelProxyInterface> proxy, |
| bool owns_bus) |
| : bus_(std::move(bus)), proxy_(std::move(proxy)), owns_bus_(owns_bus) {} |
| |
| ClientImpl(const ClientImpl&) = delete; |
| ClientImpl& operator=(const ClientImpl&) = delete; |
| |
| ~ClientImpl() override; |
| |
| void RegisterOnAvailableCallback( |
| base::OnceCallback<void(bool)> callback) override; |
| |
| void RegisterProcessChangedCallback( |
| base::RepeatingCallback<void(bool)> callback) override; |
| |
| bool NotifyArcStartup(pid_t pid) override; |
| bool NotifyArcShutdown() override; |
| |
| std::optional<Client::ArcVMAllocation> NotifyArcVmStartup( |
| uint32_t cid) override; |
| bool NotifyArcVmShutdown(uint32_t cid) override; |
| |
| std::optional<Client::TerminaAllocation> NotifyTerminaVmStartup( |
| uint32_t cid) override; |
| bool NotifyTerminaVmShutdown(uint32_t cid) override; |
| |
| std::optional<ParallelsAllocation> NotifyParallelsVmStartup( |
| uint64_t vm_id, int subnet_index) override; |
| bool NotifyParallelsVmShutdown(uint64_t vm_id) override; |
| |
| std::optional<BruschettaAllocation> NotifyBruschettaVmStartup( |
| uint64_t vm_id) override; |
| bool NotifyBruschettaVmShutdown(uint64_t vm_id) override; |
| |
| std::optional<BorealisAllocation> NotifyBorealisVmStartup( |
| uint32_t vm_id) override; |
| bool NotifyBorealisVmShutdown(uint32_t vm_id) override; |
| |
| std::pair<base::ScopedFD, Client::ConnectedNamespace> ConnectNamespace( |
| pid_t pid, |
| const std::string& outbound_ifname, |
| bool forward_user_traffic, |
| bool route_on_vpn, |
| Client::TrafficSource traffic_source, |
| bool static_ipv6) override; |
| |
| void GetTrafficCounters(const std::set<std::string>& devices, |
| GetTrafficCountersCallback callback) override; |
| |
| bool ModifyPortRule(Client::FirewallRequestOperation op, |
| Client::FirewallRequestType type, |
| Client::FirewallRequestProtocol proto, |
| const std::string& input_ifname, |
| const std::string& input_dst_ip, |
| uint32_t input_dst_port, |
| const std::string& dst_ip, |
| uint32_t dst_port) override; |
| |
| void SetVpnLockdown(bool enable) override; |
| |
| base::ScopedFD RedirectDns(Client::DnsRedirectionRequestType type, |
| const std::string& input_ifname, |
| const std::string& proxy_address, |
| const std::vector<std::string>& nameservers, |
| const std::string& host_ifname) override; |
| |
| std::vector<Client::VirtualDevice> GetDevices() override; |
| |
| void RegisterVirtualDeviceEventHandler( |
| VirtualDeviceEventHandler handler) override; |
| |
| void RegisterNeighborReachabilityEventHandler( |
| NeighborReachabilityEventHandler handler) override; |
| |
| bool CreateTetheredNetwork( |
| const std::string& downstream_ifname, |
| const std::string& upstream_ifname, |
| const std::optional<DHCPOptions>& dhcp_options, |
| const std::optional<UplinkIPv6Configuration>& uplink_ipv6_config, |
| const std::optional<int>& mtu, |
| CreateTetheredNetworkCallback callback) override; |
| |
| bool CreateLocalOnlyNetwork(const std::string& ifname, |
| CreateLocalOnlyNetworkCallback callback) override; |
| |
| bool GetDownstreamNetworkInfo( |
| const std::string& ifname, |
| GetDownstreamNetworkInfoCallback callback) override; |
| |
| bool ConfigureNetwork(int interface_index, |
| std::string_view interface_name, |
| uint32_t area, |
| const net_base::NetworkConfig& network_config, |
| net_base::NetworkPriority priority, |
| NetworkTechnology technology, |
| ConfigureNetworkCallback callback) override; |
| |
| bool SendSetFeatureFlagRequest(FeatureFlag flag, bool enable) override; |
| |
| bool TagSocket(base::ScopedFD fd, |
| std::optional<int> network_id, |
| std::optional<VpnRoutingPolicy> vpn_policy, |
| std::optional<TrafficAnnotation> traffic_annotation, |
| TagSocketCallback callback) override; |
| |
| void PrepareTagSocket( |
| const TrafficAnnotation& annotation, |
| std::shared_ptr<brillo::http::Transport> transport) override; |
| |
| private: |
| // Runs the |task| on the DBus thread synchronously. |
| // The generated proxy uses brillo::dbus_utils::CallMethod*(), which asserts |
| // to be executed on the DBus thread, instead of hopping on the DBus thread. |
| // Therefore we need to do it by ourselves. |
| bool RunOnDBusThreadSync(base::OnceCallback<bool()> task) { |
| if (!bus_->HasDBusThread() || |
| bus_->GetDBusTaskRunner()->RunsTasksInCurrentSequence()) { |
| return std::move(task).Run(); |
| } |
| |
| base::WaitableEvent event; |
| bool result = false; |
| bus_->GetDBusTaskRunner()->PostTask( |
| FROM_HERE, base::BindOnce( |
| [](base::OnceCallback<bool()> task, bool* result, |
| base::WaitableEvent* event) { |
| *result = std::move(task).Run(); |
| event->Signal(); |
| }, |
| std::move(task), base::Unretained(&result), |
| base::Unretained(&event))); |
| event.Wait(); |
| return result; |
| } |
| |
| // Runs the |task| on the DBus thread asynchronously. |
| // The generated proxy uses brillo::dbus_utils::CallMethod*(), which asserts |
| // to be executed on the DBus thread, instead of hopping on the DBus thread. |
| // Therefore we need to do it by ourselves. |
| void RunOnDBusThreadAsync(base::OnceClosure task) { |
| if (!bus_->HasDBusThread() || |
| bus_->GetDBusTaskRunner()->RunsTasksInCurrentSequence()) { |
| std::move(task).Run(); |
| return; |
| } |
| |
| bus_->GetDBusTaskRunner()->PostTask(FROM_HERE, std::move(task)); |
| } |
| |
| scoped_refptr<dbus::Bus> bus_; |
| std::unique_ptr<org::chromium::PatchPanelProxyInterface> proxy_; |
| bool owns_bus_; // Yes if |bus_| is created by Client::New |
| |
| base::RepeatingCallback<void(bool)> owner_callback_; |
| |
| void OnOwnerChanged(const std::string& old_owner, |
| const std::string& new_owner); |
| |
| base::WeakPtrFactory<ClientImpl> weak_factory_{this}; |
| }; |
| |
| ClientImpl::~ClientImpl() { |
| if (bus_ && owns_bus_) |
| bus_->ShutdownAndBlock(); |
| } |
| |
| void ClientImpl::RegisterOnAvailableCallback( |
| base::OnceCallback<void(bool)> callback) { |
| auto* object_proxy = proxy_->GetObjectProxy(); |
| if (!object_proxy) { |
| LOG(ERROR) << "Cannot register callback - no proxy"; |
| return; |
| } |
| object_proxy->WaitForServiceToBeAvailable(std::move(callback)); |
| } |
| |
| void ClientImpl::RegisterProcessChangedCallback( |
| base::RepeatingCallback<void(bool)> callback) { |
| owner_callback_ = callback; |
| bus_->GetObjectProxy(kPatchPanelServiceName, dbus::ObjectPath{"/"}) |
| ->SetNameOwnerChangedCallback(base::BindRepeating( |
| &ClientImpl::OnOwnerChanged, weak_factory_.GetWeakPtr())); |
| } |
| |
| void ClientImpl::OnOwnerChanged(const std::string& old_owner, |
| const std::string& new_owner) { |
| if (new_owner.empty()) { |
| LOG(INFO) << "Patchpanel lost"; |
| if (!owner_callback_.is_null()) |
| owner_callback_.Run(false); |
| return; |
| } |
| |
| LOG(INFO) << "Patchpanel reset"; |
| if (!owner_callback_.is_null()) |
| owner_callback_.Run(true); |
| } |
| |
| bool ClientImpl::NotifyArcStartup(pid_t pid) { |
| ArcStartupRequest request; |
| request.set_pid(pid); |
| |
| // TODO(b/284076578): Check if we can call the DBus method asynchronously. |
| ArcStartupResponse response; |
| brillo::ErrorPtr error; |
| const bool result = RunOnDBusThreadSync(base::BindOnce( |
| [](PatchPanelProxyInterface* proxy, const ArcStartupRequest& request, |
| ArcStartupResponse* response, brillo::ErrorPtr* error) { |
| return proxy->ArcStartup(request, response, error); |
| }, |
| proxy_.get(), request, &response, &error)); |
| if (!result) { |
| LOG(ERROR) << "ARC network startup failed: " << error->GetMessage(); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| bool ClientImpl::NotifyArcShutdown() { |
| // TODO(b/284076578): Check if we can call the DBus method asynchronously. |
| brillo::ErrorPtr error; |
| const bool result = RunOnDBusThreadSync(base::BindOnce( |
| [](PatchPanelProxyInterface* proxy, brillo::ErrorPtr* error) { |
| ArcShutdownResponse response; |
| return proxy->ArcShutdown({}, &response, error); |
| }, |
| proxy_.get(), &error)); |
| if (!result) { |
| LOG(ERROR) << "ARC network shutdown failed: " << error->GetMessage(); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| std::optional<Client::ArcVMAllocation> ClientImpl::NotifyArcVmStartup( |
| uint32_t cid) { |
| ArcVmStartupRequest request; |
| request.set_cid(cid); |
| |
| // TODO(b/284076578): Check if concierge can handle the result asynchronously. |
| ArcVmStartupResponse response; |
| brillo::ErrorPtr error; |
| const bool result = RunOnDBusThreadSync(base::BindOnce( |
| [](PatchPanelProxyInterface* proxy, const ArcVmStartupRequest& request, |
| ArcVmStartupResponse* response, brillo::ErrorPtr* error) { |
| return proxy->ArcVmStartup(request, response, error); |
| }, |
| proxy_.get(), request, &response, &error)); |
| if (!result) { |
| LOG(ERROR) << "ARCVM network startup failed: " << error->GetMessage(); |
| return std::nullopt; |
| } |
| |
| const auto arc0_addr = |
| net_base::IPv4Address::CreateFromBytes(response.arc0_ipv4_address()); |
| if (!arc0_addr) { |
| LOG(ERROR) << "Could not deserialize arc0 IPv4 address"; |
| return std::nullopt; |
| } |
| |
| ArcVMAllocation arcvm_alloc; |
| arcvm_alloc.arc0_ipv4_address = *arc0_addr; |
| for (const auto& tap : response.tap_device_ifnames()) { |
| arcvm_alloc.tap_device_ifnames.push_back(tap); |
| } |
| return arcvm_alloc; |
| } |
| |
| bool ClientImpl::NotifyArcVmShutdown(uint32_t cid) { |
| ArcVmShutdownRequest request; |
| request.set_cid(cid); |
| |
| // TODO(b/284076578): Check if concierge can handle the result asynchronously. |
| ArcVmShutdownResponse response; |
| brillo::ErrorPtr error; |
| const bool result = RunOnDBusThreadSync(base::BindOnce( |
| [](PatchPanelProxyInterface* proxy, const ArcVmShutdownRequest& request, |
| ArcVmShutdownResponse* response, brillo::ErrorPtr* error) { |
| return proxy->ArcVmShutdown(request, response, error); |
| }, |
| proxy_.get(), request, &response, &error)); |
| if (!result) { |
| LOG(ERROR) << "ARCVM network shutdown failed: " << error->GetMessage(); |
| } |
| |
| return result; |
| } |
| |
| std::optional<Client::TerminaAllocation> ClientImpl::NotifyTerminaVmStartup( |
| uint32_t cid) { |
| TerminaVmStartupRequest request; |
| request.set_cid(cid); |
| |
| TerminaVmStartupResponse response; |
| brillo::ErrorPtr error; |
| const bool result = RunOnDBusThreadSync(base::BindOnce( |
| [](PatchPanelProxyInterface* proxy, |
| const TerminaVmStartupRequest& request, |
| TerminaVmStartupResponse* response, brillo::ErrorPtr* error) { |
| return proxy->TerminaVmStartup(request, response, error); |
| }, |
| proxy_.get(), request, &response, &error)); |
| |
| if (!result) { |
| LOG(ERROR) << __func__ << "(cid: " << cid |
| << "): TerminaVM network startup failed: " |
| << error->GetMessage(); |
| return std::nullopt; |
| } |
| |
| const auto termina_alloc = ConvertTerminaAllocation(response); |
| if (!termina_alloc) { |
| LOG(ERROR) << __func__ << "(cid: " << cid |
| << "): Failed to convert network allocation"; |
| } |
| return termina_alloc; |
| } |
| |
| bool ClientImpl::NotifyTerminaVmShutdown(uint32_t cid) { |
| TerminaVmShutdownRequest request; |
| request.set_cid(cid); |
| |
| TerminaVmShutdownResponse response; |
| brillo::ErrorPtr error; |
| const bool result = RunOnDBusThreadSync(base::BindOnce( |
| [](PatchPanelProxyInterface* proxy, |
| const TerminaVmShutdownRequest& request, |
| TerminaVmShutdownResponse* response, brillo::ErrorPtr* error) { |
| return proxy->TerminaVmShutdown(request, response, error); |
| }, |
| proxy_.get(), request, &response, &error)); |
| if (!result) { |
| LOG(ERROR) << "TerminaVM network shutdown failed: " << error->GetMessage(); |
| return false; |
| } |
| return true; |
| } |
| |
| std::optional<Client::ParallelsAllocation> ClientImpl::NotifyParallelsVmStartup( |
| uint64_t vm_id, int subnet_index) { |
| ParallelsVmStartupRequest request; |
| request.set_id(vm_id); |
| request.set_subnet_index(subnet_index); |
| |
| ParallelsVmStartupResponse response; |
| brillo::ErrorPtr error; |
| const bool result = RunOnDBusThreadSync(base::BindOnce( |
| [](PatchPanelProxyInterface* proxy, |
| const ParallelsVmStartupRequest& request, |
| ParallelsVmStartupResponse* response, brillo::ErrorPtr* error) { |
| return proxy->ParallelsVmStartup(request, response, error); |
| }, |
| proxy_.get(), request, &response, &error)); |
| |
| if (!result) { |
| LOG(ERROR) << __func__ << "(cid: " << vm_id |
| << ", subnet_index: " << subnet_index |
| << "): Parallels VM network startup failed: " |
| << error->GetMessage(); |
| return std::nullopt; |
| } |
| |
| const auto network_alloc = ConvertParallelsAllocation(response); |
| if (!network_alloc) { |
| LOG(ERROR) << __func__ << "(cid: " << vm_id |
| << ", subnet_index: " << subnet_index |
| << "): Failed to convert Parallels VM network configuration"; |
| } |
| return network_alloc; |
| } |
| |
| bool ClientImpl::NotifyParallelsVmShutdown(uint64_t vm_id) { |
| ParallelsVmShutdownRequest request; |
| request.set_id(vm_id); |
| |
| ParallelsVmShutdownResponse response; |
| brillo::ErrorPtr error; |
| const bool result = RunOnDBusThreadSync(base::BindOnce( |
| [](PatchPanelProxyInterface* proxy, |
| const ParallelsVmShutdownRequest& request, |
| ParallelsVmShutdownResponse* response, brillo::ErrorPtr* error) { |
| return proxy->ParallelsVmShutdown(request, response, error); |
| }, |
| proxy_.get(), request, &response, &error)); |
| if (!result) { |
| LOG(ERROR) << "ParallelsVM network shutdown failed: " |
| << error->GetMessage(); |
| return false; |
| } |
| return true; |
| } |
| |
| std::optional<Client::BruschettaAllocation> |
| ClientImpl::NotifyBruschettaVmStartup(uint64_t vm_id) { |
| BruschettaVmStartupRequest request; |
| request.set_id(vm_id); |
| |
| BruschettaVmStartupResponse response; |
| brillo::ErrorPtr error; |
| const bool result = RunOnDBusThreadSync(base::BindOnce( |
| [](PatchPanelProxyInterface* proxy, |
| const BruschettaVmStartupRequest& request, |
| BruschettaVmStartupResponse* response, brillo::ErrorPtr* error) { |
| return proxy->BruschettaVmStartup(request, response, error); |
| }, |
| proxy_.get(), request, &response, &error)); |
| |
| if (!result) { |
| LOG(ERROR) << __func__ << "(vm_id: " << vm_id |
| << "): Bruschetta VM network startup failed: " |
| << error->GetMessage(); |
| return std::nullopt; |
| } |
| |
| const auto network_alloc = ConvertBruschettaAllocation(response); |
| if (!network_alloc) { |
| LOG(ERROR) << __func__ << "(vm_id: " << vm_id |
| << "): Failed to convert Bruschetta VM network configuration"; |
| } |
| return network_alloc; |
| } |
| |
| bool ClientImpl::NotifyBruschettaVmShutdown(uint64_t vm_id) { |
| BruschettaVmShutdownRequest request; |
| request.set_id(vm_id); |
| |
| BruschettaVmShutdownResponse response; |
| brillo::ErrorPtr error; |
| const bool result = RunOnDBusThreadSync(base::BindOnce( |
| [](PatchPanelProxyInterface* proxy, |
| const BruschettaVmShutdownRequest& request, |
| BruschettaVmShutdownResponse* response, brillo::ErrorPtr* error) { |
| return proxy->BruschettaVmShutdown(request, response, error); |
| }, |
| proxy_.get(), request, &response, &error)); |
| if (!result) { |
| LOG(ERROR) << "BruschettaVM network shutdown failed: " |
| << error->GetMessage(); |
| return false; |
| } |
| return true; |
| } |
| |
| std::optional<Client::BorealisAllocation> ClientImpl::NotifyBorealisVmStartup( |
| uint32_t vm_id) { |
| BorealisVmStartupRequest request; |
| request.set_id(vm_id); |
| |
| BorealisVmStartupResponse response; |
| brillo::ErrorPtr error; |
| const bool result = RunOnDBusThreadSync(base::BindOnce( |
| [](PatchPanelProxyInterface* proxy, |
| const BorealisVmStartupRequest& request, |
| BorealisVmStartupResponse* response, brillo::ErrorPtr* error) { |
| return proxy->BorealisVmStartup(request, response, error); |
| }, |
| proxy_.get(), request, &response, &error)); |
| |
| if (!result) { |
| LOG(ERROR) << __func__ << "(vm_id: " << vm_id |
| << "): Borealis VM network startup failed: " |
| << error->GetMessage(); |
| return std::nullopt; |
| } |
| |
| const auto network_alloc = ConvertBorealisAllocation(response); |
| if (!network_alloc) { |
| LOG(ERROR) << __func__ << "(vm_id: " << vm_id |
| << "): Failed to convert Borealis VM network configuration"; |
| } |
| return network_alloc; |
| } |
| |
| bool ClientImpl::NotifyBorealisVmShutdown(uint32_t vm_id) { |
| BorealisVmShutdownRequest request; |
| request.set_id(vm_id); |
| |
| BorealisVmShutdownResponse response; |
| brillo::ErrorPtr error; |
| const bool result = RunOnDBusThreadSync(base::BindOnce( |
| [](PatchPanelProxyInterface* proxy, |
| const BorealisVmShutdownRequest& request, |
| BorealisVmShutdownResponse* response, brillo::ErrorPtr* error) { |
| return proxy->BorealisVmShutdown(request, response, error); |
| }, |
| proxy_.get(), request, &response, &error)); |
| if (!result) { |
| LOG(ERROR) << "Borealis VM network shutdown failed: " |
| << error->GetMessage(); |
| return false; |
| } |
| return true; |
| } |
| |
| std::pair<base::ScopedFD, Client::ConnectedNamespace> |
| ClientImpl::ConnectNamespace(pid_t pid, |
| const std::string& outbound_ifname, |
| bool forward_user_traffic, |
| bool route_on_vpn, |
| Client::TrafficSource traffic_source, |
| bool static_ipv6) { |
| // Prepare and serialize the request proto. |
| ConnectNamespaceRequest request; |
| request.set_pid(static_cast<int32_t>(pid)); |
| request.set_outbound_physical_device(outbound_ifname); |
| request.set_allow_user_traffic(forward_user_traffic); |
| request.set_route_on_vpn(route_on_vpn); |
| request.set_traffic_source(ConvertTrafficSource(traffic_source)); |
| request.set_static_ipv6(static_ipv6); |
| |
| auto [fd_local, fd_remote] = CreateLifelineFd(); |
| if (!fd_local.is_valid()) { |
| LOG(ERROR) |
| << "Cannot send ConnectNamespace message to patchpanel: no lifeline fd"; |
| return {}; |
| } |
| |
| ConnectNamespaceResponse response; |
| brillo::ErrorPtr error; |
| const bool result = RunOnDBusThreadSync(base::BindOnce( |
| [](PatchPanelProxyInterface* proxy, |
| const ConnectNamespaceRequest& request, base::ScopedFD fd_remote, |
| ConnectNamespaceResponse* response, brillo::ErrorPtr* error) { |
| return proxy->ConnectNamespace(request, fd_remote, response, error); |
| }, |
| proxy_.get(), request, std::move(fd_remote), &response, &error)); |
| if (!result) { |
| LOG(ERROR) << "ConnectNamespace failed: " << error->GetMessage(); |
| return {}; |
| } |
| |
| if (response.peer_ifname().empty() || response.host_ifname().empty()) { |
| LOG(ERROR) << "ConnectNamespace for netns pid " << pid << " failed"; |
| return {}; |
| } |
| |
| const auto connected_ns = ConvertConnectedNamespace(response); |
| if (!connected_ns) { |
| LOG(ERROR) << "Failed to convert ConnectedNamespace"; |
| return {}; |
| } |
| |
| LOG(INFO) << "ConnectNamespace for netns pid " << pid |
| << " succeeded: peer_ifname=" << connected_ns->peer_ifname |
| << " peer_ipv4_address=" << connected_ns->peer_ipv4_address |
| << " host_ifname=" << connected_ns->host_ifname |
| << " host_ipv4_address=" << connected_ns->host_ipv4_address |
| << " subnet=" << connected_ns->ipv4_subnet.ToString(); |
| |
| return std::make_pair(std::move(fd_local), *connected_ns); |
| } |
| |
| void ClientImpl::GetTrafficCounters(const std::set<std::string>& devices, |
| GetTrafficCountersCallback callback) { |
| TrafficCountersRequest request; |
| for (const auto& device : devices) { |
| request.add_devices(device); |
| } |
| |
| RunOnDBusThreadAsync(base::BindOnce( |
| [](PatchPanelProxyInterface* proxy, const TrafficCountersRequest& request, |
| GetTrafficCountersCallback callback) { |
| auto split_callback = SplitOnceCallback(std::move(callback)); |
| proxy->GetTrafficCountersAsync( |
| request, |
| base::BindOnce(&OnGetTrafficCountersDBusResponse, |
| std::move(split_callback.first)), |
| base::BindOnce(&OnGetTrafficCountersError, |
| std::move(split_callback.second))); |
| }, |
| proxy_.get(), request, |
| base::BindPostTaskToCurrentDefault(std::move(callback)))); |
| } |
| |
| bool ClientImpl::ModifyPortRule(Client::FirewallRequestOperation op, |
| Client::FirewallRequestType type, |
| Client::FirewallRequestProtocol proto, |
| const std::string& input_ifname, |
| const std::string& input_dst_ip, |
| uint32_t input_dst_port, |
| const std::string& dst_ip, |
| uint32_t dst_port) { |
| ModifyPortRuleRequest request; |
| request.set_op(ConvertFirewallRequestOperation(op)); |
| request.set_type(ConvertFirewallRequestType(type)); |
| request.set_proto(ConvertFirewallRequestProtocol(proto)); |
| request.set_input_ifname(input_ifname); |
| request.set_input_dst_ip(input_dst_ip); |
| request.set_input_dst_port(input_dst_port); |
| request.set_dst_ip(dst_ip); |
| request.set_dst_port(dst_port); |
| |
| // TODO(b/284797476): Switch permission_brokker to use the async DBus call. |
| ModifyPortRuleResponse response; |
| brillo::ErrorPtr error; |
| const bool result = RunOnDBusThreadSync(base::BindOnce( |
| [](PatchPanelProxyInterface* proxy, const ModifyPortRuleRequest& request, |
| ModifyPortRuleResponse* response, brillo::ErrorPtr* error) { |
| return proxy->ModifyPortRule(request, response, error); |
| }, |
| proxy_.get(), request, &response, &error)); |
| if (!result) { |
| LOG(ERROR) << "ModifyPortRule failed: " << error->GetMessage(); |
| return false; |
| } |
| |
| if (!response.success()) { |
| LOG(ERROR) << "ModifyPortRuleRequest failed " << request; |
| return false; |
| } |
| return true; |
| } |
| |
| void ClientImpl::SetVpnLockdown(bool enable) { |
| SetVpnLockdownRequest request; |
| request.set_enable_vpn_lockdown(enable); |
| |
| RunOnDBusThreadAsync(base::BindOnce( |
| [](PatchPanelProxyInterface* proxy, |
| const SetVpnLockdownRequest& request) { |
| // This API doesn't return anything. |
| auto success_callback = base::DoNothing(); |
| // The current use case do not care about failures. Leaving a log is |
| // enough now. |
| auto error_callback = [](brillo::Error* error) { |
| LOG(ERROR) << "SetVpnLockdown failed: " << error->GetMessage(); |
| }; |
| proxy->SetVpnLockdownAsync(request, success_callback, |
| base::BindOnce(error_callback)); |
| }, |
| proxy_.get(), request)); |
| } |
| |
| base::ScopedFD ClientImpl::RedirectDns( |
| Client::DnsRedirectionRequestType type, |
| const std::string& input_ifname, |
| const std::string& proxy_address, |
| const std::vector<std::string>& nameservers, |
| const std::string& host_ifname) { |
| SetDnsRedirectionRuleRequest request; |
| request.set_type(ConvertDnsRedirectionRequestType(type)); |
| request.set_input_ifname(input_ifname); |
| request.set_proxy_address(proxy_address); |
| request.set_host_ifname(host_ifname); |
| for (const auto& nameserver : nameservers) { |
| request.add_nameservers(nameserver); |
| } |
| |
| // Prepare an fd pair and append one fd directly after the serialized request. |
| auto [fd_local, fd_remote] = CreateLifelineFd(); |
| if (!fd_local.is_valid()) { |
| LOG(ERROR) << "Cannot send SetDnsRedirectionRuleRequest message to " |
| "patchpanel: no lifeline fd"; |
| return {}; |
| } |
| |
| SetDnsRedirectionRuleResponse response; |
| brillo::ErrorPtr error; |
| const bool result = RunOnDBusThreadSync(base::BindOnce( |
| [](PatchPanelProxyInterface* proxy, |
| const SetDnsRedirectionRuleRequest& request, base::ScopedFD fd_remote, |
| SetDnsRedirectionRuleResponse* response, brillo::ErrorPtr* error) { |
| return proxy->SetDnsRedirectionRule(request, fd_remote, response, |
| error); |
| }, |
| proxy_.get(), request, std::move(fd_remote), &response, &error)); |
| if (!result) { |
| LOG(ERROR) << "SetDnsRedirectionRule failed: " << error->GetMessage(); |
| return {}; |
| } |
| |
| if (!response.success()) { |
| LOG(ERROR) << "SetDnsRedirectionRuleRequest failed " << request; |
| return {}; |
| } |
| return std::move(fd_local); |
| } |
| |
| std::vector<Client::VirtualDevice> ClientImpl::GetDevices() { |
| // TODO(b/284797476): Add a DBus service in dns-proxy to let patchpanel push |
| // information to dns-proxy. |
| GetDevicesResponse response; |
| brillo::ErrorPtr error; |
| const bool result = RunOnDBusThreadSync(base::BindOnce( |
| [](PatchPanelProxyInterface* proxy, GetDevicesResponse* response, |
| brillo::ErrorPtr* error) { |
| return proxy->GetDevices({}, response, error); |
| }, |
| proxy_.get(), &response, &error)); |
| if (!result) { |
| LOG(ERROR) << "GetDevices failed: " << error->GetMessage(); |
| return {}; |
| } |
| |
| std::vector<Client::VirtualDevice> devices; |
| for (const auto& d : response.devices()) { |
| const auto device = ConvertVirtualDevice(d); |
| if (device) { |
| devices.push_back(*device); |
| } |
| } |
| return devices; |
| } |
| |
| void ClientImpl::RegisterVirtualDeviceEventHandler( |
| VirtualDeviceEventHandler handler) { |
| proxy_->RegisterNetworkDeviceChangedSignalHandler( |
| base::BindRepeating(OnNetworkDeviceChanged, std::move(handler)), |
| base::BindOnce(OnSignalConnectedCallback)); |
| } |
| |
| void ClientImpl::RegisterNeighborReachabilityEventHandler( |
| NeighborReachabilityEventHandler handler) { |
| proxy_->RegisterNeighborReachabilityEventSignalHandler( |
| base::BindRepeating(OnNeighborReachabilityEvent, std::move(handler)), |
| base::BindOnce(OnSignalConnectedCallback)); |
| } |
| |
| bool ClientImpl::CreateTetheredNetwork( |
| const std::string& downstream_ifname, |
| const std::string& upstream_ifname, |
| const std::optional<DHCPOptions>& dhcp_options, |
| const std::optional<UplinkIPv6Configuration>& uplink_ipv6_config, |
| const std::optional<int>& mtu, |
| CreateTetheredNetworkCallback callback) { |
| TetheredNetworkRequest request; |
| request.set_ifname(downstream_ifname); |
| request.set_upstream_ifname(upstream_ifname); |
| if (mtu) { |
| request.set_mtu(*mtu); |
| } |
| if (dhcp_options.has_value()) { |
| auto* ipv4_config = request.mutable_ipv4_config(); |
| ipv4_config->set_use_dhcp(true); |
| for (const auto& dns_server : dhcp_options->dns_server_addresses) { |
| ipv4_config->add_dns_servers(dns_server.ToByteString()); |
| } |
| for (const auto& domain_search : dhcp_options->domain_search_list) { |
| ipv4_config->add_domain_searches(domain_search); |
| } |
| if (dhcp_options->is_android_metered) { |
| auto options = ipv4_config->add_options(); |
| // RFC 3925 defines the DHCP option 43 is Vendor Specific. |
| options->set_code(43); |
| options->set_content("ANDROID_METERED"); |
| } |
| } |
| request.set_enable_ipv6(true); |
| if (uplink_ipv6_config.has_value()) { |
| auto* ipv6_config = request.mutable_uplink_ipv6_config(); |
| auto* uplink_ipv6_cidr = ipv6_config->mutable_uplink_ipv6_cidr(); |
| uplink_ipv6_cidr->set_addr( |
| uplink_ipv6_config->uplink_address.address().ToByteString()); |
| uplink_ipv6_cidr->set_prefix_len( |
| uplink_ipv6_config->uplink_address.prefix_length()); |
| for (const auto& dns_server : uplink_ipv6_config->dns_server_addresses) { |
| ipv6_config->add_dns_servers(dns_server.ToByteString()); |
| } |
| } |
| |
| // Prepare an fd pair and append one fd directly after the serialized request. |
| auto [fd_local, fd_remote] = CreateLifelineFd(); |
| if (!fd_local.is_valid()) { |
| LOG(ERROR) << kCreateTetheredNetworkMethod << "(" << downstream_ifname |
| << "," << upstream_ifname << "): Cannot create lifeline fds"; |
| return false; |
| } |
| |
| RunOnDBusThreadAsync(base::BindOnce( |
| [](PatchPanelProxyInterface* proxy, const TetheredNetworkRequest& request, |
| base::ScopedFD fd_local, base::ScopedFD fd_remote, |
| CreateTetheredNetworkCallback callback) { |
| auto split_callback = SplitOnceCallback(std::move(callback)); |
| proxy->CreateTetheredNetworkAsync( |
| request, fd_remote, |
| base::BindOnce(&OnTetheredNetworkResponse, |
| std::move(split_callback.first), |
| std::move(fd_local)), |
| base::BindOnce(&OnTetheredNetworkError, |
| std::move(split_callback.second))); |
| }, |
| proxy_.get(), request, std::move(fd_local), std::move(fd_remote), |
| base::BindPostTaskToCurrentDefault(std::move(callback)))); |
| |
| return true; |
| } |
| |
| bool ClientImpl::CreateLocalOnlyNetwork( |
| const std::string& ifname, CreateLocalOnlyNetworkCallback callback) { |
| LocalOnlyNetworkRequest request; |
| request.set_ifname(ifname); |
| auto* ipv4_config = request.mutable_ipv4_config(); |
| ipv4_config->set_use_dhcp(true); |
| |
| // Prepare an fd pair and append one fd directly after the serialized request. |
| auto [fd_local, fd_remote] = CreateLifelineFd(); |
| if (!fd_local.is_valid()) { |
| LOG(ERROR) << kCreateLocalOnlyNetworkMethod |
| << ": Cannot create lifeline fds"; |
| return false; |
| } |
| |
| RunOnDBusThreadAsync(base::BindOnce( |
| [](PatchPanelProxyInterface* proxy, |
| const LocalOnlyNetworkRequest& request, base::ScopedFD fd_local, |
| base::ScopedFD fd_remote, CreateLocalOnlyNetworkCallback callback) { |
| auto split_callback = SplitOnceCallback(std::move(callback)); |
| proxy->CreateLocalOnlyNetworkAsync( |
| request, fd_remote, |
| base::BindOnce(&OnLocalOnlyNetworkResponse, |
| std::move(split_callback.first), |
| std::move(fd_local)), |
| base::BindOnce(&OnLocalOnlyNetworkError, |
| std::move(split_callback.second))); |
| }, |
| proxy_.get(), request, std::move(fd_local), std::move(fd_remote), |
| base::BindPostTaskToCurrentDefault(std::move(callback)))); |
| |
| return true; |
| } |
| |
| bool ClientImpl::GetDownstreamNetworkInfo( |
| const std::string& ifname, GetDownstreamNetworkInfoCallback callback) { |
| GetDownstreamNetworkInfoRequest request; |
| request.set_downstream_ifname(ifname); |
| |
| RunOnDBusThreadAsync(base::BindOnce( |
| [](PatchPanelProxyInterface* proxy, |
| const GetDownstreamNetworkInfoRequest& request, |
| GetDownstreamNetworkInfoCallback callback) { |
| auto split_callback = SplitOnceCallback(std::move(callback)); |
| proxy->GetDownstreamNetworkInfoAsync( |
| request, |
| base::BindOnce(&OnGetDownstreamNetworkInfoResponse, |
| std::move(split_callback.first)), |
| base::BindOnce(&OnGetDownstreamNetworkInfoError, |
| std::move(split_callback.second))); |
| }, |
| proxy_.get(), request, |
| base::BindPostTaskToCurrentDefault(std::move(callback)))); |
| |
| return true; |
| } |
| |
| bool ClientImpl::ConfigureNetwork(int interface_index, |
| std::string_view interface_name, |
| uint32_t area, |
| const net_base::NetworkConfig& network_config, |
| net_base::NetworkPriority priority, |
| NetworkTechnology technology, |
| ConfigureNetworkCallback callback) { |
| ConfigureNetworkRequest request; |
| request.set_technology(ConvertNetworkTechnology(technology)); |
| request.set_ifindex(interface_index); |
| request.set_ifname(std::string(interface_name)); |
| request.set_area(area); |
| auto request_priority = request.mutable_priority(); |
| request_priority->set_is_primary_logical(priority.is_primary_logical); |
| request_priority->set_is_primary_physical(priority.is_primary_physical); |
| request_priority->set_is_primary_for_dns(priority.is_primary_for_dns); |
| request_priority->set_ranking_order(priority.ranking_order); |
| |
| SerializeNetworkConfig(network_config, request.mutable_network_config()); |
| |
| RunOnDBusThreadAsync(base::BindOnce( |
| [](PatchPanelProxyInterface* proxy, |
| const ConfigureNetworkRequest& request, |
| std::string_view interface_name, ConfigureNetworkCallback callback) { |
| auto split_callback = SplitOnceCallback(std::move(callback)); |
| proxy->ConfigureNetworkAsync( |
| request, |
| base::BindOnce(&OnConfigureNetworkResponse, |
| std::move(split_callback.first), |
| std::string(interface_name)), |
| base::BindOnce(&OnConfigureNetworkError, |
| std::move(split_callback.second), |
| std::string(interface_name))); |
| }, |
| proxy_.get(), request, interface_name, |
| base::BindPostTaskToCurrentDefault(std::move(callback)))); |
| return true; |
| } |
| |
| bool ClientImpl::SendSetFeatureFlagRequest(FeatureFlag flag, bool enable) { |
| SetFeatureFlagRequest request; |
| request.set_enabled(enable); |
| request.set_flag(ConvertFeatureFlag(flag)); |
| |
| SetFeatureFlagResponse response; |
| brillo::ErrorPtr error; |
| |
| const bool result = RunOnDBusThreadSync(base::BindOnce( |
| [](PatchPanelProxyInterface* proxy, const SetFeatureFlagRequest& request, |
| SetFeatureFlagResponse* response, brillo::ErrorPtr* error) { |
| return proxy->SetFeatureFlag(request, response, error); |
| }, |
| proxy_.get(), request, &response, &error)); |
| |
| if (!result) { |
| LOG(ERROR) << "Failed to set feature flag of " << flag << ": " |
| << error->GetMessage(); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| bool ClientImpl::TagSocket(base::ScopedFD fd, |
| std::optional<int> network_id, |
| std::optional<VpnRoutingPolicy> vpn_policy, |
| std::optional<TrafficAnnotation> traffic_annotation, |
| TagSocketCallback callback) { |
| TagSocketRequest request; |
| if (network_id.has_value()) { |
| request.set_network_id(network_id.value()); |
| } |
| if (vpn_policy.has_value()) { |
| request.set_vpn_policy(ConvertVpnRoutingPolicy(vpn_policy.value())); |
| } |
| if (traffic_annotation.has_value()) { |
| auto annotation = request.mutable_traffic_annotation(); |
| annotation->set_host_id( |
| ConvertTrafficAnnotationId(traffic_annotation.value().id)); |
| } |
| |
| TagSocketResponse response; |
| brillo::ErrorPtr error; |
| |
| RunOnDBusThreadAsync(base::BindOnce( |
| [](PatchPanelProxyInterface* proxy, const TagSocketRequest& request, |
| base::ScopedFD fd, TagSocketCallback callback) { |
| auto split_callback = SplitOnceCallback(std::move(callback)); |
| proxy->TagSocketAsync(request, fd, |
| base::BindOnce(&OnTagSocketResponse, |
| std::move(split_callback.first)), |
| base::BindOnce(&OnTagSocketError, |
| std::move(split_callback.second))); |
| }, |
| proxy_.get(), request, std::move(fd), |
| base::BindPostTaskToCurrentDefault(std::move(callback)))); |
| |
| return true; |
| } |
| |
| bool OnSocketAnnotation(base::WeakPtr<ClientImpl> client, |
| const Client::TrafficAnnotationId& id, |
| int fd) { |
| // The callback might be still registered in the transport while the client |
| // has been destroyed. Ensure the client is still valid before doing anything |
| // else (see b/345769752). |
| if (!client) { |
| LOG(ERROR) << __func__ << ": client is not valid anymore"; |
| return false; |
| } |
| |
| // The socket fd has to be duplicated to prevent the DBus proxy base::ScopedFD |
| // to close the fd owned by curl. |
| int tag_fd = dup(fd); |
| if (tag_fd < 0) { |
| LOG(ERROR) << __func__ << ": failed to dup socket descriptor"; |
| return false; |
| } |
| |
| Client::TrafficAnnotation annotation(id); |
| // TODO(b/331620358) use a synchronous call to a dedicated TagSocket service |
| // to guarantee the socket is tagged when the call returns. |
| return client->TagSocket(base::ScopedFD(tag_fd), std::nullopt, std::nullopt, |
| std::move(annotation), base::DoNothing()); |
| } |
| |
| void ClientImpl::PrepareTagSocket( |
| const TrafficAnnotation& annotation, |
| std::shared_ptr<brillo::http::Transport> transport) { |
| // Bind OnSocketAnnotation as a RepeatingCallback with the annotation id as a |
| // bound parameter. |
| transport->SetSockOptCallback(base::BindRepeating( |
| &OnSocketAnnotation, weak_factory_.GetWeakPtr(), annotation.id)); |
| } |
| |
| } // namespace |
| |
| void SerializeNetworkConfig(const net_base::NetworkConfig& in, |
| patchpanel::NetworkConfig* out) { |
| if (in.ipv4_address) { |
| auto* ipv4_address = out->mutable_ipv4_address(); |
| ipv4_address->set_addr(in.ipv4_address->address().ToByteString()); |
| ipv4_address->set_prefix_len(in.ipv4_address->prefix_length()); |
| } |
| if (in.ipv4_broadcast) { |
| out->set_ipv4_broadcast(in.ipv4_broadcast->ToByteString()); |
| } |
| if (in.ipv4_gateway) { |
| out->set_ipv4_gateway(in.ipv4_gateway->ToByteString()); |
| } |
| |
| for (const auto& ipv6_address : in.ipv6_addresses) { |
| auto* out_addr = out->add_ipv6_addresses(); |
| out_addr->set_addr(ipv6_address.address().ToByteString()); |
| out_addr->set_prefix_len(ipv6_address.prefix_length()); |
| } |
| if (in.ipv6_gateway) { |
| out->set_ipv6_gateway(in.ipv6_gateway->ToByteString()); |
| } |
| |
| out->set_ipv6_blackhole_route(in.ipv6_blackhole_route); |
| |
| for (const auto& prefix : in.excluded_route_prefixes) { |
| auto* out_prefix = out->add_excluded_route_prefixes(); |
| out_prefix->set_addr(prefix.address().ToByteString()); |
| out_prefix->set_prefix_len(prefix.prefix_length()); |
| } |
| for (const auto& prefix : in.included_route_prefixes) { |
| auto* out_prefix = out->add_included_route_prefixes(); |
| out_prefix->set_addr(prefix.address().ToByteString()); |
| out_prefix->set_prefix_len(prefix.prefix_length()); |
| } |
| for (const auto& route : in.rfc3442_routes) { |
| auto* out_route = out->add_rfc3442_routes(); |
| auto* out_prefix = out_route->mutable_prefix(); |
| out_prefix->set_addr(route.first.address().ToByteString()); |
| out_prefix->set_prefix_len(route.first.prefix_length()); |
| out_route->set_gateway(route.second.ToByteString()); |
| } |
| |
| for (const auto& dns : in.dns_servers) { |
| out->add_dns_servers(dns.ToByteString()); |
| } |
| for (const auto& dnssl : in.dns_search_domains) { |
| out->add_dns_search_domains(dnssl); |
| } |
| if (in.mtu) { |
| out->set_mtu(*in.mtu); |
| } |
| |
| if (in.captive_portal_uri) { |
| out->set_captive_portal_uri(in.captive_portal_uri->ToString()); |
| } |
| } |
| |
| // static |
| std::unique_ptr<Client> Client::New() { |
| dbus::Bus::Options opts; |
| opts.bus_type = dbus::Bus::SYSTEM; |
| scoped_refptr<dbus::Bus> bus(new dbus::Bus(std::move(opts))); |
| |
| if (!bus->Connect()) { |
| LOG(ERROR) << "Failed to connect to system bus"; |
| return nullptr; |
| } |
| |
| auto proxy = std::make_unique<org::chromium::PatchPanelProxy>(bus); |
| if (!proxy) { |
| LOG(ERROR) << "Failed to create proxy"; |
| return nullptr; |
| } |
| |
| return std::make_unique<ClientImpl>(std::move(bus), std::move(proxy), |
| /*owns_bus=*/true); |
| } |
| |
| // static |
| std::unique_ptr<Client> Client::New(const scoped_refptr<dbus::Bus>& bus) { |
| auto proxy = std::make_unique<org::chromium::PatchPanelProxy>(bus); |
| if (!proxy) { |
| LOG(ERROR) << "Failed to create proxy"; |
| return nullptr; |
| } |
| return std::make_unique<ClientImpl>(bus, std::move(proxy), |
| /*owns_bus=*/false); |
| } |
| |
| // static |
| std::unique_ptr<Client> Client::NewForTesting( |
| scoped_refptr<dbus::Bus> bus, |
| std::unique_ptr<org::chromium::PatchPanelProxyInterface> proxy) { |
| return std::make_unique<ClientImpl>(std::move(bus), std::move(proxy), |
| /*owns_bus=*/false); |
| } |
| |
| // static |
| bool Client::IsArcGuest(Client::GuestType guest_type) { |
| switch (guest_type) { |
| case Client::GuestType::kArcContainer: |
| case Client::GuestType::kArcVm: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| // static |
| std::string Client::TrafficSourceName( |
| patchpanel::Client::TrafficSource source) { |
| return patchpanel::TrafficCounter::Source_Name(ConvertTrafficSource(source)); |
| } |
| |
| // static |
| std::string Client::ProtocolName( |
| patchpanel::Client::FirewallRequestProtocol protocol) { |
| return patchpanel::ModifyPortRuleRequest::Protocol_Name( |
| ConvertFirewallRequestProtocol(protocol)); |
| } |
| |
| // static |
| std::string Client::NeighborRoleName(patchpanel::Client::NeighborRole role) { |
| return NeighborReachabilityEventSignal::Role_Name(ConvertNeighborRole(role)); |
| } |
| |
| // static |
| std::string Client::NeighborStatusName( |
| patchpanel::Client::NeighborStatus status) { |
| return NeighborReachabilityEventSignal::EventType_Name( |
| ConvertNeighborStatus(status)); |
| } |
| |
| bool Client::TrafficVector::operator==( |
| const Client::TrafficVector& that) const = default; |
| |
| Client::TrafficVector& Client::TrafficVector::operator+=( |
| const TrafficVector& that) { |
| rx_bytes += that.rx_bytes; |
| tx_bytes += that.tx_bytes; |
| rx_packets += that.rx_packets; |
| tx_packets += that.tx_packets; |
| return *this; |
| } |
| |
| Client::TrafficVector& Client::TrafficVector::operator-=( |
| const TrafficVector& that) { |
| rx_bytes -= that.rx_bytes; |
| tx_bytes -= that.tx_bytes; |
| rx_packets -= that.rx_packets; |
| tx_packets -= that.tx_packets; |
| return *this; |
| } |
| |
| Client::TrafficVector Client::TrafficVector::operator+( |
| const TrafficVector& that) const { |
| auto r = *this; |
| r += that; |
| return r; |
| } |
| |
| Client::TrafficVector Client::TrafficVector::operator-( |
| const TrafficVector& that) const { |
| auto r = *this; |
| r -= that; |
| return r; |
| } |
| |
| Client::TrafficVector Client::TrafficVector::operator-() const { |
| auto r = *this; |
| r.rx_bytes = -r.rx_bytes; |
| r.tx_bytes = -r.tx_bytes; |
| r.rx_packets = -r.rx_packets; |
| r.tx_packets = -r.tx_packets; |
| return r; |
| } |
| |
| bool Client::TrafficCounter::operator==( |
| const Client::TrafficCounter& rhs) const = default; |
| |
| BRILLO_EXPORT std::ostream& operator<<( |
| std::ostream& stream, const Client::NeighborReachabilityEvent& event) { |
| return stream << "{ifindex: " << event.ifindex |
| << ", ip_address: " << event.ip_addr |
| << ", role: " << Client::NeighborRoleName(event.role) |
| << ", status: " << Client::NeighborStatusName(event.status) |
| << "}"; |
| } |
| |
| BRILLO_EXPORT std::ostream& operator<<( |
| std::ostream& stream, const Client::NetworkTechnology& technology) { |
| switch (technology) { |
| case Client::NetworkTechnology::kCellular: |
| return stream << "Cellular"; |
| case Client::NetworkTechnology::kEthernet: |
| return stream << "Ethernet"; |
| case Client::NetworkTechnology::kVPN: |
| return stream << "VPN"; |
| case Client::NetworkTechnology::kWiFi: |
| return stream << "WiFi"; |
| } |
| } |
| |
| BRILLO_EXPORT std::ostream& operator<<( |
| std::ostream& stream, const Client::TrafficSource& traffic_source) { |
| switch (traffic_source) { |
| case patchpanel::Client::TrafficSource::kUnknown: |
| return stream << "Unknown"; |
| case patchpanel::Client::TrafficSource::kChrome: |
| return stream << "Chrome"; |
| case patchpanel::Client::TrafficSource::kUser: |
| return stream << "User"; |
| case patchpanel::Client::TrafficSource::kUpdateEngine: |
| return stream << "UE"; |
| case patchpanel::Client::TrafficSource::kSystem: |
| return stream << "System"; |
| case patchpanel::Client::TrafficSource::kVpn: |
| return stream << "VPN"; |
| case patchpanel::Client::TrafficSource::kArc: |
| return stream << "ARC"; |
| case patchpanel::Client::TrafficSource::kBorealisVM: |
| return stream << "Borealis"; |
| case patchpanel::Client::TrafficSource::kBruschettaVM: |
| return stream << "Bruschetta"; |
| case patchpanel::Client::TrafficSource::kCrostiniVM: |
| return stream << "Crostini"; |
| case patchpanel::Client::TrafficSource::kParallelsVM: |
| return stream << "Parallels"; |
| case patchpanel::Client::TrafficSource::kTethering: |
| return stream << "Tethering"; |
| case patchpanel::Client::TrafficSource::kWiFiDirect: |
| return stream << "WiFi Direct"; |
| case patchpanel::Client::TrafficSource::kWiFiLOHS: |
| return stream << "WiFi LOHS"; |
| } |
| } |
| |
| BRILLO_EXPORT std::ostream& operator<<( |
| std::ostream& stream, const Client::TrafficVector& traffic_vector) { |
| return stream << "[rx=" << traffic_vector.rx_bytes |
| << ", tx=" << traffic_vector.tx_bytes << "]"; |
| } |
| |
| } // namespace patchpanel |
