recoll / Code / Diff of /src/utils/pathut.cpp

Diff of /src/utils/pathut.cpp [3ed3f1] .. [a4fd4e]

Switch to unified view


...
 *   Free Software Foundation, Inc.,
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */

#ifndef TEST_PATHUT
#ifdef BUILDING_RECOLL
#include "autoconfig.h"
#else
#include "config.h"
#endif

#include <stdio.h>
#ifdef _WIN32
#include "dirent.h"
#include "safefcntl.h"
#include "safeunistd.h"



#include "safewindows.h"
#include "safesysstat.h"
#else
#include <fcntl.h>
#include <unistd.h>
#include <sys/param.h>
#include <pwd.h>
#include <sys/file.h>
#include <sys/stat.h>
#include <dirent.h>
#endif
#include <math.h>
#include <errno.h>
#include <sys/types.h>



// Let's include all files where statfs can be defined and hope for no
// conflict...
#ifdef HAVE_SYS_MOUNT_H
#include <sys/mount.h>
#endif
#ifdef HAVE_SYS_STATFS_H
#include <sys/statfs.h>
#endif
#ifdef HAVE_SYS_STATVFS_H
#include <sys/statvfs.h>
#endif
#ifdef HAVE_SYS_VFS_H
#include <sys/vfs.h>
#endif

#include <cstdlib>
#include <cstring>
...
#include <stack>
#include <set>
#include <vector>

#include "pathut.h"




using namespace std;

#ifdef _WIN32
/// Convert \ separators to /
void path_slashize(string& s)
{
    for (string::size_type i = 0; i < s.size(); i++) {
        if (s[i] == '\\') {
            s[i] = '/';
        }
    }
}
static bool path_strlookslikedrive(const string& s)
{
    return s.size() == 2 && isalpha(s[0]) && s[1] == ':';
}

static bool path_hasdrive(const string& s)
{
    if (s.size() >= 2 && isalpha(s[0]) && s[1] == ':') {
        return true;
    }
    return false;
}
static bool path_isdriveabs(const string& s)
{
    if (s.size() >= 3 && isalpha(s[0]) && s[1] == ':' && s[2] == '/') {
        return true;
    }
    return false;
}

#include <Shlwapi.h>
#pragma comment(lib, "shlwapi.lib")
...
    // Windows API
    std::vector<char> buffer;
    int size = WideCharToMultiByte(CP_UTF8, 0, text, -1, NULL, 0, NULL, NULL);
    if (size > 0) {
        buffer.resize(size);
        WideCharToMultiByte(CP_UTF8, 0, text, -1,
                            &buffer[0], int(buffer.size()), NULL, NULL);
    } else {
        return string();
    }
    return string(&buffer[0]);
...
    PathCchRemoveFileSpec(text, MAX_PATH);
#else
    PathRemoveFileSpec(text);
#endif
    string path = path_tchartoutf8(text);
    if (path.empty()) {
        path = "c:/";
    }

    return path;
}

string path_wingettempfilename(TCHAR *pref)
{
    TCHAR buf[(MAX_PATH + 1)*sizeof(TCHAR)];
    TCHAR dbuf[(MAX_PATH + 1)*sizeof(TCHAR)];
    GetTempPath(MAX_PATH + 1, dbuf);
    GetTempFileName(dbuf, pref, 0, buf);
    // Windows will have created a temp file, we delete it.
    string filename = path_tchartoutf8(buf);
    unlink(filename.c_str());
    path_slashize(filename);
    return filename;
}
#endif

#if defined(HAVE_SYS_MOUNT_H) || defined(HAVE_SYS_STATFS_H) || \
    defined(HAVE_SYS_STATVFS_H) || defined(HAVE_SYS_VFS_H)
bool fsocc(const string& path, int *pc, long long *avmbs)
{
    static const int FSOCC_MB = 1024 * 1024;
#ifdef _WIN32
    ULARGE_INTEGER freebytesavail;
    ULARGE_INTEGER totalbytes;
    if (!GetDiskFreeSpaceEx(path.c_str(), &freebytesavail,
                            &totalbytes, NULL)) {
        return false;
    }
    if (pc) {
        *pc = int((100 * freebytesavail.QuadPart) / totalbytes.QuadPart);
    }
    if (avmbs) {
        *avmbs = int(totalbytes.QuadPart / FSOCC_MB);
    }
    return true;
#else
#ifdef sun
    struct statvfs buf;
    if (statvfs(path.c_str(), &buf) != 0) {
        return false;
    }
#else
    struct statfs buf;
    if (statfs(path.c_str(), &buf) != 0) {
        return false;
    }
#endif

    // used blocks
    double fpc = 0.0;
#define FSOCC_USED (double(buf.f_blocks - buf.f_bfree))
#define FSOCC_TOTAVAIL (FSOCC_USED + double(buf.f_bavail))
    if (FSOCC_TOTAVAIL > 0) {
        fpc = 100.0 * FSOCC_USED / FSOCC_TOTAVAIL;
    }
    if (pc) {
        *pc = int(fpc);
    }
    if (avmbs) {
        *avmbs = 0;
        if (buf.f_bsize > 0) {
            int ratio = buf.f_bsize > FSOCC_MB ? buf.f_bsize / FSOCC_MB :
                        FSOCC_MB / buf.f_bsize;

            *avmbs = buf.f_bsize > FSOCC_MB ?
                     ((long long)buf.f_bavail) * ratio :
                     ((long long)buf.f_bavail) / ratio;
        }
    }
    return true;
#endif
}
#endif // we have found an appropriate include file
















































string path_PATHsep()
{
    static const string w(";");
    static const string u(":");
...
#else
    return u;
#endif
}







































































































































void path_catslash(string& s)
{
#ifdef _WIN32
    path_slashize(s);
#endif
    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;
}

string path_getfather(const string& s)
{
    string father = s;
#ifdef _WIN32
    path_slashize(father);
#endif

    // ??
    if (father.empty()) {
        return "./";
    }

    if (path_isroot(father)) {
        return father;
    }

    if (father[father.length() - 1] == '/') {
        // Input ends with /. Strip it, root special case was tested above
        father.erase(father.length() - 1);
    }

    string::size_type slp = father.rfind('/');
    if (slp == string::npos) {
        return "./";
    }

    father.erase(slp);
    path_catslash(father);
    return father;
}

string path_getsimple(const string& s)
{
    string simple = s;
#ifdef _WIN32
    path_slashize(simple);
#endif

    if (simple.empty()) {
        return simple;
    }

    string::size_type slp = simple.rfind('/');
    if (slp == string::npos) {
        return simple;
    }

    simple.erase(0, slp + 1);
    return simple;
}

string path_basename(const string& s, const string& suff)
{
    string simple = path_getsimple(s);
    string::size_type pos = string::npos;
    if (suff.length() && simple.length() > suff.length()) {
        pos = simple.rfind(suff);
        if (pos != string::npos && pos + suff.length() == simple.length()) {
            return simple.substr(0, pos);
        }
    }
    return simple;
}

string path_suffix(const string& s)
{
    string::size_type dotp = s.rfind('.');
    if (dotp == string::npos) {
        return string();
    }
    return s.substr(dotp + 1);
}

string path_home()
{
#ifdef _WIN32
...
#else
    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;
...
    // We should use an xdg-conforming location, but, history...
    return path_home();
#endif
}

string path_tildexpand(const string& s)
{
    if (s.empty() || s[0] != '~') {
        return s;
    }
    string o = s;
#ifdef _WIN32
    path_slashize(o);
#endif

    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('/');
        string::size_type l = (pos == string::npos) ? s.length() - 1 : pos - 1;
#ifdef _WIN32
        // Dont know what this means. Just replace with HOME
        o.replace(0, l + 1, path_home());
#else
        struct passwd *entry = getpwnam(s.substr(1, l).c_str());
        if (entry) {
            o.replace(0, l + 1, entry->pw_dir);
        }
#endif
    }
    return o;
}

bool path_isroot(const string& path)
{
    if (path.size() == 1 && path[0] == '/') {
        return true;
    }
#ifdef _WIN32
    if (path.size() == 3 && isalpha(path[0]) && path[1] == ':' &&
            (path[2] == '/' || path[2] == '\\')) {
        return true;
    }
#endif
    return false;
}

bool path_isabsolute(const string& path)
{
    if (!path.empty() && (path[0] == '/'
#ifdef _WIN32
                          || path_isdriveabs(path)
#endif
                         )) {
        return true;
    }
    return false;
}

string path_absolute(const string& is)
{
    if (is.length() == 0) {
        return is;
    }
    string s = is;
    if (!path_isabsolute(s)) {
        char buf[MAXPATHLEN];
        if (!getcwd(buf, MAXPATHLEN)) {
            return string();
        }
        s = path_cat(string(buf), s);
#ifdef _WIN32
        path_slashize(s);
#endif
    }
    return s;
}

#include <smallut.h>
string path_canon(const string& is, const string* cwd)
{
    if (is.length() == 0) {
        return is;
    }
    string s = is;
#ifdef _WIN32
    path_slashize(s);
    // fix possible path from file: absolute url
    if (s.size() && s[0] == '/' && path_hasdrive(s.substr(1))) {
        s = s.substr(1);
    }
#endif

    if (!path_isabsolute(s)) {
        char buf[MAXPATHLEN];
        const char *cwdp = buf;
        if (cwd) {
            cwdp = cwd->c_str();
        } else {
            if (!getcwd(buf, MAXPATHLEN)) {
                return string();
            }
        }
        s = path_cat(string(cwdp), s);
    }
    vector<string> elems;
    stringToTokens(s, elems, "/");
    vector<string> cleaned;
    for (vector<string>::const_iterator it = elems.begin();
            it != elems.end(); it++) {
        if (*it == "..") {
            if (!cleaned.empty()) {
                cleaned.pop_back();
            }
        } else if (it->empty() || *it == ".") {
        } else {
            cleaned.push_back(*it);
        }
    }
    string ret;
    if (!cleaned.empty()) {
        for (vector<string>::const_iterator it = cleaned.begin();
                it != cleaned.end(); it++) {
            ret += "/";
#ifdef _WIN32
            if (it == cleaned.begin() && path_strlookslikedrive(*it)) {
                // Get rid of just added initial "/"
                ret.clear();
            }
#endif
            ret += *it;
        }
    } else {
        ret = "/";
    }
    return ret;
}

bool makepath(const string& ipath)
{
    string path = path_canon(ipath);
    vector<string> elems;
    stringToTokens(path, elems, "/");
    path = "/";
    for (vector<string>::const_iterator it = elems.begin();
            it != elems.end(); it++) {
#ifdef _WIN32
        if (it == elems.begin() && path_strlookslikedrive(*it)) {
            path = "";
        }
#endif
        path += *it;
        // Not using path_isdir() here, because this cant grok symlinks
        // If we hit an existing file, no worry, mkdir will just fail.
        if (access(path.c_str(), 0) != 0) {
            if (mkdir(path.c_str(), 0700) != 0)  {
                return false;
            }
        }
        path += "/";
    }
    return true;
}

bool path_isdir(const string& path)
{
    struct stat st;
    if (lstat(path.c_str(), &st) < 0) {
        return false;
    }
    if (S_ISDIR(st.st_mode)) {
        return true;
    }
    return false;
}

long long path_filesize(const string& path)
{
    struct stat st;
    if (stat(path.c_str(), &st) < 0) {
        return -1;
    }
    return (long long)st.st_size;
}

int path_fileprops(const std::string path, struct stat *stp, bool follow)
{
    if (!stp) {
        return -1;
    }
    memset(stp, 0, sizeof(struct stat));
    struct stat mst;
    int ret = follow ? stat(path.c_str(), &mst) : lstat(path.c_str(), &mst);
    if (ret != 0) {
        return ret;
    }
    stp->st_size = mst.st_size;
    stp->st_mode = mst.st_mode;
    stp->st_mtime = mst.st_mtime;
#ifdef _WIN32
    stp->st_ctime = mst.st_mtime;
...
27 '
28 (
29 )
2A *
2B +
2C ,
2D -
2E .
2F /
30 0
...
...
string url_encode(const string& url, string::size_type offs)
{
    string out = url.substr(0, offs);
    const char *cp = url.c_str();
    for (string::size_type i = offs; i < url.size(); i++) {
        unsigned int c;
        const char *h = "0123456789ABCDEF";
        c = cp[i];
        if (c <= 0x20 ||
                c >= 0x7f ||
                c == '"' ||
                c == '#' ||
                c == '%' ||
                c == ';' ||
                c == '<' ||
                c == '>' ||
                c == '?' ||
                c == '[' ||
                c == '\\' ||
                c == ']' ||
                c == '^' ||
                c == '`' ||
                c == '{' ||
                c == '|' ||
                c == '}') {
            out += '%';
            out += h[(c >> 4) & 0xf];
            out += h[c & 0xf];
        } else {
            out += char(c);
        }
    }
    return out;
}

string url_gpath(const string& url)
{
    // Remove the access schema part (or whatever it's called)
    string::size_type colon = url.find_first_of(":");
    if (colon == string::npos || colon == url.size() - 1) {
        return url;
    }
    // If there are non-alphanum chars before the ':', then there
    // probably is no scheme. Whatever...
    for (string::size_type i = 0; i < colon; i++) {
        if (!isalnum(url.at(i))) {
            return url;
        }
    }

    // In addition we canonize the path to remove empty host parts
    // (for compatibility with older versions of recoll where file://
    // was hardcoded, but the local path was used for doc
    // identification.
    return path_canon(url.substr(colon + 1));
}
























string url_parentfolder(const string& url)
{
    // In general, the parent is the directory above the full path
    string parenturl = path_getfather(url_gpath(url));
...
    bool isfileurl = urlisfileurl(url);
    if (!isfileurl && parenturl == "/") {
        parenturl = url_gpath(url);
    }
    return isfileurl ? string("file://") + parenturl :
           string("http://") + parenturl;
}











// Convert to file path if url is like file:
// Note: this only works with our internal pseudo-urls which are not
// encoded/escaped
string fileurltolocalpath(string url)
{
    if (url.find("file://") == 0) {
        url = url.substr(7, string::npos);
    } else {
        return string();
    }

#ifdef _WIN32
    // Absolute file urls are like: file:///c:/mydir/...
    // Get rid of the initial '/'
    if (url.size() >= 3 && url[0] == '/' && isalpha(url[1]) && url[2] == ':') {
...
    // Removing the fragment part. This is exclusively used when
    // executing a viewer for the recoll manual, and we only strip the
    // part after # if it is preceded by .html
    string::size_type pos;
    if ((pos = url.rfind(".html#")) != string::npos) {
        url.erase(pos + 5);
    } else if ((pos = url.rfind(".htm#")) != string::npos) {
        url.erase(pos + 4);
    }

    return url;
}

static const string cstr_fileu("file://");

string path_pathtofileurl(const string& path)
{
    // We're supposed to receive a canonic absolute path, but on windows we
    // may need to add a '/' in front of the drive spec
    string url(cstr_fileu);
    if (path.empty() || path[0] != '/') {
        url.push_back('/');
    }
    url += path;
    return url;
}

bool urlisfileurl(const string& url)
{
    return url.find("file://") == 0;











}

bool readdir(const string& dir, string& reason, set<string>& entries)
{
    struct stat st;
    int statret;
    ostringstream msg;
    DIR *d = 0;
    statret = lstat(dir.c_str(), &st);
    if (statret == -1) {
        msg << "readdir: cant stat " << dir << " errno " <<  errno;
        goto out;
    }
    if (!S_ISDIR(st.st_mode)) {
        msg << "readdir: " << dir <<  " not a directory";
        goto out;
    }
    if (access(dir.c_str(), R_OK) < 0) {
        msg << "readdir: no read access to " << dir;
        goto out;
    }

    d = opendir(dir.c_str());
    if (d == 0) {
        msg << "readdir: cant opendir " << dir << ", errno " << errno;
        goto out;
    }

    struct dirent *ent;
    while ((ent = readdir(d)) != 0) {
        if (!strcmp(ent->d_name, ".") || !strcmp(ent->d_name, "..")) {
            continue;
        }
        entries.insert(ent->d_name);
    }

out:
    if (d) {
        closedir(d);
    }
    reason = msg.str();
    if (reason.empty()) {
        return true;
    }
    return false;
}

// 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
#ifdef _WIN32
    return 0;
#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 // ! win32
#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()
...
}

int Pidfile::remove()
{
    return unlink(m_path.c_str());


































































}

// Call funcs that need static init (not initially reentrant)
void pathut_init_mt()
{
    path_home();



}


#else // TEST_PATHUT
#include <stdlib.h>
...

void path_to_thumb(const string& _input)
{
    string input(_input);
    // Make absolute path if needed
    if (input[0] != '/') {
        input = path_absolute(input);
    }

    input = string("file://") + path_canon(input);

    string path;
    //path = url_encode(input, 7);
    thumbPathForUrl(input, 7, path);
    cout << path << endl;
}

const char *tstvec[] = {"", "/", "/dir", "/dir/", "/dir1/dir2",
                        "/dir1/dir2",
                        "./dir", "./dir1/", "dir", "../dir", "/dir/toto.c",
                        "/dir/.c", "/dir/toto.txt", "toto.txt1"
                       };

const string ttvec[] = {"/dir", "", "~", "~/sub", "~root", "~root/sub",
                        "~nosuch", "~nosuch/sub"
                       };
int nttvec = sizeof(ttvec) / sizeof(string);

const char *thisprog;

int main(int argc, const char **argv)
{
    thisprog = *argv++;
    argc--;

    string s;
    vector<string>::const_iterator it;
#if 0
    for (unsigned int i = 0; i < sizeof(tstvec) / sizeof(char *); i++) {
        cout << tstvec[i] << " Father " << path_getfather(tstvec[i]) << endl;
    }
    for (unsigned int i = 0; i < sizeof(tstvec) / sizeof(char *); i++) {
        cout << tstvec[i] << " Simple " << path_getsimple(tstvec[i]) << endl;
    }
    for (unsigned int i = 0; i < sizeof(tstvec) / sizeof(char *); i++) {
        cout << tstvec[i] << " Basename " <<
             path_basename(tstvec[i], ".txt") << endl;
    }
#endif

#if 0
    for (int i = 0; i < nttvec; i++) {
        cout << "tildexp: '" << ttvec[i] << "' -> '" <<
             path_tildexpand(ttvec[i]) << "'" << endl;
    }
#endif

#if 0
    const string canontst[] = {"/dir1/../../..", "/////", "",
                               "/dir1/../../.././/////dir2///////",
                               "../../",
                               "../../../../../../../../../../"
                              };
    unsigned int nttvec = sizeof(canontst) / sizeof(string);
    for (unsigned int i = 0; i < nttvec; i++) {
        cout << "canon: '" << canontst[i] << "' -> '" <<
             path_canon(canontst[i]) << "'" << endl;
    }
#endif
#if 0
    if (argc != 2) {
        cerr << "Usage: trpathut <dir> <pattern>" << endl;
        exit(1);
    }
    string dir = *argv++;
    argc--;
    string pattern =  *argv++;
    argc--;
    vector<string> matched = path_dirglob(dir, pattern);
    for (it = matched.begin(); it != matched.end(); it++) {
        cout << *it << endl;
    }
#endif

#if 0
    if (argc != 1) {
        fprintf(stderr, "Usage: fsocc: trpathut <path>\n");
        exit(1);
    }
    string path = *argv++;
    argc--;

    int pc;
    long long blocks;
    if (!fsocc(path, &pc, &blocks)) {
        fprintf(stderr, "fsocc failed\n");
        return 1;
    }
    printf("pc %d, megabytes %ld\n", pc, blocks);
#endif

#if 0
    Pidfile pidfile("/tmp/pathutpidfile");
    pid_t pid;
    if ((pid = pidfile.open()) != 0) {
        cerr << "open failed. reason: " << pidfile.getreason() <<
             " return " << pid << endl;
        exit(1);
    }
    pidfile.write_pid();
    sleep(10);
    pidfile.close();
    pidfile.remove();
#endif

#if 0
    if (argc > 1) {
        cerr <<  "Usage: thumbpath <filepath>" << endl;
        exit(1);
    }
    string input;
    if (argc == 1) {
        input = *argv++;
        if (input.empty())  {
            cerr << "Usage: thumbpath <filepath>" << endl;
            exit(1);
        }
        path_to_thumb(input);
    } else {
        while (getline(cin, input)) {
            path_to_thumb(input);
        }
    }


    exit(0);
#endif

#if 0
    if (argc != 1) {
        cerr << "Usage: trpathut <filename>" << endl;
        exit(1);
    }
    string fn = *argv++;
    argc--;
    string ext = path_suffix(fn);
    cout << "Suffix: [" << ext << "]" << endl;
    return 0;
#endif

#if 1
    if (argc != 1) {
        cerr << "Usage: trpathut url" << endl;
        exit(1);
    }
    string url = *argv++;
    argc--;

    cout << "File: [" << fileurltolocalpath(url) << "]\n";
    return 0;
#endif


	a/src/utils/pathut.cpp		b/src/utils/pathut.cpp
	...		...
14	* Free Software Foundation, Inc.,	14	* Free Software Foundation, Inc.,
15	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.	15	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
16	*/	16	*/
17		17
18	#ifndef TEST_PATHUT	18	#ifndef TEST_PATHUT
		19	#ifdef BUILDING_RECOLL
19	#include "autoconfig.h"	20	#include "autoconfig.h"
		21	#else
		22	#include "config.h"
		23	#endif
20		24
21	#include <stdio.h>	25	#include <stdio.h>
		26	#ifdef _WIN32
		27	#include "dirent.h"
22	#include "safefcntl.h"	28	#include "safefcntl.h"
23	#include "safeunistd.h"	29	#include "safeunistd.h"
24	#include "dirent.h"
25	#include "cstr.h"
26	#ifdef _WIN32
27	#include "safewindows.h"	30	#include "safewindows.h"
		31	#include "safesysstat.h"
28	#else	32	#else
		33	#include <fcntl.h>
		34	#include <unistd.h>
29	#include <sys/param.h>	35	#include <sys/param.h>
30	#include <pwd.h>	36	#include <pwd.h>
31	#include <sys/file.h>	37	#include <sys/file.h>
		38	#include <sys/stat.h>
		39	#include <dirent.h>
32	#endif	40	#endif
33	#include <math.h>	41	#include <math.h>
34	#include <errno.h>	42	#include <errno.h>
35	#include <sys/types.h>	43	#include <sys/types.h>
36	#include "safesysstat.h"
37	#include "ptmutex.h"
38		44
39	// Let's include all files where statfs can be defined and hope for no	45	// Let's include all files where statfs can be defined and hope for no
40	// conflict...	46	// conflict...
41	#ifdef HAVE_SYS_MOUNT_H	47	#ifdef HAVE_SYS_MOUNT_H
42	#include <sys/mount.h>	48	#include <sys/mount.h>
43	#endif	49	#endif
44	#ifdef HAVE_SYS_STATFS_H	50	#ifdef HAVE_SYS_STATFS_H
45	#include <sys/statfs.h>	51	#include <sys/statfs.h>
46	#endif	52	#endif
47	#ifdef HAVE_SYS_STATVFS_H	53	#ifdef HAVE_SYS_STATVFS_H
48	#include <sys/statvfs.h>	54	#include <sys/statvfs.h>
49	#endif	55	#endif
50	#ifdef HAVE_SYS_VFS_H	56	#ifdef HAVE_SYS_VFS_H
51	#include <sys/vfs.h>	57	#include <sys/vfs.h>
52	#endif	58	#endif
53		59
54	#include <cstdlib>	60	#include <cstdlib>
55	#include <cstring>	61	#include <cstring>
	...		...
58	#include <stack>	64	#include <stack>
59	#include <set>	65	#include <set>
60	#include <vector>	66	#include <vector>
61		67
62	#include "pathut.h"	68	#include "pathut.h"
63	#include "transcode.h"
64	#include "wipedir.h"
65	#include "md5ut.h"
66		69
67	using namespace std;	70	using namespace std;
68		71
69	#ifdef _WIN32	72	#ifdef _WIN32
70	/// Convert \ separators to /	73	/// Convert \ separators to /
71	void path_slashize(string& s)	74	void path_slashize(string& s)
72	{	75	{
73	for (string::size_type i = 0; i < s.size(); i++) {	76	for (string::size_type i = 0; i < s.size(); i++) {
74	if (s[i] == '\\')	77	if (s[i] == '\\') {
75	s[i] = '/';	78	s[i] = '/';
		79	}
76	}	80	}
77	}	81	}
78	static bool path_strlookslikedrive(const string& s)	82	static bool path_strlookslikedrive(const string& s)
79	{	83	{
80	return s.size() == 2 && isalpha(s[0]) && s[1] == ':';	84	return s.size() == 2 && isalpha(s[0]) && s[1] == ':';
81	}	85	}
82		86
83	static bool path_hasdrive(const string& s)	87	static bool path_hasdrive(const string& s)
84	{	88	{
85	if (s.size() >= 2 && isalpha(s[0]) && s[1] == ':')	89	if (s.size() >= 2 && isalpha(s[0]) && s[1] == ':') {
86	return true;	90	return true;
		91	}
87	return false;	92	return false;
88	}	93	}
89	static bool path_isdriveabs(const string& s)	94	static bool path_isdriveabs(const string& s)
90	{	95	{
91	if (s.size() >= 3 && isalpha(s[0]) && s[1] == ':' && s[2] == '/')	96	if (s.size() >= 3 && isalpha(s[0]) && s[1] == ':' && s[2] == '/') {
92	return true;	97	return true;
		98	}
93	return false;	99	return false;
94	}	100	}
95		101
96	#include <Shlwapi.h>	102	#include <Shlwapi.h>
97	#pragma comment(lib, "shlwapi.lib")	103	#pragma comment(lib, "shlwapi.lib")
	...		...
107	// Windows API	113	// Windows API
108	std::vector<char> buffer;	114	std::vector<char> buffer;
109	int size = WideCharToMultiByte(CP_UTF8, 0, text, -1, NULL, 0, NULL, NULL);	115	int size = WideCharToMultiByte(CP_UTF8, 0, text, -1, NULL, 0, NULL, NULL);
110	if (size > 0) {	116	if (size > 0) {
111	buffer.resize(size);	117	buffer.resize(size);
112	WideCharToMultiByte(CP_UTF8, 0, text, -1,	118	WideCharToMultiByte(CP_UTF8, 0, text, -1,
113	&buffer[0], int(buffer.size()), NULL, NULL);	119	&buffer[0], int(buffer.size()), NULL, NULL);
114	} else {	120	} else {
115	return string();	121	return string();
116	}	122	}
117	return string(&buffer[0]);	123	return string(&buffer[0]);
	...		...
128	PathCchRemoveFileSpec(text, MAX_PATH);	134	PathCchRemoveFileSpec(text, MAX_PATH);
129	#else	135	#else
130	PathRemoveFileSpec(text);	136	PathRemoveFileSpec(text);
131	#endif	137	#endif
132	string path = path_tchartoutf8(text);	138	string path = path_tchartoutf8(text);
133	if (path.empty())	139	if (path.empty()) {
134	path = "c:/";	140	path = "c:/";
		141	}
135		142
136	return path;	143	return path;
137	}	144	}
138		145
139	string path_wingettempfilename(TCHAR *pref)	146	string path_wingettempfilename(TCHAR *pref)
140	{	147	{
141	TCHAR buf[(MAX_PATH +1)*sizeof(TCHAR)];	148	TCHAR buf[(MAX_PATH + 1)*sizeof(TCHAR)];
142	TCHAR dbuf[(MAX_PATH +1)*sizeof(TCHAR)];	149	TCHAR dbuf[(MAX_PATH + 1)*sizeof(TCHAR)];
143	GetTempPath(MAX_PATH+1, dbuf);	150	GetTempPath(MAX_PATH + 1, dbuf);
144	GetTempFileName(dbuf, pref, 0, buf);	151	GetTempFileName(dbuf, pref, 0, buf);
145	// Windows will have created a temp file, we delete it.	152	// Windows will have created a temp file, we delete it.
146	string filename = path_tchartoutf8(buf);	153	string filename = path_tchartoutf8(buf);
147	unlink(filename.c_str());	154	unlink(filename.c_str());
148	path_slashize(filename);	155	path_slashize(filename);
149	return filename;	156	return filename;
150	}	157	}
151	#endif	158	#endif
152		159
153		160	#if defined(HAVE_SYS_MOUNT_H) \|\| defined(HAVE_SYS_STATFS_H) \|\| \
		161	defined(HAVE_SYS_STATVFS_H) \|\| defined(HAVE_SYS_VFS_H)
154	bool fsocc(const string &path, int pc, long long avmbs)	162	bool fsocc(const string& path, int pc, long long avmbs)
155	{	163	{
156	static const int FSOCC_MB = 1024*1024;	164	static const int FSOCC_MB = 1024 * 1024;
157	#ifdef _WIN32	165	#ifdef _WIN32
158	ULARGE_INTEGER freebytesavail;	166	ULARGE_INTEGER freebytesavail;
159	ULARGE_INTEGER totalbytes;	167	ULARGE_INTEGER totalbytes;
160	if (!GetDiskFreeSpaceEx(path.c_str(), &freebytesavail,	168	if (!GetDiskFreeSpaceEx(path.c_str(), &freebytesavail,
161	&totalbytes, NULL)) {	169	&totalbytes, NULL)) {
162	return false;	170	return false;
163	}	171	}
164	if (pc)	172	if (pc) {
165	pc = int((100 freebytesavail.QuadPart) / totalbytes.QuadPart);	173	pc = int((100 freebytesavail.QuadPart) / totalbytes.QuadPart);
		174	}
166	if (avmbs)	175	if (avmbs) {
167	*avmbs = int(totalbytes.QuadPart / FSOCC_MB);	176	*avmbs = int(totalbytes.QuadPart / FSOCC_MB);
		177	}
168	return true;	178	return true;
169	#else	179	#else
170	#ifdef sun	180	#ifdef sun
171	struct statvfs buf;	181	struct statvfs buf;
172	if (statvfs(path.c_str(), &buf) != 0) {	182	if (statvfs(path.c_str(), &buf) != 0) {
173	return false;	183	return false;
174	}	184	}
175	#else	185	#else
176	struct statfs buf;	186	struct statfs buf;
177	if (statfs(path.c_str(), &buf) != 0) {	187	if (statfs(path.c_str(), &buf) != 0) {
178	return false;	188	return false;
179	}	189	}
180	#endif	190	#endif
181		191
182	// used blocks	192	// used blocks
183	double fpc = 0.0;	193	double fpc = 0.0;
184	#define FSOCC_USED (double(buf.f_blocks - buf.f_bfree))	194	#define FSOCC_USED (double(buf.f_blocks - buf.f_bfree))
185	#define FSOCC_TOTAVAIL (FSOCC_USED + double(buf.f_bavail))	195	#define FSOCC_TOTAVAIL (FSOCC_USED + double(buf.f_bavail))
186	if (FSOCC_TOTAVAIL > 0) {	196	if (FSOCC_TOTAVAIL > 0) {
187	fpc = 100.0 * FSOCC_USED / FSOCC_TOTAVAIL;	197	fpc = 100.0 * FSOCC_USED / FSOCC_TOTAVAIL;
188	}	198	}
189	if (pc)	199	if (pc) {
190	*pc = int(fpc);	200	*pc = int(fpc);
		201	}
191	if (avmbs) {	202	if (avmbs) {
192	*avmbs = 0;	203	*avmbs = 0;
193	if (buf.f_bsize > 0) {	204	if (buf.f_bsize > 0) {
194	int ratio = buf.f_bsize > FSOCC_MB ? buf.f_bsize / FSOCC_MB :	205	int ratio = buf.f_bsize > FSOCC_MB ? buf.f_bsize / FSOCC_MB :
195	FSOCC_MB / buf.f_bsize;	206	FSOCC_MB / buf.f_bsize;
196		207
197	*avmbs = buf.f_bsize > FSOCC_MB ?	208	*avmbs = buf.f_bsize > FSOCC_MB ?
198	((long long)buf.f_bavail) * ratio :	209	((long long)buf.f_bavail) * ratio :
199	((long long)buf.f_bavail) / ratio;	210	((long long)buf.f_bavail) / ratio;
200	}	211	}
201	}	212	}
202	return true;	213	return true;
203	#endif	214	#endif
204	}	215	}
205		216	#endif // we have found an appropriate include file
206	const string& tmplocation()
207	{
208	static string stmpdir;
209	if (stmpdir.empty()) {
210	const char *tmpdir = getenv("RECOLL_TMPDIR");
211	if (tmpdir == 0)
212	tmpdir = getenv("TMPDIR");
213	if (tmpdir == 0)
214	tmpdir = getenv("TMP");
215	if (tmpdir == 0)
216	tmpdir = getenv("TEMP");
217	if (tmpdir == 0) {
218	#ifdef _WIN32
219	TCHAR bufw[(MAX_PATH+1)*sizeof(TCHAR)];
220	GetTempPath(MAX_PATH+1, bufw);
221	stmpdir = path_tchartoutf8(bufw);
222	#else
223	stmpdir = "/tmp";
224	#endif
225	} else {
226	stmpdir = tmpdir;
227	}
228	stmpdir = path_canon(stmpdir);
229	}
230
231	return stmpdir;
232	}
233
234	// Location for sample config, filters, etc. (e.g. /usr/share/recoll/)
235	const string& path_sharedatadir()
236	{
237	static string datadir;
238	if (datadir.empty()) {
239	#ifdef _WIN32
240	datadir = path_cat(path_thisexecpath(), "Share");
241	#else
242	const char *cdatadir = getenv("RECOLL_DATADIR");
243	if (cdatadir == 0) {
244	// If not in environment, use the compiled-in constant.
245	datadir = RECOLL_DATADIR;
246	} else {
247	datadir = cdatadir;
248	}
249	#endif
250	}
251	return datadir;
252	}
253		217
254	string path_PATHsep()	218	string path_PATHsep()
255	{	219	{
256	static const string w(";");	220	static const string w(";");
257	static const string u(":");	221	static const string u(":");
	...		...
260	#else	224	#else
261	return u;	225	return u;
262	#endif	226	#endif
263	}	227	}
264		228
265	bool maketmpdir(string& tdir, string& reason)
266	{
267	#ifndef _WIN32
268	tdir = path_cat(tmplocation(), "rcltmpXXXXXX");
269
270	char *cp = strdup(tdir.c_str());
271	if (!cp) {
272	reason = "maketmpdir: out of memory (for file name !)\n";
273	tdir.erase();
274	return false;
275	}
276
277	// There is a race condition between name computation and
278	// mkdir. try to make sure that we at least don't shoot ourselves
279	// in the foot
280	#if !defined(HAVE_MKDTEMP) \|\| defined(_WIN32)
281	static PTMutexInit mlock;
282	PTMutexLocker lock(mlock);
283	#endif
284
285	if (!
286	#ifdef HAVE_MKDTEMP
287	mkdtemp(cp)
288	#else
289	mktemp(cp)
290	#endif // HAVE_MKDTEMP
291	) {
292	free(cp);
293	reason = "maketmpdir: mktemp failed for [" + tdir + "] : " +
294	strerror(errno);
295	tdir.erase();
296	return false;
297	}
298	tdir = cp;
299	free(cp);
300	#else // _WIN32
301	// There is a race condition between name computation and
302	// mkdir. try to make sure that we at least don't shoot ourselves
303	// in the foot
304	static PTMutexInit mlock;
305	PTMutexLocker lock(mlock);
306	tdir = path_wingettempfilename(TEXT("rcltmp"));
307	#endif
308
309	// At this point the directory does not exist yet except if we used
310	// mkdtemp
311
312	#if !defined(HAVE_MKDTEMP) \|\| defined(_WIN32)
313	if (mkdir(tdir.c_str(), 0700) < 0) {
314	reason = string("maketmpdir: mkdir ") + tdir + " failed";
315	tdir.erase();
316	return false;
317	}
318	#endif
319
320	return true;
321	}
322
323	TempFileInternal::TempFileInternal(const string& suffix)
324	: m_noremove(false)
325	{
326	// Because we need a specific suffix, can't use mkstemp
327	// well. There is a race condition between name computation and
328	// file creation. try to make sure that we at least don't shoot
329	// our own selves in the foot. maybe we'll use mkstemps one day.
330	static PTMutexInit mlock;
331	PTMutexLocker lock(mlock);
332
333	#ifndef _WIN32
334	string filename = path_cat(tmplocation(), "rcltmpfXXXXXX");
335	char *cp = strdup(filename.c_str());
336	if (!cp) {
337	m_reason = "Out of memory (for file name !)\n";
338	return;
339	}
340
341	// Using mkstemp this way is awful (bot the suffix adding and
342	// using mkstemp() instead of mktemp just to avoid the warnings)
343	int fd;
344	if ((fd = mkstemp(cp)) < 0) {
345	free(cp);
346	m_reason = "TempFileInternal: mkstemp failed\n";
347	return;
348	}
349	close(fd);
350	unlink(cp);
351	filename = cp;
352	free(cp);
353	#else
354	string filename = path_wingettempfilename(TEXT("recoll"));
355	#endif
356
357	m_filename = filename + suffix;
358	if (close(open(m_filename.c_str(), O_CREAT\|O_EXCL, 0600)) != 0) {
359	m_reason = string("Could not open/create") + m_filename;
360	m_filename.erase();
361	}
362	}
363
364	TempFileInternal::~TempFileInternal()
365	{
366	if (!m_filename.empty() && !m_noremove)
367	unlink(m_filename.c_str());
368	}
369
370	TempDir::TempDir()
371	{
372	if (!maketmpdir(m_dirname, m_reason)) {
373	m_dirname.erase();
374	return;
375	}
376	}
377
378	TempDir::~TempDir()
379	{
380	if (!m_dirname.empty()) {
381	(void)wipedir(m_dirname, true, true);
382	m_dirname.erase();
383	}
384	}
385
386	bool TempDir::wipe()
387	{
388	if (m_dirname.empty()) {
389	m_reason = "TempDir::wipe: no directory !\n";
390	return false;
391	}
392	if (wipedir(m_dirname, false, true)) {
393	m_reason = "TempDir::wipe: wipedir failed\n";
394	return false;
395	}
396	return true;
397	}
398
399	void path_catslash(string &s)	229	void path_catslash(string& s)
400	{	230	{
401	#ifdef _WIN32	231	#ifdef _WIN32
402	path_slashize(s);	232	path_slashize(s);
403	#endif	233	#endif
404	if (s.empty() \|\| s[s.length() - 1] != '/')	234	if (s.empty() \|\| s[s.length() - 1] != '/') {
405	s += '/';	235	s += '/';
		236	}
406	}	237	}
407		238
408	string path_cat(const string &s1, const string &s2)	239	string path_cat(const string& s1, const string& s2)
409	{	240	{
410	string res = s1;	241	string res = s1;
411	path_catslash(res);	242	path_catslash(res);
412	res += s2;	243	res += s2;
413	return res;	244	return res;
414	}	245	}
415		246
416	string path_getfather(const string &s)	247	string path_getfather(const string& s)
417	{	248	{
418	string father = s;	249	string father = s;
419	#ifdef _WIN32	250	#ifdef _WIN32
420	path_slashize(father);	251	path_slashize(father);
421	#endif	252	#endif
422		253
423	// ??	254	// ??
424	if (father.empty())	255	if (father.empty()) {
425	return "./";	256	return "./";
		257	}
426		258
427	if (path_isroot(father))	259	if (path_isroot(father)) {
428	return father;	260	return father;
429		261	}
		262
430	if (father[father.length() - 1] == '/') {	263	if (father[father.length() - 1] == '/') {
431	// Input ends with /. Strip it, root special case was tested above	264	// Input ends with /. Strip it, root special case was tested above
432	father.erase(father.length()-1);	265	father.erase(father.length() - 1);
433	}	266	}
434		267
435	string::size_type slp = father.rfind('/');	268	string::size_type slp = father.rfind('/');
436	if (slp == string::npos)	269	if (slp == string::npos) {
437	return "./";	270	return "./";
		271	}
438		272
439	father.erase(slp);	273	father.erase(slp);
440	path_catslash(father);	274	path_catslash(father);
441	return father;	275	return father;
442	}	276	}
443		277
444	string path_getsimple(const string &s)	278	string path_getsimple(const string& s)
445	{	279	{
446	string simple = s;	280	string simple = s;
447	#ifdef _WIN32	281	#ifdef _WIN32
448	path_slashize(simple);	282	path_slashize(simple);
449	#endif	283	#endif
450		284
451	if (simple.empty())	285	if (simple.empty()) {
452	return simple;	286	return simple;
		287	}
453		288
454	string::size_type slp = simple.rfind('/');	289	string::size_type slp = simple.rfind('/');
455	if (slp == string::npos)	290	if (slp == string::npos) {
456	return simple;	291	return simple;
		292	}
457		293
458	simple.erase(0, slp+1);	294	simple.erase(0, slp + 1);
459	return simple;	295	return simple;
460	}	296	}
461		297
462	string path_basename(const string &s, const string &suff)	298	string path_basename(const string& s, const string& suff)
463	{	299	{
464	string simple = path_getsimple(s);	300	string simple = path_getsimple(s);
465	string::size_type pos = string::npos;	301	string::size_type pos = string::npos;
466	if (suff.length() && simple.length() > suff.length()) {	302	if (suff.length() && simple.length() > suff.length()) {
467	pos = simple.rfind(suff);	303	pos = simple.rfind(suff);
468	if (pos != string::npos && pos + suff.length() == simple.length())	304	if (pos != string::npos && pos + suff.length() == simple.length()) {
469	return simple.substr(0, pos);	305	return simple.substr(0, pos);
		306	}
470	}	307	}
471	return simple;	308	return simple;
472	}	309	}
473		310
474	string path_suffix(const string& s)	311	string path_suffix(const string& s)
475	{	312	{
476	string::size_type dotp = s.rfind('.');	313	string::size_type dotp = s.rfind('.');
477	if (dotp == string::npos)	314	if (dotp == string::npos) {
478	return string();	315	return string();
		316	}
479	return s.substr(dotp+1);	317	return s.substr(dotp + 1);
480	}	318	}
481		319
482	string path_home()	320	string path_home()
483	{	321	{
484	#ifdef _WIN32	322	#ifdef _WIN32
	...		...
505	#else	343	#else
506	uid_t uid = getuid();	344	uid_t uid = getuid();
507		345
508	struct passwd *entry = getpwuid(uid);	346	struct passwd *entry = getpwuid(uid);
509	if (entry == 0) {	347	if (entry == 0) {
510	const char *cp = getenv("HOME");	348	const char *cp = getenv("HOME");
511	if (cp)	349	if (cp) {
512	return cp;	350	return cp;
513	else	351	} else {
514	return "/";	352	return "/";
		353	}
515	}	354	}
516		355
517	string homedir = entry->pw_dir;	356	string homedir = entry->pw_dir;
518	path_catslash(homedir);	357	path_catslash(homedir);
519	return homedir;	358	return homedir;
	...		...
537	// We should use an xdg-conforming location, but, history...	376	// We should use an xdg-conforming location, but, history...
538	return path_home();	377	return path_home();