/home/mhx/git/github/libmoost/include/moost/process/ownership.hpp

Go to the documentation of this file.

/* vim:set ts=3 sw=3 sts=3 et: */
#ifndef FM_LAST_MOOST_PROCESS_OWNERSHIP_H_
#define FM_LAST_MOOST_PROCESS_OWNERSHIP_H_

#include "detail/ownership_posix.hpp"

namespace moost { namespace process {

class ownership
{
public:
   typedef detail::ownership::uid_type uid_type;
   typedef detail::ownership::gid_type gid_type;

   bool is_superuser() const
   {
      return m_impl.is_superuser();
   }

   bool lookup_user(std::string& name, const uid_type& uid) const
   {
      return m_impl.lookup_user(name, uid);
   }

   bool lookup_uid(uid_type& uid, const std::string& name) const
   {
      return m_impl.lookup_uid(uid, name);
   }

   bool lookup_uid(uid_type& uid, gid_type& gid, const std::string& name) const
   {
      return m_impl.lookup_uid(uid, gid, name);
   }

   void set_uid(uid_type uid)
   {
      m_impl.set_uid(uid);
   }

   void set_effective_uid(uid_type uid)
   {
      m_impl.set_effective_uid(uid);
   }

   uid_type get_uid() const
   {
      return m_impl.get_uid();
   }

   uid_type get_effective_uid() const
   {
      return m_impl.get_effective_uid();
   }

   bool lookup_group(std::string& name, const gid_type& gid) const
   {
      return m_impl.lookup_group(name, gid);
   }

   bool lookup_gid(gid_type& gid, const std::string& name) const
   {
      return m_impl.lookup_gid(gid, name);
   }

   void set_gid(gid_type gid)
   {
      m_impl.set_gid(gid);
   }

   void set_effective_gid(gid_type gid)
   {
      m_impl.set_effective_gid(gid);
   }

   gid_type get_gid() const
   {
      return m_impl.get_gid();
   }

   gid_type get_effective_gid() const
   {
      return m_impl.get_effective_gid();
   }

   bool set_user(const std::string& name)
   {
      uid_type uid;

      if (!lookup_uid(uid, name))
      {
         return false;
      }

      set_uid(uid);

      return true;
   }

   bool set_effective_user(const std::string& name)
   {
      uid_type uid;

      if (!lookup_uid(uid, name))
      {
         return false;
      }

      set_effective_uid(uid);

      return true;
   }

   bool set_group(const std::string& name)
   {
      gid_type gid;

      if (!lookup_gid(gid, name))
      {
         return false;
      }

      set_gid(gid);

      return true;
   }

   bool set_effective_group(const std::string& name)
   {
      gid_type gid;

      if (!lookup_gid(gid, name))
      {
         return false;
      }

      set_effective_gid(gid);

      return true;
   }

   std::string get_user() const
   {
      std::string name;

      if (!lookup_user(name, get_uid()))
      {
         throw std::runtime_error("failed to lookup uid");
      }

      return name;
   }

   std::string get_effective_user() const
   {
      std::string name;

      if (!lookup_user(name, get_effective_uid()))
      {
         throw std::runtime_error("failed to lookup uid");
      }

      return name;
   }

   std::string get_group() const
   {
      std::string name;

      if (!lookup_group(name, get_gid()))
      {
         throw std::runtime_error("failed to lookup gid");
      }

      return name;
   }

   std::string get_effective_group() const
   {
      std::string name;

      if (!lookup_group(name, get_effective_gid()))
      {
         throw std::runtime_error("failed to lookup gid");
      }

      return name;
   }

   void drop_privileges(const std::string& user, const std::string& group = "")
   {
      uid_type uid = 0;
      gid_type gid = 0;

      if (group.empty())
      {
         if (!lookup_uid(uid, gid, user))
         {
            throw std::runtime_error("failed to lookup uid");
         }
      }
      else
      {
         if (!lookup_uid(uid, user))
         {
            throw std::runtime_error("failed to lookup uid");
         }

         if (!lookup_gid(gid, group))
         {
            throw std::runtime_error("failed to lookup gid");
         }
      }

      set_gid(gid);
      set_uid(uid);
   }

private:
   detail::ownership m_impl;
};

} }

#endif