Fix obvious errors in the tarball generation.

[sgt/agedu] / du.c

/*
 * du.c: implementation of du.h.
 */

#define _GNU_SOURCE
#include <features.h>

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>

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

#include "du.h"
#include "alloc.h"

#ifdef __linux__

/*
 * On Linux, we have the O_NOATIME flag. This means we can read
 * the contents of directories without affecting their atimes,
 * which enables us to at least try to include them in the age
 * display rather than exempting them.
 *
 * Unfortunately, opendir() doesn't let us open a directory with
 * O_NOATIME. In later glibcs we can open one manually using
 * open() and then use fdopendir() to translate the fd into a
 * POSIX dir handle; in earlier glibcs fdopendir() is not
 * available, so we have no option but to talk directly to the
 * kernel system call interface which underlies the POSIX
 * opendir/readdir machinery.
 */

#define __KERNEL__
#include <unistd.h>
#include <fcntl.h>
#include <linux/types.h>
#include <linux/dirent.h>
#include <linux/unistd.h>

_syscall3(int, getdents, uint, fd, struct dirent *, dirp, uint, count)

typedef struct {
    int fd;
    struct dirent data[32];
    struct dirent *curr;
    int pos, endpos;
} dirhandle;

int open_dir(const char *path, dirhandle *dh)
{
    dh->fd = open(path, O_RDONLY | O_NOATIME | O_DIRECTORY);
    if (dh->fd < 0) {
	/*
	 * Opening a file with O_NOATIME is not unconditionally
	 * permitted by the Linux kernel. As far as I can tell,
	 * it's permitted only for files on which the user would
	 * have been able to call utime(2): in other words, files
	 * for which the user could have deliberately set the
	 * atime back to its original value after finishing with
	 * it. Hence, O_NOATIME has no security implications; it's
	 * simply a cleaner, faster and more race-condition-free
	 * alternative to stat(), a normal open(), and a utimes()
	 * when finished.
	 *
	 * The upshot of all of which, for these purposes, is that
	 * we must be prepared to try again without O_NOATIME if
	 * we receive EPERM.
	 */
	if (errno == EPERM)
	    dh->fd = open(path, O_RDONLY | O_DIRECTORY);
	if (dh->fd < 0)
	    return -1;
    }

    dh->pos = dh->endpos = 0;

    return 0;
}

const char *read_dir(dirhandle *dh)
{
    const char *ret;

    if (dh->pos >= dh->endpos) {
	dh->curr = dh->data;
	dh->pos = 0;
	dh->endpos = getdents(dh->fd, dh->data, sizeof(dh->data));
	if (dh->endpos <= 0)
	    return NULL;
    }

    ret = dh->curr->d_name;

    dh->pos += dh->curr->d_reclen;
    dh->curr = (struct dirent *)((char *)dh->data + dh->pos);

    return ret;
}

void close_dir(dirhandle *dh)
{
    close(dh->fd);
}

#else /* __linux__ */

/*
 * This branch of the ifdef is a simple exercise of ordinary POSIX
 * opendir/readdir.
 */

#include <dirent.h>
typedef DIR *dirhandle;

int open_dir(const char *path, dirhandle *dh)
{
    *dh = opendir(path);
    if (!*dh)
	return -1;
    return 0;
}

const char *read_dir(dirhandle *dh)
{
    struct dirent *de = readdir(*dh);
    return de ? de->d_name : NULL;
}

void close_dir(dirhandle *dh)
{
    closedir(*dh);
}

#endif

static int str_cmp(const void *av, const void *bv)
{
    return strcmp(*(const char **)av, *(const char **)bv);
}

static void du_recurse(char **path, size_t pathlen, size_t *pathsize,
		       gotdata_fn_t gotdata, void *gotdata_ctx)
{
    const char *name;
    dirhandle d;
    struct stat64 st;
    char **names;
    size_t i, nnames, namesize;

    if (lstat64(*path, &st) < 0) {
	fprintf(stderr, "%s: lstat: %s\n", *path, strerror(errno));
	return;
    }

    if (!gotdata(gotdata_ctx, *path, &st))
	return;

    if (!S_ISDIR(st.st_mode))
	return;

    names = NULL;
    nnames = namesize = 0;

    if (open_dir(*path, &d) < 0) {
	fprintf(stderr, "%s: opendir: %s\n", *path, strerror(errno));
	return;
    }
    while ((name = read_dir(&d)) != NULL) {
	if (name[0] == '.' && (!name[1] || (name[1] == '.' && !name[2]))) {
	    /* do nothing - we skip "." and ".." */
	} else {
	    if (nnames >= namesize) {
		namesize = nnames * 3 / 2 + 64;
		names = sresize(names, namesize, char *);
	    }
	    names[nnames++] = dupstr(name);
	}
    }
    close_dir(&d);

    if (nnames == 0)
	return;

    qsort(names, nnames, sizeof(*names), str_cmp);

    for (i = 0; i < nnames; i++) {
	size_t newpathlen = pathlen + 1 + strlen(names[i]);
	if (*pathsize <= newpathlen) {
	    *pathsize = newpathlen * 3 / 2 + 256;
	    *path = sresize(*path, *pathsize, char);
	}
	/*
	 * Avoid duplicating a slash if we got a trailing one to
	 * begin with (i.e. if we're starting the scan in '/' itself).
	 */
	if (pathlen > 0 && (*path)[pathlen-1] == '/') {
	    strcpy(*path + pathlen, names[i]);
	    newpathlen--;
	} else {
	    sprintf(*path + pathlen, "/%s", names[i]);
	}

	du_recurse(path, newpathlen, pathsize, gotdata, gotdata_ctx);

	sfree(names[i]);
    }
    sfree(names);
}

void du(const char *inpath, gotdata_fn_t gotdata, void *gotdata_ctx)
{
    char *path;
    size_t pathlen, pathsize;

    pathlen = strlen(inpath);
    pathsize = pathlen + 256;
    path = snewn(pathsize, char);
    strcpy(path, inpath);

    du_recurse(&path, pathlen, &pathsize, gotdata, gotdata_ctx);
}