ls.c (9569B)
1 /* See LICENSE file for copyright and license details. */ 2 #include <sys/stat.h> 3 #include <sys/types.h> 4 #ifdef __GLIBC__ 5 #include <sys/sysmacros.h> 6 #endif 7 8 #include <dirent.h> 9 #include <grp.h> 10 #include <pwd.h> 11 #include <stdio.h> 12 #include <stdlib.h> 13 #include <string.h> 14 #include <time.h> 15 #include <unistd.h> 16 17 #include "utf.h" 18 #include "util.h" 19 20 struct entry { 21 char *name; 22 mode_t mode, tmode; 23 nlink_t nlink; 24 uid_t uid; 25 gid_t gid; 26 off_t size; 27 struct timespec t; 28 dev_t dev; 29 dev_t rdev; 30 ino_t ino, tino; 31 }; 32 33 static struct { 34 dev_t dev; 35 ino_t ino; 36 } tree[PATH_MAX]; 37 38 static int ret = 0; 39 static int Aflag = 0; 40 static int aflag = 0; 41 static int cflag = 0; 42 static int dflag = 0; 43 static int Fflag = 0; 44 static int fflag = 0; 45 static int Hflag = 0; 46 static int hflag = 0; 47 static int iflag = 0; 48 static int Lflag = 0; 49 static int lflag = 0; 50 static int nflag = 0; 51 static int pflag = 0; 52 static int qflag = 0; 53 static int Rflag = 0; 54 static int rflag = 0; 55 static int Uflag = 0; 56 static int uflag = 0; 57 static int first = 1; 58 static char sort = 0; 59 static int showdirs; 60 61 static void ls(const char *, const struct entry *, int); 62 63 static void 64 mkent(struct entry *ent, char *path, int dostat, int follow) 65 { 66 struct stat st; 67 68 ent->name = path; 69 if (!dostat) 70 return; 71 if ((follow ? stat : lstat)(path, &st) < 0) 72 eprintf("%s %s:", follow ? "stat" : "lstat", path); 73 ent->mode = st.st_mode; 74 ent->nlink = st.st_nlink; 75 ent->uid = st.st_uid; 76 ent->gid = st.st_gid; 77 ent->size = st.st_size; 78 if (cflag) 79 ent->t = st.st_ctim; 80 else if (uflag) 81 ent->t = st.st_atim; 82 else 83 ent->t = st.st_mtim; 84 ent->dev = st.st_dev; 85 ent->rdev = st.st_rdev; 86 ent->ino = st.st_ino; 87 if (S_ISLNK(ent->mode)) { 88 if (stat(path, &st) == 0) { 89 ent->tmode = st.st_mode; 90 ent->dev = st.st_dev; 91 ent->tino = st.st_ino; 92 } else { 93 ent->tmode = ent->tino = 0; 94 } 95 } 96 } 97 98 static char * 99 indicator(mode_t mode) 100 { 101 if (pflag || Fflag) 102 if (S_ISDIR(mode)) 103 return "/"; 104 105 if (Fflag) { 106 if (S_ISLNK(mode)) 107 return "@"; 108 else if (S_ISFIFO(mode)) 109 return "|"; 110 else if (S_ISSOCK(mode)) 111 return "="; 112 else if (mode & S_IXUSR || mode & S_IXGRP || mode & S_IXOTH) 113 return "*"; 114 } 115 116 return ""; 117 } 118 119 static void 120 printname(const char *name) 121 { 122 const char *c; 123 Rune r; 124 size_t l; 125 126 for (c = name; *c; c += l) { 127 l = chartorune(&r, c); 128 if (!qflag || isprintrune(r)) 129 fwrite(c, 1, l, stdout); 130 else 131 putchar('?'); 132 } 133 } 134 135 static void 136 output(const struct entry *ent) 137 { 138 struct group *gr; 139 struct passwd *pw; 140 struct tm *tm; 141 ssize_t len; 142 char *fmt, buf[BUFSIZ], pwname[_SC_LOGIN_NAME_MAX], 143 grname[_SC_LOGIN_NAME_MAX], mode[] = "----------"; 144 145 if (iflag) 146 printf("%lu ", (unsigned long)ent->ino); 147 if (!lflag) { 148 printname(ent->name); 149 puts(indicator(ent->mode)); 150 return; 151 } 152 if (S_ISREG(ent->mode)) 153 mode[0] = '-'; 154 else if (S_ISBLK(ent->mode)) 155 mode[0] = 'b'; 156 else if (S_ISCHR(ent->mode)) 157 mode[0] = 'c'; 158 else if (S_ISDIR(ent->mode)) 159 mode[0] = 'd'; 160 else if (S_ISFIFO(ent->mode)) 161 mode[0] = 'p'; 162 else if (S_ISLNK(ent->mode)) 163 mode[0] = 'l'; 164 else if (S_ISSOCK(ent->mode)) 165 mode[0] = 's'; 166 else 167 mode[0] = '?'; 168 169 if (ent->mode & S_IRUSR) mode[1] = 'r'; 170 if (ent->mode & S_IWUSR) mode[2] = 'w'; 171 if (ent->mode & S_IXUSR) mode[3] = 'x'; 172 if (ent->mode & S_IRGRP) mode[4] = 'r'; 173 if (ent->mode & S_IWGRP) mode[5] = 'w'; 174 if (ent->mode & S_IXGRP) mode[6] = 'x'; 175 if (ent->mode & S_IROTH) mode[7] = 'r'; 176 if (ent->mode & S_IWOTH) mode[8] = 'w'; 177 if (ent->mode & S_IXOTH) mode[9] = 'x'; 178 179 if (ent->mode & S_ISUID) mode[3] = (mode[3] == 'x') ? 's' : 'S'; 180 if (ent->mode & S_ISGID) mode[6] = (mode[6] == 'x') ? 's' : 'S'; 181 if (ent->mode & S_ISVTX) mode[9] = (mode[9] == 'x') ? 't' : 'T'; 182 183 if (!nflag && (pw = getpwuid(ent->uid))) 184 snprintf(pwname, sizeof(pwname), "%s", pw->pw_name); 185 else 186 snprintf(pwname, sizeof(pwname), "%d", ent->uid); 187 188 if (!nflag && (gr = getgrgid(ent->gid))) 189 snprintf(grname, sizeof(grname), "%s", gr->gr_name); 190 else 191 snprintf(grname, sizeof(grname), "%d", ent->gid); 192 193 if (time(NULL) > ent->t.tv_sec + (180 * 24 * 60 * 60)) /* 6 months ago? */ 194 fmt = "%b %d %Y"; 195 else 196 fmt = "%b %d %H:%M"; 197 198 if ((tm = localtime(&ent->t.tv_sec))) 199 strftime(buf, sizeof(buf), fmt, tm); 200 else 201 snprintf(buf, sizeof(buf), "%lld", (long long)(ent->t.tv_sec)); 202 printf("%s %4ld %-8.8s %-8.8s ", mode, (long)ent->nlink, pwname, grname); 203 204 if (S_ISBLK(ent->mode) || S_ISCHR(ent->mode)) 205 printf("%4u, %4u ", major(ent->rdev), minor(ent->rdev)); 206 else if (hflag) 207 printf("%10s ", humansize(ent->size)); 208 else 209 printf("%10lu ", (unsigned long)ent->size); 210 printf("%s ", buf); 211 printname(ent->name); 212 fputs(indicator(ent->mode), stdout); 213 if (S_ISLNK(ent->mode)) { 214 if ((len = readlink(ent->name, buf, sizeof(buf) - 1)) < 0) 215 eprintf("readlink %s:", ent->name); 216 buf[len] = '\0'; 217 printf(" -> %s%s", buf, indicator(ent->tmode)); 218 } 219 putchar('\n'); 220 } 221 222 static int 223 entcmp(const void *va, const void *vb) 224 { 225 int cmp = 0; 226 const struct entry *a = va, *b = vb; 227 228 switch (sort) { 229 case 'S': 230 cmp = b->size - a->size; 231 break; 232 case 't': 233 if (!(cmp = b->t.tv_sec - a->t.tv_sec)) 234 cmp = b->t.tv_nsec - a->t.tv_nsec; 235 break; 236 } 237 238 if (!cmp) 239 cmp = strcmp(a->name, b->name); 240 241 return rflag ? 0 - cmp : cmp; 242 } 243 244 static void 245 lsdir(const char *path, const struct entry *dir) 246 { 247 DIR *dp; 248 struct entry *ent, *ents = NULL; 249 struct dirent *d; 250 size_t i, n = 0; 251 char prefix[PATH_MAX]; 252 253 if (!(dp = opendir(dir->name))) { 254 ret = 1; 255 weprintf("opendir %s%s:", path, dir->name); 256 return; 257 } 258 if (chdir(dir->name) < 0) 259 eprintf("chdir %s:", dir->name); 260 261 while ((d = readdir(dp))) { 262 if (d->d_name[0] == '.' && !aflag && !Aflag) 263 continue; 264 else if (Aflag) 265 if (strcmp(d->d_name, ".") == 0 || 266 strcmp(d->d_name, "..") == 0) 267 continue; 268 269 ents = ereallocarray(ents, ++n, sizeof(*ents)); 270 mkent(&ents[n - 1], estrdup(d->d_name), Fflag || iflag || 271 lflag || pflag || Rflag || sort, Lflag); 272 } 273 274 closedir(dp); 275 276 if (!Uflag) 277 qsort(ents, n, sizeof(*ents), entcmp); 278 279 if (path[0] || showdirs) { 280 fputs(path, stdout); 281 printname(dir->name); 282 puts(":"); 283 } 284 for (i = 0; i < n; i++) 285 output(&ents[i]); 286 287 if (Rflag) { 288 if (snprintf(prefix, PATH_MAX, "%s%s/", path, dir->name) >= 289 PATH_MAX) 290 eprintf("path too long: %s%s\n", path, dir->name); 291 292 for (i = 0; i < n; i++) { 293 ent = &ents[i]; 294 if (strcmp(ent->name, ".") == 0 || 295 strcmp(ent->name, "..") == 0) 296 continue; 297 if (S_ISLNK(ent->mode) && S_ISDIR(ent->tmode) && !Lflag) 298 continue; 299 300 ls(prefix, ent, 1); 301 } 302 } 303 304 for (i = 0; i < n; ++i) 305 free(ents[i].name); 306 free(ents); 307 } 308 309 static int 310 visit(const struct entry *ent) 311 { 312 dev_t dev; 313 ino_t ino; 314 int i; 315 316 dev = ent->dev; 317 ino = S_ISLNK(ent->mode) ? ent->tino : ent->ino; 318 319 for (i = 0; i < PATH_MAX && tree[i].ino; ++i) { 320 if (ino == tree[i].ino && dev == tree[i].dev) 321 return -1; 322 } 323 324 tree[i].ino = ino; 325 tree[i].dev = dev; 326 327 return i; 328 } 329 330 static void 331 ls(const char *path, const struct entry *ent, int listdir) 332 { 333 int treeind; 334 char cwd[PATH_MAX]; 335 336 if (!listdir) { 337 output(ent); 338 } else if (S_ISDIR(ent->mode) || 339 (S_ISLNK(ent->mode) && S_ISDIR(ent->tmode))) { 340 if ((treeind = visit(ent)) < 0) { 341 ret = 1; 342 weprintf("%s%s: Already visited\n", path, ent->name); 343 return; 344 } 345 346 if (!getcwd(cwd, PATH_MAX)) 347 eprintf("getcwd:"); 348 349 if (first) 350 first = 0; 351 else 352 putchar('\n'); 353 354 lsdir(path, ent); 355 tree[treeind].ino = 0; 356 357 if (chdir(cwd) < 0) 358 eprintf("chdir %s:", cwd); 359 } 360 } 361 362 static void 363 usage(void) 364 { 365 eprintf("usage: %s [-1AacdFfHhiLlnpqRrtUu] [file ...]\n", argv0); 366 } 367 368 int 369 main(int argc, char *argv[]) 370 { 371 struct entry ent, *dents, *fents; 372 size_t i, ds, fs; 373 374 ARGBEGIN { 375 case '1': 376 /* force output to 1 entry per line */ 377 qflag = 1; 378 break; 379 case 'A': 380 Aflag = 1; 381 break; 382 case 'a': 383 aflag = 1; 384 break; 385 case 'c': 386 cflag = 1; 387 uflag = 0; 388 break; 389 case 'd': 390 dflag = 1; 391 break; 392 case 'f': 393 aflag = 1; 394 fflag = 1; 395 Uflag = 1; 396 break; 397 case 'F': 398 Fflag = 1; 399 break; 400 case 'H': 401 Hflag = 1; 402 break; 403 case 'h': 404 hflag = 1; 405 break; 406 case 'i': 407 iflag = 1; 408 break; 409 case 'L': 410 Lflag = 1; 411 break; 412 case 'l': 413 lflag = 1; 414 break; 415 case 'n': 416 lflag = 1; 417 nflag = 1; 418 break; 419 case 'p': 420 pflag = 1; 421 break; 422 case 'q': 423 qflag = 1; 424 break; 425 case 'R': 426 Rflag = 1; 427 break; 428 case 'r': 429 rflag = 1; 430 break; 431 case 'S': 432 sort = 'S'; 433 break; 434 case 't': 435 sort = 't'; 436 break; 437 case 'U': 438 Uflag = 1; 439 break; 440 case 'u': 441 uflag = 1; 442 cflag = 0; 443 break; 444 default: 445 usage(); 446 } ARGEND 447 448 switch (argc) { 449 case 0: /* fallthrough */ 450 *--argv = ".", ++argc; 451 case 1: 452 mkent(&ent, argv[0], 1, Hflag || Lflag); 453 ls("", &ent, (!dflag && S_ISDIR(ent.mode)) || 454 (S_ISLNK(ent.mode) && S_ISDIR(ent.tmode) && 455 !(dflag || Fflag || lflag))); 456 457 break; 458 default: 459 for (i = ds = fs = 0, fents = dents = NULL; i < argc; ++i) { 460 mkent(&ent, argv[i], 1, Hflag || Lflag); 461 462 if ((!dflag && S_ISDIR(ent.mode)) || 463 (S_ISLNK(ent.mode) && S_ISDIR(ent.tmode) && 464 !(dflag || Fflag || lflag))) { 465 dents = ereallocarray(dents, ++ds, sizeof(*dents)); 466 memcpy(&dents[ds - 1], &ent, sizeof(ent)); 467 } else { 468 fents = ereallocarray(fents, ++fs, sizeof(*fents)); 469 memcpy(&fents[fs - 1], &ent, sizeof(ent)); 470 } 471 } 472 473 showdirs = ds > 1 || (ds && fs); 474 475 qsort(fents, fs, sizeof(ent), entcmp); 476 qsort(dents, ds, sizeof(ent), entcmp); 477 478 for (i = 0; i < fs; ++i) 479 ls("", &fents[i], 0); 480 free(fents); 481 if (fs && ds) 482 putchar('\n'); 483 for (i = 0; i < ds; ++i) 484 ls("", &dents[i], 1); 485 free(dents); 486 } 487 488 return (fshut(stdout, "<stdout>") | ret); 489 }