extern int logger_main(int argc, char **argv)
{
int pri = LOG_USER | LOG_NOTICE;
int option = 0;
int c, i, len, opt;
char *message=NULL, buf[1024], name[128];
/* Fill out the name string early (may be overwritten later) */
my_getpwuid(name, geteuid());
/* Parse any options */
while ((opt = getopt(argc, argv, "p:st:")) > 0) {
switch (opt) {
case 's':
option |= LOG_PERROR;
break;
case 'p':
pri = pencode(optarg);
break;
case 't':
strncpy(name, optarg, sizeof(name));
break;
default:
show_usage();
}
}
openlog(name, option, (pri | LOG_FACMASK));
if (optind == argc) {
do {
/* read from stdin */
i = 0;
while ((c = getc(stdin)) != EOF && c != '\n' &&
i < (sizeof(buf)-1)) {
buf[i++] = c;
}
if (i > 0) {
buf[i++] = '\0';
syslog(pri, "%s", buf);
}
} while (c != EOF);
} else {
len = 1; /* for the '\0' */
message=xcalloc(1, 1);
for (i = optind; i < argc; i++) {
len += strlen(argv[i]);
len += 1; /* for the space between the args */
message = xrealloc(message, len);
strcat(message, argv[i]);
strcat(message, " ");
}
message[strlen(message)-1] = '\0';
syslog(pri, "%s", message);
}
closelog();
return EXIT_SUCCESS;
}
extern int whoami_main(int argc, char **argv)
{
char user[9];
uid_t uid;
if (argc > 1)
bb_show_usage();
uid = geteuid();
if (my_getpwuid(user, uid)) {
puts(user);
bb_fflush_stdout_and_exit(EXIT_SUCCESS);
}
bb_error_msg_and_die("cannot find username for UID %u", (unsigned) uid);
}
/*----------------------------------------------------------------------*/
static int list_single(struct dnode *dn)
{
int i, len;
char scratch[BUFSIZ + 1];
#ifdef BB_FEATURE_LS_TIMESTAMPS
char *filetime;
time_t ttime, age;
#endif
#if defined (BB_FEATURE_LS_FILETYPES)
struct stat info;
#endif
#ifdef BB_FEATURE_LS_FILETYPES
char append;
#endif
if (dn==NULL || dn->fullname==NULL) return(0);
#ifdef BB_FEATURE_LS_TIMESTAMPS
ttime= dn->dstat.st_mtime; /* the default time */
if (time_fmt & TIME_ACCESS) ttime= dn->dstat.st_atime;
if (time_fmt & TIME_CHANGE) ttime= dn->dstat.st_ctime;
filetime= ctime(&ttime);
#endif
#ifdef BB_FEATURE_LS_FILETYPES
append = append_char(dn->dstat.st_mode);
#endif
for (i=0; i<=31; i++) {
switch (list_fmt & (1<<i)) {
case LIST_INO:
printf("%7ld ", (long int)dn->dstat.st_ino);
column += 8;
break;
case LIST_BLOCKS:
#ifdef BB_FEATURE_HUMAN_READABLE
fprintf(stdout, "%5s ", make_human_readable_str(dn->dstat.st_blocks>>1,
(ls_disp_hr==TRUE)? 0: 1));
#else
#if _FILE_OFFSET_BITS == 64
printf("%4lld ", dn->dstat.st_blocks>>1);
#else
printf("%4ld ", dn->dstat.st_blocks>>1);
#endif
#endif
column += 5;
break;
case LIST_MODEBITS:
printf("%10s", (char *)mode_string(dn->dstat.st_mode));
column += 10;
break;
case LIST_NLINKS:
printf("%4d ", dn->dstat.st_nlink);
column += 10;
break;
case LIST_ID_NAME:
#ifdef BB_FEATURE_LS_USERNAME
my_getpwuid(scratch, dn->dstat.st_uid);
printf("%-8.8s ", scratch);
my_getgrgid(scratch, dn->dstat.st_gid);
printf("%-8.8s", scratch);
column += 17;
break;
#endif
case LIST_ID_NUMERIC:
printf("%-8d %-8d", dn->dstat.st_uid, dn->dstat.st_gid);
column += 17;
break;
case LIST_SIZE:
case LIST_DEV:
if (S_ISBLK(dn->dstat.st_mode) || S_ISCHR(dn->dstat.st_mode)) {
printf("%4d, %3d ", (int)MAJOR(dn->dstat.st_rdev), (int)MINOR(dn->dstat.st_rdev));
} else {
#if defined(BB_FEATURE_HUMAN_READABLE) && _FILE_OFFSET_BITS != 64
fprintf(stdout, "%9s ", make_human_readable_str(dn->dstat.st_size,
(ls_disp_hr==TRUE)? 0: 1));
#else
#if _FILE_OFFSET_BITS == 64
printf("%9lld ", dn->dstat.st_size);
#else
printf("%9ld ", dn->dstat.st_size);
#endif
#endif
}
column += 10;
break;
#ifdef BB_FEATURE_LS_TIMESTAMPS
case LIST_FULLTIME:
case LIST_DATE_TIME:
if (list_fmt & LIST_FULLTIME) {
printf("%24.24s ", filetime);
column += 25;
break;
}
age = time(NULL) - ttime;
printf("%6.6s ", filetime+4);
if (age < 3600L * 24 * 365 / 2 && age > -15 * 60) {
/* hh:mm if less than 6 months old */
printf("%5.5s ", filetime+11);
} else {
printf(" %4.4s ", filetime+20);
}
column += 13;
break;
#endif
case LIST_FILENAME:
printf("%s", dn->name);
column += strlen(dn->name);
break;
case LIST_SYMLINK:
if (S_ISLNK(dn->dstat.st_mode)) {
len= readlink(dn->fullname, scratch, (sizeof scratch)-1);
if (len > 0) {
scratch[len]= '\0';
printf(" -> %s", scratch);
#ifdef BB_FEATURE_LS_FILETYPES
if (!stat(dn->fullname, &info)) {
append = append_char(info.st_mode);
}
#endif
column += len+4;
}
}
break;
#ifdef BB_FEATURE_LS_FILETYPES
case LIST_FILETYPE:
if (append != '\0') {
printf("%1c", append);
column++;
}
break;
#endif
}
}
return(0);
}
extern int id_main(int argc, char **argv)
{
struct passwd *p;
uid_t uid;
gid_t gid;
unsigned long flags;
short status;
#ifdef CONFIG_SELINUX
int is_flask_enabled_flag = is_flask_enabled();
#endif
bb_opt_complementaly = "u~g:g~u";
flags = bb_getopt_ulflags(argc, argv, "rnug");
if ((flags & BB_GETOPT_ERROR)
/* Don't allow -n -r -nr */
|| (flags <= 3 && flags > 0)
/* Don't allow more than one username */
|| (argc > optind + 1))
bb_show_usage();
/* This values could be overwritten later */
uid = geteuid();
gid = getegid();
if (flags & PRINT_REAL) {
uid = getuid();
gid = getgid();
}
if(argv[optind]) {
p=getpwnam(argv[optind]);
/* my_getpwnam is needed because it exits on failure */
uid = my_getpwnam(argv[optind]);
gid = p->pw_gid;
/* in this case PRINT_REAL is the same */
}
if(flags & (JUST_GROUP | JUST_USER)) {
/* JUST_GROUP and JUST_USER are mutually exclusive */
if(flags & NAME_NOT_NUMBER) {
/* my_getpwuid and my_getgrgid exit on failure so puts cannot segfault */
puts((flags & JUST_USER) ? my_getpwuid(NULL, uid, -1 ) : my_getgrgid(NULL, gid, -1 ));
} else {
bb_printf("%u\n",(flags & JUST_USER) ? uid : gid);
}
/* exit */
bb_fflush_stdout_and_exit(EXIT_SUCCESS);
}
/* Print full info like GNU id */
/* my_getpwuid doesn't exit on failure here */
status=printf_full(uid, my_getpwuid(NULL, uid, 0), 'u');
putchar(' ');
/* my_getgrgid doesn't exit on failure here */
status|=printf_full(gid, my_getgrgid(NULL, gid, 0), 'g');
#ifdef CONFIG_SELINUX
if(is_flask_enabled_flag) {
security_id_t mysid = getsecsid();
char context[80];
int len = sizeof(context);
context[0] = '\0';
if(security_sid_to_context(mysid, context, &len))
strcpy(context, "unknown");
bb_printf(" context=%s", context);
}
#endif
putchar('\n');
bb_fflush_stdout_and_exit(status);
}
extern procps_status_t * procps_scan(int save_user_arg0
#ifdef CONFIG_SELINUX
, int use_selinux , security_id_t *sid
#endif
)
{
static DIR *dir;
struct dirent *entry;
static procps_status_t ret_status;
char *name;
int n;
char status[32];
char buf[1024];
FILE *fp;
procps_status_t curstatus;
int pid;
long tasknice;
struct stat sb;
if (!dir) {
dir = opendir("/proc");
if(!dir)
bb_error_msg_and_die("Can't open /proc");
}
for(;;) {
if((entry = readdir(dir)) == NULL) {
closedir(dir);
dir = 0;
return 0;
}
name = entry->d_name;
if (!(*name >= '0' && *name <= '9'))
continue;
memset(&curstatus, 0, sizeof(procps_status_t));
pid = atoi(name);
curstatus.pid = pid;
sprintf(status, "/proc/%d", pid);
if(stat(status, &sb))
continue;
my_getpwuid(curstatus.user, sb.st_uid, sizeof(curstatus.user));
sprintf(status, "/proc/%d/stat", pid);
if((fp = fopen(status, "r")) == NULL)
continue;
#ifdef CONFIG_SELINUX
if(use_selinux)
{
if(fstat_secure(fileno(fp), &sb, sid))
continue;
}
else
#endif
name = fgets(buf, sizeof(buf), fp);
fclose(fp);
if(name == NULL)
continue;
name = strrchr(buf, ')'); /* split into "PID (cmd" and "<rest>" */
if(name == 0 || name[1] != ' ')
continue;
*name = 0;
sscanf(buf, "%*s (%15c", curstatus.short_cmd);
n = sscanf(name+2,
"%c %d "
"%*s %*s %*s %*s " /* pgrp, session, tty, tpgid */
"%*s %*s %*s %*s %*s " /* flags, min_flt, cmin_flt, maj_flt, cmaj_flt */
#ifdef FEATURE_CPU_USAGE_PERCENTAGE
"%lu %lu "
#else
"%*s %*s "
#endif
"%*s %*s %*s " /* cutime, cstime, priority */
"%ld "
"%*s %*s %*s " /* timeout, it_real_value, start_time */
"%*s " /* vsize */
"%ld",
curstatus.state, &curstatus.ppid,
#ifdef FEATURE_CPU_USAGE_PERCENTAGE
&curstatus.utime, &curstatus.stime,
#endif
&tasknice,
&curstatus.rss);
#ifdef FEATURE_CPU_USAGE_PERCENTAGE
if(n != 6)
#else
if(n != 4)
#endif
continue;
if (curstatus.rss == 0 && curstatus.state[0] != 'Z')
curstatus.state[1] = 'W';
else
curstatus.state[1] = ' ';
if (tasknice < 0)
curstatus.state[2] = '<';
else if (tasknice > 0)
curstatus.state[2] = 'N';
else
curstatus.state[2] = ' ';
#ifdef PAGE_SHIFT
curstatus.rss <<= (PAGE_SHIFT - 10); /* 2**10 = 1kb */
#else
curstatus.rss *= (getpagesize() >> 10); /* 2**10 = 1kb */
#endif
if(save_user_arg0) {
sprintf(status, "/proc/%d/cmdline", pid);
if((fp = fopen(status, "r")) == NULL)
continue;
if((n=fread(buf, 1, sizeof(buf)-1, fp)) > 0) {
if(buf[n-1]=='\n')
buf[--n] = 0;
name = buf;
while(n) {
if(((unsigned char)*name) < ' ')
*name = ' ';
name++;
n--;
}
*name = 0;
if(buf[0])
curstatus.cmd = strdup(buf);
/* if NULL it work true also */
}
fclose(fp);
}
return memcpy(&ret_status, &curstatus, sizeof(procps_status_t));
}
}
extern int id_main(int argc, char **argv)
{
char user[9], group[9];
long pwnam, grnam;
int uid, gid;
int flags;
#ifdef CONFIG_SELINUX
int is_flask_enabled_flag = is_flask_enabled();
#endif
flags = bb_getopt_ulflags(argc, argv, "ugrn");
if (((flags & (JUST_USER | JUST_GROUP)) == (JUST_USER | JUST_GROUP))
|| (argc > optind + 1)
) {
bb_show_usage();
}
if (argv[optind] == NULL) {
if (flags & PRINT_REAL) {
uid = getuid();
gid = getgid();
} else {
uid = geteuid();
gid = getegid();
}
my_getpwuid(user, uid);
} else {
safe_strncpy(user, argv[optind], sizeof(user));
gid = my_getpwnamegid(user);
}
my_getgrgid(group, gid);
pwnam=my_getpwnam(user);
grnam=my_getgrnam(group);
if (flags & (JUST_GROUP | JUST_USER)) {
char *s = group;
if (flags & JUST_USER) {
s = user;
grnam = pwnam;
}
if (flags & NAME_NOT_NUMBER) {
puts(s);
} else {
printf("%ld\n", grnam);
}
} else {
#ifdef CONFIG_SELINUX
printf("uid=%ld(%s) gid=%ld(%s)", pwnam, user, grnam, group);
if(is_flask_enabled_flag)
{
security_id_t mysid = getsecsid();
char context[80];
int len = sizeof(context);
context[0] = '\0';
if(security_sid_to_context(mysid, context, &len))
strcpy(context, "unknown");
printf(" context=%s\n", context);
}
else
printf("\n");
#else
printf("uid=%ld(%s) gid=%ld(%s)\n", pwnam, user, grnam, group);
#endif
}
bb_fflush_stdout_and_exit(0);
}
/* Write out a tar header for the specified file/directory/whatever */
static inline int writeTarHeader(struct TarBallInfo *tbInfo,
const char *header_name,
const char *real_name, struct stat *statbuf)
{
long chksum = 0;
struct TarHeader header;
const unsigned char *cp = (const unsigned char *) &header;
ssize_t size = sizeof(struct TarHeader);
memset(&header, 0, size);
strncpy(header.name, header_name, sizeof(header.name));
putOctal(header.mode, sizeof(header.mode), statbuf->st_mode);
putOctal(header.uid, sizeof(header.uid), statbuf->st_uid);
putOctal(header.gid, sizeof(header.gid), statbuf->st_gid);
putOctal(header.size, sizeof(header.size), 0); /* Regular file size is handled later */
putOctal(header.mtime, sizeof(header.mtime), statbuf->st_mtime);
strncpy(header.magic, TAR_MAGIC TAR_VERSION,
TAR_MAGIC_LEN + TAR_VERSION_LEN);
/* Enter the user and group names (default to root if it fails) */
if (my_getpwuid(header.uname, statbuf->st_uid) == NULL)
strcpy(header.uname, "root");
if (my_getgrgid(header.gname, statbuf->st_gid) == NULL)
strcpy(header.gname, "root");
if (tbInfo->hlInfo) {
/* This is a hard link */
header.typeflag = LNKTYPE;
strncpy(header.linkname, tbInfo->hlInfo->name,
sizeof(header.linkname));
} else if (S_ISLNK(statbuf->st_mode)) {
char *lpath = xreadlink(real_name);
if (!lpath) /* Already printed err msg inside xreadlink() */
return (FALSE);
header.typeflag = SYMTYPE;
strncpy(header.linkname, lpath, sizeof(header.linkname));
free(lpath);
} else if (S_ISDIR(statbuf->st_mode)) {
header.typeflag = DIRTYPE;
strncat(header.name, "/", sizeof(header.name));
} else if (S_ISCHR(statbuf->st_mode)) {
header.typeflag = CHRTYPE;
putOctal(header.devmajor, sizeof(header.devmajor),
MAJOR(statbuf->st_rdev));
putOctal(header.devminor, sizeof(header.devminor),
MINOR(statbuf->st_rdev));
} else if (S_ISBLK(statbuf->st_mode)) {
header.typeflag = BLKTYPE;
putOctal(header.devmajor, sizeof(header.devmajor),
MAJOR(statbuf->st_rdev));
putOctal(header.devminor, sizeof(header.devminor),
MINOR(statbuf->st_rdev));
} else if (S_ISFIFO(statbuf->st_mode)) {
header.typeflag = FIFOTYPE;
} else if (S_ISREG(statbuf->st_mode)) {
header.typeflag = REGTYPE;
putOctal(header.size, sizeof(header.size), statbuf->st_size);
} else {
bb_error_msg("%s: Unknown file type", real_name);
return (FALSE);
}
/* Calculate and store the checksum (i.e., the sum of all of the bytes of
* the header). The checksum field must be filled with blanks for the
* calculation. The checksum field is formatted differently from the
* other fields: it has [6] digits, a null, then a space -- rather than
* digits, followed by a null like the other fields... */
memset(header.chksum, ' ', sizeof(header.chksum));
cp = (const unsigned char *) &header;
while (size-- > 0)
chksum += *cp++;
putOctal(header.chksum, 7, chksum);
/* Now write the header out to disk */
if ((size =
bb_full_write(tbInfo->tarFd, (char *) &header,
sizeof(struct TarHeader))) < 0) {
bb_error_msg(bb_msg_io_error, real_name);
return (FALSE);
}
/* Pad the header up to the tar block size */
for (; size < TAR_BLOCK_SIZE; size++) {
write(tbInfo->tarFd, "\0", 1);
}
/* Now do the verbose thing (or not) */
if (tbInfo->verboseFlag) {
FILE *vbFd = stdout;
if (tbInfo->tarFd == STDOUT_FILENO) /* If the archive goes to stdout, verbose to stderr */
vbFd = stderr;
fprintf(vbFd, "%s\n", header.name);
}
return (TRUE);
}
/*----------------------------------------------------------------------*/
static int list_single(struct dnode *dn)
{
int i, column = 0;
#ifdef CONFIG_FEATURE_LS_USERNAME
char scratch[16];
#endif
#ifdef CONFIG_FEATURE_LS_TIMESTAMPS
char *filetime;
time_t ttime, age;
#endif
#if defined(CONFIG_FEATURE_LS_FILETYPES) || defined (CONFIG_FEATURE_LS_COLOR)
struct stat info;
char append;
#endif
if (dn->fullname == NULL)
return (0);
#ifdef CONFIG_FEATURE_LS_TIMESTAMPS
ttime = dn->dstat.st_mtime; /* the default time */
if (all_fmt & TIME_ACCESS)
ttime = dn->dstat.st_atime;
if (all_fmt & TIME_CHANGE)
ttime = dn->dstat.st_ctime;
filetime = ctime(&ttime);
#endif
#ifdef CONFIG_FEATURE_LS_FILETYPES
append = append_char(dn->dstat.st_mode);
#endif
for (i = 0; i <= 31; i++) {
switch (all_fmt & (1 << i)) {
case LIST_INO:
column += printf("%7ld ", (long int) dn->dstat.st_ino);
break;
case LIST_BLOCKS:
#if _FILE_OFFSET_BITS == 64
column += printf("%4lld ", dn->dstat.st_blocks >> 1);
#else
column += printf("%4ld ", dn->dstat.st_blocks >> 1);
#endif
break;
case LIST_MODEBITS:
column += printf("%-10s ", (char *) bb_mode_string(dn->dstat.st_mode));
break;
case LIST_NLINKS:
column += printf("%4ld ", (long) dn->dstat.st_nlink);
break;
case LIST_ID_NAME:
#ifdef CONFIG_FEATURE_LS_USERNAME
my_getpwuid(scratch, dn->dstat.st_uid);
printf("%-8.8s ", scratch);
my_getgrgid(scratch, dn->dstat.st_gid);
printf("%-8.8s", scratch);
column += 17;
break;
#endif
case LIST_ID_NUMERIC:
column += printf("%-8d %-8d", dn->dstat.st_uid, dn->dstat.st_gid);
break;
case LIST_SIZE:
case LIST_DEV:
if (S_ISBLK(dn->dstat.st_mode) || S_ISCHR(dn->dstat.st_mode)) {
column += printf("%4d, %3d ", (int) MAJOR(dn->dstat.st_rdev),
(int) MINOR(dn->dstat.st_rdev));
} else {
#ifdef CONFIG_FEATURE_HUMAN_READABLE
if (all_fmt & LS_DISP_HR) {
column += printf("%9s ",
make_human_readable_str(dn->dstat.st_size, 1, 0));
} else
#endif
{
#if _FILE_OFFSET_BITS == 64
column += printf("%9lld ", (long long) dn->dstat.st_size);
#else
column += printf("%9ld ", dn->dstat.st_size);
#endif
}
}
break;
#ifdef CONFIG_FEATURE_LS_TIMESTAMPS
case LIST_FULLTIME:
printf("%24.24s ", filetime);
column += 25;
break;
case LIST_DATE_TIME:
if ((all_fmt & LIST_FULLTIME) == 0) {
age = time(NULL) - ttime;
printf("%6.6s ", filetime + 4);
if (age < 3600L * 24 * 365 / 2 && age > -15 * 60) {
/* hh:mm if less than 6 months old */
printf("%5.5s ", filetime + 11);
} else {
printf(" %4.4s ", filetime + 20);
}
column += 13;
}
break;
#endif
#ifdef CONFIG_SELINUX
case LIST_CONTEXT:
{
char context[64];
int len = sizeof(context);
if(security_sid_to_context(dn->sid, context, &len))
{
strcpy(context, "unknown");
len = 7;
}
printf("%-32s ", context);
column += MAX(33, len);
}
break;
#endif
case LIST_FILENAME:
#ifdef CONFIG_FEATURE_LS_COLOR
errno = 0;
if (show_color && !lstat(dn->fullname, &info)) {
printf("\033[%d;%dm", bgcolor(info.st_mode),
fgcolor(info.st_mode));
}
#endif
column += printf("%s", dn->name);
#ifdef CONFIG_FEATURE_LS_COLOR
if (show_color) {
printf("\033[0m");
}
#endif
break;
case LIST_SYMLINK:
if (S_ISLNK(dn->dstat.st_mode)) {
char *lpath = xreadlink(dn->fullname);
if (lpath) {
printf(" -> ");
#if defined(CONFIG_FEATURE_LS_FILETYPES) || defined (CONFIG_FEATURE_LS_COLOR)
if (!stat(dn->fullname, &info)) {
append = append_char(info.st_mode);
}
#endif
#ifdef CONFIG_FEATURE_LS_COLOR
if (show_color) {
errno = 0;
printf("\033[%d;%dm", bgcolor(info.st_mode),
fgcolor(info.st_mode));
}
#endif
column += printf("%s", lpath) + 4;
#ifdef CONFIG_FEATURE_LS_COLOR
if (show_color) {
printf("\033[0m");
}
#endif
free(lpath);
}
}
break;
#ifdef CONFIG_FEATURE_LS_FILETYPES
case LIST_FILETYPE:
if (append != '\0') {
printf("%1c", append);
column++;
}
break;
#endif
}
}
return column;
}
/*
* Read a tar file and extract or list the specified files within it.
* If the list is empty than all files are extracted or listed.
*/
static int readTarFile(int tarFd, int extractFlag, int listFlag,
int tostdoutFlag, int verboseFlag, char** extractList,
char** excludeList)
{
int status;
int errorFlag=FALSE;
int skipNextHeaderFlag=FALSE;
TarHeader rawHeader;
TarInfo header;
/* Read the tar file, and iterate over it one file at a time */
while ( (status = full_read(tarFd, (char*)&rawHeader, TAR_BLOCK_SIZE)) == TAR_BLOCK_SIZE ) {
/* Try to read the header */
if ( readTarHeader(&rawHeader, &header) == FALSE ) {
if ( *(header.name) == '\0' ) {
goto endgame;
} else {
errorFlag=TRUE;
error_msg("Bad tar header, skipping");
continue;
}
}
if ( *(header.name) == '\0' )
continue;
header.tarFd = tarFd;
/* Skip funky extra GNU headers that precede long files */
if ( (header.type == GNULONGNAME) || (header.type == GNULONGLINK) ) {
skipNextHeaderFlag=TRUE;
if (tarExtractRegularFile(&header, FALSE, FALSE) == FALSE)
errorFlag = TRUE;
continue;
}
if ( skipNextHeaderFlag == TRUE ) {
skipNextHeaderFlag=FALSE;
error_msg(name_longer_than_foo, NAME_SIZE);
if (tarExtractRegularFile(&header, FALSE, FALSE) == FALSE)
errorFlag = TRUE;
continue;
}
#if defined BB_FEATURE_TAR_EXCLUDE
if (exclude_file(excludeList, header.name)) {
/* There are not the droids you're looking for, move along */
/* If it is a regular file, pretend to extract it with
* the extractFlag set to FALSE, so the junk in the tarball
* is properly skipped over */
if ( header.type==REGTYPE || header.type==REGTYPE0 ) {
if (tarExtractRegularFile(&header, FALSE, FALSE) == FALSE)
errorFlag = TRUE;
}
continue;
}
#endif
if (!extract_file(extractList, header.name)) {
/* There are not the droids you're looking for, move along */
/* If it is a regular file, pretend to extract it with
* the extractFlag set to FALSE, so the junk in the tarball
* is properly skipped over */
if ( header.type==REGTYPE || header.type==REGTYPE0 ) {
if (tarExtractRegularFile(&header, FALSE, FALSE) == FALSE)
errorFlag = TRUE;
}
continue;
}
if (listFlag == TRUE) {
/* Special treatment if the list (-t) flag is on */
if (verboseFlag == TRUE) {
int len, len1;
char buf[35];
struct tm *tm = localtime (&(header.mtime));
len=printf("%s ", mode_string(header.mode));
my_getpwuid(buf, header.uid);
if (! *buf)
len+=printf("%d", header.uid);
else
len+=printf("%s", buf);
my_getgrgid(buf, header.gid);
if (! *buf)
len+=printf("/%-d ", header.gid);
else
len+=printf("/%-s ", buf);
if (header.type==CHRTYPE || header.type==BLKTYPE) {
len1=snprintf(buf, sizeof(buf), "%ld,%-ld ",
header.devmajor, header.devminor);
} else {
len1=snprintf(buf, sizeof(buf), "%lu ", (long)header.size);
}
/* Jump through some hoops to make the columns match up */
for(;(len+len1)<31;len++)
printf(" ");
printf(buf);
/* Use ISO 8610 time format */
if (tm) {
printf ("%04d-%02d-%02d %02d:%02d:%02d ",
tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
tm->tm_hour, tm->tm_min, tm->tm_sec);
}
}
printf("%s", header.name);
if (verboseFlag == TRUE) {
if (header.type==LNKTYPE) /* If this is a link, say so */
printf(" link to %s", header.linkname);
else if (header.type==SYMTYPE)
printf(" -> %s", header.linkname);
}
printf("\n");
}
/* List contents if we are supposed to do that */
if (verboseFlag == TRUE && extractFlag == TRUE) {
/* Now the normal listing */
FILE *vbFd = stdout;
if (tostdoutFlag == TRUE) // If the archive goes to stdout, verbose to stderr
vbFd = stderr;
fprintf(vbFd, "%s\n", header.name);
}
/* Remove files if we would overwrite them */
if (extractFlag == TRUE && tostdoutFlag == FALSE)
unlink(header.name);
/* If we got here, we can be certain we have a legitimate
* header to work with. So work with it. */
switch ( header.type ) {
case REGTYPE:
case REGTYPE0:
/* If the name ends in a '/' then assume it is
* supposed to be a directory, and fall through */
if (!last_char_is(header.name,'/')) {
if (tarExtractRegularFile(&header, extractFlag, tostdoutFlag)==FALSE)
errorFlag=TRUE;
break;
}
case DIRTYPE:
if (tarExtractDirectory( &header, extractFlag, tostdoutFlag)==FALSE)
errorFlag=TRUE;
break;
case LNKTYPE:
if (tarExtractHardLink( &header, extractFlag, tostdoutFlag)==FALSE)
errorFlag=TRUE;
break;
case SYMTYPE:
if (tarExtractSymLink( &header, extractFlag, tostdoutFlag)==FALSE)
errorFlag=TRUE;
break;
case CHRTYPE:
case BLKTYPE:
case FIFOTYPE:
if (tarExtractSpecial( &header, extractFlag, tostdoutFlag)==FALSE)
errorFlag=TRUE;
break;
#if 0
/* Handled earlier */
case GNULONGNAME:
case GNULONGLINK:
skipNextHeaderFlag=TRUE;
break;
#endif
default:
error_msg("Unknown file type '%c' in tar file", header.type);
close( tarFd);
return( FALSE);
}
}
close(tarFd);
if (status > 0) {
/* Bummer - we read a partial header */
perror_msg("Error reading tar file");
return ( FALSE);
}
else if (errorFlag==TRUE) {
error_msg( "Error exit delayed from previous errors");
return( FALSE);
} else
return( status);
/* Stuff to do when we are done */
endgame:
close( tarFd);
if ( *(header.name) == '\0' ) {
if (errorFlag==TRUE)
error_msg( "Error exit delayed from previous errors");
else
return( TRUE);
}
return( FALSE);
}
extern int id_main(int argc, char **argv)
{
int no_user = 0, no_group = 0, print_real = 0;
int name_not_number = 0;
char user[9], group[9];
long gid;
long pwnam, grnam;
int opt;
gid = 0;
while ((opt = getopt(argc, argv, "ugrn")) > 0) {
switch (opt) {
case 'u':
no_group++;
break;
case 'g':
no_user++;
break;
case 'r':
print_real++;
break;
case 'n':
name_not_number++;
break;
default:
show_usage();
}
}
if (no_user && no_group) show_usage();
if (argv[optind] == NULL) {
if (print_real) {
my_getpwuid(user, getuid());
my_getgrgid(group, getgid());
} else {
my_getpwuid(user, geteuid());
my_getgrgid(group, getegid());
}
} else {
strncpy(user, argv[optind], 8);
user[8] = '\0';
gid = my_getpwnamegid(user);
my_getgrgid(group, gid);
}
pwnam=my_getpwnam(user);
grnam=my_getgrnam(group);
if (no_group) {
if(name_not_number && user)
puts(user);
else
printf("%ld\n", pwnam);
} else if (no_user) {
if(name_not_number && group)
puts(group);
else
printf("%ld\n", grnam);
} else {
printf("uid=%ld(%s) gid=%ld(%s)\n", pwnam, user, grnam, group);
}
return(0);
}