/*

 * Copyright 2001-2007 Sun Microsystems, Inc.  All Rights Reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

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

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code 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 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

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

 * 2 along with this work; if not, write to the Free Software Foundation,

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

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 *

 */

# include "incls/_precompiled.incl"

# include "incls/_perfMemory_windows.cpp.incl"

#include <windows.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <errno.h>

#include <lmcons.h>

typedef BOOL (WINAPI *SetSecurityDescriptorControlFnPtr)(

   IN PSECURITY_DESCRIPTOR pSecurityDescriptor,

   IN SECURITY_DESCRIPTOR_CONTROL ControlBitsOfInterest,

   IN SECURITY_DESCRIPTOR_CONTROL ControlBitsToSet);

// Standard Memory Implementation Details

// create the PerfData memory region in standard memory.

//

static char* create_standard_memory(size_t size) {

  // allocate an aligned chuck of memory

  char* mapAddress = os::reserve_memory(size);

  if (mapAddress == NULL) {

    return NULL;

  }

  // commit memory

  if (!os::commit_memory(mapAddress, size)) {

    if (PrintMiscellaneous && Verbose) {

      warning("Could not commit PerfData memory\n");

    }

    os::release_memory(mapAddress, size);

    return NULL;

  }

  return mapAddress;

}

// delete the PerfData memory region

//

static void delete_standard_memory(char* addr, size_t size) {

  // there are no persistent external resources to cleanup for standard

  // memory. since DestroyJavaVM does not support unloading of the JVM,

  // cleanup of the memory resource is not performed. The memory will be

  // reclaimed by the OS upon termination of the process.

  //

  return;

}

// save the specified memory region to the given file

//

static void save_memory_to_file(char* addr, size_t size) {

  const char* destfile = PerfMemory::get_perfdata_file_path();

  assert(destfile[0] != '\0', "invalid Perfdata file path");

  int fd = ::_open(destfile, _O_BINARY|_O_CREAT|_O_WRONLY|_O_TRUNC,

                   _S_IREAD|_S_IWRITE);

  if (fd == OS_ERR) {

    if (PrintMiscellaneous && Verbose) {

      warning("Could not create Perfdata save file: %s: %s\n",

              destfile, strerror(errno));

    }

  } else {

    for (size_t remaining = size; remaining > 0;) {

      int nbytes = ::_write(fd, addr, (unsigned int)remaining);

      if (nbytes == OS_ERR) {

        if (PrintMiscellaneous && Verbose) {

          warning("Could not write Perfdata save file: %s: %s\n",

                  destfile, strerror(errno));

        }

        break;

      }

      remaining -= (size_t)nbytes;

      addr += nbytes;

    }

    int result = ::_close(fd);

    if (PrintMiscellaneous && Verbose) {

      if (result == OS_ERR) {

        warning("Could not close %s: %s\n", destfile, strerror(errno));

      }

    }

  }

  FREE_C_HEAP_ARRAY(char, destfile);

}

// Shared Memory Implementation Details

// Note: the win32 shared memory implementation uses two objects to represent

// the shared memory: a windows kernel based file mapping object and a backing

// store file. On windows, the name space for shared memory is a kernel

// based name space that is disjoint from other win32 name spaces. Since Java

// is unaware of this name space, a parallel file system based name space is

// maintained, which provides a common file system based shared memory name

// space across the supported platforms and one that Java apps can deal with

// through simple file apis.

//

// For performance and resource cleanup reasons, it is recommended that the

// user specific directory and the backing store file be stored in either a

// RAM based file system or a local disk based file system. Network based

// file systems are not recommended for performance reasons. In addition,

// use of SMB network based file systems may result in unsuccesful cleanup

// of the disk based resource on exit of the VM. The Windows TMP and TEMP

// environement variables, as used by the GetTempPath() Win32 API (see

// os::get_temp_directory() in os_win32.cpp), control the location of the

// user specific directory and the shared memory backing store file.

static HANDLE sharedmem_fileMapHandle = NULL;

static HANDLE sharedmem_fileHandle = INVALID_HANDLE_VALUE;

static char*  sharedmem_fileName = NULL;

// return the user specific temporary directory name.

//

// the caller is expected to free the allocated memory.

//

static char* get_user_tmp_dir(const char* user) {

  const char* tmpdir = os::get_temp_directory();

  const char* perfdir = PERFDATA_NAME;

  size_t nbytes = strlen(tmpdir) + strlen(perfdir) + strlen(user) + 2;

  char* dirname = NEW_C_HEAP_ARRAY(char, nbytes);

  // construct the path name to user specific tmp directory

  _snprintf(dirname, nbytes, "%s%s_%s", tmpdir, perfdir, user);

  return dirname;

}

// convert the given file name into a process id. if the file

// does not meet the file naming constraints, return 0.

//

static int filename_to_pid(const char* filename) {

  // a filename that doesn't begin with a digit is not a

  // candidate for conversion.

  //

  if (!isdigit(*filename)) {

    return 0;

  }

  // check if file name can be converted to an integer without

  // any leftover characters.

  //

  char* remainder = NULL;

  errno = 0;

  int pid = (int)strtol(filename, &remainder, 10);

  if (errno != 0) {

    return 0;

  }

  // check for left over characters. If any, then the filename is

  // not a candidate for conversion.

  //

  if (remainder != NULL && *remainder != '\0') {

    return 0;

  }

  // successful conversion, return the pid

  return pid;

}

// check if the given path is considered a secure directory for

// the backing store files. Returns true if the directory exists

// and is considered a secure location. Returns false if the path

// is a symbolic link or if an error occured.

//

static bool is_directory_secure(const char* path) {

  DWORD fa;

  fa = GetFileAttributes(path);

  if (fa == 0xFFFFFFFF) {

    DWORD lasterror = GetLastError();

    if (lasterror == ERROR_FILE_NOT_FOUND) {

      return false;

    }

    else {

      // unexpected error, declare the path insecure

      if (PrintMiscellaneous && Verbose) {

        warning("could not get attributes for file %s: ",

                " lasterror = %d\n", path, lasterror);

      }

      return false;

    }

  }

  if (fa & FILE_ATTRIBUTE_REPARSE_POINT) {

    // we don't accept any redirection for the user specific directory

    // so declare the path insecure. This may be too conservative,

    // as some types of reparse points might be acceptable, but it

    // is probably more secure to avoid these conditions.

    //

    if (PrintMiscellaneous && Verbose) {

      warning("%s is a reparse point\n", path);

    }

    return false;

  }

  if (fa & FILE_ATTRIBUTE_DIRECTORY) {

    // this is the expected case. Since windows supports symbolic

    // links to directories only, not to files, there is no need

    // to check for open write permissions on the directory. If the

    // directory has open write permissions, any files deposited that

    // are not expected will be removed by the cleanup code.

    //

    return true;

  }

  else {

    // this is either a regular file or some other type of file,

    // any of which are unexpected and therefore insecure.

    //

    if (PrintMiscellaneous && Verbose) {

      warning("%s is not a directory, file attributes = "

              INTPTR_FORMAT "\n", path, fa);

    }

    return false;

  }

}

// return the user name for the owner of this process

//

// the caller is expected to free the allocated memory.

//

static char* get_user_name() {

  /* get the user name. This code is adapted from code found in

   * the jdk in src/windows/native/java/lang/java_props_md.c

   * java_props_md.c  1.29 02/02/06. According to the original

   * source, the call to GetUserName is avoided because of a resulting

   * increase in footprint of 100K.

   */

  char* user = getenv("USERNAME");

  char buf[UNLEN+1];

  DWORD buflen = sizeof(buf);

  if (user == NULL || strlen(user) == 0) {

    if (GetUserName(buf, &buflen)) {

      user = buf;

    }

    else {

      return NULL;

    }

  }

  char* user_name = NEW_C_HEAP_ARRAY(char, strlen(user)+1);

  strcpy(user_name, user);

  return user_name;

}

// return the name of the user that owns the process identified by vmid.

//

// This method uses a slow directory search algorithm to find the backing

// store file for the specified vmid and returns the user name, as determined

// by the user name suffix of the hsperfdata_<username> directory name.

//

// the caller is expected to free the allocated memory.

//

static char* get_user_name_slow(int vmid) {

  // directory search

  char* oldest_user = NULL;

  time_t oldest_ctime = 0;

  const char* tmpdirname = os::get_temp_directory();

  DIR* tmpdirp = os::opendir(tmpdirname);

  if (tmpdirp == NULL) {

    return NULL;

  }

  // for each entry in the directory that matches the pattern hsperfdata_*,

  // open the directory and check if the file for the given vmid exists.

  // The file with the expected name and the latest creation date is used

  // to determine the user name for the process id.

  //

  struct dirent* dentry;

  char* tdbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(tmpdirname));

  errno = 0;

  while ((dentry = os::readdir(tmpdirp, (struct dirent *)tdbuf)) != NULL) {

    // check if the directory entry is a hsperfdata file

    if (strncmp(dentry->d_name, PERFDATA_NAME, strlen(PERFDATA_NAME)) != 0) {

      continue;

    }

    char* usrdir_name = NEW_C_HEAP_ARRAY(char,

                              strlen(tmpdirname) + strlen(dentry->d_name) + 1);

    strcpy(usrdir_name, tmpdirname);

    strcat(usrdir_name, dentry->d_name);

    DIR* subdirp = os::opendir(usrdir_name);

    if (subdirp == NULL) {

      FREE_C_HEAP_ARRAY(char, usrdir_name);

      continue;

    }

    // Since we don't create the backing store files in directories

    // pointed to by symbolic links, we also don't follow them when

    // looking for the files. We check for a symbolic link after the

    // call to opendir in order to eliminate a small window where the

    // symlink can be exploited.

    //

    if (!is_directory_secure(usrdir_name)) {

      FREE_C_HEAP_ARRAY(char, usrdir_name);

      os::closedir(subdirp);

      continue;

    }

    struct dirent* udentry;

    char* udbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(usrdir_name));

    errno = 0;

    while ((udentry = os::readdir(subdirp, (struct dirent *)udbuf)) != NULL) {

      if (filename_to_pid(udentry->d_name) == vmid) {

        struct stat statbuf;

        char* filename = NEW_C_HEAP_ARRAY(char,

                            strlen(usrdir_name) + strlen(udentry->d_name) + 2);

        strcpy(filename, usrdir_name);

        strcat(filename, "\\");

        strcat(filename, udentry->d_name);

        if (::stat(filename, &statbuf) == OS_ERR) {

           FREE_C_HEAP_ARRAY(char, filename);

           continue;

        }

        // skip over files that are not regular files.

        if ((statbuf.st_mode & S_IFMT) != S_IFREG) {

          FREE_C_HEAP_ARRAY(char, filename);

          continue;

        }

        // compare and save filename with latest creation time

        if (statbuf.st_size > 0 && statbuf.st_ctime > oldest_ctime) {

          if (statbuf.st_ctime > oldest_ctime) {

            char* user = strchr(dentry->d_name, '_') + 1;

            if (oldest_user != NULL) FREE_C_HEAP_ARRAY(char, oldest_user);

            oldest_user = NEW_C_HEAP_ARRAY(char, strlen(user)+1);

            strcpy(oldest_user, user);

            oldest_ctime = statbuf.st_ctime;

          }

        }

        FREE_C_HEAP_ARRAY(char, filename);

      }

    }

    os::closedir(subdirp);

    FREE_C_HEAP_ARRAY(char, udbuf);

    FREE_C_HEAP_ARRAY(char, usrdir_name);

  }

  os::closedir(tmpdirp);

  FREE_C_HEAP_ARRAY(char, tdbuf);

  return(oldest_user);

}

// return the name of the user that owns the process identified by vmid.

//

// note: this method should only be used via the Perf native methods.

// There are various costs to this method and limiting its use to the

// Perf native methods limits the impact to monitoring applications only.

//

static char* get_user_name(int vmid) {

  // A fast implementation is not provided at this time. It's possible

  // to provide a fast process id to user name mapping function using

  // the win32 apis, but the default ACL for the process object only

  // allows processes with the same owner SID to acquire the process

  // handle (via OpenProcess(PROCESS_QUERY_INFORMATION)). It's possible

  // to have the JVM change the ACL for the process object to allow arbitrary

  // users to access the process handle and the process security token.

  // The security ramifications need to be studied before providing this

  // mechanism.

  //

  return get_user_name_slow(vmid);

}

// return the name of the shared memory file mapping object for the

// named shared memory region for the given user name and vmid.

//

// The file mapping object's name is not the file name. It is a name

// in a separate name space.

//

// the caller is expected to free the allocated memory.

//

static char *get_sharedmem_objectname(const char* user, int vmid) {

  // construct file mapping object's name, add 3 for two '_' and a

  // null terminator.

  int nbytes = (int)strlen(PERFDATA_NAME) + (int)strlen(user) + 3;

  // the id is converted to an unsigned value here because win32 allows

  // negative process ids. However, OpenFileMapping API complains

  // about a name containing a '-' characters.

  //

  nbytes += UINT_CHARS;

  char* name = NEW_C_HEAP_ARRAY(char, nbytes);

  _snprintf(name, nbytes, "%s_%s_%u", PERFDATA_NAME, user, vmid);

  return name;

}

// return the file name of the backing store file for the named

// shared memory region for the given user name and vmid.

//

// the caller is expected to free the allocated memory.

//

static char* get_sharedmem_filename(const char* dirname, int vmid) {

  // add 2 for the file separator and a null terminator.

  size_t nbytes = strlen(dirname) + UINT_CHARS + 2;

  char* name = NEW_C_HEAP_ARRAY(char, nbytes);

  _snprintf(name, nbytes, "%s\\%d", dirname, vmid);

  return name;

}

// remove file

//

// this method removes the file with the given file name.

//

// Note: if the indicated file is on an SMB network file system, this

// method may be unsuccessful in removing the file.

//

static void remove_file(const char* dirname, const char* filename) {

  size_t nbytes = strlen(dirname) + strlen(filename) + 2;

  char* path = NEW_C_HEAP_ARRAY(char, nbytes);

  strcpy(path, dirname);

  strcat(path, "\\");

  strcat(path, filename);

  if (::unlink(path) == OS_ERR) {

    if (PrintMiscellaneous && Verbose) {

      if (errno != ENOENT) {

        warning("Could not unlink shared memory backing"

                " store file %s : %s\n", path, strerror(errno));

      }

    }

  }

  FREE_C_HEAP_ARRAY(char, path);

}

// returns true if the process represented by pid is alive, otherwise

// returns false. the validity of the result is only accurate if the

// target process is owned by the same principal that owns this process.

// this method should not be used if to test the status of an otherwise

// arbitrary process unless it is know that this process has the appropriate

// privileges to guarantee a result valid.

//

static bool is_alive(int pid) {

  HANDLE ph = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, pid);

  if (ph == NULL) {

    // the process does not exist.

    if (PrintMiscellaneous && Verbose) {

      DWORD lastError = GetLastError();

      if (lastError != ERROR_INVALID_PARAMETER) {

        warning("OpenProcess failed: %d\n", GetLastError());

      }

    }

    return false;

  }

  DWORD exit_status;

  if (!GetExitCodeProcess(ph, &exit_status)) {

    if (PrintMiscellaneous && Verbose) {

      warning("GetExitCodeProcess failed: %d\n", GetLastError());

    }

    CloseHandle(ph);

    return false;

  }

  CloseHandle(ph);

  return (exit_status == STILL_ACTIVE) ? true : false;

}

// check if the file system is considered secure for the backing store files

//

static bool is_filesystem_secure(const char* path) {

  char root_path[MAX_PATH];

  char fs_type[MAX_PATH];

  if (PerfBypassFileSystemCheck) {