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