facter 3.12.2.cfacter.20181217 → 4.0.7.pre

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

@@ -1,27 +0,0 @@
-#include <internal/facts/aix/kernel_resolver.hpp>
-#include <facter/facts/collection.hpp>
-#include <leatherman/logging/logging.hpp>
-#include <leatherman/execution/execution.hpp>
-#include <leatherman/util/regex.hpp>
-#include <leatherman/file_util/file.hpp>
-#include <boost/regex.hpp>
-
-using namespace leatherman::execution;
-using namespace std;
-
-namespace facter { namespace facts { namespace aix   {
-
-    kernel_resolver::data kernel_resolver::collect_data(collection& facts)
-    {
-        data result;
-
-        auto exec = execute("/usr/bin/oslevel", {"-s"}, 0, { execution_options::trim_output, execution_options::redirect_stderr_to_stdout, execution_options::merge_environment });
-
-        result.name = "AIX";
-        result.release = exec.output;
-        result.version = exec.output.substr(0, 4);
-
-        return result;
-    }
-
-}}}  // namespace facter::facts::aix

data/ext/facter/facter/lib/src/facts/aix/load_average_resolver.cc

@@ -1,50 +0,0 @@
-#include <internal/facts/aix/load_average_resolver.hpp>
-#include <leatherman/logging/logging.hpp>
-#include <leatherman/locale/locale.hpp>
-
-#include <sys/inttypes.h>
-#include <sys/kinfo.h>
-
-// Mark string for translation (alias for leatherman::locale::format)
-using leatherman::locale::_;
-
-using namespace std;
-
-/**
- * This system call lets us query the kernel directly for system
- * information. We use it to get our current load averages.
- *
- * @param info the info we're retrieving from the kernel.
- * @param buf the buffer that we'll store the information in
- * @param buf_size a pointer to the variable containing the size of the buffer in bytes
- * @param arg no idea what this param. represents. we will usually set this to 0.
- * @return 0 if we successfully retrieve the information, else a negative value
- */
-extern "C" int getkerninfo(int info, char* buf, int* buf_size, int32long64_t arg);
-
-// Converts the given integer average into a load average.
-static double to_load_avg(double average) {
-  // 65536 is the load average scale on AIX machines.
-  return average / 65536;
-}
-
-namespace facter { namespace facts { namespace aix {
-
-    boost::optional<tuple<double, double, double> > load_average_resolver::get_load_averages()
-    {
-        // This approach was adapted from screen-4.6.2's loadav.c file. See
-        // https://www.mail-archive.com/opensuse-commit@opensuse.org/msg122486.html
-        array<long long, 3> averages;
-        int buf_size = averages.size() * sizeof(long long);
-        int rc = getkerninfo(KINFO_GET_AVENRUN, reinterpret_cast<char*>(averages.data()), &buf_size, 0);
-        if (rc < 0) {
-            LOG_DEBUG(_("failed to retrieve the load averages"));
-            return boost::none;
-        }
-
-        return make_tuple(
-            to_load_avg(averages[0]),
-            to_load_avg(averages[1]),
-            to_load_avg(averages[2]));
-    }
-}}}  // namespace facter::facts::aix

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

@@ -1,63 +0,0 @@
-#include <internal/facts/aix/memory_resolver.hpp>
-#include <internal/util/aix/odm.hpp>
-
-#include <leatherman/logging/logging.hpp>
-#include <sys/vminfo.h>
-#include <sys/cfgodm.h>
-#include <sys/limits.h>
-#include <system_error>
-
-using namespace std;
-using namespace facter::util::aix;
-
-// This routine is useful to encapsulate knowledge of the PAGE_SIZE
-// in one place and to also handle implicit conversions of numeric
-// values to uint64_t, which is what we use to represent bytes. Otherwise,
-// we risk accidentally capturing an overflowed value in our computed
-// memory facts.
-static uint64_t pages_to_bytes(uint64_t num_pages) {
-    return num_pages * PAGE_SIZE;
-}
-
-namespace facter { namespace facts { namespace aix {
-    memory_resolver::data memory_resolver::collect_data(collection& facts)
-    {
-        data result;
-
-        vminfo info;
-        auto res = vmgetinfo(&info, VMINFO, sizeof(info));
-        if (res < 0) {
-            throw system_error(errno, system_category());
-        }
-        result.mem_total = pages_to_bytes(info.memsizepgs);
-        result.mem_free = pages_to_bytes(info.numfrb);
-
-        auto cu_at_query = odm_class<CuAt>::open("CuAt").query("value=paging and attribute=type");
-        for (auto& cu_at : cu_at_query) {
-            string device = string("/dev/") + cu_at.name;
-            pginfo info;
-            auto res = swapqry(const_cast<char*>(device.c_str()), &info);
-            if (res < 0) {
-                // it's really hard to tell from the ODM if a device
-                // is a disk, just by its name. So we'll always try to
-                // swapqry the things that have an attribute we
-                // expect, but ignore any errno values that look like
-                // "this just wasn't a good device to query"
-                // ENXIO: No such device address.
-                if (errno != ENODEV &&
-                    errno != ENOENT &&
-                    errno != ENOTBLK &&
-                    errno != ENXIO) {
-                    throw system_error(errno, system_category(), device);
-                } else {
-                    LOG_DEBUG("cannot use device {1}: error is {2}", device, errno);
-                }
-            }
-
-            result.swap_total += pages_to_bytes(info.size);
-            result.swap_free += pages_to_bytes(info.free);
-        }
-
-        return result;
-    }
-}}}  // namespace facter::facts::aix

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

@@ -1,250 +0,0 @@
-#include <internal/facts/aix/networking_resolver.hpp>
-#include <leatherman/execution/execution.hpp>
-#include <leatherman/logging/logging.hpp>
-#include <leatherman/locale/locale.hpp>
-#include <boost/algorithm/string.hpp>
-
-#include <unordered_map>
-
-#include <inttypes.h>
-#include <net/if.h>
-#include <net/if_dl.h>
-#include <net/route.h>
-#include <netinet/in.h>
-#include <sys/kinfo.h>
-
-// Mark string for translation (alias for leatherman::locale::format)
-using leatherman::locale::_;
-
-// This usage is recommended in several mailing lists, and is used at
-// least in Samba to query mac addresses. I saw some references to old
-// IBM publications also recommending its use, but couldn't actually
-// dig those pubs up.
-//
-// The structs it *returns* are in headers, though (specifically
-// mentioning usage of this function).
-//
-// This is all leftovers from ancient versions of the BSD networking
-// stack that every OS in the world has stolen/borrowed. It is pretty
-// gross in a lot of ways, but is what we have to work with on AIX.
-//
-// There does not appear to be a different or documented way to get
-// this information, outside of shelling out to tools which provide
-// human- rather than machine-readable output.
-extern "C" int getkerninfo(int, char*, int*, int32long64_t);
-
-template <typename T>
-static std::vector<T> getkerninfo(int query) {
-    for (;;) {
-        auto ksize = getkerninfo(query, nullptr, nullptr, 0);
-        if (ksize == 0) {
-            throw std::runtime_error(_("getkerninfo call was unsuccessful"));
-        }
-        auto alloc_size = ksize;
-        auto count = alloc_size/sizeof(T);
-        std::vector<T> result(count);
-        if (getkerninfo(query, reinterpret_cast<char*>(result.data()), &ksize, 0) == -1) {
-            throw std::runtime_error(_("getkerninfo call was unsuccessful"));
-        }
-
-        // getkerninfo updates the size variable to match our actual
-        // buffer size. If we need more space we loop to
-        // reallocate. Otherwise we make sure the vector is trimmed to
-        // the proper size and return the contents.
-        if (ksize <= alloc_size) {
-            result.resize(ksize/sizeof(T));
-            return result;
-        }
-    }
-}
-
-namespace facter { namespace facts { namespace aix {
-    networking_resolver::data networking_resolver::collect_data(collection& facts) {
-        auto data = posix::networking_resolver::collect_data(facts);
-
-        // Query the kernel for the list of network interfaces and
-        // their associated addresses
-        data.interfaces = get_interfaces();
-
-        // query the network device descriptors from the kernel. This
-        // gives us physical information, such as mtu.
-        auto mtus = get_mtus();
-
-        for (auto& iface : data.interfaces) {
-            auto mtu_iter = mtus.find(iface.name);
-            if (mtu_iter != mtus.end()) {
-                iface.mtu = stoll(mtu_iter->second);
-            }
-        }
-
-        data.primary_interface = get_primary_interface();
-
-        return data;
-    }
-
-    networking_resolver::mtu_map networking_resolver::get_mtus() const {
-        mtu_map result;
-        leatherman::execution::each_line("/usr/bin/netstat", {"-in"}, [&](std::string line) {
-            std::vector<std::string> fields;
-            boost::trim(line);
-            boost::split(fields, line, boost::is_space(), boost::token_compress_on);
-            if (boost::starts_with(fields[2], "link")) {
-                result[fields[0]] = fields[1];
-            }
-            return true;
-        });
-        return result;
-    }
-
-    std::vector<networking_resolver::interface> networking_resolver::get_interfaces() const {
-        auto buffer = getkerninfo<char>(KINFO_RT_IFLIST);
-
-        // interfaces are identified by 16-bit IDs. these may or may
-        // not be sequential, so we use a map as a sparse array
-        std::map<u_short, interface> ifaces;
-
-        decltype(buffer)::size_type cursor = 0;
-        while (cursor < buffer.size()) {
-            if_msghdr* hdr = reinterpret_cast<if_msghdr*>(buffer.data() + cursor);
-
-            switch (hdr->ifm_type) {
-            case RTM_IFINFO: {
-                sockaddr_dl* link_addr = reinterpret_cast<sockaddr_dl*>(hdr+1);  // sockaddr immediately follows the header
-
-                // Name is not zero-terminated, we must pass the length to the string constructor.
-                ifaces[hdr->ifm_index].name = std::string(link_addr->sdl_data, link_addr->sdl_nlen);
-
-                // The mac address is stored in binary immediately following the name length
-                ifaces[hdr->ifm_index].macaddress = macaddress_to_string(reinterpret_cast<uint8_t*>(link_addr->sdl_data+link_addr->sdl_nlen));
-                break;
-            }
-            case RTM_NEWADDR: {
-                // This is gross. Immediately following the header is
-                // a number of addresses which may or may not
-                // individually be present based on a bitfield. They
-                // are stored in a specific order, at least.
-                // Additionally, each address struct could be cut off
-                // or padded - we need to check the length of each one
-                // to know where the next one starts. PLUS we don't
-                // know whether we're looking at IPV4 or IPV6 until we
-                // find an address that actually specifies its
-                // protocol (the first one might not).
-
-                // sockaddr_storage is guaranteed to be big enough for the memcpy below.
-                std::array<sockaddr_storage, RTAX_MAX> addrs;
-                memset(addrs.data(), 0, RTAX_MAX*sizeof(sockaddr_storage));
-
-                // This represents our position walking the list of address objects
-                int addr_cursor = cursor + sizeof(if_msghdr);
-
-#define FACT_READ_ADDR(a) if (hdr->ifm_addrs & RTA_##a) { \
-                    sockaddr* sa = reinterpret_cast<sockaddr*>(buffer.data()+addr_cursor); \
-                    memcpy(&(addrs[ RTAX_##a ]), sa, sa->sa_len); \
-                    addr_cursor += RT_ROUNDUP(sa); \
-                }
-                FACT_READ_ADDR(DST);
-                FACT_READ_ADDR(GATEWAY);
-                FACT_READ_ADDR(NETMASK);
-                FACT_READ_ADDR(GENMASK);
-                FACT_READ_ADDR(IFP);
-                FACT_READ_ADDR(IFA);
-                FACT_READ_ADDR(AUTHOR);
-                FACT_READ_ADDR(BRD);
-
-                // WOO addresses read. Now we try to figure out if
-                // we're IPv4 or IPv6. We skip any other families, and
-                // warn if we get a mixed set of families.
-
-                int family = AF_UNSPEC;
-                for (const auto& addr : addrs) {
-                    if (family != AF_UNSPEC &&
-                        addr.ss_family != AF_UNSPEC &&
-                        family != addr.ss_family) {
-                        family = AF_MAX;
-                        break;
-                    }
-                    family = addr.ss_family;
-                }
-
-                binding addr_binding;
-                sockaddr* netmask = reinterpret_cast<sockaddr*>(&addrs[RTAX_NETMASK]);
-                sockaddr* address = reinterpret_cast<sockaddr*>(&addrs[RTAX_IFA]);
-                if (netmask->sa_len) {
-                    netmask->sa_family = family;  // AIX likes to return the netmask with AF_UNSPEC family.
-                    addr_binding.netmask = address_to_string(netmask);
-                }
-                if (address->sa_len) {
-                    addr_binding.address = address_to_string(address);
-                }
-                if (address->sa_len && netmask->sa_len) {
-                    addr_binding.network = address_to_string(address, netmask);
-                }
-
-                if (family == AF_MAX) {
-                    LOG_WARNING("got mixed address families for interface {1}, can't map them to a single binding.", ifaces[hdr->ifm_index].name);
-                } else if (family == AF_INET) {
-                    LOG_INFO("got ipv4 addresses for interface {1}", ifaces[hdr->ifm_index].name);
-                    ifaces[hdr->ifm_index].ipv4_bindings.push_back(addr_binding);
-                } else if (family == AF_INET6) {
-                    LOG_INFO("got ipv6 addresses for interface {1}", ifaces[hdr->ifm_index].name);
-                    ifaces[hdr->ifm_index].ipv6_bindings.push_back(addr_binding);
-                } else if (family != AF_UNSPEC) {
-                    LOG_INFO("skipping unknown address family {1} for interface {2}", family, ifaces[hdr->ifm_index].name);
-                } else {
-                    LOG_INFO("somehow didn't get an address family for interface {1}", ifaces[hdr->ifm_index].name);
-                }
-                break;
-            }
-            default: {
-                LOG_INFO("got an unknown RT_IFLIST message: {1}", hdr->ifm_type);
-                break;
-            }
-            }
-
-            cursor += hdr->ifm_msglen;
-        }
-
-        // Now that we're done processing the data we don't care about
-        // the kernel's iface IDs anymore.
-        std::vector<interface> result;
-        for (auto& iface : ifaces) {
-            result.push_back(iface.second);
-        }
-        return result;
-    }
-
-    std::string networking_resolver::get_primary_interface() const
-    {
-        std::string value;
-        leatherman::execution::each_line("netstat", { "-rn"}, [&value](std::string& line) {
-            boost::trim(line);
-            if (boost::starts_with(line, "default")) {
-                std::vector<std::string> fields;
-                boost::split(fields, line, boost::is_space(), boost::token_compress_on);
-                value = fields.size() < 6 ? "" : fields[5];
-                return false;
-            }
-            return true;
-        });
-        return value;
-    }
-
-
-    bool networking_resolver::is_link_address(const sockaddr* addr) const
-    {
-        // We explicitly populate the MAC address; we don't need address_to_string to support link layer addresses
-        return false;
-    }
-
-    uint8_t const* networking_resolver::get_link_address_bytes(const sockaddr * addr) const
-    {
-        return nullptr;
-    }
-
-    uint8_t networking_resolver::get_link_address_length(const sockaddr * addr) const
-    {
-        return 0;
-    }
-
-
-}}}  // namespace facter::facts::aix

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

@@ -1,99 +0,0 @@
-#include <internal/facts/aix/operating_system_resolver.hpp>
-#include <internal/util/aix/odm.hpp>
-#include <facter/facts/collection.hpp>
-#include <facter/facts/fact.hpp>
-#include <facter/facts/os.hpp>
-#include <facter/facts/array_value.hpp>
-#include <facter/facts/map_value.hpp>
-#include <facter/facts/scalar_value.hpp>
-#include <leatherman/logging/logging.hpp>
-
-#include <boost/algorithm/string.hpp>
-#include <odmi.h>
-#include <sys/cfgodm.h>
-
-using namespace std;
-using namespace facter::util::aix;
-
-// This routine's meant to be a general utility function that replicates the behavior of
-// lsattr -El <object> -a <field>. Although it's only used to get the modelname of the
-// sys0 device, we still would like to have it here in case we ever need to separate it
-// out to an AIX utils file to query other attributes. Part of what lsattr does is check
-// PdAt if we don't have an entry for the object's attribute in CuAt, even though it is very
-// unlikely that sys0.modelname will not have a CuAt entry. That is why we have the extra code
-// in here.
-static string getattr(string object, string field)
-{
-    // High-level logic here is:
-    //   * Check if there's an entry for our object's field attribute in CuAt (the device-specific
-    //   attribute entry).
-    //
-    //   * Else, check for the field attribute's default value in PdAt. We do this by first
-    //   figuring out the PdDv type from the CuDv entry for the object, then use our PdDv type
-    //   to query the field's default value in PdAt.
-    string query = (boost::format("name = %1% AND attribute = %2%") % object % field).str();
-    auto cuat_query = odm_class<CuAt>::open("CuAt").query(query);
-
-    // This is a more verbose way of saying that we only expect our query to have one element
-    auto cuat_ref = cuat_query.begin();
-    if (cuat_ref != cuat_query.end()) {
-      auto value = string(cuat_ref->value);
-      if (value.empty()) {
-        LOG_DEBUG("Could not get a value from the ODM for {1}'s '{2}' attribute.", object, field);
-      }
-      return value;
-    }
-
-    // Get the PdDv type from the CuDv entry
-    query = (boost::format("name = %1%") % object).str();
-    auto cudv_query = odm_class<CuDv>::open("CuDv").query(query);
-    auto cudv_ref = cudv_query.begin();
-    if (cudv_ref == cudv_query.end()) {
-      LOG_DEBUG("Could not get a value from the ODM for {1}'s '{2}' attribute: There is no CuDv entry for {1}.", object, field);
-      return "";
-    }
-    auto pddv_type = cudv_ref->PdDvLn_Lvalue;
-
-    query = (boost::format("uniquetype = %1% AND attribute = %2%") % pddv_type % field).str();
-    auto pdat_query = odm_class<PdAt>::open("PdAt").query(query);
-    auto pdat_ref = pdat_query.begin();
-    if (pdat_ref != pdat_query.end()) {
-      auto value = string(pdat_ref->deflt);
-      if (value.empty()) {
-        LOG_DEBUG("Could not get a value from the ODM for {1}'s '{2}' attribute.", object, field);
-      }
-      return value;
-    }
-
-    LOG_DEBUG("Could not get a value from the ODM for {1}'s '{2}' attribute: There is no PdAt entry for {1} with {2}.", object, field);
-    return "";
-}
-
-namespace facter { namespace facts { namespace aix {
-
-    operating_system_resolver::data operating_system_resolver::collect_data(collection& facts)
-    {
-        // Default to the base implementation
-        auto result = posix::operating_system_resolver::collect_data(facts);
-
-        // on AIX, major version is hyphen-delimited. The base
-        // resolver can't figure this out for us.
-        vector<string> tokens;
-        boost::split(tokens, result.release, boost::is_any_of("-"));
-        result.major = tokens[0];
-
-        // Get the hardware
-        result.hardware = getattr("sys0", "modelname");
-
-        // Now get the architecture. We use processor.models[0] for this information.
-        auto processors = facts.get<map_value>(fact::processors);
-        auto models = processors ? processors->get<array_value>("models") : nullptr;
-        if (! models || models->empty()) {
-          LOG_DEBUG("Could not get a value for the OS architecture. Your machine does not have any processors!");
-        } else {
-          result.architecture = models->get<string_value>(0)->value();
-        }
-
-        return result;
-    }
-}}}