X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=coreutils%2Fdu.c;h=a1ca5b59b6cd73c2bedc9667ca471451ff6b05fa;hb=bbe514683a43e81cab1d5ccc0436b9aaf984294b;hp=119895e491b2d5647636e419d8b80d2ad5e64a41;hpb=e5dfced23a904d08afa5dcee190c3c3d845d9f50;p=oweals%2Fbusybox.git diff --git a/coreutils/du.c b/coreutils/du.c index 119895e49..a1ca5b59b 100644 --- a/coreutils/du.c +++ b/coreutils/du.c @@ -2,201 +2,245 @@ /* * Mini du implementation for busybox * + * Copyright (C) 1999,2000,2001 by Lineo, inc. and John Beppu + * Copyright (C) 1999,2000,2001 by John Beppu + * Copyright (C) 2002 Edward Betts * - * Copyright (C) 1999,2000,2001 by Lineo, inc. - * Written by John Beppu - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * Licensed under GPLv2 or later, see file LICENSE in this tarball for details. + */ + +/* BB_AUDIT SUSv3 compliant (unless default blocksize set to 1k) */ +/* http://www.opengroup.org/onlinepubs/007904975/utilities/du.html */ + +/* Mar 16, 2003 Manuel Novoa III (mjn3@codepoet.org) * + * Mostly rewritten for SUSv3 compliance and to fix bugs/defects. + * 1) Added support for SUSv3 -a, -H, -L, gnu -c, and (busybox) -d options. + * The -d option allows setting of max depth (similar to gnu --max-depth). + * 2) Fixed incorrect size calculations for links and directories, especially + * when errors occurred. Calculates sizes should now match gnu du output. + * 3) Added error checking of output. + * 4) Fixed busybox bug #1284 involving long overflow with human_readable. */ -#include -#include -#include -#include -#include -#include -#include -#include #include "busybox.h" -#define BB_DECLARE_EXTERN -#define bb_need_name_too_long -#include "messages.c" - -#ifdef BB_FEATURE_HUMAN_READABLE -static unsigned long disp_hr = KILOBYTE; +#if ENABLE_FEATURE_HUMAN_READABLE +# if ENABLE_FEATURE_DU_DEFAULT_BLOCKSIZE_1K +static unsigned long disp_hr = 1024; +# else +static unsigned long disp_hr = 512; +# endif +#elif ENABLE_FEATURE_DU_DEFAULT_BLOCKSIZE_1K +static unsigned disp_k = 1; +#else +static unsigned disp_k; /* bss inits to 0 */ #endif -typedef void (Display) (long, char *); +static int max_print_depth = INT_MAX; +static nlink_t count_hardlinks = 1; -static int du_depth = 0; -static int count_hardlinks = 0; +static int status; +static int print_files; +static int slink_depth; +static int du_depth; +static int one_file_system; +static dev_t dir_dev; -static Display *print; -static void print_normal(long size, char *filename) +static void print(long size, const char * const filename) { - unsigned long base; -#ifdef BB_FEATURE_HUMAN_READABLE - switch (disp_hr) { - case MEGABYTE: - base = KILOBYTE; - break; - case KILOBYTE: - base = 1; - break; - default: - base = 0; - } - printf("%s\t%s\n", make_human_readable_str(size, base), filename); + /* TODO - May not want to defer error checking here. */ +#if ENABLE_FEATURE_HUMAN_READABLE + printf("%s\t%s\n", make_human_readable_str(size, 512, disp_hr), + filename); #else + if (disp_k) { + size++; + size >>= 1; + } printf("%ld\t%s\n", size, filename); #endif } -static void print_summary(long size, char *filename) -{ - if (du_depth == 1) { - printf("summary\n"); - print_normal(size, filename); - } -} - /* tiny recursive du */ -static long du(char *filename) +static long du(const char * const filename) { struct stat statbuf; long sum; - int len; - if ((lstat(filename, &statbuf)) != 0) { - perror_msg("%s", filename); + if (lstat(filename, &statbuf) != 0) { + bb_perror_msg("%s", filename); + status = EXIT_FAILURE; return 0; } - du_depth++; - sum = (statbuf.st_blocks >> 1); + if (one_file_system) { + if (du_depth == 0) { + dir_dev = statbuf.st_dev; + } else if (dir_dev != statbuf.st_dev) { + return 0; + } + } + + sum = statbuf.st_blocks; - /* Don't add in stuff pointed to by symbolic links */ if (S_ISLNK(statbuf.st_mode)) { - sum = 0L; - if (du_depth == 1) - print(sum, filename); + if (slink_depth > du_depth) { /* -H or -L */ + if (stat(filename, &statbuf) != 0) { + bb_perror_msg("%s", filename); + status = EXIT_FAILURE; + return 0; + } + sum = statbuf.st_blocks; + if (slink_depth == 1) { + slink_depth = INT_MAX; /* Convert -H to -L. */ + } + } } + + if (statbuf.st_nlink > count_hardlinks) { + /* Add files/directories with links only once */ + if (is_in_ino_dev_hashtable(&statbuf, NULL)) { + return 0; + } + add_to_ino_dev_hashtable(&statbuf, NULL); + } + if (S_ISDIR(statbuf.st_mode)) { DIR *dir; struct dirent *entry; + char *newfile; - dir = opendir(filename); + dir = warn_opendir(filename); if (!dir) { - du_depth--; - return 0; + status = EXIT_FAILURE; + return sum; } - len = strlen(filename); - if (filename[len - 1] == '/') - filename[--len] = '\0'; + newfile = last_char_is(filename, '/'); + if (newfile) + *newfile = '\0'; while ((entry = readdir(dir))) { - char *newfile; char *name = entry->d_name; - if ((strcmp(name, "..") == 0) - || (strcmp(name, ".") == 0)) { + newfile = concat_subpath_file(filename, name); + if (newfile == NULL) continue; - } - newfile = concat_path_file(filename, name); + ++du_depth; sum += du(newfile); + --du_depth; free(newfile); } closedir(dir); - print(sum, filename); + } else if (du_depth > print_files) { + return sum; } - else if (statbuf.st_nlink > 1 && !count_hardlinks) { - /* Add files with hard links only once */ - if (is_in_ino_dev_hashtable(&statbuf, NULL)) { - sum = 0L; - if (du_depth == 1) - print(sum, filename); - } - else { - add_to_ino_dev_hashtable(&statbuf, NULL); - } + if (du_depth <= max_print_depth) { + print(sum, filename); } - du_depth--; return sum; } int du_main(int argc, char **argv) { - int status = EXIT_SUCCESS; - int i; - int c; - - /* default behaviour */ - print = print_normal; + long total; + int slink_depth_save; + int print_final_total; + char *smax_print_depth; + unsigned opt; + +#if ENABLE_FEATURE_DU_DEFAULT_BLOCKSIZE_1K + if (getenv("POSIXLY_CORRECT")) { /* TODO - a new libbb function? */ +#if ENABLE_FEATURE_HUMAN_READABLE + disp_hr = 512; +#else + disp_k = 0; +#endif + } +#endif - /* parse argv[] */ - while ((c = getopt(argc, argv, "sl" -#ifdef BB_FEATURE_HUMAN_READABLE -"hm" + /* Note: SUSv3 specifies that -a and -s options cannot be used together + * in strictly conforming applications. However, it also says that some + * du implementations may produce output when -a and -s are used together. + * gnu du exits with an error code in this case. We choose to simply + * ignore -a. This is consistent with -s being equivalent to -d 0. + */ +#if ENABLE_FEATURE_HUMAN_READABLE + opt_complementary = "h-km:k-hm:m-hk:H-L:L-H:s-d:d-s"; + opt = getopt32(argc, argv, "aHkLsx" "d:" "lc" "hm", &smax_print_depth); + if (opt & (1 << 9)) { + /* -h opt */ + disp_hr = 0; + } + if (opt & (1 << 10)) { + /* -m opt */ + disp_hr = 1024*1024; + } + if (opt & (1 << 2)) { + /* -k opt */ + disp_hr = 1024; + } +#else + opt_complementary = "H-L:L-H:s-d:d-s"; + opt = getopt32(argc, argv, "aHkLsx" "d:" "lc", &smax_print_depth); +#if !ENABLE_FEATURE_DU_DEFAULT_BLOCKSIZE_1K + if (opt & (1 << 2)) { + /* -k opt */ + disp_k = 1; + } #endif -"k")) != EOF) { - switch (c) { - case 's': - print = print_summary; - break; - case 'l': - count_hardlinks = 1; - break; -#ifdef BB_FEATURE_HUMAN_READABLE - case 'h': disp_hr = 0; break; - case 'm': disp_hr = MEGABYTE; break; #endif - case 'k': break; - default: - show_usage(); - } + if (opt & (1 << 0)) { + /* -a opt */ + print_files = INT_MAX; } + if (opt & (1 << 1)) { + /* -H opt */ + slink_depth = 1; + } + if (opt & (1 << 3)) { + /* -L opt */ + slink_depth = INT_MAX; + } + if (opt & (1 << 4)) { + /* -s opt */ + max_print_depth = 0; + } + one_file_system = opt & (1 << 5); /* -x opt */ + if (opt & (1 << 6)) { + /* -d opt */ + max_print_depth = xatoi_u(smax_print_depth); + } + if (opt & (1 << 7)) { + /* -l opt */ + count_hardlinks = MAXINT(nlink_t); + } + print_final_total = opt & (1 << 8); /* -c opt */ /* go through remaining args (if any) */ + argv += optind; if (optind >= argc) { - if (du(".") == 0) - status = EXIT_FAILURE; - } else { - long sum; - - for (i=optind; i < argc; i++) { - if ((sum = du(argv[i])) == 0) - status = EXIT_FAILURE; - if(is_directory(argv[i], FALSE, NULL)==FALSE) { - print_normal(sum, argv[i]); - } - reset_ino_dev_hashtable(); + *--argv = "."; + if (slink_depth == 1) { + slink_depth = 0; } } - return status; -} + slink_depth_save = slink_depth; + total = 0; + do { + total += du(*argv); + slink_depth = slink_depth_save; + } while (*++argv); +#if ENABLE_FEATURE_CLEAN_UP + reset_ino_dev_hashtable(); +#endif -/* $Id: du.c,v 1.44 2001/04/09 22:48:11 andersen Exp $ */ -/* -Local Variables: -c-file-style: "linux" -c-basic-offset: 4 -tab-width: 4 -End: -*/ + if (print_final_total) { + print(total, "total"); + } + + fflush_stdout_and_exit(status); +}