/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Abstract Machine Test; executes memory access tests to show
 * compliance with Common Criteria object reuse and process address
 * space separation requirements.
 */
#include <errno.h>
#include <fcntl.h>
#include <iso/stdlib_iso.h>
#include <libelf.h>
#include <libintl.h>
#include <locale.h>
#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <sys/param.h>
#include <sys/resource.h>
#include <sys/sysmacros.h>
#include <sys/types.h>
#include <unistd.h>
#include <wait.h>

#define NOT_SILENT 0
#define SILENT_MODE 1

#define CHILD_SLEEP_PERIOD 2
#define PARENT_SLEEP_PERIOD 1
#define SIG_EVENT SIGUSR1

#define PASS       0            /* test passed, no SEGV */
#define FAIL_ZERO  1            /* expected to read zero, didn't */
#define FAIL_SEGV  2            /* expected good read or write, didn't */
#define PASS_SEGV  3            /* expected SEGV, got it */
#define FAIL_ABORT 4            /* test logic error */

#define PH_VALID   0            /* arg for probe_hole -- do valid memory */
                                /* access */
#define PH_INVALID 1            /* do illegal memory access */

#define WASTE_PAGES   8         /* a guess at where virgin stack space */
                                /* is likely to exist */
#define STACK_SLOP  256         /* a guess at how far below current end */
                                /* of stack I'll find unused space */

#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN "SYS_TEST"
#endif

extern int _end;        /* first address after the end of initialized data */

static int  data_boundary_test();
static void handler(int);
static int  memory_not_shared_after_use();
static int  memory_allocation_not_shared();
static int  memory_type(const char *);
static void print_message(char *);
static void probe_data_area(void);
static void probe_hole(int);
static void probe_stack(void);
static void probe_text_area(void);
static void segv_action(int, siginfo_t *, void *);
static void set_handler(int);
static int  test_stack_end_of_hole();
static int  text_area_not_writeable();

static int done_memory_grab = 0;
static int silent;
static int handler_exit_code;

/*
 * Main Routine
 */
int
main(int argc, char *argv[])
{
        int fail_count = 0;
        int status = 0;
        int bitsize;

        /* Internationalization */
        (void) setlocale(LC_ALL, "");
        (void) textdomain(TEXT_DOMAIN);

        silent = NOT_SILENT;

        if (argc == 2) {
                /* Pull out argument provided            */
                /* -s   silent mode, no status or error messages. */
                if (strncmp(argv[1], "-s", 4) == 0)
                        silent = SILENT_MODE;
                else {
                        /* Wrong argument */
                        (void) fprintf(stderr, gettext(
                            "Wrong argument, USAGE: amt [-s]\n"));
                        exit(EXIT_FAILURE);
                }
        } else if (argc != 1) {
                /* Illegal number of arguments. */
                (void) fprintf(stderr, gettext(
                    "Wrong usage, USAGE: amt [-s]\n"));
                exit(EXIT_FAILURE);
        }
        bitsize = memory_type(argv[0]);

        if (silent == NOT_SILENT)
                (void) printf(gettext(
                    "\n\nAMT Test Program -- %d bit application\n"
                    "================\n"), bitsize);
        /*
         * test_stack_end_of_hole must be the first test, or the stack
         * is of an unknown size.
         */
        if ((status = test_stack_end_of_hole()) == EXIT_FAILURE) {
                /* Normal fail */
                fail_count++;
                print_message(gettext("TEST 1 FAILED\n"));
        } else if (status == FAIL_ABORT) {
                /* Test logic failure */
                fail_count++;
                print_message(gettext("FAIL: Logic error in test\n"));
        } else if (status == EXIT_SUCCESS)
                print_message(gettext("TEST 1 PASSED\n"));

        /* Carry out test 2 */
        if (data_boundary_test() != EXIT_SUCCESS) {
                fail_count++;
                print_message(gettext("TEST 2 FAILED\n"));
        } else
                print_message(gettext("TEST 2 PASSED\n"));

        /* Carry out test 3 */
        if (text_area_not_writeable() != EXIT_SUCCESS) {
                fail_count++;
                print_message(gettext("TEST 3 FAILED\n"));
        } else
                print_message(gettext("TEST 3 PASSED\n"));

        /* Carry out test 4 */
        if (memory_not_shared_after_use() != EXIT_SUCCESS) {
                fail_count++;
                print_message(gettext("TEST 4 FAILED\n"));
        } else
                print_message(gettext("TEST 4 PASSED\n"));

        /* Carry out test 5 */
        if (memory_allocation_not_shared() != EXIT_SUCCESS) {
                fail_count++;
                print_message(gettext("TEST 5 FAILED\n"));
        } else
                print_message(gettext("TEST 5 PASSED\n"));

        if (silent == NOT_SILENT) {
                if (fail_count > 0)
                        (void) printf(gettext("\n %d TESTS FAILED\n\n"),
                            fail_count);
                else
                        (void) printf(gettext("\nTESTS SUCCEEDED\n\n"));
        }
        return (fail_count);
}

/*
 * Test the data boundaries. First test inside the data area at the boundary
 * of the "hole" area. Second test inside the data area at the text area
 * boundary. Both should pass.
 */
static int
data_boundary_test()
{
        int exit_status = EXIT_SUCCESS;
        pid_t pid;
        int status;

        print_message(gettext("\n\nTest 2- Data Side Boundary Test.\n"));

        if ((pid = fork()) == -1) {
                print_message(gettext("Fork failed\n"));
                return (EXIT_FAILURE);
        } else if (pid == 0) { /* Am I my child? */
                set_handler(SIGSEGV);

                /* probe_data_area() does exit() */
                probe_data_area();
        }
        /* still parent */
        (void) wait(&status);
        status = WEXITSTATUS(status);

        if (status == PASS)
                print_message(gettext(
                    "PASS: Successful read/write in data area.\n"));
        else if (status == FAIL_SEGV) {
                print_message(gettext(
                    "FAIL: Caught a segmentation fault while "
                    "attempting to write to the data area.\n"));
                exit_status = EXIT_FAILURE;
        } else {
                (void) printf(gettext("Test program failure: %d\n"),
                    status);
                exit_status = EXIT_FAILURE;
        }
        return (exit_status);
}

static void
probe_data_area()
{
        int *p;
        /* LINTED */
        volatile int p1 __unused;
        void *address;

        /* set handler status */
        handler_exit_code = FAIL_SEGV;

        /*
         * Get an address in the data area, near to the "hole".
         * sbrk returns prior address value; rather than calculating
         * the sbrk result, sbrk is called twice, so address points
         * to the new end of data
         */
        (void) sbrk(PAGESIZE);
        address = sbrk(0);
        /*
         * Get to the inside edge of a page boundary
         * two integer words short of a new page
         */
        p = ((int *)P2ROUNDUP((uintptr_t)address, PAGESIZE)) - 2;

        /* Try writing to it, shouldn't cause a segmentation fault. */
        *p = 9999;

        /* Should be able to read back with no problems. */
        p1 = *p;

        /*
         * Get an address near the text area boundary, but in the data
         * area.  _etext rounded up a page isn't correct since the
         * initialized data area isn't writeable.
         *
         * Future versions should consider handling initialized data
         * separately -- writing to initialized data should generate
         * a fault.
         */
        p = &_end;

        /* Try writing to it, should succeed. */
        *p = 9898;

        /* Should be able to read back with no problems. */
        p1 = *p;

        exit(EXIT_SUCCESS);
}

/*
 * Test that we cannot write to the text area. An attempt to write to
 * the text area will result in a segmentation fault. So if we catch it,
 * test has succeed, else it has failed.
 */
static int
text_area_not_writeable()
{
        int exit_status = EXIT_SUCCESS;
        pid_t pid;
        int status;

        print_message(gettext(
            "\n\nTest 3- Text Area Not Writeable\n"
            "Verify that a write to the text space does not cause "
            "a write to the executable\n"
            "file from which it came, or to another process which "
            "shares that text.\n"));

        if ((pid = fork()) == -1) {
                print_message(gettext("Fork failed\n"));
                return (EXIT_FAILURE);
        } else if (pid == 0) { /* Am I my child? */
                set_handler(SIGSEGV);

                /* probe_text_area() does exit() */
                probe_text_area();
        }
        /* still parent */
        (void) wait(&status);
        status = WEXITSTATUS(status);

        if (status == PASS) {
                print_message(gettext(
                    "FAIL: We did not cause a segmentation fault.\n"));
                exit_status = EXIT_FAILURE;
        } else if (status == FAIL_SEGV) {
                print_message(gettext(
                    "PASS: Caught the segmentation fault, "
                    "meaning we can't write to text area.\n"));
        } else {
                (void) printf(gettext(
                    "Test program failure: %d\n"), status);
                exit_status = EXIT_FAILURE;
        }
        return (exit_status);
}

/*
 * write to text area, trigger a SEGV
 */
static void
probe_text_area()
{
        handler_exit_code = FAIL_SEGV;
        *(caddr_t)probe_text_area = 0xff;
        exit(EXIT_FAILURE);
}

/*
 * Test that when we set some values and fork a process, when the child
 * writes to these inherited values, the parents copies are not changed.
 */
static int
memory_not_shared_after_use()
{
        pid_t pid;
        int x = 1000;
        int exit_status = EXIT_SUCCESS;

        print_message(gettext("\n\nTest 4- Memory Not Shared After Write\n"
            "Verify that anonymous memory initially shared by two "
            "processes (e.g. after a\n"
            "fork) is not shared after either process writes "
            "to it.\n"));

        if ((pid = fork()) == -1) {
                print_message(gettext("Fork failed\n"));
                return (EXIT_FAILURE);
        } else if (pid == 0) { /* I am the child. */
                /*
                 * Change child value; this should not change
                 * parent value.
                 */
                x = 2000;

                /* Wait for parent to test value */
                (void) sleep(CHILD_SLEEP_PERIOD);

                exit(EXIT_SUCCESS);
        }
        /* Wait for child to do its stuff. */
        (void) sleep(PARENT_SLEEP_PERIOD);

        if (x == 1000)
                exit_status = EXIT_SUCCESS;
        else
                exit_status = EXIT_FAILURE;

        return (exit_status);
}

/*
 * If we fork a process and then allocate some memory in that process,
 * we should not see any memory changes in the parent.
 */
static int
memory_allocation_not_shared()
{
        pid_t pid;
        pid_t parent_pid;
        int exit_status = 0;
        caddr_t address;
        caddr_t hole_start;
        caddr_t hole_after;
        void (*old_handler) ();

        print_message(gettext(
            "\n\nTest 5- Memory Allocation is Not Shared\n"
            "Verify that newly allocated memory in one of two "
            "processes created by forking\n"
            "does not result in newly allocated memory in the other.\n"));

        /* Save Size of data area and 1st block address of "hole" */
        hole_start = (caddr_t)sbrk(0);

        if (silent == NOT_SILENT)
                (void) printf(gettext(
                    "Parent address of hole before child change: %08X\n"),
                    hole_start);

        /* Set handler for signal SIG_EVENT (define at start) */
        old_handler = signal(SIG_EVENT, &handler);
        if (old_handler == SIG_ERR) {
                print_message(gettext(
                    "Can't establish signal handler, test failed\n"));
                return (EXIT_FAILURE);
        }

        if ((pid = fork()) == -1) {
                print_message(gettext("Fork failed\n"));
                return (EXIT_FAILURE);
        } else if (pid == 0) { /* We are the child. */
                address = sbrk(0);
                if (silent == NOT_SILENT)
                        (void) printf(gettext(
                            "Child end of hole before change:  %08X\n"),
                            address);

                if (brk((address+PAGESIZE)) != 0) {
                        print_message(gettext(
                            "Can't change start of hole address.\n"));
                        exit(EXIT_FAILURE);
                }

                address = sbrk(0);
                if (silent == NOT_SILENT)
                        (void) printf(gettext(
                            "Child end of hole after change: %08X\n"),
                            address);

                /* Tell the parent we're done. */
                parent_pid = getppid();
                if (sigsend(P_PID, parent_pid, SIG_EVENT) != 0) {
                        print_message(gettext("Can't send signal to parent, "
                            "test failed\n"));
                        exit(EXIT_FAILURE);
                }

                /* Sleep before exiting to allow parent to finish processing. */
                (void) sleep(CHILD_SLEEP_PERIOD);
                exit(EXIT_SUCCESS);
        }
        /* Wait for child to do its work. */
        (void) sleep(PARENT_SLEEP_PERIOD);

        if (done_memory_grab != 1) {
                print_message(gettext(
                    "Child failed to do memory alterations, "
                    "exiting\n"));
                return (EXIT_FAILURE);
        }

        hole_after = sbrk(0);
        if (silent == NOT_SILENT)
                (void) printf(gettext(
                    "Parent address of hole after child change: "
                    "%08X\n"), hole_after);

        /* Test size of hole and data region. */
        if (hole_start == hole_after)
                print_message(gettext(
                    "PASS: Hole is same size in parent.\n"));
        else {
                print_message(gettext(
                    "FAIL: Hole is a different size.\n"));
                exit_status = EXIT_FAILURE;
        }

        /* Wait for child to finish. */
        (void) wait(0);

        if (signal(SIG_EVENT, old_handler) == SIG_ERR) {
                print_message(gettext("Couldn't put back old signal handler, "
                    "test failed.\n"));
                return (EXIT_FAILURE);
        }
        return (exit_status);
}

static void
print_message(char *message)
{
        if (silent == NOT_SILENT)
                (void) printf("%s", message);
}

static int
test_stack_end_of_hole()
{
        pid_t pid;
        int status;
        int exit_status = EXIT_SUCCESS;

        print_message(gettext("\n\nTest 1- stack Side Boundary Test\n"));

        /* sub test 1:  the space the stack grows into is zero */

        if ((pid = fork()) == -1) {
                print_message(gettext("Fork failed\n"));
                return (EXIT_FAILURE);
        } else if (pid == 0) { /* Am I my child? */
                set_handler(SIGSEGV);

                /* probe_stack() does exit */
                probe_stack();
        }
        /* still parent */
        (void) wait(&status);
        status = WEXITSTATUS(status);

        if (status == FAIL_ZERO) {
                print_message(gettext("Fail with non-zero read.\n"));
                exit_status = EXIT_FAILURE;
        } else if (status != PASS) {
                print_message(gettext("Test program failure\n"));
                exit_status = EXIT_FAILURE;
        }
        /* sub test 2:  the space in hole is not readable */

        if ((pid = fork()) == -1) {
                print_message(gettext("Fork failed\n"));
                return (EXIT_FAILURE);
        } else if (pid == 0) { /* Am I my child? */
                set_handler(SIGSEGV);

                /* probe_hole does exit */
                probe_hole(PH_INVALID);
        }
        /* still parent */
        (void) wait(&status);
        status = WEXITSTATUS(status);

        if (status == FAIL_SEGV) {
                print_message(
                    gettext("Fail (SEGV expected, not received).\n"));
                exit_status = EXIT_FAILURE;
        } else if (status != PASS_SEGV) {
                print_message(gettext("Test program failure.\n"));
                exit_status = EXIT_FAILURE;
        }

        /* sub test 3:  the space in new page below hole is zero */

        if ((pid = fork()) == -1) {
                print_message(gettext("Fork failed\n"));
                return (EXIT_FAILURE);
        } else if (pid == 0) { /* Am I my child? */
                set_handler(SIGSEGV);

                /* probe_hole does exit */
                probe_hole(PH_VALID);
        }
        /* still parent */
        (void) wait(&status);
        status = WEXITSTATUS(status);

        if (status == FAIL_SEGV) {
                print_message(gettext("Fail (got SEGV).\n"));
                exit_status = EXIT_FAILURE;
        } else if (status != PASS) {
                print_message(gettext("Test program failure.\n"));
                exit_status = EXIT_FAILURE;
        }
        return (exit_status);
}


/*
 * set_handler
 */
static void
set_handler(int sig)
{
        struct sigaction act;

        act.sa_handler = NULL;
        act.sa_flags = SA_SIGINFO;
        act.sa_sigaction = segv_action;
        (void) sigemptyset(&(act.sa_mask));

        if (sigaction(sig, &act, NULL) < 0) {
                if (silent == NOT_SILENT) {
                        (void) fprintf(stderr, gettext(
                            "sigaction() returned error: %s\n"),
                            strerror(errno));
                }
                exit(EXIT_FAILURE);
        }
}


/*ARGSUSED*/
static void
segv_action(int which_sig, siginfo_t *t1, void *t2)
{
        exit(handler_exit_code);
}

/*
 * probe_stack
 *
 * Warning -- if you do a printf or fprintf prior to the actual
 * reading from the stack, you've changed the stack to an unknown
 * state.  (stack memory isn't free'd automatically and this function
 * needs to touch virgin stack space.)
 */
static void
probe_stack(void)
{
        unsigned char *end;     /* end of stack */
        unsigned char probe;
        long i;
        int j;
        unsigned char last_fail, *last_fail_address;
        unsigned char mark = 0xAA;      /* roughly the end of stack */
        handler_exit_code = FAIL_SEGV;

        end = &mark;
        /* stack growth is negative */
        end -= (WASTE_PAGES * PAGESIZE) + STACK_SLOP;

        for (i = 0, j = 0; i < PAGESIZE; i++) {
                if ((probe = *end) != 0) {
                        j++;
                        last_fail = probe;
                        last_fail_address = end;
                }
                end--;
        }

        if (j != 0) {
                if (silent == NOT_SILENT)
                        (void) fprintf(stderr, gettext(
                            "probe_stack failed. address=0x%08X; "
                            "probe=0x%02X; content = %d\n"),
                            (caddr_t)last_fail_address, last_fail, j);

                exit(FAIL_ZERO);    /* test failed at least once */
        }
        exit(EXIT_SUCCESS);
}

static void
probe_hole(int test_type)
{
        long i;
        /* LINTED */
        volatile unsigned char probe __unused;
        unsigned char *probe_adr;
        void *address;

        address = sbrk(0);  /* current end data + 1 */

        if (address == (void *)-1) {
                print_message(gettext("Test program logic error\n"));
                exit(FAIL_ABORT);
        }
        if (test_type == PH_VALID) {
                /* show that access works inside the  hole */
                handler_exit_code = FAIL_SEGV;

                probe_adr =  (unsigned char *)address - sizeof (char);

                for (i = 0; i < PAGESIZE; i++)
                        probe = *probe_adr--;

                exit(EXIT_SUCCESS);
        } else {
                /* show that a trap occurs in the  hole */
                handler_exit_code = PASS_SEGV;

                address = (void *)P2ROUNDUP((uintptr_t)address, PAGESIZE);
                probe_adr = (unsigned char *)address;

                probe = *probe_adr;
                exit(FAIL_SEGV);        /* expected SEGV, didn't get it */
        }
}

/*
 * Catch signal, child to parent
 */
/*ARGSUSED*/
void
handler(int signal)
{
        done_memory_grab = 1;
}
/*
 * memory_type:  Determine whether a given executable file is compiled
 * as 32 or 64 bit.
 *
 * The following code was stolen from isainfo (1)
 */

static int
memory_type(const char *path)
{
        char *idarray;
        Elf *elf;
        int d;
        int bits = 0;

        if ((d = open(path, O_RDONLY)) < 0) {
                (void) fprintf(stderr,
                    "cannot open: %s -- %s\n",
                    path, strerror(errno));
                return (bits);
        }

        if (elf_version(EV_CURRENT) == EV_NONE) {
                (void) fprintf(stderr,
                    "internal error: ELF library out of date?\n");
                (void) close(d);
                return (bits);
        }

        elf = elf_begin(d, ELF_C_READ, (Elf *)0);
        if (elf_kind(elf) != ELF_K_ELF) {
                (void) elf_end(elf);
                (void) close(d);
                return (bits);
        }

        idarray = elf_getident(elf, 0);

        if (idarray[EI_CLASS] == ELFCLASS32) {
                bits = 32;
        } else if (idarray[EI_CLASS] == ELFCLASS64) {
                bits = 64;
        }

        (void) elf_end(elf);
        (void) close(d);
        return (bits);
}