Programming

Hi,

I am writing a unix system utility that is supposed to scan through a directory, collecting
information about the files and subdirectories. That part is going well.

The tricky part is that some files in the directory are hard links or symbolic links. I am supposed to IGNORE these links. As in, if I reach one, I'm not supposed to gather any information about it.

I understand that hard links have the same inode as the original file.

But I dont understand how I can check if the current file is a hard link or the original file.

Can anyone give me a push in the right direction?

If you're curious, I've included my source code as to give an idea of what my utility does.

/*--------------------------------------------------------------------------
File: dsz.c

Usage: dsz <dirname>

--------------------------------------------------------------------------*/
/********************* Include definitions ***********/
#include <stdio.h>
#include <sys/types.h>
#include <dirent.h>
#include <sys/stat.h>
#include <unistd.h>

/********************* Global definitions declarations ***********/
#define MAXDIRNAMESZ 150

/* global variables */
int fileNum; /*Keeps track of total Number of Files in the directory*/
int dirNum=0; /*Keeps track of Number of directories in the directory including top*/
int sizeFiles; /*Keeps track of total size of all files found in the directory*/
int fileBlocks;/*Keeps track of total number of bytes of blocks allocated to the files*/
int dirSize;

/************Prototypes*****************/
void scanDirectory(char *);
void printResults();


/*--------------------------------------------------------------------------
Function: main

Description: The main function processes command line arguments and invokes
scanDirectory to scan directory
Output: Main always returns 0

--------------------------------------------------------------------------*/
int main(int argc, char **argv)
{
int argix = 1; /* point to first argument */

if(argc != 2)
{
printf("Usage: fndp <dir1>\n");
return(1);
}

scanDirectory(argv[1]);
printResults();
return(0);
}

/*--------------------------------------------------------------------------
Function: scanDirectory(char *dirname, int prms)

Description: This function traverses the directory searching for links and
large files.

Output: void
--------------------------------------------------------------------------*/
void scanDirectory(char *dirname)
{
DIR *dirpt; /* list of directory contents */
struct dirent *direlm; /* directory element */
struct stat statbuf; /* for stating subdirs and files */
char filedirpath[MAXDIRNAMESZ];


/* open directory file */
dirpt = opendir(dirname);
if(dirpt == NULL)
{
perror(dirname);
return;
}

while( (direlm = readdir( dirpt)) != NULL)
{
if(strcmp(direlm->d_name,".")==0) continue; /* ignore current directory */
if(strcmp(direlm->d_name,"..")==0) continue; /* ignore parent directory */

sprintf(filedirpath,"%s/%s",dirname,direlm->d_name);
if(stat(filedirpath,&statbuf) == -1)
{
perror(filedirpath);
continue; /* go to next */
}
else
{
if (S_ISREG(statbuf.st_mode)) /* regular file */
{
//do processing
//printf("Path:%s\n",filedirpath);
//printf("size:%d\n",statbuf.st_size);
//printf("num of blocks:%d\n",statbuf.st_blocks);
//printf("blocksize:%d\n",statbuf.st_blksize);
sizeFiles = sizeFiles + statbuf.st_size;
fileNum++;
fileBlocks = fileBlocks + (512*statbuf.st_blocks);

}
else if (S_ISDIR(statbuf.st_mode)) /* directory */
{
//do processing
scanDirectory(filedirpath);
dirNum++;
dirSize = dirSize + statbuf.st_blksize;

}
}
}

closedir(dirpt);

}


/*--------------------------------------------------------------------------
Function: printResults()

Description: Prints the results

Output: void
--------------------------------------------------------------------------*/
void printResults() {
printf("Num of Files:%d\n",fileNum);
printf("Size of All Files:%d\n",sizeFiles);
printf("file block size:%d\n",fileBlocks);
printf("Num of Directories:%d\n",dirNum);
printf("directory block size:%d\n",dirSize);
}

If a file has two hard links, both hard links are co-equal and you cannot distinguish which came first. But if the number of links is greater than one, save the inode number in an array. And check that array each time you encounter a file with multiple links. This will let you process each file once and only once.

1) The inode number is from the struct dirent and it is of type ino_t. What exactly is ino_t? If my inode number is 25 for example, can I compare an integer to something of type ino_t?

2) Also, is it efficient to do it this way? Because each time I process a file, I have to compare its inode with each value in the array.

Thanks for your reply by the way.

ino_t is ino_t. You're not supposed to care if it's an int or a long or whatever. Just build an array of ino_t. And compare elements of that array to your inode. I would use statbuf.st_ino by the way. If you really can't stand not knowing, take a peek at your include file. It can vary from system to system and I don't know what you're using.

And remember, if statbuf.st_nlink == 1, you can bypass all of the array checking. In most directories most files have only one link. Scanning an in-core array is fast. And fast or not, it's the only way you're going to avoid reprocessing a file with multiple links.

thanks a lot. It works.