cfacter 3.11.0.rc.20180314

data/ext/facter/facter/lib/src/facts/linux/fips_resolver.cc

@@ -0,0 +1,31 @@
+#include <internal/facts/linux/fips_resolver.hpp>
+#include <leatherman/file_util/file.hpp>
+#include <boost/algorithm/string.hpp>
+#include <boost/lexical_cast.hpp>
+
+using namespace std;
+
+using boost::lexical_cast;
+using boost::bad_lexical_cast;
+
+namespace lth_file = leatherman::file_util;
+
+namespace facter { namespace facts { namespace linux {
+
+    fips_resolver::data fips_resolver::collect_data(collection& facts)
+    {
+        data result;
+
+        // Set a safe default
+        result.is_fips_mode_enabled = false;
+
+        lth_file::each_line("/proc/sys/crypto/fips_enabled", [&](string& line) {
+            boost::trim(line);
+            result.is_fips_mode_enabled = line != "0";
+
+            return true;
+        });
+        return result;
+    }
+
+}}}  // namespace facter::facts::linux

data/ext/facter/facter/lib/src/facts/linux/kernel_resolver.cc

@@ -0,0 +1,20 @@
+#include <internal/facts/linux/kernel_resolver.hpp>
+#include <leatherman/util/regex.hpp>
+#include <boost/regex.hpp>
+#include <tuple>
+
+using namespace std;
+using namespace leatherman::util;
+
+namespace facter { namespace facts { namespace linux {
+
+    tuple<string, string> kernel_resolver::parse_version(string const& version) const
+    {
+        string major, minor;
+        if (re_search(version, boost::regex("(\\d+\\.\\d+)(.*)"), &major, &minor)) {
+            return make_tuple(major, minor);
+        }
+        return make_tuple(move(version), string());
+    }
+
+}}}  // namespace facter::facts::resolvers

data/ext/facter/facter/lib/src/facts/linux/memory_resolver.cc

@@ -0,0 +1,50 @@
+#include <internal/facts/linux/memory_resolver.hpp>
+#include <leatherman/file_util/file.hpp>
+#include <boost/algorithm/string.hpp>
+#include <boost/lexical_cast.hpp>
+
+using namespace std;
+
+using boost::lexical_cast;
+using boost::bad_lexical_cast;
+
+namespace lth_file = leatherman::file_util;
+
+namespace facter { namespace facts { namespace linux {
+
+    memory_resolver::data memory_resolver::collect_data(collection& facts)
+    {
+        data result;
+        lth_file::each_line("/proc/meminfo", [&](string& line) {
+            uint64_t* variable = nullptr;
+            if (boost::starts_with(line, "MemTotal:")) {
+                variable = &result.mem_total;
+            } else if (boost::starts_with(line, "MemFree:") ||
+                       boost::starts_with(line, "Buffers:") ||
+                       boost::starts_with(line, "Cached:")) {
+                variable = &result.mem_free;
+            } else if (boost::starts_with(line, "SwapTotal:")) {
+                variable = &result.swap_total;
+            } else if (boost::starts_with(line, "SwapFree:")) {
+                variable = &result.swap_free;
+            }
+            if (!variable) {
+                return true;
+            }
+
+            vector<boost::iterator_range<string::iterator>> parts;
+            boost::split(parts, line, boost::is_space(), boost::token_compress_on);
+            if (parts.size() < 2) {
+                return true;
+            }
+
+            try {
+                *variable += lexical_cast<uint64_t>(parts[1]) * 1024;
+            } catch (bad_lexical_cast&) {
+            }
+            return true;
+        });
+        return result;
+    }
+
+}}}  // namespace facter::facts::linux

data/ext/facter/facter/lib/src/facts/linux/networking_resolver.cc

@@ -0,0 +1,275 @@
+#include <internal/facts/linux/networking_resolver.hpp>
+#include <internal/util/posix/scoped_descriptor.hpp>
+#include <leatherman/execution/execution.hpp>
+#include <leatherman/file_util/file.hpp>
+#include <leatherman/logging/logging.hpp>
+#include <boost/algorithm/string.hpp>
+#include <algorithm>
+#include <cstring>
+#include <unordered_set>
+#include <netpacket/packet.h>
+#include <net/if.h>
+#include <sys/ioctl.h>
+
+using namespace std;
+using namespace facter::util::posix;
+
+namespace lth_file = leatherman::file_util;
+namespace lth_exe  = leatherman::execution;
+
+namespace facter { namespace facts { namespace linux {
+
+    networking_resolver::data networking_resolver::collect_data(collection& facts)
+    {
+        read_routing_table();
+        data result = bsd::networking_resolver::collect_data(facts);
+        populate_from_routing_table(result);
+
+        // On linux, the macaddress of bonded interfaces is reported
+        // as the address of the bonding master. We want to report the
+        // original HW address, so we dig it out of /proc
+        for (auto& interface : result.interfaces) {
+            // For each interface we check if we're part of a bond,
+            // and update the `macaddress` fact if we are
+            auto bond_master = get_bond_master(interface.name);
+            if (!bond_master.empty()) {
+                bool in_our_block = false;
+                lth_file::each_line("/proc/net/bonding/"+bond_master, [&](string& line) {
+                    // /proc/net/bonding files are organized into chunks for each slave
+                    // interface. We want to grab the mac address for the block we're in.
+                    if (line == "Slave Interface: " + interface.name) {
+                        in_our_block = true;
+                    } else if (line.find("Slave Interface") != string::npos) {
+                        in_our_block = false;
+                    }
+
+                    // If we're in the block for our iface, we can grab the HW address
+                    if (in_our_block && line.find("Permanent HW addr: ") != string::npos) {
+                        auto split = line.find(':') + 2;
+                        interface.macaddress = line.substr(split, string::npos);
+                        return false;
+                    }
+                    return true;
+                });
+            }
+        }
+        return result;
+    }
+
+    bool networking_resolver::is_link_address(sockaddr const* addr) const
+    {
+        return addr && addr->sa_family == AF_PACKET;
+    }
+
+    uint8_t const* networking_resolver::get_link_address_bytes(sockaddr const* addr) const
+    {
+        if (!is_link_address(addr)) {
+            return nullptr;
+        }
+        sockaddr_ll const* link_addr = reinterpret_cast<sockaddr_ll const*>(addr);
+        if (link_addr->sll_halen != 6) {
+            return nullptr;
+        }
+        return reinterpret_cast<uint8_t const*>(link_addr->sll_addr);
+    }
+
+    boost::optional<uint64_t> networking_resolver::get_link_mtu(string const& interface, void* data) const
+    {
+        // Unfortunately in Linux, the data points at interface statistics
+        // Nothing useful for us, so we need to use ioctl to query the MTU
+        ifreq req;
+        memset(&req, 0, sizeof(req));
+        strncpy(req.ifr_name, interface.c_str(), sizeof(req.ifr_name));
+
+        scoped_descriptor sock(socket(AF_INET, SOCK_DGRAM, 0));
+        if (static_cast<int>(sock) < 0) {
+            LOG_WARNING("socket failed: {1} ({2}): interface MTU fact is unavailable for interface {3}.", strerror(errno), errno, interface);
+            return boost::none;
+        }
+
+        if (ioctl(sock, SIOCGIFMTU, &req) == -1) {
+            LOG_WARNING("ioctl failed: {1} ({2}): interface MTU fact is unavailable for interface {3}.", strerror(errno), errno, interface);
+            return boost::none;
+        }
+        return req.ifr_mtu;
+    }
+
+    string networking_resolver::get_primary_interface() const
+    {
+        // If we have a list of routes, then we'll determine the
+        // primary interface from that later on when we are processing
+        // them.
+        if (routes4.size()) {
+             return {};
+        }
+
+        // Read /proc/net/route to determine the primary interface
+        // We consider the primary interface to be the one that has 0.0.0.0 as the
+        // routing destination.
+        string interface;
+        lth_file::each_line("/proc/net/route", [&interface](string& line) {
+            vector<boost::iterator_range<string::iterator>> parts;
+            boost::split(parts, line, boost::is_space(), boost::token_compress_on);
+            if (parts.size() > 7 && parts[1] == boost::as_literal("00000000")
+                                 && parts[7] == boost::as_literal("00000000")) {
+                interface.assign(parts[0].begin(), parts[0].end());
+                return false;
+            }
+            return true;
+        });
+        return interface;
+    }
+
+    void networking_resolver::read_routing_table()
+    {
+        auto ip_command = lth_exe::which("ip");
+        if (ip_command.empty()) {
+            LOG_DEBUG("Could not find the 'ip' command. Network bindings will not be populated from routing table");
+            return;
+        }
+
+        unordered_set<string> known_route_types {
+            "unicast",
+            "broadcast",
+            "local",
+            "nat",
+            "unreachable",
+            "prohibit",
+            "blackhole",
+            "throw"
+        };
+
+        auto parse_route_line = [&known_route_types](string& line, std::vector<route>& routes) {
+            vector<boost::iterator_range<string::iterator>> parts;
+            boost::split(parts, line, boost::is_space(), boost::token_compress_on);
+
+            // skip links that are linkdown
+            if (std::find_if(parts.cbegin(), parts.cend(), [](const boost::iterator_range<string::iterator>& range) {
+                return std::string(range.begin(), range.end()) == "linkdown";
+            }) != parts.cend()) {
+                return true;
+            }
+
+            // remove trailing "onlink" or "pervasive" flags
+            while (parts.size() > 0) {
+                std::string last_token(parts.back().begin(), parts.back().end());
+                if (last_token == "onlink" || last_token == "pervasive")
+                    parts.pop_back();
+                else
+                    break;
+            }
+
+            size_t dst_idx = 0;
+            if (parts.size() % 2 == 0) {
+                std::string route_type(parts[0].begin(), parts[0].end());
+                if (known_route_types.find(route_type) == known_route_types.end()) {
+                    LOG_WARNING("Could not process routing table entry: Expected a destination followed by key/value pairs, got '{1}'", line);
+                    return true;
+                } else {
+                    dst_idx = 1;
+                }
+            }
+
+            route r;
+            r.destination.assign(parts[dst_idx].begin(), parts[dst_idx].end());
+            // Iterate over key/value pairs and add the ones we care
+            // about to our routes entries
+            for (size_t i = dst_idx+1; i < parts.size(); i += 2) {
+                std::string key(parts[i].begin(), parts[i].end());
+                if (key == "dev") {
+                    r.interface.assign(parts[i+1].begin(), parts[i+1].end());
+                }
+                if (key == "src") {
+                    r.source.assign(parts[i+1].begin(), parts[i+1].end());
+                }
+            }
+            routes.push_back(r);
+            return true;
+        };
+
+        lth_exe::each_line(ip_command, { "route", "show" }, [this, &parse_route_line](string& line) {
+            return parse_route_line(line, this->routes4);
+        });
+        lth_exe::each_line(ip_command, { "-6", "route", "show" }, [this, &parse_route_line](string& line) {
+            return parse_route_line(line, this->routes6);
+        });
+    }
+
+    void networking_resolver::populate_from_routing_table(networking_resolver::data& result) const
+    {
+        for (const auto& r : routes4) {
+            if (r.destination == "default" && result.primary_interface.empty()) {
+                 result.primary_interface = r.interface;
+            }
+            associate_src_with_iface(r, result, [](interface& iface) -> vector<binding>& {
+                return iface.ipv4_bindings;
+            });
+        }
+
+        for (const auto& r : routes6) {
+            associate_src_with_iface(r, result, [](interface& iface) -> vector<binding>& {
+                return iface.ipv6_bindings;
+            });
+        }
+    }
+
+    template<typename F>
+    void networking_resolver::associate_src_with_iface(const networking_resolver::route& r, networking_resolver::data& result, F get_bindings) const {
+        if (!r.source.empty()) {
+            auto iface = find_if(result.interfaces.begin(), result.interfaces.end(), [&](const interface& iface) {
+                return iface.name == r.interface;
+            });
+            if (iface != result.interfaces.end()) {
+                auto& bindings = get_bindings(*iface);
+                auto existing_binding = find_if(bindings.begin(), bindings.end(), [&](const binding& b) {
+                    return b.address == r.source;
+                });
+                if (existing_binding == bindings.end()) {
+                    binding b = { r.source, "", "" };
+                    bindings.emplace_back(move(b));
+                }
+            }
+        }
+    }
+
+    string networking_resolver::get_bond_master(const std::string& name) const {
+        static bool have_logged_about_bonding = false;
+        auto ip_command = lth_exe::which("ip");
+        if (ip_command.empty()) {
+            if (!have_logged_about_bonding) {
+                 LOG_DEBUG("Could not find the 'ip' command. Physical macaddress for bonded interfaces will be incorrect.");
+                 have_logged_about_bonding = true;
+            }
+            return {};
+        }
+
+        string bonding_master;
+
+        lth_exe::each_line(ip_command, {"link", "show", name}, [&bonding_master](string& line) {
+            if (line.find("SLAVE") != string::npos) {
+                vector<boost::iterator_range<string::iterator>> parts;
+                boost::split(parts, line, boost::is_space(), boost::token_compress_on);
+
+                // We have to use find_if here since a boost::iterator_range doesn't compare properly to a string.
+                auto master = find_if(parts.begin(), parts.end(), [](boost::iterator_range<string::iterator>& part){
+                    string p {part.begin(), part.end()};
+                    return p == "master";
+                });
+
+                // the actual master interface is in the output as
+                // "master <iface>". Once we've found the master
+                // string above, we get the next token and return that
+                // as our interface device.
+                if (master != parts.end()) {
+                    auto master_iface = master + 1;
+                    if (master_iface != parts.end()) {
+                        bonding_master.assign(master_iface->begin(), master_iface->end());
+                        return false;
+                    }
+                }
+            }
+            return true;
+        });
+        return bonding_master;
+    }
+}}}  // namespace facter::facts::linux

data/ext/facter/facter/lib/src/facts/linux/operating_system_resolver.cc

@@ -0,0 +1,175 @@
+#include <internal/facts/linux/operating_system_resolver.hpp>
+#include <internal/facts/linux/release_file.hpp>
+#include <internal/facts/linux/os_linux.hpp>
+#include <internal/facts/linux/os_cisco.hpp>
+#include <internal/facts/linux/os_coreos.hpp>
+#include <internal/facts/linux/os_cumulus.hpp>
+#include <facter/facts/os.hpp>
+#include <facter/facts/scalar_value.hpp>
+#include <facter/facts/map_value.hpp>
+#include <facter/facts/collection.hpp>
+#include <leatherman/execution/execution.hpp>
+#include <leatherman/file_util/file.hpp>
+#include <leatherman/util/regex.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/algorithm/string.hpp>
+#include <map>
+#include <vector>
+#include <tuple>
+#include <memory>
+
+using namespace std;
+using namespace leatherman::execution;
+using namespace boost::filesystem;
+using namespace leatherman::util;
+
+namespace lth_file = leatherman::file_util;
+
+namespace facter { namespace facts { namespace linux {
+
+    static unique_ptr<os_linux> get_os()
+    {
+        auto release_info = os_linux::key_value_file(release_file::os, {"NAME", "CISCO_RELEASE_INFO", "ID"});
+        auto const& name = release_info["NAME"];
+        auto const& id = release_info["ID"];
+        if (name == "Cumulus Linux") {
+            return unique_ptr<os_linux>(new os_cumulus());
+        } else if (name == "CoreOS" || id == "coreos") {
+            return unique_ptr<os_linux>(new os_coreos());
+        } else {
+            auto const& cisco = release_info["CISCO_RELEASE_INFO"];
+            boost::system::error_code ec;
+            if (!cisco.empty() && is_regular_file(cisco, ec)) {
+                return unique_ptr<os_linux>(new os_cisco(cisco));
+            }
+        }
+        return unique_ptr<os_linux>(new os_linux());
+    }
+
+    static string get_selinux_mountpoint()
+    {
+        static boost::regex regexp("\\S+ (\\S+) selinuxfs");
+        string mountpoint;
+        lth_file::each_line("/proc/self/mounts", [&](string& line) {
+            if (re_search(line, regexp, &mountpoint)) {
+                return false;
+            }
+            return true;
+        });
+        return mountpoint;
+    }
+
+    operating_system_resolver::selinux_data operating_system_resolver::collect_selinux_data()
+    {
+        selinux_data result;
+        result.supported = true;
+
+        string mountpoint = get_selinux_mountpoint();
+        result.enabled = !mountpoint.empty();
+        if (!result.enabled) {
+            return result;
+        }
+
+        // Get the policy version
+        result.policy_version = lth_file::read(mountpoint + "/policyvers");
+
+        // Check for enforcement
+        string enforce = lth_file::read(mountpoint + "/enforce");
+        if (!enforce.empty()) {
+            if (enforce == "1") {
+                result.enforced = true;
+                result.current_mode = "enforcing";
+            } else {
+                result.current_mode = "permissive";
+            }
+        }
+
+        // Parse the SELinux config for mode and policy
+        static boost::regex mode_regex("(?m)^SELINUX=(\\w+)$");
+        static boost::regex policy_regex("(?m)^SELINUXTYPE=(\\w+)$");
+        lth_file::each_line("/etc/selinux/config", [&](string& line) {
+            if (re_search(line, mode_regex, &result.config_mode)) {
+                return true;
+            }
+            if (re_search(line, policy_regex, &result.config_policy)) {
+                return true;
+            }
+            return true;
+        });
+        return result;
+    }
+
+    operating_system_resolver::data operating_system_resolver::collect_data(collection& facts)
+    {
+        // Default to the base implementation
+        data result = posix::operating_system_resolver::collect_data(facts);
+
+        // Populate distro info
+        each_line("lsb_release", {"-a"}, [&](string& line) {
+            string* variable = nullptr;
+            size_t offset = 0;
+            if (boost::starts_with(line, "LSB Version:")) {
+                variable = &result.specification_version;
+                offset = 12;
+            } else if (boost::starts_with(line, "Distributor ID:")) {
+                variable = &result.distro.id;
+                offset = 15;
+            } else if (boost::starts_with(line, "Description:")) {
+                variable = &result.distro.description;
+                offset = 12;
+            } else if (boost::starts_with(line, "Codename:")) {
+                variable = &result.distro.codename;
+                offset = 9;
+            } else if (boost::starts_with(line, "Release:")) {
+                variable = &result.distro.release;
+                offset = 8;
+            }
+            if (!variable) {
+                return true;
+            }
+            *variable = line.substr(offset);
+            boost::trim(*variable);
+            return true;
+        });
+
+        auto implementation = get_os();
+        auto name = implementation->get_name(result.distro.id);
+        if (!name.empty()) {
+            result.name = move(name);
+        }
+
+        auto family = implementation->get_family(result.name);
+        if (!family.empty()) {
+            result.family = move(family);
+        }
+
+        auto release = implementation->get_release(result.name, result.distro.release);
+        if (!release.empty()) {
+            result.release = move(release);
+            tie(result.major, result.minor) = implementation->parse_release(result.name, result.release);
+        }
+
+        // Convert the architecture value depending on distro
+        // For certain distros, use "amd64" for "x86_64"
+        // For certain distros, use "x86" for "i386"
+        if (result.architecture == "x86_64" && (
+             result.name == os::debian ||
+             result.name == os::gentoo ||
+             result.name == os::kfreebsd ||
+             result.name == os::ubuntu)) {
+            result.architecture = "amd64";
+        } else if (re_search(result.architecture, boost::regex("i[3456]86|pentium"))) {
+            // For 32-bit, use "x86" for Gentoo and "i386" for everyone else
+            if (result.name == os::gentoo) {
+                result.architecture = "x86";
+            } else {
+                result.architecture = "i386";
+            }
+        }
+
+        result.selinux = collect_selinux_data();
+
+        return result;
+    }
+
+}}}  // namespace facter::facts::linux