/* Copyright (c) 2000, 2025, Oracle and/or its affiliates.

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License, version 2.0,

   as published by the Free Software Foundation.

   This program is designed to work with certain software (including

   but not limited to OpenSSL) that is licensed under separate terms,

   as designated in a particular file or component or in included license

   documentation.  The authors of MySQL hereby grant you an additional

   permission to link the program and your derivative works with the

   separately licensed software that they have either included with

   the program or referenced in the documentation.

   Without limiting anything contained in the foregoing, this file,

   which is part of C Driver for MySQL (Connector/C), is also subject to the

   Universal FOSS Exception, version 1.0, a copy of which can be found at

   http://oss.oracle.com/licenses/universal-foss-exception.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License, version 2.0, for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA.

*/

/**

  @file mysys/mf_pack.cc

*/

#include "my_config.h"

#include <string>

#include <cstring>

#ifdef _WIN32

#include "mysql/strings/m_ctype.h"

#endif

#include "m_string.h"

#include "my_dbug.h"

#include "my_getpwnam.h"

#include "my_inttypes.h"

#include "my_io.h"

#include "my_sys.h"

#include "mysys/my_static.h"

#include "strmake.h"

static std::string expand_tilde(char **path);

/**

  Remove unwanted chars from dirname.

  Pre-condition: At least FN_REFLEN bytes can be stored in buffer

  pointed to by 'to'. 'from' is a '\0'-terminated byte buffer.

  Post-condition: At most FN_REFLEN bytes will have been written to

  'to'. If the combined length of 'from' and any expanded elements

  exceeds FN_REFLEN-1, the result is truncated and likely not what the

  caller expects.

  IMPLEMENTATION:

  "/../" removes prev dir

  "/~/" removes all before ~

  //" is same as "/", except on Win32 at start of a file

  "/./" is removed

  Unpacks home_dir if "~/.." used

  Unpacks current dir if if "./.." used

  @param to     Store result here

  @param from   Dirname to fix.  May be same as to

  @return length of new name

*/

size_t cleanup_dirname(char *to, const char *from) {

  char *pos;

  const char *from_ptr;

  char *start;

  char parent[5], /* for "FN_PARENTDIR" */

      buff[FN_REFLEN + 1], *end_parentdir;

#ifdef _WIN32

  CHARSET_INFO *fs = fs_character_set();

#endif

  DBUG_TRACE;

  DBUG_PRINT("enter", ("from: '%s'", from));

  start = buff;

  from_ptr = from;

#ifdef FN_DEVCHAR

  {

    const char *dev_pos = strrchr(from_ptr, FN_DEVCHAR);

    if (dev_pos != nullptr) { /* Skip device part */

      const size_t length = (dev_pos - from_ptr) + 1;

      start = my_stpnmov(buff, from_ptr, length);

      from_ptr += length;

    }

  }

#endif

  parent[0] = FN_LIBCHAR;

  const size_t length = my_stpcpy(parent + 1, FN_PARENTDIR) - parent;

  const char *end = start + FN_REFLEN;

  for (pos = start; pos < end && ((*pos = *from_ptr++) != 0); pos++) {

#ifdef _WIN32

    uint l;

    if (use_mb(fs) && (l = my_ismbchar(fs, from_ptr - 1, from_ptr + 2))) {

      for (l--; l; *++pos = *from_ptr++, l--)

        ;

      start = pos + 1; /* Don't look inside multi-byte char */

      continue;

    }

#endif

    if (*pos == '/') *pos = FN_LIBCHAR;

    if (*pos == FN_LIBCHAR) {

      if ((size_t)(pos - start) > length &&

          memcmp(pos - length, parent, length) ==

              0) { /* If .../../; skip prev */

        pos -= length;

        if (pos != start) { /* not /../ */

          pos--;

          if (*pos == FN_HOMELIB && (pos == start || pos[-1] == FN_LIBCHAR)) {

            if (!home_dir) {

              pos += length + 1; /* Don't unpack ~/.. */

              continue;

            }

            pos = my_stpcpy(buff, home_dir) - 1; /* Unpacks ~/.. */

            if (*pos == FN_LIBCHAR) pos--;       /* home ended with '/' */

          }

          if (*pos == FN_CURLIB && (pos == start || pos[-1] == FN_LIBCHAR)) {

            if (my_getwd(curr_dir, FN_REFLEN, MYF(0))) {

              pos += length + 1; /* Don't unpack ./.. */

              continue;

            }

            pos = my_stpcpy(buff, curr_dir) - 1; /* Unpacks ./.. */

            if (*pos == FN_LIBCHAR) pos--;       /* home ended with '/' */

          }

          end_parentdir = pos;

          while (pos >= start && *pos != FN_LIBCHAR) /* remove prev dir */

            pos--;

          if (pos[1] == FN_HOMELIB ||

              (pos >= start &&

               memcmp(pos, parent, length) == 0)) { /* Don't remove ~user/ */

            pos = my_stpcpy(end_parentdir + 1, parent);

            *pos = FN_LIBCHAR;

            continue;

          }

        }

      } else if ((size_t)(pos - start) == length - 1 &&

                 !memcmp(start, parent + 1, length - 1))

        start = pos; /* Starts with "../" */

      else if (pos - start > 0 && pos[-1] == FN_LIBCHAR) {

#ifdef FN_NETWORK_DRIVES

        if (pos - start != 1)

#endif

          pos--; /* Remove duplicate '/' */

      } else if (pos - start > 1 && pos[-1] == FN_CURLIB &&

                 pos[-2] == FN_LIBCHAR)

        pos -= 2; /* Skip /./ */

      else if (pos > buff + 1 && pos[-1] == FN_HOMELIB &&

               pos[-2] == FN_LIBCHAR) { /* Found ..../~/  */

        buff[0] = FN_HOMELIB;

        buff[1] = FN_LIBCHAR;

        start = buff;

        pos = buff + 1;

      }

    }

  }

  buff[FN_REFLEN - 1] = '\0';

  (void)my_stpcpy(to, buff);

  DBUG_PRINT("exit", ("to: '%s'", to));

  return (size_t)(pos - buff);

} /* cleanup_dirname */

/**

  Convert a directory name to a format which can be compared as strings.

  Pre-condition: At least FN_REFLEN bytes can be stored in buffer

  pointed to by 'to'. 'from' is a '\0'-terminated byte buffer.

  Post-condition: At most FN_REFLEN bytes will have been written to

  'to'. If the combined length of 'from' and any expanded elements

  exceeds FN_REFLEN-1, the result is truncated and likely not what the

  caller expects.

  @param to     result buffer, FN_REFLEN chars in length; may be == from

  @param from   'packed' directory name, in whatever format

  @returns      size of the normalized name

  @details

  - Ensures that last char is FN_LIBCHAR, unless it is FN_DEVCHAR

  - Uses cleanup_dirname

  @note It does *not* expand ~/ (although, see cleanup_dirname).  Nor does it do

  any case folding.  All case-insensitive normalization should be done by

  the caller.

*/

size_t normalize_dirname(char *to, const char *from) {

  size_t length;

  char buff[FN_REFLEN];

  DBUG_TRACE;

  /*

    Despite the name, this actually converts the name to the system's

    format (TODO: name this properly).

  */

  (void)intern_filename(buff, from);

  length = strlen(buff); /* Fix that '/' is last */

  if (length &&

#ifdef FN_DEVCHAR

      buff[length - 1] != FN_DEVCHAR &&

#endif

      buff[length - 1] != FN_LIBCHAR && buff[length - 1] != '/') {

    /* we need reserve 2 bytes for the trailing slash and the zero */

    if (length >= sizeof(buff) - 1) length = sizeof(buff) - 2;

    buff[length] = FN_LIBCHAR;

    buff[length + 1] = '\0';

  }

  length = cleanup_dirname(to, buff);

  return length;

}

/**

  Fixes a directory name so that can be used by open().

  Pre-condition: At least FN_REFLEN bytes can be stored in buffer

  pointed to by 'to'. 'from' is a '\0'-terminated byte buffer.

  Post-condition: At most FN_REFLEN bytes will have been written to

  'to'. If the combined length of 'from' and any expanded elements

  exceeds FN_REFLEN-1, the result is truncated and likely not what the

  caller expects.

  @param to     Result buffer, FN_REFLEN characters. May be == from

  @param from   'Packed' directory name (may contain ~)

  @details

  - Uses normalize_dirname()

  - Expands ~/... to home_dir/...

  - Changes a UNIX filename to system filename (replaces / with \ on windows)

  @returns

   Length of new directory name (= length of to)

*/

size_t unpack_dirname(char *to, const char *from) {

  size_t length, h_length;

  char buff[FN_REFLEN + 1 + 4], *suffix;

  DBUG_TRACE;

  length = normalize_dirname(buff, from);

  if (buff[0] == FN_HOMELIB) {

    suffix = buff + 1;

    std::string tilde_expansion = expand_tilde(&suffix);

    if (!tilde_expansion.empty()) {

      length -= (size_t)(suffix - buff) - 1;

      if (length + (h_length = tilde_expansion.length()) <= FN_REFLEN) {

        if ((h_length > 0) && (tilde_expansion.back() == FN_LIBCHAR))

          h_length--;

        memmove(buff + h_length, suffix, length);

        memmove(buff, tilde_expansion.c_str(), h_length);

      }

    }

  }

  return system_filename(to, buff); /* Fix for open */

} /* unpack_dirname */

/**

  Expand tilde to home or user-directory.

  Path is reset to point at FN_LIBCHAR after ~xxx

  @param path pointer to path containing tilde.

  @return home directory.

*/

static std::string expand_tilde(char **path) {

  if (path[0][0] == FN_LIBCHAR)

    return (home_dir ? std::string{home_dir}

                     : std::string{}); /* ~/ expanded to home */

#ifdef HAVE_GETPWNAM

  {

    char *str, save;

    if (!(str = strchr(*path, FN_LIBCHAR))) str = strend(*path);

    save = *str;

    *str = '\0';

    PasswdValue const user_entry = my_getpwnam(*path);

    *str = save;

    if (!user_entry.IsVoid()) {

      *path = str;

      return user_entry.pw_dir;

    }

  }

#endif

  return std::string{};

}

/**

  Fix filename so it can be used by open, create

  Pre-condition: At least FN_REFLEN bytes can be stored in buffer

  pointed to by 'to'. 'from' is a '\0'-terminated byte buffer.

  Post-condition: At most FN_REFLEN bytes will have been written to

  'to'. If the combined length of 'from' and any expanded elements

  exceeds FN_REFLEN-1, the result is truncated and likely not what the

  caller expects.

  @note  to may be == from

  @note  ~ will only be expanded if total length < FN_REFLEN

  @param to   Store result here. Must be at least of size FN_REFLEN.

  @param from Filename in unix format (with ~)

  @return # length of to

*/

size_t unpack_filename(char *to, const char *from) {

  size_t length, n_length, buff_length;

  char buff[FN_REFLEN];

  DBUG_TRACE;

  length = dirname_part(buff, from, &buff_length); /* copy & convert dirname */

  n_length = unpack_dirname(buff, buff);

  if (n_length + strlen(from + length) < FN_REFLEN) {

    (void)my_stpcpy(buff + n_length, from + length);

    length = system_filename(to, buff); /* Fix to usably filename */

  } else

    length = system_filename(to, from); /* Fix to usably filename */

  return length;

} /* unpack_filename */

/**

  Convert filename (unix standard) to system standard

  Used before system command's like open(), create()

  Pre-condition: At least FN_REFLEN bytes can be stored in buffer

  pointed to by 'to'. 'from' is a '\0'-terminated byte buffer.

  Post-condition: At most FN_REFLEN bytes will have been written to

  'to'. If the combined length of 'from' and any expanded elements

  exceeds FN_REFLEN-1, the result is truncated and likely not what the

  caller expects.

  @param to destination buffer.

  @param from source string.

  @return used length of to

*/

size_t system_filename(char *to, const char *from) {

  return (size_t)(strmake(to, from, FN_REFLEN - 1) - to);

}

/**

  Fix a filename to intern (UNIX format).

  Pre-condition: At least FN_REFLEN bytes can be stored in buffer

  pointed to by 'to'. 'from' is a '\0'-terminated byte buffer.

  Post-condition: At most FN_REFLEN bytes will have been written to

  'to'. If the combined length of 'from' and any expanded elements

  exceeds FN_REFLEN-1, the result is truncated and likely not what the

  caller expects.

  @param to destination buffer.

  @param from source string.

  @return to (destination buffer).

*/

char *intern_filename(char *to, const char *from) {

  size_t length, to_length;

  char buff[FN_REFLEN];

  if (from == to) { /* Dirname may destroy from */

    (void)my_stpnmov(buff, from, FN_REFLEN);

    buff[FN_REFLEN - 1] = '\0';  // make sure buff is valid c-string

    from = buff;

  }

  length = dirname_part(to, from, &to_length); /* Copy dirname & fix chars */

  (void)my_stpnmov(to + to_length, from + length, FN_REFLEN - 1 - to_length);

  to[FN_REFLEN - 1] = '\0';  // make sure to is valid c-string

  return (to);

} /* intern_filename */