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

                                 pmfileio.c

***************************************************************************

  This file contains fundamental file I/O stuff for libnetpbm.

  These are external functions, unlike 'fileio.c', but are not

  particular to any Netpbm format.

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

#define _DEFAULT_SOURCE /* New name for SVID & BSD source defines */

#define _SVID_SOURCE

    /* Make sure P_tmpdir is defined in GNU libc 2.0.7 (_XOPEN_SOURCE 500

       does it in other libc's).  pm_config.h defines TMPDIR as P_tmpdir

       in some environments.

    */

#define _BSD_SOURCE    /* Make sure strdup is defined */

#define _XOPEN_SOURCE 500    /* Make sure ftello, fseeko, strdup are defined */

#define _LARGEFILE_SOURCE 1  /* Make sure ftello, fseeko are defined */

#define _LARGEFILE64_SOURCE 1 

#define _FILE_OFFSET_BITS 64

    /* This means ftello() is really ftello64() and returns a 64 bit file

       position.  Unless the C library doesn't have ftello64(), in which 

       case ftello() is still just ftello().

       Likewise for all the other C library file functions.

       And off_t and fpos_t are 64 bit types instead of 32.  Consequently,

       pm_filepos_t might be 64 bits instead of 32.

    */

#define _LARGE_FILES  

    /* This does for AIX what _FILE_OFFSET_BITS=64 does for GNU */

#define _LARGE_FILE_API

    /* This makes the the x64() functions available on AIX */

#include "netpbm/pm_config.h"

#include <unistd.h>

#include <assert.h>

#include <stdio.h>

#include <fcntl.h>

#include <stdarg.h>

#include <string.h>

#include <errno.h>

#if HAVE_IO_H

  #include <io.h>  /* For mktemp */

#endif

#include "netpbm/pm_c_util.h"

#include "netpbm/mallocvar.h"

#include "netpbm/nstring.h"

#include "pm.h"

/* File open/close that handles "-" as stdin/stdout and checks errors. */

FILE *

pm_openr(const char * const name) {

    FILE * f;

    if (streq(name, "-"))

        f = stdin;

    else {

        f = fopen(name, "rb");

        if (f == NULL) 

            pm_error("Unable to open file '%s' for reading.  "

                     "fopen() returns errno %d (%s)", 

                     name, errno, strerror(errno));

    }

    return f;

}

FILE *

pm_openw(const char * const name) {

    FILE * f;

    if (streq(name, "-"))

        f = stdout;

    else {

        f = fopen(name, "wb");

        if (f == NULL) 

            pm_error("Unable to open file '%s' for writing.  "

                     "fopen() returns errno %d (%s)", 

                     name, errno, strerror(errno));

    }

    return f;

}

static const char *

tmpDir(void) {

/*----------------------------------------------------------------------------

   Return the name of the directory in which we should create temporary

   files.

   The name is a constant in static storage.

-----------------------------------------------------------------------------*/

    const char * tmpdir;

        /* running approximation of the result */

    tmpdir = getenv("TMPDIR");   /* Unix convention */

    if (!tmpdir || strlen(tmpdir) == 0)

        tmpdir = getenv("TMP");  /* Windows convention */

    if (!tmpdir || strlen(tmpdir) == 0)

        tmpdir = getenv("TEMP"); /* Windows convention */

    if (!tmpdir || strlen(tmpdir) == 0)

        tmpdir = TMPDIR;

    return tmpdir;

}

static int

tempFileOpenFlags(void) {

/*----------------------------------------------------------------------------

  Open flags (argument to open()) suitable for a new temporary file  

-----------------------------------------------------------------------------*/

    int retval;

    retval = 0

        | O_CREAT

        | O_RDWR

#if !MSVCRT

        | O_EXCL

#endif

#if MSVCRT

        | O_BINARY

#endif

        ;

    return retval;

}

static int

mkstempx(char * const filenameBuffer) {

/*----------------------------------------------------------------------------

  This is meant to be equivalent to POSIX mkstemp().

  On some old systems, mktemp() is a security hazard that allows a hacker

  to read or write our temporary file or cause us to read or write some

  unintended file.  On other systems, mkstemp() does not exist.

  A Windows/mingw environment is one which doesn't have mkstemp()

  (2006.06.15).

  We assume that if a system doesn't have mkstemp() that its mktemp()

  is safe, or that the total situation is such that the problems of

  mktemp() are not a problem for the user.

-----------------------------------------------------------------------------*/

    int retval;

    int fd;

    unsigned int attempts;

    bool gotFile;

    bool error;

    for (attempts = 0, gotFile = FALSE, error = FALSE;

         !gotFile && !error && attempts < 100;

         ++attempts) {

        char * rc;

        rc = mktemp(filenameBuffer);

        if (rc == NULL)

            error = TRUE;

        else {

            int rc;

            rc = open(filenameBuffer, tempFileOpenFlags(),

                      PM_S_IWUSR | PM_S_IRUSR);

            if (rc >= 0) {

                fd = rc;

                gotFile = TRUE;

            } else {

                if (errno == EEXIST) {

                    /* We'll just have to keep trying */

                } else 

                    error = TRUE;

            }

        }

    }    

    if (gotFile)

        retval = fd;

    else

        retval = -1;

    return retval;

}

static int

mkstemp2(char * const filenameBuffer) {

#if HAVE_MKSTEMP

    if (0)

        mkstempx(NULL);  /* defeat compiler unused function warning */

    return mkstemp(filenameBuffer);

#else

    return mkstempx(filenameBuffer);

#endif

}

static void

makeTmpfileWithTemplate(const char *  const filenameTemplate,

                        int *         const fdP,

                        const char ** const filenameP,

                        const char ** const errorP) {

    char * filenameBuffer;  /* malloc'ed */

    filenameBuffer = strdup(filenameTemplate);

    if (filenameBuffer == NULL)

        pm_asprintf(errorP, "Unable to allocate storage for temporary "

                    "file name");

    else {

        int rc;

        rc = mkstemp2(filenameBuffer);

        if (rc < 0)

            pm_asprintf(errorP,

                        "Unable to create temporary file according to name "

                        "pattern '%s'.  mkstemp() failed with errno %d (%s)",

                        filenameTemplate, errno, strerror(errno));

        else {

            *fdP = rc;

            *filenameP = filenameBuffer;

            *errorP = NULL;

        }

        if (*errorP)

            pm_strfree(filenameBuffer);

    }

}

void

pm_make_tmpfile_fd(int *         const fdP,

                   const char ** const filenameP) {

    const char * filenameTemplate;

    const char * tmpdir;

    const char * dirseparator;

    const char * error;

    tmpdir = tmpDir();

    if (tmpdir[strlen(tmpdir) - 1] == '/')

        dirseparator = "";

    else

        dirseparator = "/";

    pm_asprintf(&filenameTemplate, "%s%s%s%s", 

                tmpdir, dirseparator, pm_progname, "_XXXXXX");

    if (filenameTemplate == pm_strsol)

        pm_asprintf(&error,

                    "Unable to allocate storage for temporary file name");

    else {

        makeTmpfileWithTemplate(filenameTemplate, fdP, filenameP, &error);

        pm_strfree(filenameTemplate);

    }

    if (error) {

        pm_errormsg("%s", error);

        pm_strfree(error);

        pm_longjmp();

    }

}

void

pm_make_tmpfile(FILE **       const filePP,

                const char ** const filenameP) {

    int fd;

    pm_make_tmpfile_fd(&fd, filenameP);

    *filePP = fdopen(fd, "w+b");

    if (*filePP == NULL) {

        close(fd);

        unlink(*filenameP);

        pm_strfree(*filenameP);

        pm_error("Unable to create temporary file.  "

                 "fdopen() failed with errno %d (%s)",

                 errno, strerror(errno));

    }

}

bool const canUnlinkOpen = 

#if CAN_UNLINK_OPEN

    1

#else

    0

#endif

    ;

typedef struct UnlinkListEntry {

/*----------------------------------------------------------------------------

   This is an entry in the linked list of files to close and unlink as the

   program exits.

-----------------------------------------------------------------------------*/

    struct UnlinkListEntry * next;

    int                      fd;

    char                     fileName[1];  /* Actually variable length */

} UnlinkListEntry;

static UnlinkListEntry * unlinkListP;

static void

unlinkTempFiles(void) {

/*----------------------------------------------------------------------------

  Close and unlink (so presumably delete) the files in the list

  *unlinkListP.

  This is an atexit function.

-----------------------------------------------------------------------------*/

    while (unlinkListP) {

        UnlinkListEntry * const firstEntryP = unlinkListP;

        unlinkListP = unlinkListP->next;

        close(firstEntryP->fd);

        unlink(firstEntryP->fileName);

        free(firstEntryP);

    }

}

static UnlinkListEntry *

newUnlinkListEntry(const char * const fileName,

                   int          const fd) {

    UnlinkListEntry * const unlinkListEntryP =

        malloc(sizeof(*unlinkListEntryP) + strlen(fileName) + 1);

    if (unlinkListEntryP) {

        strcpy(unlinkListEntryP->fileName, fileName);

        unlinkListEntryP->fd   = fd;

        unlinkListEntryP->next = NULL;

    }

    return unlinkListEntryP;

}

static void

addUnlinkListEntry(const char * const fileName,

                   int          const fd) {

    UnlinkListEntry * const unlinkListEntryP =

        newUnlinkListEntry(fileName, fd);

    if (unlinkListEntryP) {

        unlinkListEntryP->next = unlinkListP;

        unlinkListP = unlinkListEntryP;

    }

}

static void

scheduleUnlinkAtExit(const char * const fileName,

                     int          const fd) {

/*----------------------------------------------------------------------------

   Set things up to have the file unlinked as the program exits.

   This is messy and probably doesn't work in all situations; it is a hack

   to get Unix code essentially working on Windows, without messing up the

   code too badly for Unix.

-----------------------------------------------------------------------------*/

    static bool unlinkListEstablished = false;

    if (!unlinkListEstablished) {

        atexit(unlinkTempFiles);

        unlinkListP = NULL;

        unlinkListEstablished = true;

    }

    addUnlinkListEntry(fileName, fd);

}

static void

arrangeUnlink(const char * const fileName,

              int          const fd) {

    if (canUnlinkOpen)

        unlink(fileName);

    else

        scheduleUnlinkAtExit(fileName, fd);

}

FILE * 

pm_tmpfile(void) {

    FILE * fileP;

    const char * tmpfileNm;

    pm_make_tmpfile(&fileP, &tmpfileNm);

    arrangeUnlink(tmpfileNm, fileno(fileP));

    pm_strfree(tmpfileNm);

    return fileP;

}

int

pm_tmpfile_fd(void) {

    int fd;

    const char * tmpfileNm;

    pm_make_tmpfile_fd(&fd, &tmpfileNm);

    arrangeUnlink(tmpfileNm, fd);

    pm_strfree(tmpfileNm);

    return fd;

}

FILE *

pm_openr_seekable(const char name[]) {

/*----------------------------------------------------------------------------

  Open the file named by name[] such that it is seekable (i.e. it can be

  rewound and read in multiple passes with fseek()).

  If the file is actually seekable, this reduces to the same as

  pm_openr().  If not, we copy the named file to a temporary file

  and return that file's stream descriptor.

  We use a file that the operating system recognizes as temporary, so

  it picks the filename and deletes the file when Caller closes it.

-----------------------------------------------------------------------------*/

    int stat_rc;

    int seekable;  /* logical: file is seekable */

    struct stat statbuf;

    FILE * original_file;

    FILE * seekable_file;

    original_file = pm_openr((char *) name);

    /* I would use fseek() to determine if the file is seekable and 

       be a little more general than checking the type of file, but I

       don't have reliable information on how to do that.  I have seen

       streams be partially seekable -- you can, for example seek to

       0 if the file is positioned at 0 but you can't actually back up

       to 0.  I have seen documentation that says the errno for an

       unseekable stream is EBADF and in practice seen ESPIPE.

       On the other hand, regular files are always seekable and even if

       some other file is, it doesn't hurt much to assume it isn't.

    */

    stat_rc = fstat(fileno(original_file), &statbuf);

    if (stat_rc == 0 && S_ISREG(statbuf.st_mode))

        seekable = TRUE;

    else 

        seekable = FALSE;

    if (seekable) {

        seekable_file = original_file;

    } else {

        seekable_file = pm_tmpfile();

        /* Copy the input into the temporary seekable file */

        while (!feof(original_file) && !ferror(original_file) 

               && !ferror(seekable_file)) {

            char buffer[4096];

            int bytes_read;

            bytes_read = fread(buffer, 1, sizeof(buffer), original_file);

            fwrite(buffer, 1, bytes_read, seekable_file);

        }

        if (ferror(original_file))

            pm_error("Error reading input file into temporary file.  "

                     "Errno = %s (%d)", strerror(errno), errno);

        if (ferror(seekable_file))

            pm_error("Error writing input into temporary file.  "

                     "Errno = %s (%d)", strerror(errno), errno);

        pm_close(original_file);

        {

            int seek_rc;

            seek_rc = fseek(seekable_file, 0, SEEK_SET);

            if (seek_rc != 0)

                pm_error("fseek() failed to rewind temporary file.  "

                         "Errno = %s (%d)", strerror(errno), errno);

        }

    }

    return seekable_file;

}

void

pm_close(FILE * const f) {

    fflush(f);

    if (ferror(f))

        pm_message("A file read or write error occurred at some point");

    if (f != stdin)

        if (fclose(f) != 0)

            pm_error("close of file failed with errno %d (%s)",

                     errno, strerror(errno));

}

/* The pnmtopng package uses pm_closer() and pm_closew() instead of 

   pm_close(), apparently because the 1999 Pbmplus package has them.

   I don't know what the difference is supposed to be.

*/

void

pm_closer(FILE * const f) {

    pm_close(f);

}

void

pm_closew(FILE * const f) {

    pm_close(f);

}

/* Endian I/O.

   Before Netpbm 10.27 (March 2005), these would return failure on EOF

   or I/O failure.  For backward compatibility, they still have the return

   code, but it is always zero and the routines abort the program in case

   of EOF or I/O failure.  A program that wants to handle failure differently

   must use lower level (C library) interfaces.  But that level of detail

   is uncharacteristic of a Netpbm program; the ease of programming that

   comes with not checking a return code is more Netpbm.

   It is also for historical reasons that these return signed values,

   when clearly unsigned would make more sense.

*/

static void

abortWithReadError(FILE * const ifP) {

    if (feof(ifP))

        pm_error("Unexpected end of input file");

    else

        pm_error("Error (not EOF) reading file.");

}

static unsigned char

getcNofail(FILE * const ifP) {

    int c;

    c = getc(ifP);

    if (c == EOF)

        abortWithReadError(ifP);

    return (unsigned char)c;

}

void

pm_readchar(FILE * const ifP,

            char * const cP) {

    *cP = (char)getcNofail(ifP);

}

void

pm_writechar(FILE * const ofP,

             char   const c) {

    putc(c, ofP);

}

int

pm_readbigshort(FILE *  const ifP, 

                short * const sP) {

    unsigned short s;

    s  = getcNofail(ifP) << 8;

    s |= getcNofail(ifP) << 0;

    *sP = s;

    return 0;

}

int

pm_writebigshort(FILE * const ofP, 

                 short  const s) {

    putc((s >> 8) & 0xff, ofP);

    putc(s & 0xff, ofP);

    return 0;

}

int

pm_readbiglong(FILE * const ifP, 

               long * const lP) {

    unsigned long l;

    l  = getcNofail(ifP) << 24;

    l |= getcNofail(ifP) << 16;

    l |= getcNofail(ifP) <<  8;

    l |= getcNofail(ifP) <<  0;

    *lP = l;

    return 0;

}

int

pm_readbiglong2(FILE *    const ifP,

                int32_t * const lP) {

    int rc;

    long l;

    rc = pm_readbiglong(ifP, &l);

    assert((int32_t)l == l);

    *lP = (int32_t)l;

    return rc;

}

int

pm_writebiglong(FILE * const ofP, 

                long   const l) {

    putc((l >> 24) & 0xff, ofP);

    putc((l >> 16) & 0xff, ofP);

    putc((l >>  8) & 0xff, ofP);

    putc((l >>  0) & 0xff, ofP);

    return 0;

}

int

pm_readlittleshort(FILE *  const ifP, 

                   short * const sP) {

    unsigned short s;

    s  = getcNofail(ifP) << 0;

    s |= getcNofail(ifP) << 8;

    *sP = s;

    return 0;

}

int

pm_writelittleshort(FILE * const ofP, 

                    short  const s) {

    putc((s >> 0) & 0xff, ofP);

    putc((s >> 8) & 0xff, ofP);

    return 0;

}

int

pm_readlittlelong(FILE * const ifP, 

                  long * const lP) {

    unsigned long l;

    l  = getcNofail(ifP) <<  0;

    l |= getcNofail(ifP) <<  8;

    l |= getcNofail(ifP) << 16;

    l |= getcNofail(ifP) << 24;

    *lP = l;

    return 0;

}

int

pm_readlittlelong2(FILE *    const ifP,

                   int32_t * const lP) {

    int rc;

    long l;

    rc = pm_readlittlelong(ifP, &l);

    assert((int32_t)l == l);

    *lP = (int32_t)l;

    return rc;

}

int

pm_writelittlelong(FILE * const ofP, 

                   long   const l) {

    putc((l >>  0) & 0xff, ofP);

    putc((l >>  8) & 0xff, ofP);

    putc((l >> 16) & 0xff, ofP);

    putc((l >> 24) & 0xff, ofP);

    return 0;

}

int 

pm_readmagicnumber(FILE * const ifP) {

    int ich1, ich2;

    ich1 = getc(ifP);

    if (ich1 == EOF)

        pm_error("Error reading first byte of what is expected to be "

                 "a Netpbm magic number.  "

                 "Most often, this means your input file is empty");

    ich2 = getc(ifP);

    if (ich2 == EOF)

        pm_error("Error reading second byte of what is expected to be "

                 "a Netpbm magic number (the first byte was successfully "

                 "read as 0x%02x)", ich1);

    return ich1 * 256 + ich2;

}

/* Read a file of unknown size to a buffer. Return the number of bytes

   read. Allocate more memory as we need it. The calling routine has

   to free() the buffer.

   Oliver Trepte, oliver@fysik4.kth.se, 930613

*/

#define PM_BUF_SIZE 16384      /* First try this size of the buffer, then

                                  double this until we reach PM_MAX_BUF_INC */

#define PM_MAX_BUF_INC 65536   /* Don't allocate more memory in larger blocks

                                  than this. */

char *

pm_read_unknown_size(FILE * const file, 

                     long * const nread) {

    long nalloc;

    char * buf;

    bool eof;

    *nread = 0;

    nalloc = PM_BUF_SIZE;

    MALLOCARRAY(buf, nalloc);

    eof = FALSE;  /* initial value */

    while(!eof) {

        int val;

        if (*nread >= nalloc) { /* We need a larger buffer */

            if (nalloc > PM_MAX_BUF_INC)

                nalloc += PM_MAX_BUF_INC;

            else

                nalloc += nalloc;

            REALLOCARRAY_NOFAIL(buf, nalloc);

        }

        val = getc(file);

        if (val == EOF)

            eof = TRUE;

        else 

            buf[(*nread)++] = val;

    }

    return buf;

}

union cheat {

    uint32_t l;

    short s;

    unsigned char c[4];

};

short

pm_bs_short(short const s) {

    union cheat u;

    unsigned char t;

    u.s = s;

    t = u.c[0];

    u.c[0] = u.c[1];

    u.c[1] = t;

    return u.s;

}

long

pm_bs_long(long const l) {

    union cheat u;

    unsigned char t;

    u.l = l;

    t = u.c[0];

    u.c[0] = u.c[3];

    u.c[3] = t;

    t = u.c[1];

    u.c[1] = u.c[2];

    u.c[2] = t;

    return u.l;

}