Commit | Line | Data |
---|---|---|
984263bc MD |
1 | /*- |
2 | * Copyright (c) 1992 Keith Muller. | |
3 | * Copyright (c) 1992, 1993 | |
4 | * The Regents of the University of California. All rights reserved. | |
5 | * | |
6 | * This code is derived from software contributed to Berkeley by | |
7 | * Keith Muller of the University of California, San Diego. | |
8 | * | |
9 | * Redistribution and use in source and binary forms, with or without | |
10 | * modification, are permitted provided that the following conditions | |
11 | * are met: | |
12 | * 1. Redistributions of source code must retain the above copyright | |
13 | * notice, this list of conditions and the following disclaimer. | |
14 | * 2. Redistributions in binary form must reproduce the above copyright | |
15 | * notice, this list of conditions and the following disclaimer in the | |
16 | * documentation and/or other materials provided with the distribution. | |
dc71b7ab | 17 | * 3. Neither the name of the University nor the names of its contributors |
984263bc MD |
18 | * may be used to endorse or promote products derived from this software |
19 | * without specific prior written permission. | |
20 | * | |
21 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | |
22 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
23 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
24 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | |
25 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
26 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | |
27 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
28 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | |
29 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | |
30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | |
31 | * SUCH DAMAGE. | |
1de703da MD |
32 | * |
33 | * @(#)gen_subs.c 8.1 (Berkeley) 5/31/93 | |
34 | * $FreeBSD: src/bin/pax/gen_subs.c,v 1.12.2.4 2002/03/12 17:49:17 phantom Exp $ | |
984263bc MD |
35 | */ |
36 | ||
984263bc MD |
37 | #include <sys/types.h> |
38 | #include <sys/time.h> | |
39 | #include <sys/stat.h> | |
9e6611d4 | 40 | #include <grp.h> |
984263bc | 41 | #include <langinfo.h> |
9e6611d4 | 42 | #include <pwd.h> |
984263bc | 43 | #include <stdio.h> |
984263bc MD |
44 | #include <stdlib.h> |
45 | #include <string.h> | |
9e6611d4 | 46 | #include <unistd.h> |
984263bc MD |
47 | #include "pax.h" |
48 | #include "extern.h" | |
49 | ||
50 | /* | |
51 | * a collection of general purpose subroutines used by pax | |
52 | */ | |
53 | ||
54 | /* | |
55 | * constants used by ls_list() when printing out archive members | |
56 | */ | |
57 | #define MODELEN 20 | |
58 | #define DATELEN 64 | |
59 | #define SIXMONTHS ((365 / 2) * 86400) | |
60 | #define CURFRMTM "%b %e %H:%M" | |
61 | #define OLDFRMTM "%b %e %Y" | |
62 | #define CURFRMTD "%e %b %H:%M" | |
63 | #define OLDFRMTD "%e %b %Y" | |
984263bc MD |
64 | |
65 | static int d_first = -1; | |
66 | ||
67 | /* | |
68 | * ls_list() | |
69 | * list the members of an archive in ls format | |
70 | */ | |
71 | ||
984263bc | 72 | void |
86a586bb | 73 | ls_list(ARCHD *arcn, time_t now, FILE *fp) |
984263bc | 74 | { |
86a586bb | 75 | struct stat *sbp; |
984263bc MD |
76 | char f_mode[MODELEN]; |
77 | char f_date[DATELEN]; | |
78 | char *timefrmt; | |
9e6611d4 | 79 | const char *user, *group; |
984263bc MD |
80 | |
81 | /* | |
82 | * if not verbose, just print the file name | |
83 | */ | |
84 | if (!vflag) { | |
57fed2af EN |
85 | fprintf(fp, "%s\n", arcn->name); |
86 | fflush(fp); | |
984263bc MD |
87 | return; |
88 | } | |
89 | ||
90 | if (d_first < 0) | |
91 | d_first = (*nl_langinfo(D_MD_ORDER) == 'd'); | |
92 | /* | |
93 | * user wants long mode | |
94 | */ | |
95 | sbp = &(arcn->sb); | |
96 | strmode(sbp->st_mode, f_mode); | |
97 | ||
98 | /* | |
99 | * time format based on age compared to the time pax was started. | |
100 | */ | |
101 | if ((sbp->st_mtime + SIXMONTHS) <= now) | |
102 | timefrmt = d_first ? OLDFRMTD : OLDFRMTM; | |
103 | else | |
104 | timefrmt = d_first ? CURFRMTD : CURFRMTM; | |
105 | ||
106 | /* | |
107 | * print file mode, link count, uid, gid and time | |
108 | */ | |
109 | if (strftime(f_date,DATELEN,timefrmt,localtime(&(sbp->st_mtime))) == 0) | |
110 | f_date[0] = '\0'; | |
9e6611d4 SW |
111 | user = user_from_uid(sbp->st_uid, 0); |
112 | group = group_from_gid(sbp->st_gid, 0); | |
c3762235 | 113 | fprintf(fp, "%s%2u %-16s %-6s ", f_mode, sbp->st_nlink, |
9e6611d4 | 114 | user ? user : "", group ? group : ""); |
984263bc MD |
115 | |
116 | /* | |
117 | * print device id's for devices, or sizes for other nodes | |
118 | */ | |
119 | if ((arcn->type == PAX_CHR) || (arcn->type == PAX_BLK)) | |
57fed2af | 120 | fprintf(fp, "%4lu,%4lu ", (unsigned long)MAJOR(sbp->st_rdev), |
984263bc | 121 | (unsigned long)MINOR(sbp->st_rdev)); |
984263bc | 122 | else { |
dc4340fe | 123 | fprintf(fp, "%9jd ", (intmax_t)sbp->st_size); |
984263bc MD |
124 | } |
125 | ||
126 | /* | |
127 | * print name and link info for hard and soft links | |
128 | */ | |
57fed2af | 129 | fprintf(fp, "%s %s", f_date, arcn->name); |
984263bc | 130 | if ((arcn->type == PAX_HLK) || (arcn->type == PAX_HRG)) |
57fed2af | 131 | fprintf(fp, " == %s\n", arcn->ln_name); |
984263bc | 132 | else if (arcn->type == PAX_SLK) |
57fed2af | 133 | fprintf(fp, " => %s\n", arcn->ln_name); |
984263bc | 134 | else |
57fed2af EN |
135 | putc('\n', fp); |
136 | fflush(fp); | |
984263bc MD |
137 | return; |
138 | } | |
139 | ||
140 | /* | |
141 | * tty_ls() | |
142 | * print a short summary of file to tty. | |
143 | */ | |
144 | ||
984263bc | 145 | void |
86a586bb | 146 | ls_tty(ARCHD *arcn) |
984263bc MD |
147 | { |
148 | char f_date[DATELEN]; | |
149 | char f_mode[MODELEN]; | |
150 | char *timefrmt; | |
151 | ||
152 | if (d_first < 0) | |
153 | d_first = (*nl_langinfo(D_MD_ORDER) == 'd'); | |
154 | ||
2038fb68 | 155 | if ((arcn->sb.st_mtime + SIXMONTHS) <= time(NULL)) |
984263bc MD |
156 | timefrmt = d_first ? OLDFRMTD : OLDFRMTM; |
157 | else | |
158 | timefrmt = d_first ? CURFRMTD : CURFRMTM; | |
159 | ||
160 | /* | |
161 | * convert time to string, and print | |
162 | */ | |
163 | if (strftime(f_date, DATELEN, timefrmt, | |
164 | localtime(&(arcn->sb.st_mtime))) == 0) | |
165 | f_date[0] = '\0'; | |
166 | strmode(arcn->sb.st_mode, f_mode); | |
167 | tty_prnt("%s%s %s\n", f_mode, f_date, arcn->name); | |
168 | return; | |
169 | } | |
170 | ||
171 | /* | |
172 | * l_strncpy() | |
173 | * copy src to dest up to len chars (stopping at first '\0'). | |
174 | * when src is shorter than len, pads to len with '\0'. | |
175 | * Return: | |
176 | * number of chars copied. (Note this is a real performance win over | |
177 | * doing a strncpy(), a strlen(), and then a possible memset()) | |
178 | */ | |
179 | ||
984263bc | 180 | int |
9e6611d4 | 181 | l_strncpy(char *dest, const char *src, int len) |
984263bc | 182 | { |
86a586bb LF |
183 | char *stop; |
184 | char *start; | |
984263bc MD |
185 | |
186 | stop = dest + len; | |
187 | start = dest; | |
188 | while ((dest < stop) && (*src != '\0')) | |
189 | *dest++ = *src++; | |
190 | len = dest - start; | |
191 | while (dest < stop) | |
192 | *dest++ = '\0'; | |
193 | return(len); | |
194 | } | |
195 | ||
196 | /* | |
197 | * asc_ul() | |
198 | * convert hex/octal character string into a u_long. We do not have to | |
199 | * check for overflow! (the headers in all supported formats are not large | |
200 | * enough to create an overflow). | |
201 | * NOTE: strings passed to us are NOT TERMINATED. | |
202 | * Return: | |
203 | * unsigned long value | |
204 | */ | |
205 | ||
984263bc | 206 | u_long |
86a586bb | 207 | asc_ul(char *str, int len, int base) |
984263bc | 208 | { |
86a586bb | 209 | char *stop; |
984263bc MD |
210 | u_long tval = 0; |
211 | ||
212 | stop = str + len; | |
213 | ||
214 | /* | |
215 | * skip over leading blanks and zeros | |
216 | */ | |
217 | while ((str < stop) && ((*str == ' ') || (*str == '0'))) | |
218 | ++str; | |
219 | ||
220 | /* | |
221 | * for each valid digit, shift running value (tval) over to next digit | |
222 | * and add next digit | |
223 | */ | |
224 | if (base == HEX) { | |
225 | while (str < stop) { | |
226 | if ((*str >= '0') && (*str <= '9')) | |
227 | tval = (tval << 4) + (*str++ - '0'); | |
228 | else if ((*str >= 'A') && (*str <= 'F')) | |
229 | tval = (tval << 4) + 10 + (*str++ - 'A'); | |
230 | else if ((*str >= 'a') && (*str <= 'f')) | |
231 | tval = (tval << 4) + 10 + (*str++ - 'a'); | |
232 | else | |
233 | break; | |
234 | } | |
235 | } else { | |
236 | while ((str < stop) && (*str >= '0') && (*str <= '7')) | |
237 | tval = (tval << 3) + (*str++ - '0'); | |
238 | } | |
239 | return(tval); | |
240 | } | |
241 | ||
242 | /* | |
243 | * ul_asc() | |
244 | * convert an unsigned long into an hex/oct ascii string. pads with LEADING | |
245 | * ascii 0's to fill string completely | |
246 | * NOTE: the string created is NOT TERMINATED. | |
247 | */ | |
248 | ||
984263bc | 249 | int |
86a586bb | 250 | ul_asc(u_long val, char *str, int len, int base) |
984263bc | 251 | { |
86a586bb | 252 | char *pt; |
984263bc MD |
253 | u_long digit; |
254 | ||
255 | /* | |
256 | * WARNING str is not '\0' terminated by this routine | |
257 | */ | |
258 | pt = str + len - 1; | |
259 | ||
260 | /* | |
261 | * do a tailwise conversion (start at right most end of string to place | |
262 | * least significant digit). Keep shifting until conversion value goes | |
263 | * to zero (all digits were converted) | |
264 | */ | |
265 | if (base == HEX) { | |
266 | while (pt >= str) { | |
267 | if ((digit = (val & 0xf)) < 10) | |
268 | *pt-- = '0' + (char)digit; | |
269 | else | |
270 | *pt-- = 'a' + (char)(digit - 10); | |
271 | if ((val = (val >> 4)) == (u_long)0) | |
272 | break; | |
273 | } | |
274 | } else { | |
275 | while (pt >= str) { | |
276 | *pt-- = '0' + (char)(val & 0x7); | |
277 | if ((val = (val >> 3)) == (u_long)0) | |
278 | break; | |
279 | } | |
280 | } | |
281 | ||
282 | /* | |
283 | * pad with leading ascii ZEROS. We return -1 if we ran out of space. | |
284 | */ | |
285 | while (pt >= str) | |
286 | *pt-- = '0'; | |
287 | if (val != (u_long)0) | |
288 | return(-1); | |
289 | return(0); | |
290 | } | |
291 | ||
984263bc MD |
292 | /* |
293 | * asc_uqd() | |
294 | * convert hex/octal character string into a u_quad_t. We do not have to | |
295 | * check for overflow! (the headers in all supported formats are not large | |
296 | * enough to create an overflow). | |
297 | * NOTE: strings passed to us are NOT TERMINATED. | |
298 | * Return: | |
299 | * u_quad_t value | |
300 | */ | |
301 | ||
984263bc | 302 | u_quad_t |
86a586bb | 303 | asc_uqd(char *str, int len, int base) |
984263bc | 304 | { |
86a586bb | 305 | char *stop; |
984263bc MD |
306 | u_quad_t tval = 0; |
307 | ||
308 | stop = str + len; | |
309 | ||
310 | /* | |
311 | * skip over leading blanks and zeros | |
312 | */ | |
313 | while ((str < stop) && ((*str == ' ') || (*str == '0'))) | |
314 | ++str; | |
315 | ||
316 | /* | |
317 | * for each valid digit, shift running value (tval) over to next digit | |
318 | * and add next digit | |
319 | */ | |
320 | if (base == HEX) { | |
321 | while (str < stop) { | |
322 | if ((*str >= '0') && (*str <= '9')) | |
323 | tval = (tval << 4) + (*str++ - '0'); | |
324 | else if ((*str >= 'A') && (*str <= 'F')) | |
325 | tval = (tval << 4) + 10 + (*str++ - 'A'); | |
326 | else if ((*str >= 'a') && (*str <= 'f')) | |
327 | tval = (tval << 4) + 10 + (*str++ - 'a'); | |
328 | else | |
329 | break; | |
330 | } | |
331 | } else { | |
332 | while ((str < stop) && (*str >= '0') && (*str <= '7')) | |
333 | tval = (tval << 3) + (*str++ - '0'); | |
334 | } | |
335 | return(tval); | |
336 | } | |
337 | ||
338 | /* | |
339 | * uqd_asc() | |
340 | * convert an u_quad_t into a hex/oct ascii string. pads with LEADING | |
341 | * ascii 0's to fill string completely | |
342 | * NOTE: the string created is NOT TERMINATED. | |
343 | */ | |
344 | ||
984263bc | 345 | int |
86a586bb | 346 | uqd_asc(u_quad_t val, char *str, int len, int base) |
984263bc | 347 | { |
86a586bb | 348 | char *pt; |
984263bc MD |
349 | u_quad_t digit; |
350 | ||
351 | /* | |
352 | * WARNING str is not '\0' terminated by this routine | |
353 | */ | |
354 | pt = str + len - 1; | |
355 | ||
356 | /* | |
357 | * do a tailwise conversion (start at right most end of string to place | |
358 | * least significant digit). Keep shifting until conversion value goes | |
359 | * to zero (all digits were converted) | |
360 | */ | |
361 | if (base == HEX) { | |
362 | while (pt >= str) { | |
363 | if ((digit = (val & 0xf)) < 10) | |
364 | *pt-- = '0' + (char)digit; | |
365 | else | |
366 | *pt-- = 'a' + (char)(digit - 10); | |
367 | if ((val = (val >> 4)) == (u_quad_t)0) | |
368 | break; | |
369 | } | |
370 | } else { | |
371 | while (pt >= str) { | |
372 | *pt-- = '0' + (char)(val & 0x7); | |
373 | if ((val = (val >> 3)) == (u_quad_t)0) | |
374 | break; | |
375 | } | |
376 | } | |
377 | ||
378 | /* | |
379 | * pad with leading ascii ZEROS. We return -1 if we ran out of space. | |
380 | */ | |
381 | while (pt >= str) | |
382 | *pt-- = '0'; | |
383 | if (val != (u_quad_t)0) | |
384 | return(-1); | |
385 | return(0); | |
386 | } |