Поиск исполняемых файлов

#include <sys/types.h>
#include <sys/queue.h>
#include <sys/stat.h>
#include <dirent.h>
#include <err.h>
#include <errno.h>
#include <limits.h>
#include <pthread.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
 
#define THREADS_MAX     64
 
 
#define MAXINT(T)       ((T) (((T)1 << ((sizeof(T) * CHAR_BIT) - 1) ^ ((T) -1))))
#define OFF_T_MAX       MAXINT(off_t)
#ifndef LLONG_MAX
#define LLONG_MAX       MAXINT(long long)
#endif
#ifndef LLONG_MIN
#define LLONG_MIN       (-LLONG_MAX - 1LL)
#endif
 
#define INVALID         1
#define TOOSMALL        2
#define TOOLARGE        3
 
#ifdef DEBUG
#define MAX_LOGLINE     512
#define MAX_LOGLEVEL    4
#define logmsg(...)     __logmsg(__VA_ARGS__)
#else
#define logmsg(...)
#endif /* DEBUG */
 
extern char     *__progname;            /* From crt0.o */
pthread_mutex_t  pnmutex;               /* pathname queue synchronization */
off_t            size_max;              /* Mimimal file size */
off_t            size_min;              /* Maximal file size */
int              threads_max;           /* Threads upper limit */
int              threads_run;           /* Number of running threads */
pthread_mutex_t  tmutex;                /* threads queue synchronization */
 
/* Directory and stat() path storage */
struct pathname {
        SIMPLEQ_ENTRY(pathname)  entries;
        char                    *path;
};
SIMPLEQ_HEAD(, pathname) head;
 
/* Threads queue entry */
struct thread {
        SIMPLEQ_ENTRY(thread)   entries;
        pthread_t               tid;
};
 
#ifdef DEBUG
void             __logmsg(int, const char *, ...);
#endif /* DEBUG */
void             pathname_del(struct pathname *);
struct pathname *pathname_new(void);
struct pathname *pathname_pop(void);
void             pathname_push(struct pathname *);
void             pathname_set(struct pathname *, char *, char *);
void            *scan_do(void *);
struct thread   *scan_next(void);
long long        strtonum(const char *, long long, long long, const char **);
void             thread_lock(pthread_mutex_t *);
void             thread_unlock(pthread_mutex_t *);
void             usage(int);
 
#ifdef DEBUG
/* Output log message */
void
__logmsg(int loglevel, const char *format, ...)
{
        va_list         ap;
        char pad[MAX_LOGLEVEL * 2 + 1];
        char buf[MAX_LOGLINE];
 
        if (loglevel > MAX_LOGLEVEL)
                loglevel = MAX_LOGLEVEL;
        if (loglevel > 1) {
                memset(&pad, ' ', (loglevel - 1) * 2);
                pad[(loglevel - 1) * 2] = '\0';
        } else
                pad[0] = '\0';
 
        va_start(ap, format);
        /* We don't care about truncation. */
        snprintf(buf, sizeof(buf), format, ap);
        fprintf(stderr, "%s[%p]%s\n",
            pad, pthread_self(), buf);
        va_end(ap);
}
#endif /* DEBUG */
 
/*
 * Traverse a file hierarchy starting from given path,
 * search for executable files and check what file size
 * between given boundaries (if specified).
 * Each directory entry processing goes in separate thread.
 */
int
main(int argc, char *argv[]) {
        struct pathname *pn;
        int ch;
        const char *errstr;
 
        /* Defaults */
        size_max = -1;
        size_min = -1;
        threads_max = 2;
        threads_run = 0;
        SIMPLEQ_INIT(&head);
        pthread_mutex_init(&pnmutex, NULL);
        pthread_mutex_init(&tmutex, NULL);
 
        while ((ch = getopt(argc, argv, "hM:m:t:")) != -1)
                switch (ch) {
                case 'h':
                        usage(0);
                        /* NOTREACHED */
                case 'M':
                        size_max = strtonum(optarg, 0, OFF_T_MAX, &errstr);
                        if (errstr)
                                errx(1, "bad max file size \"%s\": %s",
                                        optarg, errstr);
                        break;
                case 'm':
                        size_min = strtonum(optarg, 0, OFF_T_MAX, &errstr);
                        if (errstr)
                                errx(1, "bad min file size \"%s\": %s",
                                        optarg, errstr);
                        break;
                case 't':
                        threads_max = strtonum(optarg, 1, THREADS_MAX, &errstr);
                        if (errstr)
                                errx(1, "bad threads limit \"%s\": %s",
                                        optarg, errstr);
                        break;
                default:
                        usage(1);
                        /* NOTREACHED */
                }
        argc -= optind;
        argv += optind;
        if (argc > 1)
                usage(1);
        if (size_max > -1 && size_min > size_max)
                errx(1, "min > max");
 
        logmsg(1, "%s()", __FUNCTION__);
        pn = pathname_new();
        if (argc)
                pathname_set(pn, argv[0], "");
        else
                pathname_set(pn, ".", "");
        pathname_push(pn);
 
        /* We don't use mutex here, because hope this is single thread */
        while (!SIMPLEQ_EMPTY(&head))
                scan_do(NULL);
 
        return (0);
}
 
/* Delete pathname structure */
void
pathname_del(struct pathname *pn)
{
        logmsg(2, "%s(%p)", __FUNCTION__, pn);
 
        if (pn->path) {
                logmsg(3, "freeing \"%s\" at %p", pn->path, pn->path);
                free(pn->path);
                pn->path = NULL;
        }
        free(pn);
}
 
/* Allocate new pathname structure */
struct pathname *
pathname_new(void) {
        struct pathname *pn;
 
        pn = malloc(sizeof(struct pathname));
        if (pn == NULL) {
                err(1, "malloc");
        }
        pn->path = NULL;
        logmsg(2, "%s(): %p", __FUNCTION__, pn);
 
        return (pn);
}
 
/* Fill path in pathname structure */
void
pathname_set(struct pathname *pn, char *dir, char *name)
{
        size_t  dlen, nlen;
        char *path;
 
        logmsg(2, "%s(%p, %s, %s)", __FUNCTION__, pn, dir, name);
        dlen = strlen(dir);
        if (dlen == 0)
                err(1, "empty path");
        nlen = strlen(name);
        path = malloc(dlen + nlen + 2);
        if (path == NULL)
                err(1, "malloc");
        strncpy(path, dir, dlen + 1);
        if (path[dlen - 1] != '/')
                strncat(path, "/", 1);
        if (nlen)
                strncat(path, name, nlen);
        pn->path = path;
        logmsg(3, "\"%s\" at %p %d byte(s)", pn->path, path, dlen + nlen + 2);
}
 
/* Push pathname structure into fifo queue */
void
pathname_push(struct pathname *pn)
{
        logmsg(2, "%s([%p]%s)", __FUNCTION__, &pn, pn->path);
 
        thread_lock(&pnmutex);
        SIMPLEQ_INSERT_TAIL(&head, pn, entries);
        thread_unlock(&pnmutex);
}
 
/* Pop pathname structure from fifo queue */
struct pathname *
pathname_pop(void)
{
        struct pathname *pn;
 
        logmsg(2, "%s()", __FUNCTION__);
        pn = NULL;
        thread_lock(&pnmutex);
        if (!SIMPLEQ_EMPTY(&head)) {
                pn = SIMPLEQ_FIRST(&head);
                SIMPLEQ_REMOVE_HEAD(&head, entries);
        }
        thread_unlock(&pnmutex);
        logmsg(3, "%p, %s", pn, pn ? pn->path : "empty queue");
 
        return (pn);
}
 
/* Scan directory. */
void *
scan_do(void * arg)
{
        SIMPLEQ_HEAD(, thread) thead = SIMPLEQ_HEAD_INITIALIZER(thead);
        struct dirent   *de;
        struct pathname *pn, *ne;
        struct stat      st;
        struct thread   *t;
        DIR             *dp;
        (void)           arg;           /* Unused */
 
        logmsg(1, "%s()", __FUNCTION__);
        ne = NULL;
 
        /* Shuld not happen, but... */
        if ((pn = pathname_pop()) == NULL) {
                thread_lock(&tmutex);
                if (threads_run)
                        threads_run--;
                thread_unlock(&tmutex);
                logmsg(2, "nothing to do");
                return (NULL);
        }
 
        logmsg(2, "scanning %s", pn->path);
 
        if ((dp = opendir(pn->path)) == NULL) {
                if (errno != EACCES)
                        err(1, "opendir");
                pathname_del(pn);
                thread_lock(&tmutex);
                if (threads_run)
                        threads_run--;
                thread_unlock(&tmutex);
                logmsg(1, "%s(): abort.", __FUNCTION__);
                return (NULL);
        }
 
        while ((de = readdir(dp)) != NULL) {
                /* man page says what de->d_type may be
                 * unimplemented for some fs, so don't
                 * we use it.
                 */
                logmsg(3, "%s", de->d_name);
                if (strcmp(de->d_name, ".") == 0 ||
                    strcmp(de->d_name, "..") == 0)
                        continue;
                if (ne == NULL)
                        ne = pathname_new();
 
                pathname_set(ne, pn->path, de->d_name);
 
                if (lstat(ne->path, &st) == -1) {
                        if (errno != EACCES && errno != ENOENT)
                                warn("lstat(\"%s\")", ne->path);
                        free(ne->path);
                        ne->path = NULL;
                        continue;
                }
 
                if (S_ISDIR(st.st_mode)) {
                        logmsg(4, "DIR");
                        pathname_push(ne);
                        if ((t = scan_next()))
                                SIMPLEQ_INSERT_TAIL(&thead, t, entries);
                        ne = NULL;
                        continue;
                }
 
                if (S_ISREG(st.st_mode) &&
                    st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)) {
                        logmsg(4, "EXE");
                        /* Just for break */
                        do {
                                if (size_min > -1 && st.st_size < size_min)
                                        break;
                                if (size_max > -1 && st.st_size > size_max)
                                        break;
                                printf("%s\n", ne->path);
                        } while (0);
                }
 
                free(ne->path);
                ne->path = NULL;
        }
 
        closedir(dp);
        if (ne)
                pathname_del(ne);
        pathname_del(pn);
 
#if 0
        if ((t = scan_next()))
                SIMPLEQ_INSERT_TAIL(&thead, t, entries);
#endif
 
        while ((t = SIMPLEQ_FIRST(&thead)) != NULL) {
                SIMPLEQ_REMOVE_HEAD(&thead, entries);
                logmsg(2, "join(%p)", t->tid);
                pthread_join(t->tid, NULL);
                free(t);
        }
 
        thread_lock(&tmutex);
        if (threads_run)
                threads_run--;
        thread_unlock(&tmutex);
        logmsg(1, "%s(): done.", __FUNCTION__);
 
        return (NULL);
}
 
/* Run next scan thread */
struct thread *
scan_next(void)
{
        struct thread   *t;
 
        logmsg(2, "%s()", __FUNCTION__);
        t = NULL;
 
        thread_lock(&tmutex);
        if (threads_run < threads_max) {
                if ((t = malloc(sizeof(struct thread))) == NULL) {
                        warn("malloc");
                } else {
                        if (pthread_create(&t->tid, NULL, &scan_do, NULL)) {
                                warn("pthread_create");
                                free(t);
                                t = NULL;
                        } else
                                threads_run++;
                }
        }
        thread_unlock(&tmutex);
        logmsg(3, "thread %sstarted %p", t ? "" : "not ", t ? t->tid : NULL);
 
        return (t);
}
 
/* strtonum(3) from OpenBSD */
long long
strtonum(const char *numstr, long long minval, long long maxval,
    const char **errstrp)
{
        long long ll = 0;
        char *ep;
        int error = 0;
        struct errval {
                const char *errstr;
                int err;
        } ev[4] = {
                { NULL,         0 },
                { "invalid",    EINVAL },
                { "too small",  ERANGE },
                { "too large",  ERANGE },
        };
 
        ev[0].err = errno;
        errno = 0;
        if (minval > maxval)
                error = INVALID;
        else {
                ll = strtoll(numstr, &ep, 10);
                if (numstr == ep || *ep != '\0')
                        error = INVALID;
                else if ((ll == LLONG_MIN && errno == ERANGE) || ll < minval)
                        error = TOOSMALL;
                else if ((ll == LLONG_MAX && errno == ERANGE) || ll > maxval)
                        error = TOOLARGE;
        }
        if (errstrp != NULL)
                *errstrp = ev[error].errstr;
        errno = ev[error].err;
        if (error)
                ll = 0;
 
        return (ll);
}
 
/* Lock mutex */
void
thread_lock(pthread_mutex_t *mutex)
{
        logmsg(3, "%s(%p)", __FUNCTION__, &mutex);
        if (pthread_mutex_lock(mutex))
                err(1, "pthread_mutex_lock");
}
 
/* Unlock mutex */
void
thread_unlock(pthread_mutex_t *mutex)
{
        logmsg(3, "%s(%p)", __FUNCTION__, &mutex);
        if (pthread_mutex_unlock(mutex))
                err(1, "pthread_mutex_unlock");
}
 
/* Output usage information */
void
usage(int status)
{
        fprintf(stdout, "usage: %s [-m <min>] [-M <max>]"
            " [-t <threads>] [path]\n", __progname);
        exit(status);
}