patchpanel/routing_service.cc

// Copyright 2020 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/routing_service.h"

#include <iostream>
#include <optional>
#include <string_view>

#include <base/containers/fixed_flat_map.h>
#include <base/logging.h>
#include <base/strings/strcat.h>

namespace patchpanel {

// Make sure that the compiler is not doing padding.
static_assert(sizeof(Fwmark) == sizeof(uint32_t));

RoutingService::RoutingService() {}

int RoutingService::GetSockopt(
    int sockfd, int level, int optname, void* optval, socklen_t* optlen) {
  return getsockopt(sockfd, level, optname, optval, optlen);
}

int RoutingService::SetSockopt(
    int sockfd, int level, int optname, const void* optval, socklen_t optlen) {
  return setsockopt(sockfd, level, optname, optval, optlen);
}

bool RoutingService::SetFwmark(int sockfd, Fwmark mark, Fwmark mask) {
  uint32_t fwmark_value = 0;
  socklen_t fwmark_len = sizeof(fwmark_value);
  if (GetSockopt(sockfd, SOL_SOCKET, SO_MARK, &fwmark_value, &fwmark_len) < 0) {
    PLOG(ERROR) << "SetFwmark mark=" << mark.ToString()
                << " mask=" << mask.ToString()
                << " getsockopt SOL_SOCKET SO_MARK failed";
    return false;
  }

  fwmark_value = (mark & mask).Value() | (fwmark_value & ~mask.Value());

  fwmark_len = sizeof(fwmark_value);
  if (SetSockopt(sockfd, SOL_SOCKET, SO_MARK, &fwmark_value, fwmark_len) < 0) {
    PLOG(ERROR) << "SetFwmark mark=" << mark.ToString()
                << " mask=" << mask.ToString()
                << " setsockopt SOL_SOCKET SO_MARK failed";
    return false;
  }

  return true;
}

bool RoutingService::TagSocket(
    int sockfd,
    std::optional<int> network_id,
    VPNRoutingPolicy vpn_policy,
    std::optional<TrafficAnnotationId> annotation_id) {
  if (vpn_policy == VPNRoutingPolicy::kRouteOnVPN && network_id.has_value()) {
    LOG(ERROR) << __func__
               << ": route_on_vpn policy and network_id should not be set at "
                  "the same time";
    return false;
  }

  if (annotation_id.has_value()) {
    // TODO(b/331744250): add fwmark to mark the socket as audited.
    return true;
  }

  // TODO(b/322083502): Do some basic verification that this socket is not
  // connected.

  Fwmark mark = {.fwmark = 0};

  if (network_id.has_value()) {
    // TODO(b/322083502): Assume network_id is interface_id now so that we can
    // test this function. Change this to the real implementation after
    // network_id is ready.
    mark.rt_table_id =
        kInterfaceTableIdIncrement + static_cast<uint16_t>(*network_id);
  }

  switch (vpn_policy) {
    case VPNRoutingPolicy::kDefault:
      break;
    case VPNRoutingPolicy::kRouteOnVPN:
      mark = mark | kFwmarkRouteOnVpn;
      break;
    case VPNRoutingPolicy::kBypassVPN:
      mark = mark | kFwmarkBypassVpn;
      break;
  }

  const auto mask = kFwmarkRoutingMask | kFwmarkVpnMask;
  LOG(INFO) << "SetFwmark mark=" << mark.ToString()
            << " mask=" << mask.ToString();
  return SetFwmark(sockfd, mark, mask);
}

std::string QoSFwmarkWithMask(QoSCategory category) {
  auto mark = Fwmark::FromQoSCategory(category);
  return base::StrCat(
      {mark.ToString(), "/", kFwmarkQoSCategoryMask.ToString()});
}

std::string SourceFwmarkWithMask(TrafficSource source) {
  auto mark = Fwmark::FromSource(source);
  return base::StrCat({mark.ToString(), "/", kFwmarkAllSourcesMask.ToString()});
}

std::string_view TrafficSourceName(TrafficSource source) {
  static constexpr auto kTrafficSourceNames =
      base::MakeFixedFlatMap<TrafficSource, std::string_view>({
          {kArc, "ARC"},
          {kArcVpn, "ARC_VPN"},
          {kBorealisVM, "BOREALIS_VM"},
          {kBruschettaVM, "BRUSCHETTA_VM"},
          {kChrome, "CHROME"},
          {kCrostiniVM, "CROSTINI_VM"},
          {kHostVpn, "HOST_VPN"},
          {kParallelsVM, "PARALLELS_VM"},
          {kSystem, "SYSTEM"},
          {kTetherDownstream, "TETHER_DOWNSTREAM"},
          {kUnknown, "UNKNOWN"},
          {kUpdateEngine, "UPDATE_ENGINE"},
          {kUser, "USER"},
          {kWiFiDirect, "WIFI_DIRECT"},
          {kWiFiLOHS, "WIFI_LOHS"},
      });
  const auto it = kTrafficSourceNames.find(source);
  return it != kTrafficSourceNames.end() ? it->second : "UNKNOWN";
}

std::ostream& operator<<(std::ostream& stream, const LocalSourceSpecs& source) {
  return stream << "{source: " << TrafficSourceName(source.source_type)
                << ", uid: " << (source.uid_name ? source.uid_name : "")
                << ", classid: " << source.classid
                << ", is_on_vpn: " << (source.is_on_vpn ? "true" : "false")
                << "}";
}

}  // namespace patchpanel