/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */

/*

 * prof_file.c ---- routines that manipulate an individual profile file.

 */

#include "prof_int.h"

#include <stdio.h>

#ifdef HAVE_STDLIB_H

#include <stdlib.h>

#endif

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#include <string.h>

#include <stddef.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <errno.h>

#ifdef HAVE_PWD_H

#include <pwd.h>

#endif

#if defined(_WIN32)

#include <io.h>

#define HAVE_STAT

#define stat _stat

#ifndef S_ISDIR

#define S_ISDIR(x) (((x) & S_IFMT) == S_IFDIR)

#endif

#endif

#include "k5-platform.h"

#include "k5-label.h"

struct global_shared_profile_data {

    /* This is the head of the global list of shared trees */

    prf_data_t trees;

    /* Lock for above list.  */

    k5_mutex_t mutex;

};

#define g_shared_trees          (krb5int_profile_shared_data.trees)

#define g_shared_trees_mutex    (krb5int_profile_shared_data.mutex)

static struct global_shared_profile_data krb5int_profile_shared_data = {

    0,

    K5_MUTEX_PARTIAL_INITIALIZER

};

MAKE_INIT_FUNCTION(profile_library_initializer);

MAKE_FINI_FUNCTION(profile_library_finalizer);

int profile_library_initializer(void)

{

#ifdef SHOW_INITFINI_FUNCS

    printf("profile_library_initializer\n");

#endif

    add_error_table(&et_prof_error_table);

    return k5_mutex_finish_init(&g_shared_trees_mutex);

}

void profile_library_finalizer(void)

{

    if (! INITIALIZER_RAN(profile_library_initializer) || PROGRAM_EXITING()) {

#ifdef SHOW_INITFINI_FUNCS

        printf("profile_library_finalizer: skipping\n");

#endif

        return;

    }

#ifdef SHOW_INITFINI_FUNCS

    printf("profile_library_finalizer\n");

#endif

    k5_mutex_destroy(&g_shared_trees_mutex);

    remove_error_table(&et_prof_error_table);

}

static void profile_free_file_data(prf_data_t);

static int rw_access(const_profile_filespec_t filespec)

{

#ifdef HAVE_ACCESS

    if (access(filespec, W_OK) == 0)

        return 1;

    else

        return 0;

#else

    /*

     * We're on a substandard OS that doesn't support access.  So

     * we kludge a test using stdio routines, and hope fopen

     * checks the r/w permissions.

     */

    FILE    *f;

    f = fopen(filespec, "r+");

    if (f) {

        fclose(f);

        return 1;

    }

    return 0;

#endif

}

static int r_access(const_profile_filespec_t filespec)

{

#ifdef HAVE_ACCESS

    if (access(filespec, R_OK) == 0)

        return 1;

    else

        return 0;

#else

    /*

     * We're on a substandard OS that doesn't support access.  So

     * we kludge a test using stdio routines, and hope fopen

     * checks the r/w permissions.

     */

    FILE    *f;

    f = fopen(filespec, "r");

    if (f) {

        fclose(f);

        return 1;

    }

    return 0;

#endif

}

int profile_file_is_writable(prf_file_t profile)

{

    if (profile && profile->data) {

        return rw_access(profile->data->filespec);

    } else {

        return 0;

    }

}

prf_data_t

profile_make_prf_data(const char *filename)

{

    prf_data_t d;

    size_t len, flen, slen;

    char *fcopy;

    flen = strlen(filename);

    slen = offsetof(struct _prf_data_t, filespec);

    len = slen + flen + 1;

    if (len < sizeof(struct _prf_data_t))

        len = sizeof(struct _prf_data_t);

    d = malloc(len);

    if (d == NULL)

        return NULL;

    memset(d, 0, len);

    fcopy = (char *) d + slen;

    assert(fcopy == d->filespec);

    strlcpy(fcopy, filename, flen + 1);

    d->refcount = 1;

    d->magic = PROF_MAGIC_FILE_DATA;

    d->root = NULL;

    d->next = NULL;

    d->fslen = flen;

    return d;

}

errcode_t profile_open_file(const_profile_filespec_t filespec,

                            prf_file_t *ret_prof, char **ret_modspec)

{

    prf_file_t      prf;

    errcode_t       retval;

    char            *home_env = 0;

    prf_data_t      data;

    char            *expanded_filename;

    retval = CALL_INIT_FUNCTION(profile_library_initializer);

    if (retval)

        return retval;

    prf = malloc(sizeof(struct _prf_file_t));

    if (!prf)

        return ENOMEM;

    memset(prf, 0, sizeof(struct _prf_file_t));

    prf->magic = PROF_MAGIC_FILE;

    if (filespec[0] == '~' && filespec[1] == '/') {

        home_env = secure_getenv("HOME");

#ifdef HAVE_PWD_H

        if (home_env == NULL) {

            uid_t uid;

            struct passwd *pw, pwx;

            char pwbuf[BUFSIZ];

            uid = getuid();

            if (!k5_getpwuid_r(uid, &pwx, pwbuf, sizeof(pwbuf), &pw)

                && pw != NULL && pw->pw_dir[0] != 0)

                home_env = pw->pw_dir;

        }

#endif

    }

    if (home_env) {

        if (asprintf(&expanded_filename, "%s%s", home_env,

                     filespec + 1) < 0)

            expanded_filename = 0;

    } else

        expanded_filename = strdup(filespec);

    if (expanded_filename == 0) {

        free(prf);

        return ENOMEM;

    }

    k5_mutex_lock(&g_shared_trees_mutex);

    for (data = g_shared_trees; data; data = data->next) {

        if (!strcmp(data->filespec, expanded_filename)

            /* Check that current uid has read access.  */

            && r_access(data->filespec))

            break;

    }

    if (data) {

        data->refcount++;

        data->last_stat = 0;    /* Make sure to stat when updating. */

        k5_mutex_unlock(&g_shared_trees_mutex);

        retval = profile_update_file_data(data, NULL);

        free(expanded_filename);

        if (retval) {

            profile_dereference_data(data);

            free(prf);

            return retval;

        }

        prf->data = data;

        *ret_prof = prf;

        return 0;

    }

    k5_mutex_unlock(&g_shared_trees_mutex);

    data = profile_make_prf_data(expanded_filename);

    if (data == NULL) {

        free(prf);

        free(expanded_filename);

        return ENOMEM;

    }

    free(expanded_filename);

    prf->data = data;

    retval = k5_mutex_init(&data->lock);

    if (retval) {

        free(data);

        free(prf);

        return retval;

    }

    retval = profile_update_file(prf, ret_modspec);

    if (retval) {

        profile_close_file(prf);

        return retval;

    }

    k5_mutex_lock(&g_shared_trees_mutex);

    data->flags |= PROFILE_FILE_SHARED;

    data->next = g_shared_trees;

    g_shared_trees = data;

    k5_mutex_unlock(&g_shared_trees_mutex);

    *ret_prof = prf;

    return 0;

}

errcode_t profile_update_file_data_locked(prf_data_t data, char **ret_modspec)

{

    errcode_t retval;

#ifdef HAVE_STAT

    struct stat st;

    unsigned long frac;

    time_t now;

#endif

    FILE *f;

    int isdir = 0;

    if ((data->flags & PROFILE_FILE_NO_RELOAD) && data->root != NULL)

        return 0;

#ifdef HAVE_STAT

    now = time(0);

    if (now == data->last_stat && data->root != NULL) {

        return 0;

    }

    if (stat(data->filespec, &st)) {

        return errno;

    }

    data->last_stat = now;

#if defined HAVE_STRUCT_STAT_ST_MTIMENSEC

    frac = st.st_mtimensec;

#elif defined HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC

    frac = st.st_mtimespec.tv_nsec;

#elif defined HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC

    frac = st.st_mtim.tv_nsec;

#else

    frac = 0;

#endif

    if (st.st_mtime == data->timestamp

        && frac == data->frac_ts

        && data->root != NULL) {

        return 0;

    }

    if (data->root) {

        profile_free_node(data->root);

        data->root = 0;

    }

    /* Only try to reload regular files, not devices such as pipes. */

    if ((st.st_mode & S_IFMT) != S_IFREG)

        data->flags |= PROFILE_FILE_NO_RELOAD;

#else

    /*

     * If we don't have the stat() call, assume that our in-core

     * memory image is correct.  That is, we won't reread the

     * profile file if it changes.

     */

    if (data->root) {

        return 0;

    }

#endif

#ifdef HAVE_STAT

    isdir = S_ISDIR(st.st_mode);

#endif

    if (!isdir) {

        errno = 0;

        f = fopen(data->filespec, "r");

        if (f == NULL)

            return (errno != 0) ? errno : ENOENT;

        set_cloexec_file(f);

    }

    data->upd_serial++;

    data->flags &= ~PROFILE_FILE_DIRTY;

    if (isdir) {

        retval = profile_process_directory(data->filespec, &data->root);

    } else {

        retval = profile_parse_file(f, &data->root, ret_modspec);

        (void)fclose(f);

    }

    if (retval) {

        return retval;

    }

    assert(data->root != NULL);

#ifdef HAVE_STAT

    data->timestamp = st.st_mtime;

    data->frac_ts = frac;

#endif

    return 0;

}

errcode_t profile_update_file_data(prf_data_t data, char **ret_modspec)

{

    errcode_t retval;

    k5_mutex_lock(&data->lock);

    retval = profile_update_file_data_locked(data, ret_modspec);

    k5_mutex_unlock(&data->lock);

    return retval;

}

static int

make_hard_link(const char *oldpath, const char *newpath)

{

#ifdef _WIN32

    return -1;

#else

    return link(oldpath, newpath);

#endif

}

static errcode_t write_data_to_file(prf_data_t data, const char *outfile,

                                    int can_create)

{

    FILE            *f;

    profile_filespec_t new_file;

    profile_filespec_t old_file;

    errcode_t       retval = 0;

    retval = ENOMEM;

    new_file = old_file = 0;

    if (asprintf(&new_file, "%s.$$$", outfile) < 0) {

        new_file = NULL;

        goto errout;

    }

    if (asprintf(&old_file, "%s.bak", outfile) < 0) {

        old_file = NULL;

        goto errout;

    }

    errno = 0;

    f = WRITABLEFOPEN(new_file, "w");

    if (!f) {

        retval = errno;

        if (retval == 0)

            retval = PROF_FAIL_OPEN;

        goto errout;

    }

    set_cloexec_file(f);

    profile_write_tree_file(data->root, f);

    if (fclose(f) != 0) {

        retval = errno;

        goto errout;

    }

    unlink(old_file);

    if (make_hard_link(outfile, old_file) == 0) {

        /* Okay, got the hard link.  Yay.  Now we've got our

           backup version, so just put the new version in

           place.  */

        if (rename(new_file, outfile)) {

            /* Weird, the rename didn't work.  But the old version

               should still be in place, so no special cleanup is

               needed.  */

            retval = errno;

            goto errout;

        }

    } else if (errno == ENOENT && can_create) {

        if (rename(new_file, outfile)) {

            retval = errno;

            goto errout;

        }

    } else {

        /* Couldn't make the hard link, so there's going to be a

           small window where data->filespec does not refer to

           either version.  */

#ifndef _WIN32

        sync();

#endif

        if (rename(outfile, old_file)) {

            retval = errno;

            goto errout;

        }

        if (rename(new_file, outfile)) {

            retval = errno;

            rename(old_file, outfile); /* back out... */

            goto errout;

        }

    }

    retval = 0;

errout:

    if (new_file)

        free(new_file);

    if (old_file)

        free(old_file);

    return retval;

}

errcode_t profile_flush_file_data_to_buffer (prf_data_t data, char **bufp)

{

    errcode_t       retval;

    k5_mutex_lock(&data->lock);

    retval = profile_write_tree_to_buffer(data->root, bufp);

    k5_mutex_unlock(&data->lock);

    return retval;

}

errcode_t profile_flush_file_data(prf_data_t data)

{

    errcode_t       retval = 0;

    if (!data || data->magic != PROF_MAGIC_FILE_DATA)

        return PROF_MAGIC_FILE_DATA;

    k5_mutex_lock(&data->lock);

    if ((data->flags & PROFILE_FILE_DIRTY) == 0) {

        k5_mutex_unlock(&data->lock);

        return 0;

    }

    retval = write_data_to_file(data, data->filespec, 0);

    data->flags &= ~PROFILE_FILE_DIRTY;

    k5_mutex_unlock(&data->lock);

    return retval;

}

errcode_t profile_flush_file_data_to_file(prf_data_t data, const char *outfile)

{

    errcode_t retval = 0;

    if (!data || data->magic != PROF_MAGIC_FILE_DATA)

        return PROF_MAGIC_FILE_DATA;

    k5_mutex_lock(&data->lock);

    retval = write_data_to_file(data, outfile, 1);

    k5_mutex_unlock(&data->lock);

    return retval;

}

void profile_dereference_data(prf_data_t data)

{

    k5_mutex_lock(&g_shared_trees_mutex);

    profile_dereference_data_locked(data);

    k5_mutex_unlock(&g_shared_trees_mutex);

}

void profile_dereference_data_locked(prf_data_t data)

{

    data->refcount--;

    if (data->refcount == 0)

        profile_free_file_data(data);

}

void profile_lock_global()

{

    k5_mutex_lock(&g_shared_trees_mutex);

}

void profile_unlock_global()

{

    k5_mutex_unlock(&g_shared_trees_mutex);

}

void profile_free_file(prf_file_t prf)

{

    profile_dereference_data(prf->data);

    free(prf);

}

/* Call with mutex locked!  */

static void profile_free_file_data(prf_data_t data)

{

    if (data->flags & PROFILE_FILE_SHARED) {

        /* Remove from linked list.  */

        if (g_shared_trees == data)

            g_shared_trees = data->next;

        else {

            prf_data_t prev, next;

            prev = g_shared_trees;

            next = prev->next;

            while (next) {

                if (next == data) {

                    prev->next = next->next;

                    break;

                }

                prev = next;

                next = next->next;

            }

        }

    }

    if (data->root)

        profile_free_node(data->root);

    data->magic = 0;

    k5_mutex_destroy(&data->lock);

    free(data);

}

errcode_t profile_close_file(prf_file_t prf)

{

    errcode_t       retval;

    retval = profile_flush_file(prf);

    if (retval)

        return retval;

    profile_free_file(prf);

    return 0;

}