static void on( const undelegatebw& del ) {
eosio_assert( del.unstake_cpu_quantity.quantity >= 0, "must stake a positive amount" );
eosio_assert( del.unstake_net_quantity.quantity >= 0, "must stake a positive amount" );
auto total_stake = del.unstake_cpu_quantity + del.unstake_net_quantity;
eosio_assert( total_stake.quantity >= 0, "must stake a positive amount" );
require_auth( del.from );
del_bandwidth_index_type del_index( SystemAccount, del.from );
total_resources_index_type total_index( SystemAccount, del.receiver );
//eosio_assert( is_account( del.receiver ), "can only delegate resources to an existing account" );
const auto& dbw = del_index.get(del.receiver);
eosio_assert( dbw.net_weight >= del.unstake_net_quantity, "insufficient staked net bandwidth" );
eosio_assert( dbw.cpu_weight >= del.unstake_cpu_quantity, "insufficient staked cpu bandwidth" );
del_index.update( dbw, del.from, [&]( auto& dbo ){
dbo.net_weight -= del.unstake_net_quantity;
dbo.cpu_weight -= del.unstake_cpu_quantity;
});
const auto& totals = total_index.get( del.receiver );
total_index.update( totals, 0, [&]( auto& tot ) {
tot.total_net_weight -= del.unstake_net_quantity;
tot.total_cpu_weight -= del.unstake_cpu_quantity;
});
set_resource_limits( totals.owner, totals.total_ram, totals.total_net_weight.quantity, totals.total_cpu_weight.quantity, 0 );
/// TODO: implement / enforce time delays on withdrawing
currency::inline_transfer( SystemAccount, del.from, total_stake, "unstake bandwidth" );
} // undelegatebw
static void proceed_child(traced_program *p)
{
set_resource_limits(p);
if (p->do_trace)
ptrace(PTRACE_TRACEME, 0, 0, 0);
for (int i = 0; i < p->argc; i++)
debug("argv[%d] = \"%s\"\n", i, p->argv[i]);
execve(p->argv[0], p->argv, NULL); // only returns if it fails
perror(NHEAD "execve");
exit(EXIT_FAILURE);
}
void
totem_resources_monitor_start (const char *input, gint wall_clock_time)
{
set_resource_limits (input);
if (wall_clock_time < 0)
return;
if (wall_clock_time > 0)
sleep_time = wall_clock_time;
finished = FALSE;
g_thread_new ("time-monitor", time_monitor, (gpointer) input);
}
static void run_child(const int slave_fd, const options_t * const options)
{
if (
!pty_prepare_for_login(slave_fd) ||
!set_resource_limits(&options->resource_limits) ||
!ignore_sighup()
)
exit(0);
execve(
options->program_path,
options->program_arguments,
options->program_environment
);
exit(0);
}
int
main (int argc, char **argv)
{
GOptionContext *option_ctx;
set_resource_limits ();
option_ctx = g_option_context_new ("Options");
g_option_context_add_main_entries (option_ctx, option_entries, NULL); /* FIXME: no translation domain */
if (!g_option_context_parse (option_ctx, &argc, &argv, NULL)
|| option_size == -1
|| option_input_filename == NULL
|| option_output_filename == NULL) {
g_printerr ("Invalid usage; type \"%s --help\" for instructions. All the options must be used.\n", argv[0]);
exit (EXIT_FAILURE);
}
gsf_init ();
read_thumbnail_and_write (option_input_filename, option_output_filename, option_size);
return 0;
}
int main(int argc, char *argv[]) {
duk_context *ctx = NULL;
int retval = 0;
int have_files = 0;
int have_eval = 0;
int interactive = 0;
int memlimit_high = 1;
int alloc_provider = ALLOC_DEFAULT;
int i;
#ifdef DUK_CMDLINE_AJSHEAP
alloc_provider = ALLOC_AJSHEAP;
#endif
/*
* Signal handling setup
*/
#ifndef NO_SIGNAL
set_sigint_handler();
/* This is useful at the global level; libraries should avoid SIGPIPE though */
/*signal(SIGPIPE, SIG_IGN);*/
#endif
/*
* Parse options
*/
for (i = 1; i < argc; i++) {
char *arg = argv[i];
if (!arg) {
goto usage;
}
if (strcmp(arg, "--restrict-memory") == 0) {
memlimit_high = 0;
} else if (strcmp(arg, "-i") == 0) {
interactive = 1;
} else if (strcmp(arg, "-e") == 0) {
have_eval = 1;
if (i == argc - 1) {
goto usage;
}
i++; /* skip code */
} else if (strcmp(arg, "--alloc-default") == 0) {
alloc_provider = ALLOC_DEFAULT;
} else if (strcmp(arg, "--alloc-logging") == 0) {
alloc_provider = ALLOC_LOGGING;
} else if (strcmp(arg, "--alloc-torture") == 0) {
alloc_provider = ALLOC_TORTURE;
} else if (strcmp(arg, "--alloc-hybrid") == 0) {
alloc_provider = ALLOC_HYBRID;
} else if (strcmp(arg, "--alloc-ajsheap") == 0) {
alloc_provider = ALLOC_AJSHEAP;
} else if (strlen(arg) >= 1 && arg[0] == '-') {
goto usage;
} else {
have_files = 1;
}
}
if (!have_files && !have_eval) {
interactive = 1;
}
/*
* Memory limit
*/
#ifndef NO_RLIMIT
set_resource_limits(memlimit_high ? MEM_LIMIT_HIGH : MEM_LIMIT_NORMAL);
#else
if (memlimit_high == 0) {
fprintf(stderr, "Warning: option --restrict-memory ignored, no rlimit support\n");
fflush(stderr);
}
#endif
/*
* Create context
*/
ctx = NULL;
if (!ctx && alloc_provider == ALLOC_LOGGING) {
#ifdef DUK_CMDLINE_ALLOC_LOGGING
ctx = duk_create_heap(duk_alloc_logging,
duk_realloc_logging,
duk_free_logging,
NULL,
NULL);
#else
fprintf(stderr, "Warning: option --alloc-logging ignored, no logging allocator support\n");
fflush(stderr);
#endif
}
if (!ctx && alloc_provider == ALLOC_TORTURE) {
#ifdef DUK_CMDLINE_ALLOC_TORTURE
ctx = duk_create_heap(duk_alloc_torture,
duk_realloc_torture,
duk_free_torture,
NULL,
NULL);
#else
fprintf(stderr, "Warning: option --alloc-torture ignored, no torture allocator support\n");
fflush(stderr);
#endif
}
if (!ctx && alloc_provider == ALLOC_HYBRID) {
#ifdef DUK_CMDLINE_ALLOC_HYBRID
void *udata = duk_alloc_hybrid_init();
if (!udata) {
fprintf(stderr, "Failed to init hybrid allocator\n");
fflush(stderr);
} else {
ctx = duk_create_heap(duk_alloc_hybrid,
duk_realloc_hybrid,
duk_free_hybrid,
udata,
NULL);
}
#else
fprintf(stderr, "Warning: option --alloc-hybrid ignored, no hybrid allocator support\n");
fflush(stderr);
#endif
}
if (!ctx && alloc_provider == ALLOC_AJSHEAP) {
#ifdef DUK_CMDLINE_AJSHEAP
ajsheap_init();
ctx = duk_create_heap(AJS_Alloc,
AJS_Realloc,
AJS_Free,
(void *) &ctx, /* alloc_udata */
NULL); /* fatal_handler */
#else
fprintf(stderr, "Warning: option --alloc-ajsheap ignored, no ajsheap allocator support\n");
fflush(stderr);
#endif
}
if (!ctx && alloc_provider == ALLOC_DEFAULT) {
ctx = duk_create_heap_default();
}
if (!ctx) {
fprintf(stderr, "Failed to create Duktape heap\n");
fflush(stderr);
exit(-1);
}
#ifdef DUK_CMDLINE_AJSHEAP
if (alloc_provider == ALLOC_AJSHEAP) {
fprintf(stdout, "Pool dump after heap creation\n");
fflush(stdout);
AJS_HeapDump();
fflush(stdout);
}
#endif
#ifdef DUK_CMDLINE_AJSHEAP
if (alloc_provider == ALLOC_AJSHEAP) {
ajsheap_register(ctx);
}
#endif
/*
* Execute any argument file(s)
*/
for (i = 1; i < argc; i++) {
char *arg = argv[i];
if (!arg) {
continue;
} else if (strlen(arg) == 2 && strcmp(arg, "-e") == 0) {
/* Here we know the eval arg exists but check anyway */
if (i == argc - 1) {
retval = 1;
goto cleanup;
}
if (handle_eval(ctx, argv[i + 1]) != 0) {
retval = 1;
goto cleanup;
}
i++; /* skip code */
continue;
} else if (strlen(arg) >= 1 && arg[0] == '-') {
continue;
}
if (handle_file(ctx, arg) != 0) {
retval = 1;
goto cleanup;
}
}
/*
* Enter interactive mode if options indicate it
*/
if (interactive) {
if (handle_interactive(ctx) != 0) {
retval = 1;
goto cleanup;
}
}
/*
* Cleanup and exit
*/
cleanup:
if (interactive) {
fprintf(stderr, "Cleaning up...\n");
fflush(stderr);
}
#ifdef DUK_CMDLINE_AJSHEAP
if (alloc_provider == ALLOC_AJSHEAP) {
fprintf(stdout, "Pool dump before duk_destroy_heap(), before forced gc\n");
fflush(stdout);
AJS_HeapDump();
fflush(stdout);
duk_gc(ctx, 0);
fprintf(stdout, "Pool dump before duk_destroy_heap(), after forced gc\n");
fflush(stdout);
AJS_HeapDump();
fflush(stdout);
}
#endif
if (ctx) {
duk_destroy_heap(ctx);
}
#ifdef DUK_CMDLINE_AJSHEAP
if (alloc_provider == ALLOC_AJSHEAP) {
fprintf(stdout, "Pool dump after duk_destroy_heap() (should have zero allocs)\n");
fflush(stdout);
AJS_HeapDump();
fflush(stdout);
}
#endif
return retval;
/*
* Usage
*/
usage:
fprintf(stderr, "Usage: duk [options] [<filenames>]\n"
"\n"
" -i enter interactive mode after executing argument file(s) / eval code\n"
" -e CODE evaluate code\n"
" --restrict-memory use lower memory limit (used by test runner)\n"
" --alloc-default use Duktape default allocator\n"
#ifdef DUK_CMDLINE_ALLOC_LOGGING
" --alloc-logging use logging allocator (writes to /tmp)\n"
#endif
#ifdef DUK_CMDLINE_ALLOC_TORTURE
" --alloc-torture use torture allocator\n"
#endif
#ifdef DUK_CMDLINE_ALLOC_HYBRID
" --alloc-hybrid use hybrid allocator\n"
#endif
#ifdef DUK_CMDLINE_AJSHEAP
" --alloc-ajsheap use ajsheap allocator (enabled by default with 'ajduk')\n"
#endif
"\n"
"If <filename> is omitted, interactive mode is started automatically.\n");
fflush(stderr);
exit(1);
}
int main(int argc, char **argv) {
int c, i;
struct emitter_config emitter_config;
struct option *getopt_options = NULL;
struct kv *extra_fields = NULL;
size_t extra_fields_len = 0;
/* defaults */
memset(&emitter_config, 0, sizeof(struct emitter_config));
emitter_config.port = 5001;
/* convert the 'option_doc' array into a 'struct option' array
* for use with getopt_long_only */
for (i = 0; options[i].name != NULL; i++) {
getopt_options = realloc(getopt_options, (i+1) * sizeof(struct option));
getopt_options[i].name = options[i].name;
getopt_options[i].has_arg = options[i].has_arg;
getopt_options[i].flag = NULL;
getopt_options[i].val = options[i].val;
}
/* Add one last item for the list terminator NULL */
getopt_options = realloc(getopt_options, (i+1) * sizeof(struct option));
getopt_options[i].name = NULL;
char *tmp;
while (i = -1, c = getopt_long_only(argc, argv, "+hv", getopt_options, &i), c != -1) {
/* TODO(sissel): handle args */
switch (c) {
case opt_ssl_ca_path:
emitter_config.ssl_ca_path = strdup(optarg);
break;
case opt_version:
printf("version unknown. Could be awesome.\n");
break;
case opt_help:
usage(argv[0]);
return 0;
case opt_host:
emitter_config.host = strdup(optarg);
break;
case opt_port:
emitter_config.port = (short)atoi(optarg);
break;
case opt_field:
tmp = strchr(optarg, '=');
if (tmp == NULL) {
printf("Invalid --field setting, expected 'foo=bar' form, " \
"didn't see '=' in '%s'", optarg);
usage(argv[0]);
exit(1);
}
extra_fields_len += 1;
extra_fields = realloc(extra_fields, extra_fields_len * sizeof(struct kv));
*tmp = '\0'; // turn '=' into null terminator
tmp++; /* skip to first char of value */
extra_fields[extra_fields_len - 1].key = strdup(optarg);
extra_fields[extra_fields_len - 1].key_len = strlen(optarg);
extra_fields[extra_fields_len - 1].value = strdup(tmp);
extra_fields[extra_fields_len - 1].value_len = strlen(tmp);
break;
default:
insist(i == -1, "Flag (--%s%s%s) known, but someone forgot to " \
"implement handling of it! This is certainly a bug.",
options[i].name,
options[i].has_arg ? " " : "",
options[i].has_arg ? optarg : "");
usage(argv[0]);
return 1;
}
}
free(getopt_options);
if (emitter_config.host == NULL) {
printf("Missing --host flag\n");
usage(argv[0]);
return 1;
}
if (emitter_config.port == 0) {
printf("Missing --port flag\n");
usage(argv[0]);
return 1;
}
argc -= optind;
argv += optind;
/* I'll handle write failures; no signals please */
signal(SIGPIPE, SIG_IGN);
insist(argc > 0, "No arguments given. What log files do you want shipped?");
/* Set resource (memory, open file, etc) limits based on the
* number of files being watched. */
set_resource_limits(argc);
pthread_t *harvesters = calloc(argc, sizeof(pthread_t));
/* no I/O threads needed since we use inproc:// only */
void *zmq = zmq_init(0 /* IO threads */);
/* Start harvesters for each path given */
for (i = 0; i < argc; i++) {
struct harvest_config *harvester = calloc(1, sizeof(struct harvest_config));
harvester->zmq = zmq;
harvester->zmq_endpoint = ZMQ_EMITTER_ENDPOINT;
harvester->path = argv[i];
harvester->fields = extra_fields;
harvester->fields_len = extra_fields_len;
pthread_create(&harvesters[i], NULL, harvest, harvester);
}
pthread_t emitter_thread;
emitter_config.zmq = zmq;
emitter_config.zmq_endpoint = ZMQ_EMITTER_ENDPOINT;
pthread_create(&emitter_thread, NULL, emitter, &emitter_config);
for (i = 0; i < argc; i++) {
pthread_join(harvesters[i], NULL);
}
printf("All harvesters completed. Exiting.\n");
free(harvesters);
/* TODO(sissel): Tell emitter to flush and exit */
return 1;
} /* main */
int main(int argc, char *argv[]) {
duk_context *ctx = NULL;
int retval = 0;
int have_files = 0;
int have_eval = 0;
int interactive = 0;
int memlimit_high = 1;
int alloc_provider = ALLOC_DEFAULT;
int ajsheap_log = 0;
int debugger = 0;
const char *compile_filename = NULL;
int i;
#ifdef DUK_CMDLINE_AJSHEAP
alloc_provider = ALLOC_AJSHEAP;
#endif
(void) ajsheap_log;
/*
* Signal handling setup
*/
#ifndef NO_SIGNAL
set_sigint_handler();
/* This is useful at the global level; libraries should avoid SIGPIPE though */
/*signal(SIGPIPE, SIG_IGN);*/
#endif
/*
* Parse options
*/
for (i = 1; i < argc; i++) {
char *arg = argv[i];
if (!arg) {
goto usage;
}
if (strcmp(arg, "--restrict-memory") == 0) {
memlimit_high = 0;
} else if (strcmp(arg, "-i") == 0) {
interactive = 1;
} else if (strcmp(arg, "-c") == 0) {
if (i == argc - 1) {
goto usage;
}
i++;
compile_filename = argv[i];
} else if (strcmp(arg, "-e") == 0) {
have_eval = 1;
if (i == argc - 1) {
goto usage;
}
i++; /* skip code */
} else if (strcmp(arg, "--alloc-default") == 0) {
alloc_provider = ALLOC_DEFAULT;
} else if (strcmp(arg, "--alloc-logging") == 0) {
alloc_provider = ALLOC_LOGGING;
} else if (strcmp(arg, "--alloc-torture") == 0) {
alloc_provider = ALLOC_TORTURE;
} else if (strcmp(arg, "--alloc-hybrid") == 0) {
alloc_provider = ALLOC_HYBRID;
} else if (strcmp(arg, "--alloc-ajsheap") == 0) {
alloc_provider = ALLOC_AJSHEAP;
} else if (strcmp(arg, "--ajsheap-log") == 0) {
ajsheap_log = 1;
} else if (strcmp(arg, "--debugger") == 0) {
debugger = 1;
} else if (strlen(arg) >= 1 && arg[0] == '-') {
goto usage;
} else {
have_files = 1;
}
}
if (!have_files && !have_eval) {
interactive = 1;
}
/*
* Memory limit
*/
#ifndef NO_RLIMIT
set_resource_limits(memlimit_high ? MEM_LIMIT_HIGH : MEM_LIMIT_NORMAL);
#else
if (memlimit_high == 0) {
fprintf(stderr, "Warning: option --restrict-memory ignored, no rlimit support\n");
fflush(stderr);
}
#endif
/*
* Create context
*/
ctx = NULL;
if (!ctx && alloc_provider == ALLOC_LOGGING) {
#ifdef DUK_CMDLINE_ALLOC_LOGGING
ctx = duk_create_heap(duk_alloc_logging,
duk_realloc_logging,
duk_free_logging,
(void *) 0xdeadbeef,
NULL);
#else
fprintf(stderr, "Warning: option --alloc-logging ignored, no logging allocator support\n");
fflush(stderr);
#endif
}
if (!ctx && alloc_provider == ALLOC_TORTURE) {
#ifdef DUK_CMDLINE_ALLOC_TORTURE
ctx = duk_create_heap(duk_alloc_torture,
duk_realloc_torture,
duk_free_torture,
(void *) 0xdeadbeef,
NULL);
#else
fprintf(stderr, "Warning: option --alloc-torture ignored, no torture allocator support\n");
fflush(stderr);
#endif
}
if (!ctx && alloc_provider == ALLOC_HYBRID) {
#ifdef DUK_CMDLINE_ALLOC_HYBRID
void *udata = duk_alloc_hybrid_init();
if (!udata) {
fprintf(stderr, "Failed to init hybrid allocator\n");
fflush(stderr);
} else {
ctx = duk_create_heap(duk_alloc_hybrid,
duk_realloc_hybrid,
duk_free_hybrid,
udata,
NULL);
}
#else
fprintf(stderr, "Warning: option --alloc-hybrid ignored, no hybrid allocator support\n");
fflush(stderr);
#endif
}
if (!ctx && alloc_provider == ALLOC_AJSHEAP) {
#ifdef DUK_CMDLINE_AJSHEAP
ajsheap_init();
ctx = duk_create_heap(
ajsheap_log ? ajsheap_alloc_wrapped : AJS_Alloc,
ajsheap_log ? ajsheap_realloc_wrapped : AJS_Realloc,
ajsheap_log ? ajsheap_free_wrapped : AJS_Free,
(void *) 0xdeadbeef, /* heap_udata: ignored by AjsHeap, use as marker */
NULL
); /* fatal_handler */
#else
fprintf(stderr, "Warning: option --alloc-ajsheap ignored, no ajsheap allocator support\n");
fflush(stderr);
#endif
}
if (!ctx && alloc_provider == ALLOC_DEFAULT) {
ctx = duk_create_heap_default();
}
if (!ctx) {
fprintf(stderr, "Failed to create Duktape heap\n");
fflush(stderr);
exit(-1);
}
#ifdef DUK_CMDLINE_AJSHEAP
if (alloc_provider == ALLOC_AJSHEAP) {
fprintf(stdout, "Pool dump after heap creation\n");
ajsheap_dump();
}
#endif
#ifdef DUK_CMDLINE_AJSHEAP
if (alloc_provider == ALLOC_AJSHEAP) {
ajsheap_register(ctx);
}
#endif
if (debugger) {
#ifdef DUK_CMDLINE_DEBUGGER_SUPPORT
fprintf(stderr, "Debugger enabled, create socket and wait for connection\n");
fflush(stderr);
duk_trans_socket_init();
duk_trans_socket_waitconn();
fprintf(stderr, "Debugger connected, call duk_debugger_attach() and then execute requested file(s)/eval\n");
fflush(stderr);
duk_debugger_attach(ctx,
duk_trans_socket_read_cb,
duk_trans_socket_write_cb,
duk_trans_socket_peek_cb,
duk_trans_socket_read_flush_cb,
duk_trans_socket_write_flush_cb,
debugger_detached,
(void *) 0xbeef1234);
#else
fprintf(stderr, "Warning: option --debugger ignored, no debugger support\n");
fflush(stderr);
#endif
}
#if 0
/* Manual test for duk_debugger_cooperate() */
{
for (i = 0; i < 60; i++) {
printf("cooperate: %d\n", i);
usleep(1000000);
duk_debugger_cooperate(ctx);
}
}
#endif
/*
* Execute any argument file(s)
*/
for (i = 1; i < argc; i++) {
char *arg = argv[i];
if (!arg) {
continue;
} else if (strlen(arg) == 2 && strcmp(arg, "-e") == 0) {
/* Here we know the eval arg exists but check anyway */
if (i == argc - 1) {
retval = 1;
goto cleanup;
}
if (handle_eval(ctx, argv[i + 1]) != 0) {
retval = 1;
goto cleanup;
}
i++; /* skip code */
continue;
} else if (strlen(arg) == 2 && strcmp(arg, "-c") == 0) {
i++; /* skip filename */
continue;
} else if (strlen(arg) >= 1 && arg[0] == '-') {
continue;
}
if (handle_file(ctx, arg, compile_filename) != 0) {
retval = 1;
goto cleanup;
}
}
/*
* Enter interactive mode if options indicate it
*/
if (interactive) {
if (handle_interactive(ctx) != 0) {
retval = 1;
goto cleanup;
}
}
/*
* Cleanup and exit
*/
cleanup:
if (interactive) {
fprintf(stderr, "Cleaning up...\n");
fflush(stderr);
}
#ifdef DUK_CMDLINE_AJSHEAP
if (alloc_provider == ALLOC_AJSHEAP) {
fprintf(stdout, "Pool dump before duk_destroy_heap(), before forced gc\n");
ajsheap_dump();
duk_gc(ctx, 0);
fprintf(stdout, "Pool dump before duk_destroy_heap(), after forced gc\n");
ajsheap_dump();
}
#endif
if (ctx) {
duk_destroy_heap(ctx);
}
#ifdef DUK_CMDLINE_AJSHEAP
if (alloc_provider == ALLOC_AJSHEAP) {
fprintf(stdout, "Pool dump after duk_destroy_heap() (should have zero allocs)\n");
ajsheap_dump();
}
#endif
return retval;
/*
* Usage
*/
usage:
fprintf(stderr, "Usage: duk [options] [<filenames>]\n"
"\n"
" -i enter interactive mode after executing argument file(s) / eval code\n"
" -e CODE evaluate code\n"
" -c FILE compile into bytecode (use with only one file argument)\n"
" --restrict-memory use lower memory limit (used by test runner)\n"
" --alloc-default use Duktape default allocator\n"
#ifdef DUK_CMDLINE_ALLOC_LOGGING
" --alloc-logging use logging allocator (writes to /tmp)\n"
#endif
#ifdef DUK_CMDLINE_ALLOC_TORTURE
" --alloc-torture use torture allocator\n"
#endif
#ifdef DUK_CMDLINE_ALLOC_HYBRID
" --alloc-hybrid use hybrid allocator\n"
#endif
#ifdef DUK_CMDLINE_AJSHEAP
" --alloc-ajsheap use ajsheap allocator (enabled by default with 'ajduk')\n"
" --ajsheap-log write alloc log to /tmp/ajduk-alloc-log.txt\n"
#endif
#ifdef DUK_CMDLINE_DEBUGGER_SUPPORT
" --debugger start example debugger\n"
#endif
"\n"
"If <filename> is omitted, interactive mode is started automatically.\n");
fflush(stderr);
exit(1);
}
int main(int argc, char *argv[]) {
duk_context *ctx = NULL;
int retval = 0;
int have_files = 0;
int interactive = 0;
int memlimit_high = 1;
int i;
/*
* Signal handling setup
*/
#ifndef NO_SIGNAL
set_sigint_handler();
/* This is useful at the global level; libraries should avoid SIGPIPE though */
/*signal(SIGPIPE, SIG_IGN);*/
#endif
/*
* Parse options
*/
for (i = 1; i < argc; i++) {
char *arg = argv[i];
if (!arg) {
goto usage;
}
if (strcmp(arg, "-r") == 0) {
memlimit_high = 0;
} else if (strcmp(arg, "-i") == 0) {
interactive = 1;
} else if (strlen(arg) >= 1 && arg[0] == '-') {
goto usage;
} else {
have_files = 1;
}
}
if (!have_files) {
interactive = 1;
}
/*
* Memory limit
*/
#ifndef NO_RLIMIT
set_resource_limits(memlimit_high ? MEM_LIMIT_HIGH : MEM_LIMIT_NORMAL);
#else
(void) memlimit_high; /* suppress warning */
#endif
/*
* Create context and execute any argument file(s)
*/
ctx = duk_create_heap_default();
#if 0
duk_ncurses_register(ctx);
duk_socket_register(ctx);
duk_fileio_register(ctx);
#endif
for (i = 1; i < argc; i++) {
char *arg = argv[i];
if (!arg) {
continue;
} else if (strlen(arg) >= 1 && arg[0] == '-') {
continue;
}
if (handle_file(ctx, arg) != 0) {
retval = 1;
goto cleanup;
}
}
/*
* Enter interactive mode if options indicate it
*/
if (interactive) {
if (handle_interactive(ctx) != 0) {
retval = 1;
goto cleanup;
}
}
/*
* Cleanup and exit
*/
cleanup:
if (interactive) {
fprintf(stderr, "Cleaning up...\n");
fflush(stderr);
}
if (ctx) {
duk_destroy_heap(ctx);
}
return retval;
/*
* Usage
*/
usage:
fprintf(stderr, "Usage: duk [-i] [-r] [<filenames>]\n"
"\n"
" -i enter interactive mode after executing argument file(s)\n"
" -r use lower memory limit (used by test runner)"
#ifdef NO_RLIMIT
" (disabled)\n"
#else
"\n"
#endif
"\n"
"If <filename> is omitted, interactive mode is started automatically.\n");
fflush(stderr);
exit(1);
}
/* init_ext_filter_process: get the external filter process going
* This is per-filter-instance (i.e., per-request) initialization.
*/
static apr_status_t init_ext_filter_process(ap_filter_t *f)
{
ef_ctx_t *ctx = f->ctx;
apr_status_t rc;
ef_dir_t *dc = ctx->dc;
const char * const *env;
ctx->proc = apr_pcalloc(ctx->p, sizeof(*ctx->proc));
rc = apr_procattr_create(&ctx->procattr, ctx->p);
ap_assert(rc == APR_SUCCESS);
rc = apr_procattr_io_set(ctx->procattr,
APR_CHILD_BLOCK,
APR_CHILD_BLOCK,
APR_CHILD_BLOCK);
ap_assert(rc == APR_SUCCESS);
rc = set_resource_limits(f->r, ctx->procattr);
ap_assert(rc == APR_SUCCESS);
if (dc->log_stderr > 0) {
rc = apr_procattr_child_err_set(ctx->procattr,
f->r->server->error_log, /* stderr in child */
NULL);
ap_assert(rc == APR_SUCCESS);
}
rc = apr_procattr_child_errfn_set(ctx->procattr, child_errfn);
ap_assert(rc == APR_SUCCESS);
apr_pool_userdata_set(f->r, ERRFN_USERDATA_KEY, apr_pool_cleanup_null, ctx->p);
rc = apr_procattr_error_check_set(ctx->procattr, 1);
if (rc != APR_SUCCESS) {
return rc;
}
/* add standard CGI variables as well as DOCUMENT_URI, DOCUMENT_PATH_INFO,
* and QUERY_STRING_UNESCAPED
*/
ap_add_cgi_vars(f->r);
ap_add_common_vars(f->r);
apr_table_setn(f->r->subprocess_env, "DOCUMENT_URI", f->r->uri);
apr_table_setn(f->r->subprocess_env, "DOCUMENT_PATH_INFO", f->r->path_info);
if (f->r->args) {
/* QUERY_STRING is added by ap_add_cgi_vars */
char *arg_copy = apr_pstrdup(f->r->pool, f->r->args);
ap_unescape_url(arg_copy);
apr_table_setn(f->r->subprocess_env, "QUERY_STRING_UNESCAPED",
ap_escape_shell_cmd(f->r->pool, arg_copy));
}
env = (const char * const *) ap_create_environment(ctx->p,
f->r->subprocess_env);
rc = apr_proc_create(ctx->proc,
ctx->filter->command,
(const char * const *)ctx->filter->args,
env, /* environment */
ctx->procattr,
ctx->p);
if (rc != APR_SUCCESS) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, rc, f->r,
"couldn't create child process to run `%s'",
ctx->filter->command);
return rc;
}
apr_pool_note_subprocess(ctx->p, ctx->proc, APR_KILL_AFTER_TIMEOUT);
/* We don't want the handle to the child's stdin inherited by any
* other processes created by httpd. Otherwise, when we close our
* handle, the child won't see EOF because another handle will still
* be open.
*/
apr_pool_cleanup_register(ctx->p, ctx->proc->in,
apr_pool_cleanup_null, /* other mechanism */
ef_close_file);
#if APR_FILES_AS_SOCKETS
{
apr_pollfd_t pfd = { 0 };
rc = apr_pollset_create(&ctx->pollset, 2, ctx->p, 0);
ap_assert(rc == APR_SUCCESS);
pfd.p = ctx->p;
pfd.desc_type = APR_POLL_FILE;
pfd.reqevents = APR_POLLOUT;
pfd.desc.f = ctx->proc->in;
rc = apr_pollset_add(ctx->pollset, &pfd);
ap_assert(rc == APR_SUCCESS);
pfd.reqevents = APR_POLLIN;
pfd.desc.f = ctx->proc->out;
rc = apr_pollset_add(ctx->pollset, &pfd);
ap_assert(rc == APR_SUCCESS);
}
#endif
return APR_SUCCESS;
}
ACTION( SystemAccount, regproducer ) {
account_name producer;
bytes producer_key;
EOSLIB_SERIALIZE( regproducer, (producer)(producer_key) )
};
ACTION( SystemAccount, regproxy ) {
account_name proxy_to_register;
EOSLIB_SERIALIZE( regproxy, (proxy_to_register) )
};
ACTION( SystemAccount, delegatebw ) {
account_name from;
account_name receiver;
typename currency::token_type stake_net_quantity;
typename currency::token_type stake_cpu_quantity;
EOSLIB_SERIALIZE( delegatebw, (from)(receiver)(stake_net_quantity)(stake_cpu_quantity) )
};
ACTION( SystemAccount, undelegatebw ) {
account_name from;
account_name receiver;
typename currency::token_type unstake_net_quantity;
typename currency::token_type unstake_cpu_quantity;
EOSLIB_SERIALIZE( undelegatebw, (from)(receiver)(unstake_net_quantity)(unstake_cpu_quantity) )
};
ACTION( SystemAccount, nonce ) {
eosio::string value;
EOSLIB_SERIALIZE( nonce, (value) )
};
/// new id options:
// 1. hash + collision
// 2. incrementing count (key=> tablename
static void on( const delegatebw& del ) {
eosio_assert( del.stake_cpu_quantity.quantity >= 0, "must stake a positive amount" );
eosio_assert( del.stake_net_quantity.quantity >= 0, "must stake a positive amount" );
auto total_stake = del.stake_cpu_quantity + del.stake_net_quantity;
eosio_assert( total_stake.quantity >= 0, "must stake a positive amount" );
require_auth( del.from );
del_bandwidth_index_type del_index( SystemAccount, del.from );
total_resources_index_type total_index( SystemAccount, del.receiver );
//eosio_assert( is_account( del.receiver ), "can only delegate resources to an existing account" );
auto itr = del_index.find( del.receiver);
if( itr != nullptr ) {
del_index.emplace( del.from, [&]( auto& dbo ){
dbo.from = del.from;
dbo.to = del.receiver;
dbo.net_weight = del.stake_net_quantity;
dbo.cpu_weight = del.stake_cpu_quantity;
});
}
else {
del_index.update( *itr, del.from, [&]( auto& dbo ){
dbo.net_weight = del.stake_net_quantity;
dbo.cpu_weight = del.stake_cpu_quantity;
});
}
auto tot_itr = total_index.find( del.receiver );
if( tot_itr == nullptr ) {
tot_itr = &total_index.emplace( del.from, [&]( auto& tot ) {
tot.owner = del.receiver;
tot.total_net_weight += del.stake_net_quantity;
tot.total_cpu_weight += del.stake_cpu_quantity;
});
} else {
total_index.update( *tot_itr, 0, [&]( auto& tot ) {
tot.total_net_weight += del.stake_net_quantity;
tot.total_cpu_weight += del.stake_cpu_quantity;
});
}
set_resource_limits( tot_itr->owner, tot_itr->total_ram, tot_itr->total_net_weight.quantity, tot_itr->total_cpu_weight.quantity, 0 );
currency::inline_transfer( del.from, SystemAccount, total_stake, "stake bandwidth" );
} // delegatebw
int main(int argc, char *argv[]) {
duk_context *ctx = NULL;
int retval = 0;
int have_files = 0;
int have_eval = 0;
int interactive = 0;
int memlimit_high = 1;
int alloc_provider = ALLOC_DEFAULT;
int ajsheap_log = 0;
int debugger = 0;
int recreate_heap = 0;
int verbose = 0;
const char *compile_filename = NULL;
int i;
#ifdef DUK_CMDLINE_AJSHEAP
alloc_provider = ALLOC_AJSHEAP;
#endif
(void) ajsheap_log;
/*
* Signal handling setup
*/
#ifndef NO_SIGNAL
set_sigint_handler();
/* This is useful at the global level; libraries should avoid SIGPIPE though */
/*signal(SIGPIPE, SIG_IGN);*/
#endif
/*
* Parse options
*/
for (i = 1; i < argc; i++) {
char *arg = argv[i];
if (!arg) {
goto usage;
}
if (strcmp(arg, "--restrict-memory") == 0) {
memlimit_high = 0;
} else if (strcmp(arg, "-i") == 0) {
interactive = 1;
} else if (strcmp(arg, "-c") == 0) {
if (i == argc - 1) {
goto usage;
}
i++;
compile_filename = argv[i];
} else if (strcmp(arg, "-e") == 0) {
have_eval = 1;
if (i == argc - 1) {
goto usage;
}
i++; /* skip code */
} else if (strcmp(arg, "--alloc-default") == 0) {
alloc_provider = ALLOC_DEFAULT;
} else if (strcmp(arg, "--alloc-logging") == 0) {
alloc_provider = ALLOC_LOGGING;
} else if (strcmp(arg, "--alloc-torture") == 0) {
alloc_provider = ALLOC_TORTURE;
} else if (strcmp(arg, "--alloc-hybrid") == 0) {
alloc_provider = ALLOC_HYBRID;
} else if (strcmp(arg, "--alloc-ajsheap") == 0) {
alloc_provider = ALLOC_AJSHEAP;
} else if (strcmp(arg, "--ajsheap-log") == 0) {
ajsheap_log = 1;
} else if (strcmp(arg, "--debugger") == 0) {
debugger = 1;
} else if (strcmp(arg, "--recreate-heap") == 0) {
recreate_heap = 1;
} else if (strcmp(arg, "--verbose") == 0) {
verbose = 1;
} else if (strlen(arg) >= 1 && arg[0] == '-') {
goto usage;
} else {
have_files = 1;
}
}
if (!have_files && !have_eval) {
interactive = 1;
}
/*
* Memory limit
*/
#ifndef NO_RLIMIT
set_resource_limits(memlimit_high ? MEM_LIMIT_HIGH : MEM_LIMIT_NORMAL);
#else
if (memlimit_high == 0) {
fprintf(stderr, "Warning: option --restrict-memory ignored, no rlimit support\n");
fflush(stderr);
}
#endif
/*
* Create heap
*/
ctx = create_duktape_heap(alloc_provider, debugger);
/*
* Execute any argument file(s)
*/
for (i = 1; i < argc; i++) {
char *arg = argv[i];
if (!arg) {
continue;
} else if (strlen(arg) == 2 && strcmp(arg, "-e") == 0) {
/* Here we know the eval arg exists but check anyway */
if (i == argc - 1) {
retval = 1;
goto cleanup;
}
if (handle_eval(ctx, argv[i + 1]) != 0) {
retval = 1;
goto cleanup;
}
i++; /* skip code */
continue;
} else if (strlen(arg) == 2 && strcmp(arg, "-c") == 0) {
i++; /* skip filename */
continue;
} else if (strlen(arg) >= 1 && arg[0] == '-') {
continue;
}
if (verbose) {
fprintf(stderr, "*** Executing file: %s\n", arg);
fflush(stderr);
}
if (handle_file(ctx, arg, compile_filename) != 0) {
retval = 1;
goto cleanup;
}
if (recreate_heap) {
if (verbose) {
fprintf(stderr, "*** Recreating heap...\n");
fflush(stderr);
}
destroy_duktape_heap(ctx, alloc_provider);
ctx = create_duktape_heap(alloc_provider, debugger);
}
}
/*
* Enter interactive mode if options indicate it
*/
if (interactive) {
if (handle_interactive(ctx) != 0) {
retval = 1;
goto cleanup;
}
}
/*
* Cleanup and exit
*/
cleanup:
if (interactive) {
fprintf(stderr, "Cleaning up...\n");
fflush(stderr);
}
if (ctx) {
destroy_duktape_heap(ctx, alloc_provider);
}
ctx = NULL;
return retval;
/*
* Usage
*/
usage:
fprintf(stderr, "Usage: duk [options] [<filenames>]\n"
"\n"
" -i enter interactive mode after executing argument file(s) / eval code\n"
" -e CODE evaluate code\n"
" -c FILE compile into bytecode (use with only one file argument)\n"
" --verbose verbose messages to stderr\n"
" --restrict-memory use lower memory limit (used by test runner)\n"
" --alloc-default use Duktape default allocator\n"
#ifdef DUK_CMDLINE_ALLOC_LOGGING
" --alloc-logging use logging allocator (writes to /tmp)\n"
#endif
#ifdef DUK_CMDLINE_ALLOC_TORTURE
" --alloc-torture use torture allocator\n"
#endif
#ifdef DUK_CMDLINE_ALLOC_HYBRID
" --alloc-hybrid use hybrid allocator\n"
#endif
#ifdef DUK_CMDLINE_AJSHEAP
" --alloc-ajsheap use ajsheap allocator (enabled by default with 'ajduk')\n"
" --ajsheap-log write alloc log to /tmp/ajduk-alloc-log.txt\n"
#endif
#ifdef DUK_CMDLINE_DEBUGGER_SUPPORT
" --debugger start example debugger\n"
#endif
" --recreate-heap recreate heap after every file\n"
"\n"
"If <filename> is omitted, interactive mode is started automatically.\n");
fflush(stderr);
exit(1);
}
