/* ====================================================================
 * The Apache Software License, Version 1.1
 *
 * Copyright (c) 2000-2002 The Apache Software Foundation.  All rights
 * reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. The end-user documentation included with the redistribution,
 *    if any, must include the following acknowledgment:
 *       "This product includes software developed by the
 *        Apache Software Foundation (http://www.apache.org/)."
 *    Alternately, this acknowledgment may appear in the software itself,
 *    if and wherever such third-party acknowledgments normally appear.
 *
 * 4. The names "Apache" and "Apache Software Foundation" must
 *    not be used to endorse or promote products derived from this
 *    software without prior written permission. For written
 *    permission, please contact apache@apache.org.
 *
 * 5. Products derived from this software may not be called "Apache",
 *    nor may "Apache" appear in their name, without prior written
 *    permission of the Apache Software Foundation.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * ====================================================================
 *
 * This software consists of voluntary contributions made by many
 * individuals on behalf of the Apache Software Foundation.  For more
 * information on the Apache Software Foundation, please see
 * <http://www.apache.org/>.
 */

#include "fileio.h"
#include "nks/dirio.h"
#include "apr_file_io.h"
#include "apr_general.h"
#include "apr_strings.h"
#include "apr_errno.h"
#include "apr_hash.h"

static apr_filetype_e filetype_from_mode(mode_t mode)
{
    apr_filetype_e type = APR_NOFILE;

    if (S_ISREG(mode))
        type = APR_REG;
    if (S_ISDIR(mode))
        type = APR_DIR;
    if (S_ISCHR(mode))
        type = APR_CHR;
    if (S_ISBLK(mode))
        type = APR_BLK;
    if (S_ISFIFO(mode))
        type = APR_PIPE;
    if (S_ISLNK(mode))
        type = APR_LNK;
    if (S_ISSOCK(mode))
        type = APR_SOCK;
    return type;
}

static void fill_out_finfo(apr_finfo_t *finfo, struct stat *info,
                           apr_int32_t wanted)
{ 
    finfo->valid = APR_FINFO_MIN | APR_FINFO_IDENT | APR_FINFO_NLINK;
    finfo->protection = apr_unix_mode2perms(info->st_mode);
    finfo->filetype = filetype_from_mode(info->st_mode);
    finfo->user = info->st_uid;
    finfo->group = info->st_gid;
    finfo->size = info->st_size;
    finfo->inode = info->st_ino;
    finfo->device = info->st_dev;
    finfo->nlink = info->st_nlink;
    apr_time_ansi_put(&finfo->atime, info->st_atime.tv_sec);
    apr_time_ansi_put(&finfo->mtime, info->st_mtime.tv_sec);
    apr_time_ansi_put(&finfo->ctime, info->st_ctime.tv_sec);
    /* ### needs to be revisited  
     * if (wanted & APR_FINFO_CSIZE) {
     *   finfo->csize = info->st_blocks * 512;
     *   finfo->valid |= APR_FINFO_CSIZE;
     * }
     */
}

char *case_filename(apr_pool_t *pPool, const char *szFile)
{
    char *casedFileName = NULL;
    char name[1024];
    int rc;

#ifdef NEW_API
    rc = realname(szFile, name);
    if (rc == 0) {
        casedFileName = apr_pstrdup(pPool, name);
    }
#else
    NXDirAttrWithName_t	*attrBuf;

    attrBuf = (NXDirAttrWithName_t *) &name;
    rc =NXGetAttr(NULL, szFile, NX_DELEVEL_NAME_ONLY, attrBuf, 1024, 0);
    if (rc == 0) {
        casedFileName = apr_pstrdup(pPool, attrBuf->deName);
    }
#endif
    else
    {
        char *s;
        s = strrchr(szFile, '/');
        if (!s)
            s = strrchr(szFile, ':');
        if (s) {
            casedFileName = apr_pstrdup(pPool, &s[1]);
        }
    }
    return casedFileName;
}


APR_DECLARE(apr_status_t) apr_file_info_get(apr_finfo_t *finfo, 
                                            apr_int32_t wanted,
                                            apr_file_t *thefile)
{
    struct stat info;

    if (fstat(thefile->filedes, &info) == 0) {
        finfo->pool = thefile->pool;
        finfo->fname = thefile->fname;
        fill_out_finfo(finfo, &info, wanted);
        return (wanted & ~finfo->valid) ? APR_INCOMPLETE : APR_SUCCESS;
    }
    else {
        return errno;
    }
}

APR_DECLARE(apr_status_t) apr_file_perms_set(const char *fname, 
                                             apr_fileperms_t perms)
{
    mode_t mode = apr_unix_perms2mode(perms);

    if (chmod(fname, mode) == -1)
        return errno;
    return APR_SUCCESS;
}

APR_DECLARE(apr_status_t) apr_file_attrs_set(const char *fname,
                                             apr_fileattrs_t attributes,
                                             apr_fileattrs_t attr_mask,
                                             apr_pool_t *pool)
{
    apr_status_t status;
    apr_finfo_t finfo;

    status = apr_stat(&finfo, fname, APR_FINFO_PROT, pool);
    if (!APR_STATUS_IS_SUCCESS(status))
        return status;

    /* ### TODO: should added bits be umask'd? */
    if (attr_mask & APR_FILE_ATTR_READONLY)
    {
        if (attributes & APR_FILE_ATTR_READONLY)
        {
            finfo.protection &= ~APR_UWRITE;
            finfo.protection &= ~APR_GWRITE;
            finfo.protection &= ~APR_WWRITE;
        }
        else
        {
            /* ### umask this! */
            finfo.protection |= APR_UWRITE;
            finfo.protection |= APR_GWRITE;
            finfo.protection |= APR_WWRITE;
        }
    }

    if (attr_mask & APR_FILE_ATTR_EXECUTABLE)
    {
        if (attributes & APR_FILE_ATTR_EXECUTABLE)
        {
            /* ### umask this! */
            finfo.protection |= APR_UEXECUTE;
            finfo.protection |= APR_GEXECUTE;
            finfo.protection |= APR_WEXECUTE;
        }
        else
        {
            finfo.protection &= ~APR_UEXECUTE;
            finfo.protection &= ~APR_GEXECUTE;
            finfo.protection &= ~APR_WEXECUTE;
        }
    }

    return apr_file_perms_set(fname, finfo.protection);
}

typedef struct apr_stat_entry_t apr_stat_entry_t;

struct apr_stat_entry_t {
    struct stat info;
    char *casedName;
    apr_time_t expire;
};

extern apr_int32_t CpuCurrentProcessor; /* system variable */

int cstat (const char *path, struct stat *buf, char **casedName, apr_pool_t *pool)
{
    apr_hash_t *statCache = (apr_hash_t *)getStatCache(CpuCurrentProcessor);
    apr_pool_t *gPool = (apr_pool_t *)getGlobalPool(CpuCurrentProcessor);
    apr_stat_entry_t *stat_entry;
    struct stat *info;
    apr_time_t now = apr_time_now();
    char *key;
    int ret;
    int found = 0;

    *casedName = NULL;

    /* If there isn't a global pool then just stat the file
       and return */
    if (!gPool) {
        char poolname[50];

        if (apr_pool_create(&gPool, NULL) != APR_SUCCESS) {
            ret = stat(path, buf);
            if (ret == 0)
                *casedName = case_filename(pool, path);
            return ret;
        }

        sprintf (poolname, "cstat_mem_pool_%d", CpuCurrentProcessor);
        apr_pool_tag(gPool, poolname);

        setGlobalPool(gPool, CpuCurrentProcessor);
    }

    /* If we have a statCache hash table then use it.
       Otherwise we need to create it and initialized it
       with a new mutex lock. */
    if (!statCache) {
        statCache = apr_hash_make(gPool);
        setStatCache((void*)statCache, CpuCurrentProcessor);
    }

    /* If we have a statCache then try to pull the information
       from the cache.  Otherwise just stat the file and return.*/
    if (statCache) {
        stat_entry = (apr_stat_entry_t*) apr_hash_get(statCache, path, APR_HASH_KEY_STRING);
        /* If we got an entry then check the expiration time.  If the entry
           hasn't expired yet then copy the information and return. */
        if (stat_entry) {
            if ((now - stat_entry->expire) <= APR_USEC_PER_SEC) {
                memcpy (buf, &(stat_entry->info), sizeof(struct stat));
                if (stat_entry->casedName)
                    *casedName = apr_pstrdup (pool, stat_entry->casedName);
                else
                    *casedName = case_filename(pool, path);
                found = 1;
            }
        }

        /* Since we are creating a separate stat cache for each processor, we
           don't need to worry about locking the hash table before manipulating
           it. */
        if (!found) {
            /* Bind the thread to the current cpu so that we don't wake
               up on some other cpu and try to manipulate the wrong cache. */
            NXThreadBind (CpuCurrentProcessor);
            ret = stat(path, buf);
            if (ret == 0) {
                *casedName = case_filename(pool, path);
                /* If we don't have a stat_entry then create one, copy
                   the data and add it to the hash table. */
                if (!stat_entry) {
                    key = apr_pstrdup (gPool, path);
                    stat_entry = apr_palloc (gPool, sizeof(apr_stat_entry_t));
                    memcpy (&(stat_entry->info), buf, sizeof(struct stat));
                    if (*casedName)
                        stat_entry->casedName = apr_pstrdup (gPool, *casedName);
                    stat_entry->expire = now;
                    apr_hash_set(statCache, key, APR_HASH_KEY_STRING, stat_entry);
                }
                else {
                    /* If we do have a stat_entry then it must have expired.  Just
                       copy the data and reset the expiration. */
                    memcpy (&(stat_entry->info), buf, sizeof(struct stat));

                    /* If we have a casedName and don't have a cached name or the names don't
                       compare, then cache the name. */
                    if (*casedName && (!stat_entry->casedName || strcmp(*casedName, stat_entry->casedName))) {
                        stat_entry->casedName = apr_pstrdup (gPool, *casedName);
                    }
                    stat_entry->expire = now;
                }
                NXThreadBind (NX_THR_UNBOUND);
            }
            else{
                NXThreadBind (NX_THR_UNBOUND);
                return ret;
			}
        }
    }
    else {
        ret = stat(path, buf);
        if (ret == 0)
            *casedName = case_filename(pool, path);
        return ret;
    }
    return 0;
}

APR_DECLARE(apr_status_t) apr_stat(apr_finfo_t *finfo, 
                                   const char *fname, 
                                   apr_int32_t wanted, apr_pool_t *pool)
{
    struct stat info;
    int srv;
    char *casedName = NULL;

    srv = cstat(fname, &info, &casedName, pool);

    if (srv == 0) {
        finfo->pool = pool;
        finfo->fname = fname;
        fill_out_finfo(finfo, &info, wanted);
        if (wanted & APR_FINFO_LINK)
            wanted &= ~APR_FINFO_LINK;
        if (wanted & APR_FINFO_NAME) {
            if (casedName) {
                finfo->name = casedName;
                finfo->valid |= APR_FINFO_NAME;
            }
        }
        return (wanted & ~finfo->valid) ? APR_INCOMPLETE : APR_SUCCESS;
    }
    else {
#if !defined(ENOENT) || !defined(ENOTDIR)
#error ENOENT || ENOTDIR not defined; please see the
#error comments at this line in the source for a workaround.
        /*
         * If ENOENT || ENOTDIR is not defined in one of the your OS's
         * include files, APR cannot report a good reason why the stat()
         * of the file failed; there are cases where it can fail even though
         * the file exists.  This opens holes in Apache, for example, because
         * it becomes possible for someone to get a directory listing of a 
         * directory even though there is an index (eg. index.html) file in 
         * it.  If you do not have a problem with this, delete the above 
         * #error lines and start the compile again.  If you need to do this,
         * please submit a bug report to http://www.apache.org/bug_report.html
         * letting us know that you needed to do this.  Please be sure to 
         * include the operating system you are using.
         */
        /* WARNING: All errors will be handled as not found
         */
#if !defined(ENOENT) 
        return APR_ENOENT;
#else
        /* WARNING: All errors but not found will be handled as not directory
         */
        if (errno != ENOENT)
            return APR_ENOENT;
        else
            return errno;
#endif
#else /* All was defined well, report the usual: */
        return errno;
#endif
    }
}

/* Perhaps this becomes nothing but a macro?
 */
APR_DECLARE(apr_status_t) apr_lstat(apr_finfo_t *finfo, const char *fname,
                      apr_int32_t wanted, apr_pool_t *pool)
{
    return apr_stat(finfo, fname, wanted | APR_FINFO_LINK, pool);
}

