fs_mount_defaults.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2003 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* Traverses /etc/vfstab in order to find default mount information about
* file systems on the current host.
*/
#include <errno.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/vfstab.h>
#include <sys/types.h>
#include <strings.h>
#include <thread.h>
#include <synch.h>
#include "libfsmgt.h"
/*
* Private constants
*/
static const char sepstr[] = "\t\n";
/*
* Private variables
*/
static mutex_t vfstab_lock = DEFAULTMUTEX;
/*
* Private method declarations
*/
static int cmp_fields(char *, char *, int);
static fs_mntdefaults_t *create_mntdefaults_entry(struct vfstab vfstab_entry,
int *errp);
static struct vfstab *create_vfstab_filter(fs_mntdefaults_t *filter,
int *errp);
static void free_vfstab_entry(struct vfstab *vfstab_entry);
static char *create_vfstab_entry_line(struct vfstab *, int *);
static int vfstab_line_cmp(fs_mntdefaults_t *, struct vfstab *);
/*
* Public methods
*/
void fs_free_mntdefaults_list(fs_mntdefaults_t *headp) {
fs_mntdefaults_t *tmp;
while (headp != NULL) {
tmp = headp->next;
free(headp->resource);
free(headp->fsckdevice);
free(headp->mountp);
free(headp->fstype);
free(headp->fsckpass);
free(headp->mountatboot);
free(headp->mntopts);
headp->next = NULL;
free(headp);
headp = tmp;
}
} /* fs_free_mntdefaults_list */
/*
* Filter by the fields that are filled in on the filter parameter.
* Fields that aren't used in filtering the defaults will be NULL.
*/
fs_mntdefaults_t *fs_get_filtered_mount_defaults(fs_mntdefaults_t *filter,
int *errp) {
fs_mntdefaults_t *newp;
fs_mntdefaults_t *headp;
fs_mntdefaults_t *tailp;
FILE *fp;
headp = NULL;
tailp = NULL;
if ((fp = fopen(VFSTAB, "r")) != NULL) {
struct vfstab vfstab_entry;
struct vfstab *search_entry;
(void) mutex_lock(&vfstab_lock);
search_entry = create_vfstab_filter(filter, errp);
if (search_entry == NULL) {
/*
* Out of memory, the error pointer (errp) gets
* set in create_vfstab_filter.
*/
fs_free_mntdefaults_list(headp);
(void) mutex_unlock(&vfstab_lock);
(void) fclose(fp);
return (NULL);
}
while (getvfsany(fp, &vfstab_entry, search_entry) == 0) {
/*
* Add to list to be returned
*/
newp = create_mntdefaults_entry(vfstab_entry, errp);
if (newp == NULL) {
/*
* Out of memory, the error pointer (errp)
* gets set in create_mntdefaults_entry.
*/
fs_free_mntdefaults_list(headp);
(void) mutex_unlock(&vfstab_lock);
(void) fclose(fp);
return (NULL);
}
if (headp == NULL) {
headp = newp;
tailp = newp;
} else {
tailp->next = newp;
tailp = newp;
}
}
free_vfstab_entry(search_entry);
(void) mutex_unlock(&vfstab_lock);
(void) fclose(fp);
} else {
*errp = errno;
} /* if ((fp = fopen(VFSTAB, "r")) != NULL) */
return (headp);
} /* fs_get_filtered_mount_defaults */
fs_mntdefaults_t *
fs_get_mount_defaults(int *errp)
{
fs_mntdefaults_t *newp;
fs_mntdefaults_t *headp;
fs_mntdefaults_t *tailp;
FILE *fp;
headp = NULL;
tailp = NULL;
if ((fp = fopen(VFSTAB, "r")) != NULL) {
struct vfstab vfstab_entry;
(void) mutex_lock(&vfstab_lock);
while (getvfsent(fp, &vfstab_entry) == 0) {
/*
* Add entry to list
*/
newp = create_mntdefaults_entry(vfstab_entry, errp);
if (newp == NULL) {
/*
* Out of memory, the error pointer (errp)
* gets set in create_mntdefaults_entry.
*/
(void) fclose(fp);
(void) mutex_unlock(&vfstab_lock);
fs_free_mntdefaults_list(headp);
return (NULL);
}
if (headp == NULL) {
headp = newp;
tailp = newp;
} else {
tailp->next = newp;
tailp = newp;
}
}
(void) fclose(fp);
(void) mutex_unlock(&vfstab_lock);
} else {
*errp = errno;
} /* if ((fp = fopen(VFSTAB, "r")) != NULL) */
/*
* Caller must free the returned list
*/
return (headp);
} /* fs_get_mount_defaults */
fs_mntdefaults_t *
fs_add_mount_default(fs_mntdefaults_t *newp, int *errp) {
FILE *fp;
struct vfstab *new_entry;
fs_mntdefaults_t *ret_val;
new_entry = create_vfstab_filter(newp, errp);
if (new_entry != NULL) {
if ((fp = fopen(VFSTAB, "a")) != NULL) {
(void) mutex_lock(&vfstab_lock);
putvfsent(fp, new_entry);
free_vfstab_entry(new_entry);
(void) fclose(fp);
(void) mutex_unlock(&vfstab_lock);
ret_val = fs_get_mount_defaults(errp);
} else {
*errp = errno;
free_vfstab_entry(new_entry);
ret_val = NULL;
}
} else {
ret_val = NULL;
}
return (ret_val);
} /* fs_add_mount_default */
fs_mntdefaults_t *
fs_edit_mount_defaults(
fs_mntdefaults_t *old_vfstab_ent,
fs_mntdefaults_t *new_vfstab_ent,
int *errp)
{
FILE *fp;
fs_mntdefaults_t *ret_val;
char vfstab_line[VFS_LINE_MAX];
char **temp_vfstab = NULL;
char *new_line;
struct vfstab vfstabp, *new_vfstab;
int line_found = 0;
if ((fp = fopen(VFSTAB, "r")) != NULL) {
char *tmp;
int count = 0;
(void) mutex_lock(&vfstab_lock);
while (fgets(vfstab_line, VFS_LINE_MAX, fp) != NULL) {
char *charp;
struct vfstab *vp;
char *orig_line = strdup(vfstab_line);
if (orig_line == NULL) {
*errp = ENOMEM;
(void) fclose(fp);
(void) mutex_unlock(&vfstab_lock);
return (NULL);
}
vp = &vfstabp;
for (charp = vfstab_line;
*charp == ' ' || *charp == '\t'; charp++);
if (*charp == '#' || *charp == '\n') {
/*
* Write comments out to temp vfstab
* image
*/
if (!fileutil_add_string_to_array(
&temp_vfstab, vfstab_line, &count, errp)) {
ret_val = NULL;
line_found = 0;
break;
}
continue;
}
vp->vfs_special = (char *)strtok_r(
vfstab_line, sepstr, &tmp);
vp->vfs_fsckdev = (char *)strtok_r(
NULL, sepstr, &tmp);
vp->vfs_mountp = (char *)strtok_r(
NULL, sepstr, &tmp);
vp->vfs_fstype = (char *)strtok_r(
NULL, sepstr, &tmp);
vp->vfs_fsckpass = (char *)strtok_r(
NULL, sepstr, &tmp);
vp->vfs_automnt = (char *)strtok_r(
NULL, sepstr, &tmp);
vp->vfs_mntopts = (char *)strtok_r(
NULL, sepstr, &tmp);
if (strtok_r(NULL, sepstr, &tmp) != NULL) {
/*
* Invalid vfstab line.
*/
*errp = EINVAL;
(void) mutex_unlock(&vfstab_lock);
(void) fclose(fp);
return (NULL);
}
if (vfstab_line_cmp(old_vfstab_ent, vp)) {
line_found = 1;
new_vfstab =
create_vfstab_filter(
new_vfstab_ent, errp);
new_line =
create_vfstab_entry_line(new_vfstab, errp);
if (!fileutil_add_string_to_array(
&temp_vfstab, new_line, &count, errp)) {
ret_val = NULL;
line_found = 0;
free(new_line);
break;
}
free(new_line);
} else {
if (!fileutil_add_string_to_array(
&temp_vfstab, orig_line, &count, errp)) {
ret_val = NULL;
line_found = 0;
break;
}
}
free(orig_line);
}
(void) fclose(fp);
if (line_found && temp_vfstab != NULL) {
if ((fp = fopen(VFSTAB, "w")) != NULL) {
int i;
for (i = 0; i < count; i++) {
fprintf(fp, "%s", temp_vfstab[i]);
}
(void) fclose(fp);
(void) mutex_unlock(&vfstab_lock);
ret_val = fs_get_mount_defaults(errp);
fileutil_free_string_array(temp_vfstab, count);
} else {
*errp = errno;
(void) mutex_unlock(&vfstab_lock);
ret_val = NULL;
}
} else {
*errp = errno;
(void) mutex_unlock(&vfstab_lock);
ret_val = NULL;
}
} else {
*errp = errno;
ret_val = NULL;
}
return (ret_val);
} /* fs_edit_mount_defaults */
fs_mntdefaults_t *
fs_del_mount_default_ent(fs_mntdefaults_t *old_vfstab_ent, int *errp)
{
FILE *fp;
fs_mntdefaults_t *ret_val;
char vfstab_line[VFS_LINE_MAX];
struct vfstab vfstabp;
int line_found = 0;
if ((fp = fopen(VFSTAB, "r")) != NULL) {
struct vfstab *vp;
char *tmp;
char *charp;
char *orig_line = NULL;
char **temp_vfstab = NULL;
int count = 0;
vp = &vfstabp;
(void) mutex_lock(&vfstab_lock);
while (fgets(vfstab_line, VFS_LINE_MAX, fp) != NULL) {
orig_line = strdup(vfstab_line);
if (orig_line == NULL) {
*errp = ENOMEM;
(void) fclose(fp);
(void) mutex_unlock(&vfstab_lock);
return (NULL);
}
for (charp = vfstab_line;
*charp == ' ' || *charp == '\t'; charp++);
if (*charp == '#' || *charp == '\n') {
/*
* Write comments out to temp vfstab
* image
*/
if (!fileutil_add_string_to_array(
&temp_vfstab, vfstab_line, &count, errp)) {
ret_val = NULL;
line_found = 0;
free(orig_line);
break;
}
continue;
}
vp->vfs_special = (char *)strtok_r(
vfstab_line, sepstr, &tmp);
vp->vfs_fsckdev = (char *)strtok_r(
NULL, sepstr, &tmp);
vp->vfs_mountp = (char *)strtok_r(
NULL, sepstr, &tmp);
vp->vfs_fstype = (char *)strtok_r(
NULL, sepstr, &tmp);
vp->vfs_fsckpass = (char *)strtok_r(
NULL, sepstr, &tmp);
vp->vfs_automnt = (char *)strtok_r(
NULL, sepstr, &tmp);
vp->vfs_mntopts = (char *)strtok_r(
NULL, sepstr, &tmp);
if (strtok_r(NULL, sepstr, &tmp) != NULL) {
/*
* Invalid vfstab line.
*/
*errp = EINVAL;
free(orig_line);
(void) fclose(fp);
(void) mutex_unlock(&vfstab_lock);
return (NULL);
}
if (vfstab_line_cmp(old_vfstab_ent, vp)) {
line_found = 1;
} else {
if (!fileutil_add_string_to_array(
&temp_vfstab, orig_line, &count, errp)) {
ret_val = NULL;
line_found = 0;
free(orig_line);
break;
}
}
free(orig_line);
}
(void) fclose(fp);
if (line_found && temp_vfstab != NULL) {
if ((fp = fopen(VFSTAB, "w")) != NULL) {
int i;
for (i = 0; i < count; i++) {
fprintf(fp, "%s", temp_vfstab[i]);
}
(void) fclose(fp);
(void) mutex_unlock(&vfstab_lock);
ret_val = fs_get_mount_defaults(errp);
fileutil_free_string_array(temp_vfstab, count);
} else {
*errp = errno;
(void) mutex_unlock(&vfstab_lock);
fileutil_free_string_array(temp_vfstab, count);
ret_val = NULL;
}
} else {
(void) mutex_unlock(&vfstab_lock);
if (temp_vfstab != NULL) {
fileutil_free_string_array(temp_vfstab, count);
}
ret_val = NULL;
}
} else {
*errp = errno;
ret_val = NULL;
}
return (ret_val);
}
/*
* Private methods
*/
static fs_mntdefaults_t *
create_mntdefaults_entry(struct vfstab vfstab_entry, int *errp) {
fs_mntdefaults_t *newp;
newp = (fs_mntdefaults_t *)calloc((size_t)1,
(size_t)sizeof (fs_mntdefaults_t));
if (newp == NULL) {
/*
* Out of memory
*/
*errp = errno;
return (NULL);
}
if (vfstab_entry.vfs_special != NULL) {
newp->resource = strdup(vfstab_entry.vfs_special);
if (newp->resource == NULL) {
/*
* Out of memory
*/
*errp = errno;
fs_free_mntdefaults_list(newp);
return (NULL);
}
}
if (vfstab_entry.vfs_fsckdev != NULL) {
newp->fsckdevice = strdup(vfstab_entry.vfs_fsckdev);
if (newp->fsckdevice == NULL) {
/*
* Out of memory
*/
*errp = errno;
fs_free_mntdefaults_list(newp);
return (NULL);
}
}
if (vfstab_entry.vfs_mountp != NULL) {
newp->mountp = strdup(vfstab_entry.vfs_mountp);
if (newp->mountp == NULL) {
/*
* Out of memory
*/
*errp = errno;
fs_free_mntdefaults_list(newp);
return (NULL);
}
}
if (vfstab_entry.vfs_fstype != NULL) {
newp->fstype = strdup(vfstab_entry.vfs_fstype);
if (newp->fstype == NULL) {
/*
* Out of memory
*/
*errp = errno;
fs_free_mntdefaults_list(newp);
return (NULL);
}
}
if (vfstab_entry.vfs_fsckpass != NULL) {
newp->fsckpass = strdup(vfstab_entry.vfs_fsckpass);
if (newp->fsckpass == NULL) {
/*
* Out of memory
*/
*errp = errno;
fs_free_mntdefaults_list(newp);
return (NULL);
}
}
if (vfstab_entry.vfs_automnt != NULL) {
newp->mountatboot = strdup(vfstab_entry.vfs_automnt);
if (newp->mountatboot == NULL) {
/*
* Out of memory
*/
*errp = errno;
fs_free_mntdefaults_list(newp);
return (NULL);
}
}
if (vfstab_entry.vfs_mntopts != NULL) {
newp->mntopts = strdup(vfstab_entry.vfs_mntopts);
if (newp->mntopts == NULL) {
/*
* Out of memory
*/
*errp = errno;
fs_free_mntdefaults_list(newp);
return (NULL);
}
}
newp->next = NULL;
return (newp);
} /* create_mntdefaults_entry */
static struct vfstab *
create_vfstab_filter(fs_mntdefaults_t *filter, int *errp) {
struct vfstab *search_entry;
search_entry = (struct vfstab *)calloc((size_t)1,
(size_t)sizeof (struct vfstab));
if (search_entry == NULL) {
/*
* Out of memory
*/
*errp = errno;
return (NULL);
}
/*
* Populate the filter criteria
*/
if (filter->resource != NULL) {
search_entry->vfs_special = strdup(filter->resource);
if (search_entry->vfs_special == NULL) {
/*
* Out of memory
*/
*errp = errno;
free_vfstab_entry(search_entry);
return (NULL);
}
}
if (filter->fsckdevice != NULL) {
search_entry->vfs_fsckdev = strdup(filter->fsckdevice);
if (search_entry->vfs_fsckdev == NULL) {
/*
* Out of memory
*/
*errp = errno;
free_vfstab_entry(search_entry);
return (NULL);
}
}
if (filter->mountp != NULL) {
search_entry->vfs_mountp = strdup(filter->mountp);
if (search_entry->vfs_mountp == NULL) {
/*
* Out of memory
*/
*errp = errno;
free_vfstab_entry(search_entry);
return (NULL);
}
}
if (filter->fstype != NULL) {
search_entry->vfs_fstype = strdup(filter->fstype);
if (search_entry->vfs_fstype == NULL) {
/*
* Out of memory
*/
*errp = errno;
free_vfstab_entry(search_entry);
return (NULL);
}
}
if (filter->fsckpass != NULL) {
search_entry->vfs_fsckpass = strdup(filter->fsckpass);
if (search_entry->vfs_fsckpass == NULL) {
/*
* Out of memory
*/
*errp = errno;
free_vfstab_entry(search_entry);
return (NULL);
}
}
if (filter->mountatboot != NULL) {
search_entry->vfs_automnt = strdup(filter->mountatboot);
if (search_entry->vfs_automnt == NULL) {
/*
* Out of memory
*/
*errp = errno;
free_vfstab_entry(search_entry);
return (NULL);
}
}
if (filter->mntopts != NULL) {
search_entry->vfs_mntopts = strdup(filter->mntopts);
if (search_entry->vfs_mntopts == NULL) {
/*
* Out of memory
*/
*errp = errno;
free_vfstab_entry(search_entry);
return (NULL);
}
}
return (search_entry);
} /* create_vfstab_filter */
static void free_vfstab_entry(struct vfstab *vfstab_entry) {
free(vfstab_entry->vfs_special);
free(vfstab_entry->vfs_fsckdev);
free(vfstab_entry->vfs_mountp);
free(vfstab_entry->vfs_fstype);
free(vfstab_entry->vfs_fsckpass);
free(vfstab_entry->vfs_automnt);
free(vfstab_entry->vfs_mntopts);
free(vfstab_entry);
} /* free_vfstab_entry */
static int
vfstab_line_cmp(fs_mntdefaults_t *mntdftp, struct vfstab *vp) {
int ret_val = 1;
ret_val = cmp_fields(mntdftp->resource, vp->vfs_special, ret_val);
ret_val = cmp_fields(mntdftp->mountp, vp->vfs_mountp, ret_val);
return (ret_val);
} /* vfstab_line_cmp */
/*
* Helper function for comparing fields in a fs_mntdefaults_t to a
* vfstab structure. Used in vfstab_line_cmp().
*/
static int
cmp_fields(char *mntdflt_str, char *vfstab_str, int ret_val) {
if (ret_val != 0) {
if (mntdflt_str != NULL && vfstab_str != NULL) {
if (strcmp(mntdflt_str, vfstab_str) != 0) {
ret_val = 0;
}
} else if (mntdflt_str == NULL || vfstab_str == NULL) {
ret_val = 0;
}
}
return (ret_val);
} /* cmp_fields */
/*
* Helper fuction used by del_vfstab_ent() and edit_vfstab_ent() to
* create a vfstab line for writing out to the vfstab file.
*/
char *
create_vfstab_entry_line(struct vfstab *vfstab_ent, int *errp) {
char *line;
int line_length;
line_length = (
(vfstab_ent->vfs_special ?
(strlen(vfstab_ent->vfs_special) +1) : 2) +
(vfstab_ent->vfs_fsckdev ?
(strlen(vfstab_ent->vfs_fsckdev) +1) : 2) +
(vfstab_ent->vfs_mountp ?
(strlen(vfstab_ent->vfs_mountp) +1) : 2) +
(vfstab_ent->vfs_fstype ?
(strlen(vfstab_ent->vfs_fstype) +1) : 2) +
(vfstab_ent->vfs_fsckpass ?
(strlen(vfstab_ent->vfs_fsckpass) +1) : 2) +
(vfstab_ent->vfs_automnt ?
(strlen(vfstab_ent->vfs_automnt) +1) : 2) +
(vfstab_ent->vfs_mntopts ?
(strlen(vfstab_ent->vfs_mntopts) +1) : 2));
line = (char *)malloc(line_length + 1);
if (line != NULL) {
sprintf(line, "%s\t%s\t%s\t%s\t%s\t%s\t%s\n",
vfstab_ent->vfs_special ? vfstab_ent->vfs_special : "-",
vfstab_ent->vfs_fsckdev ? vfstab_ent->vfs_fsckdev : "-",
vfstab_ent->vfs_mountp ? vfstab_ent->vfs_mountp : "-",
vfstab_ent->vfs_fstype ? vfstab_ent->vfs_fstype : "-",
vfstab_ent->vfs_fsckpass ? vfstab_ent->vfs_fsckpass : "-",
vfstab_ent->vfs_automnt ? vfstab_ent->vfs_automnt : "-",
vfstab_ent->vfs_mntopts ? vfstab_ent->vfs_mntopts : "-");
} else {
*errp = errno;
}
return (line);
} /* create_vfstab_entry_line */