/* **********************************************************
 * Copyright (c) 2011-2014 Google, Inc.  All rights reserved.
 * Copyright (c) 2005-2010 VMware, Inc.  All rights reserved.
 * **********************************************************/

/*
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * * Redistributions of source code must retain the above copyright notice,
 *   this list of conditions and the following disclaimer.
 *
 * * 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.
 *
 * * Neither the name of VMware, Inc. 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 COPYRIGHT HOLDERS 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 VMWARE, INC. 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.
 */


#ifndef _DETERMINA_SHAREUTILS_H_
#define _DETERMINA_SHAREUTILS_H_

#include "share.h"
#include "lib/dr_config.h"
#include "our_tchar.h"

#ifdef WINDOWS
# include "config.h"
#endif

#ifdef DEBUG
# include <stdio.h>
#endif

#if defined(WINDOWS) && defined(_DEBUG)
# include <crtdbg.h>
#endif

#ifdef __cplusplus
extern "C"{
#endif

const TCHAR *
get_dynamorio_home(void);

const TCHAR *
get_dynamorio_logdir(void);

bool
file_exists(const TCHAR *fn);

void
set_dr_platform(dr_platform_t platform);

/* return DR_PLATFORM_32BIT or DR_PLATFORM_64BIT */
dr_platform_t
get_dr_platform(void);

/* XXX: Rest are unported. */
#ifdef WINDOWS

void
wcstolower(WCHAR *str);

WCHAR *
get_exename_from_path(const WCHAR *path);

BOOL
get_commandline_qualifier(const WCHAR* command_line,
                          WCHAR* derived_name,
                          UINT max_derived_length /* in elements */,
                          BOOL no_strip);

DWORD
acquire_shutdown_privilege();

DWORD
reboot_system();

/* grokked from the core.
 * FIXME: shareme!
 * if NULL is passed for directory, then it is ignored and no directory
 *  check is done, and filename_base is assumed to be absolute.
 * TODO: make this a proactive check: make sure the file can be
 *  opened, eg, do a create/delete on the filename to be returned.
 */
BOOL
get_unique_filename(const WCHAR* directory,
                    const WCHAR* filename_base,
                    const WCHAR* file_type,
                    WCHAR* filename_buffer,
                    UINT maxlen);

DWORD
delete_file_rename_in_use(WCHAR *filename);

DWORD
delete_file_on_boot(WCHAR *filename);

DWORD
delete_tree(const WCHAR *path);

DWORD
copy_file_permissions(WCHAR *filedst, WCHAR *filesrc);

DWORD
get_platform(DWORD *platform);

BOOL
is_wow64(HANDLE hProcess);

BOOL
using_system32_for_preinject(const WCHAR *preinject);

DWORD
get_preinject_path(WCHAR *buf, int nchars, BOOL force_local_path, BOOL short_path);

DWORD
get_preinject_name(WCHAR *buf, int nchars);

/* PR 244206: these flags should be used for all Reg{Create,Open,Delete}KeyEx calls
 * for HKLM\Software keys
 */
DWORD
platform_key_flags();

/* PR 244206: use this instead of RegDeleteKey for HKLM\Software keys */
DWORD
delete_product_key(HKEY hkey, LPCWSTR subkey);

DWORD
create_root_key();

DWORD
destroy_root_key();

/* note that this checks the opstring against the
 *  version of core that matches this build, NOT the version
 *  of the core that's actually installed! */
BOOL
check_opstring(const WCHAR *opstring);

/* acquires the privileges necessary to perform tasks like detach,
 *  nudge, etc. */
DWORD
acquire_privileges();

/* said privileges should always be released after usage */
DWORD
release_privileges();

void
ensure_directory_exists_for_file(WCHAR *filename);

void
mkdir_with_parents(const WCHAR *dirname);

DWORD
write_file_contents(WCHAR *path, char *contents, BOOL overwrite);

DWORD
write_file_contents_if_different(WCHAR *path, char *contents, BOOL *changed);

DWORD
read_file_contents(WCHAR *path, char *contents,
                   SIZE_T maxchars, SIZE_T *needed);

DWORD
setup_installation(const WCHAR *path, BOOL overwrite);

DWORD
setup_cache_shared_directories(const WCHAR *cache_root);
DWORD
setup_cache_shared_registry(const WCHAR *cache_root,
                            ConfigGroup *policy);

DWORD
set_registry_permissions_for_user(WCHAR *hklm_keyname, WCHAR *user);

/* used by get_violation_info() */
typedef struct _VIOLATION_INFO {
    DWORD         flags; /* IN, NYI */
    const WCHAR  *report; /* OUT, Filename of generated report file. NULL if error.*/
    WCHAR         buf[MAX_PATH]; /* space for filename */
} VIOLATION_INFO;

/* Takes in a MSG_SEC_FORENSICS event log record pevlr and generates a report file
 * (info->report) as specified by the flags field in info.  On success returns
 * ERROR_SUCCESS, else returns a failure code. */
DWORD
get_violation_info(EVENTLOGRECORD *pevlr, /* INOUT */ VIOLATION_INFO *info);

/* The final canary code is (FAIL_CODE << 16) | (TEST_TYPE && 0xffff) */
#define CANARY_UNABLE_TO_TEST            1
#define CANARY_SUCCESS                   0
#define CANARY_FAIL_HUNG                -1
#define CANARY_FAIL_CRASH               -2
#define CANARY_FAIL_VIOLATION           -3
#define CANARY_FAIL_DR_ERROR            -4
#define CANARY_FAIL_APP_INIT_INJECTION  -5
#define CANARY_FAIL_EARLY_INJECTION     -6
/* future error codes */
#define CANARY_TEST_TYPE_NATIVE      1
#define CANARY_TEST_TYPE_THIN_CLIENT 2
#define CANARY_TEST_TYPE_CLIENT      3
#define CANARY_TEST_TYPE_MF          4
/* future types */
#define GET_CANARY_CODE(test_type, fail_code) ((fail_code << 16) | (test_type && 0xffff))

#define CANARY_RUN_NO_REQUIRE_PASS(run) (run|(run << 16))
#define CANARY_RUN_REQUIRES_PASS(run, flags) (((flags >> 16) & run) == 0)
#define CANARY_RUN_NATIVE              0x0001
#define CANARY_RUN_THIN_CLIENT_INJECT  0x0002
#define CANARY_RUN_THIN_CLIENT         0x0004
#define CANARY_RUN_CLIENT              0x0008
#define CANARY_RUN_MF                  0x0010

#define CANARY_RUN_FLAGS_DEFAULT \
    (CANARY_RUN_NATIVE | CANARY_RUN_THIN_CLIENT_INJECT | CANARY_RUN_THIN_CLIENT | \
     CANARY_RUN_CLIENT | CANARY_RUN_NO_REQUIRE_PASS(CANARY_RUN_MF))
/* NYI */
#define CANARY_INFO_FLAGS_DEFAULT 0

#define CANARY_URL_SIZE 20 /* NYI so arbitrary */
#define CANARY_MESSAGE_SIZE 1024 /* NYI so arbitrary */
typedef struct _CANARY_INFO {
    DWORD         run_flags; /* tests to run */
    DWORD         info_flags; /* info to gather, NYI */
    int           canary_code; /* canary return code, like an NTSTATUS */
    const WCHAR  *report; /* OUT, filename of generated report file */
    const WCHAR  *url; /* OUT, url string to use for querying determina */
    const WCHAR  *msg; /* OUT, msg to display to user */
    WCHAR         buf_report[MAX_PATH]; /* space for report filename */
    WCHAR         buf_url[CANARY_URL_SIZE]; /* space for url */
    WCHAR         buf_message[CANARY_MESSAGE_SIZE]; /* space for use message */
    /* Used by DRcontrol to inject faults, FIXME get rid of these and the flags and
     * go to a more data driven model. Other users should set fault_run to 0. */
    DWORD         fault_run;
    WCHAR        *canary_fault_args;
} CANARY_INFO;
/* NOTE - arbitrary value, but shouldn't be -1 (core kill_proc value) or overlapping
 * an NTSTATUS (such as ACCESS_DENIED etc.). */
#define CANARY_PROCESS_EXP_EXIT_CODE 0

/* Returns TRUE if the canary tests succeeded and protection should be enabled. Returns
 * FALSE if one of the canary tests failed and therefore protection should not be
 * enabled. Flags fields of info are used to specify which tests to run and what
 * information to gather, other fields are used to return additional information
 * to the caller. */
BOOL
run_canary_test(/* INOUT */ CANARY_INFO *info, WCHAR *version_msg);

/* Like run_canary_test(), except takes in as args what run_canary_test() implicitly
 * finds via the registry for greater customization. */
BOOL
run_canary_test_ex(FILE *file, /* INOUT */ CANARY_INFO *info,
                   const WCHAR *scratch_folder, const WCHAR *canary_process);

#endif /* WINDOWS */

# ifdef DEBUG

extern int debuglevel;
extern int abortlevel;

void
set_debuglevel(int level);

void
set_debugfile(FILE *fp);

void
set_abortlevel(int level);

#  define DL_FATAL    0
#  define DL_ERROR    2
#  define DL_WARN     4
#  define DL_INFO     6
#  define DL_VERB     8
#  define DL_FINEST   10

#  ifdef WINDOWS
#   pragma warning(disable : 4127)
#  endif

#  ifndef EXIT_ON_ASSERT
#    define EXIT_ON_ASSERT true
#  endif

#  ifndef ASSERTION_EXPRESSION
#   ifdef _DEBUG
#    define  ASSERTION_EXPRESSION(msg) _ASSERTE(0)
#   else
#    define  ASSERTION_EXPRESSION(msg)
#   endif
#  endif

#  define DO_ASSERT_EXPR(msg, expr, handle, handler)  {         \
    if ( ! (expr) ) {                                           \
        char ___buf[MAXIMUM_PATH];                              \
        _snprintf(___buf, MAXIMUM_PATH, "%s:%d [%s]",           \
                   __FILE__, __LINE__, msg);                    \
        if (handle) {                                           \
            handler                                             \
        }                                                       \
        else if (EXIT_ON_ASSERT) {                              \
            fprintf(stderr, "ASSERT: %s\n", ___buf);            \
            fflush(stderr);                                     \
            exit(-1);                                           \
        }                                                       \
        else {                                                  \
            ASSERTION_EXPRESSION(msg);                          \
        }                                                       \
    }                                                           \
}

#  define NULL_HANDLER ;

#  define DO_ASSERT(expr) DO_ASSERT_EXPR(#expr, expr, 0, NULL_HANDLER)

#  define DO_ASSERT_HANDLE(expr, handler) DO_ASSERT_EXPR(#expr, expr, 1, handler)

#  define DO_DEBUG(l,expr)  {                                   \
    if ( (l) <= debuglevel ) {                                  \
        expr                                                    \
    }                                                           \
    if ( (l) <= abortlevel ) {                                  \
        DO_ASSERT_EXPR("DEBUG failure", 0, 0, NULL_HANDLER);    \
    }                                                           \
    fflush(stdout);                                             \
    fflush(stderr);                                             \
}

#  define DO_ASSERT_WSTR_EQ(s1, s2)             \
    DO_ASSERT(s1 != NULL);                      \
    DO_ASSERT(s2 != NULL);                      \
    DO_ASSERT(0 == wcscmp(s1, s2))

#  define DO_ASSERT_STR_EQ(s1, s2)              \
    DO_ASSERT(s1 != NULL);                      \
    DO_ASSERT(s2 != NULL);                      \
    if (s1 != NULL && s2 != NULL) { DO_ASSERT(0 == strcmp(s1, s2)); }

#  define CHECKED_OPERATION(expr) {             \
    DWORD res = expr;                           \
    if (res != ERROR_SUCCESS)                   \
        printf("res=%d\n", res);                \
    DO_ASSERT(res == ERROR_SUCCESS);            \
}

#define LAUNCH_APP_WAIT_HANDLE(relpath, pidvar, wait, handle) { \
    STARTUPINFO si = { 0 };                                     \
    PROCESS_INFORMATION pi = { 0 };                             \
    WCHAR cmdl[MAX_PATH];                                       \
    _snwprintf(cmdl, MAX_PATH, L"%s", relpath);                 \
    DO_ASSERT(CreateProcess(NULL,                               \
                            cmdl,                               \
                            NULL, NULL, FALSE,                  \
                            0,                                  \
                            NULL,                               \
                            NULL,                               \
                            &si, &pi));                         \
    *pidvar = pi.dwProcessId;                                   \
    DO_DEBUG(DL_VERB,                                           \
             printf("Launched %d=%S\n", *pidvar, cmdl);         \
             );                                                 \
    if (wait) {                                                 \
        DWORD waitres = WaitForSingleObject(pi.hProcess, 5000); \
        DO_ASSERT(waitres == WAIT_OBJECT_0);                    \
    }                                                           \
    else {                                                      \
        Sleep(100);                                             \
    }                                                           \
    if (handle == NULL) {                                       \
        CloseHandle(pi.hThread);                                \
        CloseHandle(pi.hProcess);                               \
    }                                                           \
    else {                                                      \
        *handle = pi.hProcess;                                  \
    }                                                           \
}

#define LAUNCH_APP_HANDLE(relpath, pidvar, handle) LAUNCH_APP_WAIT_HANDLE(relpath, pidvar, FALSE, handle)
#define LAUNCH_APP_WAIT(relpath, pidvar, wait) LAUNCH_APP_WAIT_HANDLE(relpath, pidvar, wait, dummy)
#define LAUNCH_APP(relpath, pidvar) LAUNCH_APP_WAIT(relpath, pidvar, FALSE)
#define LAUNCH_APP_AND_WAIT(relpath, pidvar) LAUNCH_APP_WAIT(relpath, pidvar, TRUE)

#  define TERMINATE_PROCESS(pid)  {             \
    DO_DEBUG(DL_VERB,                           \
             printf("terminating %d\n", pid);   \
             );                                 \
    terminate_process(pid);                     \
    Sleep(100);                                 \
}

#  define VERIFY_UNDER_DR(pid)  {                       \
    int stat = under_dynamorio(pid);                    \
    DO_ASSERT(stat != DLL_NONE && stat != DLL_UNKNOWN); \
}

#  define VERIFY_NOT_UNDER_DR(pid)  {           \
    int stat = under_dynamorio(pid);            \
    DO_ASSERT(stat == DLL_NONE);                \
}


#  ifdef WINDOWS
DWORD
load_test_config(const char *snippet, BOOL use_hotpatch_defs);

void
get_testdir(WCHAR *buf, UINT maxchars);

/* quick helpers for unit tests */
BOOL
check_for_event(DWORD type, WCHAR *exename, ULONG pid,
                WCHAR *s3, WCHAR *s4, UINT maxchars);
void
reset_last_event();

void
show_all_events();
#  endif

# else //#ifdef DEBUG

#  define DO_DEBUG(l,x)
#  define DO_ASSERT(x)

#  define CHECKED_OPERATION(expr) {             \
    DWORD res = expr;                           \
    if (res != ERROR_SUCCESS)                   \
        return res;                             \
}

# endif /* DEBUG */

/* alignment helpers, alignment must be power of 2 */
#define ALIGNED(x, alignment) ((((INT_PTR)x) & ((alignment)-1)) == 0)
#define ALIGN_BACKWARD(x, alignment) (((INT_PTR)x) & (~((alignment)-1)))
#define ALIGN_FORWARD(x, alignment) \
    ((((INT_PTR)x) + ((alignment)-1)) & (~((alignment)-1)))

#ifdef __cplusplus
}
#endif

#endif