#include <stdio.h>
#include <stdlib.h>
#include "duktape.h"

Data Structures
struct	alloc_hdr

Functions
static void	sandbox_dump_memstate (void)

static void *	sandbox_alloc (void *udata, duk_size_t size)

static void *	sandbox_realloc (void udata, void ptr, duk_size_t size)

static void	sandbox_free (void udata, void ptr)

static duk_ret_t	do_sandbox_test (duk_context *ctx)

static void	sandbox_fatal (duk_context ctx, duk_errcode_t code, const char msg)

int	main (int argc, char *argv[])

Variables
static size_t	total_allocated = 0

static size_t	max_allocated = 256 * 1024

Function Documentation

◆ do_sandbox_test()

static duk_ret_t do_sandbox_test ( duk_context * ctx )

static

Definition at line 147 of file duktape-1.5.2/examples/sandbox/sandbox.c.

                                                   {
    FILE *f;
    char buf[4096];
    size_t ret;
    const char *globobj;
 
    /*
     *  Setup sandbox
     */
 
    globobj =
        "({\n"
        "    print: print,\n"
        "    Math: {\n"
        "        max: Math.max\n"
        "    }\n"
        "})\n";
#if 1
    fprintf(stderr, "Sandbox global object:\n----------------\n%s----------------\n", globobj);
    fflush(stderr);
#endif
    duk_eval_string(ctx, globobj);
    duk_set_global_object(ctx);
 
    /*
     *  Execute code from specified file
     */
 
    f = fopen(duk_require_string(ctx, -1), "rb");
    if (!f) {
        duk_error(ctx, DUK_ERR_ERROR, "failed to open file");
    }
 
    for (;;) {
        if (ferror(f)) {
            fclose(f);
            duk_error(ctx, DUK_ERR_ERROR, "ferror when reading file");
        }
        if (feof(f)) {
            break;
        }
 
        ret = fread(buf, 1, sizeof(buf), f);
        if (ret == 0) {
            break;
        }
 
        duk_push_lstring(ctx, (const char *) buf, ret);
    }
 
    duk_concat(ctx, duk_get_top(ctx) - 1);  /* -1 for filename */
 
    /* -> [ ... filename source ] */
 
    duk_insert(ctx, -2);
 
    /* -> [ ... source filename ] */
 
    duk_compile(ctx, 0 /*flags*/);  /* Compile as program */
    duk_call(ctx, 0 /*nargs*/);
 
    return 0;
}

References duk_call(), duk_compile, duk_concat(), DUK_ERR_ERROR, duk_error, duk_eval_string, duk_get_top(), duk_insert(), duk_push_lstring(), duk_require_string(), duk_set_global_object(), and fread().

Referenced by main().

◆ main()

int main	(	int	argc,
		char *	argv[] )

Definition at line 222 of file duktape-1.5.2/examples/sandbox/sandbox.c.

                                 {
    duk_context *ctx;
    duk_int_t rc;
 
    if (argc < 2) {
        fprintf(stderr, "Usage: sandbox <test.js>\n");
        fflush(stderr);
        exit(1);
    }
 
    ctx = duk_create_heap(sandbox_alloc,
                          sandbox_realloc,
                          sandbox_free,
                          NULL,
                          sandbox_fatal);
 
    duk_push_string(ctx, argv[1]);
    rc = duk_safe_call(ctx, do_sandbox_test, 1 /*nargs*/, 1 /*nrets*/);
    if (rc) {
        fprintf(stderr, "ERROR: %s\n", duk_safe_to_string(ctx, -1));
        fflush(stderr);
    }
 
    duk_destroy_heap(ctx);
 
    /* Should be zero. */
    fprintf(stderr, "Final allocation: %ld\n", (long) total_allocated);
    fflush(stderr);
 
    return 1;
}

References do_sandbox_test(), duk_create_heap(), duk_destroy_heap(), duk_push_string(), duk_safe_call(), duk_safe_to_string, NULL, sandbox_alloc(), sandbox_fatal(), sandbox_free(), sandbox_realloc(), and total_allocated.

◆ sandbox_alloc()

static void * sandbox_alloc	(	void *	udata,
		duk_size_t	size )

static

Definition at line 40 of file duktape-1.5.2/examples/sandbox/sandbox.c.

                                                         {
    alloc_hdr *hdr;
 
    (void) udata;  /* Suppress warning. */
 
    if (size == 0) {
        return NULL;
    }
 
    if (total_allocated + size > max_allocated) {
        fprintf(stderr, "Sandbox maximum allocation size reached, %ld requested in sandbox_alloc\n",
                (long) size);
        fflush(stderr);
        return NULL;
    }
 
    hdr = (alloc_hdr *) malloc(size + sizeof(alloc_hdr));
    if (!hdr) {
        return NULL;
    }
    hdr->u.sz = size;
    total_allocated += size;
    sandbox_dump_memstate();
    return (void *) (hdr + 1);
}

References malloc, max_allocated, NULL, sandbox_dump_memstate(), alloc_hdr::sz, total_allocated, and alloc_hdr::u.

Referenced by main().

◆ sandbox_dump_memstate()

static void sandbox_dump_memstate ( void )

static

Definition at line 33 of file duktape-1.5.2/examples/sandbox/sandbox.c.

                                        {
#if 0
    fprintf(stderr, "Total allocated: %ld\n", (long) total_allocated);
    fflush(stderr);
#endif
}

References total_allocated.

Referenced by sandbox_alloc(), sandbox_free(), and sandbox_realloc().

◆ sandbox_fatal()

static void sandbox_fatal	(	duk_context *	ctx,
		duk_errcode_t	code,
		const char *	msg )

static

Definition at line 215 of file duktape-1.5.2/examples/sandbox/sandbox.c.

                                                                                 {
    (void) ctx;  /* Suppress warning. */
    fprintf(stderr, "FATAL %ld: %s\n", (long) code, (msg ? msg : "no message"));
    fflush(stderr);
    exit(1);  /* must not return */
}

Referenced by main().

◆ sandbox_free()

static void sandbox_free	(	void *	udata,
		void *	ptr )

static

Definition at line 129 of file duktape-1.5.2/examples/sandbox/sandbox.c.

                                                 {
    alloc_hdr *hdr;
 
    (void) udata;  /* Suppress warning. */
 
    if (!ptr) {
        return;
    }
    hdr = (alloc_hdr *) (((char *) ptr) - sizeof(alloc_hdr));
    total_allocated -= hdr->u.sz;
    free((void *) hdr);
    sandbox_dump_memstate();
}

References free, sandbox_dump_memstate(), alloc_hdr::sz, total_allocated, and alloc_hdr::u.

Referenced by main().

◆ sandbox_realloc()

static void * sandbox_realloc	(	void *	udata,
		void *	ptr,
		duk_size_t	size )

static

Definition at line 66 of file duktape-1.5.2/examples/sandbox/sandbox.c.

                                                                      {
    alloc_hdr *hdr;
    size_t old_size;
    void *t;
 
    (void) udata;  /* Suppress warning. */
 
    /* Handle the ptr-NULL vs. size-zero cases explicitly to minimize
     * platform assumptions.  You can get away with much less in specific
     * well-behaving environments.
     */
 
    if (ptr) {
        hdr = (alloc_hdr *) (((char *) ptr) - sizeof(alloc_hdr));
        old_size = hdr->u.sz;
 
        if (size == 0) {
            total_allocated -= old_size;
            free((void *) hdr);
            sandbox_dump_memstate();
            return NULL;
        } else {
            if (total_allocated - old_size + size > max_allocated) {
                fprintf(stderr, "Sandbox maximum allocation size reached, %ld requested in sandbox_realloc\n",
                        (long) size);
                fflush(stderr);
                return NULL;
            }
 
            t = realloc((void *) hdr, size + sizeof(alloc_hdr));
            if (!t) {
                return NULL;
            }
            hdr = (alloc_hdr *) t;
            total_allocated -= old_size;
            total_allocated += size;
            hdr->u.sz = size;
            sandbox_dump_memstate();
            return (void *) (hdr + 1);
        }
    } else {
        if (size == 0) {
            return NULL;
        } else {
            if (total_allocated + size > max_allocated) {
                fprintf(stderr, "Sandbox maximum allocation size reached, %ld requested in sandbox_realloc\n",
                        (long) size);
                fflush(stderr);
                return NULL;
            }
 
            hdr = (alloc_hdr *) malloc(size + sizeof(alloc_hdr));
            if (!hdr) {
                return NULL;
            }
            hdr->u.sz = size;
            total_allocated += size;
            sandbox_dump_memstate();
            return (void *) (hdr + 1);
        }
    }
}