uid_map.h

Go to the documentation of this file.

#ifndef CVMFS_UID_MAP_H_
#define CVMFS_UID_MAP_H_

#include <sys/types.h>

#include <cerrno>
#include <map>
#include <string>
#include <vector>

#include "sanitizer.h"
#include "util/logging.h"
#include "util/string.h"

template <typename T>
class IntegerMap {
 public:
  typedef T                                       key_type;
  typedef T                                       value_type;
  typedef typename std::map<key_type, value_type> map_type;

 public:
  IntegerMap()
    : valid_(true)
    , has_default_value_(false)
    , default_value_(T(0)) {}

  void Set(const T k, const T v) { map_[k] = v; }

  void SetDefault(const T v) {
    has_default_value_ = true;
    default_value_     = v;
  }

  bool Read(const std::string &path) {
    valid_ = ReadFromFile(path);
    return IsValid();
  }

  bool Contains(const T k) const {
    assert(IsValid());
    return map_.find(k) != map_.end();
  }

  T Map(const T k) const {
    assert(IsValid());
    typename map_type::const_iterator i = map_.find(k);
    if (i != map_.end()) {
      return i->second;
    }

    return (HasDefault())
      ? default_value_
      : k;
  }

  bool HasEffect() const {
    return (map_.size() != 0) || has_default_value_;
  }

  bool   IsEmpty()    const { return map_.size() == 0;   }
  bool   IsValid()    const { return valid_;             }
  bool   HasDefault() const { return has_default_value_; }
  size_t RuleCount()  const { return map_.size();        }

  T GetDefault() const { assert(has_default_value_); return default_value_; }
  const map_type& GetRuleMap() const { return map_; }

 protected:
  bool ReadFromFile(const std::string &path) {
    FILE *fmap = fopen(path.c_str(), "r");
    if (!fmap) {
      LogCvmfs(kLogUtility, kLogDebug, "failed to open %s (errno: %d)",
               path.c_str(), errno);
      return false;
    }

    sanitizer::IntegerSanitizer int_sanitizer;

    std::string line;
    unsigned int line_number = 0;
    while (GetLineFile(fmap, &line)) {
      ++line_number;
      line = Trim(line);
      if (line.empty() || line[0] == '#') {
        continue;
      }

      std::vector<std::string> components = SplitString(line, ' ');
      FilterEmptyStrings(&components);
      if (components.size() != 2                ||
          !int_sanitizer.IsValid(components[1]) ||
          (components[0] != "*" && !int_sanitizer.IsValid(components[0]))) {
        fclose(fmap);
        LogCvmfs(kLogUtility, kLogDebug, "failed to read line %d in %s",
                 line_number, path.c_str());
        return false;
      }

      value_type to = String2Uint64(components[1]);
      if (components[0] == "*") {
        SetDefault(to);
        continue;
      }

      key_type from = String2Uint64(components[0]);
      Set(from, to);
    }

    fclose(fmap);
    return true;
  }

  void FilterEmptyStrings(std::vector<std::string> *vec) const {
    std::vector<std::string>::iterator i = vec->begin();
    for (; i != vec->end(); ) {
      i = (i->empty()) ? vec->erase(i) : i + 1;
    }
  }

 private:
  bool      valid_;
  map_type  map_;

  bool      has_default_value_;
  T         default_value_;
};

typedef IntegerMap<uid_t> UidMap;
typedef IntegerMap<gid_t> GidMap;

#endif  // CVMFS_UID_MAP_H_