bin/pax/gen_subs.c

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