/** @file

  A brief file description

  @section license License

  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.
 */

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

  ink_file.c

  File manipulation routines for libts

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

#include "libts.h"


int
ink_fputln(FILE * stream, const char *s)
{
  if (stream && s) {
    int rc = fputs(s, stream);
    if (rc > 0)
      rc += fputc('\n', stream);
    return rc;
  }
  else
    return -EINVAL;
}                               /* End ink_fgets */

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

  int ink_file_fd_readline(int fd, int bufsz, char *buf)

  This routine reads bytes from <fd> into the buffer pointed to by <buf>.
  The reading stops when (a) a LF is read into the buffer, (b) the end of
  file is reached, or (c) <bufsz> - 1 bytes are read.  The <bufsz> parameter
  must be >= 2.

  The data pointed to by <buf> is always NUL terminated, and the LF is
  left in the data.  This routine can be used as a replacement for
  fgets-like functions.  If the <bufsz> is too small to hold a complete line,
  the partial line will be stored, and subsequent reads will read more data.

  This routine returns the number of bytes read, 0 on end of file, or
  a negative errno on error.

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

int
ink_file_fd_readline(int fd, int bufsz, char *buf)
{
  char c;
  int i = 0;

  if (bufsz < 2)
    return (-EINVAL);           /* bufsz must by >= 2 */

  while (i < bufsz - 1) {       /* leave 1 byte for NUL */
    int n = read(fd, &c, 1);    /* read 1 byte */
    if (n == 0)
      break;                    /* EOF */
    if (n < 0)
      return (n);               /* error */
    buf[i++] = c;               /* store in buffer */
    if (c == '\n')
      break;                    /* stop if stored a LF */
  }

  buf[i] = '\0';                /* NUL terminate buffer */
  return (i);                   /* number of bytes read */
}                               /* End ink_file_fd_readline */

/* Write until NUL */
int
ink_file_fd_writestring(int fd, const char *buf)
{
  int len, i = 0;

  if (buf && (len = strlen(buf)) > 0 && (i = (int) write(fd, buf, (size_t) len) != len))
    i = -1;

  return i;                     /* return chars written */
}                               /* End ink_file_fd_writestring */

int
ink_filepath_merge(char *path, int pathsz, const char *rootpath,
                   const char *addpath, int flags)
{
  size_t rootlen; // is the length of the src rootpath
  size_t maxlen;  // maximum total path length
  size_t keptlen; // is the length of the retained rootpath
  size_t pathlen; // is the length of the result path
  size_t seglen;  // is the end of the current segment
  char curdir[PATH_MAX];

  /* Treat null as an empty path.
  */
  if (!addpath)
    addpath = "";

  if (addpath[0] == '/') {
    // If addpath is rooted, then rootpath is unused.
    // Ths violates any INK_FILEPATH_SECUREROOTTEST and
    // INK_FILEPATH_NOTABSOLUTE flags specified.
    //
    if (flags & INK_FILEPATH_SECUREROOTTEST)
      return EACCES; // APR_EABOVEROOT;
    if (flags & INK_FILEPATH_NOTABSOLUTE)
      return EISDIR; // APR_EABSOLUTE;

    // If INK_FILEPATH_NOTABOVEROOT wasn't specified,
    // we won't test the root again, it's ignored.
    // Waste no CPU retrieving the working path.
    //
    if (!rootpath && !(flags & INK_FILEPATH_NOTABOVEROOT))
      rootpath = "";
  }
  else {
    // If INK_FILEPATH_NOTABSOLUTE is specified, the caller
    // requires a relative result.  If the rootpath is
    // ommitted, we do not retrieve the working path,
    // if rootpath was supplied as absolute then fail.
    //
    if (flags & INK_FILEPATH_NOTABSOLUTE) {
      if (!rootpath)
        rootpath = "";
      else if (rootpath[0] == '/')
        return EISDIR; //APR_EABSOLUTE;
    }
  }
  if (!rootpath) {
    // Start with the current working path.  This is bass akwards,
    // but required since the compiler (at least vc) doesn't like
    // passing the address of a char const* for a char** arg.
    //
    if (!getcwd(curdir, sizeof(curdir))) {
      return errno;
    }
    rootpath = curdir;
  }
  rootlen = strlen(rootpath);
  maxlen = rootlen + strlen(addpath) + 4; // 4 for slashes at start, after
                                          // root, and at end, plus trailing
                                          // null
  if (maxlen > (size_t)pathsz) {
    return E2BIG; //APR_ENAMETOOLONG;
  }
  if (addpath[0] == '/') {
    // Ignore the given root path, strip off leading
    // '/'s to a single leading '/' from the addpath,
    // and leave addpath at the first non-'/' character.
    //
    keptlen = 0;
    while (addpath[0] == '/')
      ++addpath;
    path[0] = '/';
    pathlen = 1;
  }
  else {
    // If both paths are relative, fail early
    //
    if (rootpath[0] != '/' && (flags & INK_FILEPATH_NOTRELATIVE))
      return EBADF; //APR_ERELATIVE;

    // Base the result path on the rootpath
    //
    keptlen = rootlen;
    memcpy(path, rootpath, rootlen);

    // Always '/' terminate the given root path
    //
    if (keptlen && path[keptlen - 1] != '/') {
      path[keptlen++] = '/';
    }
    pathlen = keptlen;
  }

  while (*addpath) {
    // Parse each segment, find the closing '/'
    //
    const char *next = addpath;
    while (*next && (*next != '/')) {
      ++next;
    }
    seglen = next - addpath;

    if (seglen == 0 || (seglen == 1 && addpath[0] == '.')) {
      // noop segment (/ or ./) so skip it
      //
    }
    else if (seglen == 2 && addpath[0] == '.' && addpath[1] == '.') {
      // backpath (../)
      if (pathlen == 1 && path[0] == '/') {
        // Attempt to move above root.  Always die if the
        // INK_FILEPATH_SECUREROOTTEST flag is specified.
        //
        if (flags & INK_FILEPATH_SECUREROOTTEST) {
          return EACCES; //APR_EABOVEROOT;
        }

        // Otherwise this is simply a noop, above root is root.
        // Flag that rootpath was entirely replaced.
        //
        keptlen = 0;
      }
      else if (pathlen == 0
               || (pathlen == 3
               && !memcmp(path + pathlen - 3, "../", 3))
               || (pathlen  > 3
               && !memcmp(path + pathlen - 4, "/../", 4))) {
        // Path is already backpathed or empty, if the
        // INK_FILEPATH_SECUREROOTTEST.was given die now.
        //
        if (flags & INK_FILEPATH_SECUREROOTTEST) {
          return EACCES; //APR_EABOVEROOT;
        }

        // Otherwise append another backpath, including
        // trailing slash if present.
        //
        memcpy(path + pathlen, "../", *next ? 3 : 2);
        pathlen += *next ? 3 : 2;
      }
      else {
        // otherwise crop the prior segment
        //
        do {
            --pathlen;
        } while (pathlen && path[pathlen - 1] != '/');
      }

      // Now test if we are above where we started and back up
      // the keptlen offset to reflect the added/altered path.
      //
      if (pathlen < keptlen) {
        if (flags & INK_FILEPATH_SECUREROOTTEST) {
          return EACCES; //APR_EABOVEROOT;
        }
        keptlen = pathlen;
      }
    }
    else {
        // An actual segment, append it to the destination path
        //
      if (*next) {
        seglen++;
      }
      memcpy(path + pathlen, addpath, seglen);
      pathlen += seglen;
    }

    // Skip over trailing slash to the next segment
    //
    if (*next) {
      ++next;
    }

    addpath = next;
  }
  path[pathlen] = '\0';
  if (pathlen > 1 && path[pathlen - 1] == '/') {
    // Trim trailing slash unless requested
    size_t es = strlen(addpath);
    if (es == 0 || addpath[es - 1] != '/') {
      --pathlen;
      path[pathlen] = '\0';
    }
  }

  // keptlen will be the rootlen unless the addpath contained
  // backpath elements.  If so, and INK_FILEPATH_NOTABOVEROOT
  // is specified (INK_FILEPATH_SECUREROOTTEST was caught above),
  // compare the original root to assure the result path is
  // still within given root path.
  //
  if ((flags & INK_FILEPATH_NOTABOVEROOT) && keptlen < rootlen) {
    if (strncmp(rootpath, path, rootlen)) {
      return EACCES; //APR_EABOVEROOT;
    }
    if (rootpath[rootlen - 1] != '/'
        && path[rootlen] && path[rootlen] != '/') {
      return EACCES; //APR_EABOVEROOT;
    }
  }

  return 0;
}

int
ink_filepath_make(char *path, int pathsz, const char *rootpath,
                  const char *addpath)
{
  size_t rootlen; // is the length of the src rootpath
  size_t maxlen;  // maximum total path length

  /* Treat null as an empty path.
  */
  if (!addpath)
    addpath = "";

  if (addpath[0] == '/') {
    // If addpath is rooted, then rootpath is unused.
    ink_strncpy(path, addpath, pathsz);
    return 0;
  }
  if (!rootpath || !*rootpath) {
    // If there's no rootpath return the addpath
    ink_strncpy(path, addpath, pathsz);
    return 0;
  }
  rootlen = strlen(rootpath);
  maxlen  = strlen(addpath) + 2;
  if (maxlen > (size_t)pathsz) {
    *path = '\0';
    return (int)maxlen;
  }
  strcpy(path, rootpath);
  path += rootlen;
  if (*(path - 1) != '/')
    *(path++) = '/';
  strcpy(path, addpath);
  return 0;
}