/*

   +----------------------------------------------------------------------+

   | Copyright (c) The PHP Group                                          |

   +----------------------------------------------------------------------+

   | This source file is subject to version 3.01 of the PHP license,      |

   | that is bundled with this package in the file LICENSE, and is        |

   | available through the world-wide-web at the following url:           |

   | https://www.php.net/license/3_01.txt                                 |

   | If you did not receive a copy of the PHP license and are unable to   |

   | obtain it through the world-wide-web, please send a note to          |

   | license@php.net so we can mail you a copy immediately.               |

   +----------------------------------------------------------------------+

   | Author: Zeev Suraski <zeev@php.net>                                  |

   +----------------------------------------------------------------------+

 */

#include "php.h"

#include "zend_long.h"

#include "php_open_temporary_file.h"

#include "ext/random/php_random.h"

#include "zend_operators.h"

#include <errno.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#ifdef PHP_WIN32

#define O_RDONLY _O_RDONLY

#include "win32/param.h"

#include "win32/winutil.h"

#else

#include <sys/param.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <netdb.h>

#ifdef HAVE_ARPA_INET_H

#include <arpa/inet.h>

#endif

#endif

#ifdef HAVE_SYS_TIME_H

#include <sys/time.h>

#endif

#ifdef HAVE_SYS_FILE_H

#include <sys/file.h>

#endif

#if !defined(P_tmpdir)

#define P_tmpdir ""

#endif

/* {{{ php_do_open_temporary_file */

/* Loosely based on a tempnam() implementation by UCLA */

/*

 * Copyright (c) 1988, 1993

 *      The Regents of the University of California.  All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. All advertising materials mentioning features or use of this software

 *    must display the following acknowledgement:

 *      This product includes software developed by the University of

 *      California, Berkeley and its contributors.

 * 4. Neither the name of the University nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 */

static const char base32alphabet[] = "0123456789abcdefghijklmnopqrstuv";

static int php_do_open_temporary_file(const char *path, const char *pfx, zend_string **opened_path_p)

{

#ifdef PHP_WIN32

  char *opened_path = NULL;

  size_t opened_path_len;

  wchar_t *cwdw, *random_prefix_w, pathw[MAXPATHLEN];

#else

  char opened_path[MAXPATHLEN];

  char *trailing_slash;

#endif

  uint64_t random;

  char *random_prefix;

  char *p;

  size_t len;

  char cwd[MAXPATHLEN];

  cwd_state new_state;

  int fd = -1;

#ifndef HAVE_MKSTEMP

  int open_flags = O_CREAT | O_TRUNC | O_RDWR

#ifdef PHP_WIN32

    | _O_BINARY

#endif

    ;

#endif

  if (!path || !path[0]) {

    return -1;

  }

#ifdef PHP_WIN32

  if (!php_win32_check_trailing_space(pfx, strlen(pfx))) {

    SetLastError(ERROR_INVALID_NAME);

    return -1;

  }

#endif

  if (!VCWD_GETCWD(cwd, MAXPATHLEN)) {

    cwd[0] = '\0';

  }

  new_state.cwd = estrdup(cwd);

  new_state.cwd_length = strlen(cwd);

  if (virtual_file_ex(&new_state, path, NULL, CWD_REALPATH)) {

    efree(new_state.cwd);

    return -1;

  }

  /* Extend the prefix to increase randomness */

  if (php_random_bytes_silent(&random, sizeof(random)) == FAILURE) {

    random = php_random_generate_fallback_seed();

  }

  /* Use a compact encoding to not increase the path len too much, but do not

   * mix case to avoid losing randomness on case-insensitive file systems */

  len = strlen(pfx) + 13 /* log(2**64)/log(strlen(base32alphabet)) */ + 1;

  random_prefix = emalloc(len);

  p = zend_mempcpy(random_prefix, pfx, strlen(pfx));

  while (p + 1 < random_prefix + len) {

    *p = base32alphabet[random % strlen(base32alphabet)];

    p++;

    random /= strlen(base32alphabet);

  }

  *p = '\0';

#ifndef PHP_WIN32

  if (IS_SLASH(new_state.cwd[new_state.cwd_length - 1])) {

    trailing_slash = "";

  } else {

    trailing_slash = "/";

  }

  if (snprintf(opened_path, MAXPATHLEN, "%s%s%sXXXXXX", new_state.cwd, trailing_slash, random_prefix) >= MAXPATHLEN) {

    efree(random_prefix);

    efree(new_state.cwd);

    return -1;

  }

#endif

#ifdef PHP_WIN32

  cwdw = php_win32_ioutil_any_to_w(new_state.cwd);

  random_prefix_w = php_win32_ioutil_any_to_w(random_prefix);

  if (!cwdw || !random_prefix_w) {

    free(cwdw);

    free(random_prefix_w);

    efree(random_prefix);

    efree(new_state.cwd);

    return -1;

  }

  if (GetTempFileNameW(cwdw, random_prefix_w, 0, pathw)) {

    opened_path = php_win32_ioutil_conv_w_to_any(pathw, PHP_WIN32_CP_IGNORE_LEN, &opened_path_len);

    if (!opened_path || opened_path_len >= MAXPATHLEN) {

      free(cwdw);

      free(random_prefix_w);

      efree(random_prefix);

      efree(new_state.cwd);

      return -1;

    }

    assert(strlen(opened_path) == opened_path_len);

    /* Some versions of windows set the temp file to be read-only,

     * which means that opening it will fail... */

    if (VCWD_CHMOD(opened_path, 0600)) {

      free(cwdw);

      free(random_prefix_w);

      efree(random_prefix);

      efree(new_state.cwd);

      free(opened_path);

      return -1;

    }

    fd = VCWD_OPEN_MODE(opened_path, open_flags, 0600);

  }

  free(cwdw);

  free(random_prefix_w);

#elif defined(HAVE_MKSTEMP)

  fd = mkstemp(opened_path);

#else

  if (mktemp(opened_path)) {

    fd = VCWD_OPEN(opened_path, open_flags);

  }

#endif

#ifdef PHP_WIN32

  if (fd != -1 && opened_path_p) {

    *opened_path_p = zend_string_init(opened_path, opened_path_len, 0);

  }

  free(opened_path);

#else

  if (fd != -1 && opened_path_p) {

    *opened_path_p = zend_string_init(opened_path, strlen(opened_path), 0);

  }

#endif

  efree(new_state.cwd);

  efree(random_prefix);

  return fd;

}

/* }}} */

/*

 *  Determine where to place temporary files.

 */

PHPAPI const char* php_get_temporary_directory(void)

{

  /* Did we determine the temporary directory already? */

  if (PG(php_sys_temp_dir)) {

    return PG(php_sys_temp_dir);

  }

  /* Is there a temporary directory "sys_temp_dir" in .ini defined? */

  {

    char *sys_temp_dir = PG(sys_temp_dir);

    if (sys_temp_dir) {

      size_t len = strlen(sys_temp_dir);

      if (len >= 2 && sys_temp_dir[len - 1] == DEFAULT_SLASH) {

        PG(php_sys_temp_dir) = estrndup(sys_temp_dir, len - 1);

        return PG(php_sys_temp_dir);

      } else if (len >= 1 && sys_temp_dir[len - 1] != DEFAULT_SLASH) {

        PG(php_sys_temp_dir) = estrndup(sys_temp_dir, len);

        return PG(php_sys_temp_dir);

      }

    }

  }

#ifdef PHP_WIN32

  /* We can't count on the environment variables TEMP or TMP,

   * and so must make the Win32 API call to get the default

   * directory for temporary files.  Note this call checks

   * the environment values TMP and TEMP (in order) first.

   */

  {

    wchar_t sTemp[MAXPATHLEN];

    char *tmp;

    size_t len = GetTempPathW(MAXPATHLEN, sTemp);

    if (!len) {

      return NULL;

    }

    if (NULL == (tmp = php_win32_ioutil_conv_w_to_any(sTemp, len, &len))) {

      return NULL;

    }

    PG(php_sys_temp_dir) = estrndup(tmp, len - 1);

    free(tmp);

    return PG(php_sys_temp_dir);

  }

#else

  /* On Unix use the (usual) TMPDIR environment variable. */

  {

    char* s = getenv("TMPDIR");

    if (s && *s) {

      size_t len = strlen(s);

      if (s[len - 1] == DEFAULT_SLASH) {

        PG(php_sys_temp_dir) = estrndup(s, len - 1);

      } else {

        PG(php_sys_temp_dir) = estrndup(s, len);

      }

      return PG(php_sys_temp_dir);

    }

  }

#ifdef P_tmpdir

  /* Use the standard default temporary directory. */

  if (P_tmpdir) {

    PG(php_sys_temp_dir) = estrdup(P_tmpdir);

    return PG(php_sys_temp_dir);

  }

#endif

  /* Shouldn't ever(!) end up here ... last ditch default. */

  PG(php_sys_temp_dir) = estrdup("/tmp");

  return PG(php_sys_temp_dir);

#endif

}

/* {{{ php_open_temporary_file

 *

 * Unlike tempnam(), the supplied dir argument takes precedence

 * over the TMPDIR environment variable

 * This function should do its best to return a file pointer to a newly created

 * unique file, on every platform.

 */

PHPAPI int php_open_temporary_fd_ex(const char *dir, const char *pfx, zend_string **opened_path_p, uint32_t flags)

{

  int fd;

  const char *temp_dir;

  if (!pfx) {

    pfx = "tmp.";

  }

  if (opened_path_p) {

    *opened_path_p = NULL;

  }

  if (!dir || *dir == '\0') {

def_tmp:

    temp_dir = php_get_temporary_directory();

    if (temp_dir &&

        *temp_dir != '\0' &&

        (!(flags & PHP_TMP_FILE_OPEN_BASEDIR_CHECK_ON_FALLBACK) || !php_check_open_basedir(temp_dir))) {

      return php_do_open_temporary_file(temp_dir, pfx, opened_path_p);

    } else {

      return -1;

    }

  }

  if ((flags & PHP_TMP_FILE_OPEN_BASEDIR_CHECK_ON_EXPLICIT_DIR) && php_check_open_basedir(dir)) {

    return -1;

  }

  /* Try the directory given as parameter. */

  fd = php_do_open_temporary_file(dir, pfx, opened_path_p);

  if (fd == -1) {

    /* Use default temporary directory. */

    if (!(flags & PHP_TMP_FILE_SILENT)) {

      php_error_docref(NULL, E_NOTICE, "file created in the system's temporary directory");

    }

    goto def_tmp;

  }

  return fd;

}

PHPAPI int php_open_temporary_fd(const char *dir, const char *pfx, zend_string **opened_path_p)

{

  return php_open_temporary_fd_ex(dir, pfx, opened_path_p, PHP_TMP_FILE_DEFAULT);

}

PHPAPI FILE *php_open_temporary_file(const char *dir, const char *pfx, zend_string **opened_path_p)

{

  FILE *fp;

  int fd = php_open_temporary_fd(dir, pfx, opened_path_p);

  if (fd == -1) {

    return NULL;

  }

  fp = fdopen(fd, "r+b");

  if (fp == NULL) {

    close(fd);

  }

  return fp;

}

/* }}} */