time_t
_int_to_time(int tint)
{
if (sizeof(int) == sizeof(__int32_t))
return(_time32_to_time(tint));
return((time_t)tint);
}
time_t
_long_to_time(long tlong)
{
if (sizeof(long) == sizeof(__int32_t))
return(_time32_to_time(tlong));
return((time_t)tlong);
}
void
Sendto(int s, const void *buf, size_t cc, int flags, const struct sockaddr *to,
int tolen)
{
struct whod *w;
struct whoent *we;
struct sockaddr_in *sin;
w = (struct whod *)buf;
sin = (struct sockaddr_in *)to;
printf("sendto %x.%d\n", ntohl(sin->sin_addr.s_addr),
ntohs(sin->sin_port));
printf("hostname %s %s\n", w->wd_hostname,
interval(ntohl(w->wd_sendtime) - ntohl(w->wd_boottime), " up"));
printf("load %4.2f, %4.2f, %4.2f\n",
ntohl(w->wd_loadav[0]) / 100.0, ntohl(w->wd_loadav[1]) / 100.0,
ntohl(w->wd_loadav[2]) / 100.0);
cc -= WHDRSIZE;
for (we = w->wd_we, cc /= sizeof(struct whoent); cc > 0; cc--, we++) {
time_t t = _time32_to_time(ntohl(we->we_utmp.out_time));
printf("%-8.8s %s:%s %.12s", we->we_utmp.out_name,
w->wd_hostname, we->we_utmp.out_line, ctime(&t) + 4);
we->we_idle = ntohl(we->we_idle) / 60;
if (we->we_idle != 0) {
if (we->we_idle >= 100 * 60)
we->we_idle = 100 * 60 - 1;
if (we->we_idle >= 60)
printf(" %2d", we->we_idle / 60);
else
printf(" ");
printf(":%02d", we->we_idle % 60);
}
printf("\n");
}
}
/*
* Read the next block from the tape.
* If it is not any valid header, return an error.
*/
static int
gethead(struct s_spcl *buf)
{
long i;
readtape((char *)buf);
if (buf->c_magic != FS_UFS2_MAGIC && buf->c_magic != NFS_MAGIC) {
if (buf->c_magic == OFS_MAGIC) {
fprintf(stderr,
"Format of dump tape is too old. Must use\n");
fprintf(stderr,
"a version of restore from before 2002.\n");
return (FAIL);
}
if (swabl(buf->c_magic) != FS_UFS2_MAGIC &&
buf->c_magic != NFS_MAGIC) {
if (buf->c_magic == OFS_MAGIC) {
fprintf(stderr,
"Format of dump tape is too old. Must use\n");
fprintf(stderr,
"a version of restore from before 2002.\n");
}
return (FAIL);
}
if (!Bcvt) {
vprintf(stdout, "Note: Doing Byte swapping\n");
Bcvt = 1;
}
}
if (checksum((int *)buf) == FAIL)
return (FAIL);
if (Bcvt) {
swabst((u_char *)"8l4s1q8l2q17l", (u_char *)buf);
swabst((u_char *)"l",(u_char *) &buf->c_level);
swabst((u_char *)"2l4q",(u_char *) &buf->c_flags);
}
readmapflag = 0;
switch (buf->c_type) {
case TS_CLRI:
case TS_BITS:
/*
* Have to patch up missing information in bit map headers
*/
buf->c_size = buf->c_count * TP_BSIZE;
if (buf->c_count > TP_NINDIR)
readmapflag = 1;
else
for (i = 0; i < buf->c_count; i++)
buf->c_addr[i]++;
/* FALL THROUGH */
case TS_TAPE:
if (buf->c_magic == NFS_MAGIC &&
(buf->c_flags & NFS_DR_NEWINODEFMT) == 0)
oldinofmt = 1;
/* FALL THROUGH */
case TS_END:
buf->c_inumber = 0;
/* FALL THROUGH */
case TS_ADDR:
case TS_INODE:
/*
* For old dump tapes, have to copy up old fields to
* new locations.
*/
if (buf->c_magic == NFS_MAGIC) {
buf->c_tapea = buf->c_old_tapea;
buf->c_firstrec = buf->c_old_firstrec;
buf->c_date = _time32_to_time(buf->c_old_date);
buf->c_ddate = _time32_to_time(buf->c_old_ddate);
buf->c_atime = _time32_to_time(buf->c_old_atime);
buf->c_mtime = _time32_to_time(buf->c_old_mtime);
buf->c_birthtime = 0;
buf->c_birthtimensec = 0;
buf->c_extsize = 0;
}
break;
default:
panic("gethead: unknown inode type %d\n", buf->c_type);
break;
}
if (dumpdate != 0 && _time64_to_time(buf->c_date) != dumpdate)
fprintf(stderr, "Header with wrong dumpdate.\n");
/*
* If we're restoring a filesystem with the old (FreeBSD 1)
* format inodes, copy the uid/gid to the new location
*/
if (oldinofmt) {
buf->c_uid = buf->c_spare1[1];
buf->c_gid = buf->c_spare1[2];
}
buf->c_magic = FS_UFS2_MAGIC;
tapeaddr = buf->c_tapea;
if (dflag)
accthdr(buf);
return(GOOD);
}
void
printstat(const char *cp, ino_t inum, union dinode *dp)
{
struct group *grp;
struct passwd *pw;
ufs2_daddr_t blocks;
int64_t gen;
char *p;
time_t t;
printf("%s: ", cp);
switch (DIP(dp, di_mode) & IFMT) {
case IFDIR:
puts("directory");
break;
case IFREG:
puts("regular file");
break;
case IFBLK:
printf("block special (%#jx)", (uintmax_t)DIP(dp, di_rdev));
break;
case IFCHR:
printf("character special (%#jx)", DIP(dp, di_rdev));
break;
case IFLNK:
fputs("symlink",stdout);
if (DIP(dp, di_size) > 0 &&
DIP(dp, di_size) < sblock.fs_maxsymlinklen &&
DIP(dp, di_blocks) == 0) {
if (sblock.fs_magic == FS_UFS1_MAGIC)
p = (caddr_t)dp->dp1.di_db;
else
p = (caddr_t)dp->dp2.di_db;
printf(" to `%.*s'\n", (int) DIP(dp, di_size), p);
} else {
putchar('\n');
}
break;
case IFSOCK:
puts("socket");
break;
case IFIFO:
puts("fifo");
break;
}
printf("I=%lu MODE=%o SIZE=%ju", (u_long)inum, DIP(dp, di_mode),
(uintmax_t)DIP(dp, di_size));
if (sblock.fs_magic != FS_UFS1_MAGIC) {
t = _time64_to_time(dp->dp2.di_birthtime);
p = ctime(&t);
printf("\n\tBTIME=%15.15s %4.4s [%d nsec]", &p[4], &p[20],
dp->dp2.di_birthnsec);
}
if (sblock.fs_magic == FS_UFS1_MAGIC)
t = _time32_to_time(dp->dp1.di_mtime);
else
t = _time64_to_time(dp->dp2.di_mtime);
p = ctime(&t);
printf("\n\tMTIME=%15.15s %4.4s [%d nsec]", &p[4], &p[20],
DIP(dp, di_mtimensec));
if (sblock.fs_magic == FS_UFS1_MAGIC)
t = _time32_to_time(dp->dp1.di_ctime);
else
t = _time64_to_time(dp->dp2.di_ctime);
p = ctime(&t);
printf("\n\tCTIME=%15.15s %4.4s [%d nsec]", &p[4], &p[20],
DIP(dp, di_ctimensec));
if (sblock.fs_magic == FS_UFS1_MAGIC)
t = _time32_to_time(dp->dp1.di_atime);
else
t = _time64_to_time(dp->dp2.di_atime);
p = ctime(&t);
printf("\n\tATIME=%15.15s %4.4s [%d nsec]\n", &p[4], &p[20],
DIP(dp, di_atimensec));
if ((pw = getpwuid(DIP(dp, di_uid))))
printf("OWNER=%s ", pw->pw_name);
else
printf("OWNUID=%u ", DIP(dp, di_uid));
if ((grp = getgrgid(DIP(dp, di_gid))))
printf("GRP=%s ", grp->gr_name);
else
printf("GID=%u ", DIP(dp, di_gid));
blocks = DIP(dp, di_blocks);
gen = DIP(dp, di_gen);
printf("LINKCNT=%d FLAGS=%#x BLKCNT=%jx GEN=%jx\n", DIP(dp, di_nlink),
DIP(dp, di_flags), (intmax_t)blocks, (intmax_t)gen);
}
/*
* Dump passes 3 and 4.
*
* Dump the contents of an inode to tape.
*/
void
dumpino(union dinode *dp, ino_t ino)
{
int ind_level, cnt, last, added;
off_t size;
char buf[TP_BSIZE];
if (newtape) {
newtape = 0;
dumpmap(dumpinomap, TS_BITS, ino);
}
CLRINO(ino, dumpinomap);
/*
* Zero out the size of a snapshot so that it will be dumped
* as a zero length file.
*/
if ((DIP(dp, di_flags) & SF_SNAPSHOT) != 0) {
DIP_SET(dp, di_size, 0);
DIP_SET(dp, di_flags, DIP(dp, di_flags) & ~SF_SNAPSHOT);
}
if (sblock->fs_magic == FS_UFS1_MAGIC) {
spcl.c_mode = dp->dp1.di_mode;
spcl.c_size = dp->dp1.di_size;
spcl.c_extsize = 0;
spcl.c_atime = _time32_to_time(dp->dp1.di_atime);
spcl.c_atimensec = dp->dp1.di_atimensec;
spcl.c_mtime = _time32_to_time(dp->dp1.di_mtime);
spcl.c_mtimensec = dp->dp1.di_mtimensec;
spcl.c_birthtime = 0;
spcl.c_birthtimensec = 0;
spcl.c_rdev = dp->dp1.di_rdev;
spcl.c_file_flags = dp->dp1.di_flags;
spcl.c_uid = dp->dp1.di_uid;
spcl.c_gid = dp->dp1.di_gid;
} else {
spcl.c_mode = dp->dp2.di_mode;
spcl.c_size = dp->dp2.di_size;
spcl.c_extsize = dp->dp2.di_extsize;
spcl.c_atime = _time64_to_time(dp->dp2.di_atime);
spcl.c_atimensec = dp->dp2.di_atimensec;
spcl.c_mtime = _time64_to_time(dp->dp2.di_mtime);
spcl.c_mtimensec = dp->dp2.di_mtimensec;
spcl.c_birthtime = _time64_to_time(dp->dp2.di_birthtime);
spcl.c_birthtimensec = dp->dp2.di_birthnsec;
spcl.c_rdev = dp->dp2.di_rdev;
spcl.c_file_flags = dp->dp2.di_flags;
spcl.c_uid = dp->dp2.di_uid;
spcl.c_gid = dp->dp2.di_gid;
}
spcl.c_type = TS_INODE;
spcl.c_count = 0;
switch (DIP(dp, di_mode) & S_IFMT) {
case 0:
/*
* Freed inode.
*/
return;
case S_IFLNK:
/*
* Check for short symbolic link.
*/
if (DIP(dp, di_size) > 0 &&
DIP(dp, di_size) < sblock->fs_maxsymlinklen) {
spcl.c_addr[0] = 1;
spcl.c_count = 1;
added = appendextdata(dp);
writeheader(ino);
if (sblock->fs_magic == FS_UFS1_MAGIC)
memmove(buf, (caddr_t)dp->dp1.di_db,
(u_long)DIP(dp, di_size));
else
memmove(buf, (caddr_t)dp->dp2.di_db,
(u_long)DIP(dp, di_size));
buf[DIP(dp, di_size)] = '\0';
writerec(buf, 0);
writeextdata(dp, ino, added);
return;
}
/* FALLTHROUGH */
case S_IFDIR:
case S_IFREG:
if (DIP(dp, di_size) > 0)
break;
/* FALLTHROUGH */
case S_IFIFO:
case S_IFSOCK:
case S_IFCHR:
case S_IFBLK:
added = appendextdata(dp);
writeheader(ino);
writeextdata(dp, ino, added);
return;
default:
msg("Warning: undefined file type 0%o\n",
DIP(dp, di_mode) & IFMT);
return;
}
if (DIP(dp, di_size) > NDADDR * sblock->fs_bsize) {
cnt = NDADDR * sblock->fs_frag;
last = 0;
} else {
cnt = howmany(DIP(dp, di_size), sblock->fs_fsize);
last = 1;
}
if (sblock->fs_magic == FS_UFS1_MAGIC)
ufs1_blksout(&dp->dp1.di_db[0], cnt, ino);
else
ufs2_blksout(dp, &dp->dp2.di_db[0], cnt, ino, last);
if ((size = DIP(dp, di_size) - NDADDR * sblock->fs_bsize) <= 0)
return;
for (ind_level = 0; ind_level < NIADDR; ind_level++) {
dmpindir(dp, ino, DIP(dp, di_ib[ind_level]), ind_level, &size);
if (size <= 0)
return;
}
}