/**************************************************************************
 *
 * Copyright (c) 2013 Alcatel-Lucent
 *
 * Alcatel Lucent 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.  A copy of the License is contained the
 * file LICENSE at the top level of this repository.
 * You may also 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.
 *
 **************************************************************************
 *
 * tfsapi.c:
 *
 * This file contains the portion of TFS that provides the function-level
 * API to the application.  If this is not being used by the application
 * then it can be omitted from the monitor build.
 * Note that not all of the api-specific code is here; some of it is in
 * tfs.c.  This is because the the MicroMonitor uses some of the api itself,
 * so it cannot be omitted from the TFS package without screwing up some
 * other monitor functionality that needs it.
 *
 * Original author:     Ed Sutter (ed.sutter@alcatel-lucent.com)
 *
 */
#include "config.h"
#include "cpu.h"
#include "stddefs.h"
#include "genlib.h"
#include "tfs.h"
#include "tfsprivate.h"
#if INCLUDE_TFSAPI

/* tfstruncate():
 *  To support the ability to truncate a file (make it smaller); this
 *  function allows the user to adjust the high-water point of the currently
 *  opened (and assumed to be opened for modification) file and replaces
 *  that with the incoming argument.  This replacement is only done if the
 *  current high-water point is higher than the incoming length.
 *  MONLIB NOTICE: this function is accessible through monlib.c.
 */
int
tfstruncate(int fd, long len)
{
    struct tfsdat *tdat;

    if(tfsTrace > 1) {
        printf("tfstruncate(%d,%ld)\n",fd,len);
    }

    /* Verify valid range of incoming file descriptor. */
    if((fd < 0) || (fd >= TFS_MAXOPEN)) {
        return(TFSERR_BADFD);
    }

    tdat = &tfsSlots[fd];

    /* Make sure the file pointed to by the incoming descriptor is active
     * and that the incoming length is greater than the current high-water
     * point...
     */
    if(tdat->offset == -1) {
        return(TFSERR_BADFD);
    }
    if(len > tdat->hwp) {
        return(TFSERR_BADARG);
    }

    /* Make the adjustment... */
    tdat->hwp = len;
    return(TFS_OKAY);
}

/* tfseof():
 *  Return 1 if at the end of the file, else 0 if not at end; else negative
 *  if error.
 *  MONLIB NOTICE: this function is accessible through monlib.c.
 */
int
tfseof(int fd)
{
    struct tfsdat *tdat;

    /* Verify valid range of incoming file descriptor. */
    if((fd < 0) || (fd >= TFS_MAXOPEN)) {
        return(TFSERR_BADARG);
    }

    tdat = &tfsSlots[fd];

    /* Make sure the file pointed to by the incoming descriptor is active. */
    if(tdat->offset == -1) {
        return(TFSERR_BADFD);
    }

    if(tdat->offset >= tdat->hdr.filsize) {
        return(1);
    } else {
        return(0);
    }
}

/* tfsread():
 *  Similar to a standard read call to a file.
 *  MONLIB NOTICE: this function is accessible through monlib.c.
 */
int
tfsread(int fd, char *buf, int cnt)
{
    struct tfsdat *tdat;
    uchar *from;

    if(tfsTrace > 1) {
        printf("tfsread(%d,0x%lx,%d)\n",fd,(ulong)buf,cnt);
    }

    /* Verify valid range of incoming file descriptor. */
    if((cnt < 1) || (fd < 0) || (fd >= TFS_MAXOPEN)) {
        return(TFSERR_BADARG);
    }

    tdat = &tfsSlots[fd];

    /* Make sure the file pointed to by the incoming descriptor is active. */
    if(tdat->offset == -1) {
        return(TFSERR_BADFD);
    }

    if(tdat->offset >= tdat->hdr.filsize) {
        return(TFSERR_EOF);
    }

    from = (uchar *) tdat->base + tdat->offset;

    /* If request size is within the range of the file and current
     * then copy the data to the requestors buffer, increment offset
     * and return the count.
     */
    if((tdat->offset + cnt) <= tdat->hdr.filsize) {
        if(s_memcpy((char *)buf, (char *)from, cnt,0,0) != 0) {
            return(TFSERR_MEMFAIL);
        }
    }
    /* If request size goes beyond the size of the file, then copy
     * to the end of the file and return that smaller count.
     */
    else {
        cnt = tdat->hdr.filsize - tdat->offset;
        if(s_memcpy((char *)buf, (char *)from, cnt, 0, 0) != 0) {
            return(TFSERR_MEMFAIL);
        }
    }
    tdat->offset += cnt;
    return(cnt);
}

/* tfswrite():
 *  Similar to a standard write call to a file.
 *  MONLIB NOTICE: this function is accessible through monlib.c.
 */
int
tfswrite(int fd, char *buf, int cnt)
{
    struct tfsdat *tdat;

    if(tfsTrace > 1) {
        printf("tfswrite(%d,0x%lx,%d)\n", fd,(ulong)buf,cnt);
    }

    /* Verify valid range of incoming file descriptor. */
    if((cnt < 1) || (fd < 0) || (fd >= TFS_MAXOPEN)) {
        return(TFSERR_BADARG);
    }

    /* Make sure the file pointed to by the incoming descriptor is active. */
    if(tfsSlots[fd].offset == -1) {
        return(TFSERR_BADARG);
    }

    tdat = &tfsSlots[fd];

    /* Make sure file is not opened as read-only */
    if(tdat->flagmode & TFS_RDONLY) {
        return(TFSERR_RDONLY);
    }

    if(s_memcpy((char *)tdat->base+tdat->offset,(char *)buf,cnt,0,0) != 0) {
        return(TFSERR_MEMFAIL);
    }

    tdat->offset += cnt;

    /* If new offset is greater than current high-water point, then
     * adjust the high water point so that it is always reflecting the
     * highest offset into which the file has had some data written.
     */
    if(tdat->offset > tdat->hwp) {
        tdat->hwp = tdat->offset;
    }

    return(TFS_OKAY);
}

/* tfsseek():
 *  Adjust the current pointer into the specified file.
 *  If file is read-only, then the offset cannot exceed the file size;
 *  otherwise, the only check made to the offset is that it is positive.
 *  MONLIB NOTICE: this function is accessible through monlib.c.
 */
int
tfsseek(int fd, int offset, int whence)
{
    int o_offset;
    struct tfsdat *tdat;

    if(tfsTrace > 1) {
        printf("tfsseek(%d,%d,%d)\n",fd,offset,whence);
    }

    if((fd < 0) || (fd >= TFS_MAXOPEN)) {
        return(TFSERR_BADARG);
    }

    tdat = &tfsSlots[fd];
    o_offset = tdat->offset;

    switch(whence) {
    case TFS_BEGIN:
        tdat->offset = offset;
        break;
    case TFS_CURRENT:
        tdat->offset += offset;
        break;
    default:
        return(TFSERR_BADARG);
    }

    /* If new offset is less than zero or if the file is read-only and the
     * new offset is greater than the file size, return EOF...
     */
    if((tdat->offset < 0) ||
            ((tdat->flagmode & TFS_RDONLY) && (tdat->offset > tdat->hdr.filsize))) {
        tdat->offset = o_offset;
        return(TFSERR_EOF);
    }
    return(tdat->offset);
}

/* tfsipmod():
 *  Modify "in-place" a portion of a file in TFS.
 *  This is a cheap and dirty way to modify a file...
 *  The idea is that a file is created with a lot of writeable flash space
 *  (data = 0xff).  This function can then be called to immediately modify
 *  blocks of space in that flash.  It will not do any tfsunlink/tfsadd, and
 *  it doesn't even require a tfsopen() tfsclose() wrapper.  Its a fast and
 *  efficient way to modify flash in the file system.
 *  Arguments:
 *  name    =   name of the file to be in-place-modified;
 *  buf     =   new data to be written to flash;
 *  offset  =   offset into file into which new data is to be written;
 *  size    =   size of new data (in bytes).
 *
 *  With offset of -1, set offset to location containing first 0xff value.
 *  MONLIB NOTICE: this function is accessible through monlib.c.
 */
int
tfsipmod(char *name,char *buf,int offset,int size)
{
    int     rc;
    TFILE   *fp;
    uchar   *cp;

    fp = tfsstat(name);
    if(!fp) {
        return (TFSERR_NOFILE);
    }
    if(!(fp->flags & TFS_IPMOD)) {
        return(TFSERR_NOTIPMOD);
    }

    if(offset == -1) {
        cp = (uchar *)(TFS_BASE(fp));
        for(offset=0; offset<fp->filsize; offset++,cp++) {
            if(*cp == 0xff) {
                break;
            }
        }
    } else if(offset < -1) {
        return(TFSERR_BADARG);
    }

    if((offset + size) > fp->filsize) {
        return(TFSERR_WRITEMAX);
    }

    /* BUG fixed: 2/21/2001:
     * The (ulong *) cast was done prior to adding offset to the base.
     * This caused the offset to be quadrupled.
     */
    rc = tfsflashwrite((uchar *)(TFS_BASE(fp)+offset),(uchar *)buf,size);
    if(rc != TFS_OKAY) {
        return(rc);
    }

    tfslog(TFSLOG_IPM,name);
    return(TFS_OKAY);
}

/* tfsopen():
 *  Open a file for reading or creation.  If file is opened for writing,
 *  then the caller must provide a RAM buffer  pointer to be used for
 *  the file storage until it is transferred to flash by tfsclose().
 *  Note that the "buf" pointer is only needed for opening a file for
 *  creation or append (writing).
 *  MONLIB NOTICE: this function is accessible through monlib.c.
 */
int
tfsopen(char *file,long flagmode,char *buf)
{
    register int i;
    int     errno, retval;
    long    fmode;
    TFILE   *fp;
    struct  tfsdat *slot;

    errno = TFS_OKAY;

    fmode = flagmode & (TFS_RDONLY | TFS_APPEND | TFS_CREATE | TFS_CREATERM);

    /* See if file exists... */
    fp = tfsstat(file);

    /* If file exists, do a crc32 on the data.
     * If the file is in-place-modifiable, then the only legal flagmode
     * is TFS_RDONLY.  Plus, in this case, the crc32 test is skipped.
     */
    if(fp) {
        if(!((fmode == TFS_RDONLY) && (fp->flags & TFS_IPMOD))) {
            if(crc32((unsigned char *)TFS_BASE(fp),fp->filsize) != fp->filcrc) {
                retval = TFSERR_BADCRC;
                goto done;
            }
        }
    }

    /* This switch verifies...
     * - that the file exists if TFS_RDONLY or TFS_APPEND
     * - that the file does not exist if TFS_CREATE
     */
    switch(fmode) {
    case TFS_RDONLY:    /* Read existing file only, no change to file at all. */
        if(!fp) {
            if(_tfsstat(file,0)) {
                errno = TFSERR_LINKERROR;
            } else {
                errno = TFSERR_NOFILE;
            }
        } else {
            if((fp->flags & TFS_UNREAD) && (TFS_USRLVL(fp) > getUsrLvl())) {
                errno = TFSERR_USERDENIED;
            }
        }
        break;
    case TFS_APPEND:    /* Append to the end of the current file. */
        if(!fp) {
            errno = TFSERR_NOFILE;
        } else {
            if(TFS_USRLVL(fp) > getUsrLvl()) {
                errno = TFSERR_USERDENIED;
            }
        }
        break;
    case TFS_CREATERM:      /* Create a new file, allow tfsadd() to remove */
        fmode = TFS_CREATE; /* it if it exists. */
        break;
    case TFS_CREATE:    /* Create a new file, error if it exists. */
        if(fp) {
            errno = TFSERR_FILEEXISTS;
        }
        break;
    case(TFS_APPEND|TFS_CREATE):    /* If both mode bits are set, clear one */
        if(fp) {                    /* based on the presence of the file. */
            if(TFS_USRLVL(fp) > getUsrLvl()) {
                errno = TFSERR_USERDENIED;
            }
            fmode = TFS_APPEND;
        } else {
            fmode = TFS_CREATE;
        }
        break;
    default:
        errno = TFSERR_BADARG;
        break;
    }

    if(errno != TFS_OKAY) {
        retval = errno;
        goto done;
    }

    /* Find an empty slot...
     */
    slot = tfsSlots;
    for(i=0; i<TFS_MAXOPEN; i++,slot++) {
        if(slot->offset == -1) {
            break;
        }
    }

    /* Populate the slot structure if a slot is found to be
     * available...
     */
    if(i < TFS_MAXOPEN) {
        retval = i;
        slot->hwp = 0;
        slot->offset = 0;
        slot->flagmode = fmode;
        if(fmode & TFS_CREATE) {
            strncpy(slot->hdr.name,file,TFSNAMESIZE);
            slot->flagmode |= (flagmode & TFS_FLAGMASK);
            slot->base = (uchar *)buf;
        } else if(fmode & TFS_APPEND) {
            memcpy((char *)&slot->hdr,(char *)fp,sizeof(struct tfshdr));
            if(s_memcpy((char *)buf,(char *)(TFS_BASE(fp)),
                        fp->filsize,0,0) != 0) {
                retval = TFSERR_MEMFAIL;
                goto done;
            }
            slot->flagmode = fp->flags;
            slot->flagmode |= TFS_APPEND;
            slot->base = (uchar *)buf;
            slot->hwp = fp->filsize;
            slot->offset = fp->filsize;
        } else {
            slot->base = (uchar *)(TFS_BASE(fp));
            memcpy((char *)&slot->hdr,(char *)fp,sizeof(struct tfshdr));
        }
    } else {
        retval = TFSERR_NOSLOT;
    }

done:
    if(tfsTrace > 0) {
        printf("tfsopen(%s,0x%lx,0x%lx)=%d\n",file,flagmode,(ulong)buf,retval);
    }

    return(retval);
}

/* tfsclose():
 *  If the file was opened for reading only, then just close out the
 *  entry in the tfsSlots table.  If the file was opened for creation,
 *  then add it to the tfs list.  Note the additional argument is
 *  only needed for tfsclose() of a newly created file.
 *  info  = additional text describing the file.
 *  MONLIB NOTICE: this function is accessible through monlib.c.
 */
int
tfsclose(int fd,char *info)
{
    int     err;
    struct tfsdat *tdat;

    if(!info) {
        info = "";
    }

    if(tfsTrace > 0) {
        printf("tfsclose(%d,%s)\n",fd,info);
    }

    if((fd < 0) || (fd >= TFS_MAXOPEN)) {
        return(TFSERR_BADARG);
    }

    tdat = &tfsSlots[fd];

    if(tdat->offset == -1) {
        return(TFSERR_BADFD);
    }

    /* Mark the file as closed by setting the offset to -1.
     * Note that this is done prior to potentially calling tfsadd() so
     * that tfsadd() will not think the file is opened and reject the add...
     */
    tdat->offset = -1;

    /* If the file was opened for creation or append, and the hwp
     * (high-water-point) is greater than zero, then add it now.
     *
     * Note regarding hwp==0...
     * In cases where a non-existent file is opened for creation,
     * but then nothing is written to the file, the hwp value will
     * be zero; hence, no need to call tfsadd().
     */
    if((tdat->flagmode & (TFS_CREATE | TFS_APPEND)) && (tdat->hwp > 0)) {
        char    buf[16];

        err = tfsadd(tdat->hdr.name, info, tfsflagsbtoa(tdat->flagmode,buf),
                     tdat->base, tdat->hwp);
        if(err != TFS_OKAY) {
            printf("%s: %s\n",tdat->hdr.name,tfserrmsg(err));
            return(err);
        }
    }
    return(TFS_OKAY);
}

#else /* INCLUDE_TFSAPI */

int
tfstruncate(int fd, long len)
{
    return(TFSERR_NOTAVAILABLE);
}

int
tfseof(int fd)
{
    return(TFSERR_NOTAVAILABLE);
}

int
tfsread(int fd, char *buf, int cnt)
{
    return(TFSERR_NOTAVAILABLE);
}

int
tfswrite(int fd, char *buf, int cnt)
{
    return(TFSERR_NOTAVAILABLE);
}

int
tfsseek(int fd, int offset, int whence)
{
    return(TFSERR_NOTAVAILABLE);
}

int
tfsopen(char *file,long flagmode,char *buf)
{
    return(TFSERR_NOTAVAILABLE);
}

int
tfsclose(int fd,char *info)
{
    return(TFSERR_NOTAVAILABLE);
}

int
tfsipmod(char *name,char *buf,int offset,int size)
{
    return(TFSERR_NOTAVAILABLE);
}

#endif  /* INCLUDE_TFSAPI else */

#if INCLUDE_TFSAPI || INCLUDE_TFSSCRIPT

/* tfsgetline():
 *  Read into the buffer a block of characters upto the next EOL delimiter
 *  the file.  After the EOL, or after max-1 chars are loaded, terminate
 *  with a NULL.  Return the number of characters loaded.
 *  At end of file return 0.
 *  MONLIB NOTICE: this function is accessible through monlib.c.
 */
int
tfsgetline(int fd,char *buf,int max)
{
    uchar   *from;
    int     tot, rtot;
    struct  tfsdat *tdat;
    volatile char   *to;

    max--;

    if(tfsTrace > 1) {
        printf("tfsgetline(%d,0x%lx,%d)\n",fd,(ulong)buf,max);
    }

    /* Verify valid range of incoming file descriptor. */
    if((max < 1) || (fd < 0) || (fd >= TFS_MAXOPEN)) {
        return(TFSERR_BADARG);
    }

    /* Make sure the file pointed to by the incoming descriptor is active. */
    if(tfsSlots[fd].offset == -1) {
        return(TFSERR_BADARG);
    }

    tdat = &tfsSlots[fd];

    if(tdat->offset == -1) {
        return(TFSERR_BADFD);
    }

    if(tdat->offset >= tdat->hdr.filsize) {
        return(0);
    }

    from = (uchar *) tdat->base + tdat->offset;
    to = buf;

    /* If the incoming buffer size is larger than needed, adjust the
     * 'max' value so that we don't pass the end of the file...
     */
    if((tdat->offset + max) > tdat->hdr.filsize) {
        max = tdat->hdr.filsize - tdat->offset + 1;
    }

    /* Read from the file data area until newline (0x0a) is found
     * (or until the 'max buffer space' value is reached).
     * Strip 0x0d (if present) and terminate with NULL  in all cases.
     */
    for(rtot=0,tot=0; tot < max; from++) {
        /* Terminate on Ctrl-Z, non-ASCII, Newline or NULL.
         * Ignore carriage return completely...
         */
        if((*from == 0x1a) || (*from > 0x7f) || (*from == 0)) {
            break;
        }

        tot++;

        if(*from == 0x0d) {
            continue;
        }

        *to = *from;
        if(*to != *from) {
            return(TFSERR_MEMFAIL);
        }

        to++;
        rtot++;

        if(*from == 0x0a) {
            break;
        }
    }
    *to = 0;

    tdat->offset += tot;
    return(rtot);
}

#else

int
tfsgetline(int fd,char *buf,int max)
{
    return(TFSERR_NOTAVAILABLE);
}

#endif