static char
filetype(mode_t mode)
{
/* common cases first */
if (S_ISREG(mode)) return '-';
if (S_ISDIR(mode)) return 'd';
if (S_ISLNK(mode)) return 'l';
/* special files */
if (S_ISBLK(mode)) return 'b';
if (S_ISCHR(mode)) return 'c';
if (S_ISFIFO(mode)) return 'p';
if (S_ISSOCK(mode)) return 's';
/* non-standard types */
if (S_ISDOOR(mode)) return 'D';
if (S_ISPORT(mode)) return 'P';
if (S_ISWHT(mode)) return 'w';
/* unknown */
return '?';
}
static char
ftypelet (mode_t bits)
{
/* These are the most common, so test for them first. */
if (S_ISREG (bits))
return '-';
if (S_ISDIR (bits))
return 'd';
/* Other letters standardized by POSIX 1003.1-2004. */
if (S_ISBLK (bits))
return 'b';
if (S_ISCHR (bits))
return 'c';
if (S_ISLNK (bits))
return 'l';
if (S_ISFIFO (bits))
return 'p';
/* Other file types (though not letters) standardized by POSIX. */
if (S_ISSOCK (bits))
return 's';
/* Nonstandard file types. */
if (S_ISCTG (bits))
return 'C';
if (S_ISDOOR (bits))
return 'D';
if (S_ISMPB (bits) || S_ISMPC (bits) || S_ISMPX (bits))
return 'm';
if (S_ISNWK (bits))
return 'n';
if (S_ISPORT (bits))
return 'P';
if (S_ISWHT (bits))
return 'w';
return '?';
}
S_IRWXG, S_IRGRP, S_IWGRP, S_IXGRP,
S_IRWXO, S_IROTH, S_IWOTH, S_IXOTH,
S_ISUID, S_ISGID, S_ISVTX,
S_ISBLK (S_IFREG),
S_ISCHR (S_IFREG),
S_ISDIR (S_IFREG),
S_ISFIFO (S_IFREG),
S_ISREG (S_IFREG),
S_ISLNK (S_IFREG),
S_ISSOCK (S_IFREG),
S_ISDOOR (S_IFREG),
S_ISMPB (S_IFREG),
S_ISMPX (S_IFREG),
S_ISNAM (S_IFREG),
S_ISNWK (S_IFREG),
S_ISPORT (S_IFREG),
S_ISCTG (S_IFREG),
S_ISOFD (S_IFREG),
S_ISOFL (S_IFREG),
S_ISWHT (S_IFREG)
};
/* Sanity checks. */
verify (S_IRWXU == (S_IRUSR | S_IWUSR | S_IXUSR));
verify (S_IRWXG == (S_IRGRP | S_IWGRP | S_IXGRP));
verify (S_IRWXO == (S_IROTH | S_IWOTH | S_IXOTH));
#ifdef S_IFBLK
verify (S_ISBLK (S_IFBLK));
#endif
static int restore_special(struct asfd *asfd, struct sbuf *sb,
const char *fname, enum action act, struct conf *conf)
{
int ret=0;
char *rpath=NULL;
#ifdef HAVE_WIN32
logw(asfd, conf, "Cannot restore special files to Windows: %s\n", fname);
goto end;
#else
struct stat statp=sb->statp;
if(act==ACTION_VERIFY)
{
cntr_add(conf->cntr, CMD_SPECIAL, 1);
return 0;
}
if(build_path(fname, "", &rpath, NULL))
{
char msg[256]="";
// failed - do a warning
snprintf(msg, sizeof(msg), "build path failed: %s", fname);
if(restore_interrupt(asfd, sb, msg, conf))
ret=-1;
goto end;
}
if(S_ISFIFO(statp.st_mode))
{
if(mkfifo(rpath, statp.st_mode) && errno!=EEXIST)
{
char msg[256]="";
snprintf(msg, sizeof(msg),
"Cannot make fifo: %s\n", strerror(errno));
logw(asfd, conf, "%s", msg);
}
else
{
attribs_set(asfd, rpath, &statp, sb->winattr, conf);
cntr_add(conf->cntr, CMD_SPECIAL, 1);
}
/*
}
else if(S_ISSOCK(statp.st_mode)) {
char msg[256]="";
snprintf(msg, sizeof(msg),
"Skipping restore of socket: %s\n", fname);
logw(conf, "%s", msg);
*/
#ifdef S_IFDOOR // Solaris high speed RPC mechanism
} else if (S_ISDOOR(statp.st_mode)) {
char msg[256]="";
snprintf(msg, sizeof(msg),
"Skipping restore of door file: %s\n", fname);
logw(conf, "%s", msg);
#endif
#ifdef S_IFPORT // Solaris event port for handling AIO
} else if (S_ISPORT(statp.st_mode)) {
char msg[256]="";
snprintf(msg, sizeof(msg),
"Skipping restore of event port file: %s\n", fname);
logw(conf, "%s", msg);
#endif
} else {
if(mknod(fname, statp.st_mode, statp.st_rdev) && errno!=EEXIST)
{
char msg[256]="";
snprintf(msg, sizeof(msg),
"Cannot make node: %s\n", strerror(errno));
logw(asfd, conf, "%s", msg);
}
else
{
attribs_set(asfd, rpath, &statp, sb->winattr, conf);
cntr_add(conf->cntr, CMD_SPECIAL, 1);
}
}
#endif
end:
if(rpath) free(rpath);
return ret;
}
static int restore_special(struct asfd *asfd, struct sbuf *sb,
const char *fname, enum action act, struct cntr *cntr,
enum protocol protocol)
{
int ret=0;
char *rpath=NULL;
#ifdef HAVE_WIN32
logw(asfd, cntr, "Cannot restore special files to Windows: %s\n", fname);
goto end;
#else
struct stat statp=sb->statp;
if(act==ACTION_VERIFY)
{
cntr_add(cntr, CMD_SPECIAL, 1);
return 0;
}
if(build_path(fname, "", &rpath, NULL))
{
// failed - do a warning
if(restore_interrupt(asfd, sb,
build_msg("build path failed: %s", fname),
cntr, protocol))
ret=-1;
goto end;
}
if(S_ISFIFO(statp.st_mode))
{
if(mkfifo(rpath, statp.st_mode) && errno!=EEXIST)
do_logw(asfd, cntr,
"Cannot make fifo: %s\n", strerror(errno));
else
{
attribs_set(asfd, rpath, &statp, sb->winattr, cntr);
cntr_add(cntr, CMD_SPECIAL, 1);
}
}
else if(S_ISSOCK(statp.st_mode))
{
if(mksock(rpath))
do_logw(asfd, cntr,
"Cannot make socket: %s\n", strerror(errno));
else
{
attribs_set(asfd, rpath, &statp, sb->winattr, cntr);
cntr_add(cntr, CMD_SPECIAL, 1);
}
}
#ifdef S_IFDOOR // Solaris high speed RPC mechanism
else if (S_ISDOOR(statp.st_mode))
do_logw(asfd, cntr,
"Skipping restore of door file: %s\n", fname);
#endif
#ifdef S_IFPORT // Solaris event port for handling AIO
else if (S_ISPORT(statp.st_mode))
do_logw(asfd, cntr,
"Skipping restore of event port file: %s\n", fname);
#endif
else if(mknod(fname, statp.st_mode, statp.st_rdev) && errno!=EEXIST)
do_logw(asfd, cntr, "Cannot make node: %s\n", strerror(errno));
else
{
attribs_set(asfd, rpath, &statp, sb->winattr, cntr);
cntr_add(cntr, CMD_SPECIAL, 1);
}
#endif
end:
free_w(&rpath);
return ret;
}
/*
* Create the file, or the directory
*
* fname is the original filename
* ofile is the output filename (may be in a different directory)
*
* Returns: CF_SKIP if file should be skipped
* CF_ERROR on error
* CF_EXTRACT file created and data to restore
* CF_CREATED file created no data to restore
*
* Note, we create the file here, except for special files,
* we do not set the attributes because we want to first
* write the file, then when the writing is done, set the
* attributes.
* So, we return with the file descriptor open for normal
* files.
*
*/
int create_file(JCR *jcr, ATTR *attr, BFILE *bfd, int replace)
{
mode_t new_mode, parent_mode;
int flags;
uid_t uid;
gid_t gid;
int pnl;
bool exists = false;
struct stat mstatp;
bfd->reparse_point = false;
if (is_win32_stream(attr->data_stream)) {
set_win32_backup(bfd);
} else {
set_portable_backup(bfd);
}
new_mode = attr->statp.st_mode;
Dmsg3(200, "type=%d newmode=%x file=%s\n", attr->type, new_mode, attr->ofname);
parent_mode = S_IWUSR | S_IXUSR | new_mode;
gid = attr->statp.st_gid;
uid = attr->statp.st_uid;
#ifdef HAVE_WIN32
if (!bfd->use_backup_api) {
// eliminate invalid windows filename characters from foreign filenames
char *ch = (char *)attr->ofname;
if (ch[0] != 0 && ch[1] != 0) {
ch += 2;
while (*ch) {
switch (*ch) {
case ':':
case '<':
case '>':
case '*':
case '?':
case '|':
*ch = '_';
break;
}
ch++;
}
}
}
#endif
Dmsg2(400, "Replace=%c %d\n", (char)replace, replace);
if (lstat(attr->ofname, &mstatp) == 0) {
exists = true;
switch (replace) {
case REPLACE_IFNEWER:
if (attr->statp.st_mtime <= mstatp.st_mtime) {
Qmsg(jcr, M_SKIPPED, 0, _("File skipped. Not newer: %s\n"), attr->ofname);
return CF_SKIP;
}
break;
case REPLACE_IFOLDER:
if (attr->statp.st_mtime >= mstatp.st_mtime) {
Qmsg(jcr, M_SKIPPED, 0, _("File skipped. Not older: %s\n"), attr->ofname);
return CF_SKIP;
}
break;
case REPLACE_NEVER:
Qmsg(jcr, M_SKIPPED, 0, _("File skipped. Already exists: %s\n"), attr->ofname);
return CF_SKIP;
case REPLACE_ALWAYS:
break;
}
}
switch (attr->type) {
case FT_RAW: /* raw device to be written */
case FT_FIFO: /* FIFO to be written to */
case FT_LNKSAVED: /* Hard linked, file already saved */
case FT_LNK:
case FT_SPEC: /* fifo, ... to be backed up */
case FT_REGE: /* empty file */
case FT_REG: /* regular file */
/*
* Note, we do not delete FT_RAW because these are device files
* or FIFOs that should already exist. If we blow it away,
* we may blow away a FIFO that is being used to read the
* restore data, or we may blow away a partition definition.
*/
if (exists && attr->type != FT_RAW && attr->type != FT_FIFO) {
/* Get rid of old copy */
Dmsg1(400, "unlink %s\n", attr->ofname);
if (unlink(attr->ofname) == -1) {
berrno be;
Qmsg(jcr, M_ERROR, 0, _("File %s already exists and could not be replaced. ERR=%s.\n"),
attr->ofname, be.bstrerror());
/* Continue despite error */
}
}
/*
* Here we do some preliminary work for all the above
* types to create the path to the file if it does
* not already exist. Below, we will split to
* do the file type specific work
*/
pnl = separate_path_and_file(jcr, attr->fname, attr->ofname);
if (pnl < 0) {
return CF_ERROR;
}
/*
* If path length is <= 0 we are making a file in the root
* directory. Assume that the directory already exists.
*/
if (pnl > 0) {
char savechr;
savechr = attr->ofname[pnl];
attr->ofname[pnl] = 0; /* terminate path */
if (!path_already_seen(jcr, attr->ofname, pnl)) {
Dmsg1(400, "Make path %s\n", attr->ofname);
/*
* If we need to make the directory, ensure that it is with
* execute bit set (i.e. parent_mode), and preserve what already
* exists. Normally, this should do nothing.
*/
if (!makepath(attr, attr->ofname, parent_mode, parent_mode, uid, gid, 1)) {
Dmsg1(10, "Could not make path. %s\n", attr->ofname);
attr->ofname[pnl] = savechr; /* restore full name */
return CF_ERROR;
}
}
attr->ofname[pnl] = savechr; /* restore full name */
}
/* Now we do the specific work for each file type */
switch(attr->type) {
case FT_REGE:
case FT_REG:
Dmsg1(100, "Create=%s\n", attr->ofname);
flags = O_WRONLY | O_CREAT | O_TRUNC | O_BINARY; /* O_NOFOLLOW; */
if (IS_CTG(attr->statp.st_mode)) {
flags |= O_CTG; /* set contiguous bit if needed */
}
if (is_bopen(bfd)) {
Qmsg1(jcr, M_ERROR, 0, _("bpkt already open fid=%d\n"), bfd->fid);
bclose(bfd);
}
if ((bopen(bfd, attr->ofname, flags, S_IRUSR | S_IWUSR)) < 0) {
berrno be;
be.set_errno(bfd->berrno);
Qmsg2(jcr, M_ERROR, 0, _("Could not create %s: ERR=%s\n"),
attr->ofname, be.bstrerror());
Dmsg2(100,"Could not create %s: ERR=%s\n", attr->ofname, be.bstrerror());
return CF_ERROR;
}
return CF_EXTRACT;
#ifndef HAVE_WIN32 // none of these exists on MS Windows
case FT_RAW: /* Bacula raw device e.g. /dev/sda1 */
case FT_FIFO: /* Bacula fifo to save data */
case FT_SPEC:
if (S_ISFIFO(attr->statp.st_mode)) {
Dmsg1(400, "Restore fifo: %s\n", attr->ofname);
if (mkfifo(attr->ofname, attr->statp.st_mode) != 0 && errno != EEXIST) {
berrno be;
Qmsg2(jcr, M_ERROR, 0, _("Cannot make fifo %s: ERR=%s\n"),
attr->ofname, be.bstrerror());
return CF_ERROR;
}
} else if (S_ISSOCK(attr->statp.st_mode)) {
Dmsg1(200, "Skipping restore of socket: %s\n", attr->ofname);
#ifdef S_IFDOOR // Solaris high speed RPC mechanism
} else if (S_ISDOOR(attr->statp.st_mode)) {
Dmsg1(200, "Skipping restore of door file: %s\n", attr->ofname);
#endif
#ifdef S_IFPORT // Solaris event port for handling AIO
} else if (S_ISPORT(attr->statp.st_mode)) {
Dmsg1(200, "Skipping restore of event port file: %s\n", attr->ofname);
#endif
} else {
Dmsg1(400, "Restore node: %s\n", attr->ofname);
if (mknod(attr->ofname, attr->statp.st_mode, attr->statp.st_rdev) != 0 && errno != EEXIST) {
berrno be;
Qmsg2(jcr, M_ERROR, 0, _("Cannot make node %s: ERR=%s\n"),
attr->ofname, be.bstrerror());
return CF_ERROR;
}
}
/*
* Here we are going to attempt to restore to a FIFO, which
* means that the FIFO must already exist, AND there must
* be some process already attempting to read from the
* FIFO, so we open it write-only.
*/
if (attr->type == FT_RAW || attr->type == FT_FIFO) {
btimer_t *tid;
Dmsg1(400, "FT_RAW|FT_FIFO %s\n", attr->ofname);
flags = O_WRONLY | O_BINARY;
/* Timeout open() in 60 seconds */
if (attr->type == FT_FIFO) {
Dmsg0(400, "Set FIFO timer\n");
tid = start_thread_timer(jcr, pthread_self(), 60);
} else {
tid = NULL;
}
if (is_bopen(bfd)) {
Qmsg1(jcr, M_ERROR, 0, _("bpkt already open fid=%d\n"), bfd->fid);
}
Dmsg2(400, "open %s flags=0x%x\n", attr->ofname, flags);
if ((bopen(bfd, attr->ofname, flags, 0)) < 0) {
berrno be;
be.set_errno(bfd->berrno);
Qmsg2(jcr, M_ERROR, 0, _("Could not open %s: ERR=%s\n"),
attr->ofname, be.bstrerror());
Dmsg2(400, "Could not open %s: ERR=%s\n", attr->ofname, be.bstrerror());
stop_thread_timer(tid);
return CF_ERROR;
}
stop_thread_timer(tid);
return CF_EXTRACT;
}
Dmsg1(400, "FT_SPEC %s\n", attr->ofname);
return CF_CREATED;
case FT_LNK:
Dmsg2(130, "FT_LNK should restore: %s -> %s\n", attr->ofname, attr->olname);
if (symlink(attr->olname, attr->ofname) != 0 && errno != EEXIST) {
berrno be;
Qmsg3(jcr, M_ERROR, 0, _("Could not symlink %s -> %s: ERR=%s\n"),
attr->ofname, attr->olname, be.bstrerror());
return CF_ERROR;
}
return CF_CREATED;
case FT_LNKSAVED: /* Hard linked, file already saved */
Dmsg2(130, "Hard link %s => %s\n", attr->ofname, attr->olname);
if (link(attr->olname, attr->ofname) != 0) {
berrno be;
#ifdef HAVE_CHFLAGS
struct stat s;
/*
* If using BSD user flags, maybe has a file flag
* preventing this. So attempt to disable, retry link,
* and reset flags.
* Note that BSD securelevel may prevent disabling flag.
*/
if (stat(attr->olname, &s) == 0 && s.st_flags != 0) {
if (chflags(attr->olname, 0) == 0) {
if (link(attr->olname, attr->ofname) != 0) {
/* restore original file flags even when linking failed */
if (chflags(attr->olname, s.st_flags) < 0) {
Qmsg2(jcr, M_ERROR, 0, _("Could not restore file flags for file %s: ERR=%s\n"),
attr->olname, be.bstrerror());
}
#endif /* HAVE_CHFLAGS */
Qmsg3(jcr, M_ERROR, 0, _("Could not hard link %s -> %s: ERR=%s\n"),
attr->ofname, attr->olname, be.bstrerror());
Dmsg3(200, "Could not hard link %s -> %s: ERR=%s\n",
attr->ofname, attr->olname, be.bstrerror());
return CF_ERROR;
#ifdef HAVE_CHFLAGS
}
/* finally restore original file flags */
if (chflags(attr->olname, s.st_flags) < 0) {
Qmsg2(jcr, M_ERROR, 0, _("Could not restore file flags for file %s: ERR=%s\n"),
attr->olname, be.bstrerror());
}
} else {
Qmsg2(jcr, M_ERROR, 0, _("Could not reset file flags for file %s: ERR=%s\n"),
attr->olname, be.bstrerror());
}
} else {
Qmsg3(jcr, M_ERROR, 0, _("Could not hard link %s -> %s: ERR=%s\n"),
attr->ofname, attr->olname, be.bstrerror());
return CF_ERROR;
}
#endif /* HAVE_CHFLAGS */
}
return CF_CREATED;
#endif
} /* End inner switch */
case FT_REPARSE:
bfd->reparse_point = true;
/* Fall through wanted */
case FT_DIRBEGIN:
case FT_DIREND:
Dmsg2(200, "Make dir mode=%o dir=%s\n", new_mode, attr->ofname);
if (!makepath(attr, attr->ofname, new_mode, parent_mode, uid, gid, 0)) {
return CF_ERROR;
}
/*
* If we are using the Win32 Backup API, we open the
* directory so that the security info will be read
* and saved.
*/
if (!is_portable_backup(bfd)) {
if (is_bopen(bfd)) {
Qmsg1(jcr, M_ERROR, 0, _("bpkt already open fid=%d\n"), bfd->fid);
}
if ((bopen(bfd, attr->ofname, O_WRONLY|O_BINARY, 0)) < 0) {
berrno be;
be.set_errno(bfd->berrno);
#ifdef HAVE_WIN32
/* Check for trying to create a drive, if so, skip */
if (attr->ofname[1] == ':' &&
IsPathSeparator(attr->ofname[2]) &&
attr->ofname[3] == '\0') {
return CF_SKIP;
}
#endif
Qmsg2(jcr, M_ERROR, 0, _("Could not open %s: ERR=%s\n"),
attr->ofname, be.bstrerror());
return CF_ERROR;
}
return CF_EXTRACT;
} else {
return CF_CREATED;
}
case FT_DELETED:
Qmsg2(jcr, M_INFO, 0, _("Original file %s have been deleted: type=%d\n"), attr->fname, attr->type);
break;
/* The following should not occur */
case FT_NOACCESS:
case FT_NOFOLLOW:
case FT_NOSTAT:
case FT_DIRNOCHG:
case FT_NOCHG:
case FT_ISARCH:
case FT_NORECURSE:
case FT_NOFSCHG:
case FT_NOOPEN:
Qmsg2(jcr, M_ERROR, 0, _("Original file %s not saved: type=%d\n"), attr->fname, attr->type);
break;
default:
Qmsg2(jcr, M_ERROR, 0, _("Unknown file type %d; not restored: %s\n"), attr->type, attr->fname);
break;
}
return CF_ERROR;
}
char const *
file_type (struct stat const *st)
{
/* See POSIX 1003.1-2001 XCU Table 4-8 lines 17093-17107 for some of
these formats.
To keep diagnostics grammatical in English, the returned string
must start with a consonant. */
/* Do these three first, as they're the most common. */
if (S_ISREG (st->st_mode))
return st->st_size == 0 ? _("regular empty file") : _("regular file");
if (S_ISDIR (st->st_mode))
return _("directory");
if (S_ISLNK (st->st_mode))
return _("symbolic link");
/* Do the S_TYPEIS* macros next, as they may be implemented in terms
of S_ISNAM, and we want the more-specialized interpretation. */
if (S_TYPEISMQ (st))
return _("message queue");
if (S_TYPEISSEM (st))
return _("semaphore");
if (S_TYPEISSHM (st))
return _("shared memory object");
if (S_TYPEISTMO (st))
return _("typed memory object");
/* The remaining are in alphabetical order. */
if (S_ISBLK (st->st_mode))
return _("block special file");
if (S_ISCHR (st->st_mode))
return _("character special file");
if (S_ISCTG (st->st_mode))
return _("contiguous data");
if (S_ISFIFO (st->st_mode))
return _("fifo");
if (S_ISDOOR (st->st_mode))
return _("door");
if (S_ISMPB (st->st_mode))
return _("multiplexed block special file");
if (S_ISMPC (st->st_mode))
return _("multiplexed character special file");
if (S_ISMPX (st->st_mode))
return _("multiplexed file");
if (S_ISNAM (st->st_mode))
return _("named file");
if (S_ISNWK (st->st_mode))
return _("network special file");
if (S_ISOFD (st->st_mode))
return _("migrated file with data");
if (S_ISOFL (st->st_mode))
return _("migrated file without data");
if (S_ISPORT (st->st_mode))
return _("port");
if (S_ISSOCK (st->st_mode))
return _("socket");
if (S_ISWHT (st->st_mode))
return _("whiteout");
return _("weird file");
}
