sbuild-util.h

Go to the documentation of this file.

/* Copyright © 2005-2007  Roger Leigh <rleigh@debian.org>
 *
 * schroot is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * schroot is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see
 * <http://www.gnu.org/licenses/>.
 *
 *********************************************************************/

#ifndef SBUILD_UTIL_H
#define SBUILD_UTIL_H

#include <sbuild/sbuild-environment.h>
#include <sbuild/sbuild-error.h>
#include <sbuild/sbuild-regex.h>
#include <sbuild/sbuild-types.h>

#include <string>
#include <cerrno>

#include <sys/types.h>
#include <sys/stat.h>
#include <pwd.h>
#include <grp.h>
#include <unistd.h>

namespace sbuild
{

  std::string
  basename (std::string name,
            char        separator = '/');

  std::string
  dirname (std::string name,
           char        separator = '/');

  std::string
  normalname (std::string name,
              char        separator = '/');

  bool
  is_absname (std::string const& name);

  bool
  is_valid_filename (std::string const& name,
                     bool               lsb_mode = true);

  std::string
  getcwd ();


  std::string
  unique_identifier ();

  std::string
  string_list_to_string (string_list const& list,
                         std::string const& separator);

  template <typename S>
  std::vector<S>
  split_string (S const& value,
                S const& separator)
  {
    std::vector<S> ret;

    // Skip any separators at the start
    typename S::size_type last_pos =
      value.find_first_not_of(separator, 0);
    // Find first separator.
    typename S::size_type pos = value.find_first_of(separator, last_pos);

    while (pos !=S::npos || last_pos != S::npos)
      {
        // Add to list
        ret.push_back(value.substr(last_pos, pos - last_pos));
        // Find next
        last_pos = value.find_first_not_of(separator, pos);
        pos = value.find_first_of(separator, last_pos);
      }

    return ret;
  }

  // template
  std::vector<std::string>
  split_string (std::string const& value,
                std::string const& separator);

  template <typename S>
  std::vector<S>
  split_string_strict (S const& value,
                       S const& separator)
  {
    std::vector<S> ret;

    // Skip any separators at the start
    typename S::size_type last_pos = 0;
    // Find first separator.
    typename S::size_type pos = value.find_first_of(separator, last_pos);

    while (pos !=S::npos || last_pos != S::npos)
      {
        // Add to list
        if (pos == std::string::npos)
          // Entire string from last_pos
          ret.push_back(value.substr(last_pos, pos));
        else
          // Between pos and last_pos
          ret.push_back(value.substr(last_pos, pos - last_pos));

        // Find next
        last_pos = pos + separator.length();
        pos = value.find_first_of(separator, last_pos);
      }

    return ret;
  }

  // template
  std::vector<std::string>
  split_string_strict (std::string const& value,
                       std::string const& separator);

  std::wstring
  widen_string (std::string const& str,
                std::locale        locale);

  std::string
  narrow_string (std::wstring const& str,
                 std::locale         locale);

  std::string
  find_program_in_path (std::string const& program,
                        std::string const& path,
                        std::string const& prefix);

  char **
  string_list_to_strv (string_list const& str);

  void
  strv_delete (char **strv);

  int
  exec (std::string const& file,
        string_list const& command,
        environment const& env);

  class stat
  {
  public:
    enum error_code
      {
        FILE, 
        FD    
      };

    enum mode_bits
      {
        FILE_TYPE_MASK      = S_IFMT,   
        FILE_TYPE_SOCKET    = S_IFSOCK, 
        FILE_TYPE_LINK      = S_IFLNK,  
        FILE_TYPE_REGULAR   = S_IFREG,  
        FILE_TYPE_BLOCK     = S_IFBLK,  
        FILE_TYPE_DIRECTORY = S_IFDIR,  
        FILE_TYPE_CHARACTER = S_IFCHR,  
        FILE_TYPE_FIFO      = S_IFIFO,  
        PERM_SETUID         = S_ISUID,  
        PERM_SETGIT         = S_ISGID,  
        PERM_STICKY         = S_ISVTX,  
        PERM_USER_MASK      = S_IRWXU,  
        PERM_USER_READ      = S_IRUSR,  
        PERM_USER_WRITE     = S_IWUSR,  
        PERM_USER_EXECUTE   = S_IXUSR,  
        PERM_GROUP_MASK     = S_IRWXG,  
        PERM_GROUP_READ     = S_IRGRP,  
        PERM_GROUP_WRITE    = S_IWGRP,  
        PERM_GROUP_EXECUTE  = S_IXGRP,  
        PERM_OTHER_MASK     = S_IRWXO,  
        PERM_OTHER_READ     = S_IROTH,  
        PERM_OTHER_WRITE    = S_IWOTH,  
        PERM_OTHER_EXECUTE  = S_IXOTH   
      };

    typedef custom_error<error_code> error;

    stat (const char *file);

    stat (std::string const& file);

    stat (std::string const& file,
          int                fd);

    stat (int fd);

    virtual ~stat ();

    void check () const
    {
      if (this->errorno)
        {
          if (!this->file.empty())
            throw error(this->file, FILE, strerror(this->errorno));
          else
            {
              std::ostringstream str;
              str << "fd " << fd;
              throw error(str.str(), FD, strerror(this->errorno));
            }
        }
    }

    struct ::stat const& get_detail()
    { return this->status; }

    dev_t
    device () const
    { check(); return status.st_dev; }

    ino_t
    inode () const
    { check(); return status.st_ino; }

    mode_t
    mode () const
    { check(); return status.st_mode; }

    nlink_t
    links () const
    { check(); return status.st_nlink; }

    uid_t
    uid () const
    { check(); return status.st_uid; }

    gid_t
    gid () const
    { check(); return status.st_gid; }

    off_t
    size () const
    { check(); return status.st_size; }

    blksize_t
    blocksize () const
    { check(); return status.st_blksize; }

    blkcnt_t
    blocks () const
    { check(); return status.st_blocks; }

    time_t
    atime () const
    { check(); return status.st_atime; }

    time_t
    mtime () const
    { check(); return status.st_mtime; }

    time_t
    ctime () const
    { check(); return status.st_ctime; }

    inline bool
    is_regular () const;

    inline bool
    is_directory () const;

    inline bool
    is_character () const;

    inline bool
    is_block () const;

    inline bool
    is_fifo () const;

    inline bool
    is_link () const;

    inline bool
    is_socket () const;

    inline bool check_mode (mode_bits mask) const;

  private:

    std::string file;
    int fd;
    int errorno;
    struct ::stat status;
  };

  stat::mode_bits
  inline operator | (stat::mode_bits const& lhs,
                     stat::mode_bits const& rhs)
  {
    return static_cast<stat::mode_bits>
      (static_cast<int>(lhs) | static_cast<int>(rhs));
  }

  stat::mode_bits
  inline operator | (mode_t const&          lhs,
                     stat::mode_bits const& rhs)
  {
    return static_cast<stat::mode_bits>
      (lhs | static_cast<int>(rhs));
  }

  stat::mode_bits
  inline operator | (stat::mode_bits const& lhs,
                     mode_t const&          rhs)
  {
    return static_cast<stat::mode_bits>
      (static_cast<int>(lhs) | rhs);
  }

  stat::mode_bits
  inline operator & (stat::mode_bits const& lhs,
                     stat::mode_bits const& rhs)
  {
    return static_cast<stat::mode_bits>
      (static_cast<int>(lhs) & static_cast<int>(rhs));
  }

  stat::mode_bits
  inline operator & (mode_t const&          lhs,
                     stat::mode_bits const& rhs)
  {
    return static_cast<stat::mode_bits>
      (lhs & static_cast<int>(rhs));
  }

  stat::mode_bits
  inline operator & (stat::mode_bits const& lhs,
                     mode_t const&          rhs)
  {
    return static_cast<stat::mode_bits>
      (static_cast<int>(lhs) & rhs);
  }

  inline bool
  stat::is_regular () const
  { return check_mode(FILE_TYPE_REGULAR & FILE_TYPE_MASK); }

  inline bool
  stat::is_directory () const
  { return check_mode(FILE_TYPE_DIRECTORY & FILE_TYPE_MASK); }

  inline bool
  stat::is_character () const
  { return check_mode(FILE_TYPE_CHARACTER & FILE_TYPE_MASK); }

  inline bool
  stat::is_block () const
  { return check_mode(FILE_TYPE_BLOCK & FILE_TYPE_MASK); }

  inline bool
  stat::is_fifo () const
  { return check_mode(FILE_TYPE_FIFO & FILE_TYPE_MASK); }

  inline bool
  stat::is_link () const
  { return check_mode(FILE_TYPE_LINK & FILE_TYPE_MASK); }

  inline bool
  stat::is_socket () const
  { return check_mode(FILE_TYPE_SOCKET & FILE_TYPE_MASK); }

  inline bool
  stat::check_mode (mode_bits mask) const
  {
    check();
    return (static_cast<stat::mode_bits>(status.st_mode) & mask) == mask;
  }

  class passwd : public ::passwd
  {
  public:
    typedef std::vector<char> buffer_type;

    passwd ();

    passwd (uid_t uid);

    passwd (const char *name);

    passwd (std::string const& name);

    void
    clear ();

    void
    query_uid (uid_t uid);

    void
    query_name (const char *name);

    void
    query_name (std::string const& name);

    bool
    operator ! () const;

  private:
    buffer_type buffer;
    bool        valid;
  };

  class group : public ::group
  {
  public:
    typedef std::vector<char> buffer_type;

    group ();

    group (gid_t gid);

    group (const char *name);

    group (std::string const& name);

    void
    clear ();

    void
    query_gid (gid_t gid);

    void
    query_name (const char *name);

    void
    query_name (std::string const& name);

    bool
    operator ! () const;

  private:
    buffer_type buffer;
    bool        valid;
  };

}

#endif /* SBUILD_UTIL_H */

/*
 * Local Variables:
 * mode:C++
 * End:
 */