int
umountall(char **typelist)
{
struct vfsconf vfc;
struct fstab *fs;
int rval;
char *cp;
static int firstcall = 1;
if ((fs = getfsent()) != NULL)
firstcall = 0;
else if (firstcall)
errx(1, "fstab reading failure");
else
return (0);
do {
/* Ignore the root. */
if (strcmp(fs->fs_file, "/") == 0)
continue;
/*
* !!!
* Historic practice: ignore unknown FSTAB_* fields.
*/
if (strcmp(fs->fs_type, FSTAB_RW) &&
strcmp(fs->fs_type, FSTAB_RO) &&
strcmp(fs->fs_type, FSTAB_RQ))
continue;
/* If an unknown file system type, complain. */
if (getvfsbyname(fs->fs_vfstype, &vfc) == -1) {
warnx("%s: unknown mount type", fs->fs_vfstype);
continue;
}
if (checkvfsname(fs->fs_vfstype, typelist))
continue;
/*
* We want to unmount the file systems in the reverse order
* that they were mounted. So, we save off the file name
* in some allocated memory, and then call recursively.
*/
if ((cp = malloc((size_t)strlen(fs->fs_file) + 1)) == NULL)
err(1, "malloc failed");
(void)strcpy(cp, fs->fs_file);
rval = umountall(typelist);
rval = umountfs(cp, typelist) || rval;
free(cp);
return (rval);
} while ((fs = getfsent()) != NULL);
return (0);
}
static void read_table(void)
{
int tab;
struct fstab *ent;
MountPoint *mp;
clear_table();
tab = setfsent();
g_return_if_fail(tab != 0);
while ((ent = getfsent()))
{
if (strcmp(ent->fs_vfstype, "swap") == 0)
continue;
if (strcmp(ent->fs_vfstype, "kernfs") == 0)
continue;
mp = g_malloc(sizeof(MountPoint));
mp->name = g_strdup(ent->fs_spec); /* block special device name */
mp->dir = g_strdup(ent->fs_file); /* file system path prefix */
g_hash_table_insert(fstab_mounts, mp->dir, mp);
}
endfsent();
}
GPtrArray * disks_new(gboolean include_NFSs)
{
GPtrArray * pdisks ;
t_disk * pdisk ;
struct fstab * pfstab ;
// open fstab
if (setfsent() != 1)
return NULL ; // on error return NULL
pdisks = g_ptr_array_new();
for(;;)
{
pfstab = getfsent() ; //read a line in fstab
if (pfstab == NULL) break ; // on eof exit
// if pfstab->fs_spec do not begins with /dev discard
//if pfstab->fs_file == none discard
if ( g_str_has_prefix(pfstab->fs_spec,"/dev/") && (g_str_has_prefix(pfstab->fs_file,"/") != 0) )
{
pdisk = disk_new(pfstab->fs_spec, pfstab->fs_file);
g_ptr_array_add( pdisks , pdisk );
}
}
endfsent(); //closes file
return pdisks ;
}
LISP lgetfsent(void)
{long iflag;
LISP result;
iflag = no_interrupt(1);
result = decode_fstab(getfsent());
no_interrupt(iflag);
return(result);}
void cdrom_drive_scan(void)
{
unsigned char ident[256];
uint32_t identlen;
char cmd[12] = {0x12,0,0,0, 0xFF,0,0,0, 0,0,0,0};
struct fstab *ent;
struct stat st;
setfsent();
while( (ent = getfsent()) != NULL ) {
if( (stat(ent->fs_spec, &st) != -1) &&
S_ISBLK(st.st_mode) ) {
/* Got a valid block device - is it a CDROM? */
int fd = open(ent->fs_spec, O_RDONLY|O_NONBLOCK);
if( fd == -1 )
continue;
int caps = ioctl(fd, CDROM_GET_CAPABILITY);
if( caps != -1 ) {
/* Appears to support CDROM functions */
identlen = sizeof(ident);
if( linux_cdrom_do_cmd( fd, cmd, ident, &identlen, CGC_DATA_READ ) ==
CDROM_ERROR_OK ) {
const char *drive_name = mmc_parse_inquiry( ident );
cdrom_drive_add( ent->fs_spec, drive_name, linux_cdrom_drive_open );
}
}
close(fd);
}
}
}
int
VAttachPartitions(void)
{
int errors = 0;
struct fstab *fsent;
if (setfsent() < 0) {
Log("Error listing filesystems.\n");
exit(-1);
}
while ((fsent = getfsent())) {
if (strcmp(fsent->fs_type, "rw") != 0)
continue;
/* If we're going to always attach this partition, do it later. */
if (VIsAlwaysAttach(fsent->fs_file))
continue;
if (VCheckPartition(fsent->fs_file, fsent->fs_spec) < 0)
errors++;
}
endfsent();
/* Process the always-attach partitions, if any. */
VAttachPartitions2();
return errors;
}
bool GetInfo_Partitions (QListView *lbox)
{
struct fstab *fstab_ent;
if (setfsent() != 1) /* Try to open fstab */ {
int s_err = errno;
QString s;
s = i18n("Could not check filesystem info: ");
s += strerror(s_err);
(void)new QListViewItem(lbox, 0, s);
} else {
lbox->addColumn(i18n("Device"));
lbox->addColumn(i18n("Mount Point"));
lbox->addColumn(i18n("FS Type"));
lbox->addColumn(i18n("Mount Options"));
while ((fstab_ent=getfsent())!=NULL) {
new QListViewItem(lbox, fstab_ent->fs_spec,
fstab_ent->fs_file, fstab_ent->fs_vfstype,
fstab_ent->fs_mntops);
}
lbox->setSorting(0);
lbox->header()->setClickEnabled(true);
endfsent(); /* Close fstab */
}
return true;
}
int
main(int argc, char **argv)
{
struct fstab *fs;
umask(S_IWGRP | S_IWOTH);
if (argc != 4) {
error("Wrong number of arguments: %d", argc);
return EXIT_FAILURE;
}
unitdir = argv[1];
unitdirlen = strlen(argv[1]);
parse_cmdline_files(get_timeout);
while ((fs = getfsent()) != NULL) {
if (strncmp(fs->fs_file, KDUMP_DIR, KDUMP_DIR_LEN))
continue;
unescape_fstab(fs->fs_spec);
create_conf(fs->fs_spec);
}
return EXIT_SUCCESS;
}
int
main (int argc, char *argv[])
{
struct fstab *fstab;
int status;
int all = 0;
int c;
if (strrchr (argv[0], '/') != NULL)
program_name = strrchr (argv[0], '/') + 1;
else
program_name = argv[0];
while ((c = getopt_long (argc, argv, "ahvV", longopts, NULL)) != EOF)
switch (c)
{
case 'a': /* all */
++all;
break;
case 'h': /* help */
usage (stdout, 0);
break;
case 'v': /* be chatty */
++verbose;
break;
case 'V': /* version */
printf ("%s\n", version);
exit (0);
case 0:
break;
case '?':
default:
usage (stderr, 1);
}
argv += optind;
status = 0;
if (all)
{
while ((fstab = getfsent()) != NULL)
if (streq (fstab->fs_type, FSTAB_SW))
status |= swap (fstab->fs_spec);
}
else if (*argv == NULL)
{
usage (stderr, 2);
}
else
{
while (*argv != NULL)
status |= swap (*argv++);
}
return status;
}
bool
GetInfo_Partitions ( QListView *lbox )
{
#define NUMCOLS 5
QString Title[NUMCOLS];
int n;
struct fstab *fstab_ent;
struct statvfs svfs;
long total,avail;
QString str;
QString MB(i18n("MB")+ " "); // International Text for MB=Mega-Byte
if (setfsent() != 1) // Try to open fstab
return false;
Title[0] = i18n("Device");
Title[1] = i18n("Mount Point");
Title[2] = i18n("FS Type");
Title[3] = i18n("Total Size");
Title[4] = i18n("Free Size");
for (n=0; n<NUMCOLS; ++n) {
lbox->addColumn(Title[n] );
}
while ((fstab_ent=getfsent())!=NULL) {
/* fstab_ent->fs_type holds only "rw","xx","ro"... */
memset(&svfs,0,sizeof(svfs));
statvfs(fstab_ent->fs_file,&svfs);
get_fs_usage(fstab_ent->fs_file, &total, &avail);
if (!strcmp(fstab_ent->fs_type,FSTAB_XX)) // valid drive ?
svfs.f_basetype[0] = 0;
if(svfs.f_basetype[0]) {
new QListViewItem(lbox, QString(fstab_ent->fs_spec),
QString(fstab_ent->fs_file) + QString(" "),
(svfs.f_basetype[0] ? QString(svfs.f_basetype) : i18n("n/a")),
Value((total+512)/1024,6) + MB,
Value((avail+512)/1024,6) + MB);
}
else {
new QListViewItem(lbox, QString(fstab_ent->fs_spec),
QString(fstab_ent->fs_file) + QString(" "),
(svfs.f_basetype[0] ? QString(svfs.f_basetype) : i18n("n/a")));
}
}
endfsent();
return true;
}
/*!
Return a string containing the default CD device if none is specified.
*/
char *
cdio_get_default_device_freebsd()
{
#ifndef HAVE_FREEBSD_CDROM
return NULL;
#else
char drive[40];
bool exists=true;
char c;
/* Scan the system for CD-ROM drives.
*/
#ifdef USE_ETC_FSTAB
struct fstab *fs;
setfsent();
/* Check what's in /etc/fstab... */
while ( (fs = getfsent()) )
{
if (strncmp(fs->fs_spec, "/dev/sr", 7))
return strdup(fs->fs_spec);
}
#endif
/* Scan the system for CD-ROM drives.
Not always 100% reliable, so use the USE_MNTENT code above first.
*/
/* Scan SCSI and CAM devices */
for ( c='0'; exists && c <='9'; c++ ) {
sprintf(drive, "/dev/cd%c%s", c, DEVICE_POSTFIX);
exists = cdio_is_cdrom(drive, NULL);
if ( exists ) {
return strdup(drive);
}
}
/* Scan are ATAPI devices */
exists = true;
for ( c='0'; exists && c <='9'; c++ ) {
sprintf(drive, "/dev/acd%c%s", c, DEVICE_POSTFIX);
exists = cdio_is_cdrom(drive, NULL);
if ( exists ) {
return strdup(drive);
}
}
return NULL;
#endif /*HAVE_FREEBSD_CDROM*/
}
bool
SystemInformation::s_getFileSystem(fs_cont& out)
{
#if defined(OS_LINUX)
FILE* fp(setmntent(_PATH_MOUNTED, "r"));
if ( nullptr == fp ) return false;
fs_cont tmp;
fs_type fs;
struct mntent mntbuf;
char buf[1024+1];
while ( nullptr not_eq getmntent_r(fp, &mntbuf, buf, sizeof(buf)) )
{
if ( not s_getFileSystem(fs, mntbuf.mnt_dir) )
{
::fclose(fp);
return false;
}
tmp.insert(fs_cont::value_type(mntbuf.mnt_dir, fs));
}
::fclose(fp);
out.swap(tmp);
return true;
#elif defined(OS_BSD) || defined(OS_APPLE)
auto fstab = getfsent();
if ( nullptr == fstab ) return false;
fs_cont tmp;
fs_type fs;
while ( fstab )
{
if ( not s_getFileSystem(fs, fstab->fs_file) )
{
endfsent();
return false;
}
tmp.insert(fs_cont::value_type(fstab->fs_file, fs));
++fstab;
}
endfsent();
out.swap(tmp);
return true;
#endif
}
void DAMountMapListRefresh1( void )
{
struct stat status;
/*
* Determine whether the mount map list is up-to-date.
*/
if ( stat( _PATH_FSTAB, &status ) )
{
__gDAMountMapListTime1.tv_sec = 0;
__gDAMountMapListTime1.tv_nsec = 0;
}
if ( __gDAMountMapListTime1.tv_sec != status.st_mtimespec.tv_sec ||
__gDAMountMapListTime1.tv_nsec != status.st_mtimespec.tv_nsec )
{
__gDAMountMapListTime1.tv_sec = status.st_mtimespec.tv_sec;
__gDAMountMapListTime1.tv_nsec = status.st_mtimespec.tv_nsec;
/*
* Clear the mount map list.
*/
CFArrayRemoveAllValues( gDAMountMapList1 );
/*
* Build the mount map list.
*/
if ( setfsent( ) )
{
struct fstab * item;
while ( ( item = getfsent( ) ) )
{
CFDictionaryRef map;
map = __DAMountMapCreate1( kCFAllocatorDefault, item );
if ( map )
{
CFArrayAppendValue( gDAMountMapList1, map );
CFRelease( map );
}
}
endfsent( );
}
}
}
/* Find the dir FILE in fstab. */
struct mntent *
getfsfile (const char *file)
{
struct mntent *fstab;
/* Open or rewind fstab. */
if (!setfsent ())
return 0;
while (fstab = getfsent ())
if (streq (fstab->mnt_dir, file))
break;
return fstab;
}
/* Find the device SPEC in fstab. */
struct mntent *
getfsspec (const char *spec)
{
struct mntent *fstab;
/* Open or rewind fstab. */
if (!setfsent())
return 0;
while (fstab = getfsent ())
if (streq (fstab->mnt_fsname, spec))
break;
return fstab;
}
int listfstab(void)
{
fscounter = 0;
setfsent(); // Set use of Fstab
while(( fs = getfsent())) {
(void)mvwprintw(fslistbox, fscounter, 2, "%s", fs->fs_spec); // Filesystem node (Devices)
(void)mvwprintw(fslistbox, fscounter, 26, "%s", fs->fs_file); // Mount Point
(void)mvwprintw(fslistbox, fscounter, 46 , "%s", fs->fs_vfstype); // Filesystem Type
(void)mvwprintw(fslistbox, fscounter, 60, "%s", fs->fs_mntops); // Mount Opts
wmove(fslistbox, fscounter++, 3); // Increment downline after each line.
}
endfsent(); // end use of Fstab
wrefresh(fslistbox);
return 0;
}
/*
* Check all filesystems in /etc/fstab with a fs_passno > 0
*/
static int fsck(int pass)
{
// int save;
struct fstab *fs;
if (!setfsent()) {
_pe("Failed opening fstab");
return 1;
}
// if ((save = log_is_debug()))
// log_debug();
while ((fs = getfsent())) {
char cmd[80];
struct stat st;
if (fs->fs_passno != pass)
continue;
errno = 0;
if (stat(fs->fs_spec, &st) || !S_ISBLK(st.st_mode)) {
if (!string_match(fs->fs_spec, "UUID=") && !string_match(fs->fs_spec, "LABEL=")) {
_d("Cannot fsck %s, not a block device: %s", fs->fs_spec, strerror(errno));
continue;
}
}
if (fismnt(fs->fs_file)) {
_d("Skipping fsck of %s, already mounted on %s.", fs->fs_spec, fs->fs_file);
continue;
}
snprintf(cmd, sizeof(cmd), "fsck -a %s", fs->fs_spec);
run_interactive(cmd, "Checking filesystem %.13s", fs->fs_spec);
}
// if (save)
// log_debug();
endfsent();
return 0;
}
/*
* Collect the requested quota information.
*/
struct quotause *
getprivs(long id, int quotatype, char *fspath)
{
struct quotafile *qf;
struct fstab *fs;
struct quotause *qup, *quptail;
struct quotause *quphead;
setfsent();
quphead = quptail = NULL;
while ((fs = getfsent())) {
if (fspath && *fspath && strcmp(fspath, fs->fs_spec) &&
strcmp(fspath, fs->fs_file))
continue;
if (strcmp(fs->fs_vfstype, "ufs"))
continue;
if ((qf = quota_open(fs, quotatype, O_CREAT|O_RDWR)) == NULL) {
if (errno != EOPNOTSUPP)
warn("cannot open quotas on %s", fs->fs_file);
continue;
}
if ((qup = (struct quotause *)calloc(1, sizeof(*qup))) == NULL)
errx(2, "out of memory");
qup->qf = qf;
strncpy(qup->fsname, fs->fs_file, sizeof(qup->fsname));
if (quota_read(qf, &qup->dqblk, id) == -1) {
warn("cannot read quotas on %s", fs->fs_file);
freeprivs(qup);
continue;
}
if (quphead == NULL)
quphead = qup;
else
quptail->next = qup;
quptail = qup;
qup->next = 0;
}
if (quphead == NULL) {
warnx("No quotas on %s", fspath ? fspath : "any filesystems");
}
endfsent();
return (quphead);
}
gint32
Mono_Posix_Syscall_getfsent (struct Mono_Posix_Syscall__Fstab *fsbuf)
{
mph_fstab *fs;
if (fsbuf == NULL) {
errno = EFAULT;
return -1;
}
fs = getfsent ();
if (fs == NULL)
return -1;
if (copy_fstab (fsbuf, fs) == -1) {
errno = ENOMEM;
return -1;
}
return 0;
}
int
main(int argc, char **argv)
{
struct fstab *fstab;
int status;
int opt;
int all = 0;
if (strrchr (argv[0], '/') != NULL)
progname = strrchr (argv[0], '/') + 1;
else
progname = argv[0];
while ((opt = getopt(argc, argv, "a")) != EOF)
switch(opt)
{
case 'a': ++all; break;
default: usage ();
}
argv += optind;
status = 0;
if (all)
{
while ((fstab = getfsent()) != NULL)
if (streq (fstab->fs_type, FSTAB_SW))
status |= swap (fstab->fs_spec);
}
else if (*argv == NULL)
{
usage ();
}
else
{
while (*argv != NULL)
status |= swap (*argv++);
}
return status;
}
/* Function to detect the MB of diskspace on a path */
int detect_diskspace(const char *path)
{
long long avail = 0LL;
if ( path[0] == '/' ) {
#ifdef HAVE_SYS_STATVFS_H
struct statvfs fs;
#else
struct statfs fs;
#endif
char buf[PATH_MAX], *cp;
strcpy(buf, path);
cp = buf+strlen(buf);
while ( buf[0] && (access(buf, F_OK) < 0) ) {
while ( (cp > (buf+1)) && (*cp != '/') ) {
--cp;
}
*cp = '\0';
}
if ( buf[0] ) {
#ifdef HAVE_SYS_STATVFS_H
if ( statvfs(buf, &fs) ) {
#else
if ( statfs(buf, &fs) ) {
#endif
perror("statfs");
return 0;
}
avail = fs.f_bsize;
avail *= fs.f_bavail;
}
}
return avail / (1024*1024LL);
}
int detect_and_mount_cdrom(char *path[SETUP_MAX_DRIVES])
{
int num_cdroms = 0;
#ifdef __FreeBSD__
int mounted;
struct fstab *fstab;
/* Try to mount unmounted CDROM filesystems */
while( (fstab = getfsent()) != NULL ){
if ( !strcmp(fstab->fs_vfstype, MNTTYPE_CDROM)) {
if ( !is_fs_mounted(fstab->fs_spec)) {
if ( ! run_command(NULL, MOUNT_PATH, fstab->fs_spec, 1) ) {
add_mounted_entry(fstab->fs_spec, fstab->fs_file);
log_normal(_("Mounted device %s"), fstab->fs_spec);
}
}
}
}
endfsent();
mounted = getfsstat(NULL, 0, MNT_WAIT);
if ( mounted > 0 ) {
int i;
struct statfs *mnts = (struct statfs *)malloc(sizeof(struct statfs) * mounted);
mounted = getfsstat(mnts, mounted * sizeof(struct statfs), MNT_WAIT);
for ( i = 0; i < mounted && num_cdroms < SETUP_MAX_DRIVES; ++ i ) {
if ( ! strcmp(mnts[i].f_fstypename, MNTTYPE_CDROM) ) {
path[num_cdroms ++] = strdup(mnts[i].f_mntonname);
}
}
free(mnts);
}
#elif defined(darwin)
{
const char *devPrefix = "/dev/";
int prefixLen = strlen(devPrefix);
mach_port_t masterPort = 0;
struct statfs *mntbufp;
int i, mounts;
if (IOMasterPort(MACH_PORT_NULL, &masterPort) == KERN_SUCCESS)
{
mounts = getmntinfo(&mntbufp, MNT_WAIT); /* NOT THREAD SAFE! */
for (i = 0; i < mounts && num_cdroms < SETUP_MAX_DRIVES; i++)
{
char *dev = mntbufp[i].f_mntfromname;
char *mnt = mntbufp[i].f_mntonname;
if (strncmp(dev, devPrefix, prefixLen) != 0) /* virtual device? */
continue;
/* darwinIsMountedDisc needs to skip "/dev/" part of string... */
if (darwinIsMountedDisc(dev + prefixLen, masterPort))
{
strcpy(darwinEjectThisCDDevice, dev + prefixLen);
path[num_cdroms ++] = strdup(mnt);
}
}
}
}
#elif defined(sco)
/* Quite horrible. We have to parse mount's output :( */
/* And of course, we can't try to mount unmounted filesystems */
FILE *cmd = popen("/etc/mount", "r");
if ( cmd ) {
char device[32] = "", mountp[PATH_MAX] = "";
while ( fscanf(cmd, "%s on %32s %*[^\n]", mountp, device) > 0 ) {
if ( !strncmp(device, "/dev/cd", 7) ) {
path[num_cdroms ++] = strdup(mountp);
break;
}
}
pclose(cmd);
}
#elif defined(hpux)
char mntdevpath[PATH_MAX];
FILE *mountfp;
struct mntent *mntent;
const char *fstab, *mtab, *mount_cmd, *mnttype;
/* HPUX: We need to support PFS */
if ( !access("/etc/pfs_fstab", F_OK) ) {
fstab = "/etc/pfs_fstab";
mtab = "/etc/pfs_mtab";
mount_cmd = "/usr/sbin/pfs_mount";
mnttype = "pfs-rrip";
} else {
fstab = SETUP_FSTAB;
mtab = MOUNTS_FILE;
mnttype = MNTTYPE_CDROM;
mount_cmd = MOUNT_PATH;
}
/* Try to mount unmounted CDROM filesystems */
mountfp = setmntent( fstab, "r" );
if( mountfp != NULL ) {
while( (mntent = getmntent( mountfp )) != NULL ){
if ( !strcmp(mntent->mnt_type, mnttype) ) {
char *fsname = strdup(mntent->mnt_fsname);
char *dir = strdup(mntent->mnt_dir);
if ( !is_fs_mounted(fsname)) {
if ( ! run_command(NULL, mount_cmd, fsname, 1) ) {
add_mounted_entry(fsname, dir);
log_normal(_("Mounted device %s"), fsname);
}
}
free(fsname);
free(dir);
}
}
endmntent(mountfp);
}
mountfp = setmntent(mtab, "r" );
if( mountfp != NULL ) {
while( (mntent = getmntent( mountfp )) != NULL && num_cdroms < SETUP_MAX_DRIVES){
char mntdev[1024], mnt_type[32];
strcpy(mntdev, mntent->mnt_fsname);
strcpy(mnt_type, mntent->mnt_type);
if( strncmp(mntdev, "/dev", 4) ||
realpath(mntdev, mntdevpath) == NULL ) {
continue;
}
if ( strcmp(mnt_type, mnttype) == 0 ) {
path[num_cdroms ++] = strdup(mntent->mnt_dir);
}
}
endmntent( mountfp );
}
#elif defined(__svr4__)
struct mnttab mnt;
FILE *fstab = fopen(SETUP_FSTAB, "r");
if ( fstab != NULL ) {
while ( getmntent(fstab, &mnt)==0 ) {
if ( !strcmp(mnt.mnt_fstype, MNTTYPE_CDROM) ) {
char *fsname = strdup(mnt.mnt_special);
char *dir = strdup(mnt.mnt_mountp);
if ( !is_fs_mounted(fsname)) {
if ( ! run_command(NULL, MOUNT_PATH, fsname, 1) ) {
add_mounted_entry(fsname, dir);
log_normal(_("Mounted device %s"), fsname);
}
}
free(fsname);
free(dir);
break;
}
}
fclose(fstab);
fstab = fopen(MOUNTS_FILE, "r");
if (fstab) {
while ( getmntent(fstab, &mnt)==0 && num_cdroms < SETUP_MAX_DRIVES) {
if ( !strcmp(mnt.mnt_fstype, MNTTYPE_CDROM) ) {
path[num_cdroms ++] = strdup(mnt.mnt_mountp);
}
}
fclose(fstab);
}
}
#else
//#ifndef darwin
char mntdevpath[PATH_MAX];
FILE *mountfp;
struct mntent *mntent;
/* Try to mount unmounted CDROM filesystems */
mountfp = setmntent( SETUP_FSTAB, "r" );
if( mountfp != NULL ) {
while( (mntent = getmntent( mountfp )) != NULL ){
if ( (!strcmp(mntent->mnt_type, MNTTYPE_CDROM)
#ifdef sgi
|| !strcmp(mntent->mnt_type, "cdfs")
|| !strcmp(mntent->mnt_type, "efs")
#endif
|| !strcmp(mntent->mnt_type, "auto"))
&& strncmp(mntent->mnt_fsname, DEVICE_FLOPPY, strlen(DEVICE_FLOPPY)) ) {
char *fsname = strdup(mntent->mnt_fsname);
char *dir = strdup(mntent->mnt_dir);
if ( !is_fs_mounted(fsname)) {
if ( ! run_command(NULL, MOUNT_PATH, fsname, 1) ) {
add_mounted_entry(fsname, dir);
log_normal(_("Mounted device %s"), fsname);
}
}
free(fsname);
free(dir);
}
}
endmntent(mountfp);
}
mountfp = setmntent(MOUNTS_FILE, "r" );
if( mountfp != NULL ) {
while( (mntent = getmntent( mountfp )) != NULL && num_cdroms < SETUP_MAX_DRIVES){
char *tmp, mntdev[1024], mnt_type[32];
if ( strncmp(mntent->mnt_fsname, DEVICE_FLOPPY, strlen(DEVICE_FLOPPY)) == 0)
continue;
strcpy(mntdev, mntent->mnt_fsname);
strcpy(mnt_type, mntent->mnt_type);
if ( strcmp(mnt_type, MNTTYPE_SUPER) == 0 ) {
tmp = strstr(mntent->mnt_opts, "fs=");
if ( tmp ) {
strcpy(mnt_type, tmp+strlen("fs="));
tmp = strchr(mnt_type, ',');
if ( tmp ) {
*tmp = '\0';
}
}
tmp = strstr(mntent->mnt_opts, "dev=");
if ( tmp ) {
strcpy(mntdev, tmp+strlen("dev="));
tmp = strchr(mntdev, ',');
if ( tmp ) {
*tmp = '\0';
}
}
}
if( strncmp(mntdev, "/dev", 4) ||
realpath(mntdev, mntdevpath) == NULL ) {
continue;
}
if ( strcmp(mnt_type, MNTTYPE_CDROM) == 0 ) {
path[num_cdroms ++] = strdup(mntent->mnt_dir);
} else if ( strcmp(mnt_type, "auto") == 0 &&
strncmp(mntdev, DEVICE_FLOPPY, strlen(DEVICE_FLOPPY))) {
path[num_cdroms ++] = strdup(mntent->mnt_dir);
}
#ifdef sgi
else if ( strcmp(mnt_type, "cdfs") == 0 ||
strcmp(mnt_type, "efs") == 0 ) {
path[num_cdroms ++] = strdup(mntent->mnt_dir);
}
#endif
}
endmntent( mountfp );
}
//#endif
#endif
return num_cdroms;
}
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);
}
int
main(int argc, char *argv[])
{
struct fstab *fs;
struct passwd *pw;
struct group *gr;
struct quotafile *qfu, *qfg;
int i, argnum, maxrun, errs, ch;
long done = 0;
char *name;
errs = maxrun = 0;
while ((ch = getopt(argc, argv, "ac:guvl:")) != -1) {
switch(ch) {
case 'a':
aflag++;
break;
case 'c':
if (cflag)
usage();
cflag = atoi(optarg);
break;
case 'g':
gflag++;
break;
case 'u':
uflag++;
break;
case 'v':
vflag++;
break;
case 'l':
maxrun = atoi(optarg);
break;
default:
usage();
}
}
argc -= optind;
argv += optind;
if ((argc == 0 && !aflag) || (argc > 0 && aflag))
usage();
if (cflag && cflag != 32 && cflag != 64)
usage();
if (!gflag && !uflag) {
gflag++;
uflag++;
}
if (gflag) {
setgrent();
while ((gr = getgrent()) != NULL)
(void) addid((u_long)gr->gr_gid, GRPQUOTA, gr->gr_name,
NULL);
endgrent();
}
if (uflag) {
setpwent();
while ((pw = getpwent()) != NULL)
(void) addid((u_long)pw->pw_uid, USRQUOTA, pw->pw_name,
NULL);
endpwent();
}
/*
* The maxrun (-l) option is now deprecated.
*/
if (maxrun > 0)
warnx("the -l option is now deprecated");
if (aflag)
exit(checkfstab(uflag, gflag));
if (setfsent() == 0)
errx(1, "%s: can't open", FSTAB);
while ((fs = getfsent()) != NULL) {
if (((argnum = oneof(fs->fs_file, argv, argc)) >= 0 ||
(argnum = oneof(fs->fs_spec, argv, argc)) >= 0) &&
(name = blockcheck(fs->fs_spec))) {
done |= 1 << argnum;
qfu = NULL;
if (uflag)
qfu = quota_open(fs, USRQUOTA, O_CREAT|O_RDWR);
qfg = NULL;
if (gflag)
qfg = quota_open(fs, GRPQUOTA, O_CREAT|O_RDWR);
if (qfu == NULL && qfg == NULL)
continue;
errs += chkquota(name, qfu, qfg);
if (qfu)
quota_close(qfu);
if (qfg)
quota_close(qfg);
}
}
endfsent();
for (i = 0; i < argc; i++)
if ((done & (1 << i)) == 0)
fprintf(stderr, "%s not found in %s\n",
argv[i], FSTAB);
exit(errs);
}
int
mntlistmain()
{
/* NCurses Stuff */
app_init(); /* INIT Ncurses Stuff not needed when becomes part of SMIT*/
const char **vfslist, *vfstype;
struct fstab *fs;
struct statfs *mntbuf;
int all, i, init_flags, late, failok, mntsize, rval, ro;
int onlylate;
char *options;
all = init_flags = late = onlylate = 0;
ro = 0;
options = NULL;
vfslist = NULL;
vfstype = "ufs";
// Leave there
#define BADTYPE(type) \
(strcmp(type, FSTAB_RO) && \
strcmp(type, FSTAB_RW) && strcmp(type, FSTAB_RQ))
rval = 0;
/* Might be what I want */
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;
}
} else if (fstab_style) {
for (i = 0; i < mntsize; i++) {
if (checkvfsname(mntbuf[i].f_fstypename, vfslist))
continue;
}
} else {
for (i = 0; i < mntsize; i++) {
if (checkvfsname(mntbuf[i].f_fstypename,
vfslist))
continue;
prmount(&mntbuf[i]);
wmove(FS_LIST, ctr++, 2);
}
}
wgetch(FS_LIST);
ctr = 1; // Reset the Counter
return (rval);
}
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);
}
JBoolean
JGetUserMountPointList
(
JMountPointList* list,
JMountState* state
)
{
time_t t;
if (state != NULL &&
(!(JGetModificationTime(_PATH_FSTAB, &t)).OK() ||
t == state->modTime))
{
return kJFalse;
}
list->CleanOut();
if (state != NULL)
{
state->modTime = t;
}
endfsent();
const JBoolean isRoot = JI2B( getuid() == 0 );
if (isRoot)
{
ACE_stat stbuf;
while (const fstab* info = getfsent())
{
if (JIsRootDirectory(info->fs_file) ||
strcmp(info->fs_type, FSTAB_SW) == 0) // swap partition
{
continue;
}
const JMountType type =
JGetUserMountPointType(info->fs_file, info->fs_spec, info->fs_vfstype);
if (type == kJUnknownMountType ||
ACE_OS::stat(info->fs_file, &stbuf) != 0)
{
continue;
}
JFileSystemType fsType = kOtherFSType;
if (options.Contains("vfat"))
{
fsType = kVFATType;
}
JFileSystemType fsType = kOtherFSType;
if (JStringCompare(info->fs_vfstype, "vfat", kJFalse) == 0)
{
fsType = kVFATType;
}
JString* path = jnew JString(info->fs_file);
assert( path != NULL );
JString* devicePath = jnew JString(info->fs_spec);
assert( devicePath != NULL );
list->AppendElement(JMountPoint(path, type, stbuf.st_dev, devicePath, fsType));
}
}
endfsent();
return kJTrue;
}
int
main(int argc, char **argv)
{
struct fstab *fsp;
char *ptr;
int ret;
int ch, doall;
int sflag = 0, lflag = 0, hflag = 0, qflag = 0;
const char *etc_fstab;
if ((ptr = strrchr(argv[0], '/')) == NULL)
ptr = argv[0];
if (strstr(ptr, "swapon"))
which_prog = SWAPON;
else if (strstr(ptr, "swapoff"))
which_prog = SWAPOFF;
orig_prog = which_prog;
doall = 0;
etc_fstab = NULL;
while ((ch = getopt(argc, argv, "AadghklmqsUF:")) != -1) {
switch(ch) {
case 'A':
if (which_prog == SWAPCTL) {
doall = 1;
which_prog = SWAPON;
} else {
usage();
}
break;
case 'a':
if (which_prog == SWAPON || which_prog == SWAPOFF)
doall = 1;
else
which_prog = SWAPON;
break;
case 'd':
if (which_prog == SWAPCTL)
which_prog = SWAPOFF;
else
usage();
break;
case 'g':
hflag = 'G';
break;
case 'h':
hflag = 'H';
break;
case 'k':
hflag = 'K';
break;
case 'l':
lflag = 1;
break;
case 'm':
hflag = 'M';
break;
case 'q':
if (which_prog == SWAPON || which_prog == SWAPOFF)
qflag = 1;
break;
case 's':
sflag = 1;
break;
case 'U':
if (which_prog == SWAPCTL) {
doall = 1;
which_prog = SWAPOFF;
} else {
usage();
}
break;
case 'F':
etc_fstab = optarg;
break;
case '?':
default:
usage();
}
}
argv += optind;
ret = 0;
if (etc_fstab != NULL)
setfstab(etc_fstab);
if (which_prog == SWAPON || which_prog == SWAPOFF) {
if (doall) {
while ((fsp = getfsent()) != NULL) {
if (strcmp(fsp->fs_type, FSTAB_SW))
continue;
if (strstr(fsp->fs_mntops, "noauto"))
continue;
if (swap_on_off(fsp->fs_spec, 1)) {
ret = 1;
} else {
if (!qflag) {
printf("%s: %sing %s as swap device\n",
getprogname(),
which_prog == SWAPOFF ? "remov" : "add",
fsp->fs_spec);
}
}
}
}
else if (!*argv)
usage();
for (; *argv; ++argv) {
if (swap_on_off(*argv, 0)) {
ret = 1;
} else if (orig_prog == SWAPCTL) {
printf("%s: %sing %s as swap device\n",
getprogname(), which_prog == SWAPOFF ? "remov" : "add",
*argv);
}
}
} else {
if (lflag || sflag)
swaplist(lflag, sflag, hflag);
else
usage();
}
exit(ret);
}
int
main(int argc, char **argv)
{
const char *savedir = ".";
struct fstab *fsp;
int i, ch, error;
checkfor = compress = clear = force = keep = verbose = 0;
nfound = nsaved = nerr = 0;
openlog("savecore", LOG_PERROR, LOG_DAEMON);
while ((ch = getopt(argc, argv, "Ccfkvz")) != -1)
switch(ch) {
case 'C':
checkfor = 1;
break;
case 'c':
clear = 1;
break;
case 'k':
keep = 1;
break;
case 'v':
verbose++;
break;
case 'f':
force = 1;
break;
case 'z':
compress = 1;
break;
case '?':
default:
usage();
}
if (checkfor && (clear || force || keep))
usage();
argc -= optind;
argv += optind;
if (argc >= 1) {
error = chdir(argv[0]);
if (error) {
syslog(LOG_ERR, "chdir(%s): %m", argv[0]);
exit(1);
}
savedir = argv[0];
argc--;
argv++;
}
if (argc == 0) {
for (;;) {
fsp = getfsent();
if (fsp == NULL)
break;
if (strcmp(fsp->fs_vfstype, "swap") &&
strcmp(fsp->fs_vfstype, "dump"))
continue;
DoFile(savedir, fsp->fs_spec);
}
} else {
for (i = 0; i < argc; i++)
DoFile(savedir, argv[i]);
}
/* Emit minimal output. */
if (nfound == 0) {
if (checkfor) {
printf("No dump exists\n");
exit(1);
}
syslog(LOG_WARNING, "no dumps found");
}
else if (nsaved == 0) {
if (nerr != 0)
syslog(LOG_WARNING, "unsaved dumps found but not saved");
else
syslog(LOG_WARNING, "no unsaved dumps found");
}
return (0);
}
/*
* Collect the requested quota information.
*/
struct quotause *
getprivs(long id, int quotatype, char *fspath)
{
struct fstab *fs;
struct quotause *qup, *quptail;
struct quotause *quphead;
int qcmd, qupsize, fd;
char *qfpathname;
static int warned = 0;
setfsent();
quphead = quptail = NULL;
qcmd = QCMD(Q_GETQUOTA, quotatype);
while ((fs = getfsent())) {
if (fspath && *fspath && strcmp(fspath, fs->fs_spec) &&
strcmp(fspath, fs->fs_file))
continue;
if (strcmp(fs->fs_vfstype, "ufs"))
continue;
if (!hasquota(fs, quotatype, &qfpathname))
continue;
qupsize = sizeof(*qup) + strlen(qfpathname);
if ((qup = (struct quotause *)malloc(qupsize)) == NULL)
errx(2, "out of memory");
if (quotactl(fs->fs_file, qcmd, id, &qup->dqblk) != 0) {
if (errno == EOPNOTSUPP && !warned) {
warned++;
warnx("warning: quotas are not compiled into this kernel");
sleep(3);
}
if ((fd = open(qfpathname, O_RDONLY)) < 0) {
fd = open(qfpathname, O_RDWR|O_CREAT, 0640);
if (fd < 0 && errno != ENOENT) {
warn("%s", qfpathname);
free(qup);
continue;
}
warnx("creating quota file %s", qfpathname);
sleep(3);
fchown(fd, getuid(),
getentry(quotagroup, GRPQUOTA));
fchmod(fd, 0640);
}
lseek(fd, (long)(id * sizeof(struct ufs_dqblk)), L_SET);
switch (read(fd, &qup->dqblk, sizeof(struct ufs_dqblk))) {
case 0: /* EOF */
/*
* Convert implicit 0 quota (EOF)
* into an explicit one (zero'ed dqblk)
*/
bzero((caddr_t)&qup->dqblk,
sizeof(struct ufs_dqblk));
break;
case sizeof(struct ufs_dqblk): /* OK */
break;
default: /* ERROR */
warn("read error in %s", qfpathname);
close(fd);
free(qup);
continue;
}
close(fd);
}
strcpy(qup->qfname, qfpathname);
strcpy(qup->fsname, fs->fs_file);
if (quphead == NULL)
quphead = qup;
else
quptail->next = qup;
quptail = qup;
qup->next = NULL;
}
endfsent();
return (quphead);
}
int
main(int argc, char **argv)
{
struct fstab *fs;
struct passwd *pw;
struct group *gr;
int gflag = 0, uflag = 0, errs = 0;
long i, argnum, done = 0;
char ch, *qfnp;
while ((ch = getopt(argc, argv, "aguv")) != -1) {
switch(ch) {
case 'a':
aflag++;
break;
case 'g':
gflag++;
break;
case 'u':
uflag++;
break;
case 'v':
vflag++;
break;
default:
usage();
}
}
argc -= optind;
argv += optind;
if (argc == 0 && !aflag)
usage();
if (!gflag && !uflag) {
if (aflag)
gflag++;
uflag++;
}
if (gflag) {
setgrent();
while ((gr = getgrent()) != 0)
addid((u_long)gr->gr_gid, GRPQUOTA, gr->gr_name);
endgrent();
}
if (uflag) {
setpwent();
while ((pw = getpwent()) != 0)
addid((u_long)pw->pw_uid, USRQUOTA, pw->pw_name);
endpwent();
}
setfsent();
while ((fs = getfsent()) != NULL) {
if (strcmp(fs->fs_vfstype, "ufs"))
continue;
if (aflag) {
if (gflag && hasquota(fs, GRPQUOTA, &qfnp))
errs += repquota(fs, GRPQUOTA, qfnp);
if (uflag && hasquota(fs, USRQUOTA, &qfnp))
errs += repquota(fs, USRQUOTA, qfnp);
continue;
}
if ((argnum = oneof(fs->fs_file, argv, argc)) >= 0 ||
(argnum = oneof(fs->fs_spec, argv, argc)) >= 0) {
done |= 1 << argnum;
if (gflag && hasquota(fs, GRPQUOTA, &qfnp))
errs += repquota(fs, GRPQUOTA, qfnp);
if (uflag && hasquota(fs, USRQUOTA, &qfnp))
errs += repquota(fs, USRQUOTA, qfnp);
}
}
endfsent();
for (i = 0; i < argc; i++)
if ((done & (1 << i)) == 0)
warnx("%s not found in fstab", argv[i]);
exit(errs);
}