Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 1 | /* vi: set sw=4 ts=4: */ |
Eric Andersen | 9d3aba7 | 1999-10-06 09:04:55 +0000 | [diff] [blame] | 2 | /* |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 3 | * tiny-ls.c version 0.1.0: A minimalist 'ls' |
| 4 | * Copyright (C) 1996 Brian Candler <B.Candler@pobox.com> |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 5 | * |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 6 | * This program is free software; you can redistribute it and/or modify |
| 7 | * it under the terms of the GNU General Public License as published by |
| 8 | * the Free Software Foundation; either version 2 of the License, or |
| 9 | * (at your option) any later version. |
| 10 | * |
| 11 | * This program is distributed in the hope that it will be useful, |
| 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 14 | * GNU General Public License for more details. |
| 15 | * |
| 16 | * You should have received a copy of the GNU General Public License |
| 17 | * along with this program; if not, write to the Free Software |
| 18 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
| 19 | */ |
| 20 | |
| 21 | /* |
| 22 | * To achieve a small memory footprint, this version of 'ls' doesn't do any |
| 23 | * file sorting, and only has the most essential command line switches |
Eric Andersen | 77d9268 | 2001-05-23 20:32:09 +0000 | [diff] [blame] | 24 | * (i.e., the ones I couldn't live without :-) All features which involve |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 25 | * linking in substantial chunks of libc can be disabled. |
| 26 | * |
| 27 | * Although I don't really want to add new features to this program to |
| 28 | * keep it small, I *am* interested to receive bug fixes and ways to make |
| 29 | * it more portable. |
| 30 | * |
| 31 | * KNOWN BUGS: |
Erik Andersen | 9ffdaa6 | 2000-02-11 21:55:04 +0000 | [diff] [blame] | 32 | * 1. ls -l of a directory doesn't give "total <blocks>" header |
| 33 | * 2. ls of a symlink to a directory doesn't list directory contents |
| 34 | * 3. hidden files can make column width too large |
| 35 | * |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 36 | * NON-OPTIMAL BEHAVIOUR: |
| 37 | * 1. autowidth reads directories twice |
| 38 | * 2. if you do a short directory listing without filetype characters |
| 39 | * appended, there's no need to stat each one |
| 40 | * PORTABILITY: |
| 41 | * 1. requires lstat (BSD) - how do you do it without? |
| 42 | */ |
| 43 | |
Eric Andersen | e57d54b | 2001-01-30 18:03:11 +0000 | [diff] [blame] | 44 | enum { |
| 45 | TERMINAL_WIDTH = 80, /* use 79 if terminal has linefold bug */ |
| 46 | COLUMN_WIDTH = 14, /* default if AUTOWIDTH not defined */ |
| 47 | COLUMN_GAP = 2, /* includes the file type char */ |
| 48 | }; |
| 49 | |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 50 | |
| 51 | /************************************************************************/ |
| 52 | |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 53 | #include <sys/types.h> |
| 54 | #include <sys/stat.h> |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 55 | #include <stdio.h> |
| 56 | #include <unistd.h> |
| 57 | #include <dirent.h> |
| 58 | #include <errno.h> |
| 59 | #include <stdio.h> |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 60 | #include <string.h> |
Eric Andersen | ed3ef50 | 2001-01-27 08:24:39 +0000 | [diff] [blame] | 61 | #include <stdlib.h> |
Eric Andersen | 5307eca | 2001-01-26 01:52:43 +0000 | [diff] [blame] | 62 | #include <fcntl.h> |
| 63 | #include <signal.h> |
Eric Andersen | 8d79ce8 | 2001-07-22 23:00:15 +0000 | [diff] [blame] | 64 | #include <termios.h> |
Eric Andersen | 5307eca | 2001-01-26 01:52:43 +0000 | [diff] [blame] | 65 | #include <sys/ioctl.h> |
Eric Andersen | cbe31da | 2001-02-20 06:14:08 +0000 | [diff] [blame] | 66 | #include "busybox.h" |
Eric Andersen | 5307eca | 2001-01-26 01:52:43 +0000 | [diff] [blame] | 67 | |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 68 | #ifdef CONFIG_FEATURE_LS_TIMESTAMPS |
Eric Andersen | f1142c5 | 2001-02-20 06:16:29 +0000 | [diff] [blame] | 69 | #include <time.h> |
| 70 | #endif |
| 71 | |
Eric Andersen | 30f64c3 | 2001-01-30 19:23:46 +0000 | [diff] [blame] | 72 | #ifndef MAJOR |
Erik Andersen | 1ad302a | 2000-03-24 00:54:46 +0000 | [diff] [blame] | 73 | #define MAJOR(dev) (((dev)>>8)&0xff) |
| 74 | #define MINOR(dev) ((dev)&0xff) |
| 75 | #endif |
| 76 | |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 77 | /* what is the overall style of the listing */ |
Mark Whitley | 59ab025 | 2001-01-23 22:30:04 +0000 | [diff] [blame] | 78 | enum { |
| 79 | STYLE_AUTO = 0, |
| 80 | STYLE_LONG = 1, /* one record per line, extended info */ |
| 81 | STYLE_SINGLE = 2, /* one record per line */ |
| 82 | STYLE_COLUMNS = 3 /* fill columns */ |
| 83 | }; |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 84 | |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 85 | /* 51306 lrwxrwxrwx 1 root root 2 May 11 01:43 /bin/view -> vi* */ |
| 86 | /* what file information will be listed */ |
| 87 | #define LIST_INO (1<<0) |
| 88 | #define LIST_BLOCKS (1<<1) |
| 89 | #define LIST_MODEBITS (1<<2) |
| 90 | #define LIST_NLINKS (1<<3) |
| 91 | #define LIST_ID_NAME (1<<4) |
| 92 | #define LIST_ID_NUMERIC (1<<5) |
| 93 | #define LIST_SIZE (1<<6) |
| 94 | #define LIST_DEV (1<<7) |
| 95 | #define LIST_DATE_TIME (1<<8) |
| 96 | #define LIST_FULLTIME (1<<9) |
| 97 | #define LIST_FILENAME (1<<10) |
| 98 | #define LIST_SYMLINK (1<<11) |
| 99 | #define LIST_FILETYPE (1<<12) |
| 100 | #define LIST_EXEC (1<<13) |
| 101 | |
| 102 | /* what files will be displayed */ |
| 103 | #define DISP_NORMAL (0) /* show normal filenames */ |
| 104 | #define DISP_DIRNAME (1<<0) /* 2 or more items? label directories */ |
| 105 | #define DISP_HIDDEN (1<<1) /* show filenames starting with . */ |
| 106 | #define DISP_DOT (1<<2) /* show . and .. */ |
| 107 | #define DISP_NOLIST (1<<3) /* show directory as itself, not contents */ |
| 108 | #define DISP_RECURSIVE (1<<4) /* show directory and everything below it */ |
| 109 | #define DISP_ROWS (1<<5) /* print across rows */ |
| 110 | |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 111 | #ifdef CONFIG_FEATURE_LS_SORTFILES |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 112 | /* how will the files be sorted */ |
Mark Whitley | 59ab025 | 2001-01-23 22:30:04 +0000 | [diff] [blame] | 113 | static const int SORT_FORWARD = 0; /* sort in reverse order */ |
| 114 | static const int SORT_REVERSE = 1; /* sort in reverse order */ |
| 115 | static const int SORT_NAME = 2; /* sort by file name */ |
| 116 | static const int SORT_SIZE = 3; /* sort by file size */ |
| 117 | static const int SORT_ATIME = 4; /* sort by last access time */ |
| 118 | static const int SORT_CTIME = 5; /* sort by last change time */ |
| 119 | static const int SORT_MTIME = 6; /* sort by last modification time */ |
| 120 | static const int SORT_VERSION = 7; /* sort by version */ |
| 121 | static const int SORT_EXT = 8; /* sort by file name extension */ |
| 122 | static const int SORT_DIR = 9; /* sort by file or directory */ |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 123 | #endif |
| 124 | |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 125 | #ifdef CONFIG_FEATURE_LS_TIMESTAMPS |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 126 | /* which of the three times will be used */ |
Mark Whitley | 59ab025 | 2001-01-23 22:30:04 +0000 | [diff] [blame] | 127 | static const int TIME_MOD = 0; |
| 128 | static const int TIME_CHANGE = 1; |
| 129 | static const int TIME_ACCESS = 2; |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 130 | #endif |
| 131 | |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 132 | #define LIST_SHORT (LIST_FILENAME) |
| 133 | #define LIST_ISHORT (LIST_INO | LIST_FILENAME) |
| 134 | #define LIST_LONG (LIST_MODEBITS | LIST_NLINKS | LIST_ID_NAME | \ |
| 135 | LIST_SIZE | LIST_DATE_TIME | LIST_FILENAME | \ |
| 136 | LIST_SYMLINK) |
| 137 | #define LIST_ILONG (LIST_INO | LIST_LONG) |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 138 | |
Mark Whitley | 59ab025 | 2001-01-23 22:30:04 +0000 | [diff] [blame] | 139 | static const int SPLIT_DIR = 0; |
| 140 | static const int SPLIT_FILE = 1; |
| 141 | static const int SPLIT_SUBDIR = 2; |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 142 | |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 143 | #define TYPEINDEX(mode) (((mode) >> 12) & 0x0f) |
| 144 | #define TYPECHAR(mode) ("0pcCd?bB-?l?s???" [TYPEINDEX(mode)]) |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 145 | #ifdef CONFIG_FEATURE_LS_FILETYPES |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 146 | #define APPCHAR(mode) ("\0|\0\0/\0\0\0\0\0@\0=\0\0\0" [TYPEINDEX(mode)]) |
| 147 | #endif |
Eric Andersen | 3ad0bd9 | 2002-03-20 09:13:48 +0000 | [diff] [blame] | 148 | /* colored LS support by JaWi, janwillem.janssen@lxtreme.nl */ |
| 149 | #ifdef CONFIG_FEATURE_LS_COLOR |
| 150 | static int show_color = 0; |
| 151 | #define COLOR(mode) ("\000\043\043\043\042\000\043\043"\ |
| 152 | "\000\000\044\000\043\000\000\040" [TYPEINDEX(mode)]) |
| 153 | #define ATTR(mode) ("\00\00\01\00\01\00\01\00"\ |
| 154 | "\00\00\01\00\01\00\00\01" [TYPEINDEX(mode)]) |
| 155 | #endif |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 156 | |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 157 | /* |
| 158 | * a directory entry and its stat info are stored here |
| 159 | */ |
| 160 | struct dnode { /* the basic node */ |
| 161 | char *name; /* the dir entry name */ |
| 162 | char *fullname; /* the dir entry name */ |
| 163 | struct stat dstat; /* the file stat info */ |
| 164 | struct dnode *next; /* point at the next node */ |
| 165 | }; |
| 166 | typedef struct dnode dnode_t; |
| 167 | |
Eric Andersen | 3e6ff90 | 2001-03-09 21:24:12 +0000 | [diff] [blame] | 168 | static struct dnode **list_dir(char *); |
| 169 | static struct dnode **dnalloc(int); |
| 170 | static int list_single(struct dnode *); |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 171 | |
Mark Whitley | 59ab025 | 2001-01-23 22:30:04 +0000 | [diff] [blame] | 172 | static unsigned int disp_opts; |
| 173 | static unsigned int style_fmt; |
| 174 | static unsigned int list_fmt; |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 175 | #ifdef CONFIG_FEATURE_LS_SORTFILES |
Mark Whitley | 59ab025 | 2001-01-23 22:30:04 +0000 | [diff] [blame] | 176 | static unsigned int sort_opts; |
| 177 | static unsigned int sort_order; |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 178 | #endif |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 179 | #ifdef CONFIG_FEATURE_LS_TIMESTAMPS |
Mark Whitley | 59ab025 | 2001-01-23 22:30:04 +0000 | [diff] [blame] | 180 | static unsigned int time_fmt; |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 181 | #endif |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 182 | #ifdef CONFIG_FEATURE_LS_FOLLOWLINKS |
Matt Kraai | a2f2a8f | 2000-09-22 03:11:47 +0000 | [diff] [blame] | 183 | static unsigned int follow_links=FALSE; |
| 184 | #endif |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 185 | |
| 186 | static unsigned short column = 0; |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 187 | #ifdef CONFIG_FEATURE_AUTOWIDTH |
Eric Andersen | e57d54b | 2001-01-30 18:03:11 +0000 | [diff] [blame] | 188 | static unsigned short terminal_width = TERMINAL_WIDTH; |
| 189 | static unsigned short column_width = COLUMN_WIDTH; |
| 190 | static unsigned short tabstops = COLUMN_GAP; |
Eric Andersen | f5d5e77 | 2001-01-24 23:34:48 +0000 | [diff] [blame] | 191 | #else |
Eric Andersen | a528dc7 | 2001-01-26 18:30:12 +0000 | [diff] [blame] | 192 | static unsigned short column_width = COLUMN_WIDTH; |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 193 | #endif |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 194 | |
Matt Kraai | 33fdae5 | 2000-10-13 17:59:43 +0000 | [diff] [blame] | 195 | static int status = EXIT_SUCCESS; |
| 196 | |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 197 | #ifdef CONFIG_FEATURE_HUMAN_READABLE |
Eric Andersen | 3e6ff90 | 2001-03-09 21:24:12 +0000 | [diff] [blame] | 198 | static unsigned long ls_disp_hr = 0; |
Richard June | 6d0921c | 2001-01-22 22:35:38 +0000 | [diff] [blame] | 199 | #endif |
| 200 | |
Matt Kraai | 9a6e67c | 2000-10-13 18:03:21 +0000 | [diff] [blame] | 201 | static int my_stat(struct dnode *cur) |
| 202 | { |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 203 | #ifdef CONFIG_FEATURE_LS_FOLLOWLINKS |
Matt Kraai | 1f0c436 | 2001-12-20 23:13:26 +0000 | [diff] [blame] | 204 | if (follow_links) { |
Matt Kraai | 9a6e67c | 2000-10-13 18:03:21 +0000 | [diff] [blame] | 205 | if (stat(cur->fullname, &cur->dstat)) { |
Matt Kraai | 1fa1ade | 2000-12-18 03:57:16 +0000 | [diff] [blame] | 206 | perror_msg("%s", cur->fullname); |
Matt Kraai | 9a6e67c | 2000-10-13 18:03:21 +0000 | [diff] [blame] | 207 | status = EXIT_FAILURE; |
| 208 | free(cur->fullname); |
| 209 | free(cur); |
| 210 | return -1; |
| 211 | } |
| 212 | } else |
| 213 | #endif |
| 214 | if (lstat(cur->fullname, &cur->dstat)) { |
Matt Kraai | 1fa1ade | 2000-12-18 03:57:16 +0000 | [diff] [blame] | 215 | perror_msg("%s", cur->fullname); |
Matt Kraai | 9a6e67c | 2000-10-13 18:03:21 +0000 | [diff] [blame] | 216 | status = EXIT_FAILURE; |
| 217 | free(cur->fullname); |
| 218 | free(cur); |
| 219 | return -1; |
| 220 | } |
| 221 | return 0; |
| 222 | } |
| 223 | |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 224 | static void newline(void) |
| 225 | { |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 226 | if (column > 0) { |
Matt Kraai | 12f417e | 2001-01-18 02:57:08 +0000 | [diff] [blame] | 227 | putchar('\n'); |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 228 | column = 0; |
Eric Andersen | 79565b6 | 2000-08-11 18:10:21 +0000 | [diff] [blame] | 229 | } |
| 230 | } |
| 231 | |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 232 | /*----------------------------------------------------------------------*/ |
Eric Andersen | 3ad0bd9 | 2002-03-20 09:13:48 +0000 | [diff] [blame] | 233 | #ifdef CONFIG_FEATURE_LS_COLOR |
| 234 | static char fgcolor(mode_t mode) |
| 235 | { |
| 236 | /* Check wheter the file is existing (if so, color it red!) */ |
| 237 | if ( errno == ENOENT ) { |
| 238 | errno = 0; |
| 239 | return '\037'; |
| 240 | } |
| 241 | if ( LIST_EXEC && S_ISREG( mode ) |
| 242 | && ( mode & ( S_IXUSR | S_IXGRP | S_IXOTH ) ) ) |
| 243 | return COLOR(0xF000); /* File is executable ... */ |
| 244 | return COLOR(mode); |
| 245 | } |
| 246 | |
| 247 | /*----------------------------------------------------------------------*/ |
| 248 | static char bgcolor(mode_t mode) |
| 249 | { |
| 250 | if ( LIST_EXEC && S_ISREG( mode ) |
| 251 | && ( mode & ( S_IXUSR | S_IXGRP | S_IXOTH ) ) ) |
| 252 | return ATTR(0xF000); /* File is executable ... */ |
| 253 | return ATTR(mode); |
| 254 | } |
| 255 | #endif |
| 256 | |
| 257 | /*----------------------------------------------------------------------*/ |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 258 | #ifdef CONFIG_FEATURE_LS_FILETYPES |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 259 | static char append_char(mode_t mode) |
Eric Andersen | 79565b6 | 2000-08-11 18:10:21 +0000 | [diff] [blame] | 260 | { |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 261 | if ( !(list_fmt & LIST_FILETYPE)) |
| 262 | return '\0'; |
| 263 | if ((list_fmt & LIST_EXEC) && S_ISREG(mode) |
| 264 | && (mode & (S_IXUSR | S_IXGRP | S_IXOTH))) return '*'; |
| 265 | return APPCHAR(mode); |
| 266 | } |
| 267 | #endif |
Eric Andersen | 79565b6 | 2000-08-11 18:10:21 +0000 | [diff] [blame] | 268 | |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 269 | /*----------------------------------------------------------------------*/ |
| 270 | static void nexttabstop( void ) |
| 271 | { |
| 272 | static short nexttab= 0; |
| 273 | int n=0; |
| 274 | |
| 275 | if (column > 0) { |
| 276 | n= nexttab - column; |
| 277 | if (n < 1) n= 1; |
| 278 | while (n--) { |
Matt Kraai | 12f417e | 2001-01-18 02:57:08 +0000 | [diff] [blame] | 279 | putchar(' '); |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 280 | column++; |
| 281 | } |
| 282 | } |
Eric Andersen | f5d5e77 | 2001-01-24 23:34:48 +0000 | [diff] [blame] | 283 | nexttab= column + column_width + COLUMN_GAP; |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 284 | } |
| 285 | |
| 286 | /*----------------------------------------------------------------------*/ |
Eric Andersen | cf1189f | 2000-11-29 21:52:06 +0000 | [diff] [blame] | 287 | static int is_subdir(struct dnode *dn) |
| 288 | { |
| 289 | return (S_ISDIR(dn->dstat.st_mode) && strcmp(dn->name, ".") != 0 && |
| 290 | strcmp(dn->name, "..") != 0); |
| 291 | } |
| 292 | |
Eric Andersen | 3e6ff90 | 2001-03-09 21:24:12 +0000 | [diff] [blame] | 293 | static int countdirs(struct dnode **dn, int nfiles) |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 294 | { |
| 295 | int i, dirs; |
| 296 | |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 297 | if (dn==NULL || nfiles < 1) return(0); |
| 298 | dirs= 0; |
| 299 | for (i=0; i<nfiles; i++) { |
| 300 | if (S_ISDIR(dn[i]->dstat.st_mode)) dirs++; |
| 301 | } |
| 302 | return(dirs); |
| 303 | } |
| 304 | |
Eric Andersen | 3e6ff90 | 2001-03-09 21:24:12 +0000 | [diff] [blame] | 305 | static int countsubdirs(struct dnode **dn, int nfiles) |
Eric Andersen | cf1189f | 2000-11-29 21:52:06 +0000 | [diff] [blame] | 306 | { |
| 307 | int i, subdirs; |
| 308 | |
| 309 | if (dn == NULL || nfiles < 1) return 0; |
| 310 | subdirs = 0; |
| 311 | for (i = 0; i < nfiles; i++) |
| 312 | if (is_subdir(dn[i])) |
| 313 | subdirs++; |
| 314 | return subdirs; |
| 315 | } |
| 316 | |
Eric Andersen | 3e6ff90 | 2001-03-09 21:24:12 +0000 | [diff] [blame] | 317 | static int countfiles(struct dnode **dnp) |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 318 | { |
| 319 | int nfiles; |
| 320 | struct dnode *cur; |
| 321 | |
| 322 | if (dnp == NULL) return(0); |
| 323 | nfiles= 0; |
| 324 | for (cur= dnp[0]; cur->next != NULL ; cur= cur->next) nfiles++; |
| 325 | nfiles++; |
| 326 | return(nfiles); |
| 327 | } |
| 328 | |
| 329 | /* get memory to hold an array of pointers */ |
Eric Andersen | 3e6ff90 | 2001-03-09 21:24:12 +0000 | [diff] [blame] | 330 | static struct dnode **dnalloc(int num) |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 331 | { |
| 332 | struct dnode **p; |
| 333 | |
| 334 | if (num < 1) return(NULL); |
| 335 | |
| 336 | p= (struct dnode **)xcalloc((size_t)num, (size_t)(sizeof(struct dnode *))); |
| 337 | return(p); |
| 338 | } |
| 339 | |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 340 | #ifdef CONFIG_FEATURE_LS_RECURSIVE |
Eric Andersen | 3e6ff90 | 2001-03-09 21:24:12 +0000 | [diff] [blame] | 341 | static void dfree(struct dnode **dnp) |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 342 | { |
| 343 | struct dnode *cur, *next; |
| 344 | |
| 345 | if(dnp == NULL) return; |
| 346 | |
| 347 | cur=dnp[0]; |
| 348 | while (cur != NULL) { |
| 349 | if (cur->fullname != NULL) free(cur->fullname); /* free the filename */ |
| 350 | next= cur->next; |
| 351 | free(cur); /* free the dnode */ |
| 352 | cur= next; |
| 353 | } |
| 354 | free(dnp); /* free the array holding the dnode pointers */ |
| 355 | } |
Eric Andersen | 20aab26 | 2001-07-19 22:28:02 +0000 | [diff] [blame] | 356 | #endif |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 357 | |
Eric Andersen | 3e6ff90 | 2001-03-09 21:24:12 +0000 | [diff] [blame] | 358 | static struct dnode **splitdnarray(struct dnode **dn, int nfiles, int which) |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 359 | { |
| 360 | int dncnt, i, d; |
| 361 | struct dnode **dnp; |
| 362 | |
| 363 | if (dn==NULL || nfiles < 1) return(NULL); |
| 364 | |
| 365 | /* count how many dirs and regular files there are */ |
Eric Andersen | cf1189f | 2000-11-29 21:52:06 +0000 | [diff] [blame] | 366 | if (which == SPLIT_SUBDIR) |
| 367 | dncnt = countsubdirs(dn, nfiles); |
| 368 | else { |
| 369 | dncnt= countdirs(dn, nfiles); /* assume we are looking for dirs */ |
| 370 | if (which == SPLIT_FILE) |
| 371 | dncnt= nfiles - dncnt; /* looking for files */ |
| 372 | } |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 373 | |
| 374 | /* allocate a file array and a dir array */ |
| 375 | dnp= dnalloc(dncnt); |
| 376 | |
| 377 | /* copy the entrys into the file or dir array */ |
| 378 | for (d= i=0; i<nfiles; i++) { |
| 379 | if (which == SPLIT_DIR) { |
| 380 | if (S_ISDIR(dn[i]->dstat.st_mode)) { |
| 381 | dnp[d++]= dn[i]; |
| 382 | } /* else skip the file */ |
Eric Andersen | cf1189f | 2000-11-29 21:52:06 +0000 | [diff] [blame] | 383 | } else if (which == SPLIT_SUBDIR) { |
| 384 | if (is_subdir(dn[i])) { |
| 385 | dnp[d++]= dn[i]; |
| 386 | } /* else skip the file or dir */ |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 387 | } else { |
| 388 | if (!(S_ISDIR(dn[i]->dstat.st_mode))) { |
| 389 | dnp[d++]= dn[i]; |
| 390 | } /* else skip the dir */ |
| 391 | } |
| 392 | } |
| 393 | return(dnp); |
| 394 | } |
| 395 | |
| 396 | /*----------------------------------------------------------------------*/ |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 397 | #ifdef CONFIG_FEATURE_LS_SORTFILES |
Eric Andersen | 3e6ff90 | 2001-03-09 21:24:12 +0000 | [diff] [blame] | 398 | static int sortcmp(struct dnode *d1, struct dnode *d2) |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 399 | { |
| 400 | int cmp, dif; |
| 401 | |
| 402 | cmp= 0; |
| 403 | if (sort_opts == SORT_SIZE) { |
| 404 | dif= (int)(d1->dstat.st_size - d2->dstat.st_size); |
| 405 | } else if (sort_opts == SORT_ATIME) { |
| 406 | dif= (int)(d1->dstat.st_atime - d2->dstat.st_atime); |
| 407 | } else if (sort_opts == SORT_CTIME) { |
| 408 | dif= (int)(d1->dstat.st_ctime - d2->dstat.st_ctime); |
| 409 | } else if (sort_opts == SORT_MTIME) { |
| 410 | dif= (int)(d1->dstat.st_mtime - d2->dstat.st_mtime); |
| 411 | } else if (sort_opts == SORT_DIR) { |
| 412 | dif= S_ISDIR(d1->dstat.st_mode) - S_ISDIR(d2->dstat.st_mode); |
| 413 | /* } else if (sort_opts == SORT_VERSION) { */ |
| 414 | /* } else if (sort_opts == SORT_EXT) { */ |
| 415 | } else { /* assume SORT_NAME */ |
| 416 | dif= 0; |
| 417 | } |
| 418 | |
| 419 | if (dif > 0) cmp= -1; |
| 420 | if (dif < 0) cmp= 1; |
| 421 | if (dif == 0) { |
| 422 | /* sort by name- may be a tie_breaker for time or size cmp */ |
| 423 | dif= strcmp(d1->name, d2->name); |
| 424 | if (dif > 0) cmp= 1; |
| 425 | if (dif < 0) cmp= -1; |
| 426 | } |
| 427 | |
| 428 | if (sort_order == SORT_REVERSE) { |
| 429 | cmp= -1 * cmp; |
| 430 | } |
| 431 | return(cmp); |
| 432 | } |
| 433 | |
| 434 | /*----------------------------------------------------------------------*/ |
Eric Andersen | 3e6ff90 | 2001-03-09 21:24:12 +0000 | [diff] [blame] | 435 | static void shellsort(struct dnode **dn, int size) |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 436 | { |
| 437 | struct dnode *temp; |
| 438 | int gap, i, j; |
| 439 | |
| 440 | /* shell short the array */ |
| 441 | if(dn==NULL || size < 2) return; |
| 442 | |
| 443 | for (gap= size/2; gap>0; gap /=2) { |
| 444 | for (i=gap; i<size; i++) { |
| 445 | for (j= i-gap; j>=0; j-=gap) { |
| 446 | if (sortcmp(dn[j], dn[j+gap]) <= 0) |
| 447 | break; |
| 448 | /* they are out of order, swap them */ |
| 449 | temp= dn[j]; |
| 450 | dn[j]= dn[j+gap]; |
| 451 | dn[j+gap]= temp; |
| 452 | } |
| 453 | } |
| 454 | } |
| 455 | } |
| 456 | #endif |
| 457 | |
| 458 | /*----------------------------------------------------------------------*/ |
Eric Andersen | 3e6ff90 | 2001-03-09 21:24:12 +0000 | [diff] [blame] | 459 | static void showfiles(struct dnode **dn, int nfiles) |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 460 | { |
| 461 | int i, ncols, nrows, row, nc; |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 462 | #ifdef CONFIG_FEATURE_AUTOWIDTH |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 463 | int len; |
| 464 | #endif |
| 465 | |
| 466 | if(dn==NULL || nfiles < 1) return; |
| 467 | |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 468 | #ifdef CONFIG_FEATURE_AUTOWIDTH |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 469 | /* find the longest file name- use that as the column width */ |
| 470 | column_width= 0; |
| 471 | for (i=0; i<nfiles; i++) { |
| 472 | len= strlen(dn[i]->name) + |
| 473 | ((list_fmt & LIST_INO) ? 8 : 0) + |
| 474 | ((list_fmt & LIST_BLOCKS) ? 5 : 0) |
| 475 | ; |
Eric Andersen | e57d54b | 2001-01-30 18:03:11 +0000 | [diff] [blame] | 476 | if (column_width < len) |
| 477 | column_width= len; |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 478 | } |
Matt Kraai | 3bd31eb | 2002-03-08 16:16:38 +0000 | [diff] [blame] | 479 | ncols = (int)(terminal_width / (column_width + COLUMN_GAP)); |
Eric Andersen | f5d5e77 | 2001-01-24 23:34:48 +0000 | [diff] [blame] | 480 | #else |
| 481 | ncols= TERMINAL_WIDTH; |
| 482 | #endif |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 483 | switch (style_fmt) { |
| 484 | case STYLE_LONG: /* one record per line, extended info */ |
| 485 | case STYLE_SINGLE: /* one record per line */ |
| 486 | ncols= 1; |
| 487 | break; |
| 488 | } |
| 489 | |
Eric Andersen | e57d54b | 2001-01-30 18:03:11 +0000 | [diff] [blame] | 490 | if (ncols > 1) { |
| 491 | nrows = nfiles / ncols; |
| 492 | } else { |
| 493 | nrows = nfiles; |
| 494 | ncols = 1; |
| 495 | } |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 496 | if ((nrows * ncols) < nfiles) nrows++; /* round up fractionals */ |
| 497 | |
| 498 | if (nrows > nfiles) nrows= nfiles; |
| 499 | for (row=0; row<nrows; row++) { |
Eric Andersen | 79565b6 | 2000-08-11 18:10:21 +0000 | [diff] [blame] | 500 | for (nc=0; nc<ncols; nc++) { |
| 501 | /* reach into the array based on the column and row */ |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 502 | i= (nc * nrows) + row; /* assume display by column */ |
| 503 | if (disp_opts & DISP_ROWS) |
| 504 | i= (row * ncols) + nc; /* display across row */ |
| 505 | if (i < nfiles) { |
| 506 | nexttabstop(); |
| 507 | list_single(dn[i]); |
Eric Andersen | 79565b6 | 2000-08-11 18:10:21 +0000 | [diff] [blame] | 508 | } |
| 509 | } |
Eric Andersen | a42982e | 2000-06-07 17:28:53 +0000 | [diff] [blame] | 510 | newline(); |
| 511 | } |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 512 | } |
| 513 | |
| 514 | /*----------------------------------------------------------------------*/ |
Eric Andersen | 3e6ff90 | 2001-03-09 21:24:12 +0000 | [diff] [blame] | 515 | static void showdirs(struct dnode **dn, int ndirs) |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 516 | { |
| 517 | int i, nfiles; |
| 518 | struct dnode **subdnp; |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 519 | #ifdef CONFIG_FEATURE_LS_RECURSIVE |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 520 | int dndirs; |
| 521 | struct dnode **dnd; |
| 522 | #endif |
| 523 | |
| 524 | if (dn==NULL || ndirs < 1) return; |
| 525 | |
| 526 | for (i=0; i<ndirs; i++) { |
| 527 | if (disp_opts & (DISP_DIRNAME | DISP_RECURSIVE)) { |
Matt Kraai | 12f417e | 2001-01-18 02:57:08 +0000 | [diff] [blame] | 528 | printf("\n%s:\n", dn[i]->fullname); |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 529 | } |
| 530 | subdnp= list_dir(dn[i]->fullname); |
| 531 | nfiles= countfiles(subdnp); |
| 532 | if (nfiles > 0) { |
| 533 | /* list all files at this level */ |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 534 | #ifdef CONFIG_FEATURE_LS_SORTFILES |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 535 | shellsort(subdnp, nfiles); |
| 536 | #endif |
| 537 | showfiles(subdnp, nfiles); |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 538 | #ifdef CONFIG_FEATURE_LS_RECURSIVE |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 539 | if (disp_opts & DISP_RECURSIVE) { |
| 540 | /* recursive- list the sub-dirs */ |
Eric Andersen | cf1189f | 2000-11-29 21:52:06 +0000 | [diff] [blame] | 541 | dnd= splitdnarray(subdnp, nfiles, SPLIT_SUBDIR); |
| 542 | dndirs= countsubdirs(subdnp, nfiles); |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 543 | if (dndirs > 0) { |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 544 | #ifdef CONFIG_FEATURE_LS_SORTFILES |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 545 | shellsort(dnd, dndirs); |
Matt Kraai | a5bd268 | 2000-10-28 06:40:09 +0000 | [diff] [blame] | 546 | #endif |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 547 | showdirs(dnd, dndirs); |
| 548 | free(dnd); /* free the array of dnode pointers to the dirs */ |
| 549 | } |
| 550 | } |
| 551 | dfree(subdnp); /* free the dnodes and the fullname mem */ |
| 552 | #endif |
| 553 | } |
| 554 | } |
| 555 | } |
| 556 | |
| 557 | /*----------------------------------------------------------------------*/ |
Eric Andersen | 3e6ff90 | 2001-03-09 21:24:12 +0000 | [diff] [blame] | 558 | static struct dnode **list_dir(char *path) |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 559 | { |
| 560 | struct dnode *dn, *cur, **dnp; |
| 561 | struct dirent *entry; |
| 562 | DIR *dir; |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 563 | int i, nfiles; |
| 564 | |
| 565 | if (path==NULL) return(NULL); |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 566 | |
| 567 | dn= NULL; |
| 568 | nfiles= 0; |
Eric Andersen | e7e1e2d | 2000-10-12 22:40:14 +0000 | [diff] [blame] | 569 | dir = opendir(path); |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 570 | if (dir == NULL) { |
Matt Kraai | 1fa1ade | 2000-12-18 03:57:16 +0000 | [diff] [blame] | 571 | perror_msg("%s", path); |
Matt Kraai | 33fdae5 | 2000-10-13 17:59:43 +0000 | [diff] [blame] | 572 | status = EXIT_FAILURE; |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 573 | return(NULL); /* could not open the dir */ |
| 574 | } |
| 575 | while ((entry = readdir(dir)) != NULL) { |
| 576 | /* are we going to list the file- it may be . or .. or a hidden file */ |
Matt Kraai | 782ab3c | 2001-04-23 01:07:00 +0000 | [diff] [blame] | 577 | if ((strcmp(entry->d_name, ".")==0) && !(disp_opts & DISP_DOT)) |
| 578 | continue; |
| 579 | if ((strcmp(entry->d_name, "..")==0) && !(disp_opts & DISP_DOT)) |
| 580 | continue; |
| 581 | if ((entry->d_name[0] == '.') && !(disp_opts & DISP_HIDDEN)) |
| 582 | continue; |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 583 | cur= (struct dnode *)xmalloc(sizeof(struct dnode)); |
Matt Kraai | 782ab3c | 2001-04-23 01:07:00 +0000 | [diff] [blame] | 584 | cur->fullname = concat_path_file(path, entry->d_name); |
| 585 | cur->name = cur->fullname + |
| 586 | (strlen(cur->fullname) - strlen(entry->d_name)); |
Matt Kraai | 9a6e67c | 2000-10-13 18:03:21 +0000 | [diff] [blame] | 587 | if (my_stat(cur)) |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 588 | continue; |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 589 | cur->next= dn; |
| 590 | dn= cur; |
| 591 | nfiles++; |
| 592 | } |
| 593 | closedir(dir); |
| 594 | |
| 595 | /* now that we know how many files there are |
| 596 | ** allocate memory for an array to hold dnode pointers |
| 597 | */ |
| 598 | if (nfiles < 1) return(NULL); |
| 599 | dnp= dnalloc(nfiles); |
| 600 | for (i=0, cur=dn; i<nfiles; i++) { |
| 601 | dnp[i]= cur; /* save pointer to node in array */ |
| 602 | cur= cur->next; |
| 603 | } |
| 604 | |
| 605 | return(dnp); |
| 606 | } |
| 607 | |
| 608 | /*----------------------------------------------------------------------*/ |
Eric Andersen | 3e6ff90 | 2001-03-09 21:24:12 +0000 | [diff] [blame] | 609 | static int list_single(struct dnode *dn) |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 610 | { |
Mark Whitley | 8a63326 | 2001-04-30 18:17:00 +0000 | [diff] [blame] | 611 | int i; |
Matt Kraai | a1bbde7 | 2002-03-08 16:25:33 +0000 | [diff] [blame] | 612 | #ifdef CONFIG_FEATURE_LS_USERNAME |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 613 | char scratch[BUFSIZ + 1]; |
Matt Kraai | a1bbde7 | 2002-03-08 16:25:33 +0000 | [diff] [blame] | 614 | #endif |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 615 | #ifdef CONFIG_FEATURE_LS_TIMESTAMPS |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 616 | char *filetime; |
| 617 | time_t ttime, age; |
| 618 | #endif |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 619 | #if defined (CONFIG_FEATURE_LS_FILETYPES) |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 620 | struct stat info; |
Matt Kraai | b273d66 | 2000-10-28 01:21:22 +0000 | [diff] [blame] | 621 | #endif |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 622 | #ifdef CONFIG_FEATURE_LS_FILETYPES |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 623 | char append; |
| 624 | #endif |
| 625 | |
| 626 | if (dn==NULL || dn->fullname==NULL) return(0); |
| 627 | |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 628 | #ifdef CONFIG_FEATURE_LS_TIMESTAMPS |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 629 | ttime= dn->dstat.st_mtime; /* the default time */ |
| 630 | if (time_fmt & TIME_ACCESS) ttime= dn->dstat.st_atime; |
| 631 | if (time_fmt & TIME_CHANGE) ttime= dn->dstat.st_ctime; |
| 632 | filetime= ctime(&ttime); |
| 633 | #endif |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 634 | #ifdef CONFIG_FEATURE_LS_FILETYPES |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 635 | append = append_char(dn->dstat.st_mode); |
| 636 | #endif |
| 637 | |
| 638 | for (i=0; i<=31; i++) { |
| 639 | switch (list_fmt & (1<<i)) { |
| 640 | case LIST_INO: |
Eric Andersen | 24982c5 | 2001-06-25 19:31:48 +0000 | [diff] [blame] | 641 | printf("%7ld ", (long int)dn->dstat.st_ino); |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 642 | column += 8; |
| 643 | break; |
| 644 | case LIST_BLOCKS: |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 645 | #ifdef CONFIG_FEATURE_HUMAN_READABLE |
Eric Andersen | 7e51679 | 2001-06-30 18:00:26 +0000 | [diff] [blame] | 646 | fprintf(stdout, "%6s ", make_human_readable_str(dn->dstat.st_blocks>>1, |
Manuel Novoa III | a77cfbf | 2001-06-30 07:46:50 +0000 | [diff] [blame] | 647 | KILOBYTE, (ls_disp_hr==TRUE)? 0: KILOBYTE)); |
Richard June | 6d0921c | 2001-01-22 22:35:38 +0000 | [diff] [blame] | 648 | #else |
Eric Andersen | 8a2e56c | 2000-09-21 02:23:30 +0000 | [diff] [blame] | 649 | #if _FILE_OFFSET_BITS == 64 |
Matt Kraai | 12f417e | 2001-01-18 02:57:08 +0000 | [diff] [blame] | 650 | printf("%4lld ", dn->dstat.st_blocks>>1); |
Eric Andersen | 8a2e56c | 2000-09-21 02:23:30 +0000 | [diff] [blame] | 651 | #else |
Matt Kraai | 12f417e | 2001-01-18 02:57:08 +0000 | [diff] [blame] | 652 | printf("%4ld ", dn->dstat.st_blocks>>1); |
Eric Andersen | 8a2e56c | 2000-09-21 02:23:30 +0000 | [diff] [blame] | 653 | #endif |
Richard June | 6d0921c | 2001-01-22 22:35:38 +0000 | [diff] [blame] | 654 | #endif |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 655 | column += 5; |
| 656 | break; |
| 657 | case LIST_MODEBITS: |
Eric Andersen | f429bac | 2001-06-13 08:02:45 +0000 | [diff] [blame] | 658 | printf("%-10s ", (char *)mode_string(dn->dstat.st_mode)); |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 659 | column += 10; |
| 660 | break; |
| 661 | case LIST_NLINKS: |
Eric Andersen | e76c3b0 | 2001-04-05 03:14:39 +0000 | [diff] [blame] | 662 | printf("%4ld ", (long)dn->dstat.st_nlink); |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 663 | column += 10; |
| 664 | break; |
| 665 | case LIST_ID_NAME: |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 666 | #ifdef CONFIG_FEATURE_LS_USERNAME |
Matt Kraai | e93abf9 | 2000-11-18 01:08:24 +0000 | [diff] [blame] | 667 | my_getpwuid(scratch, dn->dstat.st_uid); |
Eric Andersen | e57d54b | 2001-01-30 18:03:11 +0000 | [diff] [blame] | 668 | printf("%-8.8s ", scratch); |
Matt Kraai | e93abf9 | 2000-11-18 01:08:24 +0000 | [diff] [blame] | 669 | my_getgrgid(scratch, dn->dstat.st_gid); |
Eric Andersen | bb9579f | 2001-07-31 22:43:50 +0000 | [diff] [blame] | 670 | printf("%-8.8s", scratch); |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 671 | column += 17; |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 672 | break; |
| 673 | #endif |
| 674 | case LIST_ID_NUMERIC: |
Matt Kraai | 12f417e | 2001-01-18 02:57:08 +0000 | [diff] [blame] | 675 | printf("%-8d %-8d", dn->dstat.st_uid, dn->dstat.st_gid); |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 676 | column += 17; |
| 677 | break; |
| 678 | case LIST_SIZE: |
| 679 | case LIST_DEV: |
| 680 | if (S_ISBLK(dn->dstat.st_mode) || S_ISCHR(dn->dstat.st_mode)) { |
Matt Kraai | 12f417e | 2001-01-18 02:57:08 +0000 | [diff] [blame] | 681 | printf("%4d, %3d ", (int)MAJOR(dn->dstat.st_rdev), (int)MINOR(dn->dstat.st_rdev)); |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 682 | } else { |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 683 | #ifdef CONFIG_FEATURE_HUMAN_READABLE |
Eric Andersen | 91c9388 | 2001-04-03 23:14:29 +0000 | [diff] [blame] | 684 | if (ls_disp_hr==TRUE) { |
Eric Andersen | f429bac | 2001-06-13 08:02:45 +0000 | [diff] [blame] | 685 | fprintf(stdout, "%8s ", make_human_readable_str(dn->dstat.st_size, 1, 0)); |
Eric Andersen | 91c9388 | 2001-04-03 23:14:29 +0000 | [diff] [blame] | 686 | } else |
| 687 | #endif |
| 688 | { |
Eric Andersen | 8a2e56c | 2000-09-21 02:23:30 +0000 | [diff] [blame] | 689 | #if _FILE_OFFSET_BITS == 64 |
Eric Andersen | 250a221 | 2001-04-05 23:26:44 +0000 | [diff] [blame] | 690 | printf("%9lld ", (long long)dn->dstat.st_size); |
Eric Andersen | 8a2e56c | 2000-09-21 02:23:30 +0000 | [diff] [blame] | 691 | #else |
Eric Andersen | 91c9388 | 2001-04-03 23:14:29 +0000 | [diff] [blame] | 692 | printf("%9ld ", dn->dstat.st_size); |
Eric Andersen | 8a2e56c | 2000-09-21 02:23:30 +0000 | [diff] [blame] | 693 | #endif |
Eric Andersen | 91c9388 | 2001-04-03 23:14:29 +0000 | [diff] [blame] | 694 | } |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 695 | } |
| 696 | column += 10; |
| 697 | break; |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 698 | #ifdef CONFIG_FEATURE_LS_TIMESTAMPS |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 699 | case LIST_FULLTIME: |
| 700 | case LIST_DATE_TIME: |
| 701 | if (list_fmt & LIST_FULLTIME) { |
Matt Kraai | 12f417e | 2001-01-18 02:57:08 +0000 | [diff] [blame] | 702 | printf("%24.24s ", filetime); |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 703 | column += 25; |
| 704 | break; |
| 705 | } |
| 706 | age = time(NULL) - ttime; |
Matt Kraai | 12f417e | 2001-01-18 02:57:08 +0000 | [diff] [blame] | 707 | printf("%6.6s ", filetime+4); |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 708 | if (age < 3600L * 24 * 365 / 2 && age > -15 * 60) { |
| 709 | /* hh:mm if less than 6 months old */ |
Matt Kraai | 12f417e | 2001-01-18 02:57:08 +0000 | [diff] [blame] | 710 | printf("%5.5s ", filetime+11); |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 711 | } else { |
Matt Kraai | 12f417e | 2001-01-18 02:57:08 +0000 | [diff] [blame] | 712 | printf(" %4.4s ", filetime+20); |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 713 | } |
| 714 | column += 13; |
| 715 | break; |
| 716 | #endif |
| 717 | case LIST_FILENAME: |
Eric Andersen | 3ad0bd9 | 2002-03-20 09:13:48 +0000 | [diff] [blame] | 718 | #ifdef CONFIG_FEATURE_LS_COLOR |
Eric Andersen | 5f68736 | 2002-04-17 20:21:45 +0000 | [diff] [blame] | 719 | errno = 0; |
Eric Andersen | 3ad0bd9 | 2002-03-20 09:13:48 +0000 | [diff] [blame] | 720 | if (show_color && !lstat(dn->fullname, &info)) { |
| 721 | printf( "\033[%d;%dm", bgcolor(info.st_mode), |
| 722 | fgcolor(info.st_mode) ); |
| 723 | } |
| 724 | #endif |
Matt Kraai | 12f417e | 2001-01-18 02:57:08 +0000 | [diff] [blame] | 725 | printf("%s", dn->name); |
Eric Andersen | 3ad0bd9 | 2002-03-20 09:13:48 +0000 | [diff] [blame] | 726 | #ifdef CONFIG_FEATURE_LS_COLOR |
| 727 | if (show_color) { |
| 728 | printf( "\033[0m" ); |
| 729 | } |
| 730 | #endif |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 731 | column += strlen(dn->name); |
| 732 | break; |
| 733 | case LIST_SYMLINK: |
| 734 | if (S_ISLNK(dn->dstat.st_mode)) { |
Mark Whitley | 8a63326 | 2001-04-30 18:17:00 +0000 | [diff] [blame] | 735 | char *lpath = xreadlink(dn->fullname); |
| 736 | if (lpath) { |
Eric Andersen | 3ad0bd9 | 2002-03-20 09:13:48 +0000 | [diff] [blame] | 737 | printf(" -> "); |
| 738 | #if defined(BB_FEATURE_LS_FILETYPES) || defined(CONFIG_FEATURE_LS_COLOR) |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 739 | if (!stat(dn->fullname, &info)) { |
| 740 | append = append_char(info.st_mode); |
| 741 | } |
| 742 | #endif |
Eric Andersen | 3ad0bd9 | 2002-03-20 09:13:48 +0000 | [diff] [blame] | 743 | #ifdef CONFIG_FEATURE_LS_COLOR |
| 744 | if (show_color) { |
Eric Andersen | 5f68736 | 2002-04-17 20:21:45 +0000 | [diff] [blame] | 745 | errno = 0; |
Eric Andersen | 3ad0bd9 | 2002-03-20 09:13:48 +0000 | [diff] [blame] | 746 | printf( "\033[%d;%dm", bgcolor(info.st_mode), |
| 747 | fgcolor(info.st_mode) ); |
| 748 | } |
| 749 | #endif |
| 750 | printf("%s", lpath); |
| 751 | #ifdef CONFIG_FEATURE_LS_COLOR |
| 752 | if (show_color) { |
| 753 | printf( "\033[0m" ); |
| 754 | } |
| 755 | #endif |
Mark Whitley | 8a63326 | 2001-04-30 18:17:00 +0000 | [diff] [blame] | 756 | column += strlen(lpath) + 4; |
| 757 | free(lpath); |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 758 | } |
| 759 | } |
| 760 | break; |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 761 | #ifdef CONFIG_FEATURE_LS_FILETYPES |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 762 | case LIST_FILETYPE: |
| 763 | if (append != '\0') { |
Matt Kraai | 12f417e | 2001-01-18 02:57:08 +0000 | [diff] [blame] | 764 | printf("%1c", append); |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 765 | column++; |
| 766 | } |
| 767 | break; |
| 768 | #endif |
| 769 | } |
| 770 | } |
| 771 | |
| 772 | return(0); |
| 773 | } |
| 774 | |
| 775 | /*----------------------------------------------------------------------*/ |
| 776 | extern int ls_main(int argc, char **argv) |
| 777 | { |
| 778 | struct dnode **dnf, **dnd; |
| 779 | int dnfiles, dndirs; |
| 780 | struct dnode *dn, *cur, **dnp; |
| 781 | int i, nfiles; |
| 782 | int opt; |
| 783 | int oi, ac; |
| 784 | char **av; |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 785 | #ifdef CONFIG_FEATURE_AUTOWIDTH |
Eric Andersen | 5307eca | 2001-01-26 01:52:43 +0000 | [diff] [blame] | 786 | struct winsize win = { 0, 0, 0, 0 }; |
| 787 | #endif |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 788 | |
| 789 | disp_opts= DISP_NORMAL; |
| 790 | style_fmt= STYLE_AUTO; |
| 791 | list_fmt= LIST_SHORT; |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 792 | #ifdef CONFIG_FEATURE_LS_SORTFILES |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 793 | sort_opts= SORT_NAME; |
Mark Whitley | 59ab025 | 2001-01-23 22:30:04 +0000 | [diff] [blame] | 794 | sort_order= SORT_FORWARD; |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 795 | #endif |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 796 | #ifdef CONFIG_FEATURE_LS_TIMESTAMPS |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 797 | time_fmt= TIME_MOD; |
| 798 | #endif |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 799 | #ifdef CONFIG_FEATURE_AUTOWIDTH |
Mark Whitley | 9b300d0 | 2001-02-01 19:39:43 +0000 | [diff] [blame] | 800 | ioctl(fileno(stdout), TIOCGWINSZ, &win); |
| 801 | if (win.ws_row > 4) |
| 802 | column_width = win.ws_row - 2; |
| 803 | if (win.ws_col > 0) |
| 804 | terminal_width = win.ws_col - 1; |
Eric Andersen | 5307eca | 2001-01-26 01:52:43 +0000 | [diff] [blame] | 805 | #endif |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 806 | nfiles=0; |
| 807 | |
Eric Andersen | 3ad0bd9 | 2002-03-20 09:13:48 +0000 | [diff] [blame] | 808 | #ifdef CONFIG_FEATURE_LS_COLOR |
| 809 | if (isatty(fileno(stdout))) |
| 810 | show_color = 1; |
| 811 | #endif |
| 812 | |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 813 | /* process options */ |
| 814 | while ((opt = getopt(argc, argv, "1AaCdgilnsx" |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 815 | #ifdef CONFIG_FEATURE_AUTOWIDTH |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 816 | "T:w:" |
| 817 | #endif |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 818 | #ifdef CONFIG_FEATURE_LS_FILETYPES |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 819 | "Fp" |
| 820 | #endif |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 821 | #ifdef CONFIG_FEATURE_LS_RECURSIVE |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 822 | "R" |
| 823 | #endif |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 824 | #ifdef CONFIG_FEATURE_LS_SORTFILES |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 825 | "rSvX" |
| 826 | #endif |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 827 | #ifdef CONFIG_FEATURE_LS_TIMESTAMPS |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 828 | "cetu" |
| 829 | #endif |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 830 | #ifdef CONFIG_FEATURE_LS_FOLLOWLINKS |
Matt Kraai | a2f2a8f | 2000-09-22 03:11:47 +0000 | [diff] [blame] | 831 | "L" |
| 832 | #endif |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 833 | #ifdef CONFIG_FEATURE_HUMAN_READABLE |
Richard June | 6d0921c | 2001-01-22 22:35:38 +0000 | [diff] [blame] | 834 | "h" |
| 835 | #endif |
| 836 | "k")) > 0) { |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 837 | switch (opt) { |
| 838 | case '1': style_fmt = STYLE_SINGLE; break; |
| 839 | case 'A': disp_opts |= DISP_HIDDEN; break; |
| 840 | case 'a': disp_opts |= DISP_HIDDEN | DISP_DOT; break; |
| 841 | case 'C': style_fmt = STYLE_COLUMNS; break; |
| 842 | case 'd': disp_opts |= DISP_NOLIST; break; |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 843 | case 'g': /* ignore -- for ftp servers */ break; |
| 844 | case 'i': list_fmt |= LIST_INO; break; |
Richard June | 6d0921c | 2001-01-22 22:35:38 +0000 | [diff] [blame] | 845 | case 'l': |
| 846 | style_fmt = STYLE_LONG; |
| 847 | list_fmt |= LIST_LONG; |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 848 | #ifdef CONFIG_FEATURE_HUMAN_READABLE |
Eric Andersen | 651f8c0 | 2001-03-07 03:48:02 +0000 | [diff] [blame] | 849 | ls_disp_hr = FALSE; |
Richard June | 6d0921c | 2001-01-22 22:35:38 +0000 | [diff] [blame] | 850 | #endif |
| 851 | break; |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 852 | case 'n': list_fmt |= LIST_ID_NUMERIC; break; |
| 853 | case 's': list_fmt |= LIST_BLOCKS; break; |
| 854 | case 'x': disp_opts = DISP_ROWS; break; |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 855 | #ifdef CONFIG_FEATURE_LS_FILETYPES |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 856 | case 'F': list_fmt |= LIST_FILETYPE | LIST_EXEC; break; |
| 857 | case 'p': list_fmt |= LIST_FILETYPE; break; |
| 858 | #endif |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 859 | #ifdef CONFIG_FEATURE_LS_RECURSIVE |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 860 | case 'R': disp_opts |= DISP_RECURSIVE; break; |
| 861 | #endif |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 862 | #ifdef CONFIG_FEATURE_LS_SORTFILES |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 863 | case 'r': sort_order |= SORT_REVERSE; break; |
| 864 | case 'S': sort_opts= SORT_SIZE; break; |
| 865 | case 'v': sort_opts= SORT_VERSION; break; |
| 866 | case 'X': sort_opts= SORT_EXT; break; |
| 867 | #endif |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 868 | #ifdef CONFIG_FEATURE_LS_TIMESTAMPS |
Matt Kraai | a5bd268 | 2000-10-28 06:40:09 +0000 | [diff] [blame] | 869 | case 'e': list_fmt |= LIST_FULLTIME; break; |
| 870 | case 'c': |
| 871 | time_fmt = TIME_CHANGE; |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 872 | #ifdef CONFIG_FEATURE_LS_SORTFILES |
Matt Kraai | a5bd268 | 2000-10-28 06:40:09 +0000 | [diff] [blame] | 873 | sort_opts= SORT_CTIME; |
| 874 | #endif |
| 875 | break; |
| 876 | case 'u': |
| 877 | time_fmt = TIME_ACCESS; |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 878 | #ifdef CONFIG_FEATURE_LS_SORTFILES |
Matt Kraai | a5bd268 | 2000-10-28 06:40:09 +0000 | [diff] [blame] | 879 | sort_opts= SORT_ATIME; |
| 880 | #endif |
| 881 | break; |
| 882 | case 't': |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 883 | #ifdef CONFIG_FEATURE_LS_SORTFILES |
Matt Kraai | a5bd268 | 2000-10-28 06:40:09 +0000 | [diff] [blame] | 884 | sort_opts= SORT_MTIME; |
| 885 | #endif |
| 886 | break; |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 887 | #endif |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 888 | #ifdef CONFIG_FEATURE_LS_FOLLOWLINKS |
Matt Kraai | a2f2a8f | 2000-09-22 03:11:47 +0000 | [diff] [blame] | 889 | case 'L': follow_links= TRUE; break; |
| 890 | #endif |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 891 | #ifdef CONFIG_FEATURE_AUTOWIDTH |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 892 | case 'T': tabstops= atoi(optarg); break; |
| 893 | case 'w': terminal_width= atoi(optarg); break; |
| 894 | #endif |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 895 | #ifdef CONFIG_FEATURE_HUMAN_READABLE |
Eric Andersen | 651f8c0 | 2001-03-07 03:48:02 +0000 | [diff] [blame] | 896 | case 'h': ls_disp_hr = TRUE; break; |
Richard June | 6d0921c | 2001-01-22 22:35:38 +0000 | [diff] [blame] | 897 | #endif |
Eric Andersen | 8b728a2 | 2001-03-06 23:14:43 +0000 | [diff] [blame] | 898 | case 'k': break; |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 899 | default: |
| 900 | goto print_usage_message; |
| 901 | } |
| 902 | } |
| 903 | |
| 904 | /* sort out which command line options take precedence */ |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 905 | #ifdef CONFIG_FEATURE_LS_RECURSIVE |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 906 | if (disp_opts & DISP_NOLIST) |
| 907 | disp_opts &= ~DISP_RECURSIVE; /* no recurse if listing only dir */ |
| 908 | #endif |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 909 | #if defined (CONFIG_FEATURE_LS_TIMESTAMPS) && defined (CONFIG_FEATURE_LS_SORTFILES) |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 910 | if (time_fmt & TIME_CHANGE) sort_opts= SORT_CTIME; |
| 911 | if (time_fmt & TIME_ACCESS) sort_opts= SORT_ATIME; |
| 912 | #endif |
| 913 | if (style_fmt != STYLE_LONG) |
| 914 | list_fmt &= ~LIST_ID_NUMERIC; /* numeric uid only for long list */ |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 915 | #ifdef CONFIG_FEATURE_LS_USERNAME |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 916 | if (style_fmt == STYLE_LONG && (list_fmt & LIST_ID_NUMERIC)) |
| 917 | list_fmt &= ~LIST_ID_NAME; /* don't list names if numeric uid */ |
| 918 | #endif |
| 919 | |
| 920 | /* choose a display format */ |
| 921 | if (style_fmt == STYLE_AUTO) |
| 922 | style_fmt = isatty(fileno(stdout)) ? STYLE_COLUMNS : STYLE_SINGLE; |
| 923 | |
| 924 | /* |
| 925 | * when there are no cmd line args we have to supply a default "." arg. |
| 926 | * we will create a second argv array, "av" that will hold either |
| 927 | * our created "." arg, or the real cmd line args. The av array |
| 928 | * just holds the pointers- we don't move the date the pointers |
| 929 | * point to. |
| 930 | */ |
| 931 | ac= argc - optind; /* how many cmd line args are left */ |
| 932 | if (ac < 1) { |
| 933 | av= (char **)xcalloc((size_t)1, (size_t)(sizeof(char *))); |
| 934 | av[0]= xstrdup("."); |
| 935 | ac=1; |
| 936 | } else { |
| 937 | av= (char **)xcalloc((size_t)ac, (size_t)(sizeof(char *))); |
| 938 | for (oi=0 ; oi < ac; oi++) { |
| 939 | av[oi]= argv[optind++]; /* copy pointer to real cmd line arg */ |
| 940 | } |
| 941 | } |
| 942 | |
| 943 | /* now, everything is in the av array */ |
| 944 | if (ac > 1) |
| 945 | disp_opts |= DISP_DIRNAME; /* 2 or more items? label directories */ |
| 946 | |
| 947 | /* stuff the command line file names into an dnode array */ |
| 948 | dn=NULL; |
| 949 | for (oi=0 ; oi < ac; oi++) { |
| 950 | cur= (struct dnode *)xmalloc(sizeof(struct dnode)); |
| 951 | cur->fullname= xstrdup(av[oi]); |
Eric Andersen | 958c78f | 2000-10-09 17:51:25 +0000 | [diff] [blame] | 952 | cur->name= cur->fullname; |
Matt Kraai | 9a6e67c | 2000-10-13 18:03:21 +0000 | [diff] [blame] | 953 | if (my_stat(cur)) |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 954 | continue; |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 955 | cur->next= dn; |
| 956 | dn= cur; |
| 957 | nfiles++; |
| 958 | } |
| 959 | |
| 960 | /* now that we know how many files there are |
| 961 | ** allocate memory for an array to hold dnode pointers |
| 962 | */ |
| 963 | dnp= dnalloc(nfiles); |
| 964 | for (i=0, cur=dn; i<nfiles; i++) { |
| 965 | dnp[i]= cur; /* save pointer to node in array */ |
| 966 | cur= cur->next; |
| 967 | } |
| 968 | |
| 969 | |
| 970 | if (disp_opts & DISP_NOLIST) { |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 971 | #ifdef CONFIG_FEATURE_LS_SORTFILES |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 972 | shellsort(dnp, nfiles); |
| 973 | #endif |
| 974 | if (nfiles > 0) showfiles(dnp, nfiles); |
| 975 | } else { |
| 976 | dnd= splitdnarray(dnp, nfiles, SPLIT_DIR); |
| 977 | dnf= splitdnarray(dnp, nfiles, SPLIT_FILE); |
| 978 | dndirs= countdirs(dnp, nfiles); |
| 979 | dnfiles= nfiles - dndirs; |
| 980 | if (dnfiles > 0) { |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 981 | #ifdef CONFIG_FEATURE_LS_SORTFILES |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 982 | shellsort(dnf, dnfiles); |
| 983 | #endif |
| 984 | showfiles(dnf, dnfiles); |
| 985 | } |
| 986 | if (dndirs > 0) { |
Eric Andersen | bdfd0d7 | 2001-10-24 05:00:29 +0000 | [diff] [blame] | 987 | #ifdef CONFIG_FEATURE_LS_SORTFILES |
Eric Andersen | 11c6552 | 2000-09-07 17:24:47 +0000 | [diff] [blame] | 988 | shellsort(dnd, dndirs); |
| 989 | #endif |
| 990 | showdirs(dnd, dndirs); |
| 991 | } |
| 992 | } |
Matt Kraai | 33fdae5 | 2000-10-13 17:59:43 +0000 | [diff] [blame] | 993 | return(status); |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 994 | |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 995 | print_usage_message: |
Eric Andersen | 67991cf | 2001-02-14 21:23:06 +0000 | [diff] [blame] | 996 | show_usage(); |
Eric Andersen | cc8ed39 | 1999-10-05 16:24:54 +0000 | [diff] [blame] | 997 | } |