Open Source Projects Europe

// Append system error string to input string

void catstrerror(string *reason, const char *what, int _errno)

{

    if (!reason)

  return;

    if (what)

  reason->append(what);

    reason->append(": errno: ");

    char nbuf[20];

    sprintf(nbuf, "%d", _errno);

    reason->append(nbuf);

    reason->append(" : ");

#ifdef sun

    // Note: sun strerror is noted mt-safe ??

    reason->append(strerror(_errno));

#else

#define ERRBUFSZ 200    

    char errbuf[ERRBUFSZ];

    // There are 2 versions of strerror_r. 

    // - The GNU one returns a pointer to the message (maybe

    //   static storage or supplied buffer).

    // - The POSIX one always stores in supplied buffer and

    //   returns 0 on success. As the possibility of error and

    //   error code are not specified, we're basically doomed

    //   cause we can't use a test on the 0 value to know if we

    //   were returned a pointer... 

    // Also couldn't find an easy way to disable the gnu version without

    // changing the cxxflags globally, so forget it. Recent gnu lib versions

    // normally default to the posix version.

    // At worse we get no message at all here.

    errbuf[0] = 0;

    (void)strerror_r(_errno, errbuf, ERRBUFSZ);

    reason->append(errbuf);

#endif

}

bool file_to_string(const string &fn, string &data, string *reason)

{

    const int RDBUFSZ = 4096;

    bool ret = false;

    int fd = -1;

    struct stat st;

    fd = open(fn.c_str(), O_RDONLY|O_STREAMING);

    if (fd < 0 || fstat(fd, &st) < 0) {

        catstrerror(reason, "open/stat", errno);

        return false;

    }

    data.reserve(st.st_size+1);

    char buf[RDBUFSZ];

    for (;;) {

  int n = read(fd, buf, RDBUFSZ);

  if (n < 0) {

      catstrerror(reason, "read", errno);

      goto out;

  }

  if (n == 0)

      break;

        data.append(buf, n);

    }

    ret = true;

out:

    if (fd >= 0)

  close(fd);

    return ret;

}

void path_catslash(string &s) {

    if (s.empty() || s[s.length() - 1] != '/')

  s += '/';

}

string path_cat(const string &s1, const string &s2) {

    string res = s1;

    path_catslash(res);

    res +=  s2;

    return res;

}

bool path_exists(const string& path)

{

    return access(path.c_str(), 0) == 0;

}

bool path_isabsolute(const string &path)

{

    if (!path.empty() && (path[0] == '/'

#ifdef _WIN32

                          || path_isdriveabs(path)

#endif

            )) {

        return true;

    } 

    return false;

}

string path_home()

{

    uid_t uid = getuid();

    struct passwd *entry = getpwuid(uid);

    if (entry == 0) {

  const char *cp = getenv("HOME");

  if (cp)

      return cp;

  else 

  return "/";

    }

    string homedir = entry->pw_dir;

    path_catslash(homedir);

    return homedir;

}

string path_tildexpand(const string &s) 

{

    if (s.empty() || s[0] != '~')

  return s;

    string o = s;

    if (s.length() == 1) {

  o.replace(0, 1, path_home());

    } else if  (s[1] == '/') {

  o.replace(0, 2, path_home());

    } else {

  string::size_type pos = s.find('/');

  int l = (pos == string::npos) ? s.length() - 1 : pos - 1;

  struct passwd *entry = getpwnam(s.substr(1, l).c_str());

  if (entry)

      o.replace(0, l+1, entry->pw_dir);

    }

    return o;

}

bool path_makepath(const string& path, int mode)

{

    if (path.empty() || path[0] != '/') {

        return false;

    }

    vector<string> vpath;

    stringToTokens(path, vpath, "/", true);

    string npath;

    for (auto it = vpath.begin(); it != vpath.end(); it++) {

        npath += string("/") + *it;

        if (access(npath.c_str(), 0) < 0) {

            if (mkdir(npath.c_str(), mode)) {

                return false;

            }

        }

    }

    return true;

}

void trimstring(string &s, const char *ws)

{

    string::size_type pos = s.find_first_not_of(ws);

    if (pos == string::npos) {

  s.clear();

  return;

    }

    s.replace(0, pos, string());

    pos = s.find_last_not_of(ws);

    if (pos != string::npos && pos != s.length()-1)

  s.replace(pos+1, string::npos, string());

}

void stringToTokens(const string& str, vector<string>& tokens,

          const string& delims, bool skipinit)

{

    string::size_type startPos = 0, pos;

    // Skip initial delims, return empty if this eats all.

    if (skipinit && 

  (startPos = str.find_first_not_of(delims, 0)) == string::npos) {

  return;

    }

    while (startPos < str.size()) { 

        // Find next delimiter or end of string (end of token)

        pos = str.find_first_of(delims, startPos);

        // Add token to the vector and adjust start

  if (pos == string::npos) {

      tokens.push_back(str.substr(startPos));

      break;

  } else if (pos == startPos) {

      // Dont' push empty tokens after first

      if (tokens.empty())

      tokens.push_back(string());

      startPos = ++pos;

  } else {

      tokens.push_back(str.substr(startPos, pos - startPos));

      startPos = ++pos;

  }

    }

}

template <class T> bool stringToStrings(const string &s, T &tokens, 

                                        const string& addseps)

{

    string current;

    tokens.clear();

    enum states {SPACE, TOKEN, INQUOTE, ESCAPE};

    states state = SPACE;

    for (unsigned int i = 0; i < s.length(); i++) {

  switch (s[i]) {

        case '"': 

      switch(state) {

            case SPACE: 

      state=INQUOTE; continue;

            case TOKEN: 

          current += '"';

      continue;

            case INQUOTE: 

                tokens.insert(tokens.end(), current);

      current.clear();

      state = SPACE;

      continue;

            case ESCAPE:

          current += '"';

          state = INQUOTE;

                continue;

      }

      break;

        case '\\': 

      switch(state) {

            case SPACE: 

            case TOKEN: 

                current += '\\';

                state=TOKEN; 

                continue;

            case INQUOTE: 

                state = ESCAPE;

                continue;

            case ESCAPE:

                current += '\\';

                state = INQUOTE;

                continue;

      }

      break;

        case ' ': 

        case '\t': 

        case '\n': 

        case '\r': 

      switch(state) {

            case SPACE: 

                continue;

            case TOKEN: 

      tokens.insert(tokens.end(), current);

      current.clear();

      state = SPACE;

      continue;

            case INQUOTE: 

            case ESCAPE:

                current += s[i];

                continue;

      }

      break;

        default:

            if (!addseps.empty() && addseps.find(s[i]) != string::npos) {

                switch(state) {

                case ESCAPE:

                    state = INQUOTE;

                    break;

                case INQUOTE: 

                    break;

                case SPACE: 

                    tokens.insert(tokens.end(), string(1, s[i]));

                    continue;

                case TOKEN: 

                    tokens.insert(tokens.end(), current);

                    current.erase();

                    tokens.insert(tokens.end(), string(1, s[i]));

                    state = SPACE;

                    continue;

                }

            } else switch(state) {

                case ESCAPE:

                    state = INQUOTE;

                    break;

                case SPACE: 

                    state = TOKEN;

                    break;

                case TOKEN: 

                case INQUOTE: 

                    break;

                }

      current += s[i];

  }

    }

    switch(state) {

    case SPACE: 

  break;

    case TOKEN: 

  tokens.insert(tokens.end(), current);

  break;

    case INQUOTE: 

    case ESCAPE:

  return false;

    }

    return true;

}

template bool stringToStrings<vector<string> >(const string &, 

                         vector<string> &,const string&);

    if (percent < 0)  percent = 0;

    if (percent > 100)    percent = 100;

// We do not want to mess with the pidfile content in the destructor:

// the lock might still be in use in a child process. In fact as much

// as we'd like to reset the pid inside the file when we're done, it

// would be very difficult to do it right and it's probably best left

// alone.

Pidfile::~Pidfile()

{

    if (m_fd >= 0)

  ::close(m_fd);

    m_fd = -1;

}

pid_t Pidfile::read_pid()

{

    int fd = ::open(m_path.c_str(), O_RDONLY);

    if (fd == -1)

  return (pid_t)-1;

    char buf[16];

    int i = read(fd, buf, sizeof(buf) - 1);

    ::close(fd);

    if (i <= 0)

  return (pid_t)-1;

    buf[i] = '\0';

    char *endptr;

    pid_t pid = strtol(buf, &endptr, 10);

    if (endptr != &buf[i])

  return (pid_t)-1;

    return pid;

}

int Pidfile::flopen()

{

    const char *path = m_path.c_str();

    if ((m_fd = ::open(path, O_RDWR|O_CREAT, 0644)) == -1) {

  m_reason = "Open failed: [" + m_path + "]: " + strerror(errno);

  return -1;

    }

#ifdef sun

    struct flock lockdata;

    lockdata.l_start = 0;

    lockdata.l_len = 0;

    lockdata.l_type = F_WRLCK;

    lockdata.l_whence = SEEK_SET;

    if (fcntl(m_fd, F_SETLK,  &lockdata) != 0) {

  int serrno = errno;

  (void)::close(m_fd);

  errno = serrno;

  m_reason = "fcntl lock failed";

  return -1;

    }

#else

    int operation = LOCK_EX | LOCK_NB;

    if (flock(m_fd, operation) == -1) {

  int serrno = errno;

  (void)::close(m_fd);

  errno = serrno;

  m_reason = "flock failed";

  return -1;

    }

#endif // ! sun

    if (ftruncate(m_fd, 0) != 0) {

  /* can't happen [tm] */

  int serrno = errno;

  (void)::close(m_fd);

  errno = serrno;

  m_reason = "ftruncate failed";

  return -1;

    }

    return 0;

}

pid_t Pidfile::open()

{

    if (flopen() < 0) {

  return read_pid();

    }

    return (pid_t)0;

}

int Pidfile::write_pid()

{

    /* truncate to allow multiple calls */

    if (ftruncate(m_fd, 0) == -1) {

  m_reason = "ftruncate failed";

  return -1;

    }

    char pidstr[20];

    sprintf(pidstr, "%u", int(getpid()));

    lseek(m_fd, 0, 0);

    if (::write(m_fd, pidstr, strlen(pidstr)) != (ssize_t)strlen(pidstr)) {

  m_reason = "write failed";

  return -1;

    }

    return 0;

}

int Pidfile::close()

{

    return ::close(m_fd);

}

int Pidfile::remove()

{

    return unlink(m_path.c_str());

}