print.c revision 1.36 1 /* $NetBSD: print.c,v 1.36 2003/09/14 19:16:06 jschauma Exp $ */
2
3 /*
4 * Copyright (c) 1989, 1993, 1994
5 * The Regents of the University of California. All rights reserved.
6 *
7 * This code is derived from software contributed to Berkeley by
8 * Michael Fischbein.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * 3. Neither the name of the University nor the names of its contributors
19 * may be used to endorse or promote products derived from this software
20 * without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 */
34
35 #include <sys/cdefs.h>
36 #ifndef lint
37 #if 0
38 static char sccsid[] = "@(#)print.c 8.5 (Berkeley) 7/28/94";
39 #else
40 __RCSID("$NetBSD: print.c,v 1.36 2003/09/14 19:16:06 jschauma Exp $");
41 #endif
42 #endif /* not lint */
43
44 #include <sys/param.h>
45 #include <sys/stat.h>
46
47 #include <err.h>
48 #include <errno.h>
49 #include <fts.h>
50 #include <grp.h>
51 #include <pwd.h>
52 #include <stdio.h>
53 #include <stdlib.h>
54 #include <string.h>
55 #include <time.h>
56 #include <tzfile.h>
57 #include <unistd.h>
58
59 #include "ls.h"
60 #include "extern.h"
61
62 extern int termwidth;
63
64 static int printaname(FTSENT *, int, int);
65 static void printlink(FTSENT *);
66 static void printtime(time_t);
67 static int printtype(u_int);
68
69 static time_t now;
70
71 #define IS_NOPRINT(p) ((p)->fts_number == NO_PRINT)
72
73 void
74 printscol(DISPLAY *dp)
75 {
76 FTSENT *p;
77
78 for (p = dp->list; p; p = p->fts_link) {
79 if (IS_NOPRINT(p))
80 continue;
81 (void)printaname(p, dp->s_inode, dp->s_block);
82 (void)putchar('\n');
83 }
84 }
85
86 void
87 printlong(DISPLAY *dp)
88 {
89 struct stat *sp;
90 FTSENT *p;
91 NAMES *np;
92 char buf[20];
93
94 now = time(NULL);
95
96 if (dp->list->fts_level != FTS_ROOTLEVEL && (f_longform || f_size))
97 (void)printf("total %llu\n",
98 (long long)(howmany(dp->btotal, blocksize)));
99
100 for (p = dp->list; p; p = p->fts_link) {
101 if (IS_NOPRINT(p))
102 continue;
103 sp = p->fts_statp;
104 if (f_inode)
105 (void)printf("%*lu ", dp->s_inode,
106 (unsigned long)sp->st_ino);
107 if (f_size)
108 (void)printf("%*llu ", dp->s_block,
109 (long long)howmany(sp->st_blocks, blocksize));
110 (void)strmode(sp->st_mode, buf);
111 np = p->fts_pointer;
112 (void)printf("%s %*lu ", buf, dp->s_nlink,
113 (unsigned long)sp->st_nlink);
114 if (!f_grouponly)
115 (void)printf("%-*s ", dp->s_user, np->user);
116 (void)printf("%-*s ", dp->s_group, np->group);
117 if (f_flags)
118 (void)printf("%-*s ", dp->s_flags, np->flags);
119 if (S_ISCHR(sp->st_mode) || S_ISBLK(sp->st_mode))
120 (void)printf("%*u, %*u ",
121 dp->s_major, major(sp->st_rdev), dp->s_minor,
122 minor(sp->st_rdev));
123 else
124 (void)printf("%*llu ", dp->s_size,
125 (long long)sp->st_size);
126 if (f_accesstime)
127 printtime(sp->st_atime);
128 else if (f_statustime)
129 printtime(sp->st_ctime);
130 else
131 printtime(sp->st_mtime);
132 if (f_escape)
133 (void)safe_print(p->fts_name);
134 else if (f_nonprint)
135 (void)printescaped(p->fts_name);
136 else
137 (void)printf("%s", p->fts_name);
138
139 if (f_type || (f_typedir && S_ISDIR(sp->st_mode)))
140 (void)printtype(sp->st_mode);
141 if (S_ISLNK(sp->st_mode))
142 printlink(p);
143 (void)putchar('\n');
144 }
145 }
146
147 void
148 printcol(DISPLAY *dp)
149 {
150 static FTSENT **array;
151 static int lastentries = -1;
152 FTSENT *p;
153 int base, chcnt, col, colwidth, num;
154 int numcols, numrows, row;
155
156 colwidth = dp->maxlen;
157 if (f_inode)
158 colwidth += dp->s_inode + 1;
159 if (f_size)
160 colwidth += dp->s_block + 1;
161 if (f_type || f_typedir)
162 colwidth += 1;
163
164 colwidth += 1;
165
166 if (termwidth < 2 * colwidth) {
167 printscol(dp);
168 return;
169 }
170
171 /*
172 * Have to do random access in the linked list -- build a table
173 * of pointers.
174 */
175 if (dp->entries > lastentries) {
176 lastentries = dp->entries;
177 if ((array =
178 realloc(array, dp->entries * sizeof(FTSENT *))) == NULL) {
179 warn(NULL);
180 printscol(dp);
181 }
182 }
183 for (p = dp->list, num = 0; p; p = p->fts_link)
184 if (p->fts_number != NO_PRINT)
185 array[num++] = p;
186
187 numcols = termwidth / colwidth;
188 colwidth = termwidth / numcols; /* spread out if possible */
189 numrows = num / numcols;
190 if (num % numcols)
191 ++numrows;
192
193 if (dp->list->fts_level != FTS_ROOTLEVEL && (f_longform || f_size))
194 (void)printf("total %llu\n",
195 (long long)(howmany(dp->btotal, blocksize)));
196 for (row = 0; row < numrows; ++row) {
197 for (base = row, chcnt = col = 0; col < numcols; ++col) {
198 chcnt = printaname(array[base], dp->s_inode,
199 dp->s_block);
200 if ((base += numrows) >= num)
201 break;
202 while (chcnt++ < colwidth)
203 (void)putchar(' ');
204 }
205 (void)putchar('\n');
206 }
207 }
208
209 void
210 printacol(DISPLAY *dp)
211 {
212 FTSENT *p;
213 int chcnt, col, colwidth;
214 int numcols;
215
216 colwidth = dp->maxlen;
217 if (f_inode)
218 colwidth += dp->s_inode + 1;
219 if (f_size)
220 colwidth += dp->s_block + 1;
221 if (f_type || f_typedir)
222 colwidth += 1;
223
224 colwidth += 1;
225
226 if (termwidth < 2 * colwidth) {
227 printscol(dp);
228 return;
229 }
230
231 numcols = termwidth / colwidth;
232 colwidth = termwidth / numcols; /* spread out if possible */
233
234 if (dp->list->fts_level != FTS_ROOTLEVEL && (f_longform || f_size))
235 (void)printf("total %llu\n",
236 (long long)(howmany(dp->btotal, blocksize)));
237 chcnt = col = 0;
238 for (p = dp->list; p; p = p->fts_link) {
239 if (IS_NOPRINT(p))
240 continue;
241 if (col >= numcols) {
242 chcnt = col = 0;
243 (void)putchar('\n');
244 }
245 chcnt = printaname(p, dp->s_inode, dp->s_block);
246 while (chcnt++ < colwidth)
247 (void)putchar(' ');
248 col++;
249 }
250 (void)putchar('\n');
251 }
252
253 void
254 printstream(DISPLAY *dp)
255 {
256 FTSENT *p;
257 int col;
258 int extwidth;
259
260 extwidth = 0;
261 if (f_inode)
262 extwidth += dp->s_inode + 1;
263 if (f_size)
264 extwidth += dp->s_block + 1;
265 if (f_type)
266 extwidth += 1;
267
268 for (col = 0, p = dp->list; p != NULL; p = p->fts_link) {
269 if (IS_NOPRINT(p))
270 continue;
271 if (col > 0) {
272 (void)putchar(','), col++;
273 if (col + 1 + extwidth + p->fts_namelen >= termwidth)
274 (void)putchar('\n'), col = 0;
275 else
276 (void)putchar(' '), col++;
277 }
278 col += printaname(p, dp->s_inode, dp->s_block);
279 }
280 (void)putchar('\n');
281 }
282
283 /*
284 * print [inode] [size] name
285 * return # of characters printed, no trailing characters.
286 */
287 static int
288 printaname(FTSENT *p, int inodefield, int sizefield)
289 {
290 struct stat *sp;
291 int chcnt;
292
293 sp = p->fts_statp;
294 chcnt = 0;
295 if (f_inode)
296 chcnt += printf("%*lu ", inodefield, (unsigned long)sp->st_ino);
297 if (f_size)
298 chcnt += printf("%*llu ", sizefield,
299 (long long)howmany(sp->st_blocks, blocksize));
300 if (f_escape)
301 chcnt += safe_print(p->fts_name);
302 else if (f_nonprint)
303 chcnt += printescaped(p->fts_name);
304 else
305 chcnt += printf("%s", p->fts_name);
306 if (f_type || (f_typedir && S_ISDIR(sp->st_mode)))
307 chcnt += printtype(sp->st_mode);
308 return (chcnt);
309 }
310
311 static void
312 printtime(time_t ftime)
313 {
314 int i;
315 char *longstring;
316
317 longstring = ctime(&ftime);
318 for (i = 4; i < 11; ++i)
319 (void)putchar(longstring[i]);
320
321 #define SIXMONTHS ((DAYSPERNYEAR / 2) * SECSPERDAY)
322 if (f_sectime)
323 for (i = 11; i < 24; i++)
324 (void)putchar(longstring[i]);
325 else if (ftime + SIXMONTHS > now && ftime - SIXMONTHS < now)
326 for (i = 11; i < 16; ++i)
327 (void)putchar(longstring[i]);
328 else {
329 (void)putchar(' ');
330 for (i = 20; i < 24; ++i)
331 (void)putchar(longstring[i]);
332 }
333 (void)putchar(' ');
334 }
335
336 static int
337 printtype(u_int mode)
338 {
339 switch (mode & S_IFMT) {
340 case S_IFDIR:
341 (void)putchar('/');
342 return (1);
343 case S_IFIFO:
344 (void)putchar('|');
345 return (1);
346 case S_IFLNK:
347 (void)putchar('@');
348 return (1);
349 case S_IFSOCK:
350 (void)putchar('=');
351 return (1);
352 case S_IFWHT:
353 (void)putchar('%');
354 return (1);
355 }
356 if (mode & (S_IXUSR | S_IXGRP | S_IXOTH)) {
357 (void)putchar('*');
358 return (1);
359 }
360 return (0);
361 }
362
363 static void
364 printlink(FTSENT *p)
365 {
366 int lnklen;
367 char name[MAXPATHLEN + 1], path[MAXPATHLEN + 1];
368
369 if (p->fts_level == FTS_ROOTLEVEL)
370 (void)snprintf(name, sizeof(name), "%s", p->fts_name);
371 else
372 (void)snprintf(name, sizeof(name),
373 "%s/%s", p->fts_parent->fts_accpath, p->fts_name);
374 if ((lnklen = readlink(name, path, sizeof(path) - 1)) == -1) {
375 (void)fprintf(stderr, "\nls: %s: %s\n", name, strerror(errno));
376 return;
377 }
378 path[lnklen] = '\0';
379 (void)printf(" -> ");
380 if (f_escape)
381 (void)safe_print(path);
382 else if (f_nonprint)
383 (void)printescaped(path);
384 else
385 (void)printf("%s", path);
386 }
387