X-Git-Url: http://erislabs.net/gitweb/?a=blobdiff_plain;f=lib%2Fmountlist.c;h=55071c3fc80fe44003a6c2cf7a61f0cf6ce38d73;hb=fdbc2d4ba69ef24b623b87cb6fd2114215e7b52b;hp=58ac26df4e5d1d1be79dd7f0d55574ede1bea0cb;hpb=32a530aab639cb193993637703af36e2fcb96d4c;p=gnulib.git diff --git a/lib/mountlist.c b/lib/mountlist.c index 58ac26df4..55071c3fc 100644 --- a/lib/mountlist.c +++ b/lib/mountlist.c @@ -1,5 +1,5 @@ -/* mountlist.c -- return a list of mounted filesystems - Copyright (C) 1991, 1992, 1997, 1998 Free Software Foundation, Inc. +/* mountlist.c -- return a list of mounted file systems + Copyright (C) 1991, 1992, 1997-2004 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -21,31 +21,16 @@ #include #include -#include "mountlist.h" +#include +#include -#ifdef STDC_HEADERS -# include -#else -void free (); -#endif -#if defined(STDC_HEADERS) || defined(HAVE_STRING_H) -# include -#else -# include -#endif +#include "xalloc.h" #ifndef strstr char *strstr (); #endif -char *xmalloc (); -char *xrealloc (); -char *xstrdup (); -void error (); #include -#ifndef errno -extern int errno; -#endif #ifdef HAVE_FCNTL_H # include @@ -59,18 +44,35 @@ extern int errno; # include #endif -#if defined (MOUNTED_GETFSSTAT) /* __alpha running OSF_1 */ -# include -# include +#if defined MOUNTED_GETFSSTAT /* OSF_1 and Darwin1.3.x */ +# if HAVE_SYS_UCRED_H +# include /* needed on OSF V4.0 for definition of NGROUPS, + NGROUPS is used as an array dimension in ucred.h */ +# include /* needed by powerpc-apple-darwin1.3.7 */ +# endif +# if HAVE_SYS_MOUNT_H +# include +# endif +# if HAVE_SYS_FS_TYPES_H +# include /* needed by powerpc-apple-darwin1.3.7 */ +# endif +# if HAVE_STRUCT_FSSTAT_F_FSTYPENAME +# define FS_TYPE(Ent) ((Ent).f_fstypename) +# else +# define FS_TYPE(Ent) mnt_names[(Ent).f_type] +# endif #endif /* MOUNTED_GETFSSTAT */ #ifdef MOUNTED_GETMNTENT1 /* 4.3BSD, SunOS, HP-UX, Dynix, Irix. */ # include -# if !defined(MOUNTED) -# if defined(MNT_MNTTAB) /* HP-UX. */ +# if !defined MOUNTED +# if defined _PATH_MOUNTED /* GNU libc */ +# define MOUNTED _PATH_MOUNTED +# endif +# if defined MNT_MNTTAB /* HP-UX. */ # define MOUNTED MNT_MNTTAB # endif -# if defined(MNTTABNAME) /* Dynix. */ +# if defined MNTTABNAME /* Dynix. */ # define MOUNTED MNTTABNAME # endif # endif @@ -85,6 +87,11 @@ extern int errno; # include #endif +#ifdef MOUNTED_FS_STAT_DEV /* BeOS. */ +# include +# include +#endif + #ifdef MOUNTED_FREAD /* SVR2. */ # include #endif @@ -119,45 +126,28 @@ extern int errno; # include #endif -#if defined (MNTOPT_IGNORE) && defined (HAVE_HASMNTOPT) +#undef MNT_IGNORE +#if defined MNTOPT_IGNORE && defined HAVE_HASMNTOPT # define MNT_IGNORE(M) hasmntopt ((M), MNTOPT_IGNORE) #else # define MNT_IGNORE(M) 0 #endif -#ifdef MOUNTED_GETMNTENT1 /* 4.3BSD, SunOS, HP-UX, Dynix, Irix. */ -/* Return the value of the hexadecimal number represented by CP. - No prefix (like '0x') or suffix (like 'h') is expected to be - part of CP. */ +#include "mountlist.h" -static int -xatoi (cp) - char *cp; -{ - int val; +#if USE_UNLOCKED_IO +# include "unlocked-io.h" +#endif - val = 0; - while (*cp) - { - if (*cp >= 'a' && *cp <= 'f') - val = val * 16 + *cp - 'a' + 10; - else if (*cp >= 'A' && *cp <= 'F') - val = val * 16 + *cp - 'A' + 10; - else if (*cp >= '0' && *cp <= '9') - val = val * 16 + *cp - '0'; - else - break; - cp++; - } - return val; -} -#endif /* MOUNTED_GETMNTENT1. */ +#ifndef SIZE_MAX +# define SIZE_MAX ((size_t) -1) +#endif #if MOUNTED_GETMNTINFO # if ! HAVE_F_FSTYPENAME_IN_STATFS static char * -fstype_to_string (short t) +fstype_to_string (short int t) { switch (t) { @@ -256,7 +246,7 @@ static char * fsp_to_string (const struct statfs *fsp) { # if defined HAVE_F_FSTYPENAME_IN_STATFS - return xstrdup (fsp->f_fstypename); + return (char *) (fsp->f_fstypename); # else return fstype_to_string (fsp->f_type); # endif @@ -266,8 +256,7 @@ fsp_to_string (const struct statfs *fsp) #ifdef MOUNTED_VMOUNT /* AIX. */ static char * -fstype_to_string (t) - int t; +fstype_to_string (int t) { struct vfs_ent *e; @@ -279,25 +268,17 @@ fstype_to_string (t) } #endif /* MOUNTED_VMOUNT */ -/* Return a list of the currently mounted filesystems, or NULL on error. +/* Return a list of the currently mounted file systems, or NULL on error. Add each entry to the tail of the list so that they stay in order. - If NEED_FS_TYPE is nonzero, ensure that the filesystem type fields in - the returned list are valid. Otherwise, they might not be. - If ALL_FS is zero, do not return entries for filesystems that - are automounter (dummy) entries. */ + If NEED_FS_TYPE is true, ensure that the file system type fields in + the returned list are valid. Otherwise, they might not be. */ struct mount_entry * -read_filesystem_list (need_fs_type, all_fs) - int need_fs_type, all_fs; +read_file_system_list (bool need_fs_type) { struct mount_entry *mount_list; struct mount_entry *me; - struct mount_entry *mtail; - - /* Start the list off with a dummy entry. */ - me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry)); - me->me_next = NULL; - mount_list = mtail = me; + struct mount_entry **mtail = &mount_list; #ifdef MOUNTED_LISTMNTENT { @@ -310,22 +291,22 @@ read_filesystem_list (need_fs_type, all_fs) remove. Specifically, automount create normal NFS mounts. */ - if(listmntent(&mntlist, KMTAB, NULL, NULL) < 0) + if (listmntent (&mntlist, KMTAB, NULL, NULL) < 0) return NULL; - p = mntlist; - while(p){ + for (p = mntlist; p; p = p->next) { mnt = p->ment; - me = (struct mount_entry*) xmalloc(sizeof (struct mount_entry)); - me->me_devname = xstrdup(mnt->mnt_fsname); - me->me_mountdir = xstrdup(mnt->mnt_dir); - me->me_type = xstrdup(mnt->mnt_type); + me = xmalloc (sizeof *me); + me->me_devname = xstrdup (mnt->mnt_fsname); + me->me_mountdir = xstrdup (mnt->mnt_dir); + me->me_type = xstrdup (mnt->mnt_type); + me->me_type_malloced = 1; + me->me_dummy = ME_DUMMY (me->me_devname, me->me_type); + me->me_remote = ME_REMOTE (me->me_devname, me->me_type); me->me_dev = -1; - me->me_next = NULL; - mtail->me_next = me; - mtail = me; - p = p->next; + *mtail = me; + mtail = &me->me_next; } - freemntlist(mntlist); + freemntlist (mntlist); } #endif @@ -342,33 +323,26 @@ read_filesystem_list (need_fs_type, all_fs) while ((mnt = getmntent (fp))) { - if (!all_fs && (!strcmp (mnt->mnt_type, "ignore") - || !strcmp (mnt->mnt_type, "auto"))) - continue; - - me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry)); + me = xmalloc (sizeof *me); me->me_devname = xstrdup (mnt->mnt_fsname); me->me_mountdir = xstrdup (mnt->mnt_dir); me->me_type = xstrdup (mnt->mnt_type); + me->me_type_malloced = 1; + me->me_dummy = ME_DUMMY (me->me_devname, me->me_type); + me->me_remote = ME_REMOTE (me->me_devname, me->me_type); devopt = strstr (mnt->mnt_opts, "dev="); if (devopt) - { - if (devopt[4] == '0' && (devopt[5] == 'x' || devopt[5] == 'X')) - me->me_dev = xatoi (devopt + 6); - else - me->me_dev = xatoi (devopt + 4); - } + me->me_dev = strtoul (devopt + 4, NULL, 16); else me->me_dev = (dev_t) -1; /* Magic; means not known yet. */ - me->me_next = NULL; /* Add to the linked list. */ - mtail->me_next = me; - mtail = me; + *mtail = me; + mtail = &me->me_next; } if (endmntent (fp) == 0) - return NULL; + goto free_then_fail; } #endif /* MOUNTED_GETMNTENT1. */ @@ -380,19 +354,22 @@ read_filesystem_list (need_fs_type, all_fs) entries = getmntinfo (&fsp, MNT_NOWAIT); if (entries < 0) return NULL; - while (entries-- > 0) + for (; entries-- > 0; fsp++) { - me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry)); + char *fs_type = fsp_to_string (fsp); + + me = xmalloc (sizeof *me); me->me_devname = xstrdup (fsp->f_mntfromname); me->me_mountdir = xstrdup (fsp->f_mntonname); - me->me_type = fsp_to_string (fsp); + me->me_type = fs_type; + me->me_type_malloced = 0; + me->me_dummy = ME_DUMMY (me->me_devname, me->me_type); + me->me_remote = ME_REMOTE (me->me_devname, me->me_type); me->me_dev = (dev_t) -1; /* Magic; means not known yet. */ - me->me_next = NULL; /* Add to the linked list. */ - mtail->me_next = me; - mtail = me; - fsp++; + *mtail = me; + mtail = &me->me_next; } } #endif /* MOUNTED_GETMNTINFO */ @@ -403,37 +380,147 @@ read_filesystem_list (need_fs_type, all_fs) int val; struct fs_data fsd; - while ((val = getmnt (&offset, &fsd, sizeof (fsd), NOSTAT_MANY, - (char *) 0)) > 0) + while (errno = 0, + 0 < (val = getmnt (&offset, &fsd, sizeof (fsd), NOSTAT_MANY, + (char *) 0))) { - me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry)); + me = xmalloc (sizeof *me); me->me_devname = xstrdup (fsd.fd_req.devname); me->me_mountdir = xstrdup (fsd.fd_req.path); me->me_type = gt_names[fsd.fd_req.fstype]; + me->me_type_malloced = 0; + me->me_dummy = ME_DUMMY (me->me_devname, me->me_type); + me->me_remote = ME_REMOTE (me->me_devname, me->me_type); me->me_dev = fsd.fd_req.dev; - me->me_next = NULL; /* Add to the linked list. */ - mtail->me_next = me; - mtail = me; + *mtail = me; + mtail = &me->me_next; } if (val < 0) - return NULL; + goto free_then_fail; } #endif /* MOUNTED_GETMNT. */ -#if defined (MOUNTED_GETFSSTAT) /* __alpha running OSF_1 */ +#if defined MOUNTED_FS_STAT_DEV /* BeOS */ { - int numsys, counter, bufsize; + /* The next_dev() and fs_stat_dev() system calls give the list of + all file systems, including the information returned by statvfs() + (fs type, total blocks, free blocks etc.), but without the mount + point. But on BeOS all file systems except / are mounted in the + rootfs, directly under /. + The directory name of the mount point is often, but not always, + identical to the volume name of the device. + We therefore get the list of subdirectories of /, and the list + of all file systems, and match the two lists. */ + + DIR *dirp; + struct rootdir_entry + { + char *name; + dev_t dev; + ino_t ino; + struct rootdir_entry *next; + }; + struct rootdir_entry *rootdir_list; + struct rootdir_entry **rootdir_tail; + int32 pos; + dev_t dev; + fs_info fi; + + /* All volumes are mounted in the rootfs, directly under /. */ + rootdir_list = NULL; + rootdir_tail = &rootdir_list; + dirp = opendir ("/"); + if (dirp) + { + struct dirent *d; + + while ((d = readdir (dirp)) != NULL) + { + char *name; + struct stat statbuf; + + if (strcmp (d->d_name, "..") == 0) + continue; + + if (strcmp (d->d_name, ".") == 0) + name = xstrdup ("/"); + else + { + name = xmalloc (1 + strlen (d->d_name) + 1); + name[0] = '/'; + strcpy (name + 1, d->d_name); + } + + if (lstat (name, &statbuf) >= 0 && S_ISDIR (statbuf.st_mode)) + { + struct rootdir_entry *re = xmalloc (sizeof *re); + re->name = name; + re->dev = statbuf.st_dev; + re->ino = statbuf.st_ino; + + /* Add to the linked list. */ + *rootdir_tail = re; + rootdir_tail = &re->next; + } + else + free (name); + } + closedir (dirp); + } + *rootdir_tail = NULL; + + for (pos = 0; (dev = next_dev (&pos)) >= 0; ) + if (fs_stat_dev (dev, &fi) >= 0) + { + /* Note: fi.dev == dev. */ + struct rootdir_entry *re; + + for (re = rootdir_list; re; re = re->next) + if (re->dev == fi.dev && re->ino == fi.root) + break; + + me = xmalloc (sizeof *me); + me->me_devname = xstrdup (fi.device_name[0] != '\0' ? fi.device_name : fi.fsh_name); + me->me_mountdir = xstrdup (re != NULL ? re->name : fi.fsh_name); + me->me_type = xstrdup (fi.fsh_name); + me->me_type_malloced = 1; + me->me_dev = fi.dev; + me->me_dummy = 0; + me->me_remote = (fi.flags & B_FS_IS_SHARED) != 0; + + /* Add to the linked list. */ + *mtail = me; + mtail = &me->me_next; + } + *mtail = NULL; + + while (rootdir_list != NULL) + { + struct rootdir_entry *re = rootdir_list; + rootdir_list = re->next; + free (re->name); + free (re); + } + } +#endif /* MOUNTED_FS_STAT_DEV */ + +#if defined MOUNTED_GETFSSTAT /* __alpha running OSF_1 */ + { + int numsys, counter; + size_t bufsize; struct statfs *stats; - numsys = getfsstat ((struct statfs *)0, 0L, MNT_WAIT); + numsys = getfsstat ((struct statfs *)0, 0L, MNT_NOWAIT); if (numsys < 0) return (NULL); + if (SIZE_MAX / sizeof *stats <= numsys) + xalloc_die (); - bufsize = (1 + numsys) * sizeof (struct statfs); - stats = (struct statfs *)xmalloc (bufsize); - numsys = getfsstat (stats, bufsize, MNT_WAIT); + bufsize = (1 + numsys) * sizeof *stats; + stats = xmalloc (bufsize); + numsys = getfsstat (stats, bufsize, MNT_NOWAIT); if (numsys < 0) { @@ -443,23 +530,25 @@ read_filesystem_list (need_fs_type, all_fs) for (counter = 0; counter < numsys; counter++) { - me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry)); + me = xmalloc (sizeof *me); me->me_devname = xstrdup (stats[counter].f_mntfromname); me->me_mountdir = xstrdup (stats[counter].f_mntonname); - me->me_type = mnt_names[stats[counter].f_type]; + me->me_type = xstrdup (FS_TYPE (stats[counter])); + me->me_type_malloced = 1; + me->me_dummy = ME_DUMMY (me->me_devname, me->me_type); + me->me_remote = ME_REMOTE (me->me_devname, me->me_type); me->me_dev = (dev_t) -1; /* Magic; means not known yet. */ - me->me_next = NULL; /* Add to the linked list. */ - mtail->me_next = me; - mtail = me; + *mtail = me; + mtail = &me->me_next; } free (stats); } #endif /* MOUNTED_GETFSSTAT */ -#if defined (MOUNTED_FREAD) || defined (MOUNTED_FREAD_FSTYP) /* SVR[23]. */ +#if defined MOUNTED_FREAD || defined MOUNTED_FREAD_FSTYP /* SVR[23]. */ { struct mnttab mnt; char *table = "/etc/mnttab"; @@ -471,7 +560,7 @@ read_filesystem_list (need_fs_type, all_fs) while (fread (&mnt, sizeof mnt, 1, fp) > 0) { - me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry)); + me = xmalloc (sizeof *me); # ifdef GETFSTYP /* SVR3. */ me->me_devname = xstrdup (mnt.mt_dev); # else @@ -482,6 +571,7 @@ read_filesystem_list (need_fs_type, all_fs) me->me_mountdir = xstrdup (mnt.mt_filsys); me->me_dev = (dev_t) -1; /* Magic; means not known yet. */ me->me_type = ""; + me->me_type_malloced = 0; # ifdef GETFSTYP /* SVR3. */ if (need_fs_type) { @@ -490,38 +580,53 @@ read_filesystem_list (need_fs_type, all_fs) if (statfs (me->me_mountdir, &fsd, sizeof fsd, 0) != -1 && sysfs (GETFSTYP, fsd.f_fstyp, typebuf) != -1) - me->me_type = xstrdup (typebuf); + { + me->me_type = xstrdup (typebuf); + me->me_type_malloced = 1; + } } # endif - me->me_next = NULL; + me->me_dummy = ME_DUMMY (me->me_devname, me->me_type); + me->me_remote = ME_REMOTE (me->me_devname, me->me_type); /* Add to the linked list. */ - mtail->me_next = me; - mtail = me; + *mtail = me; + mtail = &me->me_next; + } + + if (ferror (fp)) + { + /* The last fread() call must have failed. */ + int saved_errno = errno; + fclose (fp); + errno = saved_errno; + goto free_then_fail; } if (fclose (fp) == EOF) - return NULL; + goto free_then_fail; } #endif /* MOUNTED_FREAD || MOUNTED_FREAD_FSTYP. */ #ifdef MOUNTED_GETMNTTBL /* DolphinOS goes it's own way */ { - struct mntent **mnttbl=getmnttbl(),**ent; + struct mntent **mnttbl = getmnttbl (), **ent; for (ent=mnttbl;*ent;ent++) { - me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry)); + me = xmalloc (sizeof *me); me->me_devname = xstrdup ( (*ent)->mt_resource); - me->me_mountdir = xstrdup( (*ent)->mt_directory); - me->me_type = xstrdup ((*ent)->mt_fstype); + me->me_mountdir = xstrdup ( (*ent)->mt_directory); + me->me_type = xstrdup ((*ent)->mt_fstype); + me->me_type_malloced = 1; + me->me_dummy = ME_DUMMY (me->me_devname, me->me_type); + me->me_remote = ME_REMOTE (me->me_devname, me->me_type); me->me_dev = (dev_t) -1; /* Magic; means not known yet. */ - me->me_next = NULL; /* Add to the linked list. */ - mtail->me_next = me; - mtail = me; + *mtail = me; + mtail = &me->me_next; } - endmnttbl(); + endmnttbl (); } #endif @@ -551,42 +656,50 @@ read_filesystem_list (need_fs_type, all_fs) flock.l_len = 0; while (fcntl (lockfd, F_SETLKW, &flock) == -1) if (errno != EINTR) - return NULL; + { + int saved_errno = errno; + close (lockfd); + errno = saved_errno; + return NULL; + } } + else if (errno != ENOENT) + return NULL; # endif + errno = 0; fp = fopen (table, "r"); if (fp == NULL) - ret = 1; + ret = errno; else { while ((ret = getmntent (fp, &mnt)) == 0) { - /* Don't show automounted filesystems twice on e.g., Solaris. */ - if (!all_fs && MNT_IGNORE (&mnt)) - continue; - - me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry)); + me = xmalloc (sizeof *me); me->me_devname = xstrdup (mnt.mnt_special); me->me_mountdir = xstrdup (mnt.mnt_mountp); me->me_type = xstrdup (mnt.mnt_fstype); + me->me_type_malloced = 1; + me->me_dummy = MNT_IGNORE (&mnt) != 0; + me->me_remote = ME_REMOTE (me->me_devname, me->me_type); me->me_dev = (dev_t) -1; /* Magic; means not known yet. */ - me->me_next = NULL; /* Add to the linked list. */ - mtail->me_next = me; - mtail = me; + *mtail = me; + mtail = &me->me_next; } - if (fclose (fp) == EOF) - ret = 1; + ret = fclose (fp) == EOF ? errno : 0 < ret ? 0 : -1; } if (0 <= lockfd && close (lockfd) != 0) - return NULL; + ret = errno; - if (ret > 0) - return NULL; + if (0 <= ret) + { + errno = ret; + goto free_then_fail; + } } #endif /* MOUNTED_GETMNTENT2. */ @@ -595,23 +708,37 @@ read_filesystem_list (need_fs_type, all_fs) int bufsize; char *entries, *thisent; struct vmount *vmp; + int n_entries; + int i; - /* Ask how many bytes to allocate for the mounted filesystem info. */ - mntctl (MCTL_QUERY, sizeof bufsize, (struct vmount *) &bufsize); + /* Ask how many bytes to allocate for the mounted file system info. */ + if (mntctl (MCTL_QUERY, sizeof bufsize, (struct vmount *) &bufsize) != 0) + return NULL; entries = xmalloc (bufsize); - /* Get the list of mounted filesystems. */ - mntctl (MCTL_QUERY, bufsize, (struct vmount *) entries); + /* Get the list of mounted file systems. */ + n_entries = mntctl (MCTL_QUERY, bufsize, (struct vmount *) entries); + if (n_entries < 0) + { + int saved_errno = errno; + free (entries); + errno = saved_errno; + return NULL; + } - for (thisent = entries; thisent < entries + bufsize; - thisent += vmp->vmt_length) + for (i = 0, thisent = entries; + i < n_entries; + i++, thisent += vmp->vmt_length) { + char *options, *ignore; + vmp = (struct vmount *) thisent; - me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry)); + me = xmalloc (sizeof *me); if (vmp->vmt_flags & MNT_REMOTE) { char *host, *path; + me->me_remote = 1; /* Prepend the remote pathname. */ host = thisent + vmp->vmt_data[VMT_HOSTNAME].vmt_off; path = thisent + vmp->vmt_data[VMT_OBJECT].vmt_off; @@ -622,25 +749,50 @@ read_filesystem_list (need_fs_type, all_fs) } else { + me->me_remote = 0; me->me_devname = xstrdup (thisent + vmp->vmt_data[VMT_OBJECT].vmt_off); } me->me_mountdir = xstrdup (thisent + vmp->vmt_data[VMT_STUB].vmt_off); me->me_type = xstrdup (fstype_to_string (vmp->vmt_gfstype)); + me->me_type_malloced = 1; + options = thisent + vmp->vmt_data[VMT_ARGS].vmt_off; + ignore = strstr (options, "ignore"); + me->me_dummy = (ignore + && (ignore == options || ignore[-1] == ',') + && (ignore[sizeof "ignore" - 1] == ',' + || ignore[sizeof "ignore" - 1] == '\0')); me->me_dev = (dev_t) -1; /* vmt_fsid might be the info we want. */ - me->me_next = NULL; /* Add to the linked list. */ - mtail->me_next = me; - mtail = me; + *mtail = me; + mtail = &me->me_next; } free (entries); } #endif /* MOUNTED_VMOUNT. */ - /* Free the dummy head. */ - me = mount_list; - mount_list = mount_list->me_next; - free (me); + *mtail = NULL; return mount_list; + + + free_then_fail: + { + int saved_errno = errno; + *mtail = NULL; + + while (mount_list) + { + me = mount_list->me_next; + free (mount_list->me_devname); + free (mount_list->me_mountdir); + if (mount_list->me_type_malloced) + free (mount_list->me_type); + free (mount_list); + mount_list = me; + } + + errno = saved_errno; + return NULL; + } }