cs_utility.hpp

Go to the documentation of this file.

/*
 *      Copyright (c) 2023, an unpublished work by CodeSecure, Inc.
 *                      ALL RIGHTS RESERVED
 *
 *      Copyright (c) 2013-2023, an unpublished work by GrammaTech, Inc.
 *                      ALL RIGHTS RESERVED
 *
 *      This software is furnished under a license and may be used and
 *      copied only in accordance with the terms of such license and the
 *      inclusion of the above copyright notice.  This software or any
 *      other copies thereof may not be provided or otherwise made
 *      available to any other person.  Title to and ownership of the
 *      software is retained by CodeSecure, Inc.
 */ 

#ifndef CS_UTILITY_HPP
#define CS_UTILITY_HPP

#include "cs_utility.h"
#include "cs_scratchpad.hpp"

namespace cs{
    class csurf_info{
    private:
        csurf_info();
    public:

        static std::string version()
        { return cs_version(); }

        /* /usr/include/sys/sysmacros.h #define's "major", so we
         * suffix these with _ver to avoid conflict.
         */
        static int major_version()
        { return cs_major_version(); }
        
        static int minor_version()
        { return cs_minor_version(); }
        
        static int patch_version()
        { return cs_patch_version(); }
        
        /* csurf_install_prefix intentionally not lifted because it is
         * confusing -- users will expect+want this more general
         * function:
         */
        static std::string install_path()
        { return cs_codesecure_home_directory(); }

        static std::vector<std::string> startup_argv() {
            std::vector<std::string> ans;
            for (cs_const_string const* argv = cs_get_startup_argv();
                 *argv;
                 ++argv)
            {
                ans.push_back(*argv);
            }
            return ans;
        }

    };

    class sysinfo{
    private:
        sysinfo();
    public:

        static std::string user_name()
        {
            string_scratchpad::
                to_string_functor0_limit<cs_get_user_name>
                functor(-1);
            return string_scratchpad::to_string(functor);
        }

        static std::string machine_name()
        {
            string_scratchpad::
                to_string_functor0_limit<cs_get_machine_name>
                functor(-1);
            return string_scratchpad::to_string(functor);
        }
    };
    

    class object_pager{
        object_pager();
    public:

        static void flush()
        { cs_flush_managed_objects(); }
        

        static void set_capacity(size_t s)
        { cs_set_resident_capacity(s); }

        static size_t get_capacity()
        { return cs_get_resident_capacity(); }
        

        static void set_io_buffer_capacity(size_t s)
        { cs_set_io_buffer_capacity(s); }


        static size_t get_pending_io_buffer_capacity()
        { return cs_get_io_buffer_capacity_pending(); }


        static size_t get_current_io_buffer_capacity()
        {
            size_t rv;
            check(cs_get_io_buffer_capacity_current(&rv));
            return rv;
        }
    };

    inline csuint64 string_hash(const std::string &s)
    { return cs_bytes_hash(s.c_str(), s.size()); }

    inline std::string xmlencode(const std::string &s,
                                 bool use_private_use_area = true)
    { return cs_xmlencode_string(s.data(), s.size(), use_private_use_area); }
    inline std::string xmldecode(const std::string &s)
    { return cs_xmldecode_string(s.c_str()); }
}

#endif /* CS_UTILITY_HPP */