cfacter 3.11.0.rc.20180314

data/ext/facter/facter/lib/inc/internal/util/aix/vmount.hpp

@@ -0,0 +1,139 @@
+/**
+ * @file
+ * Declares an iterator interface for examining AIX mountpoints
+ */
+
+#include <leatherman/logging/logging.hpp>
+
+// AIX doesn't properly wrap these function declarations as C-style
+extern "C" {
+#include <sys/vmount.h>
+}
+
+#include <cstdint>
+#include <vector>
+
+namespace facter { namespace util { namespace aix {
+
+    /**
+     * This wraps the AIX mntctl(MCTL_QUERY, ...) function in an
+     * iterator interface. Each item is a mountctl struct.
+     */
+    class mountctl {
+    public:
+        /**
+         * Implements the standard C++ iterator interface for mounted
+         * filesystems. Iterators can be incremented and compared for
+         * inequality. This is the minimum to make range-based for
+         * loops work.
+         *
+         * Additional members may need to be added to make other
+         * algorithms play nice.
+         */
+        class iterator {
+            mountctl* _parent;
+            size_t _idx;
+            struct vmount* _current;
+        protected:
+            /**
+             * Construct an iterator from a mountctl class and the given
+             * vmount object index.
+             * @param parent the mountctl instance that this iterator points to
+             * @param idx the index into the list of vmount instances
+             */
+            iterator(mountctl* parent, size_t idx)
+                 : _parent(parent), _idx(0) {
+                _current = reinterpret_cast<struct vmount*>(_parent->_buffer.data());
+                while (_idx < idx) {
+                     ++(*this);
+                }
+            }
+
+        public:
+            iterator() = delete;
+
+            /// Defaulted move constructor
+            iterator(iterator&&) = default;
+
+            /// Defaulted move assignment
+            /// @return myself
+            iterator& operator=(iterator&&) = default;
+
+            /**
+             * inequality comparison
+             * @param rhs the other iterator to compare us to
+             * @return true if the iterators are not equal
+             */
+            bool operator != (const iterator& rhs) {
+                return _parent != rhs._parent || _idx != rhs._idx;
+            }
+
+            /**
+             * pre-increment operator. This moves the iterator to
+             * the next position in the list of vmount structs
+             * @return A reference to this iterator after it has advanced.
+             */
+            iterator& operator++() {
+                // Only increment if we're not at the end
+                // thus, end()++ == end();
+                if (_idx != _parent->_count) {
+                    uintptr_t pos = reinterpret_cast<uintptr_t>(_current);
+                    pos += _current->vmt_length;
+                    _current = reinterpret_cast<struct vmount*>(pos);
+                    _idx++;
+                }
+                return *this;
+            }
+
+            /**
+             * dereference operator
+             * @return a reference to the held vmount structure
+             */
+            const struct vmount& operator*() const {
+                return *_current;
+            }
+
+            friend class mountctl;
+        };
+        friend class iterator;  // iterator is our friend so it can access data
+
+        /**
+         * Query the mounted filesystems and return an iterable instance
+         */
+        mountctl() {
+            uint32_t buf_sz;
+            int result = mntctl(MCTL_QUERY, sizeof(uint32_t), reinterpret_cast<char*>(&buf_sz));
+            if (result < 0) {
+                throw std::system_error(errno, std::system_category());
+            }
+            LOG_DEBUG("Required space for mountpoints is {1}", buf_sz);
+
+            _buffer.reserve(buf_sz);
+            result = mntctl(MCTL_QUERY, buf_sz, _buffer.data());
+            if (result < 0) {
+                throw std::system_error(errno, std::system_category());
+            }
+            _count = result;
+            LOG_DEBUG("Got {1} mountpoints", _count);
+        }
+
+        /// Start the iteration
+        /// @return an iterator that references me. I must outlive this iterator
+        iterator begin() {
+            return iterator(this, 0);
+        }
+
+        /// Retrieve iterator sentinel value
+        /// @return an iterator that references me. I must outlive this iterator
+        iterator end() {
+            return iterator(this, _count);
+        }
+
+    protected:
+        /// The data returned from mntctl. Used by the iterator
+        std::vector<char> _buffer;
+
+        /// The number of elements returned from mntctl
+        size_t _count;
+    };
+}}}  // namespace facter::util::aix

data/ext/facter/facter/lib/inc/internal/util/bsd/scoped_ifaddrs.hpp

@@ -0,0 +1,33 @@
+/**
+ * @file
+ * Declares the scoped ifaddrs resource.
+ */
+#pragma once
+
+#include <leatherman/util/scoped_resource.hpp>
+#include <ifaddrs.h>
+
+namespace facter { namespace util { namespace bsd {
+
+    /**
+     * Represents a scoped ifaddrs pointer that automatically is freed when it goes out of scope.
+    */
+    struct scoped_ifaddrs : leatherman::util::scoped_resource<ifaddrs*>
+    {
+        /**
+         * Default constructor.
+         * This constructor will handle calling getifaddrs.
+         */
+        scoped_ifaddrs();
+
+        /**
+         * Constructs a scoped_descriptor.
+         * @param addrs The ifaddrs pointer to free when destroyed
+         */
+        explicit scoped_ifaddrs(ifaddrs* addrs);
+
+     private:
+        static void free(ifaddrs* addrs);
+    };
+
+}}}  // namespace facter::util::bsd

data/ext/facter/facter/lib/inc/internal/util/posix/scoped_addrinfo.hpp

@@ -0,0 +1,45 @@
+/**
+ * @file
+ * Declares the scoped addrinfo resource.
+ */
+#pragma once
+
+#include <leatherman/util/scoped_resource.hpp>
+#include <netdb.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <string>
+#include <cstring>
+
+namespace facter { namespace util { namespace posix {
+
+    /**
+     * Represents a scoped addrinfo for POSIX systems.
+     * Automatically frees the address information pointer when it goes out of scope.
+    */
+    struct scoped_addrinfo : leatherman::util::scoped_resource<addrinfo*>
+    {
+        /**
+         * Constructs a scoped_addrinfo.
+         * @param hostname The hostname to get the address information of.
+         */
+        explicit scoped_addrinfo(std::string const& hostname);
+
+        /**
+         * Constructs a scoped_addrinfo.
+         * @param info The address info to free when destroyed.
+         */
+        explicit scoped_addrinfo(addrinfo* info);
+
+        /**
+         * Returns the result of any call to getaddrinfo.
+         * @returns Returns the result of any call to getaddrinfo.
+         */
+        int result() const;
+
+     private:
+        static void free(addrinfo* info);
+        int _result;
+    };
+
+}}}  // namespace facter::util::posix

data/ext/facter/facter/lib/inc/internal/util/posix/scoped_bio.hpp

@@ -0,0 +1,34 @@
+/**
+ * @file
+ * Declares the scoped BIO (OpenSSL) resource.
+ */
+#pragma once
+
+#include <leatherman/util/scoped_resource.hpp>
+#include <openssl/bio.h>
+
+namespace facter { namespace util { namespace posix {
+
+    /**
+     * Represents a scoped OpenSSL BIO object.
+     * Automatically frees the BIO when it goes out of scope.
+    */
+    struct scoped_bio : leatherman::util::scoped_resource<BIO*>
+    {
+        /**
+         * Constructs a scoped_bio.
+         * @param method The BIO_METHOD to use.
+         */
+        explicit scoped_bio(const BIO_METHOD* method);
+
+        /**
+         * Constructs a scoped_bio.
+         * @param bio The BIO to free when destroyed.
+         */
+        explicit scoped_bio(BIO* bio);
+
+     private:
+        static void free(BIO* bio);
+    };
+
+}}}  // namespace facter::util::posix

data/ext/facter/facter/lib/inc/internal/util/posix/scoped_descriptor.hpp

@@ -0,0 +1,27 @@
+/**
+ * @file
+ * Declares the scoped descriptor resource for managing file/socket descriptors.
+ */
+#pragma once
+
+#include <leatherman/util/scoped_resource.hpp>
+#include <unistd.h>
+
+namespace facter { namespace util { namespace posix {
+    /**
+     * Represents a scoped file descriptor for POSIX systems.
+     * Automatically closes the file descriptor when it goes out of scope.
+    */
+    struct scoped_descriptor : leatherman::util::scoped_resource<int>
+    {
+        /**
+         * Constructs a scoped_descriptor.
+         * @param descriptor The file descriptor to close when destroyed.
+         */
+        explicit scoped_descriptor(int descriptor);
+
+     private:
+        static void close(int descriptor);
+    };
+
+}}}  // namespace facter::util::posix

data/ext/facter/facter/lib/inc/internal/util/scoped_file.hpp

@@ -0,0 +1,36 @@
+/**
+ * @file
+ * Declares the scoped file resource for managing FILE pointers.
+ */
+#pragma once
+
+#include <leatherman/util/scoped_resource.hpp>
+#include <string>
+#include <cstdio>
+
+namespace facter { namespace util {
+
+    /**
+     * Represents a scoped file.
+     * Automatically closes the file when it goes out of scope.
+    */
+    struct scoped_file : leatherman::util::scoped_resource<std::FILE*>
+    {
+        /**
+         * Constructs a scoped_file.
+         * @param path The path to the file.
+         * @param mode The open mode.
+         */
+        explicit scoped_file(std::string const& path, std::string const& mode);
+
+        /**
+         * Constructs a scoped_file.
+         * @param file The existing file pointer.
+         */
+        explicit scoped_file(std::FILE* file);
+
+     private:
+        static void close(std::FILE* file);
+    };
+
+}}  // namespace facter::util

data/ext/facter/facter/lib/inc/internal/util/solaris/k_stat.hpp

@@ -0,0 +1,176 @@
+/**
+ * @file
+ * Declares the k_stat resource.
+ */
+#pragma once
+
+#include "scoped_kstat.hpp"
+#include <vector>
+#include <string>
+
+namespace facter { namespace util { namespace solaris {
+
+    /**
+     * Wrapper around the kstat_t structure.
+     */
+    struct k_stat_entry
+    {
+        /**
+         * Default constructor. Should be created only by k_stat[] call.
+         * @param kp The kstat_t pointer we wrap.
+         *
+         */
+        k_stat_entry(kstat_t* kp);
+
+        /**
+         * Get a value out of our kstat_named_t
+         * @param attrib The attribute we are looking up
+         * @tparam T the datatype of the attribute result
+         * @return Returns the looked up value.
+         */
+        template <typename T>
+        T value(const std::string& attrib) const;
+
+        /**
+         * Gets the name of the entry.
+         * @return Returns the name of entry.
+         */
+        std::string name();
+
+        /**
+         * Gets the class of the entry.
+         * @return Returns the class of entry.
+         */
+        std::string klass();
+
+        /**
+         * Gets the module of the entry.
+         * @return Returns the module of entry.
+         */
+        std::string module();
+
+        /**
+         * Gets the instance of the entry.
+         * @return Returns the instance of entry.
+         */
+        int instance();
+
+     private:
+        /**
+         * Lookup the given attribute in the kstat structure.
+         * @param attrib The attribute we are looking up
+         * @return Returns the looked up value.
+         */
+        kstat_named_t* lookup(const std::string& attrib) const;
+
+        /**
+         * Lookup the given attribute in the kstat structure, and verify that
+         * the datatype is correct.
+         * @param datatype The datatype of attribute we are looking up
+         * @param attrib The attribute we are looking up
+         * @return Returns the looked up value.
+         */
+        kstat_named_t* lookup(const int datatype, const std::string& attrib) const;
+
+       /**
+         * The main data in the struct, obtained by a lookup
+         */
+        kstat_t* k_stat;
+    };
+
+    /**
+     * The template specializations for k_stat_entry::value with ulong_t.
+     * @param attrib The attribute we are looking up.
+     * @return Returns the looked up value.
+     */
+    template<>
+    ulong_t k_stat_entry::value(const std::string& attrib) const;
+
+    /**
+     * The template specializations for k_stat_entry::value with long.
+     * @param attrib The attribute we are looking up.
+     * @return Returns the looked up value.
+     */
+    template<>
+    long k_stat_entry::value(const std::string& attrib) const;
+
+    /**
+     * The template specializations for k_stat_entry::value with int32_t.
+     * @param attrib The attribute we are looking up.
+     * @return Returns the looked up value.
+     */
+    template<>
+    int32_t k_stat_entry::value(const std::string& attrib) const;
+
+    /**
+     * The template specializations for k_stat_entry::value with uint32_t.
+     * @param attrib The attribute we are looking up.
+     * @return Returns the looked up value.
+     */
+    template<>
+    uint32_t k_stat_entry::value(const std::string& attrib) const;
+
+    /**
+     * The template specializations for k_stat_entry::value with int64_t.
+     * @param attrib The attribute we are looking up.
+     * @return Returns the looked up value.
+     */
+    template<>
+    int64_t k_stat_entry::value(const std::string& attrib) const;
+
+    /**
+     * The template specializations for k_stat_entry::value with uint64_t.
+     * @param attrib The attribute we are looking up.
+     * @return Returns the looked up value.
+     */
+    template<>
+    uint64_t k_stat_entry::value(const std::string& attrib) const;
+
+    /**
+     * The template specializations for k_stat_entry::value with string.
+     * @param attrib The attribute we are looking up.
+     * @return Returns the looked up value.
+     */
+    template<>
+    std::string k_stat_entry::value(const std::string& attrib) const;
+
+    /**
+     * Wrapper around the kstat_ctl structure. It represents our
+     * link to kernel stats, and controls the lifetime of any kstat
+     * structures associated. (They go away when it is closed)
+     */
+    struct k_stat
+    {
+        /**
+         * Default constructor.
+         * This constructor will handle calling kstat_open.
+         */
+        k_stat();
+
+        /**
+         * Function for looking up a module.
+         * @param module The module name.
+         * @return Returns the vector containing all entries.
+         */
+        std::vector<k_stat_entry> operator[](std::string const& module);
+
+        /**
+         * Function for looking up a module, and an entry name.
+         * @param entry A pair containing module name an entry name.
+         * @return Returns the vector containing all entries.
+         */
+        std::vector<k_stat_entry> operator[](std::pair<std::string, std::string> const& entry);
+
+        /**
+         * Function for looking up a module, and an instance id.
+         * @param entry A pair containing module name an instance id.
+         * @return Returns the vector containing all entries.
+         */
+        std::vector<k_stat_entry> operator[](std::pair<std::string, int> const& entry);
+
+     private:
+        std::vector<k_stat_entry> lookup(std::string const& module, int instance, std::string const& name);
+        scoped_kstat ctrl;
+    };
+
+}}}  // namespace facter::util::solaris