Method parseFromFile

src/Library/UMockdevDeviceDefinition.cpp:267–325

  }

  std::vector<std::unique_ptr<UMockdevDeviceDefinition>> UMockdevDeviceDefinition::parseFromFile(const std::string& filepath,
      bool sort_by_hierarchy)
  {
    const std::string umockdev_name = filenameFromPath(filepath, /*include_extension=*/true);
    std::vector<std::unique_ptr<UMockdevDeviceDefinition>> definitions;

    try {
      USBGUARD_LOG(Debug) << "Parsing umockdev definitions from " << filepath;
      tao::pegtl::file_input<> input(filepath);
      tao::pegtl::parse<UMockdevParser::grammar, UMockdevParser::actions>(input, definitions, umockdev_name);
      USBGUARD_LOG(Debug) << "Parsed " << definitions.size() << " definition(s)";
    }
    catch (...) {
      USBGUARD_LOG(Error) << "UMockdevDeviceDefinition: " << filepath << ": parsing failed at line <LINE>";
      throw;
    }

    const auto lambdaSysfsPathHierarchyCompare = [](const std::unique_ptr<UMockdevDeviceDefinition>& a,
    const std::unique_ptr<UMockdevDeviceDefinition>& b) {
      const std::string full_a = a->getSysfsPath();
      const std::string full_b = b->getSysfsPath();
      const std::size_t component_count_a = countPathComponents(full_a);
      const std::size_t component_count_b = countPathComponents(full_b);
      USBGUARD_LOG(Debug) << "c_c_a=" << component_count_a << " c_c_b=" << component_count_b;

      if (component_count_a < component_count_b) {
        return true;
      }
      else if (component_count_a > component_count_b) {
        return false;
      }

      const std::string base_a = filenameFromPath(full_a, /*include_extension=*/true);
      const std::string base_b = filenameFromPath(full_b, /*include_extension=*/true);
      const bool a_has_usb_prefix = hasPrefix("usb", base_a);
      const bool b_has_usb_prefix = hasPrefix("usb", base_b);
      USBGUARD_LOG(Debug) << "a_p=" << a_has_usb_prefix << " b_p=" << b_has_usb_prefix;

      if (a_has_usb_prefix) {
        if (!b_has_usb_prefix) {
          return true;
        }
      }
      else {
        if (b_has_usb_prefix) {
          return false;
        }
      }

      return base_a < base_b;
    };

    if (sort_by_hierarchy) {
      USBGUARD_LOG(Debug) << "Sorting definitions";
      std::sort(definitions.begin(), definitions.end(), lambdaSysfsPathHierarchyCompare);
    }

    return definitions;