static boolean getodbvalue (hdltreenode hparam1, short pnum, tyodbrecord *odb, boolean flreadonly) {
//
// 2006-06-23 creedon: for Mac, FSRef-ized
//
hdlodbrecord hodb;
if (!getodbparam (hparam1, pnum, &hodb))
return (false);
*odb = **hodb;
if ((*odb).flreadonly && !flreadonly) {
bigstring bs;
getfsfile ( &( *odb ).fs, bs );
lang2paramerror (dbopenedreadonlyerror, bsfunctionname, bs );
return (false);
}
return (true);
} // getodbvalue
static boolean getodbparam (hdltreenode hparam1, short pnum, hdlodbrecord *hodbrecord) {
//
// 2006-06-23 creedon: for Mac, FSRef-zed
//
bigstring bs;
hdlodbrecord hodb;
tyfilespec fs;
ptrfilespec ptrfs;
ptrfs = &fs;
if (!getfilespecvalue (hparam1, pnum, ptrfs))
return (false);
for (hodb = hodblist; hodb != nil; hodb = (**hodb).hnext) {
if ( equalfilespecs ( &( **hodb ).fs, ptrfs ) ) {
*hodbrecord = hodb;
return (true);
}
}
getfsfile ( ptrfs, bs );
lang2paramerror (dbnotopenederror, bsfunctionname, bs );
return (false);
} // getodbparam
static void
putfsent(const struct statfs *ent)
{
struct stat sb;
struct fstab *fst;
char *opts;
opts = flags2opts(ent->f_flags);
printf("%s\t%s\t%s %s", ent->f_mntfromname, ent->f_mntonname,
ent->f_fstypename, opts);
free(opts);
/*
* If fstab file is missing don't call getfsspec() or getfsfile()
* at all, because the same warning will be printed twice for every
* mounted filesystem.
*/
if (stat(_PATH_FSTAB, &sb) != -1) {
if ((fst = getfsspec(ent->f_mntfromname)))
printf("\t%u %u\n", fst->fs_freq, fst->fs_passno);
else if ((fst = getfsfile(ent->f_mntonname)))
printf("\t%u %u\n", fst->fs_freq, fst->fs_passno);
else
printdefvals(ent);
} else {
printdefvals(ent);
}
}
int
main(int argc, char *argv[])
{
char all = 0;
struct statfs *mp;
struct fstab *fs;
int cnt;
func = douser;
#ifndef COMPAT
header = getbsize(&headerlen,&blocksize);
#endif
while (--argc > 0 && **++argv == '-') {
while (*++*argv) {
switch (**argv) {
case 'n':
func = donames;
break;
case 'c':
func = dofsizes;
break;
case 'a':
all = 1;
break;
case 'f':
count = 1;
break;
case 'h':
estimate = 1;
break;
#ifndef COMPAT
case 'k':
blocksize = 1024;
break;
#endif /* COMPAT */
case 'v':
unused = 1;
break;
default:
usage();
}
}
}
if (all) {
cnt = getmntinfo(&mp,MNT_NOWAIT);
for (; --cnt >= 0; mp++) {
if (!strncmp(mp->f_fstypename, "ufs", MFSNAMELEN))
quot(mp->f_mntfromname, mp->f_mntonname);
}
}
while (--argc >= 0) {
if ((fs = getfsfile(*argv)) != NULL)
quot(fs->fs_spec, 0);
else
quot(*argv,0);
argv++;
}
return 0;
}
/* Create mtab with a root entry. */
static void
create_mtab (void)
{
struct mntent *fstab;
if ((F_mtab = setmntent (MOUNTED, "a+")) == NULL)
die (1, "mount: can't open %s for writing: %s", MOUNTED, strerror (errno));
/* Find the root entry by looking it up in fstab, which might be wrong.
We could statfs "/" followed by a slew of stats on /dev/ but then
we'd have to unparse the mount options as well.... */
if ((fstab = getfsfile ("/")) || (fstab = getfsfile ("root")))
{
if (addmntent (F_mtab, fstab) == 1)
die (1, "mount: error writing %s: %s", MOUNTED, strerror (errno));
}
endmntent (F_mtab);
}
void testValues() {
f = 2;
struct fstab * result = getfsfile(anystring());
//@ assert result == \null || \valid(result);
//@ assert f == 2;
//@ assert vacuous: \false;
}
void
putfsent(struct statfs *ent)
{
struct fstab *fst;
char *opts, *rw;
int l;
opts = NULL;
/* flags2opts() doesn't return the "rw" option. */
if ((ent->f_flags & MNT_RDONLY) != 0)
rw = NULL;
else
rw = catopt(NULL, "rw");
opts = flags2opts(ent->f_flags);
opts = catopt(rw, opts);
if (strncmp(ent->f_mntfromname, "<below>", 7) == 0 ||
strncmp(ent->f_mntfromname, "<above>", 7) == 0) {
strcpy(ent->f_mntfromname, (strnstr(ent->f_mntfromname, ":", 8)
+1));
}
l = strlen(ent->f_mntfromname);
printf("%s%s%s%s", ent->f_mntfromname,
l < 8 ? "\t" : "",
l < 16 ? "\t" : "",
l < 24 ? "\t" : " ");
l = strlen(ent->f_mntonname);
printf("%s%s%s%s", ent->f_mntonname,
l < 8 ? "\t" : "",
l < 16 ? "\t" : "",
l < 24 ? "\t" : " ");
printf("%s\t", ent->f_fstypename);
l = strlen(opts);
printf("%s%s", opts,
l < 8 ? "\t" : " ");
free(opts);
if ((fst = getfsspec(ent->f_mntfromname)))
printf("\t%u %u\n", fst->fs_freq, fst->fs_passno);
else if ((fst = getfsfile(ent->f_mntonname)))
printf("\t%u %u\n", fst->fs_freq, fst->fs_passno);
else if (strcmp(ent->f_fstypename, "ufs") == 0) {
if (strcmp(ent->f_mntonname, "/") == 0)
printf("\t1 1\n");
else
printf("\t2 2\n");
} else
printf("\t0 0\n");
}
/*
* XXX this code is from NetBSD, but fails in FreeBSD because we
* don't have blockdevs. I don't think its needed.
*/
const char *
blockcheck(const char *origname)
{
struct stat stslash, stblock, stchar;
const char *newname, *raw;
struct fstab *fsp;
int retried = 0;
hot = 0;
if (stat("/", &stslash) < 0) {
perror("/");
printf("Can't stat root\n");
return (origname);
}
newname = origname;
retry:
if (stat(newname, &stblock) < 0) {
perror(newname);
printf("Can't stat %s\n", newname);
return (origname);
}
if (S_ISBLK(stblock.st_mode)) {
if (stslash.st_dev == stblock.st_rdev)
hot++;
raw = rawname(newname);
if (stat(raw, &stchar) < 0) {
perror(raw);
printf("Can't stat %s\n", raw);
return (origname);
}
if (S_ISCHR(stchar.st_mode)) {
return (raw);
} else {
printf("%s is not a character device\n", raw);
return (origname);
}
} else if (S_ISCHR(stblock.st_mode) && !retried) {
newname = unrawname(newname);
retried++;
goto retry;
} else if ((fsp = getfsfile(newname)) != 0 && !retried) {
newname = fsp->fs_spec;
retried++;
goto retry;
}
/*
* Not a block or character device, just return name and
* let the user decide whether to use it.
*/
return (origname);
}
static int
openpartition(char *name, int flags, char **devicep)
{
char rawspec[MAXPATHLEN], *p;
struct fstab *fs;
int fd;
fs = getfsfile(name);
if (fs) {
if ((p = strrchr(fs->fs_spec, '/')) != NULL) {
snprintf(rawspec, sizeof(rawspec), "%.*s/r%s",
(int)(p - fs->fs_spec), fs->fs_spec, p + 1);
name = rawspec;
} else
name = fs->fs_spec;
}
fd = opendev(name, flags, 0, devicep);
if (fd == -1 && errno == ENOENT)
devicep = &name;
return (fd);
}
gint32
Mono_Posix_Syscall_getfsfile (const char *mount_point,
struct Mono_Posix_Syscall__Fstab *fsbuf)
{
mph_fstab *fs;
if (fsbuf == NULL) {
errno = EFAULT;
return -1;
}
fs = getfsfile (mount_point);
if (fs == NULL)
return -1;
if (copy_fstab (fsbuf, fs) == -1) {
errno = ENOMEM;
return -1;
}
return 0;
}
boolean claygetfilename (const tybrowserspec *pfs, bigstring name) {
//
// 2006-06-23 creedon: FSRef-ized
//
#if filebrowser
return (getfsfile (pfs, name));
#endif
#if odbbrowser
copystring ((*pfs).name, name);
return (true);
#endif
} // claygetfilename
dvd_reader_t *DVDOpen( const char *path )
{
struct stat fileinfo;
int ret, have_css;
char *dev_name = NULL;
int internal_errno = 0;
int verbose;
if( path == NULL ) {
errno = EINVAL;
return NULL;
}
verbose = get_verbose();
#ifdef WIN32
/* Stat doesn't work on devices under mingwin/cygwin. */
if( path[0] && path[1] == ':' && path[2] == '\0' )
{
/* Don't try to stat the file */
fileinfo.st_mode = S_IFBLK;
}
else
#endif
{
ret = stat( path, &fileinfo );
if( ret < 0 ) {
int tmp_errno = errno;
/* If we can't stat the file, give up */
if(verbose >= 1) {
fprintf( stderr, "libdvdread: Can't stat '%s': %s\n",
path, strerror(errno));
}
errno = tmp_errno;
return NULL;
}
}
/* Try to open libdvdcss or fall back to standard functions */
have_css = dvdinput_setup();
/* First check if this is a block/char device or a file*/
if( S_ISBLK( fileinfo.st_mode ) ||
S_ISCHR( fileinfo.st_mode ) ||
S_ISREG( fileinfo.st_mode ) ) {
/**
* Block devices and regular files are assumed to be DVD-Video images.
*/
dvd_reader_t *dvd = NULL;
#if defined(__sun)
dev_name = sun_block2char( path );
#elif defined(SYS_BSD)
dev_name = bsd_block2char( path );
#else
dev_name = strdup( path );
#endif
dvd = DVDOpenImageFile( dev_name, have_css );
free( dev_name );
return dvd;
} else if( S_ISDIR( fileinfo.st_mode ) ) {
dvd_reader_t *auth_drive = 0;
char *path_copy;
#if defined(SYS_BSD)
struct fstab* fe;
#elif defined(__sun) || defined(__linux__) || defined(__CYGWIN__)
FILE *mntfile;
#endif
/* XXX: We should scream real loud here. */
if( !(path_copy = strdup( path ) ) ) return 0;
#ifndef WIN32 /* don't have fchdir, and getcwd( NULL, ... ) is strange */
/* Resolve any symlinks and get the absolut dir name. */
{
char *new_path;
char *current_path;
current_path = malloc(PATH_MAX);
if(current_path) {
if(!getcwd(current_path, PATH_MAX)) {
free(current_path);
current_path = NULL;
}
}
if(current_path) {
chdir( path_copy );
new_path = malloc(PATH_MAX);
if(new_path) {
if(!getcwd(new_path, PATH_MAX )) {
free(new_path);
new_path = NULL;
}
}
chdir(current_path);
free(current_path);
if( new_path ) {
free( path_copy );
path_copy = new_path;
}
}
}
#endif
/**
* If we're being asked to open a directory, check if that directory
* is the mountpoint for a DVD-ROM which we can use instead.
*/
if( strlen( path_copy ) > 1 ) {
if( path_copy[ strlen( path_copy ) - 1 ] == '/' ) {
path_copy[ strlen( path_copy ) - 1 ] = '\0';
}
}
if( strlen( path_copy ) >= 9 ) {
if( !strcasecmp( &(path_copy[ strlen( path_copy ) - 9 ]),
"/video_ts" ) ) {
path_copy[ strlen( path_copy ) - 9 ] = '\0';
if(path_copy[0] == '\0') {
path_copy[0] = '/';
path_copy[1] = '\0';
}
}
}
#if defined(SYS_BSD)
if( ( fe = getfsfile( path_copy ) ) ) {
dev_name = bsd_block2char( fe->fs_spec );
if(verbose >= 1) {
fprintf( stderr,
"libdvdread: Attempting to use device %s"
" mounted on %s%s\n",
dev_name,
fe->fs_file,
have_css ? " for CSS authentication" : "");
}
auth_drive = DVDOpenImageFile( dev_name, have_css );
if(!auth_drive) {
internal_errno = errno;
}
}
#elif defined(__sun)
mntfile = fopen( MNTTAB, "r" );
if( mntfile ) {
struct mnttab mp;
int res;
while( ( res = getmntent( mntfile, &mp ) ) != -1 ) {
if( res == 0 && !strcmp( mp.mnt_mountp, path_copy ) ) {
dev_name = sun_block2char( mp.mnt_special );
if(verbose >= 1) {
fprintf( stderr,
"libdvdread: Attempting to use device %s"
" mounted on %s%s\n",
dev_name,
mp.mnt_mountp,
have_css ? " for CSS authentication" : "");
}
auth_drive = DVDOpenImageFile( dev_name, have_css );
if(!auth_drive) {
internal_errno = errno;
}
break;
}
}
fclose( mntfile );
}
#elif defined(__linux__) || defined(__CYGWIN__)
mntfile = fopen( MOUNTED, "r" );
if( mntfile ) {
struct mntent *me;
while( ( me = getmntent( mntfile ) ) ) {
if( !strcmp( me->mnt_dir, path_copy ) ) {
if(verbose >= 1) {
fprintf( stderr,
"libdvdread: Attempting to use device %s"
" mounted on %s%s\n",
me->mnt_fsname,
me->mnt_dir,
have_css ? " for CSS authentication" : "");
}
auth_drive = DVDOpenImageFile( me->mnt_fsname, have_css );
if(!auth_drive) {
internal_errno = errno;
}
dev_name = strdup(me->mnt_fsname);
break;
}
}
fclose( mntfile );
}
#elif defined(__MINGW32__)
dev_name = strdup(path);
auth_drive = DVDOpenImageFile( path, have_css );
#endif
if( !dev_name ) {
if(verbose >= 1) {
fprintf( stderr, "libdvdread: Couldn't find device name.\n" );
}
} else if( !auth_drive ) {
if(verbose >= 1) {
fprintf( stderr, "libdvdread: Device %s inaccessible%s: %s\n",
dev_name,
have_css ? ", CSS authentication not available" : "",
strerror(internal_errno));
}
}
free( dev_name );
free( path_copy );
/**
* If we've opened a drive, just use that.
*/
if( auth_drive ) {
return auth_drive;
}
/**
* Otherwise, we now try to open the directory tree instead.
*/
return DVDOpenPath( path );
}
/* If it's none of the above, screw it. */
if(verbose >= 1) {
fprintf( stderr, "libdvdread: Could not open %s\n", path );
}
return 0;
}
int
main(int argc, char *argv[])
{
struct fstab *fs;
int i, rval;
const char *vfstype = NULL;
char globopt[3];
int ret = FSCK_EXIT_OK;
globopt[0] = '-';
globopt[2] = '\0';
TAILQ_INIT(&selhead);
TAILQ_INIT(&opthead);
while ((i = getopt(argc, argv, "dfl:nPpqT:t:vy")) != -1) {
switch (i) {
case 'd':
flags |= CHECK_DEBUG;
continue;
case 'f':
flags |= CHECK_FORCE;
break;
case 'n':
flags |= CHECK_NOFIX;
break;
case 'p':
flags |= CHECK_PREEN;
break;
case 'P':
flags |= CHECK_PROGRESS;
break;
case 'q':
break;
case 'l':
maxrun = atoi(optarg);
continue;
case 'T':
if (*optarg)
addoption(optarg);
continue;
case 't':
if (TAILQ_FIRST(&selhead) != NULL)
errx(1, "only one -t option may be specified.");
maketypelist(optarg);
vfstype = optarg;
continue;
case 'v':
flags |= CHECK_VERBOSE;
continue;
case 'y':
break;
case '?':
default:
usage();
/* NOTREACHED */
}
/* Pass option to fsck_xxxfs */
globopt[1] = i;
catopt(&options, globopt);
}
/* Don't do progress meters if we're debugging. */
if (flags & CHECK_DEBUG)
flags &= ~CHECK_PROGRESS;
/*
* If progress meters are being used, force max parallel to 1
* so the progress meter outputs don't interfere with one another.
*/
if (flags & CHECK_PROGRESS)
maxrun = 1;
argc -= optind;
argv += optind;
if (argc == 0)
return checkfstab(flags, maxrun, isok, checkfs);
#define BADTYPE(type) \
(strcmp(type, FSTAB_RO) && \
strcmp(type, FSTAB_RW) && strcmp(type, FSTAB_RQ))
for (; argc--; argv++) {
const char *spec, *type, *cp;
char device[MAXPATHLEN];
spec = *argv;
cp = strrchr(spec, '/');
if (cp == 0) {
(void)snprintf(device, sizeof(device), "%s%s",
_PATH_DEV, spec);
spec = device;
}
if ((fs = getfsfile(spec)) == NULL &&
(fs = getfsspec(spec)) == NULL) {
if (vfstype == NULL)
vfstype = getfslab(spec);
type = vfstype;
}
else {
spec = fs->fs_spec;
type = fs->fs_vfstype;
if (BADTYPE(fs->fs_type))
errx(FSCK_EXIT_CHECK_FAILED,
"%s has unknown file system type.",
spec);
}
rval = checkfs(type, blockcheck(spec), *argv, NULL, NULL);
if (rval > ret)
ret = rval;
}
return ret;
}
dvd_reader_t *DVDOpen( const char *ppath )
{
struct stat fileinfo;
int ret;
int have_css;
dvd_reader_t *ret_val = NULL;
char *dev_name = 0;
char *path;
#ifdef _MSC_VER
int len;
#endif
if( ppath == NULL )
return 0;
path = strdup(ppath);
/* Try to open libdvdcss or fall back to standard functions */
have_css = dvdinput_setup();
#ifdef _MSC_VER
/* Strip off the trailing \ if it is not a drive */
len = strlen(path);
if ((len > 1) &&
(path[len - 1] == '\\') &&
(path[len - 2] != ':'))
{
path[len-1] = '\0';
}
#endif
ret = stat( path, &fileinfo );
if( ret < 0 ) {
/* maybe "host:port" url? try opening it with acCeSS library */
if( strchr(path,':') ) {
ret_val = DVDOpenImageFile( path, have_css );
free(path);
return ret_val;
}
/* If we can't stat the file, give up */
fprintf( stderr, "libdvdread: Can't stat %s\n", path );
perror("");
free(path);
return 0;
}
/* First check if this is a block/char device or a file*/
if( S_ISBLK( fileinfo.st_mode ) ||
S_ISCHR( fileinfo.st_mode ) ||
S_ISREG( fileinfo.st_mode ) ) {
/**
* Block devices and regular files are assumed to be DVD-Video images.
*/
#if defined(__sun)
ret_val = DVDOpenImageFile( sun_block2char( path ), have_css );
#elif defined(SYS_BSD)
ret_val = DVDOpenImageFile( bsd_block2char( path ), have_css );
#else
ret_val = DVDOpenImageFile( path, have_css );
#endif
free(path);
return ret_val;
} else if( S_ISDIR( fileinfo.st_mode ) ) {
dvd_reader_t *auth_drive = 0;
char *path_copy;
#if defined(SYS_BSD)
struct fstab* fe;
#elif defined(__sun) || defined(__linux__)
FILE *mntfile;
#endif
/* XXX: We should scream real loud here. */
if( !(path_copy = strdup( path ) ) ) {
free(path);
return 0;
}
#ifndef WIN32 /* don't have fchdir, and getcwd( NULL, ... ) is strange */
/* Also WIN32 does not have symlinks, so we don't need this bit of code. */
/* Resolve any symlinks and get the absolut dir name. */
{
char *new_path;
int cdir = open( ".", O_RDONLY );
if( cdir >= 0 ) {
chdir( path_copy );
new_path = getcwd( NULL, XINE_PATH_MAX );
fchdir( cdir );
close( cdir );
if( new_path ) {
free( path_copy );
path_copy = new_path;
}
}
}
#endif
/**
* If we're being asked to open a directory, check if that directory
* is the mountpoint for a DVD-ROM which we can use instead.
*/
if( strlen( path_copy ) > 1 ) {
if( path_copy[ strlen( path_copy ) - 1 ] == '/' )
path_copy[ strlen( path_copy ) - 1 ] = '\0';
}
if( strlen( path_copy ) > 9 ) {
if( !strcasecmp( &(path_copy[ strlen( path_copy ) - 9 ]),
"/video_ts" ) ) {
path_copy[ strlen( path_copy ) - 9 ] = '\0';
}
}
#if defined(SYS_BSD)
if( ( fe = getfsfile( path_copy ) ) ) {
dev_name = bsd_block2char( fe->fs_spec );
fprintf( stderr,
"libdvdread: Attempting to use device %s"
" mounted on %s for CSS authentication\n",
dev_name,
fe->fs_file );
auth_drive = DVDOpenImageFile( dev_name, have_css );
}
#elif defined(__sun)
mntfile = fopen( MNTTAB, "r" );
if( mntfile ) {
struct mnttab mp;
int res;
while( ( res = getmntent( mntfile, &mp ) ) != -1 ) {
if( res == 0 && !strcmp( mp.mnt_mountp, path_copy ) ) {
dev_name = sun_block2char( mp.mnt_special );
fprintf( stderr,
"libdvdread: Attempting to use device %s"
" mounted on %s for CSS authentication\n",
dev_name,
mp.mnt_mountp );
auth_drive = DVDOpenImageFile( dev_name, have_css );
break;
}
}
fclose( mntfile );
}
#elif defined(__linux__)
mntfile = fopen( MOUNTED, "r" );
if( mntfile ) {
struct mntent *me;
while( ( me = getmntent( mntfile ) ) ) {
if( !strcmp( me->mnt_dir, path_copy ) ) {
fprintf( stderr,
"libdvdread: Attempting to use device %s"
" mounted on %s for CSS authentication\n",
me->mnt_fsname,
me->mnt_dir );
auth_drive = DVDOpenImageFile( me->mnt_fsname, have_css );
/* If the device is not encrypted, don't access the device
* directly as it would fail for non-UDF DVDs */
if ( auth_drive && dvdinput_is_encrypted( auth_drive->dev ) == 0) {
DVDClose( auth_drive );
auth_drive = NULL;
break;
}
dev_name = strdup(me->mnt_fsname);
break;
}
}
fclose( mntfile );
}
#elif defined(_MSC_VER)
auth_drive = DVDOpenImageFile( path, have_css );
#endif
#ifndef _MSC_VER
if( !dev_name ) {
fprintf( stderr, "libdvdread: Couldn't find device name.\n" );
} else if( !auth_drive ) {
fprintf( stderr, "libdvdread: Device %s inaccessible, "
"CSS authentication not available.\n", dev_name );
}
#else
if( !auth_drive ) {
fprintf( stderr, "libdvdread: Device %s inaccessible, "
"CSS authentication not available.\n", dev_name );
}
#endif
free( dev_name );
free( path_copy );
/**
* If we've opened a drive, just use that.
*/
if( auth_drive ) {
free(path);
return auth_drive;
}
/**
* Otherwise, we now try to open the directory tree instead.
*/
ret_val = DVDOpenPath( path );
free( path );
return ret_val;
}
/* If it's none of the above, screw it. */
fprintf( stderr, "libdvdread: Could not open %s\n", path );
free( path );
return 0;
}
int
main(int argc, char *argv[])
{
struct fstab *fs;
int i, rval = 0;
char *vfstype = NULL;
char *p, globopt[3];
struct rlimit rl;
/* Increase our data size to the max */
if (getrlimit(RLIMIT_DATA, &rl) == 0) {
if (geteuid() == 0)
rl.rlim_cur = rl.rlim_max = RLIM_INFINITY;
else
rl.rlim_cur = rl.rlim_max;
if (setrlimit(RLIMIT_DATA, &rl) < 0)
warn("Can't get resource limit to max data size");
} else
warn("Can't get resource limit for data size");
globopt[0] = '-';
globopt[2] = '\0';
TAILQ_INIT(&selhead);
TAILQ_INIT(&opthead);
while ((i = getopt(argc, argv, "dvpfnyb:l:T:t:")) != -1)
switch (i) {
case 'd':
flags |= CHECK_DEBUG;
break;
case 'v':
flags |= CHECK_VERBOSE;
break;
case 'p':
flags |= CHECK_PREEN;
/*FALLTHROUGH*/
case 'n':
case 'f':
case 'y':
globopt[1] = i;
options = catopt(options, globopt, 1);
break;
case 'b':
if (asprintf(&p, "-b %s", optarg) == -1)
err(1, "malloc failed");
options = catopt(options, p, 1);
free(p);
break;
case 'l':
maxrun = atoi(optarg);
break;
case 'T':
if (*optarg)
addoption(optarg);
break;
case 't':
if (!TAILQ_EMPTY(&selhead))
errx(1, "only one -t option may be specified.");
maketypelist(optarg);
vfstype = optarg;
break;
case '?':
default:
usage();
/* NOTREACHED */
}
argc -= optind;
argv += optind;
if (argc == 0)
return checkfstab(flags, maxrun, isok, checkfs);
#define BADTYPE(type) \
(strcmp(type, FSTAB_RO) && \
strcmp(type, FSTAB_RW) && strcmp(type, FSTAB_RQ))
for (; argc--; argv++) {
char *spec, *type;
if ((strncmp(*argv, "/dev/", 5) == 0 || isduid(*argv, 0)) &&
(type = readlabelfs(*argv, 0))) {
spec = *argv;
} else if ((fs = getfsfile(*argv)) == NULL &&
(fs = getfsspec(*argv)) == NULL) {
if (vfstype == NULL)
errx(1,
"%s: unknown special file or file system.",
*argv);
spec = *argv;
type = vfstype;
} else {
spec = fs->fs_spec;
type = fs->fs_vfstype;
if (BADTYPE(fs->fs_type))
errx(1, "%s has unknown file system type.",
*argv);
}
rval |= checkfs(type, blockcheck(spec), *argv, NULL, NULL);
}
return rval;
}
int
main(int argc, char **argv)
{
char *cp, *special;
const char *name, *action;
struct stat st;
int i;
int Aflag = 0, active = 0;
struct fstab *fs;
const char *chg[2];
char device[MAXPATHLEN];
struct ufs_args args;
struct statfs stfs;
argc--, argv++;
if (argc < 2)
usage();
special = argv[argc - 1];
fs = getfsfile(special);
if (fs) {
if (statfs(special, &stfs) == 0 &&
strcmp(special, stfs.f_mntonname) == 0) {
active = 1;
}
special = fs->fs_spec;
}
again:
if (stat(special, &st) < 0) {
if (*special != '/') {
if (*special == 'r')
special++;
snprintf(device, sizeof(device), "%s%s",
_PATH_DEV, special);
special = device;
goto again;
}
err(1, "%s", special);
}
if (fs == NULL && (st.st_mode & S_IFMT) == S_IFDIR)
errx(10, "%s: unknown file system", special);
getsb(&sblock, special);
for (; argc > 0 && argv[0][0] == '-'; argc--, argv++) {
for (cp = &argv[0][1]; *cp; cp++)
switch (*cp) {
case 'A':
Aflag++;
continue;
case 'p':
printfs();
exit(0);
case 'a':
name = "maximum contiguous block count";
if (argc < 1)
errx(10, "-a: missing %s", name);
argc--, argv++;
i = atoi(*argv);
if (i < 1)
errx(10, "%s must be >= 1 (was %s)",
name, *argv);
warnx("%s changes from %d to %d",
name, sblock.fs_maxcontig, i);
sblock.fs_maxcontig = i;
continue;
case 'd':
name =
"rotational delay between contiguous blocks";
if (argc < 1)
errx(10, "-d: missing %s", name);
argc--, argv++;
i = atoi(*argv);
warnx("%s changes from %dms to %dms",
name, sblock.fs_rotdelay, i);
sblock.fs_rotdelay = i;
continue;
case 'e':
name =
"maximum blocks per file in a cylinder group";
if (argc < 1)
errx(10, "-e: missing %s", name);
argc--, argv++;
i = atoi(*argv);
if (i < 1)
errx(10, "%s must be >= 1 (was %s)",
name, *argv);
warnx("%s changes from %d to %d",
name, sblock.fs_maxbpg, i);
sblock.fs_maxbpg = i;
continue;
case 'f':
name = "average file size";
if (argc < 1)
errx(10, "-a: missing %s", name);
argc--, argv++;
i = atoi(*argv);
if (i < 1)
errx(10, "%s must be >= 1 (was %s)", name, *argv);
if (sblock.fs_avgfilesize == i) {
warnx("%s remains unchanged as %d",
name, i);
} else {
warnx("%s changes from %d to %d",
name, sblock.fs_avgfilesize, i);
sblock.fs_avgfilesize = i;
}
break;
case 'm':
name = "minimum percentage of free space";
if (argc < 1)
errx(10, "-m: missing %s", name);
argc--, argv++;
i = atoi(*argv);
if (i < 0 || i > 99)
errx(10, "bad %s (%s)", name, *argv);
warnx("%s changes from %d%% to %d%%",
name, sblock.fs_minfree, i);
sblock.fs_minfree = i;
if (i >= MINFREE &&
sblock.fs_optim == FS_OPTSPACE)
warnx(OPTWARN, "time", ">=", MINFREE);
if (i < MINFREE &&
sblock.fs_optim == FS_OPTTIME)
warnx(OPTWARN, "space", "<", MINFREE);
continue;
case 'n':
name = "soft updates";
if (argc < 1)
errx(10, "-n: missing %s", name);
argc--, argv++;
if (strcmp(*argv, "enable") == 0) {
sblock.fs_flags |= FS_DOSOFTDEP;
action = "set";
} else if (strcmp(*argv, "disable") == 0) {
sblock.fs_flags &= ~FS_DOSOFTDEP;
action = "cleared";
} else {
errx(10, "bad %s (options are %s)",
name, "`enable' or `disable'");
}
warnx("%s %s", name, action);
continue;
case 'o':
name = "optimization preference";
if (argc < 1)
errx(10, "-o: missing %s", name);
argc--, argv++;
chg[FS_OPTSPACE] = "space";
chg[FS_OPTTIME] = "time";
if (strcmp(*argv, chg[FS_OPTSPACE]) == 0)
i = FS_OPTSPACE;
else if (strcmp(*argv, chg[FS_OPTTIME]) == 0)
i = FS_OPTTIME;
else
errx(10, "bad %s (options are `space' or `time')",
name);
if (sblock.fs_optim == i) {
warnx("%s remains unchanged as %s",
name, chg[i]);
continue;
}
warnx("%s changes from %s to %s",
name, chg[sblock.fs_optim], chg[i]);
sblock.fs_optim = i;
if (sblock.fs_minfree >= MINFREE &&
i == FS_OPTSPACE)
warnx(OPTWARN, "time", ">=", MINFREE);
if (sblock.fs_minfree < MINFREE &&
i == FS_OPTTIME)
warnx(OPTWARN, "space", "<", MINFREE);
continue;
case 's':
name = "expected number of files per directory";
if (argc < 1)
errx(10, "-a: missing %s", name);
argc--, argv++;
i = atoi(*argv);
if (i < 1)
errx(10, "%s must be >= 1 (was %s)", name, *argv);
if (sblock.fs_avgfpdir == i) {
warnx("%s remains unchanged as %d",
name, i);
} else {
warnx("%s changes from %d to %d",
name, sblock.fs_avgfpdir, i);
sblock.fs_avgfpdir = i;
}
break;
default:
usage();
}
}
if (argc != 1)
usage();
putsb(&sblock, special, Aflag);
if (active) {
bzero(&args, sizeof(args));
if (mount("ufs", fs->fs_file,
stfs.f_flags | MNT_UPDATE | MNT_RELOAD, &args) < 0)
err(9, "%s: reload", special);
warnx("file system reloaded");
}
exit(0);
}
int
main(int argc, char *argv[])
{
const char *mntfromname, **vfslist, *vfstype;
struct fstab *fs;
struct statfs *mntbuf;
int all, ch, i, init_flags, late, failok, mntsize, rval, have_fstab, ro;
int onlylate;
char *cp, *ep, *options;
all = init_flags = late = onlylate = 0;
ro = 0;
options = NULL;
vfslist = NULL;
vfstype = "ufs";
while ((ch = getopt(argc, argv, "adF:fLlno:prt:uvw")) != -1)
switch (ch) {
case 'a':
all = 1;
break;
case 'd':
debug = 1;
break;
case 'F':
setfstab(optarg);
break;
case 'f':
init_flags |= MNT_FORCE;
break;
case 'L':
onlylate = 1;
late = 1;
break;
case 'l':
late = 1;
break;
case 'n':
/* For compatibility with the Linux version of mount. */
break;
case 'o':
if (*optarg) {
options = catopt(options, optarg);
if (specified_ro(optarg))
ro = 1;
}
break;
case 'p':
fstab_style = 1;
verbose = 1;
break;
case 'r':
options = catopt(options, "ro");
ro = 1;
break;
case 't':
if (vfslist != NULL)
errx(1, "only one -t option may be specified");
vfslist = makevfslist(optarg);
vfstype = optarg;
break;
case 'u':
init_flags |= MNT_UPDATE;
break;
case 'v':
verbose = 1;
break;
case 'w':
options = catopt(options, "noro");
break;
case '?':
default:
usage();
/* NOTREACHED */
}
argc -= optind;
argv += optind;
#define BADTYPE(type) \
(strcmp(type, FSTAB_RO) && \
strcmp(type, FSTAB_RW) && strcmp(type, FSTAB_RQ))
if ((init_flags & MNT_UPDATE) && (ro == 0))
options = catopt(options, "noro");
rval = 0;
switch (argc) {
case 0:
if ((mntsize = getmntinfo(&mntbuf, MNT_NOWAIT)) == 0)
err(1, "getmntinfo");
if (all) {
while ((fs = getfsent()) != NULL) {
if (BADTYPE(fs->fs_type))
continue;
if (checkvfsname(fs->fs_vfstype, vfslist))
continue;
if (hasopt(fs->fs_mntops, "noauto"))
continue;
if (!hasopt(fs->fs_mntops, "late") && onlylate)
continue;
if (hasopt(fs->fs_mntops, "late") && !late)
continue;
if (hasopt(fs->fs_mntops, "failok"))
failok = 1;
else
failok = 0;
if (!(init_flags & MNT_UPDATE) &&
ismounted(fs, mntbuf, mntsize))
continue;
options = update_options(options, fs->fs_mntops,
mntbuf->f_flags);
if (mountfs(fs->fs_vfstype, fs->fs_spec,
fs->fs_file, init_flags, options,
fs->fs_mntops) && !failok)
rval = 1;
}
} else if (fstab_style) {
for (i = 0; i < mntsize; i++) {
if (checkvfsname(mntbuf[i].f_fstypename, vfslist))
continue;
putfsent(&mntbuf[i]);
}
} else {
for (i = 0; i < mntsize; i++) {
if (checkvfsname(mntbuf[i].f_fstypename,
vfslist))
continue;
if (!verbose &&
(mntbuf[i].f_flags & MNT_IGNORE) != 0)
continue;
prmount(&mntbuf[i]);
}
}
exit(rval);
case 1:
if (vfslist != NULL)
usage();
rmslashes(*argv, *argv);
if (init_flags & MNT_UPDATE) {
mntfromname = NULL;
have_fstab = 0;
if ((mntbuf = getmntpt(*argv)) == NULL)
errx(1, "not currently mounted %s", *argv);
/*
* Only get the mntflags from fstab if both mntpoint
* and mntspec are identical. Also handle the special
* case where just '/' is mounted and 'spec' is not
* identical with the one from fstab ('/dev' is missing
* in the spec-string at boot-time).
*/
if ((fs = getfsfile(mntbuf->f_mntonname)) != NULL) {
if (strcmp(fs->fs_spec,
mntbuf->f_mntfromname) == 0 &&
strcmp(fs->fs_file,
mntbuf->f_mntonname) == 0) {
have_fstab = 1;
mntfromname = mntbuf->f_mntfromname;
} else if (argv[0][0] == '/' &&
argv[0][1] == '\0') {
fs = getfsfile("/");
have_fstab = 1;
mntfromname = fs->fs_spec;
}
}
if (have_fstab) {
options = update_options(options, fs->fs_mntops,
mntbuf->f_flags);
} else {
mntfromname = mntbuf->f_mntfromname;
options = update_options(options, NULL,
mntbuf->f_flags);
}
rval = mountfs(mntbuf->f_fstypename, mntfromname,
mntbuf->f_mntonname, init_flags, options, 0);
break;
}
if ((fs = getfsfile(*argv)) == NULL &&
(fs = getfsspec(*argv)) == NULL)
errx(1, "%s: unknown special file or file system",
*argv);
if (BADTYPE(fs->fs_type))
errx(1, "%s has unknown file system type",
*argv);
rval = mountfs(fs->fs_vfstype, fs->fs_spec, fs->fs_file,
init_flags, options, fs->fs_mntops);
break;
case 2:
/*
* If -t flag has not been specified, the path cannot be
* found, spec contains either a ':' or a '@', then assume
* that an NFS file system is being specified ala Sun.
* Check if the hostname contains only allowed characters
* to reduce false positives. IPv6 addresses containing
* ':' will be correctly parsed only if the separator is '@'.
* The definition of a valid hostname is taken from RFC 1034.
*/
if (vfslist == NULL && ((ep = strchr(argv[0], '@')) != NULL ||
(ep = strchr(argv[0], ':')) != NULL)) {
if (*ep == '@') {
cp = ep + 1;
ep = cp + strlen(cp);
} else
cp = argv[0];
while (cp != ep) {
if (!isdigit(*cp) && !isalpha(*cp) &&
*cp != '.' && *cp != '-' && *cp != ':')
break;
cp++;
}
if (cp == ep)
vfstype = "nfs";
}
rval = mountfs(vfstype,
argv[0], argv[1], init_flags, options, NULL);
break;
default:
usage();
/* NOTREACHED */
}
/*
* If the mount was successfully, and done by root, tell mountd the
* good news.
*/
if (rval == 0 && getuid() == 0)
restart_mountd();
exit(rval);
}
void runSuccess() {
getfsfile(anystring());
}
static dvd_reader_t *DVDOpenCommon( const char *ppath,
void *stream,
dvd_reader_stream_cb *stream_cb )
{
struct stat fileinfo;
int ret, have_css, retval, cdir = -1;
dvd_reader_t *ret_val = NULL;
char *dev_name = NULL;
char *path = NULL, *new_path = NULL, *path_copy = NULL;
#if defined(_WIN32) || defined(__OS2__)
int len;
#endif
/* Try to open DVD using stream_cb functions */
if( stream != NULL && stream_cb != NULL )
{
have_css = dvdinput_setup( "" );
return DVDOpenImageFile( NULL, stream, stream_cb, have_css );
}
if( ppath == NULL )
goto DVDOpen_error;
path = strdup(ppath);
if( path == NULL )
goto DVDOpen_error;
/* Try to open libdvdcss or fall back to standard functions */
have_css = dvdinput_setup(path);
#if defined(_WIN32) || defined(__OS2__)
/* Strip off the trailing \ if it is not a drive */
len = strlen(path);
if ((len > 1) &&
(path[len - 1] == '\\') &&
(path[len - 2] != ':'))
{
path[len-1] = '\0';
}
#endif
ret = mythfile_stat( path, &fileinfo );
if( ret < 0 ) {
/* maybe "host:port" url? try opening it with acCeSS library */
if( strchr(path,':') ) {
ret_val = DVDOpenImageFile( path, NULL, NULL, have_css );
free(path);
return ret_val;
}
/* If we can't stat the file, give up */
fprintf( stderr, "libdvdread: Can't stat %s\n", path );
perror("");
goto DVDOpen_error;
}
/* First check if this is a block/char device or a file*/
if( S_ISBLK( fileinfo.st_mode ) ||
S_ISCHR( fileinfo.st_mode ) ||
S_ISREG( fileinfo.st_mode ) ) {
/**
* Block devices and regular files are assumed to be DVD-Video images.
*/
dvd_reader_t *dvd = NULL;
#if defined(__sun)
dev_name = sun_block2char( path );
#elif defined(SYS_BSD)
dev_name = bsd_block2char( path );
#else
dev_name = strdup( path );
#endif
if(!dev_name)
goto DVDOpen_error;
dvd = DVDOpenImageFile( dev_name, NULL, NULL, have_css );
free( dev_name );
free(path);
return dvd;
} else if( S_ISDIR( fileinfo.st_mode ) ) {
dvd_reader_t *auth_drive = 0;
#if defined(SYS_BSD)
struct fstab* fe;
#elif defined(__sun) || defined(__linux__)
FILE *mntfile;
#endif
/* XXX: We should scream real loud here. */
if( !(path_copy = strdup( path ) ) )
goto DVDOpen_error;
#ifndef WIN32 /* don't have fchdir, and getcwd( NULL, ... ) is strange */
/* Also WIN32 does not have symlinks, so we don't need this bit of code. */
/* Resolve any symlinks and get the absolute dir name. */
if (!strncmp(path, "myth://", 7))
dev_name = strdup( path );
else
{
if( ( cdir = open( ".", O_RDONLY ) ) >= 0 ) {
if( chdir( path_copy ) == -1 ) {
goto DVDOpen_error;
}
new_path = malloc(PATH_MAX+1);
if(!new_path) {
goto DVDOpen_error;
}
if( getcwd( new_path, PATH_MAX ) == NULL ) {
goto DVDOpen_error;
}
retval = fchdir( cdir );
close( cdir );
cdir = -1;
if( retval == -1 ) {
goto DVDOpen_error;
}
free(path_copy);
path_copy = new_path;
new_path = NULL;
}
}
#endif
/**
* If we're being asked to open a directory, check if that directory
* is the mount point for a DVD-ROM which we can use instead.
*/
if( strlen( path_copy ) > 1 ) {
if( path_copy[ strlen( path_copy ) - 1 ] == '/' ) {
path_copy[ strlen( path_copy ) - 1 ] = '\0';
}
}
#if defined(_WIN32) || defined(__OS2__)
if( strlen( path_copy ) > 9 ) {
if( !strcasecmp( &(path_copy[ strlen( path_copy ) - 9 ]),
"\\video_ts"))
path_copy[ strlen( path_copy ) - (9-1) ] = '\0';
}
#endif
if( strlen( path_copy ) > 9 ) {
if( !strcasecmp( &(path_copy[ strlen( path_copy ) - 9 ]),
"/video_ts" ) ) {
path_copy[ strlen( path_copy ) - 9 ] = '\0';
}
}
if(path_copy[0] == '\0') {
free( path_copy );
if( !(path_copy = strdup( "/" ) ) )
goto DVDOpen_error;
}
#if defined(__APPLE__)
struct statfs s[128];
int r = getfsstat(NULL, 0, MNT_NOWAIT);
if (r > 0) {
if (r > 128)
r = 128;
r = getfsstat(s, r * sizeof(s[0]), MNT_NOWAIT);
int i;
for (i=0; i<r; i++) {
if (!strcmp(path_copy, s[i].f_mntonname)) {
dev_name = bsd_block2char(s[i].f_mntfromname);
fprintf( stderr,
"libdvdread: Attempting to use device %s"
" mounted on %s for CSS authentication\n",
dev_name,
s[i].f_mntonname);
auth_drive = DVDOpenImageFile( dev_name, NULL, NULL, have_css );
break;
}
}
}
#elif defined(SYS_BSD)
if( ( fe = getfsfile( path_copy ) ) ) {
dev_name = bsd_block2char( fe->fs_spec );
fprintf( stderr,
"libdvdread: Attempting to use device %s"
" mounted on %s for CSS authentication\n",
dev_name,
fe->fs_file );
auth_drive = DVDOpenImageFile( dev_name, NULL, NULL, have_css );
}
#elif defined(__sun)
mntfile = fopen( MNTTAB, "r" );
if( mntfile ) {
struct mnttab mp;
int res;
while( ( res = getmntent( mntfile, &mp ) ) != -1 ) {
if( res == 0 && !strcmp( mp.mnt_mountp, path_copy ) ) {
dev_name = sun_block2char( mp.mnt_special );
fprintf( stderr,
"libdvdread: Attempting to use device %s"
" mounted on %s for CSS authentication\n",
dev_name,
mp.mnt_mountp );
auth_drive = DVDOpenImageFile( dev_name, NULL, NULL, have_css );
break;
}
}
fclose( mntfile );
}
#elif defined(__linux__)
mntfile = fopen( _PATH_MOUNTED, "r" );
if( mntfile ) {
struct mntent *me;
while( ( me = getmntent( mntfile ) ) ) {
if( !strcmp( me->mnt_dir, path_copy ) ) {
fprintf( stderr,
"libdvdread: Attempting to use device %s"
" mounted on %s for CSS authentication\n",
me->mnt_fsname,
me->mnt_dir );
auth_drive = DVDOpenImageFile( me->mnt_fsname, NULL, NULL, have_css );
dev_name = strdup(me->mnt_fsname);
break;
}
}
fclose( mntfile );
}
#elif defined(_WIN32) || defined(__OS2__)
#ifdef __OS2__
/* Use DVDOpenImageFile() only if it is a drive */
if(isalpha(path[0]) && path[1] == ':' &&
( !path[2] ||
((path[2] == '\\' || path[2] == '/') && !path[3])))
#endif
auth_drive = DVDOpenImageFile( path, NULL, NULL, have_css );
#endif
#if !defined(_WIN32) && !defined(__OS2__)
if( !dev_name ) {
fprintf( stderr, "libdvdread: Couldn't find device name.\n" );
} else if( !auth_drive ) {
fprintf( stderr, "libdvdread: Device %s inaccessible, "
"CSS authentication not available.\n", dev_name );
}
#else
if( !auth_drive ) {
fprintf( stderr, "libdvdread: Device %s inaccessible, "
"CSS authentication not available.\n", path );
}
#endif
free( dev_name );
dev_name = NULL;
free( path_copy );
path_copy = NULL;
/**
* If we've opened a drive, just use that.
*/
if( auth_drive ) {
free(path);
return auth_drive;
}
/**
* Otherwise, we now try to open the directory tree instead.
*/
ret_val = DVDOpenPath( path );
free( path );
return ret_val;
}
DVDOpen_error:
/* If it's none of the above, screw it. */
fprintf( stderr, "libdvdread: Could not open %s\n", path );
free( path );
free( path_copy );
if ( cdir >= 0 )
close( cdir );
free( new_path );
return NULL;
}
int
main (int argc, char *argv[])
{
int c;
int all = 0;
string_list types = NULL;
string_list options;
struct mntentchn *mc, *fs;
char *file;
int result = 0;
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
while ((c = getopt_long (argc, argv, "afhnrt:vV",
longopts, NULL)) != EOF)
switch (c) {
case 'a': /* umount everything */
++all;
break;
case 'f': /* force umount */
++force;
break;
case 'h': /* help */
usage (stdout, 0);
break;
case 'n': /* do not write in /etc/mtab */
++nomtab;
break;
case 'r': /* remount read-only if umount fails */
++remount;
break;
case 'v': /* make noise */
++verbose;
break;
case 'V': /* version */
printf ("umount: %s\n", version);
exit (0);
case 't': /* specify file system type */
types = parse_list (optarg);
break;
case 0:
break;
case '?':
default:
usage (stderr, 1);
}
if (getuid () != geteuid ())
{
suid = 1;
if (all || types || nomtab || force)
die (2, _("umount: only root can do that"));
}
argc -= optind;
argv += optind;
if (all) {
if (types == NULL)
types = parse_list("noproc");
result = umount_all (types);
} else if (argc < 1) {
usage (stderr, 2);
} else while (argc--) {
file = canonicalize (*argv); /* mtab paths are canonicalized */
if (verbose > 1)
printf(_("Trying to umount %s\n"), file);
mc = getmntfilesbackward (file, NULL);
if (!mc && verbose)
printf(_("Could not find %s in mtab\n"), file);
if (suid) {
if (!mc)
die (2, _("umount: %s is not mounted (according to mtab)"), file);
if (getmntfilesbackward (file, mc))
die (2, _("umount: it seems %s is mounted multiple times"), file);
/* If fstab contains the two lines
/dev/sda1 /mnt/zip auto user,noauto 0 0
/dev/sda4 /mnt/zip auto user,noauto 0 0
then "mount /dev/sda4" followed by "umount /mnt/zip"
used to fail. So, we must not look for file, but for
the pair (spec,file) in fstab. */
fs = getfsspecfile(mc->mnt_fsname, mc->mnt_dir);
if (!fs) {
if (!getfsspec (file) && !getfsfile (file))
die (2,
_("umount: %s is not in the fstab (and you are not root)"),
file);
else
die (2, _("umount: %s mount disagrees with the fstab"), file);
}
/* User mounting and unmounting is allowed only
if fstab contains the option `user' or `users' */
/* The option `users' allows arbitrary users to mount
and unmount - this may be a security risk. */
/* The option `user' only allows unmounting by the user
that mounted. */
/* The option `owner' only allows (un)mounting by the owner. */
/* A convenient side effect is that the user who mounted
is visible in mtab. */
options = parse_list (fs->mnt_opts);
while (options) {
if (streq (car (options), "user") ||
streq (car (options), "users") ||
streq (car (options), "owner"))
break;
options = cdr (options);
}
if (!options)
die (2, _("umount: only root can unmount %s from %s"),
fs->mnt_fsname, fs->mnt_dir);
if (streq (car (options), "user") ||
streq (car (options), "owner")) {
char *user = getusername();
options = parse_list (mc->mnt_opts);
while (options) {
char *co = car (options);
if (!strncmp(co, "user="******"umount: only %s can unmount %s from %s"),
co+5, fs->mnt_fsname, fs->mnt_dir);
break;
}
options = cdr (options);
}
}
}
if (mc)
result = umount_one_bw (file, mc);
else
result = umount_one (*argv, *argv, *argv, *argv, NULL);
argv++;
}
exit (result);
}
KMountPoint::List KMountPoint::currentMountPoints(int infoNeeded)
{
KMountPoint::List result;
#ifdef HAVE_GETMNTINFO
#ifdef GETMNTINFO_USES_STATVFS
struct statvfs *mounted;
#else
struct statfs *mounted;
#endif
int num_fs = getmntinfo(&mounted, MNT_NOWAIT);
for (int i=0;i<num_fs;i++)
{
KMountPoint *mp = new KMountPoint();
mp->m_mountedFrom = TQFile::decodeName(mounted[i].f_mntfromname);
mp->m_mountPoint = TQFile::decodeName(mounted[i].f_mntonname);
#ifdef __osf__
mp->m_mountType = TQFile::decodeName(mnt_names[mounted[i].f_type]);
#else
mp->m_mountType = TQFile::decodeName(mounted[i].f_fstypename);
#endif
if (infoNeeded & NeedMountOptions)
{
struct fstab *ft = getfsfile(mounted[i].f_mntonname);
TQString options = TQFile::decodeName(ft->fs_mntops);
mp->m_mountOptions = TQStringList::split(',', options);
}
if (infoNeeded & NeedRealDeviceName)
{
if (mp->m_mountedFrom.startsWith("/"))
mp->m_device = TDEStandardDirs::realPath(mp->m_mountedFrom);
}
// TODO: Strip trailing '/' ?
result.append(mp);
}
#elif defined(_AIX)
struct vmount *mntctl_buffer;
struct vmount *vm;
char *mountedfrom;
char *mountedto;
int fsname_len, num;
int buf_sz = 4096;
mntctl_buffer = (struct vmount*)malloc(buf_sz);
num = mntctl(MCTL_QUERY, buf_sz, mntctl_buffer);
if (num == 0)
{
buf_sz = *(int*)mntctl_buffer;
free(mntctl_buffer);
mntctl_buffer = (struct vmount*)malloc(buf_sz);
num = mntctl(MCTL_QUERY, buf_sz, mntctl_buffer);
}
if (num > 0)
{
/* iterate through items in the vmount structure: */
vm = (struct vmount *)mntctl_buffer;
for ( ; num > 0; num-- )
{
/* get the name of the mounted file systems: */
fsname_len = vmt2datasize(vm, VMT_STUB);
mountedto = (char*)malloc(fsname_len + 1);
mountedto[fsname_len] = '\0';
strncpy(mountedto, (char *)vmt2dataptr(vm, VMT_STUB), fsname_len);
fsname_len = vmt2datasize(vm, VMT_OBJECT);
mountedfrom = (char*)malloc(fsname_len + 1);
mountedfrom[fsname_len] = '\0';
strncpy(mountedfrom, (char *)vmt2dataptr(vm, VMT_OBJECT), fsname_len);
/* Look up the string for the file system type,
* as listed in /etc/vfs.
* ex.: nfs,jfs,afs,cdrfs,sfs,cachefs,nfs3,autofs
*/
struct vfs_ent* ent = getvfsbytype(vm->vmt_gfstype);
KMountPoint *mp = new KMountPoint();
mp->m_mountedFrom = TQFile::decodeName(mountedfrom);
mp->m_mountPoint = TQFile::decodeName(mountedto);
mp->m_mountType = TQFile::decodeName(ent->vfsent_name);
free(mountedfrom);
free(mountedto);
if (infoNeeded & NeedMountOptions)
{
// TODO
}
if (infoNeeded & NeedRealDeviceName)
{
if (mp->m_mountedFrom.startsWith("/"))
mp->m_device = TDEStandardDirs::realPath(mp->m_mountedFrom);
}
result.append(mp);
/* goto the next vmount structure: */
vm = (struct vmount *)((char *)vm + vm->vmt_length);
}
endvfsent( );
}
free( mntctl_buffer );
#elif defined(Q_WS_WIN)
//TODO?
#else
STRUCT_SETMNTENT mnttab;
if ((mnttab = SETMNTENT(MNTTAB, "r")) == 0)
return result;
STRUCT_MNTENT fe;
while (GETMNTENT(mnttab, fe))
{
KMountPoint *mp = new KMountPoint();
mp->m_mountedFrom = TQFile::decodeName(FSNAME(fe));
mp->m_mountPoint = TQFile::decodeName(MOUNTPOINT(fe));
mp->m_mountType = TQFile::decodeName(MOUNTTYPE(fe));
//Devices using supermount have their device names in the mount options
//instead of the device field. That's why we need to read the mount options
if (infoNeeded & NeedMountOptions || (mp->m_mountType == "supermount"))
{
TQString options = TQFile::decodeName(MOUNTOPTIONS(fe));
mp->m_mountOptions = TQStringList::split(',', options);
}
if (mp->m_mountType == "supermount")
mp->m_mountedFrom = devNameFromOptions(mp->m_mountOptions);
if (infoNeeded & NeedRealDeviceName)
{
if (mp->m_mountedFrom.startsWith("/"))
mp->m_device = TDEStandardDirs::realPath(mp->m_mountedFrom);
}
// TODO: Strip trailing '/' ?
result.append(mp);
}
ENDMNTENT(mnttab);
#endif
return result;
}
int
main(int argc, char **argv)
{
const char *mntfromname, **vfslist, *vfstype;
struct fstab *fs;
struct statfs *mntbuf;
FILE *mountdfp;
pid_t pid;
int all, ch, i, init_flags, mntsize, rval, have_fstab;
char *options;
all = init_flags = 0;
options = NULL;
vfslist = NULL;
vfstype = "ufs";
while ((ch = getopt(argc, argv, "adF:fo:prwt:uv")) != -1) {
switch (ch) {
case 'a':
all = 1;
break;
case 'd':
debug = 1;
break;
case 'F':
setfstab(optarg);
break;
case 'f':
init_flags |= MNT_FORCE;
break;
case 'o':
if (*optarg)
options = catopt(options, optarg);
break;
case 'p':
fstab_style = 1;
verbose = 1;
break;
case 'r':
options = catopt(options, "ro");
break;
case 't':
if (vfslist != NULL)
errx(1, "only one -t option may be specified");
vfslist = makevfslist(optarg);
vfstype = optarg;
break;
case 'u':
init_flags |= MNT_UPDATE;
break;
case 'v':
verbose = 1;
break;
case 'w':
options = catopt(options, "noro");
break;
case '?':
default:
usage();
/* NOTREACHED */
}
}
argc -= optind;
argv += optind;
#define BADTYPE(type) \
(strcmp(type, FSTAB_RO) && \
strcmp(type, FSTAB_RW) && strcmp(type, FSTAB_RQ))
rval = 0;
switch (argc) {
case 0:
if ((mntsize = getmntinfo(&mntbuf, MNT_NOWAIT)) == 0)
err(1, "getmntinfo");
if (all) {
while ((fs = getfsent()) != NULL) {
if (BADTYPE(fs->fs_type))
continue;
if (checkvfsname(fs->fs_vfstype, vfslist))
continue;
if (hasopt(fs->fs_mntops, "noauto"))
continue;
if (!(init_flags & MNT_UPDATE) &&
ismounted(fs, mntbuf, mntsize))
continue;
options = update_options(options,
fs->fs_mntops, mntbuf->f_flags);
if (mountfs(fs->fs_vfstype, fs->fs_spec,
fs->fs_file, init_flags, options,
fs->fs_mntops))
rval = 1;
}
} else if (fstab_style) {
for (i = 0; i < mntsize; i++) {
if (checkvfsname(mntbuf[i].f_fstypename, vfslist))
continue;
putfsent(&mntbuf[i]);
}
} else {
for (i = 0; i < mntsize; i++) {
if (checkvfsname(mntbuf[i].f_fstypename,
vfslist))
continue;
prmount(&mntbuf[i]);
}
}
exit(rval);
case 1:
if (vfslist != NULL)
usage();
rmslashes(*argv, *argv);
if (init_flags & MNT_UPDATE) {
mntfromname = NULL;
have_fstab = 0;
if ((mntbuf = getmntpt(*argv)) == NULL)
errx(1, "not currently mounted %s", *argv);
/*
* Only get the mntflags from fstab if both mntpoint
* and mntspec are identical. Also handle the special
* case where just '/' is mounted and 'spec' is not
* identical with the one from fstab ('/dev' is missing
* in the spec-string at boot-time).
*/
if ((fs = getfsfile(mntbuf->f_mntonname)) != NULL) {
if (strcmp(fs->fs_spec,
mntbuf->f_mntfromname) == 0 &&
strcmp(fs->fs_file,
mntbuf->f_mntonname) == 0) {
have_fstab = 1;
mntfromname = mntbuf->f_mntfromname;
} else if (argv[0][0] == '/' &&
argv[0][1] == '\0') {
fs = getfsfile("/");
have_fstab = 1;
mntfromname = fs->fs_spec;
}
}
if (have_fstab) {
options = update_options(options, fs->fs_mntops,
mntbuf->f_flags);
} else {
mntfromname = mntbuf->f_mntfromname;
options = update_options(options, NULL,
mntbuf->f_flags);
}
rval = mountfs(mntbuf->f_fstypename, mntfromname,
mntbuf->f_mntonname, init_flags, options, 0);
break;
}
if ((fs = getfsfile(*argv)) == NULL &&
(fs = getfsspec(*argv)) == NULL)
errx(1, "%s: unknown special file or file system",
*argv);
if (BADTYPE(fs->fs_type))
errx(1, "%s has unknown file system type",
*argv);
rval = mountfs(fs->fs_vfstype, fs->fs_spec, fs->fs_file,
init_flags, options, fs->fs_mntops);
break;
case 2:
/*
* If -t flag has not been specified, the path cannot be
* found.
*
* If the spec is not a file and contains a ':' then assume
* NFS.
*
* If the spec is a cdev attempt to extract the fstype from
* the label.
*
* When all else fails ufs is assumed.
*/
if (vfslist == NULL) {
if (strpbrk(argv[0], ":") != NULL &&
access(argv[0], 0) == -1) {
vfstype = "nfs";
} else {
checkdisklabel(argv[0], &vfstype);
}
}
rval = mountfs(vfstype, getdevpath(argv[0], 0), argv[1],
init_flags, options, NULL);
break;
default:
usage();
/* NOTREACHED */
}
/*
* If the mount was successfully, and done by root, tell mountd the
* good news. Pid checks are probably unnecessary, but don't hurt.
*/
if (rval == 0 && getuid() == 0 &&
(mountdfp = fopen(_PATH_MOUNTDPID, "r")) != NULL) {
if (fscanf(mountdfp, "%d", &pid) == 1 &&
pid > 0 && kill(pid, SIGHUP) == -1 && errno != ESRCH)
err(1, "signal mountd");
fclose(mountdfp);
}
exit(rval);
}
void runFailure() {
getfsfile(NULL);
}
int
this_was_main_int_mount_c (int argc, char *argv[])
{
int c;
int all = 0;
string_list types = NULL;
string_list options;
struct mntentchn *mc, *fs;
char *file;
int result = 0;
while ((c = getopt_long (argc, argv, "afhnrvVt:", longopts, NULL)) != EOF)
switch (c) {
case 'a': /* umount everything */
++all;
break;
case 'f': /* force umount (needs kernel support) */
#if 0
++force;
#else
die (2, "umount: forced umount not supported yet");
#endif
break;
case 'h': /* help */
usage (stdout, 0);
break;
case 'n':
++umount_nomtab;
break;
case 'r': /* remount read-only if umount fails */
++remount;
break;
case 'v': /* make noise */
++umount_verbose;
break;
case 'V': /* version */
printf ("umount: %s\n", version);
exit (0);
case 't': /* specify file system type */
types = parse_list (optarg);
break;
case 0:
break;
case '?':
default:
usage (stderr, 1);
}
if (getuid () != geteuid ())
{
umount_suid = 1;
if (all || types || umount_nomtab)
die (2, "umount: only root can do that");
}
argc -= optind;
argv += optind;
if (all) {
if (types == NULL)
types = parse_list(xstrdup("noproc"));
result = umount_all (types);
} else if (argc < 1) {
usage (stderr, 2);
} else while (argc--) {
file = canonicalize (*argv); /* mtab paths are canonicalized */
if (umount_verbose > 1)
printf("Trying to umount %s\n", file);
mc = getmntfile (file);
if (!mc && umount_verbose)
printf("Could not find %s in mtab\n", file);
if (umount_suid) {
if (!mc)
die (2, "umount: %s is not mounted (according to mtab)", file);
if (!(fs = getfsspec (file)) && !(fs = getfsfile (file)))
die (2, "umount: %s is not in the fstab (and you are not root)",
file);
if ((!streq (mc->mnt_fsname, fs->mnt_fsname) &&
!streq (mc->mnt_fsname, canonicalize (fs->mnt_fsname)))
|| (!streq (mc->mnt_dir, fs->mnt_dir) &&
!streq (mc->mnt_dir, canonicalize (fs->mnt_dir)))) {
die (2, "umount: %s mount disagrees with the fstab", file);
}
options = parse_list (fs->mnt_opts);
while (options) {
if (streq (car (options), "user"))
break;
options = cdr (options);
}
if (!options)
die (2, "umount: only root can unmount %s from %s",
fs->mnt_fsname, fs->mnt_dir);
}
if (mc)
result = umount_one (xstrdup(mc->mnt_fsname), xstrdup(mc->mnt_dir),
xstrdup(mc->mnt_type), xstrdup(mc->mnt_opts));
else
result = umount_one (*argv, *argv, *argv, *argv);
argv++;
}
exit (result);
}
int
ufs_disk_fillout_blank(struct uufsd *disk, const char *name)
{
struct stat st;
struct fstab *fs;
struct statfs sfs;
const char *oname;
char dev[MAXPATHLEN];
int fd, ret;
ERROR(disk, NULL);
oname = name;
again: if ((ret = stat(name, &st)) < 0) {
if (*name != '/') {
snprintf(dev, sizeof(dev), "%s%s", _PATH_DEV, name);
name = dev;
goto again;
}
/*
* The given object doesn't exist, but don't panic just yet -
* it may be still mount point listed in /etc/fstab, but without
* existing corresponding directory.
*/
name = oname;
}
if (ret >= 0 && S_ISREG(st.st_mode)) {
/* Possibly a disk image, give it a try. */
;
} else if (ret >= 0 && S_ISCHR(st.st_mode)) {
/* This is what we need, do nothing. */
;
} else if ((fs = getfsfile(name)) != NULL) {
/*
* The given mount point is listed in /etc/fstab.
* It is possible that someone unmounted file system by hand
* and different file system is mounted on this mount point,
* but we still prefer /etc/fstab entry, because on the other
* hand, there could be /etc/fstab entry for this mount
* point, but file system is not mounted yet (eg. noauto) and
* statfs(2) will point us at different file system.
*/
name = fs->fs_spec;
} else if (ret >= 0 && S_ISDIR(st.st_mode)) {
/*
* The mount point is not listed in /etc/fstab, so it may be
* file system mounted by hand.
*/
if (statfs(name, &sfs) < 0) {
ERROR(disk, "could not find special device");
return (-1);
}
strlcpy(dev, sfs.f_mntfromname, sizeof(dev));
name = dev;
} else {
ERROR(disk, "could not find special device");
return (-1);
}
fd = open(name, O_RDONLY);
if (fd == -1) {
ERROR(disk, "could not open special device");
return (-1);
}
disk->d_bsize = 1;
disk->d_ccg = 0;
disk->d_fd = fd;
disk->d_inoblock = NULL;
disk->d_inomin = 0;
disk->d_inomax = 0;
disk->d_lcg = 0;
disk->d_mine = 0;
disk->d_ufs = 0;
disk->d_error = NULL;
disk->d_sbcsum = NULL;
if (oname != name) {
name = strdup(name);
if (name == NULL) {
ERROR(disk, "could not allocate memory for disk name");
return (-1);
}
disk->d_mine |= MINE_NAME;
}
disk->d_name = name;
return (0);
}
const char *
blockcheck(const char *origname)
{
struct stat stslash, stblock, stchar;
const char *newname, *raw, *cooked;
struct fstab *fsp;
int retried = 0;
ssize_t len;
char cbuf[MAXPATHLEN];
static char buf[MAXPATHLEN];
hot = 0;
if (stat("/", &stslash) < 0) {
perr("Can't stat `/'");
return (origname);
}
len = readlink(origname, cbuf, sizeof(cbuf)-1);
if (len == -1) {
newname = origname;
} else {
cbuf[len] = '\0';
newname = cbuf;
}
retry:
if (stat(newname, &stblock) < 0) {
perr("Can't stat `%s'", newname);
return origname;
}
if (S_ISBLK(stblock.st_mode)) {
if (stslash.st_dev == stblock.st_rdev)
hot++;
raw = getdiskrawname(buf, sizeof(buf), newname);
if (raw == NULL) {
perr("Can't convert to raw `%s'", newname);
return origname;
}
if (stat(raw, &stchar) < 0) {
perr("Can't stat `%s'", raw);
return origname;
}
if (S_ISCHR(stchar.st_mode)) {
return raw;
} else {
perr("%s is not a character device\n", raw);
return origname;
}
} else if (S_ISCHR(stblock.st_mode) && !retried) {
cooked = getdiskcookedname(cbuf, sizeof(cbuf), newname);
if (cooked == NULL) {
perr("Can't convert to cooked `%s'", newname);
return origname;
} else
newname = cooked;
retried++;
goto retry;
} else if ((fsp = getfsfile(newname)) != 0 && !retried) {
newname = getfsspecname(cbuf, sizeof(cbuf), fsp->fs_spec);
if (newname == NULL)
perr("%s", buf);
retried++;
goto retry;
}
/*
* Not a block or character device, just return name and
* let the user decide whether to use it.
*/
return origname;
}
int
main(int argc, char *argv[])
{
struct fstab *fs;
int i, rval = 0;
const char *vfstype = NULL;
char globopt[3];
const char *etc_fstab;
globopt[0] = '-';
globopt[2] = '\0';
TAILQ_INIT(&selhead);
TAILQ_INIT(&opthead);
etc_fstab = NULL;
while ((i = getopt(argc, argv, "BCdvpfFnyl:t:T:c:")) != -1)
switch (i) {
case 'B':
if (flags & CHECK_BACKGRD)
errx(1, "Cannot specify -B and -F.");
flags |= DO_BACKGRD;
break;
case 'd':
flags |= CHECK_DEBUG;
break;
case 'v':
flags |= CHECK_VERBOSE;
break;
case 'F':
if (flags & DO_BACKGRD)
errx(1, "Cannot specify -B and -F.");
flags |= CHECK_BACKGRD;
break;
case 'p':
flags |= CHECK_PREEN;
/*FALLTHROUGH*/
case 'C':
flags |= CHECK_CLEAN;
/*FALLTHROUGH*/
case 'n':
case 'y':
globopt[1] = i;
catopt(&options, globopt);
break;
case 'f':
forceflag = 1;
globopt[1] = i;
catopt(&options, globopt);
break;
case 'l':
warnx("Ignoring obsolete -l option\n");
break;
case 'T':
if (*optarg)
addoption(optarg);
break;
case 't':
if (!TAILQ_EMPTY(&selhead))
errx(1, "only one -t option may be specified.");
maketypelist(optarg);
vfstype = optarg;
break;
case 'c':
etc_fstab = optarg;
break;
case '?':
default:
usage();
/* NOTREACHED */
}
argc -= optind;
argv += optind;
if (etc_fstab != NULL)
setfstab(etc_fstab);
if (argc == 0)
return checkfstab(flags, isok, checkfs);
#define BADTYPE(type) \
(strcmp(type, FSTAB_RO) && \
strcmp(type, FSTAB_RW) && strcmp(type, FSTAB_RQ))
for (; argc--; argv++) {
const char *spec, *mntpt, *type, *cp;
char device[MAXPATHLEN];
struct statfs *mntp;
mntpt = NULL;
spec = *argv;
cp = strrchr(spec, '/');
if (cp == 0) {
(void)snprintf(device, sizeof(device), "%s%s",
_PATH_DEV, spec);
spec = device;
}
mntp = getmntpt(spec);
if (mntp != NULL) {
spec = mntp->f_mntfromname;
mntpt = mntp->f_mntonname;
}
if ((fs = getfsfile(spec)) == NULL &&
(fs = getfsspec(spec)) == NULL) {
if (vfstype == NULL)
vfstype = getfslab(spec);
if (vfstype == NULL)
errx(1, "Could not determine filesystem type");
type = vfstype;
devcheck(spec);
} else {
spec = fs->fs_spec;
type = fs->fs_vfstype;
mntpt = fs->fs_file;
if (BADTYPE(fs->fs_type))
errx(1, "%s has unknown file system type.",
spec);
}
if ((flags & CHECK_BACKGRD) &&
checkfs(type, spec, mntpt, "-F", NULL) == 0) {
printf("%s: DEFER FOR BACKGROUND CHECKING\n", *argv);
continue;
}
if ((flags & DO_BACKGRD) && forceflag == 0 &&
checkfs(type, spec, mntpt, "-F", NULL) != 0)
continue;
rval |= checkfs(type, spec, mntpt, NULL, NULL);
}
return rval;
}
void disk_parse_config(char *token, char *cptr)
{
#if HAVE_GETMNTENT
#if HAVE_SYS_MNTTAB_H
struct mnttab mnttab;
#else
struct mntent *mntent;
#endif
FILE *mntfp;
#else
#if HAVE_FSTAB_H
struct fstab *fstab;
struct stat stat1, stat2;
#endif
#endif
char tmpbuf[1024];
#if defined(HAVE_GETMNTENT) && !defined(HAVE_SETMNTENT)
int i;
#endif
#if HAVE_FSTAB_H || HAVE_GETMNTENT
if (numdisks == MAXDISKS) {
config_perror("Too many disks specified.");
sprintf(tmpbuf,"\tignoring: %s",cptr);
config_perror(tmpbuf);
}
else {
/* read disk path (eg, /1 or /usr) */
copy_word(cptr,disks[numdisks].path);
cptr = skip_not_white(cptr);
cptr = skip_white(cptr);
/* read optional minimum disk usage spec */
if (cptr != NULL) {
if (strchr(cptr, '%') == 0) {
disks[numdisks].minimumspace = atoi(cptr);
disks[numdisks].minpercent = -1;
}
else {
disks[numdisks].minimumspace = -1;
disks[numdisks].minpercent = atoi(cptr);
}
}
else {
disks[numdisks].minimumspace = DEFDISKMINIMUMSPACE;
disks[numdisks].minpercent = -1;
}
/* find the device associated with the directory */
#if HAVE_GETMNTENT
#if HAVE_SETMNTENT
mntfp = setmntent(ETC_MNTTAB, "r");
disks[numdisks].device[0] = 0;
while ((mntent = getmntent (mntfp)))
if (strcmp (disks[numdisks].path, mntent->mnt_dir) == 0) {
copy_word (mntent->mnt_fsname, disks[numdisks].device);
DEBUGMSGTL(("ucd-snmp/disk", "Disk: %s\n",mntent->mnt_fsname));
break;
}
else {
DEBUGMSGTL(("ucd-snmp/disk", " %s != %s\n", disks[numdisks].path,
mntent->mnt_dir));
}
endmntent(mntfp);
if (disks[numdisks].device[0] != 0) {
/* dummy clause for else below */
numdisks += 1; /* but inc numdisks here after test */
}
#else /* getmentent but not setmntent */
mntfp = fopen (ETC_MNTTAB, "r");
while ((i = getmntent (mntfp, &mnttab)) == 0)
if (strcmp (disks[numdisks].path, mnttab.mnt_mountp) == 0)
break;
else {
DEBUGMSGTL(("ucd-snmp/disk", " %s != %s\n", disks[numdisks].path, mnttab.mnt_mountp));
}
fclose (mntfp);
if (i == 0) {
copy_word (mnttab.mnt_special, disks[numdisks].device);
numdisks += 1;
}
#endif /* HAVE_SETMNTENT */
#else
#if HAVE_FSTAB_H
stat(disks[numdisks].path,&stat1);
setfsent();
if ((fstab = getfsfile(disks[numdisks].path))) {
copy_word(fstab->fs_spec,disks[numdisks].device);
numdisks += 1;
}
#endif
#endif
else {
sprintf(tmpbuf, "Couldn't find device for disk %s",
disks[numdisks].path);
config_pwarn(tmpbuf);
disks[numdisks].minimumspace = -1;
disks[numdisks].minpercent = -1;
disks[numdisks].path[0] = 0;
}
#if HAVE_FSTAB_H
endfsent();
#endif
}
#else
config_perror("'disk' checks not supported on this architecture.");
#endif
}
