ls/print.c

   1 /*
   2  * Copyright (c) 1989, 1993, 1994
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * This code is derived from software contributed to Berkeley by
   6  * Michael Fischbein.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. All advertising materials mentioning features or use of this software
  17  *    must display the following acknowledgement:
  18  *      This product includes software developed by the University of
  19  *      California, Berkeley and its contributors.
  20  * 4. Neither the name of the University nor the names of its contributors
  21  *    may be used to endorse or promote products derived from this software
  22  *    without specific prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34  * SUCH DAMAGE.
  35  */
  36
  37 #if 0
  38 #ifndef lint
  39 static char sccsid[] = "@(#)print.c     8.4 (Berkeley) 4/17/94";
  40 #endif /* not lint */
  41 #endif
  42 #include <sys/cdefs.h>
  43 __RCSID("$FreeBSD: src/bin/ls/print.c,v 1.57 2002/08/29 14:29:09 keramida Exp $");
  44
  45 #include <sys/param.h>
  46 #include <sys/stat.h>
  47 #ifdef __APPLE__
  48 #include <sys/acl.h>
  49 #include <sys/xattr.h>
  50 #include <sys/types.h>
  51 #include <grp.h>
  52 #include <pwd.h>
  53 #include <TargetConditionals.h>
  54 #if !TARGET_OS_EMBEDDED
  55 #include <membership.h>
  56 #include <membershipPriv.h>
  57 #endif
  58 #include <uuid/uuid.h>
  59 #endif
  60
  61 #include <err.h>
  62 #include <errno.h>
  63 #include <fts.h>
  64 #include <math.h>
  65 #include <langinfo.h>
  66 #include <libutil.h>
  67 #include <stdio.h>
  68 #include <stdlib.h>
  69 #include <string.h>
  70 #include <time.h>
  71 #include <unistd.h>
  72 #ifdef COLORLS
  73 #include <ctype.h>
  74 #include <termcap.h>
  75 #include <signal.h>
  76 #endif
  77 #include <stdint.h>             /* intmax_t */
  78 #include <assert.h>
  79 #ifdef __APPLE__
  80 #include <get_compat.h>
  81 #else
  82 #define COMPAT_MODE(a,b) (1)
  83 #endif /* __APPLE__ */
  84
  85 #include "ls.h"
  86 #include "extern.h"
  87
  88 static int      printaname(FTSENT *, u_long, u_long);
  89 static void     printlink(FTSENT *);
  90 static void     printtime(time_t);
  91 static int      printtype(u_int);
  92 static void     printsize(size_t, off_t);
  93 #ifdef COLORLS
  94 static void     endcolor(int);
  95 static int      colortype(mode_t);
  96 #endif
  97
  98 #define IS_NOPRINT(p)   ((p)->fts_number == NO_PRINT)
  99
 100 #ifdef COLORLS
 101 /* Most of these are taken from <sys/stat.h> */
 102 typedef enum Colors {
 103         C_DIR,                  /* directory */
 104         C_LNK,                  /* symbolic link */
 105         C_SOCK,                 /* socket */
 106         C_FIFO,                 /* pipe */
 107         C_EXEC,                 /* executable */
 108         C_BLK,                  /* block special */
 109         C_CHR,                  /* character special */
 110         C_SUID,                 /* setuid executable */
 111         C_SGID,                 /* setgid executable */
 112         C_WSDIR,                /* directory writeble to others, with sticky
 113                                  * bit */
 114         C_WDIR,                 /* directory writeble to others, without
 115                                  * sticky bit */
 116         C_NUMCOLORS             /* just a place-holder */
 117 } Colors;
 118
 119 static const char *defcolors = "exfxcxdxbxegedabagacad";
 120
 121 /* colors for file types */
 122 static struct {
 123         int     num[2];
 124         int     bold;
 125 } colors[C_NUMCOLORS];
 126 #endif
 127
 128 void
 129 printscol(DISPLAY *dp)
 130 {
 131         FTSENT *p;
 132
 133         if (COMPAT_MODE("bin/ls", "Unix2003")) {
 134                 if (dp->list->fts_level != FTS_ROOTLEVEL && (f_longform || f_size))
 135                         (void)printf("total %qu\n", (u_int64_t)howmany(dp->btotal, blocksize));
 136         }
 137
 138         for (p = dp->list; p; p = p->fts_link) {
 139                 if (IS_NOPRINT(p))
 140                         continue;
 141                 (void)printaname(p, dp->s_inode, dp->s_block);
 142                 (void)putchar('\n');
 143         }
 144 }
 145
 146 /*
 147  * print name in current style
 148  */
 149 static int
 150 printname(const char *name)
 151 {
 152         if (f_octal || f_octal_escape)
 153                 return prn_octal(name);
 154         else if (f_nonprint)
 155                 return prn_printable(name);
 156         else
 157                 return prn_normal(name);
 158 }
 159
 160 /*
 161  * print access control list
 162  */
 163 static struct {
 164         acl_perm_t      perm;
 165         char            *name;
 166         int             flags;
 167 #define ACL_PERM_DIR    (1<<0)
 168 #define ACL_PERM_FILE   (1<<1)
 169 } acl_perms[] = {
 170         {ACL_READ_DATA,         "read",         ACL_PERM_FILE},
 171         {ACL_LIST_DIRECTORY,    "list",         ACL_PERM_DIR},
 172         {ACL_WRITE_DATA,        "write",        ACL_PERM_FILE},
 173         {ACL_ADD_FILE,          "add_file",     ACL_PERM_DIR},
 174         {ACL_EXECUTE,           "execute",      ACL_PERM_FILE},
 175         {ACL_SEARCH,            "search",       ACL_PERM_DIR},
 176         {ACL_DELETE,            "delete",       ACL_PERM_FILE | ACL_PERM_DIR},
 177         {ACL_APPEND_DATA,       "append",       ACL_PERM_FILE},
 178         {ACL_ADD_SUBDIRECTORY,  "add_subdirectory", ACL_PERM_DIR},
 179         {ACL_DELETE_CHILD,      "delete_child", ACL_PERM_DIR},
 180         {ACL_READ_ATTRIBUTES,   "readattr",     ACL_PERM_FILE | ACL_PERM_DIR},
 181         {ACL_WRITE_ATTRIBUTES,  "writeattr",    ACL_PERM_FILE | ACL_PERM_DIR},
 182         {ACL_READ_EXTATTRIBUTES, "readextattr", ACL_PERM_FILE | ACL_PERM_DIR},
 183         {ACL_WRITE_EXTATTRIBUTES, "writeextattr", ACL_PERM_FILE | ACL_PERM_DIR},
 184         {ACL_READ_SECURITY,     "readsecurity", ACL_PERM_FILE | ACL_PERM_DIR},
 185         {ACL_WRITE_SECURITY,    "writesecurity", ACL_PERM_FILE | ACL_PERM_DIR},
 186         {ACL_CHANGE_OWNER,      "chown",        ACL_PERM_FILE | ACL_PERM_DIR},
 187         {0, NULL, 0}
 188 };
 189
 190 static struct {
 191         acl_flag_t      flag;
 192         char            *name;
 193         int             flags;
 194 } acl_flags[] = {
 195         {ACL_ENTRY_FILE_INHERIT,        "file_inherit",         ACL_PERM_DIR},
 196         {ACL_ENTRY_DIRECTORY_INHERIT,   "directory_inherit",    ACL_PERM_DIR},
 197         {ACL_ENTRY_LIMIT_INHERIT,       "limit_inherit",        ACL_PERM_FILE | ACL_PERM_DIR},
 198         {ACL_ENTRY_ONLY_INHERIT,        "only_inherit",         ACL_PERM_DIR},
 199         {0, NULL, 0}
 200 };
 201
 202 static char *
 203 uuid_to_name(uuid_t *uu)
 204 {
 205 #if TARGET_OS_EMBEDDED
 206   return strdup("<UNKNOWN>");
 207 #else  /* !TARGET_OS_EMBEDDED */
 208   int is_gid = -1;
 209   struct group *tgrp = NULL;
 210   struct passwd *tpass = NULL;
 211   char *name = NULL;
 212   uid_t id;
 213
 214
 215 #define MAXNAMETAG (MAXLOGNAME + 6) /* + strlen("group:") */
 216   name = (char *) malloc(MAXNAMETAG);
 217
 218   if (NULL == name)
 219           err(1, "malloc");
 220
 221         if (!f_numericonly) {
 222   if (0 != mbr_uuid_to_id(*uu, &id, &is_gid))
 223           goto errout;
 224         }
 225
 226   switch (is_gid) {
 227   case ID_TYPE_UID:
 228           tpass = getpwuid(id);
 229           if (!tpass) {
 230                   goto errout;
 231           }
 232           snprintf(name, MAXNAMETAG, "%s:%s", "user", tpass->pw_name);
 233           break;
 234   case ID_TYPE_GID:
 235           tgrp = getgrgid((gid_t) id);
 236           if (!tgrp) {
 237                   goto errout;
 238           }
 239           snprintf(name, MAXNAMETAG, "%s:%s", "group", tgrp->gr_name);
 240           break;
 241   default:
 242                 goto errout;
 243   }
 244   return name;
 245  errout:
 246   uuid_unparse_upper(*uu, name);
 247   return name;
 248 #endif  /* !TARGET_OS_EMBEDDED */
 249 }
 250
 251 static void
 252 printxattr(DISPLAY *dp, char *filename, ssize_t xattr)
 253 {
 254         int flags = XATTR_NOFOLLOW;
 255         char *buf = malloc(xattr);
 256
 257         if (NULL == buf)
 258                 err(1, "malloc");
 259         if (listxattr(filename, buf, xattr, flags) > 0) {
 260                 char *name;
 261                 for (name = buf; name < buf+xattr; name += strlen(name) + 1) {
 262                         ssize_t size = getxattr(filename, name, 0, 0, 0, flags);
 263                         putchar('\t');
 264                         printname(name);
 265                         putchar('\t');
 266                         printsize(dp->s_size, size);
 267                         putchar('\n');
 268                 }
 269         }
 270         free(buf);
 271 }
 272
 273 static void
 274 printacl(acl_t acl, int isdir)
 275 {
 276         acl_entry_t     entry = NULL;
 277         int             index;
 278         uuid_t          *applicable;
 279         char            *name = NULL;
 280         acl_tag_t       tag;
 281         acl_flagset_t   flags;
 282         acl_permset_t   perms;
 283         char            *type;
 284         int             i, first;
 285
 286
 287         for (index = 0;
 288              acl_get_entry(acl, entry == NULL ? ACL_FIRST_ENTRY : ACL_NEXT_ENTRY, &entry) == 0;
 289              index++) {
 290                 if (acl_get_tag_type(entry, &tag) != 0)
 291                         continue;
 292                 if (acl_get_flagset_np(entry, &flags) != 0)
 293                         continue;
 294                 if (acl_get_permset(entry, &perms) != 0)
 295                         continue;
 296                 if ((applicable = (uuid_t *) acl_get_qualifier(entry)) == NULL)
 297                         continue;
 298                 name = uuid_to_name(applicable);
 299                 acl_free(applicable);
 300                 switch(tag) {
 301                 case ACL_EXTENDED_ALLOW:
 302                         type = "allow";
 303                         break;
 304                 case ACL_EXTENDED_DENY:
 305                         type = "deny";
 306                         break;
 307                 default:
 308                         type = "unknown";
 309                 }
 310
 311                 (void)printf(" %d: %s%s %s ",
 312                     index,
 313                     name,
 314                     acl_get_flag_np(flags, ACL_ENTRY_INHERITED) ? " inherited" : "",
 315                     type);
 316
 317                 if (name)
 318                         free(name);
 319
 320                 for (i = 0, first = 0; acl_perms[i].name != NULL; i++) {
 321                         if (acl_get_perm_np(perms, acl_perms[i].perm) == 0)
 322                                 continue;
 323                         if (!(acl_perms[i].flags & (isdir ? ACL_PERM_DIR : ACL_PERM_FILE)))
 324                                 continue;
 325                         (void)printf("%s%s", first++ ? "," : "", acl_perms[i].name);
 326                 }
 327                 for (i = 0; acl_flags[i].name != NULL; i++) {
 328                         if (acl_get_flag_np(flags, acl_flags[i].flag) == 0)
 329                                 continue;
 330                         if (!(acl_flags[i].flags & (isdir ? ACL_PERM_DIR : ACL_PERM_FILE)))
 331                                 continue;
 332                         (void)printf("%s%s", first++ ? "," : "", acl_flags[i].name);
 333                 }
 334
 335                 (void)putchar('\n');
 336         }
 337
 338 }
 339
 340 void
 341 printlong(DISPLAY *dp)
 342 {
 343         struct stat *sp;
 344         FTSENT *p;
 345         NAMES *np;
 346         char buf[20];
 347 #ifdef __APPLE__
 348         acl_t acl = NULL;
 349         acl_entry_t dummy;
 350         char full_path[MAXPATHLEN];
 351         char *filename;
 352         ssize_t xattr = 0;
 353         char str[2];
 354 #endif
 355 #ifdef COLORLS
 356         int color_printed = 0;
 357 #endif
 358
 359         if (dp->list->fts_level != FTS_ROOTLEVEL && (f_longform || f_size))
 360                 (void)printf("total %qu\n", (u_int64_t)howmany(dp->btotal, blocksize));
 361
 362         for (p = dp->list; p; p = p->fts_link) {
 363                 if (IS_NOPRINT(p))
 364                         continue;
 365                 sp = p->fts_statp;
 366                 if (f_inode)
 367 #if _DARWIN_FEATURE_64_BIT_INODE
 368                         (void)printf("%*llu ", dp->s_inode, (u_quad_t)sp->st_ino);
 369 #else
 370                         (void)printf("%*lu ", dp->s_inode, (u_long)sp->st_ino);
 371 #endif
 372                 if (f_size)
 373                         (void)printf("%*qu ",
 374                             dp->s_block, (u_int64_t)howmany(sp->st_blocks, blocksize));
 375                 strmode(sp->st_mode, buf);
 376                 np = p->fts_pointer;
 377 #ifdef __APPLE__
 378                 buf[10] = '\0'; /* make +/@ abut the mode */
 379                 filename = p->fts_name;
 380                 if (p->fts_level != FTS_ROOTLEVEL)
 381                 {
 382                     snprintf(full_path, sizeof full_path, "%s/%s",
 383                             p->fts_parent->fts_accpath, p->fts_name);
 384                     filename = full_path;
 385                 }
 386                 /* symlinks can not have ACLs */
 387                 acl = acl_get_link_np(filename, ACL_TYPE_EXTENDED);
 388                 if (acl && acl_get_entry(acl, ACL_FIRST_ENTRY, &dummy) == -1) {
 389                         acl_free(acl);
 390                         acl = NULL;
 391                 }
 392                 xattr = listxattr(filename, NULL, 0, XATTR_NOFOLLOW);
 393                 if (xattr < 0)
 394                         xattr = 0;
 395                 str[1] = '\0';
 396                 if (xattr > 0)
 397                         str[0] = '@';
 398                 else if (acl != NULL)
 399                         str[0] = '+';
 400                 else
 401                         str[0] = ' ';
 402 #endif /* __APPLE__ */
 403                 if (f_group && f_owner) {       /* means print neither */
 404 #ifdef __APPLE__
 405                         (void)printf("%s%s %*u   ", buf, str, dp->s_nlink,
 406                                      sp->st_nlink);
 407 #else  /* ! __APPLE__ */
 408                         (void)printf("%s %*u   ", buf, dp->s_nlink,
 409                                      sp->st_nlink);
 410 #endif /* __APPLE__ */
 411                 }
 412                 else if (f_group) {
 413 #ifdef __APPLE__
 414                         (void)printf("%s%s %*u %-*s  ", buf, str, dp->s_nlink,
 415                                      sp->st_nlink, dp->s_group, np->group);
 416 #else  /* ! __APPLE__ */
 417                         (void)printf("%s %*u %-*s  ", buf, dp->s_nlink,
 418                                      sp->st_nlink, dp->s_group, np->group);
 419 #endif /* __APPLE__ */
 420                 }
 421                 else if (f_owner) {
 422 #ifdef __APPLE__
 423                         (void)printf("%s%s %*u %-*s  ", buf, str, dp->s_nlink,
 424                                      sp->st_nlink, dp->s_user, np->user);
 425 #else  /* ! __APPLE__ */
 426                         (void)printf("%s %*u %-*s  ", buf, dp->s_nlink,
 427                                      sp->st_nlink, dp->s_user, np->user);
 428 #endif /* __APPLE__ */
 429                 }
 430                 else {
 431 #ifdef __APPLE__
 432                         (void)printf("%s%s %*u %-*s  %-*s  ", buf, str, dp->s_nlink,
 433                                      sp->st_nlink, dp->s_user, np->user, dp->s_group,
 434                                      np->group);
 435 #else  /* ! __APPLE__ */
 436                         (void)printf("%s %*u %-*s  %-*s  ", buf, dp->s_nlink,
 437                                      sp->st_nlink, dp->s_user, np->user, dp->s_group,
 438                                      np->group);
 439 #endif /* ! __APPLE__ */
 440                 }
 441                 if (f_flags)
 442                         (void)printf("%-*s ", dp->s_flags, np->flags);
 443                 if (S_ISCHR(sp->st_mode) || S_ISBLK(sp->st_mode))
 444                         if (minor(sp->st_rdev) > 255 || minor(sp->st_rdev) < 0)
 445                                 (void)printf("%3d, 0x%08x ",
 446                                     major(sp->st_rdev),
 447                                     (u_int)minor(sp->st_rdev));
 448                         else
 449                                 (void)printf("%3d, %3d ",
 450                                     major(sp->st_rdev), minor(sp->st_rdev));
 451                 else if (dp->bcfile)
 452                         (void)printf("%*s%*qu ",
 453                             8 - dp->s_size, "", dp->s_size, (u_int64_t)sp->st_size);
 454                 else
 455                         printsize(dp->s_size, sp->st_size);
 456                 if (f_accesstime)
 457                         printtime(sp->st_atime);
 458                 else if (f_statustime)
 459                         printtime(sp->st_ctime);
 460                 else if (f_birthtime)
 461                         printtime(sp->st_birthtime);
 462                 else
 463                         printtime(sp->st_mtime);
 464 #ifdef COLORLS
 465                 if (f_color)
 466                         color_printed = colortype(sp->st_mode);
 467 #endif
 468                 (void)printname(p->fts_name);
 469 #ifdef COLORLS
 470                 if (f_color && color_printed)
 471                         endcolor(0);
 472 #endif
 473                 if (f_type)
 474                         (void)printtype(sp->st_mode);
 475                 if (S_ISLNK(sp->st_mode))
 476                         printlink(p);
 477                 (void)putchar('\n');
 478 #ifdef __APPLE__
 479                 if (f_xattr && xattr) {
 480                         printxattr(dp, filename, xattr);
 481                 }
 482                 if (acl != NULL) {
 483                         if (f_acl)
 484                                 printacl(acl, S_ISDIR(sp->st_mode));
 485                         acl_free(acl);
 486                         acl = NULL;
 487                 }
 488 #endif /* __APPLE__ */
 489         }
 490 }
 491
 492 void
 493 printstream(DISPLAY *dp)
 494 {
 495         FTSENT *p;
 496         extern int termwidth;
 497         int chcnt;
 498
 499         for (p = dp->list, chcnt = 0; p; p = p->fts_link) {
 500                 if (p->fts_number == NO_PRINT)
 501                         continue;
 502                 if (strlen(p->fts_name) + chcnt +
 503                     (p->fts_link ? 2 : 0) >= (unsigned)termwidth) {
 504                         putchar('\n');
 505                         chcnt = 0;
 506                 }
 507                 chcnt += printaname(p, dp->s_inode, dp->s_block);
 508                 if (p->fts_link) {
 509                         printf(", ");
 510                         chcnt += 2;
 511                 }
 512         }
 513         if (chcnt)
 514                 putchar('\n');
 515 }
 516
 517 void
 518 printcol(DISPLAY *dp)
 519 {
 520         extern int termwidth;
 521         static FTSENT **array;
 522         static int lastentries = -1;
 523         FTSENT *p;
 524         int base;
 525         int chcnt;
 526         int cnt;
 527         int col;
 528         int colwidth;
 529         int endcol;
 530         int num;
 531         int numcols;
 532         int numrows;
 533         int row;
 534         int tabwidth;
 535
 536         if (f_notabs)
 537                 tabwidth = 1;
 538         else
 539                 tabwidth = 8;
 540
 541         /*
 542          * Have to do random access in the linked list -- build a table
 543          * of pointers.
 544          */
 545         if ((lastentries == -1) || (dp->entries > lastentries)) {
 546                 lastentries = dp->entries;
 547                 if ((array =
 548                     realloc(array, dp->entries * sizeof(FTSENT *))) == NULL) {
 549                         warn(NULL);
 550                         printscol(dp);
 551                 }
 552         }
 553         for (p = dp->list, num = 0; p; p = p->fts_link)
 554                 if (p->fts_number != NO_PRINT)
 555                         array[num++] = p;
 556
 557         colwidth = dp->maxlen;
 558         if (f_inode)
 559                 colwidth += dp->s_inode + 1;
 560         if (f_size)
 561                 colwidth += dp->s_block + 1;
 562         if (f_type)
 563                 colwidth += 1;
 564
 565         colwidth = (colwidth + tabwidth) & ~(tabwidth - 1);
 566         if (termwidth < 2 * colwidth) {
 567                 printscol(dp);
 568                 return;
 569         }
 570         numcols = termwidth / colwidth;
 571         numrows = num / numcols;
 572         if (num % numcols)
 573                 ++numrows;
 574
 575         assert(dp->list);
 576         if (dp->list->fts_level != FTS_ROOTLEVEL && (f_longform || f_size))
 577                 (void)printf("total %qu\n", (u_int64_t)howmany(dp->btotal, blocksize));
 578
 579         base = 0;
 580         for (row = 0; row < numrows; ++row) {
 581                 endcol = colwidth;
 582                 if (!f_sortacross)
 583                         base = row;
 584                 for (col = 0, chcnt = 0; col < numcols; ++col) {
 585                         chcnt += printaname(array[base], dp->s_inode,
 586                             dp->s_block);
 587                         if (f_sortacross)
 588                                 base++;
 589                         else
 590                                 base += numrows;
 591                         if (base >= num)
 592                                 break;
 593                         while ((cnt = ((chcnt + tabwidth) & ~(tabwidth - 1)))
 594                             <= endcol) {
 595                                 if (f_sortacross && col + 1 >= numcols)
 596                                         break;
 597                                 (void)putchar(f_notabs ? ' ' : '\t');
 598                                 chcnt = cnt;
 599                         }
 600                         endcol += colwidth;
 601                 }
 602                 (void)putchar('\n');
 603         }
 604 }
 605
 606 /*
 607  * print [inode] [size] name
 608  * return # of characters printed, no trailing characters.
 609  */
 610 static int
 611 printaname(FTSENT *p, u_long inodefield, u_long sizefield)
 612 {
 613         struct stat *sp;
 614         int chcnt;
 615 #ifdef COLORLS
 616         int color_printed = 0;
 617 #endif
 618
 619         sp = p->fts_statp;
 620         chcnt = 0;
 621         if (f_inode)
 622 #if _DARWIN_FEATURE_64_BIT_INODE
 623                 chcnt += printf("%*llu ", (int)inodefield, (u_quad_t)sp->st_ino);
 624 #else
 625                 chcnt += printf("%*lu ", (int)inodefield, (u_long)sp->st_ino);
 626 #endif
 627         if (f_size)
 628                 chcnt += printf("%*qu ",
 629                     (int)sizefield, (u_int64_t)howmany(sp->st_blocks, blocksize));
 630 #ifdef COLORLS
 631         if (f_color)
 632                 color_printed = colortype(sp->st_mode);
 633 #endif
 634         chcnt += printname(p->fts_name);
 635 #ifdef COLORLS
 636         if (f_color && color_printed)
 637                 endcolor(0);
 638 #endif
 639         if (f_type)
 640                 chcnt += printtype(sp->st_mode);
 641         return (chcnt);
 642 }
 643
 644 static void
 645 printtime(time_t ftime)
 646 {
 647         char longstring[80];
 648         static time_t now;
 649         const char *format;
 650         static int d_first = -1;
 651
 652         if (d_first < 0)
 653                 d_first = (*nl_langinfo(D_MD_ORDER) == 'd');
 654         if (now == 0)
 655                 now = time(NULL);
 656
 657 #define SIXMONTHS       ((365 / 2) * 86400)
 658         if (f_sectime)
 659                 /* mmm dd hh:mm:ss yyyy || dd mmm hh:mm:ss yyyy */
 660                 format = d_first ? "%e %b %T %Y " : "%b %e %T %Y ";
 661         else if (COMPAT_MODE("bin/ls", "Unix2003")) {
 662                 if (ftime + SIXMONTHS > now && ftime <= now)
 663                         /* mmm dd hh:mm || dd mmm hh:mm */
 664                         format = d_first ? "%e %b %R " : "%b %e %R ";
 665                 else
 666                         /* mmm dd  yyyy || dd mmm  yyyy */
 667                         format = d_first ? "%e %b  %Y " : "%b %e  %Y ";
 668         }
 669         else if (ftime + SIXMONTHS > now && ftime < now + SIXMONTHS)
 670                 /* mmm dd hh:mm || dd mmm hh:mm */
 671                 format = d_first ? "%e %b %R " : "%b %e %R ";
 672         else
 673                 /* mmm dd  yyyy || dd mmm  yyyy */
 674                 format = d_first ? "%e %b  %Y " : "%b %e  %Y ";
 675         strftime(longstring, sizeof(longstring), format, localtime(&ftime));
 676         fputs(longstring, stdout);
 677 }
 678
 679 static int
 680 printtype(u_int mode)
 681 {
 682
 683         if (f_slash) {
 684                 if ((mode & S_IFMT) == S_IFDIR) {
 685                         (void)putchar('/');
 686                         return (1);
 687                 }
 688                 return (0);
 689         }
 690
 691         switch (mode & S_IFMT) {
 692         case S_IFDIR:
 693                 (void)putchar('/');
 694                 return (1);
 695         case S_IFIFO:
 696                 (void)putchar('|');
 697                 return (1);
 698         case S_IFLNK:
 699                 (void)putchar('@');
 700                 return (1);
 701         case S_IFSOCK:
 702                 (void)putchar('=');
 703                 return (1);
 704         case S_IFWHT:
 705                 (void)putchar('%');
 706                 return (1);
 707         default:
 708                 break;
 709         }
 710         if (mode & (S_IXUSR | S_IXGRP | S_IXOTH)) {
 711                 (void)putchar('*');
 712                 return (1);
 713         }
 714         return (0);
 715 }
 716
 717 #ifdef COLORLS
 718 static int
 719 putch(int c)
 720 {
 721         (void)putchar(c);
 722         return 0;
 723 }
 724
 725 static int
 726 writech(int c)
 727 {
 728         char tmp = c;
 729
 730         (void)write(STDOUT_FILENO, &tmp, 1);
 731         return 0;
 732 }
 733
 734 static void
 735 printcolor(Colors c)
 736 {
 737         char *ansiseq;
 738
 739         if (colors[c].bold)
 740                 tputs(enter_bold, 1, putch);
 741
 742         if (colors[c].num[0] != -1) {
 743                 ansiseq = tgoto(ansi_fgcol, 0, colors[c].num[0]);
 744                 if (ansiseq)
 745                         tputs(ansiseq, 1, putch);
 746         }
 747         if (colors[c].num[1] != -1) {
 748                 ansiseq = tgoto(ansi_bgcol, 0, colors[c].num[1]);
 749                 if (ansiseq)
 750                         tputs(ansiseq, 1, putch);
 751         }
 752 }
 753
 754 static void
 755 endcolor(int sig)
 756 {
 757         tputs(ansi_coloff, 1, sig ? writech : putch);
 758         tputs(attrs_off, 1, sig ? writech : putch);
 759 }
 760
 761 static int
 762 colortype(mode_t mode)
 763 {
 764         switch (mode & S_IFMT) {
 765         case S_IFDIR:
 766                 if (mode & S_IWOTH)
 767                         if (mode & S_ISTXT)
 768                                 printcolor(C_WSDIR);
 769                         else
 770                                 printcolor(C_WDIR);
 771                 else
 772                         printcolor(C_DIR);
 773                 return (1);
 774         case S_IFLNK:
 775                 printcolor(C_LNK);
 776                 return (1);
 777         case S_IFSOCK:
 778                 printcolor(C_SOCK);
 779                 return (1);
 780         case S_IFIFO:
 781                 printcolor(C_FIFO);
 782                 return (1);
 783         case S_IFBLK:
 784                 printcolor(C_BLK);
 785                 return (1);
 786         case S_IFCHR:
 787                 printcolor(C_CHR);
 788                 return (1);
 789         }
 790         if (mode & (S_IXUSR | S_IXGRP | S_IXOTH)) {
 791                 if (mode & S_ISUID)
 792                         printcolor(C_SUID);
 793                 else if (mode & S_ISGID)
 794                         printcolor(C_SGID);
 795                 else
 796                         printcolor(C_EXEC);
 797                 return (1);
 798         }
 799         return (0);
 800 }
 801
 802 void
 803 parsecolors(const char *cs)
 804 {
 805         int i;
 806         int j;
 807         int len;
 808         char c[2];
 809         short legacy_warn = 0;
 810
 811         if (cs == NULL)
 812                 cs = "";        /* LSCOLORS not set */
 813         len = strlen(cs);
 814         for (i = 0; i < C_NUMCOLORS; i++) {
 815                 colors[i].bold = 0;
 816
 817                 if (len <= 2 * i) {
 818                         c[0] = defcolors[2 * i];
 819                         c[1] = defcolors[2 * i + 1];
 820                 } else {
 821                         c[0] = cs[2 * i];
 822                         c[1] = cs[2 * i + 1];
 823                 }
 824                 for (j = 0; j < 2; j++) {
 825                         /* Legacy colours used 0-7 */
 826                         if (c[j] >= '0' && c[j] <= '7') {
 827                                 colors[i].num[j] = c[j] - '0';
 828                                 if (!legacy_warn) {
 829                                         fprintf(stderr,
 830                                             "warn: LSCOLORS should use "
 831                                             "characters a-h instead of 0-9 ("
 832                                             "see the manual page)\n");
 833                                 }
 834                                 legacy_warn = 1;
 835                         } else if (c[j] >= 'a' && c[j] <= 'h')
 836                                 colors[i].num[j] = c[j] - 'a';
 837                         else if (c[j] >= 'A' && c[j] <= 'H') {
 838                                 colors[i].num[j] = c[j] - 'A';
 839                                 colors[i].bold = 1;
 840                         } else if (tolower((unsigned char)c[j] == 'x'))
 841                                 colors[i].num[j] = -1;
 842                         else {
 843                                 fprintf(stderr,
 844                                     "error: invalid character '%c' in LSCOLORS"
 845                                     " env var\n", c[j]);
 846                                 colors[i].num[j] = -1;
 847                         }
 848                 }
 849         }
 850 }
 851
 852 void
 853 colorquit(int sig)
 854 {
 855         endcolor(sig);
 856
 857         (void)signal(sig, SIG_DFL);
 858         (void)kill(getpid(), sig);
 859 }
 860
 861 #endif /* COLORLS */
 862
 863 static void
 864 printlink(FTSENT *p)
 865 {
 866         int lnklen;
 867         char name[MAXPATHLEN + 1];
 868         char path[MAXPATHLEN + 1];
 869
 870         if (p->fts_level == FTS_ROOTLEVEL)
 871                 (void)snprintf(name, sizeof(name), "%s", p->fts_name);
 872         else
 873                 (void)snprintf(name, sizeof(name),
 874                     "%s/%s", p->fts_parent->fts_accpath, p->fts_name);
 875         if ((lnklen = readlink(name, path, sizeof(path) - 1)) == -1) {
 876                 (void)fprintf(stderr, "\nls: %s: %s\n", name, strerror(errno));
 877                 return;
 878         }
 879         path[lnklen] = '\0';
 880         (void)printf(" -> ");
 881         (void)printname(path);
 882 }
 883
 884 static void
 885 printsize(size_t width, off_t bytes)
 886 {
 887
 888   if (f_humanval) {
 889     char buf[5];
 890
 891     humanize_number(buf, sizeof(buf), (int64_t)bytes, "",
 892                     HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL);
 893     (void)printf("%5s ", buf);
 894   } else
 895     (void)printf("%*jd ", (u_int)width, (intmax_t)bytes);
 896 }