/*
 * 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.
 */

#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);
}