/************************************************************************
 *
 * file.cpp - definitions of testsuite file I/O helpers
 *
 * $Id$
 *
 ************************************************************************
 *
 * Licensed to the Apache Software  Foundation (ASF) under one or more
 * contributor  license agreements.  See  the NOTICE  file distributed
 * with  this  work  for  additional information  regarding  copyright
 * ownership.   The ASF  licenses this  file to  you under  the Apache
 * License, Version  2.0 (the  "License"); you may  not use  this file
 * except in  compliance with the License.   You may obtain  a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the  License is distributed on an  "AS IS" BASIS,
 * WITHOUT  WARRANTIES OR CONDITIONS  OF ANY  KIND, either  express or
 * implied.   See  the License  for  the  specific language  governing
 * permissions and limitations under the License.
 *
 * Copyright 2004-2006 Rogue Wave Software.
 * 
 **************************************************************************/

// expand _TEST_EXPORT macros
#define _RWSTD_TEST_SRC

#include <file.h>

#if defined __linux__
   // on Linux define _XOPEN_SOURCE to get CODESET defined in <langinfo.h>
#  define _XOPEN_SOURCE   500   /* Single Unix conformance */
   // bring __int32_t into scope (otherwise <wctype.h> fails to compile)
#  include <sys/types.h>
#endif   // __linux__

#include <fcntl.h>
#include <sys/stat.h>

#if !defined  (_WIN32) && !defined (_WIN64)
#  include <langinfo.h>   // for CODESET
#  include <unistd.h>     // for close(), open()
#else
#  include <io.h>         // for _commit()
#endif

#include <assert.h>   // for assert
#include <errno.h>    // for errno
#include <locale.h>   // for LC_XXX macros
#include <stdio.h>    // for sprintf, ...
#include <stdlib.h>   // for free, malloc, realloc
#include <string.h>   // for strcat, strcpy, strlen, ...
#include <ctype.h>
#include <wchar.h>    // for wcslen, ...


#ifndef PATH_MAX
#  define PATH_MAX   1024
#endif

#ifndef P_tmpdir
   // P_tmpdir is an XSI (X/Open System Interfaces) extension
   // to POSIX which need not be provided by otherwise conforming
   // implementations
#  define P_tmpdir "/tmp/"
#endif

#ifndef _RWSTD_NO_PURE_C_HEADERS

extern "C" int mkstemp (char*);

#endif   // _RWSTD_NO_PURE_C_HEADERS

// write `str' using symbolic names from the Portable Character Set (PCS)
// or using the <U00XX> notations for narrow characters outside that set
// if (0 == str), writes out the CHARMAP section of the locale definition
// file for the Portable Character Set (in POSIX-compliant format) 
_TEST_EXPORT void pcs_write (void *fpv, const char *str)
{
    FILE* const fp = _RWSTD_STATIC_CAST (FILE*, fpv);

    // ASCII (ISO-646) character map definition
    static const char* charmap[] = {
        "<NUL>", "<SOH>", "<STX>", "<ETX>", "<EOT>", "<ENQ>", "<ACK>", "<BEL>",
        "<backspace>",
        "<tab>",
        "<newline>",
        "<vertical-tab>",
        "<form-feed>",
        "<carriage-return>",
        "<SO>", "<SI>", "<DLE>", "<DC1>", "<DC2>", "<DC3>", "<DC4>", "<NAK>",
        "<SYN>","<ETB>", "<CAN>", "<EM>", "<SUB>", "<ESC>", "<IS4>", "<IS3>",
        "<IS2>", "<IS1>",
        "<space>",
        /* ! */ "<exclamation-mark>",
        /* " */ "<quotation-mark>",
        /* # */ "<number-sign>",
        /* $ */ "<dollar-sign>",
        /* % */ "<percent-sign>",
        /* & */ "<ampersand>",
        /* ' */ "<apostrophe>",
        /* ( */ "<left-parenthesis>",
        /* ) */ "<right-parenthesis>",
        /* * */ "<asterisk>",
        /* + */ "<plus-sign>",
        /* , */ "<comma>",
        /* - */ "<hyphen>",
        /* . */ "<period>",
        /* / */ "<slash>",
        /* 0 */ "<zero>",
        /* 1 */ "<one>",
        /* 2 */ "<two>",
        /* 3 */ "<three>",
        /* 4 */ "<four>",
        /* 5 */ "<five>",
        /* 6 */ "<six>",
        /* 7 */ "<seven>",
        /* 8 */ "<eight>",
        /* 9 */ "<nine>",
        /* : */ "<colon>",
        /* ; */ "<semicolon>",
        /* < */ "<less-than-sign>",
        /* = */ "<equals-sign>",
        /* > */ "<greater-than-sign>",
        /* ? */ "<question-mark>",
        /* @ */ "<commercial-at>",
        "<A>", "<B>", "<C>", "<D>", "<E>", "<F>", "<G>", "<H>", "<I>", "<J>",
        "<K>", "<L>", "<M>", "<N>", "<O>", "<P>", "<Q>", "<R>", "<S>", "<T>",
        "<U>", "<V>", "<W>", "<X>", "<Y>", "<Z>",
        /* [ */ "<left-square-bracket>",
        /* \ */ "<backslash>",
        /* ] */ "<right-square-bracket>",
        /* ^ */ "<circumflex>",
        /* _ */ "<underscore>",
        /* ` */ "<grave-accent>",
        "<a>", "<b>", "<c>", "<d>", "<e>", "<f>", "<g>", "<h>", "<i>", "<j>",
        "<k>", "<l>", "<m>", "<n>", "<o>", "<p>", "<q>", "<r>", "<s>", "<t>",
        "<u>", "<v>", "<w>", "<x>", "<y>", "<z>",
        /* { */ "<left-brace>",
        /* | */ "<vertical-line>",
        /* } */ "<right-brace>",
        /* ~ */ "<tilde>",
        "<DEL>"
    };

    if (str) {
        // write out `str' using the charmap above
        for (; *str; ++str) {
            const unsigned char uc = _RWSTD_STATIC_CAST (unsigned char, *str);

            if (uc < sizeof charmap / sizeof *charmap)
                fprintf (fp, "%s", charmap [uc]);
            else
                fprintf (fp, "<U%04X>", uc);
        }
    }
    else {

#if !defined (_WIN32) && !defined (_WIN64)
        const char* const codeset = nl_langinfo (CODESET);
#else
        // FIXME: determine the current code page
        const char* const codeset = "UTF-8";
#endif   // _WIN{32,64}

        fprintf (fp, "<code_set_name> \"%s\"\n", codeset);
        fprintf (fp, "<mb_cur_max> 1\n");
        fprintf (fp, "<mb_cur_min> 1\n");

        fprintf (fp, "CHARMAP\n");

        // write out the charmap above
        for (unsigned i = 0; i != sizeof charmap / sizeof *charmap; ++i) {
            fprintf (fp, "%s \\x%02x\n", charmap [i], i);
        }

        // write out duplicate symbolic names to prevent warnings
        fprintf (fp, "<alert> \\x%02x\n", '\a');
        fprintf (fp, "<hyphen-minus> \\x%02x\n", '-');
        fprintf (fp, "<full-stop> \\x%02x\n", '.');
        fprintf (fp, "<solidus> \\x%02x\n", '/');
        fprintf (fp, "<reverse-solidus> \\x%02x\n", '\\');
        fprintf (fp, "<circumflex-accent> \\x%02x\n", '^');
        fprintf (fp, "<underline> \\x%02x\n", '_');
        fprintf (fp, "<low-line> \\x%02x\n", '_');
        fprintf (fp, "<left-curly-bracket> \\x%02x\n", '{');
        fprintf (fp, "<right-curly-bracket> \\x%02x\n", '}');

        fprintf (fp, "END CHARMAP\n");
    }
}


_TEST_EXPORT
const char* rw_tmpnam (char *buf)
{
#ifndef _RWSTD_NO_MKSTEMP
#  define TMP_TEMPLATE      "tmpfile-XXXXXX"

    if (!buf) {
        static char fname_buf [sizeof (P_tmpdir) + sizeof (TMP_TEMPLATE)];

        buf = fname_buf;
        *buf = '\0';
    }

    if ('\0' == *buf) {
        // copy the template to the buffer; make sure there is exactly
        // one path separator character between P_tmpdir and the file
        // name template (it doesn't really matter how many there are
        // as long as it's at least one, but one looks better than two
        // in diagnostic messages)
        size_t len = sizeof (P_tmpdir) - 1;

        memcpy (buf, P_tmpdir, len);
        if (_RWSTD_PATH_SEP != buf [len - 1])
            buf [len++] = _RWSTD_PATH_SEP;

        memcpy (buf + len, TMP_TEMPLATE, sizeof TMP_TEMPLATE);
    }

    // prevent annoying glibc warnings (issued by the linker):
    // the use of `tmpnam' is dangerous, better use `mkstemp'

    const int fd = mkstemp (buf);

    if (-1 == fd) {
        fprintf (stderr, "%s:%d: mkstemp(\"%s\") failed: %s\n",
                 __FILE__, __LINE__, buf, strerror (errno));
        return 0;
    }

    close (fd);

    const char* const fname = buf;

#  undef TMP_TEMPLATE
#else   // if defined (_RWSTD_NO_MKSTEMP)

#  if defined (_WIN32) || defined (_WIN64)

    // create a temporary file name
    char* fname = tempnam (P_tmpdir, ".rwtest-tmp");

    if (fname) {

        static char tmpbuf [256];

        if (0 == buf)
            buf = tmpbuf;

        _RWSTD_ASSERT (strlen (fname) < sizeof (tmpbuf));

        // copy the generated temporary file name to the provided buffer
        strcpy (buf, fname);

        // free the storage allocated by tempnam()
        free (fname);
        fname = buf;
    }
    else {
        fprintf (stderr, "%s:%d: tempnam(\"%s\", \"%s\") failed: %s\n",
                 __FILE__, __LINE__,
                 P_tmpdir, ".rwtest-tmp", strerror (errno));
    }

#  else
#    if defined (__hpux) && defined (_RWSTD_REENTRANT)

    // on HP-UX, in reentrant mode, tmpnam(0) fails by design

    if (!buf) {
        static char tmpbuf [L_tmpnam];
        buf = tmpbuf;
        *buf = '\0';
    }

#    endif   // __hpux && _REENTRANT

    const char* const fname = tmpnam (buf);

    if (!fname)
        fprintf (stderr, "%s:%d: tmpnam(\"%s\") failed: %s\n",
                 __FILE__, __LINE__, buf, strerror (errno));

#  endif   // _WIN{32,64}
#endif   // _RWSTD_NO_MKSTEMP

    return fname;
}


_TEST_EXPORT
size_t rw_fsize (const char *fname)
{
#if defined (_WIN32) || defined (_WIN64)

    // note: both method of obtaining the size of a file
    // just written by a process may fail (i.e., the size
    // will be 0)

#  if 1

    struct _stat sb;

    if (-1 == _stat (fname, &sb))
        return _RWSTD_SIZE_MAX;

    return sb.st_size;

#  else

    // #include <windows.h> for CreateFile() and GetFileSize()
    const HANDLE hfile =
        CreateFile (fname,
                    GENERIC_READ,
                    0,                     // dwShareMode,
                    0,                     // lpSecurityAttributes,
                    OPEN_EXISTING,         // dwCreationDisposition,
                    FILE_ATTRIBUTE_NORMAL, // dwFlagsAndAttributes,
                    0);                    // hTemplateFile

    if (INVALID_HANDLE_VALUE == hfile)
        return _RWSTD_SIZE_MAX;

    const size_t size = GetFileSize (hfile, 0);

    CloseHandle (hfile);

    return size;

#  endif   // 0/1

#else   // if !defined (_WIN{32,64})

    struct stat sb;

    if (stat (fname, &sb) == -1)
        return _RWSTD_SIZE_MAX;

    return sb.st_size;

#endif   // _WIN{32,64}

}


_TEST_EXPORT
void* rw_fread (const char *fname,
                size_t     *size   /* = 0 */,
                const char *mode   /* = "r" */)
{
    // buffer and size supplied by the user
    static char*  usrbuf = 0;
    static size_t usrsize = 0;

    // when called with 0 file name and non-0 size, set the static
    // local buffer for the functions to use in subsequent calls
    // with non-0 `fname' instead of dynamically allocating a new
    // buffer
    if (!fname && size) {

        char* const oldbuf = usrbuf;

        usrbuf  = _RWSTD_CONST_CAST (char*, mode);
        usrsize = usrbuf ? *size : 0;

        return oldbuf;
    }

    static char   buffer [1024];
    static char*  buf     = usrbuf ? usrbuf : buffer;
    static size_t bufsize = usrbuf ? usrsize : sizeof buffer;

    // open the file in the specified mode
    FILE* const fp = fopen (fname, mode);

    if (!fp)
        return 0;

    for (char *bufend = buf; ; ) {
        // compute the total number of bytes read from the file so far
        // and the number of bytes that are still available in the buffer
        const size_t bytes_read  = size_t (bufend - buf);
        const size_t bytes_avail = bufsize - bytes_read;

        // try to read the contents of the file into the buffer
        const size_t nbytes = fread (bufend, 1, bytes_avail, fp);

        if (0 == nbytes) {
            *bufend = '\0';

            // store the number of bytes read
            if (size)
                *size = bytes_read;

            break;
        }

        if (nbytes == bytes_avail) {

            // do not grow user-specified buffer
            if (buf == usrbuf)
                break;

            const size_t newsize = (bufsize + 1) * 2;

            // increase the size of the buffer and continue reading
            char *tmp = new char [newsize];
            memcpy (tmp, buf, bufsize);

            // deallocate buffer only if it's been
            // previously dynamically allocated
            if (buf != buffer)
                delete[] buf;

            bufsize = newsize;
            bufend  = tmp + bytes_read;
            buf     = tmp;
        }

        bufend += nbytes;
    }

    fclose (fp);

    return buf;
}


_TEST_EXPORT
size_t rw_fwrite (const char *fname,
                  const void *buf,
                  size_t      size /* = -1 */,
                  const char *mode /* = "w" */)
{
    FILE *fp = 0;

    if (buf)
        fp = fopen (fname, mode);
    else {
        remove (fname);
        return 0;
    }

    if (!fp)
        return size_t (-1);

    if (size_t (-1) == size)
        size = strlen (_RWSTD_STATIC_CAST (const char*, buf));

    // fwrite() returns the number of elements successfully written
    // set it up so that the number of elements == the number of bytes
    const size_t nbytes = fwrite (buf, 1 /* byte */, size, fp);

    fclose (fp);

    return nbytes;
}


/************************************************************************/

// get the file descriptor that will be returned by the next call
// to creat() or open() (used to detect file descriptor leaks)
_TEST_EXPORT int
rw_nextfd (int *count)
{
    if (count) {

        *count = 0;

#if defined (_WIN32) || defined (_WIN64)

        for (int i = 0; i != 256; ++i) {

            const int ret = _commit (i);

            if (-1 != ret || EBADF != errno)
                ++*count;
        }
#else   // if not Windoze

        for (int i = 0; i != 256; ++i) {
            if (-1 != fcntl (i, F_GETFD))
                ++*count;
        }

#endif   // WIN{32,64}

    }

    const int fd = open (DEV_NULL, O_RDONLY);

    close (fd);

    return fd;
}