Перебор файлов в каталоге (включая вложенные каталоги)

#include <stdio.h>
#include <dirent.h>
#include <stdlib.h>
 
void cmp(DIR *, DIR *);
 
int main(int argc, char *argv[])
{
        DIR *d1, *d2;
        
        if ( !(d1 = opendir(argv[1])) || ! (d2 = opendir(argv[2])) || argc < 3 )
        {
                fprintf(stderr, "$s: error dir or arg\n", argv[0]);
                exit(1);
        }
 
        cmp(d1, d2);
 
        return 0;
}
 
void cmp(DIR *d1, DIR *d2)
{
        struct dirent *f1;
        struct dirent *f2;
        
        while ( (f1 = readdir(d1)) )
        {
                if ( f1->d_type == DT_DIR )
                {
                        DIR *t1;
                        if ( (t1 = opendir(f1->d_name)) )
                                cmp(t1, d2);
                }
                else
                {
                        while ( (f2 = readdir(d2)) )
                        {
                                if ( f2->d_type == DT_DIR )
                                {
                                        DIR *t2;
                                        if ( (t2 = opendir(f2->d_name)) )
                                                cmp(d1, t2);
                                }
                                else
                                        printf("%s - %s\n", f1->d_name, f2->d_name);
                        }
                }
        }   
}

struct dirent {
ino_t d_ino; /* номер индексного узла */
char d_name[NAME_MAX +1]; /* строка имени файла, завершающаяся */
/* нулевым символом */
}

#include <stdio.h>
#include <stdlib.h>
#include <dirent.h>
#include <limits.h>
#include <string.h>
#include <sys/stat.h>
 
typedef int           /* 1 в случае ошибки, 0 в прот. случае */
(*PFUNC)(const char*,         /* обрабатываемый файл */
     const struct stat*); /* информация о файле */
 
int             /* 1 в случае ошибки, 0 в прот. случае */
walk(const char*,       /* начальная директория */
     PFUNC,         /* функция, которая вызывается для каждого
                   элемента директории */
     int);          /* вызывать функцию для каталогов? */
 
int print_entry(const char* name, const struct stat* st)
{
    printf("%s%s\n", name,
       /* добавляем "/" к именам каталогов при выводе
        * для наглядности
        */
       (S_ISDIR(st->st_mode) ? "/" : ""));
 
    return 0;
}
 
int main(int argc, char* argv[])
{
    if(argc != 2)
    {
    fprintf(stderr, "Usage: %s DIR\n", argv[0]);
    exit(1);
    }
 
    /* печать всего дерева каталогов, начиная
     * с argv[1] (каталоги тоже печатаются)
     */
    exit(walk(argv[1], print_entry, 1));
}
 
/* делаем глобальной переменной, чтобы не допустить разрастания
 * стека при рекурсивных вызовах (рекурсия-то древовидная)
 */
char buf[PATH_MAX];
 
int walk(const char* dirname, PFUNC pfunc, int do_dirs)
{
    DIR* dp;
    struct stat st;
    struct dirent* dirp;
    int retval = 0;
 
    size_t len = strlen(dirname);
 
    if((dp = opendir(dirname)) == NULL)
    {
    perror(dirname);
    return 1;
    }
 
    strncpy(buf, dirname, len);
 
    while((dirp = readdir(dp)) != NULL)
    {
    if(strcmp(dirp->d_name, ".") == 0 ||
       strcmp(dirp->d_name, "..") == 0)
        continue;
 
    buf[len] = '/';
    buf[len+1] = '\0';
 
    strcat(buf, dirp->d_name);
    
    if(lstat(buf, &st) == -1)
    {
        perror(dirp->d_name);
        retval = 1;
        break;
    }
 
    if(S_ISDIR(st.st_mode))
    {
        if(do_dirs)
        {
        if(pfunc(buf, &st) == 1)
        {
            retval = 1;
            break;
        }
        }
                
        if(walk(buf, pfunc, do_dirs) == 1)
        {
        retval = 1;
        break;
        }
        
    }
    else if(pfunc(dirp->d_name, &st) == 1)
    {
        retval = 1;
        break;
    }
 
    buf[len] = '\0';
    }
 
    closedir(dp);
    return retval;
}

        buf[len] = '/';
        buf[len+1] = '\0';
 
        strcat(buf, dirp->d_name);