OpenSolaris_b135/cmd/fs.d/nfs/lib/nfslogtab.c
/*
* 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 (c) 1999 by Sun Microsystems, Inc.
* All rights reserved.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* Manipulates the nfslogtab
*/
#ifndef _REENTRANT
#define _REENTRANT
#endif
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <utmpx.h>
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <strings.h>
#include <string.h>
#include "nfslogtab.h"
#ifndef LINTHAPPY
#define LINTHAPPY
#endif
static void logtab_ent_list_free(struct logtab_ent_list *);
/*
* Retrieves the next entry from nfslogtab.
* Assumes the file is locked.
* '*lepp' points to the new entry if successful.
* Returns:
* > 0 valid entry
* = 0 end of file
* < 0 error
*/
int
logtab_getent(FILE *fd, struct logtab_ent **lepp)
{
char line[MAXBUFSIZE + 1];
char *p;
char *lasts, *tmp;
char *w = " \t";
struct logtab_ent *lep = NULL;
int error = 0;
if ((lep = (struct logtab_ent *)malloc(sizeof (*lep))) == NULL) {
return (-1);
}
(void) memset((char *)lep, 0, sizeof (*lep));
if ((p = fgets(line, MAXBUFSIZE, fd)) == NULL) {
error = 0;
goto errout;
}
line[strlen(line) - 1] = '\0';
tmp = (char *)strtok_r(p, w, &lasts);
if (tmp == NULL) {
error = -1;
goto errout;
}
if ((lep->le_buffer = strdup(tmp)) == NULL) {
error = -1;
goto errout;
}
tmp = (char *)strtok_r(NULL, w, &lasts);
if (tmp == NULL) {
error = -1;
goto errout;
}
if ((lep->le_path = strdup(tmp)) == NULL) {
error = -1;
goto errout;
}
tmp = (char *)strtok_r(NULL, w, &lasts);
if (tmp == NULL) {
error = -1;
goto errout;
}
if ((lep->le_tag = strdup(tmp)) == NULL) {
error = -1;
goto errout;
}
tmp = (char *)strtok_r(NULL, w, &lasts);
if (tmp == NULL) {
error = -1;
goto errout;
}
lep->le_state = atoi(tmp);
*lepp = lep;
return (1);
errout:
logtab_ent_free(lep);
return (error);
}
/*
* Append an entry to the logtab file.
*/
int
logtab_putent(FILE *fd, struct logtab_ent *lep)
{
int r;
if (fseek(fd, 0L, SEEK_END) < 0)
return (errno);
r = fprintf(fd, "%s\t%s\t%s\t%d\n",
lep->le_buffer,
lep->le_path,
lep->le_tag,
lep->le_state);
return (r);
}
#ifndef LINTHAPPY
/*
* Searches the nfslogtab file looking for the next entry which matches
* the search criteria. The search is continued at the current position
* in the nfslogtab file.
* If 'buffer' != NULL, then buffer is matched.
* If 'path' != NULL, then path is matched.
* If 'tag' != NULL, then tag is matched.
* If 'state' != -1, then state is matched.
* 'buffer', 'path' and 'tag' can all be non-NULL, which means the entry must
* satisfy all requirements.
*
* Returns 0 on success, ENOENT otherwise.
* If found, '*lepp' points to the matching entry, otherwise '*lepp' is
* undefined.
*/
static int
logtab_findent(FILE *fd, char *buffer, char *path, char *tag, int state,
struct logtab_ent **lepp)
{
boolean_t found = B_FALSE;
while (!found && (logtab_getent(fd, lepp) > 0)) {
found = B_TRUE;
if (buffer != NULL)
found = strcmp(buffer, (*lepp)->le_buffer) == 0;
if (path != NULL)
found = found && (strcmp(path, (*lepp)->le_path) == 0);
if (tag != NULL)
found = found && (strcmp(tag, (*lepp)->le_tag) == 0);
if (state != -1)
found = found && (state == (*lepp)->le_state);
if (!found)
logtab_ent_free(*lepp);
}
return (found ? 0 : ENOENT);
}
#endif
/*
* Remove all entries which match the search criteria.
* If 'buffer' != NULL, then buffer is matched.
* If 'path' != NULL, then path is matched.
* If 'tag' != NULL, then tag is matched.
* If 'state' != -1, then state is matched.
* 'buffer', 'path' and 'tag' can all be non-NULL, which means the entry must
* satisfy all requirements.
* The file is assumed to be locked.
* Read the entries into a linked list of logtab_ent structures
* minus the entries to be removed, then truncate the nfslogtab
* file and write it back to the file from the linked list.
*
* On success returns 0, -1 otherwise.
* Entry not found is treated as success since it was going to be removed
* anyway.
*/
int
logtab_rement(FILE *fd, char *buffer, char *path, char *tag, int state)
{
struct logtab_ent_list *head = NULL, *tail = NULL, *tmpl;
struct logtab_ent *lep;
int remcnt = 0; /* remove count */
int error = 0;
boolean_t found;
rewind(fd);
while ((error = logtab_getent(fd, &lep)) > 0) {
found = B_TRUE;
if (buffer != NULL)
found = strcmp(buffer, lep->le_buffer) == 0;
if (path != NULL)
found = found && (strcmp(path, lep->le_path) == 0);
if (tag != NULL)
found = found && (strcmp(tag, lep->le_tag) == 0);
if (state != -1)
found = found && (state == lep->le_state);
if (found) {
remcnt++;
logtab_ent_free(lep);
} else {
tmpl = (struct logtab_ent_list *)
malloc(sizeof (struct logtab_ent));
if (tmpl == NULL) {
error = ENOENT;
break;
}
tmpl->lel_le = lep;
tmpl->lel_next = NULL;
if (head == NULL) {
/*
* empty list
*/
head = tail = tmpl;
} else {
/*
* Add to the end of the list and remember
* the new last element.
*/
tail->lel_next = tmpl;
tail = tmpl; /* remember the last element */
}
}
}
if (error)
goto deallocate;
if (remcnt == 0) {
/*
* Entry not found, nothing to do
*/
goto deallocate;
}
if (ftruncate(fileno(fd), 0) < 0) {
error = -1;
goto deallocate;
}
for (tmpl = head; tmpl != NULL; tmpl = tmpl->lel_next)
(void) logtab_putent(fd, tmpl->lel_le);
deallocate:
logtab_ent_list_free(head);
return (error);
}
/*
* Deactivate all entries matching search criteria.
* If 'buffer' != NULL then match buffer.
* If 'path' != NULL then match path.
* If 'tag' != NULL then match tag.
* Note that 'buffer', 'path' and 'tag' can al be non-null at the same time.
*
* Rewrites the nfslogtab file with the updated state for each entry.
* Assumes the nfslogtab file has been locked for writing.
* Returns 0 on success, -1 on failure.
*/
int
logtab_deactivate(FILE *fd, char *buffer, char *path, char *tag)
{
struct logtab_ent_list *lelp, *head = NULL, *tail = NULL;
struct logtab_ent *lep;
boolean_t found;
int error = 0;
int count = 0;
rewind(fd);
while ((error = logtab_getent(fd, &lep)) > 0) {
found = B_TRUE;
if (buffer != NULL)
found = strcmp(buffer, lep->le_buffer) == 0;
if (path != NULL)
found = found && (strcmp(path, lep->le_path) == 0);
if (tag != NULL)
found = found && (strcmp(tag, lep->le_tag) == 0);
if (found && (lep->le_state == LES_ACTIVE)) {
count++;
lep->le_state = LES_INACTIVE;
}
lelp = (struct logtab_ent_list *)
malloc(sizeof (struct logtab_ent));
if (lelp == NULL) {
error = ENOENT;
break;
}
lelp->lel_le = lep;
lelp->lel_next = NULL;
if (head == NULL) {
/*
* empty list
*/
head = tail = lelp;
} else {
/*
* Add to the end of the list and remember
* the new last element.
*/
tail->lel_next = lelp;
tail = lelp; /* remember the last element */
}
}
if (error)
goto deallocate;
if (count == 0) {
/*
* done
*/
error = 0;
goto deallocate;
}
if (ftruncate(fileno(fd), 0) < 0) {
error = -1;
goto deallocate;
}
for (lelp = head; lelp != NULL; lelp = lelp->lel_next)
(void) logtab_putent(fd, lelp->lel_le);
deallocate:
logtab_ent_list_free(head);
return (error);
}
/*
* Deactivates all entries if nfslogtab exists and is older than boot time
* This will only happen the first time it is called.
* Assumes 'fd' has been locked by the caller.
* Returns 0 on success, otherwise -1.
*/
int
logtab_deactivate_after_boot(FILE *fd)
{
struct stat st;
struct utmpx *utmpxp;
int error = 0;
if ((fstat(fileno(fd), &st) == 0) &&
((utmpxp = getutxent()) != NULL) &&
(utmpxp->ut_xtime > st.st_mtime)) {
if (logtab_deactivate(fd, NULL, NULL, NULL))
error = -1;
}
return (error);
}
void
logtab_ent_free(struct logtab_ent *lep)
{
if (lep->le_buffer)
free(lep->le_buffer);
if (lep->le_path)
free(lep->le_path);
if (lep->le_tag)
free(lep->le_tag);
free(lep);
}
static void
logtab_ent_list_free(struct logtab_ent_list *head)
{
struct logtab_ent_list *lelp, *next;
if (head == NULL)
return;
for (lelp = head; lelp != NULL; lelp = next) {
if (lelp->lel_le != NULL)
logtab_ent_free(lelp->lel_le);
next = lelp->lel_next;
free(lelp);
}
}