OpenSolaris_b135/cmd/logadm/fn.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (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 2007 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*
* logadm/fn.c -- "filename" string module
*
* this file contains routines for the manipulation of filenames.
* they aren't particularly fast (at least they weren't designed
* for performance), but they are simple and put all the malloc/free
* stuff for these strings in a central place. most routines in
* logadm that return filenames return a struct fn, and most routines
* that return lists of strings return a struct fn_list.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include <stdio.h>
#include <libintl.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "err.h"
#include "fn.h"
#define roundup(x, y) ((((x)+((y)-1))/(y))*(y))
/*
* constants controlling how we malloc space. bigger means fewer
* calls to malloc. smaller means less wasted space.
*/
#define FN_MIN 1024 /* initial size of string buffers */
#define FN_MAX 10240 /* maximum size allowed before fatal "overflow" error */
#define FN_INC 1024 /* increments in buffer size as strings grow */
/* info created by fn_new(), private to this module */
struct fn {
char *fn_buf; /* first location in buf */
char *fn_buflast; /* last location in buf */
char *fn_rptr; /* read pointer (next unread character) */
char *fn_wptr; /* write pointer (points at null terminator) */
struct fn *fn_next; /* next in list */
struct stat fn_stbuf;
int fn_n;
};
/* info created by fn_list_new(), private to this module */
struct fn_list {
struct fn *fnl_first; /* first element of list */
struct fn *fnl_last; /* last element of list */
struct fn *fnl_rptr; /* read pointer for iterating through list */
};
/*
* fn_new -- create a new filename buffer, possibly with initial contents
*
* use like this:
* struct fn *fnp = fn_new("this is a string");
*/
struct fn *
fn_new(const char *s)
{
struct fn *fnp = MALLOC(sizeof (struct fn));
fnp->fn_n = -1;
bzero(&fnp->fn_stbuf, sizeof (fnp->fn_stbuf));
fnp->fn_next = NULL;
/* if passed-in string contains at least 1 non-null character... */
if (s != NULL && *s) {
int len = strlen(s);
int buflen = roundup(len + 1, FN_INC);
/* start with buffer filled with passed-in string */
fnp->fn_buf = MALLOC(buflen);
fnp->fn_buflast = &fnp->fn_buf[buflen - 1];
(void) strlcpy(fnp->fn_buf, s, buflen);
fnp->fn_rptr = fnp->fn_buf;
fnp->fn_wptr = &fnp->fn_buf[len];
} else {
/* start with empty buffer */
fnp->fn_buf = MALLOC(FN_MIN);
fnp->fn_buflast = &fnp->fn_buf[FN_MIN - 1];
*fnp->fn_buf = '\0';
fnp->fn_rptr = fnp->fn_buf;
fnp->fn_wptr = fnp->fn_buf;
}
return (fnp);
}
/*
* fn_dup -- duplicate a filename buffer
*/
struct fn *
fn_dup(struct fn *fnp)
{
struct fn *ret = fn_new(fn_s(fnp));
ret->fn_n = fnp->fn_n;
ret->fn_stbuf = fnp->fn_stbuf;
return (ret);
}
/*
* fn_dirname -- return the dirname part of a filename
*/
struct fn *
fn_dirname(struct fn *fnp)
{
char *ptr = NULL;
struct fn *ret;
char *buf;
buf = fn_s(fnp);
if (buf != NULL)
ptr = strrchr(buf, '/');
if (ptr == NULL || buf == NULL)
return (fn_new("."));
else {
*ptr = '\0';
ret = fn_new(buf);
*ptr = '/';
return (ret);
}
}
/*
* fn_setn -- set the "n" value for a filename
*
* the "n" value is initially -1, and is used by logadm to store
* the suffix for rotated log files. the function fn_list_popoldest()
* looks at these "n" values when sorting filenames to determine which
* old log file is the oldest and should be expired first.
*/
void
fn_setn(struct fn *fnp, int n)
{
fnp->fn_n = n;
}
/*
* fn_setstat -- store a struct stat with a filename
*
* the glob functions typically fill in these struct stats since they
* have to stat while globbing anyway. just turned out to be a common
* piece of information that was conveniently stored with the associated
* filename.
*/
void
fn_setstat(struct fn *fnp, struct stat *stp)
{
fnp->fn_stbuf = *stp;
}
/*
* fn_getstat -- return a pointer to the stat info stored by fn_setstat()
*/
struct stat *
fn_getstat(struct fn *fnp)
{
return (&fnp->fn_stbuf);
}
/*
* fn_free -- free a filename buffer
*/
void
fn_free(struct fn *fnp)
{
if (fnp) {
if (fnp->fn_buf)
FREE(fnp->fn_buf);
FREE(fnp);
}
}
/*
* fn_renew -- reset a filename buffer
*
* calling fn_renew(fnp, s) is the same as calling:
* fn_free(fnp);
* fn_new(s);
*/
void
fn_renew(struct fn *fnp, const char *s)
{
fnp->fn_rptr = fnp->fn_wptr = fnp->fn_buf;
fn_puts(fnp, s);
}
/*
* fn_putc -- append a character to a filename
*
* this is the function that handles growing the filename buffer
* automatically and calling err() if it overflows.
*/
void
fn_putc(struct fn *fnp, int c)
{
if (fnp->fn_wptr >= fnp->fn_buflast) {
int buflen = fnp->fn_buflast + 1 - fnp->fn_buf;
char *newbuf;
char *src;
char *dst;
/* overflow, allocate more space or die if at FN_MAX */
if (buflen >= FN_MAX)
err(0, "fn buffer overflow");
buflen += FN_INC;
newbuf = MALLOC(buflen);
/* copy string into new buffer */
src = fnp->fn_buf;
dst = newbuf;
/* just copy up to wptr, rest is history anyway */
while (src < fnp->fn_wptr)
*dst++ = *src++;
fnp->fn_rptr = &newbuf[fnp->fn_rptr - fnp->fn_buf];
FREE(fnp->fn_buf);
fnp->fn_buf = newbuf;
fnp->fn_buflast = &fnp->fn_buf[buflen - 1];
fnp->fn_wptr = dst;
}
*fnp->fn_wptr++ = c;
*fnp->fn_wptr = '\0';
}
/*
* fn_puts -- append a string to a filename
*/
void
fn_puts(struct fn *fnp, const char *s)
{
/* non-optimal, but simple! */
while (s != NULL && *s)
fn_putc(fnp, *s++);
}
/*
* fn_putfn -- append a filename buffer to a filename
*/
void
fn_putfn(struct fn *fnp, struct fn *srcfnp)
{
int c;
fn_rewind(srcfnp);
while (c = fn_getc(srcfnp))
fn_putc(fnp, c);
}
/*
* fn_rewind -- reset the "read pointer" to the beginning of a filename
*/
void
fn_rewind(struct fn *fnp)
{
fnp->fn_rptr = fnp->fn_buf;
}
/*
* fn_getc -- "read" the next character of a filename
*/
int
fn_getc(struct fn *fnp)
{
if (fnp->fn_rptr > fnp->fn_buflast || *fnp->fn_rptr == '\0')
return (0);
return (*fnp->fn_rptr++);
}
/*
* fn_peekc -- "peek" at the next character of a filename
*/
int
fn_peekc(struct fn *fnp)
{
if (fnp->fn_rptr > fnp->fn_buflast || *fnp->fn_rptr == '\0')
return (0);
return (*fnp->fn_rptr);
}
/*
* fn_s -- return a pointer to a null-terminated string containing the filename
*/
char *
fn_s(struct fn *fnp)
{
return (fnp->fn_buf);
}
/*
* fn_isgz -- return true if filename is *.gz
*/
boolean_t
fn_isgz(struct fn *fnp)
{
size_t len;
char *name;
name = fnp->fn_buf;
len = strlen(name);
if (len > 3 && strcmp(name + len - 3, ".gz") == 0)
return (B_TRUE);
else
return (B_FALSE);
}
/*
* fn_list_new -- create a new list of filenames
*
* by convention, an empty list is represented by an allocated
* struct fn_list which contains a NULL linked list, rather than
* by a NULL fn_list pointer. in other words:
*
* struct fn_list *fnlp = some_func_returning_a_list();
* if (fn_list_empty(fnlp))
* ...
*
* is preferable to checking if the fnlp returned is NULL.
*/
struct fn_list *
fn_list_new(const char * const *slist)
{
struct fn_list *fnlp = MALLOC(sizeof (struct fn_list));
fnlp->fnl_first = fnlp->fnl_last = fnlp->fnl_rptr = NULL;
while (slist && *slist)
fn_list_adds(fnlp, *slist++);
return (fnlp);
}
/*
* fn_list_dup -- duplicate a list of filenames
*/
struct fn_list *
fn_list_dup(struct fn_list *fnlp)
{
struct fn_list *ret = fn_list_new(NULL);
struct fn *fnp;
fn_list_rewind(fnlp);
while ((fnp = fn_list_next(fnlp)) != NULL)
fn_list_addfn(ret, fn_dup(fnp));
return (ret);
}
/*
* fn_list_free -- free a list of filenames
*/
void
fn_list_free(struct fn_list *fnlp)
{
struct fn *fnp;
fn_list_rewind(fnlp);
while ((fnp = fn_list_next(fnlp)) != NULL)
fn_free(fnp);
FREE(fnlp);
}
/*
* fn_list_adds -- add a string to a list of filenames
*/
void
fn_list_adds(struct fn_list *fnlp, const char *s)
{
fn_list_addfn(fnlp, fn_new(s));
}
/*
* fn_list_addfn -- add a filename (i.e. struct fn *) to a list of filenames
*/
void
fn_list_addfn(struct fn_list *fnlp, struct fn *fnp)
{
fnp->fn_next = NULL;
if (fnlp->fnl_first == NULL)
fnlp->fnl_first = fnlp->fnl_last = fnlp->fnl_rptr = fnp;
else {
fnlp->fnl_last->fn_next = fnp;
fnlp->fnl_last = fnp;
}
}
/*
* fn_list_rewind -- reset the "read pointer" to the beginning of the list
*/
void
fn_list_rewind(struct fn_list *fnlp)
{
fnlp->fnl_rptr = fnlp->fnl_first;
}
/*
* fn_list_next -- return the filename at the read pointer and advance it
*/
struct fn *
fn_list_next(struct fn_list *fnlp)
{
struct fn *ret = fnlp->fnl_rptr;
if (fnlp->fnl_rptr == fnlp->fnl_last)
fnlp->fnl_rptr = NULL;
else if (fnlp->fnl_rptr != NULL)
fnlp->fnl_rptr = fnlp->fnl_rptr->fn_next;
return (ret);
}
/*
* fn_list_addfn_list -- move filenames from fnlp2 to end of fnlp
*
* frees fnlp2 after moving all the filenames off of it.
*/
void
fn_list_addfn_list(struct fn_list *fnlp, struct fn_list *fnlp2)
{
struct fn *fnp2 = fnlp2->fnl_first;
struct fn *nextfnp2;
/* for each fn in the second list... */
while (fnp2) {
if (fnp2 == fnlp2->fnl_last)
nextfnp2 = NULL;
else
nextfnp2 = fnp2->fn_next;
/* append it to the first list */
fn_list_addfn(fnlp, fnp2);
fnp2 = nextfnp2;
}
/* all the fn's were moved off the second list */
fnlp2->fnl_first = fnlp2->fnl_last = fnlp2->fnl_rptr = NULL;
/* done with the second list */
fn_list_free(fnlp2);
}
/*
* fn_list_appendrange -- append a range of characters to each filename in list
*
* range of characters appended is the character at *s up to but not including
* the character at *limit. NULL termination is not required.
*/
void
fn_list_appendrange(struct fn_list *fnlp, const char *s, const char *limit)
{
struct fn *fnp = fnlp->fnl_first;
struct fn *nextfnp;
const char *ptr;
/* for each fn in the list... */
while (fnp != NULL) {
if (fnp == fnlp->fnl_last)
nextfnp = NULL;
else
nextfnp = fnp->fn_next;
/* append the range */
for (ptr = s; ptr < limit; ptr++)
fn_putc(fnp, *ptr);
fnp = nextfnp;
}
}
/*
* fn_list_totalsize -- sum up all the st_size fields in the stat structs
*/
off_t
fn_list_totalsize(struct fn_list *fnlp)
{
struct fn *fnp;
off_t ret = 0;
fn_list_rewind(fnlp);
while ((fnp = fn_list_next(fnlp)) != NULL)
ret += fnp->fn_stbuf.st_size;
return (ret);
}
/*
* fn_list_popoldest -- remove oldest file from list and return it
*
* this function uses the "n" values (set by fn_setn()) to determine
* which file is oldest, or when there's a tie it turns to the modification
* times in the stat structs, or when there's still a tie lexical sorting.
*/
struct fn *
fn_list_popoldest(struct fn_list *fnlp)
{
struct fn *fnp;
struct fn *ret = NULL;
fn_list_rewind(fnlp);
while ((fnp = fn_list_next(fnlp)) != NULL)
if (ret == NULL)
ret = fnp;
else if (fnp->fn_n > ret->fn_n ||
(fnp->fn_n == ret->fn_n &&
(fnp->fn_stbuf.st_mtime < ret->fn_stbuf.st_mtime ||
((fnp->fn_stbuf.st_mtime == ret->fn_stbuf.st_mtime &&
strcmp(fnp->fn_buf, ret->fn_buf) > 0)))))
ret = fnp;
if (ret == NULL)
return (NULL);
/* oldest file is ret, remove it from list */
if (fnlp->fnl_first == ret) {
fnlp->fnl_first = ret->fn_next;
} else {
fn_list_rewind(fnlp);
while ((fnp = fn_list_next(fnlp)) != NULL) {
if (fnp->fn_next == ret) {
fnp->fn_next = ret->fn_next;
if (fnlp->fnl_last == ret)
fnlp->fnl_last = fnp;
break;
}
}
}
ret->fn_next = NULL;
return (ret);
}
/*
* fn_list_empty -- true if the list is empty
*/
boolean_t
fn_list_empty(struct fn_list *fnlp)
{
return (fnlp->fnl_first == NULL);
}
/*
* fn_list_count -- return number of filenames in list
*/
int
fn_list_count(struct fn_list *fnlp)
{
int ret = 0;
/*
* if this operation were more common, we'd cache the count
* in the struct fn_list, but it isn't very common so we just
* count 'em up here
*/
fn_list_rewind(fnlp);
while (fn_list_next(fnlp) != NULL)
ret++;
return (ret);
}