Print errors to stderr.
[dus.git] / dus.c
1
2 /*
3  *  dus is a simple utility to display the files and directories
4  *  according to their total disk occupancy.
5  *
6  *  Copyright (c) 2010 Francois Fleuret
7  *  Written by Francois Fleuret <francois@fleuret.org>
8  *
9  *  This file is part of dus.
10  *
11  *  dus is free software: you can redistribute it and/or modify it
12  *  under the terms of the GNU General Public License version 3 as
13  *  published by the Free Software Foundation.
14  *
15  *  dus is distributed in the hope that it will be useful, but WITHOUT
16  *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
17  *  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
18  *  License for more details.
19  *
20  *  You should have received a copy of the GNU General Public License
21  *  along with dus.  If not, see <http://www.gnu.org/licenses/>.
22  *
23  */
24
25 #define _BSD_SOURCE
26
27 #include <sys/types.h>
28 #include <sys/stat.h>
29 #include <dirent.h>
30 #include <stdlib.h>
31 #include <stdio.h>
32 #include <unistd.h>
33 #include <errno.h>
34 #include <string.h>
35 #include <sys/ioctl.h>
36 #include <locale.h>
37 #include <getopt.h>
38
39 #define BUFFER_SIZE 4096
40
41 typedef int64_t size_sum_t;
42
43 /* Yeah, global variables! */
44
45 int ignore_dotfiles = 0; /* 1 means ignore files and directories
46                             starting with a dot */
47
48 int forced_width = 0; /* -1 means no width limit, strictly positive
49                          means limit, 0 means not active */
50
51 int forced_height = 0; /* -1 means no height limit, strictly positive
52                            means limit, 0 means not active */
53
54 int fancy_size_display = 0; /* 1 means to use floating values with K, M and G
55                                as units */
56
57 int reverse_sorting = 0; /* 1 means to show the large ones first */
58
59 int show_top = 0; /* 1 means to show the top of the sorted list
60                      instead of the bottom */
61
62 /********************************************************************/
63
64 /* malloc with error checking.  */
65
66 void *safe_malloc(size_t n) {
67   void *p = malloc(n);
68   if (!p && n != 0) {
69     fprintf(stderr, "Can not allocate memory: %s\n", strerror(errno));
70     exit(EXIT_FAILURE);
71   }
72   return p;
73 }
74
75 /********************************************************************/
76
77 int ignore_entry(const char *name) {
78   return
79     strcmp(name, ".") == 0 ||
80     strcmp(name, "..") == 0 ||
81     (ignore_dotfiles && name[0] == '.');
82 }
83
84 void print_size_sum(size_sum_t s) {
85   char tmp[100];
86   char *a = tmp + sizeof(tmp)/sizeof(char);
87   *(--a) = '\0';
88   if(s) {
89     while(s) {
90       *(--a) = s%10 + '0';
91       s /= 10;
92     }
93   } else {
94     *(--a) = '0';
95   }
96   printf(a);
97 }
98
99 size_sum_t file_or_dir_size(const char *name) {
100   DIR *dir;
101   struct dirent *dir_e;
102   struct stat dummy;
103   size_sum_t result;
104   char subname[BUFFER_SIZE];
105
106   result = 0;
107
108   if(lstat(name, &dummy) != 0) {
109     fprintf(stderr, "Can not stat %s: %s\n", name, strerror(errno));
110     exit(EXIT_FAILURE);
111   }
112
113   if(S_ISLNK(dummy.st_mode)) {
114     return 0;
115   }
116
117   dir = opendir(name);
118
119   if(dir) {
120     while((dir_e = readdir(dir))) {
121       if(!ignore_entry(dir_e->d_name)) {
122         snprintf(subname, BUFFER_SIZE, "%s/%s", name, dir_e->d_name);
123         result += file_or_dir_size(subname);
124       }
125     }
126     closedir(dir);
127   } else {
128     if(S_ISREG(dummy.st_mode)) {
129       result += dummy.st_size;
130     }
131   }
132
133   return result;
134 }
135
136 /**********************************************************************/
137
138 struct file_with_size {
139   char *filename;
140   size_sum_t size;
141   struct file_with_size *next;
142 };
143
144 struct file_with_size *create(char *name, struct file_with_size *current) {
145   struct file_with_size *result;
146   result = safe_malloc(sizeof(struct file_with_size));
147   result->filename = strdup(name);
148   result->size = file_or_dir_size(name);
149   result->next = current;
150   return result;
151 }
152
153 void destroy(struct file_with_size *node) {
154   struct file_with_size *next;
155   while(node) {
156     next = node->next;
157     free(node->filename);
158     free(node);
159     node = next;
160   }
161 }
162
163 /**********************************************************************/
164
165 int compare_files(const void *x1, const void *x2) {
166   const struct file_with_size **f1, **f2;
167
168   f1 = (const struct file_with_size **) x1;
169   f2 = (const struct file_with_size **) x2;
170
171   if(reverse_sorting) {
172     if((*f1)->size < (*f2)->size) {
173       return 1;
174     } else if((*f1)->size > (*f2)->size) {
175       return -1;
176     } else {
177       return 0;
178     }
179   } else {
180     if((*f1)->size < (*f2)->size) {
181       return -1;
182     } else if((*f1)->size > (*f2)->size) {
183       return 1;
184     } else {
185       return 0;
186     }
187   }
188 }
189
190 void raw_print(char *buffer, char *filename,  size_sum_t size) {
191   char *a, *b, *c, u;
192
193   b = buffer;
194   if(size) {
195     while(size) {
196       *(b++) = size%10 + '0';
197       size /= 10;
198     }
199   } else {
200     *(b++) = '0';
201   }
202
203   a = buffer;
204   c = b;
205   while(a < c) {
206     u = *a;
207     *(a++) = *(--c);
208     *c = u;
209   }
210
211   *(b++) = ' ';
212
213   sprintf(b, " %s\n", filename);
214 }
215
216 void fancy_print(char *buffer, char *filename, size_sum_t size) {
217   if(size < 1024) {
218     sprintf(buffer,
219             "% 7d %s\n",
220             ((int) size),
221             filename);
222   } else if(size < 1024 * 1024) {
223     sprintf(buffer,
224             "% 6.1fK %s\n",
225             ((double) (size))/(1024.0),
226             filename);
227   } else if(size < 1024 * 1024 * 1024) {
228     sprintf(buffer,
229             "% 6.1fM %s\n",
230             ((double) (size))/(1024.0 * 1024),
231             filename);
232   } else {
233     sprintf(buffer,
234             "% 6.1fG %s\n",
235             ((double) (size))/(1024.0 * 1024.0 * 1024.0),
236             filename);
237   }
238 }
239
240 void print_sorted(struct file_with_size *root, int width, int height) {
241   char line[BUFFER_SIZE];
242   struct file_with_size *node;
243   struct file_with_size **nodes;
244   int nb, n, first, last;
245
246   nb = 0;
247   for(node = root; node; node = node->next) {
248     nb++;
249   }
250
251   nodes = safe_malloc(nb * sizeof(struct file_with_size *));
252
253   n = 0;
254   for(node = root; node; node = node->next) {
255     nodes[n++] = node;
256   }
257
258   qsort(nodes, nb, sizeof(struct file_with_size *), compare_files);
259
260   first = 0;
261   last = nb;
262
263   if(forced_height) {
264     height = forced_height;
265   }
266
267   if(height > 0 && height < nb) {
268     first = nb - height;
269   }
270
271   if(show_top) {
272     n = last;
273     last = nb - first;
274     first = nb - n;
275   }
276
277   for(n = first; n < last; n++) {
278     if(fancy_size_display) {
279       fancy_print(line, nodes[n]->filename, nodes[n]->size);
280     } else {
281       raw_print(line, nodes[n]->filename, nodes[n]->size);
282     }
283     if(width >= 0 && width < BUFFER_SIZE) {
284       line[width] = '\0';
285     }
286     printf(line);
287   }
288
289   free(nodes);
290 }
291
292 /**********************************************************************/
293
294 int main(int argc, char **argv) {
295   int c;
296   struct file_with_size *root;
297
298   root = 0;
299
300   setlocale (LC_ALL, "");
301
302   while (1) {
303     c = getopt(argc, argv, "dfrtl:c:hdu");
304     if (c == -1)
305       break;
306
307     switch (c) {
308
309     case 'd':
310       ignore_dotfiles = 1;
311       break;
312
313     case 'f':
314       fancy_size_display = 1;
315       break;
316
317     case 'r':
318       reverse_sorting = 1;
319       break;
320
321     case 't':
322       show_top = 1;
323       break;
324
325     case 'l':
326       forced_height = atoi(optarg);
327       break;
328
329     case 'c':
330       forced_width = atoi(optarg);
331       break;
332
333     case 'h':
334       printf("Usage: dus [OPTION]... [FILE]...\n");
335       printf("List files and directories sorted according to their size or content size. Take the content of the current directory as argument if none is provided.\n");
336       printf("\n");
337       printf("   -d          ignore files and directories starting with a '.'\n");
338       printf("   -f          display size with float values and K, M and G units.\n");
339       printf("   -r          reverse the sorting order.\n");
340       printf("   -t          show the top of the list.\n");
341       printf("   -c <cols>   specificy the number of columns to display. The value -1\n");
342       printf("               corresponds to no constraint. By default the command\n");
343       printf("               uses the tty width, or no constraint if the stdout is\n");
344       printf("               not a tty.\n");
345       printf("   -l <lines>  same as -c for number of lines.\n");
346       printf("   -h          show this help.\n");
347       printf("\n");
348       printf("Report bugs and comments to <francois@fleuret.org>\n");
349       exit(EXIT_SUCCESS);
350
351       break;
352
353     default:
354       exit(EXIT_FAILURE);
355     }
356   }
357
358   if (optind < argc) {
359     while (optind < argc) {
360       root = create(argv[optind++], root);
361     }
362   } else {
363     DIR *dir;
364     struct dirent *dir_e;
365     dir = opendir(".");
366     if(dir) {
367       while((dir_e = readdir(dir))) {
368         if(!ignore_entry(dir_e->d_name)) {
369           root = create(dir_e->d_name, root);
370         }
371       }
372       closedir(dir);
373     } else {
374       fprintf(stderr, "Can not open ./: %s\n", strerror(errno));
375       exit (EXIT_FAILURE);
376     }
377   }
378
379   if(isatty(STDOUT_FILENO)) {
380     struct winsize win;
381     if(ioctl (STDOUT_FILENO, TIOCGWINSZ, (char *) &win)) {
382       fprintf(stderr, "Can not get the tty size: %s\n", strerror(errno));
383       exit (EXIT_FAILURE);
384     }
385     print_sorted(root, win.ws_col, win.ws_row - 2);
386   } else {
387     print_sorted(root, -1, -1);
388   }
389
390   destroy(root);
391
392   exit(EXIT_SUCCESS);
393 }