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;
}
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();
}
void
parselabel(void)
{
char *partname, *partduid;
struct fstab *fsent;
int i;
i = asprintf(&partname, "/dev/%s%c", dkname, 'a');
if (i == -1)
err(4, NULL);
i = asprintf(&partduid,
"%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx.a",
lab.d_uid[0], lab.d_uid[1], lab.d_uid[2], lab.d_uid[3],
lab.d_uid[4], lab.d_uid[5], lab.d_uid[6], lab.d_uid[7]);
if (i == -1)
err(4, NULL);
setfsent();
for (i = 0; i < MAXPARTITIONS; i++) {
partname[strlen(dkname) + 5] = 'a' + i;
partduid[strlen(partduid) - 1] = 'a' + i;
fsent = getfsspec(partname);
if (fsent == NULL)
fsent = getfsspec(partduid);
if (fsent)
mountpoints[i] = strdup(fsent->fs_file);
}
endfsent();
free(partduid);
free(partname);
if (aflag)
editor_allocspace(&lab);
}
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;
}
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 lsetfsent(void)
{long iflag;
LISP result;
iflag = no_interrupt(1);
result = flocons(setfsent());
no_interrupt(iflag);
return(result);}
struct fstab *
getfsent()
{
if ((!_fs_fp && !setfsent()) || !fstabscan())
return((struct fstab *)NULL);
return(&_fs_fstab);
}
struct fstab *
getfsfile(const char *name)
{
if (setfsent())
while (fstabscan())
if (!strcmp(_fs_fstab.fs_file, name))
return(&_fs_fstab);
return(NULL);
}
/*
* Collect the requested quota information.
*/
static struct quotause *
getprivs(long id, int quotatype)
{
struct quotause *qup, *quptail = NULL;
struct fstab *fs;
struct quotause *quphead;
struct statfs *fst;
int nfst, i;
qup = quphead = NULL;
nfst = getmntinfo(&fst, MNT_NOWAIT);
if (nfst == 0)
errx(2, "no filesystems mounted!");
setfsent();
for (i=0; i<nfst; i++) {
if (qup == NULL) {
if ((qup = (struct quotause *)malloc(sizeof *qup))
== NULL)
errx(2, "out of memory");
}
if (strcmp(fst[i].f_fstypename, "nfs") == 0) {
if (lflag)
continue;
if (getnfsquota(&fst[i], qup, id, quotatype)
== 0)
continue;
} else if (strcmp(fst[i].f_fstypename, "ufs") == 0) {
/*
* XXX
* UFS filesystems must be in /etc/fstab, and must
* indicate that they have quotas on (?!) This is quite
* unlike SunOS where quotas can be enabled/disabled
* on a filesystem independent of /etc/fstab, and it
* will still print quotas for them.
*/
if ((fs = getfsspec(fst[i].f_mntfromname)) == NULL)
continue;
if (getufsquota(fs, qup, id, quotatype) == 0)
continue;
} else
continue;
strcpy(qup->fsname, fst[i].f_mntonname);
if (quphead == NULL)
quphead = qup;
else
quptail->next = qup;
quptail = qup;
quptail->next = 0;
qup = NULL;
}
if (qup)
free(qup);
endfsent();
return (quphead);
}
struct fstab *
getfsent()
{
if (!returnedRoot) {
setfsent();
}
if (!fstabscan()) {
return((struct fstab *)NULL);
}
return(&_fs_fstab);
}
/*!
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
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;
}
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( );
}
}
}
static struct fstab *
lu_getfsfile(const char *name)
{
struct fstab *fs;
if (name == NULL) return (struct fstab *)NULL;
setfsent();
for (fs = lu_getfsent(); fs != NULL; fs = lu_getfsent())
if (!strcmp(fs->fs_file, name)) return fs;
endfsent();
return (struct fstab *)NULL;
}
/* 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;
}
/* 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;
}
static struct vfstab*
getfsfile (const char *mount_point)
{
int r;
int close = 0;
if (etc_fstab == 0) {
close = 1;
if (setfsent () != 1)
return NULL;
}
rewind (etc_fstab);
r = getvfsfile (etc_fstab, &cur_vfstab_entry, (char*) mount_point);
if (close)
endfsent ();
if (r == 0)
return &cur_vfstab_entry;
return NULL;
}
static struct vfstab*
getfsspec (const char *special_file)
{
int r;
int close = 0;
if (etc_fstab == 0) {
close = 1;
if (setfsent () != 1)
return NULL;
}
rewind (etc_fstab);
r = getvfsspec (etc_fstab, &cur_vfstab_entry, (char*) special_file);
if (close)
endfsent ();
if (r == 0)
return &cur_vfstab_entry;
return NULL;
}
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;
}
/*
* 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);
}
struct fstab *
getfsent(void)
{
if (((!mntbuf) && !setfsent()) || mntcnt == 0)
return (NULL);
fstabent.fs_file = mntent->f_mntonname;
fstabent.fs_freq = fstabent.fs_passno = 0;
fstabent.fs_mntops = mntent->f_fstypename;
fstabent.fs_spec = mntent->f_mntfromname;
if (mntent->f_flags & MNT_RDONLY)
fstabent.fs_type = FSTAB_RO;
else
fstabent.fs_type = FSTAB_RW;
fstabent.fs_vfstype = mntent->f_fstypename;
mntent++;
mntcnt--;
return &fstabent;
}
/*
* 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;
}
/*
* Fetch requested disklabel into 'lab' using ioctl.
*/
void
readlabel(int f)
{
char *partname, *partduid;
struct fstab *fsent;
int i;
if (cflag && ioctl(f, DIOCRLDINFO) < 0)
err(4, "ioctl DIOCRLDINFO");
if ((op == RESTORE) || dflag || aflag) {
if (ioctl(f, DIOCGPDINFO, &lab) < 0)
err(4, "ioctl DIOCGPDINFO");
} else {
if (ioctl(f, DIOCGDINFO, &lab) < 0)
err(4, "ioctl DIOCGDINFO");
}
asprintf(&partname, "/dev/%s%c", dkname, 'a');
asprintf(&partduid,
"%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx.a",
lab.d_uid[0], lab.d_uid[1], lab.d_uid[2], lab.d_uid[3],
lab.d_uid[4], lab.d_uid[5], lab.d_uid[6], lab.d_uid[7]);
setfsent();
for (i = 0; i < MAXPARTITIONS; i++) {
partname[strlen(dkname) + 5] = 'a' + i;
partduid[strlen(partduid) - 1] = 'a' + i;
fsent = getfsspec(partname);
if (fsent == NULL)
fsent = getfsspec(partduid);
if (fsent)
mountpoints[i] = strdup(fsent->fs_file);
}
endfsent();
free(partduid);
free(partname);
if (aflag)
editor_allocspace(&lab);
}
/* Return next entry in fstab, skipping ignore entries. I also put
in some ugly hacks here to skip comments and blank lines. */
struct mntent *
getfsent (void)
{
struct mntent *fstab;
if (!F_fstab && !setfsent())
return 0;
for (;;)
{
fstab = getmntent (F_fstab);
if (fstab == NULL)
{
if (!feof (F_fstab) && !ferror (F_fstab))
continue;
else
break;
}
else if ((*fstab->mnt_fsname != '#')
&& !streq (fstab->mnt_type, MNTTYPE_IGNORE))
break;
}
return fstab;
}
int
main(int argc, char *argv[])
{
int all, errs, ch, mntsize, error, nfsforce, ret;
char **typelist = NULL;
struct statfs *mntbuf, *sfs;
struct addrinfo hints;
nfsforce = all = errs = 0;
while ((ch = getopt(argc, argv, "AaF:fh:Nnt:v")) != -1)
switch (ch) {
case 'A':
all = 2;
break;
case 'a':
all = 1;
break;
case 'F':
setfstab(optarg);
break;
case 'f':
fflag |= MNT_FORCE;
break;
case 'h': /* -h implies -A. */
all = 2;
nfshost = optarg;
break;
case 'N':
nfsforce = 1;
break;
case 'n':
fflag |= MNT_NONBUSY;
break;
case 't':
if (typelist != NULL)
err(1, "only one -t option may be specified");
typelist = makevfslist(optarg);
break;
case 'v':
vflag = 1;
break;
default:
usage();
/* NOTREACHED */
}
argc -= optind;
argv += optind;
if ((fflag & MNT_FORCE) != 0 && (fflag & MNT_NONBUSY) != 0)
err(1, "-f and -n are mutually exclusive");
/* Start disks transferring immediately. */
if ((fflag & (MNT_FORCE | MNT_NONBUSY)) == 0 && nfsforce == 0)
sync();
if ((argc == 0 && !all) || (argc != 0 && all))
usage();
if (nfsforce != 0 && (argc == 0 || nfshost != NULL || typelist != NULL))
usage();
/* -h implies "-t nfs" if no -t flag. */
if ((nfshost != NULL) && (typelist == NULL))
typelist = makevfslist("nfs");
if (nfshost != NULL) {
memset(&hints, 0, sizeof hints);
error = getaddrinfo(nfshost, NULL, &hints, &nfshost_ai);
if (error)
errx(1, "%s: %s", nfshost, gai_strerror(error));
}
switch (all) {
case 2:
if ((mntsize = mntinfo(&mntbuf)) <= 0)
break;
/*
* We unmount the nfs-mounts in the reverse order
* that they were mounted.
*/
for (errs = 0, mntsize--; mntsize > 0; mntsize--) {
sfs = &mntbuf[mntsize];
if (checkvfsname(sfs->f_fstypename, typelist))
continue;
if (strcmp(sfs->f_mntonname, "/dev") == 0)
continue;
if (umountfs(sfs) != 0)
errs = 1;
}
free(mntbuf);
break;
case 1:
if (setfsent() == 0)
err(1, "%s", getfstab());
errs = umountall(typelist);
break;
case 0:
for (errs = 0; *argv != NULL; ++argv)
if (nfsforce != 0) {
/*
* First do the nfssvc() syscall to shut down
* the mount point and then do the forced
* dismount.
*/
ret = nfssvc(NFSSVC_FORCEDISM, *argv);
if (ret >= 0)
ret = unmount(*argv, MNT_FORCE);
if (ret < 0) {
warn("%s", *argv);
errs = 1;
}
} else if (checkname(*argv, typelist) != 0)
errs = 1;
break;
}
exit(errs);
}
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);
}
/*
* 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;
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
main(int argc, char *argv[])
{
int all, errs, ch, mntsize, error;
char **typelist = NULL;
struct statfs *mntbuf, *sfs;
struct addrinfo hints;
all = errs = 0;
while ((ch = getopt(argc, argv, "AaF:fh:t:v")) != -1)
switch (ch) {
case 'A':
all = 2;
break;
case 'a':
all = 1;
break;
case 'F':
setfstab(optarg);
break;
case 'f':
fflag = MNT_FORCE;
break;
case 'h': /* -h implies -A. */
all = 2;
nfshost = optarg;
break;
case 't':
if (typelist != NULL)
err(1, "only one -t option may be specified");
typelist = makevfslist(optarg);
break;
case 'v':
vflag = 1;
break;
default:
usage();
/* NOTREACHED */
}
argc -= optind;
argv += optind;
/* Start disks transferring immediately. */
if ((fflag & MNT_FORCE) == 0)
sync();
if ((argc == 0 && !all) || (argc != 0 && all))
usage();
/* -h implies "-t nfs" if no -t flag. */
if ((nfshost != NULL) && (typelist == NULL))
typelist = makevfslist("nfs");
if (nfshost != NULL) {
memset(&hints, 0, sizeof hints);
error = getaddrinfo(nfshost, NULL, &hints, &nfshost_ai);
if (error)
errx(1, "%s: %s", nfshost, gai_strerror(error));
}
switch (all) {
case 2:
if ((mntsize = mntinfo(&mntbuf)) <= 0)
break;
/*
* We unmount the nfs-mounts in the reverse order
* that they were mounted.
*/
for (errs = 0, mntsize--; mntsize > 0; mntsize--) {
sfs = &mntbuf[mntsize];
if (checkvfsname(sfs->f_fstypename, typelist))
continue;
if (strcmp(sfs->f_mntonname, "/dev") == 0)
continue;
if (umountfs(sfs) != 0)
errs = 1;
}
free(mntbuf);
break;
case 1:
if (setfsent() == 0)
err(1, "%s", getfstab());
errs = umountall(typelist);
break;
case 0:
for (errs = 0; *argv != NULL; ++argv)
if (checkname(*argv, typelist) != 0)
errs = 1;
break;
}
exit(errs);
}
