suckless
/
sbase
mirror of git://git.suckless.org/sbase
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
sbase/du.c

122 lines
2.0 KiB
C
Raw Normal View History

Add primitive du(1) Defaults to a 512-byte blocksize.
2013-10-16 15:58:52 +00:00
/* See LICENSE file for copyright and license details. */
Clean up #includes
2015-02-14 20:02:41 +00:00
#include <sys/stat.h>
#include <sys/types.h>
Audit du(1) and refactor recurse() While auditing du(1) I realized that there's no way the over 100 lines of procedures in du() would pass the audit. Instead, I decided to rewrite this section using recurse() from libutil. However, the issue was that you'd need some kind of payload to count the number of bytes in the subdirectories and use them in the higher hierarchies. The solution is to add a "void *data" data pointer to each recurse- function-prototype, which we might also be able to use in other recurse-applications. recurse() itself had to be augmented with a recurse_samedev-flag, which basically prevents recurse from leaving the current device. Now, let's take a closer look at the audit: 1) Removing the now unnecessary util-functions push, pop, xrealpath, rename print() to printpath(), localize some global variables. 2) Only pass the block count to nblks instead of the entire stat- pointer. 3) Fix estrtonum to use the minimum of LLONG_MAX and SIZE_MAX. 4) Use idiomatic argv+argc-loop 5) Report proper exit-status.
2015-03-11 22:21:52 +00:00
#include <errno.h>
#include <limits.h>
Adjust some limits to more flexibility for strtonum
2015-02-01 00:24:03 +00:00
#include <stdint.h>
Add primitive du(1) Defaults to a 512-byte blocksize.
2013-10-16 15:58:52 +00:00
#include <stdlib.h>
Audit du(1) and refactor recurse() While auditing du(1) I realized that there's no way the over 100 lines of procedures in du() would pass the audit. Instead, I decided to rewrite this section using recurse() from libutil. However, the issue was that you'd need some kind of payload to count the number of bytes in the subdirectories and use them in the higher hierarchies. The solution is to add a "void *data" data pointer to each recurse- function-prototype, which we might also be able to use in other recurse-applications. recurse() itself had to be augmented with a recurse_samedev-flag, which basically prevents recurse from leaving the current device. Now, let's take a closer look at the audit: 1) Removing the now unnecessary util-functions push, pop, xrealpath, rename print() to printpath(), localize some global variables. 2) Only pass the block count to nblks instead of the entire stat- pointer. 3) Fix estrtonum to use the minimum of LLONG_MAX and SIZE_MAX. 4) Use idiomatic argv+argc-loop 5) Report proper exit-status.
2015-03-11 22:21:52 +00:00
#include <stdio.h>
Fix coding style It was about damn time. Consistency is very important in such a big codebase.
2014-11-13 17:29:30 +00:00
Add primitive du(1) Defaults to a 512-byte blocksize.
2013-10-16 15:58:52 +00:00
#include "util.h"
Audit du(1) and refactor recurse() While auditing du(1) I realized that there's no way the over 100 lines of procedures in du() would pass the audit. Instead, I decided to rewrite this section using recurse() from libutil. However, the issue was that you'd need some kind of payload to count the number of bytes in the subdirectories and use them in the higher hierarchies. The solution is to add a "void *data" data pointer to each recurse- function-prototype, which we might also be able to use in other recurse-applications. recurse() itself had to be augmented with a recurse_samedev-flag, which basically prevents recurse from leaving the current device. Now, let's take a closer look at the audit: 1) Removing the now unnecessary util-functions push, pop, xrealpath, rename print() to printpath(), localize some global variables. 2) Only pass the block count to nblks instead of the entire stat- pointer. 3) Fix estrtonum to use the minimum of LLONG_MAX and SIZE_MAX. 4) Use idiomatic argv+argc-loop 5) Report proper exit-status.
2015-03-11 22:21:52 +00:00
static size_t maxdepth = SIZE_MAX;
static size_t blksize = 512;
Add primitive du(1) Defaults to a 512-byte blocksize.
2013-10-16 15:58:52 +00:00
Un-boolify sbase It actually makes the binaries smaller, the code easier to read (gems like "val == true", "val == false" are gone) and actually predictable in the sense of that we actually know what we're working with (one bitwise operator was quite adventurous and should now be fixed). This is also more consistent with the other suckless projects around which don't use boolean types.
2014-11-13 20:24:47 +00:00
static int aflag = 0;
static int sflag = 0;
static int hflag = 0;
Audit du(1) and refactor recurse() While auditing du(1) I realized that there's no way the over 100 lines of procedures in du() would pass the audit. Instead, I decided to rewrite this section using recurse() from libutil. However, the issue was that you'd need some kind of payload to count the number of bytes in the subdirectories and use them in the higher hierarchies. The solution is to add a "void *data" data pointer to each recurse- function-prototype, which we might also be able to use in other recurse-applications. recurse() itself had to be augmented with a recurse_samedev-flag, which basically prevents recurse from leaving the current device. Now, let's take a closer look at the audit: 1) Removing the now unnecessary util-functions push, pop, xrealpath, rename print() to printpath(), localize some global variables. 2) Only pass the block count to nblks instead of the entire stat- pointer. 3) Fix estrtonum to use the minimum of LLONG_MAX and SIZE_MAX. 4) Use idiomatic argv+argc-loop 5) Report proper exit-status.
2015-03-11 22:21:52 +00:00
static int ret = 0;
Use xrealpath() in du(1)
2014-01-23 21:16:05 +00:00
Add primitive du(1) Defaults to a 512-byte blocksize.
2013-10-16 15:58:52 +00:00
static void
Audit du(1) and refactor recurse() While auditing du(1) I realized that there's no way the over 100 lines of procedures in du() would pass the audit. Instead, I decided to rewrite this section using recurse() from libutil. However, the issue was that you'd need some kind of payload to count the number of bytes in the subdirectories and use them in the higher hierarchies. The solution is to add a "void *data" data pointer to each recurse- function-prototype, which we might also be able to use in other recurse-applications. recurse() itself had to be augmented with a recurse_samedev-flag, which basically prevents recurse from leaving the current device. Now, let's take a closer look at the audit: 1) Removing the now unnecessary util-functions push, pop, xrealpath, rename print() to printpath(), localize some global variables. 2) Only pass the block count to nblks instead of the entire stat- pointer. 3) Fix estrtonum to use the minimum of LLONG_MAX and SIZE_MAX. 4) Use idiomatic argv+argc-loop 5) Report proper exit-status.
2015-03-11 22:21:52 +00:00
printpath(size_t n, const char *path)
Add primitive du(1) Defaults to a 512-byte blocksize.
2013-10-16 15:58:52 +00:00
{
Add human readable output to du(1) Thanks Jeffrey Picard!
2014-10-16 09:06:27 +00:00
if (hflag)
separate humansize into a util function also show 1 decimal of human size string like: 4M -> 4.4M
2014-10-18 21:25:00 +00:00
printf("%s\t%s\n", humansize(n * blksize), path);
Add human readable output to du(1) Thanks Jeffrey Picard!
2014-10-16 09:06:27 +00:00
else
Audit du(1) and refactor recurse() While auditing du(1) I realized that there's no way the over 100 lines of procedures in du() would pass the audit. Instead, I decided to rewrite this section using recurse() from libutil. However, the issue was that you'd need some kind of payload to count the number of bytes in the subdirectories and use them in the higher hierarchies. The solution is to add a "void *data" data pointer to each recurse- function-prototype, which we might also be able to use in other recurse-applications. recurse() itself had to be augmented with a recurse_samedev-flag, which basically prevents recurse from leaving the current device. Now, let's take a closer look at the audit: 1) Removing the now unnecessary util-functions push, pop, xrealpath, rename print() to printpath(), localize some global variables. 2) Only pass the block count to nblks instead of the entire stat- pointer. 3) Fix estrtonum to use the minimum of LLONG_MAX and SIZE_MAX. 4) Use idiomatic argv+argc-loop 5) Report proper exit-status.
2015-03-11 22:21:52 +00:00
printf("%zu\t%s\n", n, path);
Add primitive du(1) Defaults to a 512-byte blocksize.
2013-10-16 15:58:52 +00:00
}
Adjust some limits to more flexibility for strtonum
2015-02-01 00:24:03 +00:00
static size_t
Audit du(1) and refactor recurse() While auditing du(1) I realized that there's no way the over 100 lines of procedures in du() would pass the audit. Instead, I decided to rewrite this section using recurse() from libutil. However, the issue was that you'd need some kind of payload to count the number of bytes in the subdirectories and use them in the higher hierarchies. The solution is to add a "void *data" data pointer to each recurse- function-prototype, which we might also be able to use in other recurse-applications. recurse() itself had to be augmented with a recurse_samedev-flag, which basically prevents recurse from leaving the current device. Now, let's take a closer look at the audit: 1) Removing the now unnecessary util-functions push, pop, xrealpath, rename print() to printpath(), localize some global variables. 2) Only pass the block count to nblks instead of the entire stat- pointer. 3) Fix estrtonum to use the minimum of LLONG_MAX and SIZE_MAX. 4) Use idiomatic argv+argc-loop 5) Report proper exit-status.
2015-03-11 22:21:52 +00:00
nblks(blkcnt_t blocks)
Always round up to the next blocksize unit in du(1)
2013-10-18 15:40:31 +00:00
{
Audit du(1) and refactor recurse() While auditing du(1) I realized that there's no way the over 100 lines of procedures in du() would pass the audit. Instead, I decided to rewrite this section using recurse() from libutil. However, the issue was that you'd need some kind of payload to count the number of bytes in the subdirectories and use them in the higher hierarchies. The solution is to add a "void *data" data pointer to each recurse- function-prototype, which we might also be able to use in other recurse-applications. recurse() itself had to be augmented with a recurse_samedev-flag, which basically prevents recurse from leaving the current device. Now, let's take a closer look at the audit: 1) Removing the now unnecessary util-functions push, pop, xrealpath, rename print() to printpath(), localize some global variables. 2) Only pass the block count to nblks instead of the entire stat- pointer. 3) Fix estrtonum to use the minimum of LLONG_MAX and SIZE_MAX. 4) Use idiomatic argv+argc-loop 5) Report proper exit-status.
2015-03-11 22:21:52 +00:00
return (512 * blocks + blksize - 1) / blksize;
Always round up to the next blocksize unit in du(1)
2013-10-18 15:40:31 +00:00
}
Audit du(1) and refactor recurse() While auditing du(1) I realized that there's no way the over 100 lines of procedures in du() would pass the audit. Instead, I decided to rewrite this section using recurse() from libutil. However, the issue was that you'd need some kind of payload to count the number of bytes in the subdirectories and use them in the higher hierarchies. The solution is to add a "void *data" data pointer to each recurse- function-prototype, which we might also be able to use in other recurse-applications. recurse() itself had to be augmented with a recurse_samedev-flag, which basically prevents recurse from leaving the current device. Now, let's take a closer look at the audit: 1) Removing the now unnecessary util-functions push, pop, xrealpath, rename print() to printpath(), localize some global variables. 2) Only pass the block count to nblks instead of the entire stat- pointer. 3) Fix estrtonum to use the minimum of LLONG_MAX and SIZE_MAX. 4) Use idiomatic argv+argc-loop 5) Report proper exit-status.
2015-03-11 22:21:52 +00:00
void
du(const char *path, int depth, void *total)
Add primitive du(1) Defaults to a 512-byte blocksize.
2013-10-16 15:58:52 +00:00
{
Audit du(1) and refactor recurse() While auditing du(1) I realized that there's no way the over 100 lines of procedures in du() would pass the audit. Instead, I decided to rewrite this section using recurse() from libutil. However, the issue was that you'd need some kind of payload to count the number of bytes in the subdirectories and use them in the higher hierarchies. The solution is to add a "void *data" data pointer to each recurse- function-prototype, which we might also be able to use in other recurse-applications. recurse() itself had to be augmented with a recurse_samedev-flag, which basically prevents recurse from leaving the current device. Now, let's take a closer look at the audit: 1) Removing the now unnecessary util-functions push, pop, xrealpath, rename print() to printpath(), localize some global variables. 2) Only pass the block count to nblks instead of the entire stat- pointer. 3) Fix estrtonum to use the minimum of LLONG_MAX and SIZE_MAX. 4) Use idiomatic argv+argc-loop 5) Report proper exit-status.
2015-03-11 22:21:52 +00:00
struct stat st;
size_t subtotal = 0;
if (lstat(path, &st) < 0) {
if (!depth || errno != ENOENT)
weprintf("stat %s:", path);
if (!depth)
ret = 1;
return;
Fix indentation in du(1)
2013-10-17 17:03:01 +00:00
}
Audit du(1) and refactor recurse() While auditing du(1) I realized that there's no way the over 100 lines of procedures in du() would pass the audit. Instead, I decided to rewrite this section using recurse() from libutil. However, the issue was that you'd need some kind of payload to count the number of bytes in the subdirectories and use them in the higher hierarchies. The solution is to add a "void *data" data pointer to each recurse- function-prototype, which we might also be able to use in other recurse-applications. recurse() itself had to be augmented with a recurse_samedev-flag, which basically prevents recurse from leaving the current device. Now, let's take a closer look at the audit: 1) Removing the now unnecessary util-functions push, pop, xrealpath, rename print() to printpath(), localize some global variables. 2) Only pass the block count to nblks instead of the entire stat- pointer. 3) Fix estrtonum to use the minimum of LLONG_MAX and SIZE_MAX. 4) Use idiomatic argv+argc-loop 5) Report proper exit-status.
2015-03-11 22:21:52 +00:00
recurse(path, du, depth, &subtotal);
*((size_t *)total) += subtotal + nblks(st.st_blocks);
Add primitive du(1) Defaults to a 512-byte blocksize.
2013-10-16 15:58:52 +00:00
Audit du(1) and refactor recurse() While auditing du(1) I realized that there's no way the over 100 lines of procedures in du() would pass the audit. Instead, I decided to rewrite this section using recurse() from libutil. However, the issue was that you'd need some kind of payload to count the number of bytes in the subdirectories and use them in the higher hierarchies. The solution is to add a "void *data" data pointer to each recurse- function-prototype, which we might also be able to use in other recurse-applications. recurse() itself had to be augmented with a recurse_samedev-flag, which basically prevents recurse from leaving the current device. Now, let's take a closer look at the audit: 1) Removing the now unnecessary util-functions push, pop, xrealpath, rename print() to printpath(), localize some global variables. 2) Only pass the block count to nblks instead of the entire stat- pointer. 3) Fix estrtonum to use the minimum of LLONG_MAX and SIZE_MAX. 4) Use idiomatic argv+argc-loop 5) Report proper exit-status.
2015-03-11 22:21:52 +00:00
if (!sflag && depth <= maxdepth && (S_ISDIR(st.st_mode) || aflag))
printpath(subtotal + nblks(st.st_blocks), path);
Add primitive du(1) Defaults to a 512-byte blocksize.
2013-10-16 15:58:52 +00:00
}
Adjust some limits to more flexibility for strtonum
2015-02-01 00:24:03 +00:00
static void
usage(void)
{
Add -x support for du(1)
2015-02-18 17:24:21 +00:00
eprintf("usage: %s [-a | -s] [-d depth] [-h] [-k] [-H | -L | -P] [-x] [file ...]\n", argv0);
Adjust some limits to more flexibility for strtonum
2015-02-01 00:24:03 +00:00
}
int
main(int argc, char *argv[])
{
Audit du(1) and refactor recurse() While auditing du(1) I realized that there's no way the over 100 lines of procedures in du() would pass the audit. Instead, I decided to rewrite this section using recurse() from libutil. However, the issue was that you'd need some kind of payload to count the number of bytes in the subdirectories and use them in the higher hierarchies. The solution is to add a "void *data" data pointer to each recurse- function-prototype, which we might also be able to use in other recurse-applications. recurse() itself had to be augmented with a recurse_samedev-flag, which basically prevents recurse from leaving the current device. Now, let's take a closer look at the audit: 1) Removing the now unnecessary util-functions push, pop, xrealpath, rename print() to printpath(), localize some global variables. 2) Only pass the block count to nblks instead of the entire stat- pointer. 3) Fix estrtonum to use the minimum of LLONG_MAX and SIZE_MAX. 4) Use idiomatic argv+argc-loop 5) Report proper exit-status.
2015-03-11 22:21:52 +00:00
int kflag = 0, dflag = 0;
size_t n = 0;
Adjust some limits to more flexibility for strtonum
2015-02-01 00:24:03 +00:00
char *bsize;
ARGBEGIN {
case 'a':
aflag = 1;
break;
case 'd':
dflag = 1;
Audit du(1) and refactor recurse() While auditing du(1) I realized that there's no way the over 100 lines of procedures in du() would pass the audit. Instead, I decided to rewrite this section using recurse() from libutil. However, the issue was that you'd need some kind of payload to count the number of bytes in the subdirectories and use them in the higher hierarchies. The solution is to add a "void *data" data pointer to each recurse- function-prototype, which we might also be able to use in other recurse-applications. recurse() itself had to be augmented with a recurse_samedev-flag, which basically prevents recurse from leaving the current device. Now, let's take a closer look at the audit: 1) Removing the now unnecessary util-functions push, pop, xrealpath, rename print() to printpath(), localize some global variables. 2) Only pass the block count to nblks instead of the entire stat- pointer. 3) Fix estrtonum to use the minimum of LLONG_MAX and SIZE_MAX. 4) Use idiomatic argv+argc-loop 5) Report proper exit-status.
2015-03-11 22:21:52 +00:00
maxdepth = estrtonum(EARGF(usage()), 0, MIN(LLONG_MAX, SIZE_MAX));
Adjust some limits to more flexibility for strtonum
2015-02-01 00:24:03 +00:00
break;
Audit du(1) and refactor recurse() While auditing du(1) I realized that there's no way the over 100 lines of procedures in du() would pass the audit. Instead, I decided to rewrite this section using recurse() from libutil. However, the issue was that you'd need some kind of payload to count the number of bytes in the subdirectories and use them in the higher hierarchies. The solution is to add a "void *data" data pointer to each recurse- function-prototype, which we might also be able to use in other recurse-applications. recurse() itself had to be augmented with a recurse_samedev-flag, which basically prevents recurse from leaving the current device. Now, let's take a closer look at the audit: 1) Removing the now unnecessary util-functions push, pop, xrealpath, rename print() to printpath(), localize some global variables. 2) Only pass the block count to nblks instead of the entire stat- pointer. 3) Fix estrtonum to use the minimum of LLONG_MAX and SIZE_MAX. 4) Use idiomatic argv+argc-loop 5) Report proper exit-status.
2015-03-11 22:21:52 +00:00
case 'h':
hflag = 1;
Adjust some limits to more flexibility for strtonum
2015-02-01 00:24:03 +00:00
break;
case 'k':
kflag = 1;
break;
Audit du(1) and refactor recurse() While auditing du(1) I realized that there's no way the over 100 lines of procedures in du() would pass the audit. Instead, I decided to rewrite this section using recurse() from libutil. However, the issue was that you'd need some kind of payload to count the number of bytes in the subdirectories and use them in the higher hierarchies. The solution is to add a "void *data" data pointer to each recurse- function-prototype, which we might also be able to use in other recurse-applications. recurse() itself had to be augmented with a recurse_samedev-flag, which basically prevents recurse from leaving the current device. Now, let's take a closer look at the audit: 1) Removing the now unnecessary util-functions push, pop, xrealpath, rename print() to printpath(), localize some global variables. 2) Only pass the block count to nblks instead of the entire stat- pointer. 3) Fix estrtonum to use the minimum of LLONG_MAX and SIZE_MAX. 4) Use idiomatic argv+argc-loop 5) Report proper exit-status.
2015-03-11 22:21:52 +00:00
case 's':
sflag = 1;
break;
case 'x':
recurse_samedev = 1;
Adjust some limits to more flexibility for strtonum
2015-02-01 00:24:03 +00:00
break;
du.c: add symlink dereferencing flags -H and -L
2015-02-09 22:18:49 +00:00
case 'H':
case 'L':
du: Update usage and document -P as well
2015-02-17 16:07:10 +00:00
case 'P':
Audit du(1) and refactor recurse() While auditing du(1) I realized that there's no way the over 100 lines of procedures in du() would pass the audit. Instead, I decided to rewrite this section using recurse() from libutil. However, the issue was that you'd need some kind of payload to count the number of bytes in the subdirectories and use them in the higher hierarchies. The solution is to add a "void *data" data pointer to each recurse- function-prototype, which we might also be able to use in other recurse-applications. recurse() itself had to be augmented with a recurse_samedev-flag, which basically prevents recurse from leaving the current device. Now, let's take a closer look at the audit: 1) Removing the now unnecessary util-functions push, pop, xrealpath, rename print() to printpath(), localize some global variables. 2) Only pass the block count to nblks instead of the entire stat- pointer. 3) Fix estrtonum to use the minimum of LLONG_MAX and SIZE_MAX. 4) Use idiomatic argv+argc-loop 5) Report proper exit-status.
2015-03-11 22:21:52 +00:00
recurse_follow = ARGC();
Add -x support for du(1)
2015-02-18 17:24:21 +00:00
break;
Adjust some limits to more flexibility for strtonum
2015-02-01 00:24:03 +00:00
default:
usage();
} ARGEND;
if ((aflag && sflag) || (dflag && sflag))
usage();
bsize = getenv("BLOCKSIZE");
if (bsize)
Audit du(1) and refactor recurse() While auditing du(1) I realized that there's no way the over 100 lines of procedures in du() would pass the audit. Instead, I decided to rewrite this section using recurse() from libutil. However, the issue was that you'd need some kind of payload to count the number of bytes in the subdirectories and use them in the higher hierarchies. The solution is to add a "void *data" data pointer to each recurse- function-prototype, which we might also be able to use in other recurse-applications. recurse() itself had to be augmented with a recurse_samedev-flag, which basically prevents recurse from leaving the current device. Now, let's take a closer look at the audit: 1) Removing the now unnecessary util-functions push, pop, xrealpath, rename print() to printpath(), localize some global variables. 2) Only pass the block count to nblks instead of the entire stat- pointer. 3) Fix estrtonum to use the minimum of LLONG_MAX and SIZE_MAX. 4) Use idiomatic argv+argc-loop 5) Report proper exit-status.
2015-03-11 22:21:52 +00:00
blksize = estrtonum(bsize, 0, MIN(LLONG_MAX, SIZE_MAX));
Adjust some limits to more flexibility for strtonum
2015-02-01 00:24:03 +00:00
if (kflag)
blksize = 1024;
Audit du(1) and refactor recurse() While auditing du(1) I realized that there's no way the over 100 lines of procedures in du() would pass the audit. Instead, I decided to rewrite this section using recurse() from libutil. However, the issue was that you'd need some kind of payload to count the number of bytes in the subdirectories and use them in the higher hierarchies. The solution is to add a "void *data" data pointer to each recurse- function-prototype, which we might also be able to use in other recurse-applications. recurse() itself had to be augmented with a recurse_samedev-flag, which basically prevents recurse from leaving the current device. Now, let's take a closer look at the audit: 1) Removing the now unnecessary util-functions push, pop, xrealpath, rename print() to printpath(), localize some global variables. 2) Only pass the block count to nblks instead of the entire stat- pointer. 3) Fix estrtonum to use the minimum of LLONG_MAX and SIZE_MAX. 4) Use idiomatic argv+argc-loop 5) Report proper exit-status.
2015-03-11 22:21:52 +00:00
if (!argc) {
du(".", 0, &n);
if (sflag && !ret)
printpath(nblks(n), ".");
Adjust some limits to more flexibility for strtonum
2015-02-01 00:24:03 +00:00
} else {
Audit du(1) and refactor recurse() While auditing du(1) I realized that there's no way the over 100 lines of procedures in du() would pass the audit. Instead, I decided to rewrite this section using recurse() from libutil. However, the issue was that you'd need some kind of payload to count the number of bytes in the subdirectories and use them in the higher hierarchies. The solution is to add a "void *data" data pointer to each recurse- function-prototype, which we might also be able to use in other recurse-applications. recurse() itself had to be augmented with a recurse_samedev-flag, which basically prevents recurse from leaving the current device. Now, let's take a closer look at the audit: 1) Removing the now unnecessary util-functions push, pop, xrealpath, rename print() to printpath(), localize some global variables. 2) Only pass the block count to nblks instead of the entire stat- pointer. 3) Fix estrtonum to use the minimum of LLONG_MAX and SIZE_MAX. 4) Use idiomatic argv+argc-loop 5) Report proper exit-status.
2015-03-11 22:21:52 +00:00
for (; *argv; argc--, argv++) {
du(argv[0], 0, &n);
if (sflag && !ret)
printpath(n, argv[0]);
Adjust some limits to more flexibility for strtonum
2015-02-01 00:24:03 +00:00
}
}
Audit du(1) and refactor recurse() While auditing du(1) I realized that there's no way the over 100 lines of procedures in du() would pass the audit. Instead, I decided to rewrite this section using recurse() from libutil. However, the issue was that you'd need some kind of payload to count the number of bytes in the subdirectories and use them in the higher hierarchies. The solution is to add a "void *data" data pointer to each recurse- function-prototype, which we might also be able to use in other recurse-applications. recurse() itself had to be augmented with a recurse_samedev-flag, which basically prevents recurse from leaving the current device. Now, let's take a closer look at the audit: 1) Removing the now unnecessary util-functions push, pop, xrealpath, rename print() to printpath(), localize some global variables. 2) Only pass the block count to nblks instead of the entire stat- pointer. 3) Fix estrtonum to use the minimum of LLONG_MAX and SIZE_MAX. 4) Use idiomatic argv+argc-loop 5) Report proper exit-status.
2015-03-11 22:21:52 +00:00
return ret;
Adjust some limits to more flexibility for strtonum
2015-02-01 00:24:03 +00:00
}