t_args *get_args(int argc, char **argv)
{
t_args *args;
args = MAL1(t_args);
args->args = MAL1(char*);
args->args[0] = NULL;
args->args_count = 0;
args->flags = 0;
while (--argc > 0 && argv++)
if (ft_strequ(*argv, "--"))
break ;
else if (**argv == '-' && *(*argv + 1) != '\0')
read_flags(args, *argv, *argv);
else
{
add_arg(args, *argv);
break ;
}
while (--argc > 0 && argv++)
add_arg(args, *argv);
if (args->args_count == 0)
add_arg(args, ".");
return (args);
}
rule_set * mk_loop_counter::operator()(rule_set const & source) {
m_refs.reset();
m_old2new.reset();
m_new2old.reset();
rule_manager& rm = source.get_rule_manager();
rule_set * result = alloc(rule_set, m_ctx);
unsigned sz = source.get_num_rules();
rule_ref new_rule(rm);
app_ref_vector tail(m);
app_ref head(m);
svector<bool> neg;
rule_counter& vc = rm.get_counter();
for (unsigned i = 0; i < sz; ++i) {
tail.reset();
neg.reset();
rule & r = *source.get_rule(i);
unsigned cnt = vc.get_max_rule_var(r)+1;
unsigned utsz = r.get_uninterpreted_tail_size();
unsigned tsz = r.get_tail_size();
for (unsigned j = 0; j < utsz; ++j, ++cnt) {
tail.push_back(add_arg(source, *result, r.get_tail(j), cnt));
neg.push_back(r.is_neg_tail(j));
}
for (unsigned j = utsz; j < tsz; ++j) {
tail.push_back(r.get_tail(j));
neg.push_back(false);
}
head = add_arg(source, *result, r.get_head(), cnt);
// set the loop counter to be an increment of the previous
bool found = false;
unsigned last = head->get_num_args()-1;
for (unsigned j = 0; !found && j < utsz; ++j) {
if (head->get_decl() == tail[j]->get_decl()) {
tail.push_back(m.mk_eq(head->get_arg(last),
a.mk_add(tail[j]->get_arg(last),
a.mk_numeral(rational(1), true))));
neg.push_back(false);
found = true;
}
}
// initialize loop counter to 0 if none was found.
if (!found) {
expr_ref_vector args(m);
args.append(head->get_num_args(), head->get_args());
args[last] = a.mk_numeral(rational(0), true);
head = m.mk_app(head->get_decl(), args.size(), args.c_ptr());
}
new_rule = rm.mk(head, tail.size(), tail.c_ptr(), neg.c_ptr(), r.name(), true);
result->add_rule(new_rule);
}
// model converter: remove references to extra argument.
// proof converter: remove references to extra argument as well.
return result;
}
char *parse_args (const char *ptr, define_t *define, list_t **curr_arg_set) {
int num_args = 0;
if (curr_arg_set == NULL)
return NULL;
if (*ptr != '(' && define->num_args == 0)
return (char *) ptr;
*curr_arg_set = add_arg_set();
//then parse each argument and store its value
if (*ptr == '(') {
ptr = skip_whitespace(ptr + 1);
if (*ptr != ')' && !is_end_of_code_line(ptr))
{
char *word = NULL;
arg_context_t context = ARG_CONTEXT_INITIALIZER;
while ((word = extract_arg_string(&ptr, &context)) != NULL)
{
if (num_args >= define->num_args) {
SetLastSPASMWarning(SPASM_WARN_MACRO_TOO_MANY_ARGS, define->name);
break;
}
//int nSession = StartSPASMErrorSession();
if (*define->args[num_args] == '@')
{
add_arg(strdup(define->args[num_args++]), strdup(word), *curr_arg_set);
}
else
{
label_t *label = search_labels(define->name);
add_arg(strdup(define->args[num_args++]), eval(word), *curr_arg_set);
//free(evald_word);
}
//AddSPASMErrorSessionAnnotation(nSession, "Error during evaluation of macro '%s' argument '%s'", define->name, define->args[num_args - 1]);
//ReplaySPASMErrorSession(nSession);
//EndSPASMErrorSession(nSession);
}
}
if (*ptr == ')') ptr++;
}
//fill in the undefined arguments
while (num_args < define->num_args)
add_arg (strdup (define->args[num_args++]), NULL, *curr_arg_set);
return (char *) ptr;
}
static void
add_args(char *first_arg, ...)
{
va_list ap;
char* arg;
add_arg(first_arg);
va_start(ap, first_arg);
while ((arg = va_arg(ap, char *)) != NULL) {
add_arg(arg);
}
va_end(ap);
}
/******************************************************************************
install_db()
Install the a database.
******************************************************************************/
void install_db(char *datadir)
{
arg_list_t al;
int err, i;
char input[PATH_MAX];
char output[PATH_MAX];
char error[PATH_MAX];
// input file
snprintf(input, PATH_MAX, "%s/bin/test_db.sql", base_dir);
snprintf(output, PATH_MAX, "%s/install.out", datadir);
snprintf(error, PATH_MAX, "%s/install.err", datadir);
// args
init_args(&al);
add_arg(&al, mysqld_file);
add_arg(&al, "--no-defaults");
add_arg(&al, "--bootstrap");
add_arg(&al, "--skip-grant-tables");
add_arg(&al, "--basedir=%s", base_dir);
add_arg(&al, "--datadir=%s", datadir);
add_arg(&al, "--skip-innodb");
add_arg(&al, "--skip-bdb");
// spawn
if ((err = spawn(mysqld_file, &al, TRUE, input, output, error)) != 0)
{
die("Unable to create database.");
}
// free args
free_args(&al);
}
void arg_value(uint8_t event, context_t *context)
{
if ((event == EVENT_HELP) ||
(event == EVENT_PROMPT))
{
buffer_str(&gMnuBuffer, "\nVAL>");
}
else if (event == EVENT_BACKSP) {
if (context->substate > 0) {
context->substate--;
context->currentArg--;
}
else {
}
}
else if ((context->substate == 0 && event >= '0' && event <= '9') ||
(context->substate == 1 && event >= '0' && event <= '9') ||
(context->substate == 2 && event >= '0' && event <= '9'))
{
buffer_ch(&gMnuBuffer, event);
add_arg(context, event - '0');
(context->substate)++;
if (context->substate == 3) {
execute(context);
change_state(context, menu_root);
}
}
else {
invalid_character(context);
}
}
static int opt_parse(struct fuse_opt_context *ctx)
{
if (ctx->argc) {
if (add_arg(ctx, ctx->argv[0]) == -1)
return -1;
}
for (ctx->argctr = 1; ctx->argctr < ctx->argc; ctx->argctr++)
if (process_one(ctx, ctx->argv[ctx->argctr]) == -1)
return -1;
if (ctx->opts) {
if (fuse_opt_insert_arg(&ctx->outargs, 1, "-o") == -1 ||
fuse_opt_insert_arg(&ctx->outargs, 2, ctx->opts) == -1)
return -1;
}
/* If option separator ("--") is the last argument, remove it */
if (ctx->nonopt && ctx->nonopt == ctx->outargs.argc &&
strcmp(ctx->outargs.argv[ctx->outargs.argc - 1], "--") == 0) {
free(ctx->outargs.argv[ctx->outargs.argc - 1]);
ctx->outargs.argv[--ctx->outargs.argc] = NULL;
}
return 0;
}
void arg_meas(uint8_t event, context_t *context)
{
#define AMEAS_PROMPT "\nMEA>"
if (event == EVENT_HELP) {
buffer_nl(&gMnuBuffer);
buffer_ch(&gMnuBuffer, MEAS_BEGIN);
buffer_str(&gMnuBuffer, " .. ");
buffer_ch(&gMnuBuffer, MEAS_END);
buffer_str(&gMnuBuffer, AMEAS_PROMPT);
}
else if (event == EVENT_PROMPT) {
buffer_str(&gMnuBuffer, AMEAS_PROMPT);
}
else if (event == EVENT_BACKSP) {
change_state(context, &menu_meas);
}
else if ((event >= MEAS_BEGIN) && (event <= MEAS_END)) {
add_arg(context, event - MEAS_BEGIN);
buffer_ch(&gMnuBuffer, event);
if ((context->action == act_meas_high) ||
(context->action == act_meas_low))
{
change_state(context, arg_value);
}
else {
change_state(context, menu_root);
}
}
else {
invalid_character(context);
}
}
int start_cc() {
const char *compiler = getenv("CC_LOCATION");
STARTUPINFOA si = { .cb = sizeof(STARTUPINFOA) };
PROCESS_INFORMATION pi;
while(!CreateProcessA(compiler, cc_command_line, NULL, NULL, 0, 0, NULL, NULL, &si, &pi)) {
if(compiler) {
compiler = NULL;
continue;
}
fprintf(stderr, "CreateProcessA failed, error %lu\n", GetLastError());
exit(127);
}
unsigned long int r;
if(WaitForSingleObject(pi.hProcess, INFINITE) == 0xffffffff) {
unsigned long int e = GetLastError();
fprintf(stderr, "WaitForSingleObject failed, error %lu\n", e);
return -e;
}
if(!GetExitCodeProcess(pi.hProcess, &r)) {
unsigned long int e = GetLastError();
fprintf(stderr, "GetExitCodeProcess failed, error %lu\n", e);
return -e;
}
return r;
}
void define(const char *d) {
char buffer[2 + strlen(d) + 1];
strcpy(buffer, "-D");
strcpy(buffer + 2, d);
add_arg(buffer);
}
std::string get_image_identifier(const std::string qualifiers,
const image2d &image)
{
add_arg(qualifiers, "image", image);
return "image";
}
void arg_on_off(uint8_t event, context_t *context)
{
#define AONOFF_PROMPT "\nSTA>"
switch (event) {
case EVENT_HELP:
case EVENT_PROMPT:
buffer_str(&gMnuBuffer, AONOFF_PROMPT);
break;
case EVENT_BACKSP:
if (context->action == act_timer_activate) {
change_state(context, arg_timer);
}
else {
change_state(context, menu_root);
}
break;
case '0':
case '1':
add_arg(context, event - '0');
if (context->action == act_timer_activate) {
execute(context);
}
change_state(context, menu_root);
break;
default:
invalid_character(context);
break;
}
}
/******************************************************************************
read_defaults()
Read the defaults.
******************************************************************************/
void read_defaults(arg_list_t *pal)
{
arg_list_t al;
char defaults_file[PATH_MAX];
char mydefaults[PATH_MAX];
char line[PATH_MAX];
FILE *fp;
// defaults output file
snprintf(defaults_file, PATH_MAX, "%s/bin/defaults.out", basedir);
remove(defaults_file);
// mysqladmin file
snprintf(mydefaults, PATH_MAX, "%s/bin/my_print_defaults", basedir);
// args
init_args(&al);
add_arg(&al, mydefaults);
if (default_option[0]) add_arg(&al, default_option);
add_arg(&al, "mysqld");
add_arg(&al, "mysql_install_db");
spawn(mydefaults, &al, TRUE, NULL, defaults_file, NULL);
free_args(&al);
// gather defaults
if((fp = fopen(defaults_file, "r")) != NULL)
{
while(fgets(line, PATH_MAX, fp))
{
char *p;
// remove end-of-line character
if ((p = strrchr(line, '\n')) != NULL) *p = '\0';
// add the option as an argument
add_arg(pal, line);
}
fclose(fp);
}
// remove file
remove(defaults_file);
}
void add_library(const char *lib) {
//fprintf(stderr, "function: add_library(%p<%s>)\n", lib, lib);
size_t len = strlen(lib);
if(strncasecmp(lib + len - 4, ".lib", 4) == 0) len -= 4;
char buffer[2 + len + 1];
strcpy(buffer, "-l");
memcpy(buffer + 2, lib, len);
buffer[2 + len] = 0;
add_arg(buffer);
}
void deserialize_args(t_stack_entry **entry, void **serialized_data, int *serialized_data_size, int cant_args) {
int indice = 0;
t_arg * aux_arg = NULL;
if(cant_args > 0) {
for(indice = 0; indice < cant_args; indice++ ) {
aux_arg = calloc(1, sizeof(t_arg));
deserialize_data(&aux_arg->page_number, sizeof(int), serialized_data, serialized_data_size);
deserialize_data(&aux_arg->offset, sizeof(int), serialized_data, serialized_data_size);
deserialize_data(&aux_arg->tamanio, sizeof(int), serialized_data, serialized_data_size);
add_arg(entry, aux_arg);
}
}
}
int disable_warning_by_number(unsigned int number) {
if(number > 4999) return -1;
int i;
for(i = 0; i < sizeof gcc_to_cl / sizeof(struct warning_table); i++) {
struct warning_table *p = gcc_to_cl + i;
if(p->number == number) {
char buffer[5 + strlen(p->name) + 1];
memcpy(buffer, "-Wno-", 4);
strcpy(buffer + 4, p->name);
add_arg(buffer);
return 1;
}
}
return 0;
}
static int call_proc(struct fuse_opt_context *ctx, const char *arg, int key,
int iso)
{
if (key == FUSE_OPT_KEY_DISCARD)
return 0;
if (key != FUSE_OPT_KEY_KEEP && ctx->proc) {
int res = ctx->proc(ctx->data, arg, key, &ctx->outargs);
if (res == -1 || !res)
return res;
}
if (iso)
return add_opt(ctx, arg);
else
return add_arg(ctx, arg);
}
bool gcc_cmdlinet::parse(int argc, const char **argv)
{
assert(argc>0);
add_arg(argv[0]);
argst args;
args.reserve(argc-1);
for(int i=1; i<argc; i++)
args.push_back(argv[i]);
bool result=parse_arguments(args, false);
parse_specs();
return result;
}
void stack(const std::string section, bool clear = true)
{
if (l2opts.send_delay)
{
char buf[15];
snprintf(buf,sizeof(buf),"delay=%d",l2opts.send_delay);
add_arg(buf);
do_filter("pace");
}
ITER(i,filters)
ADD((*ini[section])["filters"],(*i));
if (l2opts.flags & FLAG_B_TPUARTS_ACKGROUP)
(*ini[section])["ack-group"] = "true";
if (l2opts.flags & FLAG_B_TPUARTS_ACKINDIVIDUAL)
(*ini[section])["ack-individual"] = "true";
if (l2opts.flags & FLAG_B_TPUARTS_DISCH_RESET)
(*ini[section])["reset"] = "true";
if (l2opts.flags & FLAG_B_NO_MONITOR)
(*ini[section])["monitor"] = "false";
ITER(i, more_args)
(*ini[section])[i->first] = i->second;
more_args.clear();
if (tracelevel >= 0 || errorlevel >= 0 || no_timestamps) {
char b1[10],b2[50];
snprintf(b2,sizeof(b2),"debug-%s",section.c_str());
(*ini[section])["debug"] = b2;
if (tracelevel >= 0)
{
snprintf(b1,sizeof(b1),"0x%x",tracelevel);
(*ini[b2])["trace-mask"] = b1;
}
if (errorlevel >= 0)
{
snprintf(b1,sizeof(b1),"0x%x",errorlevel);
(*ini[b2])["error-level"] = b1;
}
if (no_timestamps)
{
(*ini[b2])["timestamps"] = "false";
}
}
if (clear)
reset();
}
/******************************************************************************
mysql_install_db()
Install the database.
******************************************************************************/
int mysql_install_db(int argc, char *argv[])
{
arg_list_t al;
int i, j, err;
char skip;
// private options
static char *private_options[] =
{
"--autoclose",
"--sql-file=",
NULL
};
// args
init_args(&al);
add_arg(&al, "%s", mysqld);
// parent args
for(i = 1; i < argc; i++)
{
skip = FALSE;
// skip private arguments
for (j=0; private_options[j]; j++)
{
if(!strnicmp(argv[i], private_options[j], strlen(private_options[j])))
{
skip = TRUE;
break;
}
}
if (!skip) add_arg(&al, "%s", argv[i]);
}
add_arg(&al, "--bootstrap");
add_arg(&al, "--skip-grant-tables");
add_arg(&al, "--skip-innodb");
add_arg(&al, "--skip-bdb");
// spawn mysqld
err = spawn(mysqld, &al, TRUE, sql_file, out_log, err_log);
// free args
free_args(&al);
return err;
}
/******************************************************************************
get_options()
Get the options.
******************************************************************************/
void get_options(int argc, char *argv[])
{
arg_list_t al;
// start defaults
start_defaults(argc, argv);
// default file arguments
init_args(&al);
add_arg(&al, "ignore");
read_defaults(&al);
parse_args(al.argc, al.argv);
free_args(&al);
// command-line arguments
parse_args(argc, argv);
// finish defaults
finish_defaults();
}
static int process_one(struct fuse_opt_context *ctx, const char *arg)
{
if (ctx->nonopt || arg[0] != '-')
return call_proc(ctx, arg, FUSE_OPT_KEY_NONOPT, 0);
else if (arg[1] == 'o') {
if (arg[2])
return process_option_group(ctx, arg + 2);
else {
if (next_arg(ctx, arg) == -1)
return -1;
return process_option_group(ctx, ctx->argv[ctx->argctr]);
}
} else if (arg[1] == '-' && !arg[2]) {
if (add_arg(ctx, arg) == -1)
return -1;
ctx->nonopt = ctx->outargs.argc;
return 0;
} else
return process_gopt(ctx, arg, 0);
}
ExprPtr IoBlock::call(ArgList args, std::size_t num_args)
{
if (!empty())
{
char const* errorPoint = "before eval";
IoMessage* m;
try
{
m = new_message(io_target, "IoBlock");
errorPoint = "while adding args";
for (int i = 0; i < num_args; ++i)
add_arg(m, args[i]);
errorPoint = "on activate";
IoObject* io_obj = activate(m);
errorPoint = "create IoObjectExpr";
TypeIndex from_type = FromIoTypeInfo::create_index(get_type_name(io_obj));
if (type_system->has_type(from_type))
return create_expr(io_obj, from_type);
else
return Term<IoObject*>::create(io_obj);
}
catch (Iocaste::ScriptException const& exc)
{
// TODO: assoc addn'l info w/exp.
throw;
}
// TODO: Create LikeMagic exception object.
catch (std::exception const& e)
{
throw Iocaste::IoStateError(io_block, std::string() + "Error in IoBlock " + errorPoint + ": " + e.what(), m);
}
}
else
{
throw std::logic_error("Tried to eval an empty block.");
}
}
static void test_common()
{
try
{
message m(1);
add_arg(m);
m << m;
boost::thread_group thrs;
for (std::size_t i=0; i<lv1_thr_num; ++i)
{
thrs.create_thread(boost::bind(&message_ut::lv1_thr, m));
}
thrs.join_all();
//std::cout << "\n///----------------------------------------------------------\n" << std::endl;
}
catch (std::exception& ex)
{
std::cerr << ex.what() << std::endl;
}
}
static int opt_parse(struct fuse_opt_context *ctx)
{
if (ctx->argc) {
if (add_arg(ctx, ctx->argv[0]) == -1)
return -1;
}
for (ctx->argctr = 1; ctx->argctr < ctx->argc; ctx->argctr++)
if (process_one(ctx, ctx->argv[ctx->argctr]) == -1)
return -1;
if (ctx->opts) {
if (fuse_opt_insert_arg(&ctx->outargs, 1, "-o") == -1 ||
fuse_opt_insert_arg(&ctx->outargs, 2, ctx->opts) == -1)
return -1;
}
if (ctx->nonopt && ctx->nonopt == ctx->outargs.argc) {
free(ctx->outargs.argv[ctx->outargs.argc - 1]);
ctx->outargs.argv[--ctx->outargs.argc] = NULL;
}
return 0;
}
void arg_timer(uint8_t event, context_t *context)
{
#define ATIMER_PROMPT "\nTIM>"
if (event == EVENT_HELP) {
buffer_nl(&gMnuBuffer);
buffer_ch(&gMnuBuffer, TIMER_BEGIN);
buffer_str(&gMnuBuffer, " .. ");
buffer_ch(&gMnuBuffer, TIMER_END);
buffer_str(&gMnuBuffer, ATIMER_PROMPT);
}
else if (event == EVENT_PROMPT) {
buffer_str(&gMnuBuffer, ATIMER_PROMPT);
}
else if (event == EVENT_BACKSP) {
change_state(context, &menu_timer);
}
else if ((event >= TIMER_BEGIN) && (event <= TIMER_END)) {
add_arg(context, event - TIMER_BEGIN);
buffer_ch(&gMnuBuffer, event);
if ((context->action == act_timer_begin) ||
(context->action == act_timer_end))
{
change_state(context, arg_clock);
}
else if (context->action == act_timer_activate) {
change_state(context, &arg_on_off);
}
else {
change_state(context, &menu_root);
}
}
else {
invalid_character(context);
}
}
int
process_optvalue(const char *optname, struct arg *cur, const char *optval)
{
int ok = True;
long numeric;
char *endptr;
const struct dataset *ds;
switch (cur->type) {
case ARGTYPE_NUMERIC:
if ((numeric = strtol(optval, &endptr, 10)) == 0) {
if (endptr == optval) {
printf("Error: %s needs a numeric argument (given %s)\n", optname, optval);
ok = False;
break;
}
cur->data.i = (int)numeric;
}
break;
case ARGTYPE_STRING:
cur->data.p = optval;
break;
case ARGTYPE_STRING_MULTISINGLE:
ok = add_arg(&cur->data.dl, optval);
break;
case ARGTYPE_CHOICE:
ds = match_dataset(cur->dataset, optval);
if (ds) {
cur->data.i = ds->dset_value;
} else {
printf("Error: Illegal value for %s: %s, should be ", optname, optval);
print_dataset(cur->dataset);
ok = False;
}
}
return ok;
}
int __init linux_main(int argc, char **argv)
{
unsigned long avail, diff;
unsigned long virtmem_size, max_physmem;
unsigned long stack;
unsigned int i;
int add;
char * mode;
for (i = 1; i < argc; i++) {
if ((i == 1) && (argv[i][0] == ' '))
continue;
add = 1;
uml_checksetup(argv[i], &add);
if (add)
add_arg(argv[i]);
}
if (have_root == 0)
add_arg(DEFAULT_COMMAND_LINE);
host_task_size = os_get_top_address();
/*
* TASK_SIZE needs to be PGDIR_SIZE aligned or else exit_mmap craps
* out
*/
task_size = host_task_size & PGDIR_MASK;
/* OS sanity checks that need to happen before the kernel runs */
os_early_checks();
can_do_skas();
if (proc_mm && ptrace_faultinfo)
mode = "SKAS3";
else
mode = "SKAS0";
printf("UML running in %s mode\n", mode);
brk_start = (unsigned long) sbrk(0);
/*
* Increase physical memory size for exec-shield users
* so they actually get what they asked for. This should
* add zero for non-exec shield users
*/
diff = UML_ROUND_UP(brk_start) - UML_ROUND_UP(&_end);
if (diff > 1024 * 1024) {
printf("Adding %ld bytes to physical memory to account for "
"exec-shield gap\n", diff);
physmem_size += UML_ROUND_UP(brk_start) - UML_ROUND_UP(&_end);
}
uml_physmem = (unsigned long) &__binary_start & PAGE_MASK;
/* Reserve up to 4M after the current brk */
uml_reserved = ROUND_4M(brk_start) + (1 << 22);
setup_machinename(init_utsname()->machine);
highmem = 0;
iomem_size = (iomem_size + PAGE_SIZE - 1) & PAGE_MASK;
max_physmem = TASK_SIZE - uml_physmem - iomem_size - MIN_VMALLOC;
/*
* Zones have to begin on a 1 << MAX_ORDER page boundary,
* so this makes sure that's true for highmem
*/
max_physmem &= ~((1 << (PAGE_SHIFT + MAX_ORDER)) - 1);
if (physmem_size + iomem_size > max_physmem) {
highmem = physmem_size + iomem_size - max_physmem;
physmem_size -= highmem;
#ifndef CONFIG_HIGHMEM
highmem = 0;
printf("CONFIG_HIGHMEM not enabled - physical memory shrunk "
"to %Lu bytes\n", physmem_size);
#endif
}
high_physmem = uml_physmem + physmem_size;
end_iomem = high_physmem + iomem_size;
high_memory = (void *) end_iomem;
start_vm = VMALLOC_START;
setup_physmem(uml_physmem, uml_reserved, physmem_size, highmem);
if (init_maps(physmem_size, iomem_size, highmem)) {
printf("Failed to allocate mem_map for %Lu bytes of physical "
"memory and %Lu bytes of highmem\n", physmem_size,
highmem);
exit(1);
}
virtmem_size = physmem_size;
stack = (unsigned long) argv;
stack &= ~(1024 * 1024 - 1);
avail = stack - start_vm;
if (physmem_size > avail)
virtmem_size = avail;
end_vm = start_vm + virtmem_size;
if (virtmem_size < physmem_size)
printf("Kernel virtual memory size shrunk to %lu bytes\n",
virtmem_size);
atomic_notifier_chain_register(&panic_notifier_list,
&panic_exit_notifier);
uml_postsetup();
stack_protections((unsigned long) &init_thread_info);
os_flush_stdout();
return start_uml();
}
int linux_main(int argc, char **argv)
{
unsigned long avail, diff;
unsigned long virtmem_size, max_physmem;
unsigned int i, add;
for (i = 1; i < argc; i++){
if((i == 1) && (argv[i][0] == ' ')) continue;
add = 1;
uml_checksetup(argv[i], &add);
if(add) add_arg(saved_command_line, argv[i]);
}
if(have_root == 0) add_arg(saved_command_line, DEFAULT_COMMAND_LINE);
mode_tt = force_tt ? 1 : !can_do_skas();
#ifndef CONFIG_MODE_TT
if (mode_tt) {
/*Since CONFIG_MODE_TT is #undef'ed, force_tt cannot be 1. So,
* can_do_skas() returned 0, and the message is correct. */
printf("Support for TT mode is disabled, and no SKAS support is present on the host.\n");
exit(1);
}
#endif
uml_start = CHOOSE_MODE_PROC(set_task_sizes_tt, set_task_sizes_skas, 0,
&host_task_size, &task_size);
/* Need to check this early because mmapping happens before the
* kernel is running.
*/
check_tmpexec();
brk_start = (unsigned long) sbrk(0);
CHOOSE_MODE_PROC(before_mem_tt, before_mem_skas, brk_start);
/* Increase physical memory size for exec-shield users
so they actually get what they asked for. This should
add zero for non-exec shield users */
diff = UML_ROUND_UP(brk_start) - UML_ROUND_UP(&_end);
if(diff > 1024 * 1024){
printf("Adding %ld bytes to physical memory to account for "
"exec-shield gap\n", diff);
physmem_size += UML_ROUND_UP(brk_start) - UML_ROUND_UP(&_end);
}
uml_physmem = uml_start;
/* Reserve up to 4M after the current brk */
uml_reserved = ROUND_4M(brk_start) + (1 << 22);
setup_machinename(system_utsname.machine);
#ifdef CONFIG_MODE_TT
argv1_begin = argv[1];
argv1_end = &argv[1][strlen(argv[1])];
#endif
highmem = 0;
iomem_size = (iomem_size + PAGE_SIZE - 1) & PAGE_MASK;
max_physmem = get_kmem_end() - uml_physmem - iomem_size - MIN_VMALLOC;
/* Zones have to begin on a 1 << MAX_ORDER page boundary,
* so this makes sure that's true for highmem
*/
max_physmem &= ~((1 << (PAGE_SHIFT + MAX_ORDER)) - 1);
if(physmem_size + iomem_size > max_physmem){
highmem = physmem_size + iomem_size - max_physmem;
physmem_size -= highmem;
#ifndef CONFIG_HIGHMEM
highmem = 0;
printf("CONFIG_HIGHMEM not enabled - physical memory shrunk "
"to %ld bytes\n", physmem_size);
#endif
}
high_physmem = uml_physmem + physmem_size;
end_iomem = high_physmem + iomem_size;
high_memory = (void *) end_iomem;
start_vm = VMALLOC_START;
setup_physmem(uml_physmem, uml_reserved, physmem_size, highmem);
if(init_maps(physmem_size, iomem_size, highmem)){
printf("Failed to allocate mem_map for %ld bytes of physical "
"memory and %ld bytes of highmem\n", physmem_size,
highmem);
exit(1);
}
virtmem_size = physmem_size;
avail = get_kmem_end() - start_vm;
if(physmem_size > avail) virtmem_size = avail;
end_vm = start_vm + virtmem_size;
if(virtmem_size < physmem_size)
printf("Kernel virtual memory size shrunk to %ld bytes\n",
virtmem_size);
uml_postsetup();
task_protections((unsigned long) &init_thread_info);
os_flush_stdout();
return(CHOOSE_MODE(start_uml_tt(), start_uml_skas()));
}
int
main(int argc, char **argv)
{
int i;
int n;
int ch;
char *s;
int wp, rp, ep = 0;
char wmbuf[256], rmbuf[256];
FILE *pid_file;
int sock = -1;
int done_fwds = 0;
int runasdaemon = 0;
int sawargstop = 0;
#if defined(__CYGWIN__)
int sawoptionn = 0;
#endif
#ifndef HAVE___PROGNAME
__progname = "autossh";
#endif
/*
* set up options from environment
*/
get_env_args();
/*
* We accept all ssh args, and quietly pass them on
* to ssh when we call it.
*/
while ((ch = getopt(argc, argv, OPTION_STRING)) != -1) {
switch(ch) {
case 'M':
if (!env_port)
writep = optarg;
break;
case 'V':
fprintf(stdout, "%s %s\n", __progname, VER);
exit(0);
break;
case 'f':
runasdaemon = 1;
break;
#if defined(__CYGWIN__)
case 'N':
sawoptionn = 1;
break;
#endif
case '?':
usage(1);
break;
default:
/* other options get passed to ssh */
break;
}
}
/* if we got it from the environment */
if (env_port)
writep = env_port;
/*
* We must at least have a monitor port and a remote host.
*/
if (env_port) {
if (argc < 2)
usage(1);
} else if (!writep || argc < 4)
usage(1);
if (logtype & L_SYSLOG)
openlog(__progname, LOG_PID|syslog_perror, LOG_USER);
/*
* Check for echo port
*/
if ((s = strchr(writep, ':')) != NULL) {
*s = '\0';
echop = s + 1;
ep = strtoul(echop, &s, 0);
if (*echop == '\0' || *s != '\0' || ep == 0)
xerrlog(LOG_ERR, "invalid echo port \"%s\"", echop);
}
/*
* Check, and get the read port (write port + 1);
* then construct port-forwarding arguments for ssh.
*/
wp = strtoul(writep, &s, 0);
if (*writep == '\0' || *s != '\0')
xerrlog(LOG_ERR, "invalid port \"%s\"", writep);
if (wp == 0) {
errlog(LOG_INFO, "port set to 0, monitoring disabled");
writep = NULL;
}
else if (wp > 65534 || wp < 0)
xerrlog(LOG_ERR, "monitor port (%d) out of range", wp);
else {
rp = wp+1;
/* all this for solaris; we could use asprintf() */
(void)snprintf(readp, sizeof(readp), "%d", rp);
/* port-forward arg strings */
n = snprintf(wmbuf, sizeof(wmbuf), "%d:%s:%d", wp, mhost,
echop ? ep : wp);
if (n > sizeof(wmbuf))
xerrlog(LOG_ERR,
"overflow building forwarding string");
if (!echop) {
n = snprintf(rmbuf, sizeof(rmbuf), "%d:%s:%d",
wp, mhost, rp);
if (n > sizeof(rmbuf))
xerrlog(LOG_ERR,
"overflow building forwarding string");
}
}
/*
* Adjust timeouts if necessary: net_timeout is first
* the timeout for accept and then for io, so if the
* poll_time is set less than 2 timeouts, the timeouts need
* to be adjusted to be at least 1/2. Perhaps there should be
* be some padding here as well....
*/
if ((poll_time * 1000) / 2 < net_timeout) {
net_timeout = (poll_time * 1000) / 2;
errlog(LOG_INFO,
"short poll time: adjusting net timeouts to %d",
net_timeout);
}
/*
* Build a new arg list, skipping -f, -M and inserting
* port forwards.
*/
add_arg(ssh_path);
#if defined(__CYGWIN__)
if (ntservice && !sawoptionn)
add_arg("-N");
#endif
for (i = 1; i < argc; i++) {
/*
* We step past the first '--', taking it as ours
* (autossh's). Any further ones we pass to ssh.
*/
if (argv[i][0] == '-' && argv[i][1] == '-') {
if (!sawargstop) {
sawargstop = 1;
continue;
}
}
if (wp && env_port && !done_fwds) {
add_arg("-L");
add_arg(wmbuf);
if (!echop) {
add_arg("-R");
add_arg(rmbuf);
}
done_fwds = 1;
} else if (!sawargstop && argv[i][0] == '-' && argv[i][1] == 'M') {
if (argv[i][2] == '\0')
i++;
if (wp && !done_fwds) {
add_arg("-L");
add_arg(wmbuf);
if (!echop) {
add_arg("-R");
add_arg(rmbuf);
}
done_fwds = 1;
}
continue;
}
/* look for -f in option args and strip out */
strip_arg(argv[i], 'f', OPTION_STRING);
add_arg(argv[i]);
}
if (runasdaemon) {
if (daemon(0, 0) == -1) {
xerrlog(LOG_ERR, "run as daemon failed: %s",
strerror(errno));
}
/*
* If running as daemon, the user likely wants it
* to just run and not fail early (perhaps machines
* are coming up, etc.)
*/
gate_time = 0;
}
/*
* Only if we're doing the network monitor thing.
* Socket once opened stays open for listening for
* the duration of the program.
*/
if (writep) {
if (!echop) {
sock = conn_listen(mhost, readp);
/* set close-on-exec */
(void)fcntl(sock, F_SETFD, FD_CLOEXEC);
} else
sock = NO_RD_SOCK;
}
if (pid_file_name) {
pid_file = fopen(pid_file_name, "w");
if (!pid_file) {
xerrlog(LOG_ERR, "cannot open pid file \"%s\": %s",
pid_file_name, strerror(errno));
}
pid_file_created = 1;
atexit(unlink_pid_file);
if (fprintf(pid_file, "%d\n", (int)getpid()) == 0)
xerrlog(LOG_ERR, "write failed to pid file \"%s\": %s",
pid_file_name, strerror(errno));
fflush(pid_file);
fclose(pid_file);
}
ssh_run(sock, newav);
if (sock >= 0) {
shutdown(sock, SHUT_RDWR);
close(sock);
}
if (logtype & L_SYSLOG)
closelog();
exit(0);
}
int __init linux_main(int argc, char **argv)
{
unsigned long avail, diff;
unsigned long virtmem_size, max_physmem;
unsigned long stack;
unsigned int i;
int add;
for (i = 1; i < argc; i++) {
if ((i == 1) && (argv[i][0] == ' '))
continue;
add = 1;
uml_checksetup(argv[i], &add);
if (add)
add_arg(argv[i]);
}
if (have_root == 0)
add_arg(DEFAULT_COMMAND_LINE);
host_task_size = os_get_top_address();
/*
* TASK_SIZE needs to be PGDIR_SIZE aligned or else exit_mmap craps
* out
*/
task_size = host_task_size & PGDIR_MASK;
/* OS sanity checks that need to happen before the kernel runs */
os_early_checks();
brk_start = (unsigned long) sbrk(0);
/*
* Increase physical memory size for exec-shield users
* so they actually get what they asked for. This should
* add zero for non-exec shield users
*/
diff = UML_ROUND_UP(brk_start) - UML_ROUND_UP(&_end);
if (diff > 1024 * 1024) {
os_info("Adding %ld bytes to physical memory to account for "
"exec-shield gap\n", diff);
physmem_size += UML_ROUND_UP(brk_start) - UML_ROUND_UP(&_end);
}
uml_physmem = (unsigned long) __binary_start & PAGE_MASK;
/* Reserve up to 4M after the current brk */
uml_reserved = ROUND_4M(brk_start) + (1 << 22);
setup_machinename(init_utsname()->machine);
highmem = 0;
iomem_size = (iomem_size + PAGE_SIZE - 1) & PAGE_MASK;
max_physmem = TASK_SIZE - uml_physmem - iomem_size - MIN_VMALLOC;
/*
* Zones have to begin on a 1 << MAX_ORDER page boundary,
* so this makes sure that's true for highmem
*/
max_physmem &= ~((1 << (PAGE_SHIFT + MAX_ORDER)) - 1);
if (physmem_size + iomem_size > max_physmem) {
highmem = physmem_size + iomem_size - max_physmem;
physmem_size -= highmem;
}
high_physmem = uml_physmem + physmem_size;
end_iomem = high_physmem + iomem_size;
high_memory = (void *) end_iomem;
start_vm = VMALLOC_START;
virtmem_size = physmem_size;
stack = (unsigned long) argv;
stack &= ~(1024 * 1024 - 1);
avail = stack - start_vm;
if (physmem_size > avail)
virtmem_size = avail;
end_vm = start_vm + virtmem_size;
if (virtmem_size < physmem_size)
os_info("Kernel virtual memory size shrunk to %lu bytes\n",
virtmem_size);
os_flush_stdout();
return start_uml();
}
